@loom-forge/forge 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/README.md +278 -0
  2. package/dist/index.d.ts +746 -0
  3. package/dist/index.js +1078 -0
  4. package/dist/index.js.map +1 -0
  5. package/package.json +58 -0
package/dist/index.js.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"sources":["../src/mount.ts","../src/commands.ts","../src/facts.ts","../src/ir.ts","../src/compile.ts","../src/state.ts","../src/slots.ts","../src/context.ts","../src/rules.ts","../src/expand.ts"],"names":["provided","EMPTY_COMMANDS","routed","edges","edgesOf","invertEdges","EMPTY","n","commandScope"],"mappings":"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","file":"index.js","sourcesContent":["import { edgesOf, invertEdges } from \"@tslite/graph\";\nimport {\n commandScope,\n EMPTY_COMMANDS,\n type CommandAlias,\n type CommandScope,\n type DefNode,\n} from \"@loom-forge/core\";\nimport type { ComponentIR, NodeIR } from \"./ir\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n MONTAGEM — o que um ponto da árvore ENXERGA, sem rodar.\n\n Dois escopos da definição não são léxicos: o CONTEXTO e o vocabulário de COMANDO. O\n valor vem de onde o nó foi MONTADO, não de onde foi escrito — e um filho de slot é\n escrito num componente e monta dentro de outro. A expansão resolve isso ao vivo, com\n valores; aqui se resolve com NOMES, e a regra tem de ser a dela:\n\n um nó instala para BAIXO, não para si;\n o `provides`/`commands` do componente JUNTA com o da raiz do corpo;\n o corpo do chamado É a subárvore do nó de chamada — o que o nó instala vale lá;\n os filhos de slot montam no `$slot` do chamado, e enxergam o que ELE instala ali.\n\n Tudo aqui é RELATIVO ao ponto onde o componente foi montado, que de dentro dele não se\n vê. O que o documento não resolve ESCAPA para quem o monta — e é isso que as análises\n de contexto e de comando propagam, com o mesmo ponto-fixo.\n ────────────────────────────────────────────────────────────────────────────── */\n\nexport const SLOT_TYPE = \"$slot\";\n\n/** o nome do slot que um `$slot` preenche. Sem nome, é o `children`. */\nexport const slotName = (node: { props?: Record<string, unknown> }): string => {\n const name = (node.props as { name?: unknown } | undefined)?.name;\n return typeof name === \"string\" ? name : \"children\";\n};\n\n/** O que o documento instala num ponto da árvore, acima do que chega de fora. */\nexport interface MountScope {\n /** os contextos providos — só o nome: o tipo é do catálogo, e o valor é de runtime. */\n contexts: ReadonlySet<string>;\n /** o vocabulário de comando, com o mais próximo já vencendo. */\n commands: CommandScope;\n}\n\n/** a raiz de um componente: nada do documento ainda — tudo o que vale ali veio de fora. */\nexport const EMPTY_MOUNT: MountScope = {\n contexts: new Set(),\n commands: EMPTY_COMMANDS,\n};\n\n/** o que um nó declara para a própria subárvore. */\nexport interface Installs {\n provides?: Record<string, unknown>;\n commands?: Record<string, CommandAlias>;\n}\n\n/** o escopo ABAIXO de um nó: o que ele enxerga, com o que ele instala por cima. */\nexport const installed = (scope: MountScope, node: Installs): MountScope => {\n const provided = Object.keys(node.provides ?? {});\n if (provided.length === 0 && node.commands === undefined) return scope;\n return {\n contexts: provided.length\n ? new Set([...scope.contexts, ...provided])\n : scope.contexts,\n commands: commandScope(scope.commands, node),\n };\n};\n\n/** um escopo montado DENTRO de outro: o de dentro é o mais próximo, e ganha. */\nconst nested = (outer: MountScope, inner: MountScope): MountScope => ({\n contexts: new Set([...outer.contexts, ...inner.contexts]),\n commands: { ...outer.commands, ...inner.commands },\n});\n\n/**\n * A forma de montagem de uma árvore, sem saber de que árvore se trata. O IR plano (a análise)\n * e o `DefNode` aninhado (o `check`, o `eject`) montam do mesmo jeito, e a regra fica num lugar.\n */\nexport interface MountShape<N> {\n children(node: N): readonly N[];\n /** o `type` que o nó CHAMA, se ele pode ser uma chamada. Quem decide se é: a montagem. */\n callee(node: N): string | undefined;\n /** o que o nó instala para baixo. */\n installs(node: N): Installs;\n}\n\n/** A montagem de um SISTEMA de definições — o que cada componente instala nos próprios slots. */\nexport interface Mounting {\n /**\n * Os escopos em que os filhos de slot de um componente MONTAM, relativos ao nó de chamada —\n * um por `$slot`. `[]` quando eles não montam em lugar nenhum; `undefined` quando o `type`\n * não é componente deste sistema, e aí não há slot: os filhos são filhos comuns.\n */\n slotScopesOf(component: string): readonly MountScope[] | undefined;\n /**\n * Os nomes que ALGUM vocabulário do sistema declara. Um nome livre que não está aqui só pode\n * chegar à porta; um que está depende de onde o componente montar.\n */\n readonly vocabulary: ReadonlySet<string>;\n}\n\n/**\n * Anda a árvore entregando, para cada nó, os escopos em que ele MONTA — relativos ao ponto\n * onde o componente foi montado.\n *\n * É uma LISTA porque um filho de slot monta em cada `$slot` do chamado: dois `$slot` são duas\n * montagens, e cada uma pode enxergar outra coisa. Lista vazia é o nó que não monta — o\n * chamado não tem `$slot`, e os filhos somem (como no React).\n */\nexport function walkMounted<N>(\n root: N,\n shape: MountShape<N>,\n mounting: Pick<Mounting, \"slotScopesOf\">,\n visit: (node: N, scopes: readonly MountScope[]) => void,\n): void {\n const go = (node: N, scopes: readonly MountScope[]): void => {\n visit(node, scopes);\n const below = scopes.map((s) => installed(s, shape.installs(node)));\n const callee = shape.callee(node);\n const slots =\n callee === undefined ? undefined : mounting.slotScopesOf(callee);\n // numa chamada, os filhos vão para o `$slot` do chamado: o que o nó instala vale lá\n // (o corpo do chamado é a subárvore dele), e o que o chamado instala no slot vem por cima.\n const childScopes =\n slots === undefined\n ? below\n : below.flatMap((b) => slots.map((s) => nested(b, s)));\n for (const child of shape.children(node)) go(child, childScopes);\n };\n go(root, [EMPTY_MOUNT]);\n}\n\n/** A forma de montagem do IR plano. A raiz carrega o açúcar do componente. */\nexport const irShape = (ir: ComponentIR): MountShape<NodeIR> => ({\n children: (node) =>\n node.children\n .map((address) => ir.nodes.get(address))\n .filter((n): n is NodeIR => n !== undefined),\n callee: (node) => (node.kind === \"component\" ? node.type : undefined),\n installs: (node) =>\n node.address === ir.root\n ? {\n ...(ir.provides || node.provides\n ? { provides: { ...ir.provides, ...node.provides } }\n : {}),\n ...(ir.commands || node.commands\n ? { commands: { ...ir.commands, ...node.commands } }\n : {}),\n }\n : node,\n});\n\n/** A forma de montagem do `DefNode` — a raiz já chega com o açúcar do componente aplicado. */\nexport const defShape: MountShape<DefNode> = {\n children: (node) => node.children ?? [],\n callee: (node) => (node.el == null ? node.type : undefined),\n installs: (node) => node,\n};\n\nconst NEVER: readonly MountScope[] = [];\n\n/**\n * A montagem de um conjunto de componentes: onde cada um monta os filhos de slot, e que nomes\n * algum vocabulário declara. `host` é o vocabulário que a aplicação instala na raiz.\n */\nexport function mountingOf(\n components: Iterable<ComponentIR>,\n opts: { host?: CommandScope } = {},\n): Mounting {\n const irs = new Map<string, ComponentIR>();\n for (const c of components) irs.set(c.id, c);\n\n const memo = new Map<string, readonly MountScope[]>();\n const open = new Set<string>();\n\n const mounting: Mounting = {\n slotScopesOf(component) {\n const ir = irs.get(component);\n if (!ir) return undefined;\n const known = memo.get(component);\n if (known) return known;\n // um componente que chega a si mesmo pelo próprio slot é ciclo: a expansão o degrada\n // para `unknown`, e lá nada monta.\n if (open.has(component)) return NEVER;\n open.add(component);\n const found: MountScope[] = [];\n const root = ir.nodes.get(ir.root);\n if (root)\n walkMounted(root, irShape(ir), mounting, (node, scopes) => {\n // só o slot `children` monta: é o único que a expansão preenche\n if (node.type === SLOT_TYPE && slotName(node) === \"children\")\n found.push(...scopes);\n });\n open.delete(component);\n memo.set(component, found);\n return found;\n },\n vocabulary: vocabularyOf(irs.values(), opts.host),\n };\n return mounting;\n}\n\nconst vocabularyOf = (\n irs: Iterable<ComponentIR>,\n host: CommandScope | undefined,\n): Set<string> => {\n const names = new Set(Object.keys(host ?? {}));\n for (const ir of irs) {\n for (const name of Object.keys(ir.commands ?? {})) names.add(name);\n for (const node of ir.nodes.values())\n for (const name of Object.keys(node.commands ?? {})) names.add(name);\n }\n return names;\n};\n\n/** Os escopos de montagem de cada nó de uma árvore `DefNode`, por identidade do nó. */\nexport function mountScopesOf(\n root: DefNode,\n mounting: Pick<Mounting, \"slotScopesOf\">,\n): Map<DefNode, readonly MountScope[]> {\n const out = new Map<DefNode, readonly MountScope[]>();\n walkMounted(root, defShape, mounting, (node, scopes) =>\n out.set(node, scopes),\n );\n return out;\n}\n\n/* ── A obrigação que sobe ──────────────────────────────────────────────────────── */\n\n/** Um ponto de chamada: o chamado, e o que estava resolvido naquele ponto. */\nexport interface ObligationSite {\n callee: string;\n /** o nome que o chamado deve é quitado aqui? */\n discharges(name: string): boolean;\n}\n\n/**\n * O que cada componente deve a quem o monta: o que ele deve por si, mais o que escapou dos\n * chamados sem ser quitado no ponto da chamada.\n *\n * É o formato de um sistema de EFEITOS — o requerido propaga até encontrar quem o quite. A\n * função de transferência é POR PONTO DE CHAMADA (dois pontos do mesmo chamado podem quitar\n * coisas diferentes), então o `join` de um reticulado, que não recebe a aresta, não serve. O\n * grafo TEM ciclo, e o que existe é ponto-fixo: um worklist que só reacorda quem lê um valor\n * que mudou.\n */\nexport function propagateObligations(\n own: ReadonlyMap<string, ReadonlySet<string>>,\n sitesOf: ReadonlyMap<string, readonly ObligationSite[]>,\n): Map<string, Set<string>> {\n const ids = [...own.keys()];\n const outgoing = new Map<string, Set<string>>();\n for (const id of ids) {\n const callees = new Set<string>();\n for (const site of sitesOf.get(id) ?? [])\n if (own.has(site.callee)) callees.add(site.callee);\n outgoing.set(id, callees);\n }\n const incoming = invertEdges(ids, edgesOf(outgoing));\n\n const required = new Map<string, Set<string>>(\n ids.map((id) => [id, new Set(own.get(id))]),\n );\n const queue = [...ids];\n const queued = new Set(queue);\n while (queue.length > 0) {\n const id = queue.shift()!;\n queued.delete(id);\n const next = new Set(own.get(id));\n for (const site of sitesOf.get(id) ?? [])\n for (const name of required.get(site.callee) ?? [])\n if (!site.discharges(name)) next.add(name);\n if (sameSet(next, required.get(id)!)) continue;\n required.set(id, next);\n for (const dependent of incoming.get(id) ?? [])\n if (!queued.has(dependent)) {\n queue.push(dependent);\n queued.add(dependent);\n }\n }\n return required;\n}\n\nconst sameSet = (a: ReadonlySet<string>, b: ReadonlySet<string>): boolean =>\n a.size === b.size && [...a].every((x) => b.has(x));\n","import {\n aliasOf,\n EMPTY_COMMANDS,\n intentsOf,\n type CommandScope,\n} from \"@loom-forge/core\";\nimport type { Address, ComponentIR, IrEdge } from \"./ir\";\nimport {\n EMPTY_MOUNT,\n installed,\n irShape,\n propagateObligations,\n walkMounted,\n type MountScope,\n type Mounting,\n type ObligationSite,\n} from \"./mount\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n COMANDO — o que cada intenção EXECUTA, sem rodar.\n\n A expansão resolve um nome em três degraus: update local → escopo de comando mais\n próximo → porta raiz. Aqui a pergunta é a mesma, e a resposta tem de ser a dela — com\n uma diferença que é a razão deste módulo existir: a definição não sabe onde vai montar.\n\n Um nome se resolve no documento quando um alias em vigor ali o cobre (incluindo o que o\n chamado instala no `$slot`, para os filhos de slot). O que sobra se divide em dois, e a\n divisão é EXATA, não heurística:\n\n o nome não é declarado por vocabulário NENHUM do sistema → só pode chegar à porta: é\n um id, e a aresta é daqui;\n algum vocabulário o declara → o que ele executa depende\n de onde o componente monta.\n Ele ESCAPA, como o `uses` de\n um contexto.\n\n O que escapa sobe pelo mesmo ponto-fixo do contexto (`./mount`), e vira aresta de quem o\n resolve: o componente em cujo ponto de chamada um alias o cobre. Na borda — um `entry`,\n ou quem ninguém compõe —, é o vocabulário do host que responde, e sem ele o nome é o id.\n\n Tudo aqui é FATO. É daqui que sai o eixo `actions` do grafo, e por isso o `computeUnable`\n pergunta à porta por um id que EXISTE, e não por um apelido de sessão.\n ────────────────────────────────────────────────────────────────────────────── */\n\n/** O que uma intenção executa, visto de UM lugar onde ela monta. */\nexport type IntentRoute =\n /** chamada interna: um update do componente que escreveu a intenção. */\n | { kind: \"update\"; action: string; bound?: unknown }\n /** um id que sai para a aplicação. */\n | { kind: \"action\"; action: string; bound?: unknown }\n /** um nome de vocabulário que este lugar não resolve: depende de onde o componente monta. */\n | { kind: \"command\"; name: string };\n\n/** O que a rota precisa saber do componente e do sistema. */\nexport interface RouteContext {\n /** os updates do componente que ESCREVEU a intenção. */\n updates: ReadonlySet<string>;\n /** os nomes que algum vocabulário do sistema declara — ver `Mounting.vocabulary`. */\n vocabulary: ReadonlySet<string>;\n}\n\n/**\n * A rota de UMA intenção num lugar de montagem — os três degraus da expansão, sobre nomes.\n *\n * `bound` são os params que um alias já liga (a aplicação parcial): o disparo os recebe por baixo\n * dos seus, e quem prova ou traduz a chamada precisa deles.\n */\nexport function routeIntent(\n action: string,\n scope: MountScope,\n ctx: RouteContext,\n): IntentRoute {\n // update local primeiro: um nome que resolve nele não sai do componente (ADR-014)\n if (ctx.updates.has(action)) return { kind: \"update\", action };\n const alias = scope.commands[action];\n if (alias !== undefined) {\n const { action: target, params } = aliasOf(alias);\n const bound = params === undefined ? {} : { bound: params };\n // o alias pode apontar para um update do mesmo componente: o boundary despacha pelo id\n // resolvido, e o encontra\n return ctx.updates.has(target)\n ? { kind: \"update\", action: target, ...bound }\n : { kind: \"action\", action: target, ...bound };\n }\n return ctx.vocabulary.has(action)\n ? { kind: \"command\", name: action }\n : { kind: \"action\", action };\n}\n\n/**\n * A rota de uma intenção quando TODO lugar onde ela monta concorda.\n *\n * `undefined` quando ela não monta em lugar nenhum, ou quando dois lugares a resolvem de jeitos\n * diferentes — aí não há UMA ação contra a qual provar ou para a qual traduzir.\n */\nexport function settledRoute(\n action: string,\n scopes: readonly MountScope[],\n ctx: RouteContext,\n): IntentRoute | undefined {\n let settled: IntentRoute | undefined;\n for (const scope of scopes) {\n const route = routeIntent(action, scope, ctx);\n if (settled === undefined) settled = route;\n else if (!sameRoute(settled, route)) return undefined;\n }\n return settled;\n}\n\nconst sameRoute = (a: IntentRoute, b: IntentRoute): boolean => {\n if (a.kind === \"command\") return b.kind === \"command\" && a.name === b.name;\n return (\n b.kind !== \"command\" &&\n a.kind === b.kind &&\n a.action === b.action &&\n a.bound === b.bound\n );\n};\n\nexport interface CommandFacts {\n /** por nó: o que cada intenção dele executa, em cada lugar onde ele monta. */\n intentsAt: ReadonlyMap<Address, readonly IrEdge[]>;\n /** por componente: os ids de ação que ele roteia para a aplicação. */\n actions: ReadonlyMap<string, ReadonlySet<string>>;\n /** por componente: os nomes de comando que escapam dele — quem resolve é quem o monta. */\n free: ReadonlyMap<string, readonly string[]>;\n}\n\n/** um ponto de chamada, com o vocabulário em vigor ali. */\ninterface CallSite extends ObligationSite {\n commands: CommandScope;\n}\n\n/**\n * Deriva o roteamento de todas as intenções de um conjunto de componentes.\n *\n * `host` é o vocabulário que a aplicação instala na raiz — o `commands` do `ForgeView`.\n */\nexport function deriveCommands(\n components: Iterable<ComponentIR>,\n mounting: Mounting,\n host: CommandScope = EMPTY_COMMANDS,\n): CommandFacts {\n const irs = new Map<string, ComponentIR>();\n for (const c of components) irs.set(c.id, c);\n\n const intentsAt = new Map<Address, IrEdge[]>();\n const actions = new Map<string, Set<string>>();\n const own = new Map<string, Set<string>>();\n const sitesOf = new Map<string, CallSite[]>();\n\n for (const ir of irs.values()) {\n const ctx: RouteContext = {\n updates: new Set(Object.keys(ir.updates ?? {})),\n vocabulary: mounting.vocabulary,\n };\n const routed = new Set<string>();\n const free = new Set<string>();\n actions.set(ir.id, routed);\n own.set(ir.id, free);\n\n /** uma intenção ESCRITA neste componente, vista de um lugar onde ela monta — como aresta. */\n const route = (action: string, scope: MountScope): IrEdge => {\n const found = routeIntent(action, scope, ctx);\n switch (found.kind) {\n case \"update\":\n return { to: found.action, rel: \"update\" };\n case \"action\":\n routed.add(found.action);\n return { to: found.action, rel: \"action\" };\n case \"command\":\n free.add(found.name);\n return { to: found.name, rel: \"command\" };\n }\n };\n\n // o EFEITO é intenção do componente, não de um nó: ele enxerga só o lugar onde o\n // componente montou — o `commands` do componente instala para o corpo, não para si.\n for (const effect of Object.values(ir.effects ?? {})) {\n for (const link of intentsOf(effect)) route(link.action, EMPTY_MOUNT);\n if (effect.cleanup)\n for (const link of intentsOf(effect.cleanup))\n route(link.action, EMPTY_MOUNT);\n }\n\n const sites: CallSite[] = [];\n const shape = irShape(ir);\n const root = ir.nodes.get(ir.root);\n if (root)\n walkMounted(root, shape, mounting, (node, scopes) => {\n // um nó que não monta não dispara nada: não há o que rotear\n const edges = new Map<string, IrEdge>();\n // cada elo da cadeia de uma intenção (`then`/`catch`) executa algo, e roteia igual\n for (const binding of Object.values(node.events ?? {}))\n for (const link of intentsOf(binding))\n for (const scope of scopes) {\n const edge = route(link.action, scope);\n edges.set(`${edge.rel} ${edge.to}`, edge);\n }\n if (edges.size) intentsAt.set(node.address, [...edges.values()]);\n\n if (node.kind === \"component\")\n for (const scope of scopes) {\n // o corpo do chamado É a subárvore deste nó: o que ele instala vale lá\n const commands = installed(scope, shape.installs(node)).commands;\n sites.push({\n callee: node.type,\n commands,\n discharges: (name) => commands[name] !== undefined,\n });\n }\n });\n sitesOf.set(ir.id, sites);\n }\n\n const required = propagateObligations(own, sitesOf);\n\n // o que um chamado deve e o ponto de chamada resolve vira aresta de QUEM resolveu\n const called = new Set<string>();\n for (const [id, sites] of sitesOf)\n for (const site of sites) {\n called.add(site.callee);\n for (const name of required.get(site.callee) ?? []) {\n const alias = site.commands[name];\n if (alias !== undefined) actions.get(id)!.add(aliasOf(alias).action);\n }\n }\n\n // a BORDA: o que chega a um componente que o host monta é resolvido pelo vocabulário do\n // host — e, sem ele, o nome é o id que vai para a porta.\n for (const ir of irs.values()) {\n if (!ir.entry && called.has(ir.id)) continue;\n for (const name of required.get(ir.id) ?? []) {\n const alias = host[name];\n actions\n .get(ir.id)!\n .add(alias === undefined ? name : aliasOf(alias).action);\n }\n }\n\n return {\n intentsAt,\n actions,\n free: new Map([...required].map(([id, s]) => [id, [...s].sort()])),\n };\n}\n","import {\n propagateUnion,\n invertEdges,\n detectCycles,\n edgesOf,\n type CycleInfo,\n} from \"@tslite/graph\";\nimport type {\n CommandScope,\n Descriptor,\n DescriptorRegistry,\n} from \"@loom-forge/core\";\nimport type { Address, ComponentIR, DepAxis, IrEdge, NodeIR } from \"./ir\";\nimport { deriveCommands } from \"./commands\";\nimport { mountingOf } from \"./mount\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n FATOS — o que se DERIVA sobre a árvore, ao lado dela.\n\n A árvore normalizada (`ComponentIR`/`NodeIR`) tem o que o autor escreveu, normalizado.\n Nada derivado mora lá — não por disciplina, por AUSÊNCIA DE LUGAR. É o corte do TSC: o\n `SourceFile` é a árvore, e o que o binder deriva mora em tabela lateral.\n\n ── A LINHA, para não haver dúvida na próxima vez ───────────────────────────────\n NORMALIZAÇÃO fica na árvore: o `el` consumido (a tag vira `type`), o `kind`, o caminho\n virando `Address`, os filhos virando lista de endereços. É a mesma informação do autor,\n em outra forma.\n DERIVAÇÃO fica aqui: arestas, deps por eixo, tags próprias e efetivas, ciclos, o grafo\n invertido. É informação NOVA, calculada a partir daquela.\n\n E tudo aqui é derivável da árvore — de propósito. Se um fato não pudesse ser recalculado\n do `ComponentIR`, seria sinal de que a árvore está PERDENDO algo que o autor escreveu.\n\n ── FATO ≠ JULGAMENTO ───────────────────────────────────────────────────────────\n \"Existe ciclo\" é fato; \"ciclo é erro\" é julgamento, e mora no `rules.ts`. A propagação\n transitiva também é fato: `tags` efetivas é VALOR derivado, não veredito — a diferença\n para `deps` é só o ALCANCE da derivação (um salto × ponto-fixo), não a natureza.\n ────────────────────────────────────────────────────────────────────────────── */\n\n/** O que se deriva de UM componente. */\nexport interface ComponentFacts {\n /** tags próprias — as que o autor declarou, e as que a forma implica. */\n ownTags: { declared: readonly string[]; inferred: readonly string[] };\n /** arestas de saída por eixo. `contains` fica FORA do `outgoing` (containment ≠ dep). */\n deps: Readonly<Record<DepAxis, readonly string[]>>;\n}\n\n/** O que se deriva de UM nó. */\nexport interface NodeFacts {\n /** de-para que este nó cria. */\n edges: readonly IrEdge[];\n /** comportamento inferido a nível de nó (ex.: `interactive` = tem evento). */\n tags?: readonly string[];\n}\n\n/** Referência a um alvo que não existe em registry nenhum. */\nexport interface DependencyError {\n componentId: string;\n code: \"UNRESOLVED_TARGET\";\n target: string;\n axis: DepAxis;\n message: string;\n}\n\nexport interface Facts {\n /** local, por componente. */\n components: ReadonlyMap<string, ComponentFacts>;\n /** local, por nó. */\n nodes: ReadonlyMap<Address, NodeFacts>;\n /** `uses ∪ usesRegistered ∪ actions ∪ dataRefs` — o grafo que propaga. */\n outgoing: ReadonlyMap<string, ReadonlySet<string>>;\n /** alvos ausentes. Fato (\"não existe\"), não veredito (\"é proibido\"). */\n errors: readonly DependencyError[];\n /** transitivo: dependentes (\"quem usa isto\") — por onde o dirty sobe. */\n incoming?: ReadonlyMap<string, readonly string[]>;\n /** transitivo: tags efetivas, canônicas (ordenadas, sem repetição). */\n tags?: ReadonlyMap<string, readonly string[]>;\n /** transitivo: componentes fortemente conexos. */\n cycles?: CycleInfo;\n}\n\n/** Os fatos de um componente, ou `undefined` se ele não está no conjunto. */\nexport const factsOf = (\n facts: Facts,\n componentId: string,\n): ComponentFacts | undefined => facts.components.get(componentId);\n\n/** Os fatos de um nó, pelo endereço. */\nexport const nodeFactsOf = (\n facts: Facts,\n address: Address,\n): NodeFacts | undefined => facts.nodes.get(address);\n\n/** As tags EFETIVAS (próprias + herdadas) de um nó de grafo. Vazio sem o overlay. */\nexport const effectiveTags = (facts: Facts, id: string): readonly string[] =>\n facts.tags?.get(id) ?? EMPTY;\n\nconst EMPTY: readonly string[] = [];\n\nconst readBehavior = (d: Descriptor | undefined): string[] | undefined => {\n const b = d?.meta?.behavior;\n return Array.isArray(b) ? (b as string[]) : undefined;\n};\n\nexport interface DeriveFactsOptions {\n /** registry de descriptors — own-tags de React registrado (`meta.behavior`) + detecção de ausente. */\n registry?: DescriptorRegistry;\n /** tags de uma action externa (via `transparentActionProvider`). Futuro. */\n actionTags?: (id: string) => readonly string[];\n /** ids de actions conhecidas — habilita a detecção de ausente no eixo `actions`. */\n knownActions?: ReadonlySet<string>;\n /**\n * O vocabulário de comando que o HOST instala na raiz (o `commands` do `ForgeView`). É a\n * borda: um nome de comando que chega a um componente que o host monta é resolvido aqui, e,\n * sem ele, vale como o id que vai para a porta.\n */\n commands?: CommandScope;\n /**\n * As camadas TRANSITIVAS. Custo zero quando ausentes: quem só quer as arestas locais não\n * paga o ponto-fixo. Default: todas ligadas (é o que o `buildSystemIR` sempre fez).\n */\n overlays?: { tags?: boolean; incoming?: boolean; cycles?: boolean };\n}\n\n/**\n * As arestas ESTRUTURAIS de um nó: o que ele compõe.\n *\n * As de intenção não saem daqui, porque não dependem só do nó: o que um `events.action`\n * executa depende dos updates do componente e do vocabulário de comando em vigor onde o nó\n * monta. Quem responde é o `./commands` — update local é chamada **interna** (ADR-014), alias é\n * o id que ele cobre, e nome livre de vocabulário é `command`.\n */\nconst structuralEdgesOf = (node: NodeIR): IrEdge[] =>\n // `el` já foi normalizado para `kind: \"element\"`, e elemento nunca cria aresta — mesmo que\n // a tag colida com um componente conhecido (é intrínseco explícito).\n node.kind === \"component\" || node.kind === \"registered\"\n ? [{ to: node.type, rel: \"uses\" }]\n : [];\n\nconst mkError = (\n componentId: string,\n target: string,\n axis: DepAxis,\n message: string,\n): DependencyError => ({\n componentId,\n code: \"UNRESOLVED_TARGET\",\n target,\n axis,\n message,\n});\n\n/**\n * Deriva os fatos de um conjunto de componentes compilados.\n *\n * Tudo sai da árvore normalizada — nenhum dado a mais entra. As camadas locais (arestas, deps,\n * own-tags) são um salto; as transitivas (tags efetivas, invertido, ciclos) são ponto-fixo sobre\n * o grafo, que TEM ciclo (um componente compõe outro que o compõe de volta) — daí o\n * `@tslite/graph`, e não uma ordem topológica.\n */\nexport function deriveFacts(\n components: Iterable<ComponentIR>,\n opts: DeriveFactsOptions = {},\n): Facts {\n const irs = new Map<string, ComponentIR>();\n for (const c of components) irs.set(c.id, c);\n\n const componentFacts = new Map<string, ComponentFacts>();\n const nodeFacts = new Map<Address, NodeFacts>();\n const outgoing = new Map<string, Set<string>>();\n const nodeIds = new Set<string>(irs.keys());\n const errors: DependencyError[] = [];\n\n // o que cada intenção EXECUTA — evento e efeito, update local, alias e nome livre. É daqui\n // que sai o eixo `actions`: só o que sai para a aplicação, com o id que de fato existe.\n const routing = deriveCommands(\n irs.values(),\n mountingOf(irs.values(), { host: opts.commands }),\n opts.commands,\n );\n\n for (const ir of irs.values()) {\n const deps: Record<DepAxis, Set<string>> = {\n uses: new Set(),\n usesRegistered: new Set(),\n actions: new Set(routing.actions.get(ir.id)),\n dataRefs: new Set(),\n contains: new Set(),\n };\n\n for (const node of ir.nodes.values()) {\n const edges = [\n ...structuralEdgesOf(node),\n ...(routing.intentsAt.get(node.address) ?? []),\n ];\n const tags =\n node.events && Object.keys(node.events).length\n ? [\"interactive\"]\n : undefined;\n nodeFacts.set(node.address, { edges, ...(tags ? { tags } : {}) });\n\n if (node.kind === \"component\") deps.uses.add(node.type);\n else if (node.kind === \"registered\") deps.usesRegistered.add(node.type);\n }\n\n const inferred: string[] = [];\n if (Object.keys(ir.state).length) inferred.push(\"stateful\");\n if (Object.keys(ir.effects ?? {}).length) inferred.push(\"effectful\");\n\n componentFacts.set(ir.id, {\n ownTags: { declared: ir.tags ?? EMPTY, inferred },\n deps: {\n uses: [...deps.uses],\n usesRegistered: [...deps.usesRegistered],\n actions: [...deps.actions],\n dataRefs: [...deps.dataRefs],\n contains: [...deps.contains],\n },\n });\n\n // o `outgoing` unifica os eixos que PROPAGAM; `contains` fica de fora (§6 do IR.md).\n const out = new Set<string>();\n const add = (\n targets: Iterable<string>,\n axis: DepAxis,\n known: ((t: string) => boolean) | undefined,\n message: (t: string) => string,\n ): void => {\n for (const t of targets) {\n out.add(t);\n nodeIds.add(t);\n if (known && !known(t))\n errors.push(mkError(ir.id, t, axis, message(t)));\n }\n };\n add(\n deps.uses,\n \"uses\",\n (t) => irs.has(t),\n (t) => `component \"${ir.id}\" uses unregistered component \"${t}\"`,\n );\n add(\n deps.usesRegistered,\n \"usesRegistered\",\n opts.registry ? (t) => opts.registry!.has(t) : undefined,\n (t) => `component \"${ir.id}\" uses unregistered element \"${t}\"`,\n );\n add(\n deps.actions,\n \"actions\",\n opts.knownActions ? (t) => opts.knownActions!.has(t) : undefined,\n (t) => `component \"${ir.id}\" invokes unknown action \"${t}\"`,\n );\n add(deps.dataRefs, \"dataRefs\", undefined, () => \"\");\n outgoing.set(ir.id, out);\n }\n\n const facts: Facts = {\n components: componentFacts,\n nodes: nodeFacts,\n outgoing,\n errors,\n };\n const on = opts.overlays ?? { tags: true, incoming: true, cycles: true };\n if (!on.tags && !on.incoming && !on.cycles) return facts;\n\n const edges = edgesOf(outgoing);\n /** as tags PRÓPRIAS de um nó de grafo — heterogêneo: custom tem IR, registrado tem\n * `meta.behavior` (folha), action vem do `actionTags`. */\n const ownOf = (id: string): readonly string[] => {\n const own = componentFacts.get(id);\n if (own) return [...own.ownTags.declared, ...own.ownTags.inferred];\n const behavior = readBehavior(opts.registry?.get(id));\n if (behavior) return behavior;\n if (opts.actionTags) return opts.actionTags(id);\n return EMPTY;\n };\n\n return {\n ...facts,\n ...(on.tags ? { tags: propagateUnion(nodeIds, edges, ownOf) } : {}),\n ...(on.incoming ? { incoming: invertEdges(nodeIds, edges) } : {}),\n ...(on.cycles ? { cycles: detectCycles(nodeIds, edges) } : {}),\n };\n}\n","/* ──────────────────────────────────────────────────────────────────────────────\n COMPONENT IR — modelo normalizado de ANÁLISE/resolução, data-independente, por\n DEFINIÇÃO de componente. NÃO é alvo de codegen (React é o runtime); é um IR de\n análise. Headless: zero React, zero TSLite (a resolução de tipos → Schema é do\n `./check`). Spec: docs/components/IR.md.\n\n 3 tiers (2 relógios): ComponentDef/DefNode (SoT, autor, relógio LENTO) →\n ComponentIR (derivado, plano, id-keyed) → ResolvedNode (efêmero, por render, RÁPIDO).\n\n Fase 1 (aqui): normaliza a árvore (aninhado→plano, endereçável), extrai arestas de\n dependência (componente compõe componente = aresta, igual action invoca action),\n propaga tags de comportamento pelo grafo, detecta ciclos e dependências faltando.\n Fase 2 (overlay/regras — futuro): entry/unable/categoria sobre o IR, sem mutá-lo.\n ────────────────────────────────────────────────────────────────────────────── */\n\nimport type {\n DefNode,\n DescriptorRegistry,\n EventBinding,\n CommandAlias,\n} from \"@loom-forge/core\";\nimport { deriveFacts, type DeriveFactsOptions, type Facts } from \"./facts\";\n\n/* ── Endereço estrutural (`componentId#indexPath`) — chave do overlay, estável a\n reformatação (≈ JSON-Pointer / caminho de AST). Decisão #3: árvore no IR é PLANA. ── */\n\nexport type Address = string;\n\nexport const componentAddress = (component: string): Address => component;\n\n/** `comp#0` = raiz do corpo; `comp#0.1.2` = caminho de índices de filho a partir da raiz. */\nexport const nodeAddress = (\n component: string,\n indexPath: readonly number[],\n): Address => `${component}#${indexPath.join(\".\")}`;\n\nexport const parseAddress = (\n addr: Address,\n): { component: string; path: number[] | null } => {\n const i = addr.indexOf(\"#\");\n if (i < 0) return { component: addr, path: null };\n const p = addr.slice(i + 1);\n return {\n component: addr.slice(0, i),\n path: p === \"\" ? [] : p.split(\".\").map(Number),\n };\n};\n\n/* ── TIER 1: SOURCE (SoT) — a declaração de um componente custom (a unidade do grafo) ── */\n\n/** Tipo declarado de uma prop/state/context. DADO (shorthand | Schema do TSLite | JSON Schema).\n * A resolução p/ Schema do TSLite é do `./check` — o core IR não importa TSLite. */\nexport type TypeRef = string | Record<string, unknown>;\nexport type PropsDecl = Record<string, TypeRef>;\nexport interface StateDecl {\n type: TypeRef;\n /**\n * O que SEMEIA esta chave — expressão sobre `props` e `ctx`, avaliada **uma vez, no mount**.\n *\n * É a semântica do `useState(props.x)` do React: lê na montagem e o setter assume dali em\n * diante. O escopo NÃO tem `state` (é o que está sendo definido) nem `params` (não há\n * chamada), e o valor é provado contra o `type` declarado ao lado.\n *\n * Constante continua constante: `0` atravessa o bind intacto.\n */\n init: unknown;\n}\n\n/** Uma ação de UPDATE local (a DSL de estado, v1): seta campos do estado a valores/expressões\n * (`{{ }}` avaliado contra as raízes `props`/`state`/`params`). Vocabulário no espírito das\n * directives do statedelta; v1 só `set`. Port-ready: trocar o interpretador é reimplementar\n * `applyUpdate`. */\n/**\n * Um EFEITO — a intenção que um componente dispara por conta própria.\n *\n * **É um events-out cujo gatilho é uma mudança de dependência, em vez de um gesto.** Mesma\n * `action` (local primeiro, senão o `ActionPort` do host), mesmo `params`, mesma aresta no\n * grafo, mesma tipagem. O que muda é quem puxa o gatilho.\n *\n * É o que torna o componente impuro de verdade: quem declara efeito é VIVO, e a tag\n * `effectful` propaga pelo grafo como qualquer outra.\n */\nexport interface EffectDecl {\n /**\n * Os CAMINHOS que disparam — `\"props.id\"`, `\"state.aberto\"`, `\"ctx.tema\"`.\n *\n * `[]` = só no mount: é a convenção do React, e sem string mágica — sem dependência, não há\n * o que reexecutar. Caminho pontilhado; nome com ponto dentro não é suportado.\n */\n on: string[];\n /** a intenção: ação LOCAL primeiro, senão o `ActionPort` do host. */\n action: string;\n /** os params da intenção — `event` é `undefined` aqui: um efeito não recebe nada (ADR-018). */\n params?: unknown;\n /**\n * A cadeia, como num evento (ADR-018): o `then` roda quando a intenção resolve, com `event` =\n * o `data` da ação (ou `undefined` depois de um update local); o `catch`, quando o despacho ao\n * host falha, com `event` = o erro. É por aqui que \"carregar no mount\" GUARDA o que carregou.\n */\n then?: EventBinding;\n catch?: EventBinding;\n /** no unmount, e ANTES de reexecutar. Mesma forma de um `EventBinding`, cadeia inclusa. */\n cleanup?: EventBinding;\n}\n\nexport interface UpdateDecl {\n /** os ARGUMENTOS que este update aceita — os mesmos tipos de uma `PropsDecl`.\n *\n * Sem eles, `params` é dado de fora **não declarado**: vale `unknown`, e escrevê-lo direto\n * num estado tipado não passa. Não é aspereza — é a mesma fronteira das props: dado que\n * entra sem contrato precisa ser declarado ou provado. Declará-los também tipa o call-site\n * do evento que o dispara. */\n params?: PropsDecl;\n set?: Record<string, unknown>;\n}\n\n/** Contrato de um SLOT de composição (children tipado). Um pai declara o que aceita como\n * filho — sem conhecer o filho concreto (composição ≠ dependência; o filho é opaco, só o\n * CONTRATO é conhecido). Checado no SITE de composição. NOVO vs React (lá todo filho é leaf\n * opaco). Eixos ESTRUTURAIS (puros). O eixo de PROPS (`Component<C>` por subtype) é do\n * `./check` e vem com a integração do tipo — ver decisão deferida. */\nexport interface SlotContract {\n /** o filho deve ter categoria ∈ (declarada do filho). string ou lista. */\n category?: string | string[];\n /** o filho deve ter (pelo menos) estas tags de comportamento EFETIVAS (propagadas). */\n tags?: string[];\n /** o filho não pode ter filhos próprios no site de composição (deve ser folha). */\n leaf?: boolean;\n /** no máximo 1 filho neste slot (não lista). */\n single?: boolean;\n /** cardinalidade. */\n min?: number;\n max?: number;\n}\n\n/** Um componente custom declarado em JSON. Isomorfo a uma Action: `id + árvore` (fn JS). */\nexport interface ComponentDef {\n /** nome = id do nó de grafo (estável). */\n component: string;\n /** público/rota vs privado (sessão interna). Default: false. */\n entry?: boolean;\n /** categoria arquitetural (ui/data/feature…) — eixo das regras de direção (fase 2). */\n category?: string;\n /** tipos das props que aceita. */\n props?: PropsDecl;\n /** os contextos que este componente CONSOME — nomes do catálogo do sistema. É a declaração\n * que põe `ctx` no escopo dele: nada entra implicitamente. */\n context?: { uses: string[] };\n /** os contextos que este componente PROVÊ para o próprio corpo — `nome → expressão`.\n * Açúcar para um `provides` na raiz da árvore: é um mecanismo só, em dois lugares. */\n provides?: Record<string, unknown>;\n /** o vocabulário de COMANDOS que este componente instala para o próprio corpo. Mesmo açúcar do\n * `provides`, no eixo do comportamento: uma sessão declara os comandos dela aqui. */\n commands?: Record<string, CommandAlias>;\n /** estado local declarado, escopado ao componente (NUNCA global). */\n state?: Record<string, StateDecl>;\n /** os UPDATES locais (a lógica \"suja\"): mutam o estado local da instância. Presença de `updates`\n * torna o componente VIVO → boundary React por instância; `events.action` resolve LOCAL\n * primeiro. NÃO é uma action no sentido do node-actions: não tem id no runtime, não entra em\n * palette e não tem disponibilidade. Ver ADR-014. */\n updates?: Record<string, UpdateDecl>;\n /** EFEITOS: intenções disparadas por MUDANÇA, não por gesto. Presença também torna o\n * componente VIVO — é literalmente o que o torna impuro. */\n effects?: Record<string, EffectDecl>;\n /** contratos dos slots de composição (children tipado). Chave = nome do slot (\"children\"). */\n slots?: Record<string, SlotContract>;\n /** tags de comportamento DECLARADAS (own.declared). */\n tags?: string[];\n /** gate de capability: `cap → versão | \"*\"`. */\n requires?: Record<string, string>;\n /** o corpo. */\n body: DefNode;\n version?: string;\n}\n\n/** Registry de DEFINIÇÕES de componente custom (SoT). Headless — só ComponentDefs, sem React.\n * É o `type → árvore` que a expansão consome no render, e o `names()` alimenta o\n * `CompileCtx.components` da análise. Encadeável. */\nexport interface ComponentDefRegistry {\n register(def: ComponentDef): ComponentDefRegistry;\n get(name: string): ComponentDef | undefined;\n has(name: string): boolean;\n list(): ComponentDef[];\n /** os nomes registrados — uso direto como `CompileCtx.components`. */\n names(): Set<string>;\n}\n\nexport function createComponentDefRegistry(\n initial?: ComponentDef[],\n): ComponentDefRegistry {\n const map = new Map<string, ComponentDef>();\n const registry: ComponentDefRegistry = {\n register(def) {\n if (!def.component)\n throw new Error(\n \"componentDefRegistry.register: `component` é obrigatório.\",\n );\n map.set(def.component, def);\n return registry;\n },\n get: (name) => map.get(name),\n has: (name) => map.has(name),\n list: () => [...map.values()],\n names: () => new Set(map.keys()),\n };\n for (const d of initial ?? []) registry.register(d);\n return registry;\n}\n\n/* ── TIER 2: COMPONENT IR (derivado, data-independente) ── */\n\nexport type NodeKind = \"component\" | \"registered\" | \"element\";\n\n/** Eixos de dependência, separados (§6/decisão #1). `outgoing` = todos MENOS `contains`. */\nexport type DepAxis =\n | \"uses\" // componentes custom compostos (recursa; propaga tag)\n | \"usesRegistered\" // React registrados (leaf; propaga tag via descriptor.meta.behavior)\n | \"actions\" // actions invocadas (cross-space; tags via transparentActionProvider — futuro)\n | \"dataRefs\" // refs de binding a outros ids (futuro — precisa de freeVars do TSLite)\n | \"contains\"; // containment — RESERVADO; nunca é dep (fora do outgoing). Ver NodeIR.children.\n\nexport interface IrEdge {\n to: string;\n /**\n * `action` é um id que sai para a aplicação; `update`, uma chamada interna; `command`, um nome\n * de vocabulário que este documento NÃO resolve — o que ele executa depende de onde o\n * componente montar, e quem responde é o componente que o monta.\n */\n rel: \"uses\" | \"action\" | \"update\" | \"command\" | \"dataref\";\n}\n\n/** O nó normalizado (a \"diretiva\" endereçável). Molde do GuideNode do overlay. */\nexport interface NodeIR {\n address: Address;\n /** id autorado (estável). */\n id: string;\n type: string;\n kind: NodeKind;\n /** props com ilhas {{}}/#expr INLINE, não avaliadas (decisão #6). */\n props?: Record<string, unknown>;\n events?: Record<string, EventBinding>;\n layout?: string;\n /** opaco pro core (lido pelo planner no resolve). */\n placement?: unknown;\n /** filhos por ENDEREÇO (flat, não aninhado). */\n children: Address[];\n /** each/when (expr inline); a EXPANSÃO acontece no resolve (decisão #6). */\n template?: { data?: unknown; when?: unknown };\n /** contextos que ESTE nó instala para a subárvore (expr inline, como as props). */\n provides?: Record<string, unknown>;\n /** o vocabulário de comando que ESTE nó instala para a subárvore. */\n commands?: Record<string, CommandAlias>;\n fallback?: \"drop\";\n requires?: Record<string, string>;\n}\n\n/** Nível componente — o nó do grafo. */\nexport interface ComponentIR {\n id: string;\n entry: boolean;\n /** categoria arquitetural — eixo das regras de direção (fase 2). */\n category?: string;\n /** superfície de tipo — formas DECLARADAS (dado). Resolução p/ Schema é do `./check`. */\n props?: PropsDecl;\n context: { uses: string[] };\n /** o que o componente provê ao próprio corpo (`ComponentDef.provides`, inline). */\n provides?: Record<string, unknown>;\n /** o vocabulário de comando que o componente instala no próprio corpo (inline). */\n commands?: Record<string, CommandAlias>;\n /** os efeitos declarados (inline) — a fonte das arestas de ação de nível componente. */\n effects?: Record<string, EffectDecl>;\n /** os updates locais declarados (inline). Autorados, como `state` e `effects`. */\n updates?: Record<string, UpdateDecl>;\n state: Record<string, StateDecl>;\n /** contratos dos slots de composição (children tipado). */\n slots?: Record<string, SlotContract>;\n /** tags de comportamento DECLARADAS pelo autor, como ele as escreveu. As PRÓPRIAS\n * (declaradas + inferidas) e as EFETIVAS (propagadas) são fato, e moram em `./facts`. */\n tags?: string[];\n requires: Record<string, string>;\n root: Address;\n nodes: Map<Address, NodeIR>;\n version?: string;\n}\n\n/* ── Nível SISTEMA — o registry inteiro (cross-componente). Aqui rodam os algoritmos. ── */\n\nexport interface SystemIR {\n /** as ÁRVORES normalizadas — só o que o autor escreveu. */\n components: Map<string, ComponentIR>;\n /** o que se DERIVOU sobre elas: arestas, deps, tags, ciclos, alvos ausentes. Dois artefatos\n * que viajam juntos, não um — ver o cabeçalho de `./facts`. */\n facts: Facts;\n}\n\n/* ── Compilador da FASE 1 ───────────────────────────────────────────────────────── */\n\nconst readKey = (node: DefNode, key: string): unknown =>\n (node as unknown as Record<string, unknown>)[key];\n\nconst templateOf = (\n node: DefNode,\n): { data?: unknown; when?: unknown } | undefined => {\n const data = readKey(node, \"each\");\n const when = readKey(node, \"when\");\n if (data === undefined && when === undefined) return undefined;\n const t: { data?: unknown; when?: unknown } = {};\n if (data !== undefined) t.data = data;\n if (when !== undefined) t.when = when;\n return t;\n};\n\nexport interface CompileCtx {\n /** ids de componentes custom conhecidos — classifica `type` como \"component\". */\n components: ReadonlySet<string>;\n /** registry de descriptors — `type` registrado → \"registered\" (senão \"element\"). */\n registry?: DescriptorRegistry;\n}\n\n/**\n * Compila UMA definição → `ComponentIR`: a árvore **normalizada** — aninhado vira plano e\n * endereçável, o `el` é consumido (a tag vira `type`), cada nó é classificado. PURO e\n * data-independente.\n *\n * **Nada derivado sai daqui.** Arestas, deps e tags são FATO, e moram em `./facts` — a árvore\n * tem o que o autor escreveu, em outra forma. Ver a linha no cabeçalho de `facts.ts`.\n */\nexport function compileComponent(\n def: ComponentDef,\n ctx: CompileCtx,\n): ComponentIR {\n const nodes = new Map<Address, NodeIR>();\n\n const classify = (type: string): NodeKind =>\n ctx.components.has(type)\n ? \"component\"\n : ctx.registry?.has(type)\n ? \"registered\"\n : \"element\";\n\n const flatten = (node: DefNode, indexPath: number[]): Address => {\n const address = nodeAddress(def.component, indexPath);\n // `el` = elemento intrínseco (a tag mora em `el`). `type` é a tag efetiva no IR (consome\n // o `el`); sem `type` nem `el` = malformado → tratado como element.\n const isEl = node.el != null;\n const tag = node.el ?? node.type ?? \"\";\n const kind: NodeKind = isEl || !node.type ? \"element\" : classify(node.type);\n\n const children = (node.children ?? []).map((c, i) =>\n flatten(c, [...indexPath, i]),\n );\n\n const template = templateOf(node);\n const ir: NodeIR = {\n address,\n id: node.id,\n type: tag,\n kind,\n children,\n ...(node.props ? { props: node.props } : {}),\n ...(node.events ? { events: node.events } : {}),\n ...(node.layout ? { layout: node.layout } : {}),\n ...(node.placement !== undefined ? { placement: node.placement } : {}),\n ...(template ? { template } : {}),\n ...(node.provides ? { provides: node.provides } : {}),\n ...(node.commands ? { commands: node.commands } : {}),\n ...(node.fallback === \"drop\" ? { fallback: \"drop\" as const } : {}),\n ...(node.requires ? { requires: node.requires } : {}),\n };\n nodes.set(address, ir);\n return address;\n };\n\n const root = flatten(def.body, [0]);\n\n return {\n id: def.component,\n entry: def.entry ?? false,\n context: { uses: def.context?.uses ?? [] },\n ...(def.provides ? { provides: def.provides } : {}),\n ...(def.commands ? { commands: def.commands } : {}),\n ...(def.effects ? { effects: def.effects } : {}),\n ...(def.updates ? { updates: def.updates } : {}),\n state: def.state ?? {},\n requires: def.requires ?? {},\n root,\n nodes,\n ...(def.category ? { category: def.category } : {}),\n ...(def.slots ? { slots: def.slots } : {}),\n ...(def.props ? { props: def.props } : {}),\n ...(def.tags ? { tags: def.tags } : {}),\n ...(def.version ? { version: def.version } : {}),\n };\n}\n\n/** As opções da derivação — ver `DeriveFactsOptions` em `./facts`, que é o mesmo objeto. */\nexport type { DeriveFactsOptions as BuildSystemOptions } from \"./facts\";\n\n/**\n * Indexa os componentes compilados e **deriva os fatos** sobre eles.\n *\n * O artefato tem duas metades que viajam juntas: a árvore (`components`) e o que se calculou\n * sobre ela (`facts`). Fundir as duas foi o que a decisão #7 do `IR.md` desfez.\n */\nexport function buildSystemIR(\n components: Iterable<ComponentIR>,\n opts: DeriveFactsOptions = {},\n): SystemIR {\n const map = new Map<string, ComponentIR>();\n for (const c of components) map.set(c.id, c);\n return { components: map, facts: deriveFacts(map.values(), opts) };\n}\n","import type { DefNode } from \"@loom-forge/core\";\nimport type { ComponentDef } from \"./ir\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n A FORMA do `ComponentDef` como DADO — o irmão da tabela de slots do core.\n\n O core responde \"onde cabe expressão dentro de um NÓ\". Esta responde a mesma\n pergunta um nível acima: **onde cabe expressão dentro de uma DEFINIÇÃO**, fora\n da árvore. São lugares reais — o `provides`, o `set` de um update, os `params`\n de um efeito — e até aqui cada consumidor os compilava por conta própria, com\n um nó-fantasma escrito na mão: um no `applyUpdate`, um no `EffectRunner`, um no\n `eject`. Três cópias da mesma pergunta, e nenhuma sabia das outras.\n\n A exaustividade é do TypeScript: `Record<keyof ComponentDef, FieldRole>` não\n compila com um campo a menos. Campo novo na definição obriga a classificá-lo, e\n é isso que impede o próximo esquecimento silencioso.\n\n E a divisão de conhecimento continua a mesma: o `forge` diz ONDE a expressão\n mora, e quem sabe traduzi-la é a linguagem, que entra como função. Nenhum dos\n dois lados importa o outro.\n ────────────────────────────────────────────────────────────────────────────── */\n\n/** O papel de um campo da definição. */\nexport type ComponentFieldRole =\n /** identidade — nunca tocada. */\n | \"identity\"\n /** dado do documento: nome, flag, versão, categoria. Não é código. */\n | \"data\"\n /** DECLARAÇÃO de tipo (`PropsDecl`, `SlotContract`) — vocabulário do checker, não expressão. */\n | \"decl\"\n /** carrega nó(s) — a árvore, que a tabela do core cobre. */\n | \"tree\"\n /** aceita EXPRESSÃO em algum lugar dentro de si — ver `componentSlotsOf`. */\n | \"slot\";\n\nexport const COMPONENT_FIELDS: Readonly<\n Record<keyof ComponentDef, ComponentFieldRole>\n> = {\n component: \"identity\",\n entry: \"data\",\n category: \"data\",\n version: \"data\",\n tags: \"data\",\n requires: \"data\",\n /** só NOMES do catálogo: o que entra no escopo, não o que ele vale. */\n context: \"data\",\n props: \"decl\",\n slots: \"decl\",\n /** `type` é DECLARAÇÃO; o `init` é EXPRESSÃO sobre `props` e `ctx`, avaliada no mount. */\n state: \"slot\",\n provides: \"slot\",\n /** o alias é roteador (nome → nome), mas os `params` da aplicação parcial são expressão. */\n commands: \"slot\",\n updates: \"slot\",\n effects: \"slot\",\n body: \"tree\",\n};\n\n/** Um lugar de expressão fora da árvore. O caminho É o endereço, e é o que evita duas verdades. */\nexport interface ComponentSlot {\n /** `[\"updates\", \"add\", \"set\"]` — e o endereço reportado é ele, pontilhado. */\n readonly path: readonly string[];\n readonly value: unknown;\n}\n\n/**\n * O caminho como o autor o lê: `#0.1.props.title` na árvore (a raiz é o nó `0`), `updates.add.set`\n * fora dela. Derivado — ninguém o lê de volta; quem precisa do caminho guarda a lista.\n */\nexport const addressOf = (path: CompiledPath): string =>\n typeof path[0] === \"number\" ? `#${path.join(\".\")}` : path.join(\".\");\n\n/**\n * Os lugares de expressão de uma definição, FORA da árvore.\n *\n * A árvore é do `compile()` da linguagem, que já a percorre pela tabela do core. Isto cobre o\n * resto — e existe separado porque quem precisa da resposta não é um só: o runtime (para avaliar),\n * o eject (para traduzir) e a autoria (para diagnosticar no endereço certo).\n */\nexport function componentSlotsOf(def: ComponentDef): ComponentSlot[] {\n const slots: ComponentSlot[] = [];\n\n if (def.provides) slots.push({ path: [\"provides\"], value: def.provides });\n\n // do alias, só os `params` são expressão — o `action` é um nome, como o `type` de um nó.\n for (const [name, alias] of Object.entries(def.commands ?? {}))\n if (typeof alias === \"object\" && alias.params !== undefined)\n slots.push({ path: [\"commands\", name, \"params\"], value: alias.params });\n\n // o `init` SEMEIA o estado a partir de `props`/`ctx` — e é expressão como qualquer outra.\n // O `type` ao lado dele é declaração, e não passa por aqui.\n for (const [key, decl] of Object.entries(def.state ?? {}))\n if (decl.init !== undefined)\n slots.push({ path: [\"state\", key, \"init\"], value: decl.init });\n\n for (const [name, update] of Object.entries(def.updates ?? {}))\n if (update.set !== undefined)\n slots.push({ path: [\"updates\", name, \"set\"], value: update.set });\n\n // o efeito e o cleanup são intenções, e uma intenção é uma CADEIA (ADR-018): os `params` de\n // cada elo — o próprio, o `then`, o `catch`, em profundidade — moram no caminho do elo\n const intentSlots = (intent: IntentLink, path: readonly string[]): void => {\n if (intent.params !== undefined)\n slots.push({ path: [...path, \"params\"], value: intent.params });\n if (intent.then) intentSlots(intent.then, [...path, \"then\"]);\n if (intent.catch) intentSlots(intent.catch, [...path, \"catch\"]);\n };\n for (const [name, effect] of Object.entries(def.effects ?? {})) {\n intentSlots(effect, [\"effects\", name]);\n if (effect.cleanup)\n intentSlots(effect.cleanup, [\"effects\", name, \"cleanup\"]);\n }\n\n return slots;\n}\n\n/** um elo de intenção: o que a tabela precisa ler dele. */\ninterface IntentLink {\n readonly params?: unknown;\n readonly then?: IntentLink;\n readonly catch?: IntentLink;\n}\n\n/**\n * Escrita imutável por CAMINHO.\n *\n * Ela lê o valor corrente a cada nível em vez de reconstruir a partir do original — e isso não é\n * elegância: com dois slots no mesmo efeito (`params` e `cleanup.params`), reconstruir do\n * original faz a segunda escrita APAGAR a primeira, em silêncio. Aconteceu.\n */\nconst setIn = <T>(target: T, path: readonly string[], value: unknown): T => {\n if (path.length === 0) return value as T;\n const [head, ...rest] = path;\n const current = (target as Record<string, unknown> | undefined)?.[head!];\n return {\n ...(target as object),\n [head!]: setIn(current, rest, value),\n } as T;\n};\n\n/** O caminho de um campo, como lista: índice e chave são distintos no tipo. */\nexport type CompiledPath = readonly (string | number)[];\n\n/** Algo que a linguagem endereça num nó: um diagnóstico, uma ilha. O forge só reancora. */\nexport interface Addressed {\n /** o caminho a partir da raiz do nó traduzido — `[0, \"props\", \"value\", …]` na porta. */\n readonly path: CompiledPath;\n /** o caminho como o autor o lê. Derivado do `path`; o forge o reescreve junto. */\n readonly address: string;\n}\n\n/**\n * O que a linguagem devolve ao traduzir um nó: a forma, e — quando ela tem o que dizer — os\n * diagnósticos e as ilhas dele. Os dois últimos são opcionais porque o port do binder\n * (`BindingEngine.compile`) fala só `DefNode`: quem traduz pelo port não inventa listas vazias.\n */\nexport interface CompiledNode<\n D extends Addressed = Addressed,\n I extends Addressed = Addressed,\n> {\n readonly def: DefNode;\n readonly diagnostics?: readonly D[];\n readonly islands?: readonly I[];\n}\n\n/** Traduz um nó — a metade que a LINGUAGEM sabe fazer, e que entra como função. */\nexport type CompileNode<\n D extends Addressed = Addressed,\n I extends Addressed = Addressed,\n> = (node: DefNode) => CompiledNode<D, I>;\n\n/** A definição compilada, com o que a linguagem disse sobre ela — na árvore e fora dela. */\nexport interface CompiledDefinition<\n D extends Addressed = Addressed,\n I extends Addressed = Addressed,\n> {\n readonly def: ComponentDef;\n /** os da árvore com o endereço de nó (`#0.1.props.x`); os de fora com o caminho do slot\n * (`updates.somar.set.n`). */\n readonly diagnostics: readonly D[];\n readonly islands: readonly I[];\n}\n\nconst GHOST_ID = \"$slot\";\n/** o caminho, dentro do nó-fantasma, onde o valor de um slot de componente entra. */\nconst GHOST_PATH: CompiledPath = [0, \"props\", \"value\"];\n\n/**\n * Reancora o que a linguagem endereçou dentro do nó-fantasma para o caminho do slot: o\n * `[0, \"props\", \"value\", \"n\"]` da porta vira `[\"updates\", \"somar\", \"set\", \"n\"]`, e o endereço,\n * `updates.somar.set.n`. O que não sai da porta do fantasma (não deveria haver) é descartado.\n */\nconst reanchor = <T extends Addressed>(\n item: T,\n slot: ComponentSlot,\n): T | undefined => {\n if (\n item.path.length < GHOST_PATH.length ||\n GHOST_PATH.some((seg, i) => item.path[i] !== seg)\n )\n return undefined;\n const path = [...slot.path, ...item.path.slice(GHOST_PATH.length)];\n return { ...item, path, address: addressOf(path) };\n};\n\n/**\n * O valor sai e volta pela porta de um nó: é a única forma que a linguagem conhece. O que ela\n * disser sobre ele volta reancorado no caminho do slot.\n */\nconst compileValue = <D extends Addressed, I extends Addressed>(\n slot: ComponentSlot,\n compile: CompileNode<D, I>,\n): { value: unknown; diagnostics: D[]; islands: I[] } => {\n const ghost: DefNode = {\n id: GHOST_ID,\n type: GHOST_ID,\n props: { value: slot.value },\n };\n const out = compile(ghost);\n const back = <T extends Addressed>(items: readonly T[] | undefined): T[] =>\n (items ?? []).flatMap((item) => {\n const moved = reanchor(item, slot);\n return moved === undefined ? [] : [moved];\n });\n return {\n value: (out.def.props as { value?: unknown } | undefined)?.value,\n diagnostics: back(out.diagnostics),\n islands: back(out.islands),\n };\n};\n\n/* Memoizado por IDENTIDADE da definição E do tradutor: a mesma definição compilada por dois\n binders com profiles diferentes não é o mesmo artefato (uma ilha que um recusa, o outro\n liga). Um `WeakMap` por tradutor faz a chave ser o par, sem segurar nenhum dos dois — e é por\n isso que o tradutor precisa ser ESTÁVEL: uma arrow nova por render nunca acerta a memória, e\n derruba o cache do binder junto. Quem traduz pelo port usa o `compileNodeOf`, que é estável\n por binder. */\nconst compiled = new WeakMap<\n CompileNode,\n WeakMap<ComponentDef, CompiledDefinition>\n>();\n\nconst adapters = new WeakMap<object, CompileNode>();\n\n/**\n * O tradutor de um PORT — `BindingEngine.compile`, que fala só `DefNode`. Um por binder, sempre\n * o mesmo objeto: é o que faz a memória do `compileDefinition` acertar de um render para o outro.\n * Sem `compile` no port, o nó atravessa como está (a definição já vem compilada, ou ninguém\n * compila).\n */\nexport function compileNodeOf(binder: {\n compile?(node: DefNode): DefNode;\n}): CompileNode {\n let adapter = adapters.get(binder);\n if (adapter === undefined) {\n adapter = (node) => ({ def: binder.compile?.(node) ?? node });\n adapters.set(binder, adapter);\n }\n return adapter;\n}\n\n/**\n * A definição COMPILADA: mesma forma, ilhas no lugar do texto — na árvore e fora dela —, com\n * os diagnósticos e as ilhas que a linguagem devolveu, cada um no endereço do campo que o\n * produziu.\n *\n * Simétrico ao `compile(node)` da linguagem, e o par dos dois é o artefato derivado inteiro. O\n * SoT continua sendo a definição autorada: esta é recomputada, nunca editada à mão.\n *\n * Memoizado por identidade, como o `bodyOf` — montar um objeto novo a cada render derrubaria o\n * cache de compilação do binder (ADR-109), que é memoizado do mesmo jeito.\n */\nexport function compileDefinition<\n D extends Addressed = Addressed,\n I extends Addressed = Addressed,\n>(def: ComponentDef, compile: CompileNode<D, I>): CompiledDefinition<D, I> {\n let byDef = compiled.get(compile as CompileNode);\n if (byDef === undefined) {\n byDef = new WeakMap();\n compiled.set(compile as CompileNode, byDef);\n }\n const hit = byDef.get(def);\n if (hit) return hit as CompiledDefinition<D, I>;\n\n const body = compile(def.body);\n const diagnostics: D[] = [...(body.diagnostics ?? [])];\n const islands: I[] = [...(body.islands ?? [])];\n let out: ComponentDef = { ...def, body: body.def };\n for (const slot of componentSlotsOf(def)) {\n const value = compileValue(slot, compile);\n out = setIn(out, slot.path, value.value);\n diagnostics.push(...value.diagnostics);\n islands.push(...value.islands);\n }\n\n const result: CompiledDefinition<D, I> = { def: out, diagnostics, islands };\n byDef.set(def, result);\n byDef.set(out, result); // idempotente: compilar o compilado devolve ele mesmo\n return result;\n}\n","import type { BindingEngine, DefNode } from \"@loom-forge/core\";\nimport type { ComponentDef, UpdateDecl } from \"./ir\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n STATE — o tier \"sujo\" do componente (v1). Estado local POR INSTÂNCIA (nunca global) +\n ações de update. Decisão (jun/2026, investigação statedelta): o engine completo do\n statedelta é pesado demais por instância (codegen por instância ~5ms+20KB); então reusamos\n o MODELO/vocabulário (directives) e um interpretador LEVE atrás deste port. Pro boundary\n React, o container de estado é o próprio React (`useState`) — `createStateCore` do apex seria\n redundante no v1. Trocar pro interpretador de directives do statedelta = reimplementar\n `applyUpdate` (a fronteira está aqui).\n ────────────────────────────────────────────────────────────────────────────── */\n\n/** tipo do nó-marcador que a expansão emite no lugar de um componente VIVO; a view o materializa\n * num boundary React. Carrega `props: { def, callProps }`. */\nexport const STATEFUL_TYPE = \"$stateful\";\n\n/**\n * Um componente é VIVO (sujo) se tem UPDATES locais ou efeitos.\n *\n * Sem nenhum dos dois, o estado nunca muda e nada dispara sozinho → expande estaticamente\n * (`state.init` entra no escopo, como um componente puro). Com qualquer um, vira boundary React\n * por instância — e o EFEITO é literalmente o que torna o componente impuro: ele age sem que\n * ninguém o toque.\n */\nexport const isLive = (def: ComponentDef): boolean =>\n Object.keys(def.updates ?? {}).length > 0 ||\n Object.keys(def.effects ?? {}).length > 0;\n\n/**\n * Estado inicial: o `init` de cada chave, avaliado contra `props` e `ctx`.\n *\n * **Uma vez, no mount** — é a semântica do `useState(props.x)` do React, que é o padrão para\n * SEMEAR: lê a prop na montagem e o setter assume dali em diante. O escopo NÃO tem `state` (é o\n * que está sendo definido) nem `params` (não há chamada).\n *\n * Um `init` constante atravessa o bind intacto, então declarar `0` continua sendo `0`.\n */\nexport const initState = (\n def: ComponentDef,\n scope: Readonly<Record<string, unknown>>,\n binder: BindingEngine,\n): Record<string, unknown> => {\n const inits: Record<string, unknown> = {};\n for (const [key, decl] of Object.entries(def.state ?? {}))\n inits[key] = decl.init;\n if (Object.keys(inits).length === 0) return {};\n // um bind só para o estado inteiro: o escopo é o mesmo para todas as chaves.\n const ghost: DefNode = { id: \"$init\", type: \"$init\", props: inits };\n return (binder.bind(ghost, scope).props ?? {}) as Record<string, unknown>;\n};\n\n/* ──────────────────────────────────────────────────────────────────────────────\n Os dois avaliam pelo MESMO caminho do render: montam um nó-fantasma, mandam o\n binder ligar, e leem as props avaliadas. Reusar o binder é o que garante o mesmo\n escopo, o mesmo gate de capability e o mesmo orçamento.\n\n E os dois **só ligam**: a definição chega COMPILADA, uma vez, pelo\n `compileDefinition`, quando ela entra no registry. Antes cada um compilava por\n conta na hora do disparo — três cópias da mesma pergunta, no caminho quente.\n\n > **É contrato, não otimização.** O binder não avalia `{{ }}` em texto: string é\n > dado (ADR-111). Um `set` que chegue cru vira o próprio texto no estado, com o\n > aviso de \"definição não compilada\" em dev.\n ────────────────────────────────────────────────────────────────────────────── */\n\n/** Avalia um payload (os `params` de um efeito, de um cleanup) contra o escopo. */\nexport const bindPayload = (\n params: unknown,\n scope: Record<string, unknown>,\n binder: BindingEngine,\n): unknown => {\n if (params === undefined) return undefined;\n const ghost: DefNode = {\n id: \"$payload\",\n type: \"$payload\",\n props: { params },\n };\n const bound = binder.bind(ghost, scope);\n return (bound.props as { params?: unknown } | undefined)?.params;\n};\n\n/**\n * Aplica um update ao estado: avalia as expressões do `set` contra o escopo\n * (`{...props, ...state, ...params}`) e devolve o novo estado (merge imutável, PARCIAL).\n *\n * É o port: o v1 é `set`; um interpretador de directives entra aqui.\n */\nexport const applyUpdate = (\n prev: Record<string, unknown>,\n update: UpdateDecl,\n scope: Record<string, unknown>,\n binder: BindingEngine,\n): Record<string, unknown> => {\n if (!update.set) return prev;\n const ghost: DefNode = { id: \"$set\", type: \"$set\", props: update.set };\n const bound = binder.bind(ghost, scope);\n return { ...prev, ...(bound.props ?? {}) };\n};\n","/* ──────────────────────────────────────────────────────────────────────────────\n SLOTS — children TIPADO. PURO; valida no SITE de composição (NÃO muta o IR).\n\n A inovação vs React: lá todo filho é leaf opaco; aqui o PAI declara o CONTRATO do que\n aceita como filho (categoria/grupo, tags, leaf, cardinalidade) sem conhecer o filho\n concreto. Composição ≠ dependência: A não conhece B, só o CONTRATO do slot — então isto\n NÃO cria aresta A→B. A checagem mora no COMPOSITOR (quem colocou B dentro de A): \"no\n componente C, o nó <A> recebeu um filho <B> que viola o contrato de children de A\".\n\n Eixos estruturais (puros). O eixo de PROPS (`Component<C>` por subtype) é do `./check` —\n ver decisão deferida (slot por props + factory).\n ────────────────────────────────────────────────────────────────────────────── */\n\nimport type { ComponentIR, NodeIR, SlotContract, SystemIR } from \"./ir\";\nimport type { Descriptor, DescriptorRegistry } from \"@loom-forge/core\";\nimport { effectiveTags } from \"./facts\";\n\nexport interface SlotViolation {\n rule: \"slot-cardinality\" | \"slot-leaf\" | \"slot-category\" | \"slot-tags\";\n /** o COMPOSITOR (componente onde o pai foi usado com filhos). */\n componentId: string;\n /** tipo do nó-pai cujo slot foi violado. */\n parent: string;\n /** nome do slot (\"children\"). */\n slot: string;\n /** tipo do filho infrator (quando aplicável). */\n child?: string;\n message: string;\n}\n\nexport interface CheckSlotsOptions {\n /** registry de descriptors — slots/categoria/behavior de React registrado (via `meta`). */\n registry?: DescriptorRegistry;\n}\n\ninterface ChildInfo {\n category?: string;\n tags: ReadonlySet<string>;\n}\n\nconst metaStr = (\n d: Descriptor | undefined,\n key: string,\n): string | undefined => {\n const v = d?.meta?.[key];\n return typeof v === \"string\" ? v : undefined;\n};\n\nconst metaArr = (d: Descriptor | undefined, key: string): string[] =>\n Array.isArray(d?.meta?.[key]) ? (d!.meta![key] as string[]) : [];\n\n/**\n * Valida cada SITE de composição contra o contrato de slot do pai. Caminha todos os nós de\n * todos os componentes; quando um nó (cujo `type` declara slots) tem filhos, confere-os.\n * Pai/filho podem ser custom (IR) ou React registrado (via `descriptor.meta`).\n */\nexport function checkSlots(\n sys: SystemIR,\n opts: CheckSlotsOptions = {},\n): SlotViolation[] {\n const registry = opts.registry;\n const violations: SlotViolation[] = [];\n\n /** slots declarados por um `type` (custom via IR; registrado via `meta.slots`). */\n const slotsOf = (type: string): Record<string, SlotContract> | undefined => {\n const c = sys.components.get(type);\n if (c?.slots) return c.slots;\n const ms = registry?.get(type)?.meta?.slots;\n return ms && typeof ms === \"object\"\n ? (ms as Record<string, SlotContract>)\n : undefined;\n };\n\n /** categoria + tags efetivas de um `type` (custom: IR + tags propagadas; registrado: meta). */\n const infoOf = (type: string): ChildInfo => {\n const c = sys.components.get(type);\n if (c)\n return {\n category: c.category,\n tags: new Set(effectiveTags(sys.facts, type)),\n };\n const d = registry?.get(type);\n if (d)\n return {\n category: metaStr(d, \"category\"),\n tags: new Set(metaArr(d, \"behavior\")),\n };\n return { category: undefined, tags: EMPTY };\n };\n\n const checkChild = (\n comp: ComponentIR,\n parentType: string,\n contract: SlotContract,\n child: NodeIR,\n ): void => {\n const push = (rule: SlotViolation[\"rule\"], message: string): void => {\n violations.push({\n rule,\n componentId: comp.id,\n parent: parentType,\n slot: \"children\",\n child: child.type,\n message,\n });\n };\n if (contract.leaf && child.children.length)\n push(\n \"slot-leaf\",\n `slot de \"${parentType}\" exige folha, mas \"${child.type}\" tem filhos`,\n );\n\n const info = infoOf(child.type);\n if (contract.category) {\n const allowed = Array.isArray(contract.category)\n ? contract.category\n : [contract.category];\n if (info.category === undefined || !allowed.includes(info.category))\n push(\n \"slot-category\",\n `\"${child.type}\" (categoria ${info.category ?? \"—\"}) não é aceito no slot de \"${parentType}\" (exige ${allowed.join(\"|\")})`,\n );\n }\n if (contract.tags && !contract.tags.every((t) => info.tags.has(t)))\n push(\n \"slot-tags\",\n `\"${child.type}\" não tem as tags exigidas pelo slot de \"${parentType}\" (${contract.tags.join(\", \")})`,\n );\n };\n\n for (const comp of sys.components.values()) {\n for (const node of comp.nodes.values()) {\n if (!node.children.length) continue;\n const contract = slotsOf(node.type)?.children;\n if (!contract) continue;\n\n const children = node.children\n .map((a) => comp.nodes.get(a))\n .filter((n): n is NodeIR => n !== undefined);\n\n // cardinalidade (do slot inteiro)\n const n = children.length;\n if (\n (contract.single && n > 1) ||\n (contract.max !== undefined && n > contract.max)\n )\n violations.push({\n rule: \"slot-cardinality\",\n componentId: comp.id,\n parent: node.type,\n slot: \"children\",\n message: `slot de \"${node.type}\" aceita no máximo ${contract.single ? 1 : contract.max} filho(s), recebeu ${n}`,\n });\n if (contract.min !== undefined && n < contract.min)\n violations.push({\n rule: \"slot-cardinality\",\n componentId: comp.id,\n parent: node.type,\n slot: \"children\",\n message: `slot de \"${node.type}\" exige ao menos ${contract.min} filho(s), recebeu ${n}`,\n });\n\n for (const child of children)\n checkChild(comp, node.type, contract, child);\n }\n }\n\n return violations;\n}\n\nconst EMPTY: ReadonlySet<string> = new Set();\n","import type { Address, ComponentIR, TypeRef } from \"./ir\";\nimport {\n installed,\n irShape,\n mountingOf,\n propagateObligations,\n walkMounted,\n type ObligationSite,\n} from \"./mount\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n CONTEXTO — a obrigação que sobe, e quem a descarrega.\n\n `uses: [\"X\"]` não é atributo, é DÍVIDA. Ela viaja:\n\n B usa X → a obrigação nasce\n A compõe B e não provê X → ESCAPA: vira obrigação de A\n A compõe B e provê X → DESCARREGADA, para ali\n Página compõe A e não provê X → chega na borda\n\n É o formato de um sistema de EFEITOS: um efeito requerido propaga até encontrar um\n handler. Aqui tudo é FATO — \"o que este componente exige de fora\". O veredito (\"exigiu e\n não declarou\" = erro) é julgamento, e mora no `rules.ts`.\n\n O que está provido num ponto é o que ele ENXERGA depois de montado (`./mount`): um filho de\n slot, escrito aqui e montado dentro do chamado, enxerga o que o chamado provê no `$slot`. A\n travessia e o ponto-fixo são os mesmos do vocabulário de comando — é o mesmo mecanismo,\n noutro eixo.\n ────────────────────────────────────────────────────────────────────────────── */\n\n/** O catálogo de contextos do sistema: `nome → tipo`. O nome é NOMINAL (com namespace\n * quando o componente cruza a fronteira do app); o tipo é global, e o valor é posicional. */\nexport type ContextCatalog = Record<string, TypeRef>;\n\nexport interface ContextFacts {\n /** por componente: o que ele exige de FORA — o próprio, mais o que escapou dos filhos. */\n required: ReadonlyMap<string, readonly string[]>;\n /**\n * por nó: o que estava provido naquele ponto, contando o que o próprio nó instala. É o que o\n * painel mostra ao selecionar. Um nó que monta em mais de um lugar mostra o que TODOS os\n * pontos proveem; um nó que não monta não aparece.\n */\n providedAt: ReadonlyMap<Address, readonly string[]>;\n /** por nó de CHAMADA: o que o chamado exige e não estava provido ali — o que escapa. */\n unsatisfiedAt: ReadonlyMap<Address, readonly string[]>;\n}\n\nconst sorted = (set: Iterable<string>): string[] => [...set].sort();\n\n/** um ponto de chamada, com o que estava provido ali. */\ninterface CallSite extends ObligationSite {\n address: Address;\n provided: ReadonlySet<string>;\n}\n\n/** o que TODOS os escopos proveem. */\nconst common = (sets: readonly ReadonlySet<string>[]): Set<string> =>\n new Set([...(sets[0] ?? [])].filter((n) => sets.every((s) => s.has(n))));\n\n/**\n * Deriva, para cada componente, o que ele exige de fora — e por qual nó cada exigência\n * escapou.\n *\n * Um componente que PROVÊ um nome não precisa dele de fora: `uses ∖ provides`. As duas\n * declarações têm direções diferentes (o que preciso × o que dou), e quando coincidem o\n * autor está dizendo que se basta.\n */\nexport function deriveContext(components: Iterable<ComponentIR>): ContextFacts {\n const irs = new Map<string, ComponentIR>();\n for (const c of components) irs.set(c.id, c);\n const mounting = mountingOf(irs.values());\n\n const providedAt = new Map<Address, readonly string[]>();\n const sitesOf = new Map<string, CallSite[]>();\n /** o que o componente exige por si só — a semente do ponto-fixo. */\n const own = new Map<string, Set<string>>();\n\n for (const ir of irs.values()) {\n const provides = new Set(Object.keys(ir.provides ?? {}));\n own.set(\n ir.id,\n new Set(ir.context.uses.filter((name) => !provides.has(name))),\n );\n\n const sites: CallSite[] = [];\n const shape = irShape(ir);\n const root = ir.nodes.get(ir.root);\n if (root)\n walkMounted(root, shape, mounting, (node, scopes) => {\n // o que vale NO nó, contando o que ele instala: numa chamada, é o que o corpo do\n // chamado enxerga — o corpo dele É a subárvore deste nó.\n const here = scopes.map(\n (s) => installed(s, shape.installs(node)).contexts,\n );\n if (here.length) providedAt.set(node.address, sorted(common(here)));\n if (node.kind === \"component\")\n for (const provided of here)\n sites.push({\n callee: node.type,\n address: node.address,\n provided,\n discharges: (name) => provided.has(name),\n });\n });\n sitesOf.set(ir.id, sites);\n }\n\n const required = propagateObligations(own, sitesOf);\n\n // o que escapou POR NÓ — é o endereço que o diagnóstico aponta e que a correção usa.\n const unsatisfiedAt = new Map<Address, Set<string>>();\n for (const sites of sitesOf.values())\n for (const site of sites)\n for (const name of required.get(site.callee) ?? [])\n if (!site.provided.has(name)) {\n const missing = unsatisfiedAt.get(site.address) ?? new Set<string>();\n missing.add(name);\n unsatisfiedAt.set(site.address, missing);\n }\n\n return {\n required: new Map([...required].map(([id, s]) => [id, sorted(s)])),\n providedAt,\n unsatisfiedAt: new Map(\n [...unsatisfiedAt].map(([address, s]) => [address, sorted(s)]),\n ),\n };\n}\n","/* ──────────────────────────────────────────────────────────────────────────────\n COMPONENT RULES — FASE 2: regras de domínio sobre o IR já gerado. PURO; NÃO muta o IR\n (o IR é a SSOT; regras leem e emitem diagnósticos — modelo película do overlay).\n\n A fase 1 (compileComponent/buildSystemIR) é o ESSENCIAL pra \"compilar\": grafo, tags\n propagadas, ciclos, dep-faltando. A fase 2 (aqui) são as REGRAS que sobram — categoria/\n direção, unable/availability, tags proibidas — exatamente como o checker/Razor das Actions\n caem sobre o IR delas. Caem sobre as TAGS PROPAGADAS (fase 1).\n\n O gate de público/privado (`entry`) NÃO mora aqui: \"entry\" é um boundary de ENTRADA, não\n uma regra de lista — vive no `resolveTree` (`requireEntryRoot`), isomorfo ao `invoke(entry)`\n das Actions. Rota/endereço é direção de acesso do HOST; a lib não conhece rota. Tudo é\n componente; \"página\" = um componente `entry`/raiz.\n\n Substrato de inspeção/película (buildGuide/macroFilm do overlay) é visualização — fica\n pra quando houver um inspector. Aqui o foco é validação (build/CI/authoring).\n ────────────────────────────────────────────────────────────────────────────── */\n\nimport { reachable, edgesOf } from \"@tslite/graph\";\nimport type { ComponentIR, SystemIR } from \"./ir\";\nimport type { ContextFacts } from \"./context\";\nimport type { DescriptorRegistry } from \"@loom-forge/core\";\n\nexport interface RuleViolation {\n /** id da regra (`category-policy` / `route-entry` / `forbidden-tag`…). */\n rule: string;\n /** componente infrator. */\n componentId: string;\n message: string;\n data?: Record<string, unknown>;\n}\n\nexport type Decision = \"allow\" | \"deny\";\n\n/* ── Categoria (eixo das regras de direção) ─────────────────────────────────────── */\n\n/** Categoria de um nó de grafo: custom via `ComponentIR.category`; registrado via\n * `descriptor.meta.category` (declarado, confiável — não se infere de React). */\nexport type CategoryResolver = (id: string) => string | undefined;\n\nexport function categoryOf(\n sys: SystemIR,\n registry?: DescriptorRegistry,\n): CategoryResolver {\n return (id) => {\n const c = sys.components.get(id);\n if (c) return c.category;\n const meta = registry?.get(id)?.meta?.category;\n return typeof meta === \"string\" ? meta : undefined;\n };\n}\n\nexport interface CategoryPolicy {\n categoryOf: CategoryResolver;\n /** matriz por categoria: `matrix[from][to]` = allow|deny. */\n matrix: Record<string, Record<string, Decision>>;\n /** decisão quando o par não está na matriz (default: `allow` — estilo deny-list). */\n defaultPolicy?: Decision;\n}\n\n/**\n * Regra arquitetural POR ARESTA (categoria/direção): \"UI pode usar Data, Data não pode usar\n * UI\". Caminha o `outgoing` (componente compõe componente/registrado); pares sem categoria\n * são ignorados. Sem propagação — só a aresta direta (igual `analysis.policies`).\n */\nexport function checkCategoryPolicy(\n sys: SystemIR,\n policy: CategoryPolicy,\n): RuleViolation[] {\n const violations: RuleViolation[] = [];\n const dflt = policy.defaultPolicy ?? \"allow\";\n for (const [from, targets] of sys.facts.outgoing) {\n const fromCat = policy.categoryOf(from);\n if (fromCat === undefined) continue;\n for (const to of targets) {\n const toCat = policy.categoryOf(to);\n if (toCat === undefined) continue;\n const decision = policy.matrix[fromCat]?.[toCat] ?? dflt;\n if (decision === \"deny\")\n violations.push({\n rule: \"category-policy\",\n componentId: from,\n message: `\"${from}\" (${fromCat}) não pode depender de \"${to}\" (${toCat})`,\n data: { to, fromCategory: fromCat, toCategory: toCat },\n });\n }\n }\n return violations;\n}\n\n/* ── Availability / unable (transitivo) ─────────────────────────────────────────── */\n\nexport interface UnableSources {\n /** capabilities indisponíveis — um componente que as `requires` fica unable. */\n capabilities?: ReadonlySet<string>;\n /** actions indisponíveis — um componente que as invoca fica unable. */\n actions?: ReadonlySet<string>;\n /** componentes explicitamente indisponíveis. */\n components?: Iterable<string>;\n /**\n * A PORTA de ação — quem sabe o que pode rodar AGORA (o `isAvailable` do Tier 1).\n *\n * Com ela, ninguém precisa montar a lista de indisponíveis à mão: pergunta-se por ação que o\n * grafo de fato invoca. Uma porta sem `isAvailable` não torna nada unable — não saber não é\n * saber que não.\n *\n * **É um retrato, não uma assinatura.** Disponibilidade muda em runtime (cota, permissão,\n * provider caído) e isto é análise do relógio LENTO: quem quiser acompanhar, recomputa.\n */\n port?: { isAvailable?(id: string): boolean };\n}\n\n/**\n * Availability/unable TRANSITIVO: a partir das fontes off, marca todo componente que delas\n * depende — o Razor das Actions. Capability/action off → o componente que as exige/invoca é\n * fonte; e todo dependente herda `unable`.\n */\nexport function computeUnable(sys: SystemIR, off: UnableSources): Set<string> {\n const sources = new Set<string>(off.components ?? []);\n for (const c of sys.components.values()) {\n if (\n off.capabilities &&\n Object.keys(c.requires).some((cap) => off.capabilities!.has(cap))\n )\n sources.add(c.id);\n const deps = sys.facts.components.get(c.id)?.deps;\n // o eixo `actions` só tem o que SAI (update local é chamada interna, ADR-014), então\n // perguntar à porta aqui é perguntar exatamente pelo que a aplicação provê.\n if (\n deps?.actions.some(\n (a) => off.actions?.has(a) || off.port?.isAvailable?.(a) === false,\n )\n )\n sources.add(c.id);\n }\n // \"A usa B, e B está unable → A está unable\". `reachable` devolve quem ALCANÇA uma fonte\n // pelas arestas de saída — que é esse mesmo conjunto, e é o mesmo cano do dirty. Os `ids`\n // saem do `incoming`, o único mapa que tem TODO nó (o `outgoing` só tem quem compõe algo).\n return reachable(\n sys.facts.incoming?.keys() ?? sys.components.keys(),\n edgesOf(sys.facts.outgoing),\n sources,\n );\n}\n\n/* ── Identidade: o id é o que liga um nó a tudo que o aponta ────────────────────── */\n\n/**\n * Um id REPETIDO no documento de um componente.\n *\n * O id é a identidade do nó: é por ele que o editor muta, que o patch acha o alvo e que a tela\n * liga o foco ao documento. Dois nós com o mesmo id fazem os três apontarem para o primeiro — e\n * nada falha na hora, porque a árvore renderiza igual. O escopo é o DOCUMENTO: componentes\n * diferentes repetem id à vontade, e a expansão os separa por instância.\n */\nexport function checkIdentity(sys: SystemIR): RuleViolation[] {\n const violations: RuleViolation[] = [];\n for (const c of sys.components.values()) {\n const byId = new Map<string, string[]>();\n for (const node of c.nodes.values()) {\n const addresses = byId.get(node.id) ?? [];\n addresses.push(node.address);\n byId.set(node.id, addresses);\n }\n for (const [id, nodes] of byId)\n if (nodes.length > 1)\n violations.push({\n rule: \"duplicate-id\",\n componentId: c.id,\n message: `component \"${c.id}\" has ${nodes.length} nodes with id \"${id}\" — the editor, the patch and the focus would all point to the first one`,\n data: { id, nodes },\n });\n }\n return violations;\n}\n\n/* ── Regras sobre TAGS efetivas (propagadas na fase 1) ──────────────────────────── */\n\n/**\n * Um componente no escopo não pode ter nenhuma das tags proibidas (efetivas/propagadas).\n * Ex.: páginas (entry) não podem ser `unsafe` → `checkForbiddenTags(sys, [\"unsafe\"], c => c.entry)`.\n * É a prova de que \"tag declarada propaga aos dependentes e as regras caem sobre o propagado\".\n */\nexport function checkForbiddenTags(\n sys: SystemIR,\n forbidden: Iterable<string>,\n scope?: (comp: ComponentIR) => boolean,\n): RuleViolation[] {\n const banned = new Set(forbidden);\n const violations: RuleViolation[] = [];\n for (const c of sys.components.values()) {\n if (scope && !scope(c)) continue;\n const tags = sys.facts.tags?.get(c.id);\n if (!tags) continue;\n for (const t of tags)\n if (banned.has(t))\n violations.push({\n rule: \"forbidden-tag\",\n componentId: c.id,\n message: `\"${c.id}\" tem a tag proibida \"${t}\" (efetiva/propagada)`,\n data: { tag: t },\n });\n }\n return violations;\n}\n\n/* ── Contexto: o que FOI DECLARADO × o que a análise EXIGE ───────────────────────── */\n\nexport interface ContextIssue extends RuleViolation {\n rule: \"context-undeclared\" | \"context-unsatisfied\" | \"context-unused\";\n /** os nomes em questão. É o dado que a correção usa para agir sem adivinhar. */\n data: { contexts: string[]; node?: string };\n}\n\nexport interface CheckContextsOptions {\n /** os contextos que o HOST provê de ambiente (`auth`, `route`…). Um componente `entry`\n * que exija algo fora disto não tem onde viver: é a fronteira da prova. */\n ambient?: Iterable<string>;\n}\n\n/**\n * Julga o que a análise de contexto derivou. A assimetria é a de sempre — **você só pode ser\n * contrariado se tiver afirmado**:\n *\n * | declarou MENOS que a realidade | mentira → erro |\n * | declarou MAIS | desperdício → warning |\n * | não declarou | a inferência decide |\n *\n * O erro aponta o NÓ por onde a exigência escapou, e carrega os nomes: promover a obrigação\n * para o componente de cima é correção mecânica, e quem conserta não deve ter de re-derivar.\n */\nexport function checkContexts(\n sys: SystemIR,\n ctx: ContextFacts,\n opts: CheckContextsOptions = {},\n): ContextIssue[] {\n const issues: ContextIssue[] = [];\n const ambient = new Set(opts.ambient ?? []);\n\n for (const c of sys.components.values()) {\n const declared = new Set([\n ...c.context.uses,\n ...Object.keys(c.provides ?? {}),\n ]);\n const required = ctx.required.get(c.id) ?? [];\n\n // (1) exige e NÃO declarou — a mentira. O endereço é o nó por onde escapou.\n const undeclared = required.filter((name) => !declared.has(name));\n if (undeclared.length) {\n const at = [...ctx.unsatisfiedAt].find(\n ([address, names]) =>\n address.startsWith(`${c.id}#`) &&\n names.some((n) => undeclared.includes(n)),\n );\n issues.push({\n rule: \"context-undeclared\",\n componentId: c.id,\n message: `\"${c.id}\" exige o contexto ${undeclared.map((n) => `\"${n}\"`).join(\", \")} e não o declara — quem o compõe não tem como saber`,\n data: { contexts: undeclared, ...(at ? { node: at[0] } : {}) },\n });\n }\n\n // (2) componente de ENTRADA exigindo o que o host não provê — a borda da prova.\n if (c.entry && opts.ambient !== undefined) {\n const missing = required.filter((name) => !ambient.has(name));\n if (missing.length)\n issues.push({\n rule: \"context-unsatisfied\",\n componentId: c.id,\n message: `\"${c.id}\" é entry e exige ${missing.map((n) => `\"${n}\"`).join(\", \")}, que o host não provê`,\n data: { contexts: missing },\n });\n }\n\n // (3) provê e ninguém abaixo usa — desperdício, não mentira. Só computável porque a\n // inferência SOBE: é o mesmo fato, lido ao contrário.\n const provided = Object.keys(c.provides ?? {});\n if (provided.length) {\n const wanted = new Set<string>();\n for (const node of c.nodes.values())\n if (node.kind === \"component\")\n for (const n of ctx.required.get(node.type) ?? []) wanted.add(n);\n for (const n of c.context.uses) wanted.add(n);\n const unused = provided.filter((name) => !wanted.has(name));\n if (unused.length)\n issues.push({\n rule: \"context-unused\",\n componentId: c.id,\n message: `\"${c.id}\" provê ${unused.map((n) => `\"${n}\"`).join(\", \")} e ninguém abaixo usa`,\n data: { contexts: unused },\n });\n }\n }\n return issues;\n}\n\n/* ── Efeito: o laço que se prova sem rodar ──────────────────────────────────────── */\n\nexport interface EffectIssue extends RuleViolation {\n rule: \"effect-loop\";\n data: { effect: string; action: string; paths: string[] };\n}\n\n/**\n * Um efeito que ESCREVE o que ele OBSERVA é laço infinito — e aqui dá para provar sem rodar,\n * porque os dois lados são declarados: o `on` diz o que ele observa, e o `set` da ação local\n * diz o que ele escreve.\n *\n * O React só descobre isso em runtime, com o navegador travado. Nós descobrimos porque o\n * programa é dado.\n *\n * Só ação LOCAL é julgada: o que o `ActionPort` do host faz com o estado dele não é daqui.\n */\nexport function checkEffects(sys: SystemIR): EffectIssue[] {\n const issues: EffectIssue[] = [];\n for (const c of sys.components.values()) {\n for (const [name, effect] of Object.entries(c.effects ?? {})) {\n const local = c.updates?.[effect.action];\n if (!local?.set) continue;\n const written = new Set(\n Object.keys(local.set).map((key) => `state.${key}`),\n );\n const watched = effect.on.filter((path) => written.has(path));\n if (watched.length)\n issues.push({\n rule: \"effect-loop\",\n componentId: c.id,\n message: `o efeito \"${name}\" observa ${watched.map((p) => `\"${p}\"`).join(\", \")} e a ação \"${effect.action}\" escreve ali — reexecutaria para sempre`,\n data: { effect: name, action: effect.action, paths: watched },\n });\n }\n }\n return issues;\n}\n","import {\n identityBinder,\n resolveTree,\n commandScope,\n resolveIntent,\n EMPTY_COMMANDS,\n TREE,\n type BindingEngine,\n type CommandScope,\n type DefNode,\n type EventBinding,\n type NodeOrigin,\n type ResolveTreeOptions,\n type ResolvedNode,\n} from \"@loom-forge/core\";\nimport { createComponentDefRegistry } from \"./ir\";\nimport type { ComponentDef, ComponentDefRegistry } from \"./ir\";\nimport { SLOT_TYPE, slotName } from \"./mount\";\nimport { initState, isLive, STATEFUL_TYPE } from \"./state\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n EXPANSÃO — o seam do construtor (forge) sobre o compositor (loom). A expansão de\n componente custom é um PRÉ-PASSO estrutural (igual `each`/`when` do bind): transforma\n uma árvore JÁ ligada (data-bind) numa árvore PURA de `DefNode` (só registrados/intrínsecos/\n `el`) que o compositor renderiza sem saber o que é um `ComponentDef`.\n\n Identidade call-site: `type:\"Card\"` é uma CHAMADA — o resultado OCUPA o slot do nó (mesma\n id/placement); o corpo é ligado contra as props (escopo próprio, nunca global); os ids dos\n descendentes são namespaced por instância (`hostId/childId`). Slot-filling: os children do\n call-site são injetados onde o corpo declara `<$slot/>` (opacos pro componente). Ciclo/\n profundidade → o nó fica como tipo custom e o compositor degrada pra `unknown`.\n ────────────────────────────────────────────────────────────────────────────── */\n\nconst MAX_DEPTH = 100;\n\nconst EMPTY_UPDATES: ReadonlySet<string> = new Set();\n\n/** o registry vazio: a expansão roda sempre, e sem definições ela só resolve as diretivas de\n * escopo. Um por módulo — alocar a cada render recompilaria nada, mas seria lixo por frame. */\nconst EMPTY_DEFS: ComponentDefRegistry = createComponentDefRegistry();\n\n/**\n * Carimba em cada nó DE ONDE ele veio — o componente e o id que o autor deu.\n *\n * É antes do bind de propósito: o bind renomeia a cópia de um `each` (`card.item`), e o id autorado\n * se perderia; o carimbo atravessa a cópia intacto. A travessia sai da tabela `TREE`. Uma origem\n * escrita no documento é substituída — não é campo de autoria.\n */\nconst stamped = (node: DefNode, component: string): DefNode => {\n const out: DefNode = { ...node, origins: [{ component, id: node.id }] };\n const fields = out as unknown as Record<string, unknown>;\n for (const [field, shape] of Object.entries(TREE)) {\n const value = fields[field];\n if (shape === \"list\" && Array.isArray(value))\n fields[field] = value.map((child: DefNode) => stamped(child, component));\n else if (shape === \"node\" && value !== null && typeof value === \"object\")\n fields[field] = stamped(value as DefNode, component);\n }\n return out;\n};\n\n/**\n * O corpo de um componente, com o `provides` e os `commands` do COMPONENTE virando os do nó RAIZ\n * do corpo — o açúcar existindo de verdade, e não em dois lugares —, e cada nó carimbado com a\n * origem dele.\n *\n * Exportado porque o boundary de um componente VIVO expande o mesmo corpo, ao vivo, e tem de\n * vê-lo exatamente como a expansão estática o vê.\n *\n * Memoizado por IDENTIDADE da definição porque o `compile` do binder também memoiza assim\n * (ADR-109): montar um objeto novo a cada expansão recompilaria a árvore a cada render.\n */\nconst bodies = new WeakMap<ComponentDef, DefNode>();\nexport const bodyOf = (def: ComponentDef): DefNode => {\n const cached = bodies.get(def);\n if (cached) return cached;\n // JUNTA com o que a raiz já declara, e a raiz ganha no mesmo nome: substituir apagaria a\n // declaração do nó em silêncio. Os dois são o mesmo lugar, e o nó é o mais específico.\n const sugared =\n def.provides || def.commands\n ? {\n ...def.body,\n ...(def.provides\n ? { provides: { ...def.provides, ...def.body.provides } }\n : {}),\n ...(def.commands\n ? { commands: { ...def.commands, ...def.body.commands } }\n : {}),\n }\n : def.body;\n const body = stamped(sugared, def.component);\n bodies.set(def, body);\n return body;\n};\n\n/** As origens de quem OCUPA um nó de chamada: a chamada primeiro, e depois o que o corpo já diz de\n * si. Fora do documento de um componente, a chamada não tem origem. */\nconst occupying = (\n call: DefNode,\n ctx: ExpandCtx,\n inner: readonly NodeOrigin[] = [],\n): Pick<DefNode, \"origins\"> => {\n const origins = [\n ...(ctx.component !== undefined ? (call.origins ?? []) : []),\n ...inner,\n ];\n return origins.length ? { origins } : {};\n};\n\n/** Children de um call-site, AINDA NÃO expandidos, com o escopo de onde foram escritos.\n *\n * A expansão é adiada até o `$slot` de propósito: **dado vem de onde você foi escrito,\n * contexto vem de onde você foi montado**. Expandi-los aqui congelaria o contexto do\n * compositor, e eles montam dentro do corpo do chamado — onde o contexto é outro. */\ninterface PendingSlot {\n nodes: DefNode[];\n /** o ctx de expansão de quem ESCREVEU os children (prefixo, profundidade, slots de cima). */\n written: ExpandCtx;\n}\n\ninterface ExpandCtx {\n prefix: string;\n expanding: ReadonlySet<string>;\n depth: number;\n /** children do call-site, por slot, expandidos no PONTO DE MONTAGEM. */\n slots?: Record<string, PendingSlot>;\n /** o registro de contextos em vigor aqui — `nome → valor`, o nearest-wins já resolvido. */\n contexts: Readonly<Record<string, unknown>>;\n /** o vocabulário de COMANDOS em vigor aqui — mesmo mecanismo, eixo do comportamento. */\n commands: CommandScope;\n /** os UPDATES do componente cujo corpo está sendo expandido: nome que resolve aqui é chamada\n * interna, e não passa pelo escopo de comando (ADR-014). */\n updates: ReadonlySet<string>;\n /** o componente cujo DOCUMENTO está sendo expandido — `undefined` na árvore do host, que não\n * vem de definição nenhuma e por isso não tem origem. */\n component?: string;\n}\n\n/** Escopo do corpo: DUAS raízes, sem merge. Antes props e state disputavam o mesmo espaço\n * achatado — e a precedência INVERTIA entre componente puro e vivo, em silêncio. */\nconst componentScope = (\n def: ComponentDef,\n props: Record<string, unknown> | undefined,\n contexts: Readonly<Record<string, unknown>>,\n binder: BindingEngine,\n): Record<string, unknown> => {\n // o `init` enxerga `props` e `ctx` — e só. Ele é avaliado ANTES de haver estado.\n const outer = {\n props: props ?? {},\n ctx: pick(contexts, def.context?.uses),\n };\n // só o que ele DECLAROU usar entra no `ctx`: provisão não vaza, ela fica disponível e\n // alcança quem pediu. É a mesma projeção que o `env` do checker faz.\n return { ...outer, state: initState(def, outer, binder) };\n};\n\n/** o registro visto por quem declarou estes nomes. */\nconst pick = (\n contexts: Readonly<Record<string, unknown>>,\n uses: readonly string[] | undefined,\n): Record<string, unknown> => {\n const out: Record<string, unknown> = {};\n for (const name of uses ?? [])\n if (name in contexts) out[name] = contexts[name];\n return out;\n};\n\n/** As intenções de um nó, já roteadas pelo escopo em vigor. Diretiva CONSUMIDA: o que chega na\n * view é sempre um id de ação de verdade, nunca um apelido de sessão. */\nconst routed = (\n node: DefNode,\n ctx: { commands: CommandScope; updates: ReadonlySet<string> },\n): Record<string, EventBinding> | undefined => {\n if (node.events === undefined) return undefined;\n const out: Record<string, EventBinding> = {};\n for (const [name, binding] of Object.entries(node.events))\n out[name] = resolveIntent(binding, ctx.commands, ctx.updates);\n return out;\n};\n\n/** o registro em vigor ABAIXO de um nó: o herdado com o que ele instala por cima\n * (`{...herdado, ...meu}` — o sombreamento dinâmico é literalmente o merge). */\nconst provided = (\n inherited: Readonly<Record<string, unknown>>,\n node: DefNode,\n): Readonly<Record<string, unknown>> =>\n node.provides ? { ...inherited, ...node.provides } : inherited;\n\nexport interface ExpandOptions {\n /** boundary de entrada: componente custom PRIVADO entrado como RAIZ não expande → `unknown`. */\n requireEntryRoot?: boolean;\n /** os contextos de AMBIENTE — o que o host provê na raiz (`auth`, `route`…). É a fronteira\n * declarada: dentro da árvore a prova é total, na borda ela depende disto. */\n contexts?: Readonly<Record<string, unknown>>;\n /** o vocabulário de comando da RAIZ — o que a aplicação instala antes de qualquer sessão. */\n commands?: CommandScope;\n /**\n * Os UPDATES do componente cujo corpo É esta raiz — só existe quando quem expande é o boundary\n * de um componente vivo.\n *\n * Um nome que resolve aqui é chamada interna e não passa pelo escopo de comando. Sem isto, um\n * alias de fora com o mesmo nome reescreveria o update local — e o boundary é o ÚNICO lugar onde\n * updates existem, porque ter update é o que torna o componente vivo.\n */\n updates?: ReadonlySet<string>;\n /** o componente cujo corpo É esta raiz — o boundary de um componente vivo o informa, para que os\n * nós do corpo mantenham a origem. Ausente, a raiz é do host. */\n component?: string;\n}\n\n/**\n * Expande os componentes custom de `root` (árvore já data-bound) numa árvore PURA de `DefNode`.\n * `system` = registry de definições; `binder` = pra ligar o corpo de cada componente.\n */\nexport function expandComponents(\n root: DefNode,\n system: ComponentDefRegistry,\n binder: BindingEngine,\n opts: ExpandOptions = {},\n): DefNode {\n // gate de RAIZ (entry): privado como raiz não expande → compositor → unknown.\n if (opts.requireEntryRoot && root.type != null && system.has(root.type)) {\n if (!system.get(root.type)!.entry) return { id: root.id, type: root.type };\n }\n\n const expandChildren = (\n children: DefNode[] | undefined,\n ctx: ExpandCtx,\n ): DefNode[] => {\n const out: DefNode[] = [];\n for (const c of children ?? []) {\n if (c.type === SLOT_TYPE) {\n const pending = ctx.slots?.[slotName(c)];\n // expandidos AQUI: o dado deles é o de onde foram escritos (já ligado) e o ID segue o\n // namespace de lá, mas o CONTEXTO é o deste ponto — que é onde eles de fato montam.\n //\n // Pela mesma travessia, não por um laço à parte: um `$slot` DENTRO dos children é\n // forwarding, e tem de ser resolvido contra os slots de quem os escreveu.\n if (pending)\n out.push(\n ...expandChildren(pending.nodes, {\n ...pending.written,\n // dado vem de onde você foi ESCRITO; contexto e COMANDO vêm de onde você foi\n // MONTADO. É o que faz o mesmo botão executar o `submeter` da sessão que o recebe.\n contexts: ctx.contexts,\n commands: ctx.commands,\n }),\n );\n continue;\n }\n out.push(expand(c, ctx.prefix + c.id, ctx));\n }\n return out;\n };\n\n const expand = (\n node: DefNode,\n instanceId: string,\n ctx: ExpandCtx,\n ): DefNode => {\n // componente custom → substitui pela árvore do componente (ocupa `instanceId`).\n if (node.el == null && node.type != null && system.has(node.type)) {\n if (ctx.expanding.has(node.type) || ctx.depth >= MAX_DEPTH)\n return { id: instanceId, type: node.type }; // ciclo → compositor degrada p/ unknown\n const cdef = system.get(node.type)!;\n // componente VIVO (tem ações) → NÃO expande estaticamente: emite um marcador que a view\n // materializa num boundary React (estado local por instância). O corpo é expandido AO VIVO\n // lá dentro, contra `{...props, ...state}`. É o puro/sujo virando concreto no runtime.\n if (isLive(cdef))\n return {\n id: instanceId,\n type: STATEFUL_TYPE,\n placement: node.placement,\n // os contextos em vigor AQUI viajam com o marcador: o boundary expande o corpo ao\n // vivo, e ele precisa do mesmo registro que um componente puro receberia.\n // o marcador responde pela CHAMADA; a origem do corpo vem de dentro do boundary\n ...occupying(node, ctx),\n props: {\n def: cdef,\n callProps: node.props ?? {},\n contexts: provided(ctx.contexts, node),\n // o vocabulário de comando viaja igual: o boundary expande o corpo ao vivo, e ele\n // precisa do mesmo escopo que um componente puro receberia.\n commands: commandScope(ctx.commands, node),\n },\n };\n // O `provides` DESTE nó vale para o corpo do chamado: depois da expansão, o corpo É a\n // subárvore deste nó. Os slots que o compositor escreveu aqui continuam no escopo de fora.\n const inner = provided(ctx.contexts, node);\n // o vocabulário de comando do call-site vale para o CORPO do chamado, como o `provides`:\n // depois da expansão, o corpo é a subárvore deste nó.\n const innerCommands = commandScope(ctx.commands, node);\n const authored = bodyOf(cdef);\n const tree = binder.compile?.(authored) ?? authored;\n const body = binder.bind(\n tree,\n componentScope(cdef, node.props, inner, binder),\n );\n const expanded = expand(body, instanceId, {\n prefix: `${instanceId}/`,\n expanding: new Set(ctx.expanding).add(node.type),\n depth: ctx.depth + 1,\n // os children do call-site vão CRUS, com o escopo de quem os escreveu; quem os expande\n // é o `$slot`, já dentro do corpo.\n slots: { children: { nodes: node.children ?? [], written: ctx } },\n contexts: inner,\n commands: innerCommands,\n // o corpo passa a ser do CHAMADO: os updates dele é que resolvem antes do escopo.\n updates: new Set(Object.keys(cdef.updates ?? {})),\n component: cdef.component,\n });\n // o resultado OCUPA o slot do host: herda id (já = instanceId) E placement do call-site\n // (o placement do corpo é interno; quem vale no pai é o da chamada), e responde pelos dois.\n return {\n ...expanded,\n placement: node.placement,\n ...occupying(node, ctx, expanded.origins),\n };\n }\n // nó normal / `el` / intrínseco → recursa filhos (resolvendo `$slot`); assume `instanceId`.\n // O nó provê para BAIXO: o `provides` dele entra no ctx dos filhos, não no dele.\n const next: DefNode = { ...node, id: instanceId };\n delete next.provides; // diretiva CONSUMIDA — não vai para a saída\n delete next.commands; // idem: o alias morre aqui, e a view recebe o id de verdade\n // a origem é do documento de um componente; na árvore do host ela não existe\n if (ctx.component === undefined) delete next.origins;\n // os eventos do PRÓPRIO nó veem o escopo herdado, não o que ele instala — é a mesma regra\n // do `provides`: o nó provê para baixo, não para si.\n const events = routed(node, ctx);\n if (events !== undefined) next.events = events;\n if (node.children !== undefined)\n next.children = expandChildren(node.children, {\n ...ctx,\n contexts: provided(ctx.contexts, node),\n commands: commandScope(ctx.commands, node),\n });\n return next;\n };\n\n return expand(root, root.id, {\n prefix: \"\",\n expanding: new Set(),\n depth: 0,\n contexts: opts.contexts ?? {},\n commands: opts.commands ?? EMPTY_COMMANDS,\n updates: opts.updates ?? EMPTY_UPDATES,\n ...(opts.component !== undefined ? { component: opts.component } : {}),\n });\n}\n\nexport interface ResolveComponentTreeOptions extends ResolveTreeOptions {\n /** registry de definições de componente custom. Ausente → nenhum `type` é custom, e a expansão\n * só consome as diretivas de escopo. */\n componentDefs?: ComponentDefRegistry;\n requireEntryRoot?: boolean;\n /** os contextos de AMBIENTE que o host provê na raiz. Ver `ExpandOptions.contexts`. */\n contexts?: Readonly<Record<string, unknown>>;\n /** o vocabulário de comando da RAIZ — repassado à expansão. */\n commands?: CommandScope;\n /** os updates do componente cujo corpo é esta raiz. Ver `ExpandOptions.updates`. */\n updates?: ReadonlySet<string>;\n /** o componente cujo corpo é esta raiz. Ver `ExpandOptions.component`. */\n component?: string;\n}\n\n/**\n * Render do construtor: `bind` (dados) → `expand` (componentes custom → árvore pura) →\n * `resolveTree` (compositor, com `identityBinder` — a árvore já está ligada). É o que o\n * `@loom-forge/forge-react` usa por baixo; também serve headless.\n *\n * **A expansão roda SEMPRE, mesmo sem `componentDefs`.** Ela não é só \"trocar custom por corpo\":\n * é também onde as diretivas de ESCOPO são consumidas — o `provides` e o `commands`. Uma árvore\n * só de componentes registrados e `el` continua tendo sessão, contexto e vocabulário de comando,\n * e sem esta passada eles ficariam declarados e inertes, em silêncio. Sem definição nenhuma o\n * custo é um walk, e nenhum id muda (o prefixo só cresce quando um custom é expandido).\n */\nexport function resolveComponentTree(\n node: DefNode,\n opts: ResolveComponentTreeOptions,\n data?: unknown,\n): ResolvedNode {\n const binder = opts.binder ?? identityBinder;\n const bound = binder.bind(binder.compile?.(node) ?? node, data);\n const expanded = expandComponents(\n bound,\n opts.componentDefs ?? EMPTY_DEFS,\n binder,\n {\n requireEntryRoot: opts.requireEntryRoot,\n ...(opts.contexts ? { contexts: opts.contexts } : {}),\n ...(opts.commands ? { commands: opts.commands } : {}),\n ...(opts.updates ? { updates: opts.updates } : {}),\n ...(opts.component !== undefined ? { component: opts.component } : {}),\n },\n );\n return resolveTree(expanded, { ...opts, binder: identityBinder });\n}\n"]}
package/package.json ADDED
@@ -0,0 +1,58 @@
1
+ {
2
+ "name": "@loom-forge/forge",
3
+ "version": "0.1.0",
4
+ "type": "module",
5
+ "description": "forge · o CONSTRUTOR de componentes (headless): declara componentes novos em JSON — IR, grafo, regras, slots, estado local e a expansão sobre o compositor. Zero dependências.",
6
+ "keywords": [
7
+ "nocode",
8
+ "components",
9
+ "ir",
10
+ "graph",
11
+ "json",
12
+ "dsl"
13
+ ],
14
+ "license": "MIT",
15
+ "author": {
16
+ "name": "Anderson D. Rosa",
17
+ "url": "https://github.com/andersondrosa"
18
+ },
19
+ "repository": {
20
+ "type": "git",
21
+ "url": "https://github.com/andersondrosa/loom-forge.git",
22
+ "directory": "packages/forge"
23
+ },
24
+ "homepage": "https://github.com/andersondrosa/loom-forge/tree/main/packages/forge#readme",
25
+ "bugs": {
26
+ "url": "https://github.com/andersondrosa/loom-forge/issues"
27
+ },
28
+ "publishConfig": {
29
+ "access": "public"
30
+ },
31
+ "sideEffects": false,
32
+ "exports": {
33
+ ".": {
34
+ "types": "./dist/index.d.ts",
35
+ "import": "./dist/index.js"
36
+ }
37
+ },
38
+ "files": [
39
+ "dist"
40
+ ],
41
+ "dependencies": {
42
+ "@tslite/graph": "^0.1.0",
43
+ "@loom-forge/core": "0.1.0"
44
+ },
45
+ "devDependencies": {
46
+ "tsup": "^8.0.0",
47
+ "typescript": "^5.9.3",
48
+ "@loom-forge/tslite": "0.1.0"
49
+ },
50
+ "scripts": {
51
+ "build": "tsup",
52
+ "dev": "tsup --watch",
53
+ "test": "vitest run",
54
+ "test:watch": "vitest",
55
+ "typecheck": "tsc --noEmit",
56
+ "clean": "rm -rf dist"
57
+ }
58
+ }