@loom-forge/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,552 @@
+/** Intenção declarativa: um evento do componente (`onClick`, `onSave`…) → uma action.
+ *  O caminho CANÔNICO de efeito (events-out). Serializável; o componente não pega serviço. */
+interface EventBinding {
+    action: string;
+    /**
+     * Os params da ação — e é POR AQUI que entra tudo o que a intenção recebe (ADR-018).
+     *
+     * Dentro deles a raiz `event` é o valor recebido: o que o widget emitiu num `events.onX`, o
+     * `data` da ação anterior num `then`, o `error` num `catch`. O autor escreve o mapeamento
+     * (`{ campo: "cpf", valor: "{{ event }}" }`, `{ valido: "{{ event.valido }}" }`) — nada entra
+     * costurado por fora. O que chega de um widget é o **valor** que o componente registrado emite,
+     * declarado em `Descriptor.meta.emits`, não o evento do DOM.
+     *
+     * São avaliados no DESPACHO, com o escopo do render mais `event` — não no render.
+     */
+    params?: unknown;
+    /**
+     * O que roda quando esta intenção RESOLVE: com `success: true` num despacho ao host, e
+     * `event` = `data`; depois do estado escrito num update local, e `event` = `undefined`.
+     */
+    then?: EventBinding;
+    /**
+     * O que roda quando o despacho ao host FALHA (`success: false` — falha de domínio ou o
+     * `UNHANDLED_ERROR` de um port que lança), com `event` = `error`. Sem `catch`, a falha vai só
+     * ao `onActionResult` do host, como sempre foi. Um fluxo cancelado (`aborted` com sucesso) não
+     * é resultado e não passa por aqui; um port que lançou é falha, e passa.
+     */
+    catch?: EventBinding;
+    /**
+     * Os params que o autor deixa DELIBERADAMENTE para a camada de comando preencher.
+     *
+     * Um comando resolve param por token (`$focus`), por default, ou perguntando — abrindo um
+     * drawer, um seletor. Isso é legítimo, e é diferente de esquecer: sem declarar, um obrigatório
+     * ausente é erro de build, e **tem de continuar sendo**. Trocar prova por sorte no default é o
+     * que a declaração impede.
+     *
+     * Quem preenche é o commander, com os resolvers dele; aqui só se declara a intenção — e ela
+     * fica visível na inspeção, que é o ponto.
+     */
+    resolve?: readonly string[];
+    /**
+     * A intenção é um UPDATE do componente que a escreveu — chamada interna, que não sai pela porta.
+     *
+     * **Não é campo de autoria.** Quem marca é a resolução (`resolveIntent`), que sabe de qual
+     * componente o nó é; uma marca escrita no documento é descartada ali. É ela que diz à view para
+     * entregar a intenção ao componente vivo em vez do `ActionPort` — e é por ser marca, e não nome,
+     * que o evento de um componente puro inlinado no corpo de um vivo não alcança os updates dele.
+     */
+    local?: true;
+    /**
+     * O ESCOPO do render em que o nó foi ligado — o que os `params` enxergam no despacho.
+     *
+     * **Não é campo de autoria.** Quem escreve é o `bind`, quando os `params` têm expressão: eles
+     * ficam compilados no nó resolvido e são avaliados no despacho, sobre este escopo mais `event`.
+     * Sem expressão nos `params`, não há escopo a guardar.
+     */
+    scope?: Readonly<Record<string, unknown>>;
+}
+/**
+ * O que um nome de comando executa: a ação, e o que já vem preenchido.
+ *
+ * A forma curta (`"submeter": "form/submit"`) é o caso comum; a longa existe para a **aplicação
+ * parcial** — a sessão liga parte dos params, e quem dispara só passa o que sobrou.
+ */
+type CommandAlias = string | {
+    action: string;
+    params?: unknown;
+};
+/**
+ * De onde um nó veio: o componente cujo documento o escreveu, e o id que o autor deu a ele.
+ *
+ * Um nó resolvido não tem mais o id autorado — a expansão o prefixa por instância, e o `each` o
+ * renomeia por cópia. A origem é o que liga a TELA de volta ao DOCUMENTO.
+ */
+interface NodeOrigin {
+    component: string;
+    id: string;
+}
+/** Um nó da definição declarativa (entrada). */
+interface DefNode {
+    /** identidade ESTÁVEL — keys, endereçamento (JSON Pointer), mutação (json-myers). */
+    id: string;
+    /** discriminador → resolvido contra o registry de descriptors. Ausente quando `el` define
+     *  uma tag intrínseca. */
+    type?: string;
+    /** TAG intrínseca: `{ el: "div", props, children }` = `createElement("div", props, children)`.
+     *  Bypassa o registry; o tier mais baixo (DESIGN §6), "sob sua responsabilidade". Tem precedência
+     *  sobre `type`, é CONSUMIDO na normalização (sai limpo no IR/ResolvedNode → vira `type` + `el`) e
+     *  NUNCA cria aresta de dep no grafo. Compõe com children/layout/events normalmente. */
+    el?: string;
+    /** props brutas (após o bind). */
+    props?: Record<string, unknown>;
+    /** layout adapter que arruma os filhos deste nó. Default: o do descriptor, senão o do engine. */
+    layout?: string;
+    children?: DefNode[];
+    /** posição deste nó no layout do pai — opaca pro core, lida pelo planner. */
+    placement?: unknown;
+    /** forward-compat: se `type` não resolve, usa isto. `"drop"` = nada. */
+    fallback?: "drop" | DefNode;
+    /** gating de capability: `cap → versão mínima`, ou `cap → "*"` (só presença).
+     *  Checado contra as capabilities anunciadas pelo host. */
+    requires?: Record<string, string>;
+    version?: string;
+    /** eventos declarativos: `nomeDaProp → intenção` (ex.: `onSave → { action, params }`). */
+    events?: Record<string, EventBinding>;
+    /** DIRETIVA estrutural: repete este nó por item da coleção (array) ou re-escopa a subárvore
+     *  (objeto). Expande 1:N no bind — não liga valor. Consumida (não aparece na saída). */
+    each?: unknown;
+    /** o NOME que o `each` liga para o item corrente. Identificador, não expressão. */
+    as?: string;
+    /**
+     * DIRETIVA de escopo: instala contextos para a SUBÁRVORE — `nome → expressão`.
+     *
+     * É o `<Ctx.Provider value={…}>` escrito como diretiva, e por isso **qualquer nó provê**:
+     * um componente-provedor seria um nó que existe só por mecanismo. O nó provê para BAIXO,
+     * não para si — as props e o `when` dele são avaliados no contexto herdado, como os
+     * atributos de um Provider são avaliados por fora. A exceção é o nó que é CHAMADA de
+     * componente custom: ali o corpo do chamado É a subárvore, e enxerga.
+     */
+    provides?: Record<string, unknown>;
+    /**
+     * DIRETIVA de escopo: o vocabulário de COMANDOS da subárvore — `nome local → ação`.
+     *
+     * É o mesmo mecanismo do `provides`, no eixo do comportamento: o que viaja é **nome**, nunca
+     * função (contrato tem de ser dado — ver `forge/docs/CONTEXT.md`). Uma sessão de formulário
+     * declara `limpar`, `autopreencher` e `submeter`, e o mesmo botão composto em outra sessão
+     * executa outro `submeter`. Contrato, não acoplamento.
+     *
+     * A resolução é léxica e tem três degraus: **update local do componente → escopo de comando
+     * mais próximo → porta raiz**. O update ganha porque ele não sai do componente; o alias ganha
+     * do host porque ele é mais perto.
+     */
+    commands?: Record<string, CommandAlias>;
+    /** DIRETIVA estrutural: dropa o nó se a expressão for falsy. Dentro de um `each`, é
+     *  avaliada por item (filtra). Consumida (não aparece na saída). */
+    when?: unknown;
+    /**
+     * De onde o nó veio, do mais de FORA para o mais de dentro.
+     *
+     * É uma lista porque um nó pode estar no lugar de mais de um: o corpo de um componente OCUPA o
+     * nó de chamada, e a raiz do corpo responde pelos dois. **Não é campo de autoria** — quem escreve
+     * é a expansão do `forge`, e ela passa até o `ResolvedNode`.
+     */
+    origins?: readonly NodeOrigin[];
+}
+/** Metadado HEADLESS de um `type` — nunca contém o componente (isso é da camada de render). */
+interface Descriptor {
+    type: string;
+    /** props default (mescladas sob as props do nó). */
+    defaultProps?: Record<string, unknown>;
+    /** schema das props (JSON Schema / Schema do TSLite) — validação & form-builder. */
+    schema?: unknown;
+    /** layout default pros filhos deste type. */
+    layout?: string;
+    /** metadados de editor (label/categoria/ícone…). */
+    meta?: Record<string, unknown>;
+}
+interface DescriptorRegistry {
+    register(descriptor: Descriptor): DescriptorRegistry;
+    register(type: string): DescriptorRegistry;
+    get(type: string): Descriptor | undefined;
+    has(type: string): boolean;
+    list(): Descriptor[];
+}
+/** Saída do pipeline — árvore RESOLVIDA, dados puros, agnóstica de ambiente.
+ *  Qualquer renderer (React/HTML/RN) consome isto; o core não conhece nenhum. */
+type ResolvedNode = {
+    kind: "node";
+    id: string;
+    type: string;
+    /** quando `true`, `type` é uma tag intrínseca → a view usa `createElement(type, …)`. */
+    el?: boolean;
+    props: Record<string, unknown>;
+    /** intenções declarativas (events-out) — a view materializa em callbacks via ActionPort. */
+    events?: Record<string, EventBinding>;
+    /** plano de arrumação dos filhos (calculado pelo planner). */
+    layout?: ResolvedLayout;
+    children: ResolvedNode[];
+    /** de onde o nó veio — ver `DefNode.origins`. */
+    origins?: readonly NodeOrigin[];
+} | {
+    kind: "drop";
+    id: string;
+} | {
+    kind: "unknown";
+    id: string;
+    type: string;
+};
+interface ResolvedLayout {
+    name: string;
+    /** dados do plano — pareado por `name` com o renderer da camada de view. */
+    plan: unknown;
+}
+
+/** Bind: expande a definição contra dados (pré-passo). Adapter alvo: TSLite. */
+interface BindingEngine {
+    /**
+     * Avalia a definição COMPILADA contra o escopo. O segundo argumento é o mapa de RAÍZES
+     * — `{ data }` no render, `{ props, state }` no corpo de um componente. Nada entra no
+     * escopo implicitamente: o resto dos nomes é declarado pelo `as` de um `each`.
+     */
+    bind(node: DefNode, scope: unknown): DefNode;
+    /**
+     * Traduz a definição AUTORADA para a forma que este binder consome — em geral, expressão
+     * em texto vira expressão em árvore. **Idempotente e memoizada por identidade**, então
+     * chamar de novo é barato e chamar sobre já-compilado é no-op.
+     *
+     * Ausente = o binder consome o autorado direto (é o caso do `identityBinder`).
+     *
+     * As duas fases ficam separadas de propósito: compilar pode acontecer no servidor, no save
+     * ou no build, e o resultado é dado serializável. Quem chama é o PONTO DE ENTRADA (o
+     * `resolveTree`, a expansão do forge), não o `bind` por dentro — um `bind` que compilasse
+     * escondido apagaria a fronteira que torna a consolidação possível.
+     */
+    compile?(node: DefNode): DefNode;
+}
+declare const identityBinder: BindingEngine;
+/** Validação de um valor contra um schema. Adapter alvo: AJV / Zod (escolha do consumidor). */
+interface ValidationIssue {
+    code: string;
+    path?: string;
+    message?: string;
+}
+interface ValidationProvider {
+    validate(schema: unknown, value: unknown): ValidationIssue[] | null;
+}
+/** Default: sem validação. */
+declare const noopValidator: ValidationProvider;
+/**
+ * O ENVELOPE de um despacho. **`invoke` nunca lança por erro de domínio** — falha é DADO.
+ *
+ * `code` é o contrato do erro: discrimine por ele, nunca por regex na mensagem.
+ */
+interface ActionResult<T = unknown> {
+    readonly success: boolean;
+    /** o fluxo foi interrompido (vs. completou)? */
+    readonly aborted?: boolean;
+    readonly abortedBy?: string;
+    readonly data?: T;
+    readonly error?: {
+        readonly code: string;
+        readonly message?: string;
+        readonly data?: unknown;
+    };
+}
+/**
+ * O que um `invoke` devolve.
+ *
+ * **Async é o piso por física**, não por gosto: async embrulha sync, sync não embrulha async. Um
+ * host que não tem o que dizer devolve `void`, e quem normaliza é o `dispatchIntent`.
+ */
+type ActionOutcome = void | ActionResult | Promise<void | ActionResult>;
+/** Execução de ações da aplicação — o destino do events-out. */
+interface ActionPort {
+    /** dispara. Domínio falho volta como `{ success: false, error }`; não lança. */
+    invoke(id: string, params?: unknown, ctx?: unknown): ActionOutcome;
+    has?(id: string): boolean;
+    /** pode rodar agora? Alimenta o `computeUnable` e o estado desabilitado de um botão. */
+    isAvailable?(id: string): boolean;
+    /** a FORMA dos params, em JSON Schema — é o que tipa o call-site de um evento. */
+    paramsOf?(id: string): unknown;
+    /** a forma do RETORNO, em JSON Schema — é o que tipa "o retorno vira estado". */
+    resultOf?(id: string): unknown;
+    /** rótulo, ícone, categoria, atalho — o que uma paleta mostra. */
+    metadataOf?(id: string): Record<string, unknown> | undefined;
+    /**
+     * **Quanto vale** cada resposta do Tier 1 — `"inferred" | "declared" | "verified" | "none"`.
+     *
+     * Não é enfeite: uma assinatura `declared` pode divergir do que a implementação de fato aceita,
+     * e a única prova que depende dela ser COMPLETA é "esta chave não existe". Por isso o `check`
+     * usa isto para decidir se um `excess-property` é erro ou aviso.
+     */
+    provenanceOf?(query: string): string;
+}
+/** Endereço/diff/patch do documento (editor). Adapter alvo: json-myers (ou RFC 6902). */
+interface AddressPort {
+    diff(a: unknown, b: unknown): unknown;
+    patch(base: unknown, diff: unknown): unknown;
+}
+/** Checagem de tipos — compat `action.return ≤ component.props`, bindings. Adapter: @tslite/type-core. */
+interface TypeChecker {
+    /** `a` é atribuível a `b`? */
+    subtype(a: unknown, b: unknown): boolean;
+}
+/** ESCAPE imperativo: capabilities vivas do host (router, mapa, ws, focus-handle…) que NÃO
+ *  cabem em data-in/events-out. O caminho canônico é via ActionPort; isto é a exceção.
+ *  Pode ser preenchido pelo kernel/providers do host. */
+interface CapabilityPort {
+    get(name: string): unknown;
+    has(name: string): boolean;
+}
+
+/** O que o despacho de uma cadeia precisa de quem a executa — a view, o boundary. */
+interface IntentRuntime {
+    /** avalia os `params` de UMA intenção: o escopo dela (o do render) mais `event`. */
+    params(binding: EventBinding, event: unknown): unknown;
+    /** aplica um update local — o componente vivo. Ausente = não há boundary aqui. */
+    apply?(action: string, params: unknown): void;
+    /** o que fazer com uma intenção local sem boundary — em dev, avisar. */
+    orphan?(action: string): void;
+    port?: ActionPort;
+    onResult?(id: string, result: ActionResult): void;
+    /** o pendente da instância: `true` do despacho ao resultado. Ausente = não há instância. */
+    pending?(action: string, flag: boolean): void;
+}
+/**
+ * Executa uma intenção e a cadeia dela. Nunca devolve nada — o resultado é evento.
+ *
+ * Local: aplica e segue para o `then` com `event` = `undefined`. Host: despacha; no
+ * `success`, segue para o `then` com `data`; na falha, para o `catch` com `error`;
+ * `aborted` não é nenhum dos dois e fica só com o host.
+ */
+declare function runIntent(binding: EventBinding, event: unknown, rt: IntentRuntime): void;
+/**
+ * Dispara uma intenção e NUNCA devolve nada — nem promessa, nem valor.
+ *
+ * O resultado, sync ou async, vai para `onResult`. Falha de domínio chega como
+ * `{ success: false, error }`; um port que LANÇA vira `UNHANDLED_ERROR`, porque isso é bug de
+ * programa e não pode derrubar um clique.
+ */
+declare function dispatchIntent(port: ActionPort | undefined, id: string, params?: unknown, onResult?: (id: string, result: ActionResult) => void): void;
+/**
+ * Os `params` de uma intenção, avaliados no despacho — pelo MESMO caminho do render.
+ *
+ * O binder liga um nó-fantasma cuja prop é o `params` compilado, sobre o escopo que o `bind`
+ * guardou no binding mais a raiz `event`. Reusar o binder é o que garante o mesmo gate de
+ * capability, o mesmo orçamento e o mesmo escopo que o clique enxergava. Sem escopo guardado
+ * não há expressão nos `params`, e eles são dado como estão.
+ */
+declare function intentParams(binder: BindingEngine, binding: EventBinding, event: unknown): unknown;
+/** A intenção e cada elo da cadeia dela (`then`/`catch`, em profundidade), na ordem de escrita. */
+declare function intentsOf(binding: EventBinding): EventBinding[];
+
+/** O que está em vigor num ponto da árvore — nome local → ação. */
+type CommandScope = Readonly<Record<string, CommandAlias>>;
+declare const EMPTY_COMMANDS: CommandScope;
+/**
+ * O escopo em vigor ABAIXO de um nó: o herdado com o que ele instala por cima.
+ *
+ * O sombreamento é literalmente o merge — o mais próximo ganha, como no `provides`.
+ */
+declare const commandScope: (inherited: CommandScope, node: {
+    commands?: Record<string, CommandAlias>;
+}) => CommandScope;
+/** O alias normalizado: a forma curta é açúcar para `{ action }`. */
+declare const aliasOf: (alias: CommandAlias) => {
+    action: string;
+    params?: unknown;
+};
+/**
+ * Resolve uma intenção contra o escopo — e a ordem é a do runtime.
+ *
+ * `updates` são os UPDATES do componente que ESCREVEU a intenção: um nome que resolve ali é
+ * chamada interna e **não** passa pelo escopo, porque ele não sai do componente (ADR-014). O que
+ * não é update nem alias segue como está, e vai parar na porta raiz.
+ *
+ * Os params do alias são **aplicação parcial**: eles entram por baixo, e o que o call-site passa
+ * ganha. Quem dispara é mais específico que quem declarou o vocabulário.
+ *
+ * O que termina num update — pelo nome, ou pelo alvo de um alias — sai MARCADO (`local`). A marca
+ * é a resposta, e não o nome: a view entrega ao componente vivo só o que foi marcado, então uma
+ * intenção de outro componente com o mesmo nome não alcança o update dele.
+ *
+ * `then` e `catch` são intenções, e resolvem pela mesma régua — cada elo da cadeia no mesmo
+ * escopo em que a cadeia foi escrita.
+ */
+declare function resolveIntent(binding: EventBinding, scope: CommandScope, updates?: ReadonlySet<string>): EventBinding;
+
+/** Registry ABERTO de descriptors (metadado headless por `type`). Encadeável.
+ *  Aceita a forma completa (`Descriptor`) ou só o `type` (descriptor nu). */
+declare function createDescriptorRegistry(initial?: Descriptor[]): DescriptorRegistry;
+
+interface ResolveCtx {
+    registry: DescriptorRegistry;
+}
+type ResolveResult = {
+    kind: "render";
+    descriptor: Descriptor;
+    props: Record<string, unknown>;
+} | {
+    kind: "drop";
+} | {
+    kind: "unknown";
+    node: DefNode;
+};
+interface Resolver {
+    resolve(node: DefNode, ctx: ResolveCtx): ResolveResult;
+}
+interface TypeResolverOptions {
+    /** capacidades do host (capability → versão). Habilita o gating por `node.requires`. */
+    capabilities?: Record<string, string>;
+}
+/** Estratégia de resolução EXPLÍCITA (`node.type` → descriptor). Mescla `defaultProps`,
+ *  aplica `requires` e a cadeia de `fallback`. */
+declare function createTypeResolver(options?: TypeResolverOptions): Resolver;
+
+interface PlannerChild {
+    id: string;
+    placement?: unknown;
+}
+interface LayoutPlanner {
+    name: string;
+    plan(children: PlannerChild[]): unknown;
+    /**
+     * A FORMA do `placement` que este layout lê, em JSON Schema — o contrato do filho.
+     *
+     * É o `descriptor.schema` do eixo de arrumação: um editor monta os campos de posição a partir
+     * dele, sem saber que layout é. Ausente = o layout não publica a forma, e quem edita fica com o
+     * objeto cru.
+     */
+    placementSchema?: unknown;
+}
+interface FragmentPlan {
+    order: string[];
+}
+declare function fragmentPlanner(): LayoutPlanner;
+interface SectionPlan {
+    direction: "column" | "row";
+    gap?: string | number;
+    order: string[];
+}
+interface SectionOptions {
+    direction?: "column" | "row";
+    gap?: string | number;
+}
+declare function sectionPlanner(opts?: SectionOptions): LayoutPlanner;
+/** span por breakpoint (mobile-first; cada nível herda o anterior se ausente). */
+interface ResponsiveSpan {
+    base: number;
+    sm?: number;
+    md?: number;
+    lg?: number;
+    xl?: number;
+}
+/** spans preenchidos pra todos os breakpoints (forward-fill). */
+interface FilledSpans {
+    base: number;
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+}
+interface GridFormCell {
+    id: string;
+    /** span no breakpoint base — back-compat + caminho inline (não-responsivo). */
+    span: number;
+    /** spans por breakpoint (forward-filled) — caminho responsivo. */
+    spans: FilledSpans;
+    break?: boolean;
+}
+interface GridFormPlan {
+    columns: number;
+    gap: string | number;
+    /** algum slot varia entre breakpoints? (decide inline vs CSS no renderer). */
+    responsive: boolean;
+    cells: GridFormCell[];
+}
+interface GridFormPlacement {
+    /** número (fixo) ou objeto `{ base, sm, md, lg, xl }` (responsivo). */
+    span?: number | ResponsiveSpan;
+    break?: boolean;
+    index?: number;
+}
+interface GridFormOptions {
+    columns?: number;
+    gap?: string | number;
+}
+declare function gridFormPlanner(opts?: GridFormOptions): LayoutPlanner;
+/** planners default (`fragment` · `section` · `grid-form`). */
+declare function defaultPlanners(): Record<string, LayoutPlanner>;
+
+interface ResolveTreeOptions {
+    registry: DescriptorRegistry;
+    resolver?: Resolver;
+    binder?: BindingEngine;
+    planners?: Record<string, LayoutPlanner>;
+    /** layout usado quando o nó/descriptor não declara um. */
+    defaultLayout?: string;
+}
+/**
+ * O PIPELINE headless do COMPOSITOR: `bind` (pré-passo) → `resolve` (type→descriptor+props) →
+ * `plan` (layout). Produz uma `ResolvedNode` — DADOS puros. Compõe componentes REGISTRADOS +
+ * elementos intrínsecos (`el`) + data-binding. **Não conhece componente custom** — a expansão
+ * de `ComponentDef` é do construtor (`forge`), que entrega uma árvore pura pra cá.
+ *
+ * `el`: `type` vem da tag (`{ el: "div" }`) → `createElement(type, …)` na view (`el: true`).
+ * `fallback:"drop"` some da árvore E do plano; `unknown` permanece (a view degrada).
+ */
+declare function resolveTree(node: DefNode, opts: ResolveTreeOptions, scope?: unknown): ResolvedNode;
+
+/** Percorre em pré-ordem. `visit(node, parent)` — `parent` é `null` na raiz. */
+declare function walk(node: DefNode, visit: (node: DefNode, parent: DefNode | null) => void, parent?: DefNode | null): void;
+/** Primeiro nó com o `id` dado (busca em profundidade). */
+declare function findById(root: DefNode, id: string): DefNode | undefined;
+/** Caminho de ids da raiz ao alvo (inclusive), ou `null`. */
+declare function pathToId(root: DefNode, id: string): string[] | null;
+/** Mapeia a árvore imutavelmente, bottom-up (filhos já transformados quando `fn` roda). */
+declare function mapNodes(node: DefNode, fn: (node: DefNode) => DefNode): DefNode;
+
+/** O papel de um campo do `DefNode` na travessia. */
+type FieldRole = 
+/** identidade — nunca tocada. */
+"identity"
+/** dado do documento: nome de tipo, tag, layout. Não é código, não é subárvore. */
+ | "data"
+/** carrega nó(s) — a travessia desce por aqui. */
+ | "tree"
+/** aceita EXPRESSÃO — ver `SLOTS`. */
+ | "slot";
+declare const FIELDS: Readonly<Record<keyof DefNode, FieldRole>>;
+/** Onde, dentro do campo, os valores compiláveis estão. */
+type SlotShape = 
+/** o próprio valor do campo. */
+"value"
+/** um mapa de INTENÇÕES (`events`, `commands`); o valor é o `params` de cada entrada. */
+ | "intentParams";
+interface SlotDecl {
+    shape: SlotShape;
+    /** o que o slot espera render. O checker usa isto como `resultType`; `unknown` = não restringe. */
+    expects: "boolean" | "unknown";
+    /**
+     * Em que estágio do bind o slot é resolvido.
+     *
+     * `structural` muda a ÁRVORE e é consumido (não aparece na saída) — `each` repete o nó,
+     * `when` o dropa. `value` liga o campo NO LUGAR. Sem isto, quem liga valores teria de
+     * lembrar de excluir os estruturais à mão, que é a forma de esquecimento que esta tabela
+     * existe para impedir.
+     */
+    stage: "value" | "structural";
+    /**
+     * Se `{% %}` e `{# #}` são marcação neste slot, além do `{{ }}`.
+     *
+     * O dado não se auto-declara: é o slot que diz o que uma string dele pode conter. Hoje
+     * nenhum slot aceita controle de fluxo — `{%` e `{#` são texto em todos —, e a coluna existe
+     * para que a compilação pergunte à tabela, e não a um padrão implícito.
+     */
+    directives: boolean;
+}
+declare const SLOTS: Readonly<Record<string, SlotDecl>>;
+/** Este campo aceita expressão? Campo fora da tabela NÃO tem porta: expressão ali é erro,
+ *  e a resposta sai sem avaliar nada. */
+declare const isSlot: (field: string) => boolean;
+/** A declaração do slot, ou `undefined` se o campo não é um. */
+declare const slotOf: (field: string) => SlotDecl | undefined;
+/** Como cada campo `tree` carrega nó: uma lista, ou um nó só. */
+type TreeShape = "list" | "node";
+/** Os campos por onde a travessia desce em busca de mais nós. Um campo `tree` novo entra aqui
+ *  e todo mundo que anda a árvore passa a cobri-lo — travessia divergente é o bug que só
+ *  aparece quando um campo novo entra. */
+declare const TREE: Readonly<Record<string, TreeShape>>;
+
+export { type ActionOutcome, type ActionPort, type ActionResult, type AddressPort, type BindingEngine, type CapabilityPort, type CommandAlias, type CommandScope, type DefNode, type Descriptor, type DescriptorRegistry, EMPTY_COMMANDS, type EventBinding, FIELDS, type FieldRole, type FilledSpans, type FragmentPlan, type GridFormCell, type GridFormOptions, type GridFormPlacement, type GridFormPlan, type IntentRuntime, type LayoutPlanner, type NodeOrigin, type PlannerChild, type ResolveCtx, type ResolveResult, type ResolveTreeOptions, type ResolvedLayout, type ResolvedNode, type Resolver, type ResponsiveSpan, SLOTS, type SectionOptions, type SectionPlan, type SlotDecl, type SlotShape, TREE, type TreeShape, type TypeChecker, type TypeResolverOptions, type ValidationIssue, type ValidationProvider, aliasOf, commandScope, createDescriptorRegistry, createTypeResolver, defaultPlanners, dispatchIntent, findById, fragmentPlanner, gridFormPlanner, identityBinder, intentParams, intentsOf, isSlot, mapNodes, noopValidator, pathToId, resolveIntent, resolveTree, runIntent, sectionPlanner, slotOf, walk };