@loom-forge/check 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,478 @@
+import { Schema } from '@tslite/type-core';
+import { TypeChecker, ResolvedNode, DescriptorRegistry } from '@loom-forge/core';
+import { Env, Anchors, CheckResult } from '@tslite/checker';
+import { ComponentDef, PropsDecl, CompiledPath, TypeRef, ComponentIR, SystemIR, CompiledDefinition, Mounting } from '@loom-forge/forge';
+import { Expression } from '@tslite/core';
+import { CompileDiagnostic, CompiledIsland } from '@loom-forge/tslite/compile';
+import { CapabilityProfile } from '@tslite/capability';
+import { Span } from '@tslite/language-service';
+
+interface TsliteChecker extends TypeChecker {
+    /** infere o Schema (forma) de um valor/dados (escalares alargam à base). */
+    inferType(value: unknown): Schema;
+    /** JSON Schema → Schema do TSLite. */
+    fromJsonSchema(jsonSchema: unknown): Schema;
+    /** Schema do TSLite → JSON Schema. */
+    toJsonSchema(schema: Schema): unknown;
+    /** a forma de `value` é atribuível ao tipo descrito por `jsonSchema`? (infer + subtype) */
+    assignable(value: unknown, jsonSchema: unknown): boolean;
+    /** representação textual de um Schema (diagnóstico). */
+    format(schema: Schema): string;
+}
+declare function createTsliteChecker(): TsliteChecker;
+interface DataflowIssue {
+    nodeId: string;
+    type: string;
+    /** tipo declarado pelo descriptor (props esperadas). */
+    expected: string;
+    /** forma efetiva das props resolvidas. */
+    got: string;
+}
+/**
+ * Percorre uma `ResolvedNode` e checa, em cada nó, se as props resolvidas são atribuíveis
+ * ao `schema` declarado no descriptor (quando há). É a verificação ponta-a-ponta da
+ * Linguagem: a mesma máquina que, com o actions plugado, prova `action.return ≤ props`.
+ */
+declare function checkTree(node: ResolvedNode, registry: DescriptorRegistry, checker: TsliteChecker): DataflowIssue[];
+
+/**
+ * O nome do asserter no escopo: `parseAs`, publicado pelo `@tslite/validate`. Não é `parse` porque
+ * a stdlib já tem um — o `JSON.parse` (`(text: string) => unknown`) —, e os dois consumidores do
+ * TSLite chegaram ao mesmo nome pelo mesmo obstáculo.
+ */
+declare const DEFAULT_ASSERTER: string;
+interface BuildEnvOptions {
+    /**
+     * O catálogo de contextos do sistema — `nome → tipo`. A raiz `ctx` do componente é a
+     * **projeção** dele: catálogo ∩ `context.uses`.
+     *
+     * É assim que se tipa um escopo DINÂMICO: o **valor** vem da posição (quem montou), o
+     * **tipo** é global. Se cada provedor declarasse o tipo, o tipo do consumidor dependeria de
+     * qual provedor está acima — tipagem dinâmica, e aí não há prova.
+     *
+     * Sem catálogo, `ctx` não é raiz: um `ctx` vazio resolvendo `undefined` em silêncio seria
+     * pior que a ausência.
+     */
+    contexts?: Record<string, Schema>;
+    /** o tipo dos dados do host — a raiz `data` do render. Sem ele, `data` não é raiz. */
+    data?: Schema;
+    /** substitui a stdlib. Para acrescentar, espalhe: `{ ...vanilla, meu }`. */
+    operators?: Record<string, Schema>;
+    /**
+     * o catálogo de tipos NOMEADOS. Cada um entra como híbrido (valor + tipo) e habilita
+     * o asserter: `{{ parseAs(Address, data.x) }}` rende `Address` em vez de `unknown`.
+     * O mesmo catálogo precisa estar no `globals` do binder para a prova acontecer.
+     *
+     * Ele vale também como `TypeRef` nas DECLARAÇÕES — `props: { addr: "Address" }`.
+     */
+    types?: Record<string, Schema>;
+}
+/**
+ * Monta o `Env` de um componente a partir das declarações. As raízes são as mesmas do
+ * runtime — `props`, `state`, e `data` quando o chamador declara o tipo dos dados —, o
+ * que é o que faz o que o checker prova valer para o que o binder executa.
+ */
+declare function buildEnv(def: ComponentDef, opts?: BuildEnvOptions): Env;
+/**
+ * O `Env` do `init` — o escopo que SEMEIA o estado.
+ *
+ * Ele tem `props` e `ctx`, e **não** tem `state` (é o que está sendo definido) nem `params` (não
+ * há chamada). É a mesma projeção que o runtime passa ao `initState`, e é por isso que ele existe
+ * separado: no env do corpo, um `init` lendo `state` tiparia limpo e valeria `undefined`.
+ */
+declare function buildInitEnv(def: ComponentDef, opts?: BuildEnvOptions): Env;
+
+/** O catálogo de tipos NOMEADOS — o mesmo que o `buildEnv` recebe. Um nome declarado aqui vale
+ *  como `TypeRef` numa declaração (`props: { addr: "Address" }`). */
+type TypeCatalog = Record<string, Schema>;
+/**
+ * `TypeRef` (nome do catálogo | shorthand escalar | Schema do TSLite | JSON Schema) → Schema.
+ *
+ * O que NÃO resolve vira **`unknown`**, não `any`. `any` desligaria toda a prova daquela prop em
+ * silêncio — call-site, membro, span —, e um erro de digitação na declaração apagaria a máquina
+ * inteira sem dizer nada. `unknown` obriga o programa a lidar; quem diz o que houve é o
+ * `checkDeclarations`, que reporta o nome que não existe.
+ */
+declare function resolveTypeRef(ref: TypeRef, types?: TypeCatalog): Schema;
+/**
+ * `PropsDecl` → Schema de objeto. Prop com nome terminando em `?` é OPCIONAL (`{ "title?": … }`)
+ * — TS-like, JSON-native; o `?` é tirado do nome e marca `optional`.
+ *
+ * **Opcional aqui significa `T | undefined`**, e a razão é do MEIO, não de leniência: uma prop
+ * viaja como JSON, e em JSON `undefined` não existe — `{}` e `{ body: undefined }` são o mesmo
+ * documento. Distinguir "ausente" de "presente e indefinido" (o que o `exactOptionalPropertyTypes`
+ * do tsc faz, e o que o `subtype` do TSLite implementa) é uma distinção que este formato não
+ * consegue expressar. Sem isso, passar um campo opcional de um dado para uma prop opcional —
+ * o caso mais comum que existe — não tiparia.
+ */
+declare function resolveProps(props: PropsDecl | undefined, types?: TypeCatalog): Schema;
+/**
+ * O TIPO de um componente — o que ele declara sobre si.
+ *
+ * Não carrega tags: tag é **fato** derivado sobre a árvore, não tipo, e desde a separação
+ * árvore × fatos ela mora em `@loom-forge/forge` (`effectiveTags(sys.facts, id)`, que é a
+ * propagada — mais útil que a própria). Uma função que resolve o TIPO não deve ser a porta
+ * dos fatos.
+ */
+interface ComponentType {
+    props: Schema;
+    category?: string;
+    entry: boolean;
+}
+/** Resolve o TIPO de um `ComponentIR`: props → Schema, mais categoria e entry. */
+declare function componentType(ir: ComponentIR, types?: TypeCatalog): ComponentType;
+/** Contrato no eixo de PROPS (`Component<C>`): o conjunto de props que o componente precisa
+ *  aceitar — mesma forma de `ComponentDef.props` (um `PropsDecl`). */
+interface ComponentContract {
+    props?: PropsDecl;
+}
+/**
+ * O componente `child` satisfaz o contrato (eixo de props)? `subtype(child.props, contrato)`
+ * — um componente com props MAIS amplas serve onde se exige menos (estrutural). É a máquina
+ * de `child ≤ Component<C>` e do `action.return ≤ component.props`. Os eixos estruturais
+ * (categoria/tags/cardinalidade/leaf) ficam no `checkSlots`.
+ */
+declare function componentAssignable(child: ComponentType, contract: ComponentContract, types?: TypeCatalog): boolean;
+/**
+ * As DECLARAÇÕES de um componente também são conferidas — `props` e `state`.
+ *
+ * Um `TypeRef` que não resolve é o furo mais caro que restava: ele não quebra nada na hora, e
+ * desliga a prova daquela prop para sempre. O endereço é o da declaração (`props.n`,
+ * `state.aberto`), não o de um nó — não há nó: é a superfície do componente.
+ */
+declare function checkDeclarations(def: {
+    props?: PropsDecl;
+    state?: Record<string, {
+        type: TypeRef;
+    }>;
+}, types?: TypeCatalog): DeclarationIssue[];
+/**
+ * O resolvedor do catálogo de contextos: `nome → Schema`. É o que tipa a raiz `ctx` e o que
+ * prova um `provides`.
+ *
+ * **Um contrato de contexto precisa ser SERIALIZÁVEL** — dado, não comportamento. Efeito já
+ * tem porta aqui (`events` → `ActionPort`), e uma função no contexto seria uma segunda, que
+ * não cria aresta no grafo e some da análise. O predicado é o `isSerializable` do
+ * `@tslite/type-core`; um contrato que não passa vira `undefined` (não tipa), e quem acusa é o
+ * `checkContextCatalog`.
+ */
+declare function declaredContextsOf(catalog: Record<string, TypeRef> | undefined, types?: TypeCatalog): (name: string) => Schema | undefined;
+/**
+ * O catálogo de contextos, conferido: um contrato que não resolve, ou que não é dado
+ * serializável, não é contrato.
+ */
+declare function checkContextCatalog(catalog: Record<string, TypeRef> | undefined, types?: TypeCatalog): DeclarationIssue[];
+/**
+ * O resolvedor de `params` dos UPDATES locais de um componente: `action` → o `Schema` declarado.
+ * Ausente para o update que não os declara (e para a ação do host, que não mora aqui).
+ */
+declare function declaredParamsOf(updates: Record<string, {
+    params?: PropsDecl;
+}> | undefined, types?: TypeCatalog): (action: string) => Schema | undefined;
+/**
+ * O tipo de um `set` de ação local: o estado declarado, com **tudo opcional**.
+ *
+ * Um `set` é uma atualização PARCIAL — escrever um campo não obriga a escrever os outros. É o
+ * mesmo mecanismo do call-site, sobre outra superfície: o objeto vai anotado com este tipo, e o
+ * motor acusa `not-assignable` no campo com o tipo errado e `excess-property` na chave que o
+ * estado não declara.
+ *
+ * O `optional` aqui é por outra razão que o das props, e por isso o tipo NÃO ganha `| undefined`:
+ * o campo do estado não é opcional — a ESCRITA é que é parcial. Escrever `undefined` num campo
+ * `number` continua errado.
+ */
+declare function partialStateType(state: Record<string, {
+    type: TypeRef;
+}> | undefined, types?: TypeCatalog): Schema;
+/** um `TypeRef` que não resolve. Mesma forma do `CheckIssue`, sem `span`: não há texto onde
+ *  pousar — a declaração É o nome. */
+interface DeclarationIssue {
+    code: "unknown-type-name";
+    message: string;
+    severity: "error";
+    /** o caminho da declaração: `["props", "n"]`, `["state", "aberto"]`, `["contexts", "@app/x"]`. */
+    path: CompiledPath;
+    address: string;
+    source: string;
+}
+/**
+ * O resolvedor de props para o call-site: `type` → o `Schema` que o componente declara.
+ *
+ * É o seam entre o `SystemIR` (quem sabe o que existe) e o lowering (que é transformação de
+ * forma e não conhece registry). Memoiza: o mesmo chamado aparece em muitos call-sites.
+ */
+declare function declaredPropsOf(sys: SystemIR, types?: TypeCatalog): (type: string) => Schema | undefined;
+/**
+ * O tipo declarado de cada chave do estado — o que o `init` dela tem de render.
+ *
+ * É o mesmo `resolveTypeRef` das props: o `init` é uma expressão como qualquer outra, e o tipo
+ * contra o qual ela é provada é o que o autor declarou ao lado.
+ */
+declare function stateTypeOf(state: Record<string, {
+    type: TypeRef;
+}> | undefined, types?: TypeCatalog): (key: string) => Schema | undefined;
+
+/** A definição compilada pela linguagem, com o que ela disse — o que o lowering consome. */
+type CompiledComponent = CompiledDefinition<CompileDiagnostic, CompiledIsland>;
+/**
+ * A âncora de um nó do corpo baixado é o CAMINHO do campo que o produziu — a lista
+ * (`[0, 1, "props", "title"]`, `["updates", "somar", "set", "n"]`), em que índice e chave são
+ * distintos no tipo. O endereço (`#0.1.props.title`) é derivado dela; o texto do campo, quando
+ * há um, mora ao lado, em `texts`.
+ */
+type NodeMap = Anchors<CompiledPath>;
+/** Uma raiz de expressão que o checker vai tipar, e de onde ela veio. */
+interface LoweredIsland {
+    readonly node: Expression;
+    readonly path: CompiledPath;
+    readonly address: string;
+    /** o texto do campo, como o autor o escreveu. Ausente quando a ilha já chegou compilada. */
+    readonly source?: string;
+}
+interface Lowered {
+    /** o corpo tipável. Entregue ao `check` como está — nunca impresso no caminho. */
+    program: Expression;
+    /** os `init` do estado, num corpo à parte: eles têm OUTRO escopo (`props` e `ctx`, só). */
+    inits?: Expression;
+    /** nó → caminho do campo, por identidade. */
+    anchors: NodeMap;
+    /** endereço → o texto do campo, para o span pousar nele. Inclui os nomes declarados (`as`). */
+    texts: ReadonlyMap<string, string>;
+    /**
+     * Endereço → o BLOCO do corpo baixado em que os slots daquele lugar foram emitidos: o de cada nó
+     * (`#0.1` — o bloco do `map` do `each` mais próximo, ou o do corpo) e o de cada update
+     * (`updates.somar` — o frame com `params`). É a porta para o escopo de um campo: o `scopeAt`
+     * do checker sobre esse bloco responde que nomes o campo enxerga, pela mesma análise que o tipa
+     * — inclusive para um campo vazio ou que não compilou. O que não está aqui (`effects`, o
+     * `provides` e os `commands` do componente) vive no bloco raiz de `program`; os `init`, em
+     * `inits`.
+     */
+    frames: ReadonlyMap<string, object>;
+    /** as raízes de expressão tipadas, na ordem em que foram emitidas. */
+    islands: readonly LoweredIsland[];
+    /** a definição que foi baixada — a compilada, com o que a compilação reclamou. */
+    compiled: CompiledComponent;
+    /**
+     * Endereços cujo `excess-property` não é confiável — a assinatura daquela ação pode ter
+     * envelhecido (ver `exhaustiveParams`). Quem julga é o `checkComponent`: ali o veredito vira
+     * aviso em vez de erro.
+     */
+    weak: ReadonlySet<string>;
+}
+/** A forma de um `each`: coleção (vira `map`) ou objeto (vira aplicação direta). */
+type DataShape = "list" | "value";
+interface LowerOptions {
+    /**
+     * A definição já COMPILADA pela linguagem — o mesmo artefato que a bancada mostra e o bind
+     * executa. Ausente, o lowering compila (`compileDefinition` com o `compile` da linguagem, sem
+     * profile: o eixo de sintaxe não é do check). Quem compilou uma vez passa o resultado, e a
+     * string não é derivada duas vezes.
+     */
+    compiled?: CompiledComponent;
+    /**
+     * A forma de cada `each` — quem chama sabe, porque já tipou a expressão.
+     * Default `"list"`: o caso do laço, que é o que o `as` existe para nomear.
+     */
+    shapeOf?: (expression: Expression) => DataShape;
+    /**
+     * *"Que props este componente declara?"* — a pergunta que o lowering FAZ e não responde.
+     *
+     * Ele é transformação de forma: não conhece registry, `SystemIR` nem `Schema`. Quem sabe é
+     * quem montou o sistema, e o seam entre os dois é este resolvedor (a mesma natureza do
+     * `TargetResolver` do `checker-v2`).
+     *
+     * **Ausente = nenhum call-site é tipado**, e não "todos falham": quem chama o lowering só
+     * para VER o corpo baixado não tem sistema para perguntar, e inventar um erro ali esconderia
+     * justamente o que essa pessoa foi olhar.
+     */
+    propsOf?: (type: string) => Schema | undefined;
+    /**
+     * O tipo declarado de cada contexto — o catálogo do sistema. É contra ele que um
+     * `provides` é provado: mesma máquina do call-site, quinta superfície.
+     * Ausente = as provisões não são tipadas.
+     */
+    contextOf?: (name: string) => Schema | undefined;
+    /**
+     * O tipo de um `set` de update local — o estado declarado, com tudo opcional
+     * (`partialStateType`). Ausente = as ações não são tipadas.
+     */
+    setType?: Schema;
+    /**
+     * O tipo dos `params` de cada update local, quando ela os declara. É o que tipa o corpo do update
+     * e o call-site do evento que a dispara. Sem declaração, `params` vale `unknown`.
+     */
+    paramsOf?: (action: string) => Schema | undefined;
+    /**
+     * A assinatura daquela ação é EXAUSTIVA? (default: sim)
+     *
+     * Só uma prova depende disso: "esta chave não existe". Com uma assinatura que pode divergir do
+     * que a implementação aceita — o `declared` do contrato —, acusar `excess-property` como ERRO é
+     * afirmar mais do que se sabe. Então o endereço entra em `weak`, e o julgamento vira aviso.
+     */
+    exhaustiveParams?: (action: string) => boolean;
+    /**
+     * O tipo declarado de cada chave do estado — o que o `init` dela tem de render.
+     *
+     * O `init` SEMEIA o estado a partir de `props`/`ctx`, e por isso ele é baixado num programa
+     * SEPARADO: o escopo dele não tem `state` (é o que está sendo definido) nem `params`. Tipar os
+     * dois no mesmo corpo deixaria passar um `init` que lê `state`, que em runtime é `undefined`.
+     */
+    stateTypeOf?: (key: string) => Schema | undefined;
+    /**
+     * O tipo do valor que um componente REGISTRADO emite num evento — `descriptor.meta.emits`.
+     *
+     * É o tipo da raiz `event` nos `params` desse evento (ADR-018). Sem declaração, `event` é
+     * `unknown` — e `unknown` num param tipado é acusado: quem não declarou o que emite não ganha
+     * um tipo de graça. Declarar é do kit; provar (`parseAs`) é do autor.
+     */
+    emitsOf?: (type: string, event: string) => Schema | undefined;
+    /**
+     * O tipo do que uma ação do HOST devolve — o `resultOf` do Tier 1 da porta. É o tipo da raiz
+     * `event` no `then` da intenção que a executou. Sem declaração, `unknown`.
+     */
+    resultOf?: (action: string) => Schema | undefined;
+    /**
+     * A montagem do SISTEMA (`mountingOf` do `@loom-forge/forge`) — o que responde o que um nome de
+     * comando EXECUTA num nó: o vocabulário que um chamado instala no próprio `$slot`, e os nomes
+     * que algum vocabulário declara.
+     *
+     * **Ausente = o documento é o sistema.** O que ele declara resolve dentro dele, um chamado
+     * desconhecido não tem slot, e um nome que só outro componente declararia vale como o id da
+     * porta — que é tudo o que dá para saber sem o resto.
+     */
+    mounting?: Pick<Mounting, "slotScopesOf" | "vocabulary">;
+}
+/** Baixa uma definição de componente num corpo TSL. */
+declare function lowerComponent(authored: ComponentDef, opts?: LowerOptions): Lowered;
+
+/**
+ * O profile que vai ao `@tslite/checker`, a partir do profile do deploy: a sintaxe da Linguagem
+ * inteira e o eixo `types` do deploy. Sem `types` no deploy, vale o do `complete` (sem `strict`).
+ */
+declare const checkerProfileOf: (deploy: CapabilityProfile) => CapabilityProfile;
+
+interface CheckIssue {
+    /** o código do checker (`no-such-member`, `unknown-name`, `not-assignable`…). */
+    code: string;
+    message: string;
+    severity: "error" | "warning";
+    /** o caminho do campo, como lista: `[0, 1, "props", "title"]` na árvore (a raiz é o nó `0`),
+     *  `["updates", "somar", "set", "n"]` fora dela. Índice e chave são distintos no tipo. */
+    path: CompiledPath;
+    /** o caminho como o autor o lê: `#0.1.props.title`. Derivado de `path`. */
+    address: string;
+    /** o texto do campo, como o autor o escreveu — com o `{{ }}`, quando há. Ausente quando o
+     *  campo já vinha compilado. */
+    source?: string;
+    /** offsets dentro de `source`, na forma do `@tslite/language-service` (fim exclusivo) —
+     *  `source.slice(span.from, span.to)` é o trecho aceso. */
+    span?: Span;
+}
+interface CheckComponentOptions {
+    /** limites estruturais — o drawer do editor roda isto por tecla digitada. */
+    limits?: {
+        maxDepth?: number;
+        maxNodes?: number;
+    };
+    /**
+     * A definição já COMPILADA pela linguagem (`compileDefinition(def, compile)`), quando quem
+     * chama já a tem — a bancada, o serviço de linguagem. A string não é derivada duas vezes, e os
+     * diagnósticos da compilação são de quem compilou: com `compiled`, este check não os repete.
+     * Ausente, o check compila (sem profile — o eixo de sintaxe não é dele) e os reporta.
+     */
+    compiled?: CompiledComponent;
+    /**
+     * O `CapabilityProfile` do DEPLOY — o mesmo que o binder executa. Default: `DEFAULT_PROFILE`
+     * do `@loom-forge/tslite`.
+     *
+     * Daqui sai só o eixo de TIPOS (`types.strict`): o `any` autorado e o cast que estreita
+     * (`{{ (props.bruto as Endereco).cep }}` é `narrowing-cast-not-allowed`). O eixo de sintaxe —
+     * que nós a expressão pode conter — é da compilação, e acusá-lo aqui de novo seria o mesmo
+     * erro duas vezes no campo. Ver `profile.ts`.
+     */
+    profile?: CapabilityProfile;
+    /**
+     * O tipo de props que cada componente CHAMADO declara — o que liga o call-site.
+     *
+     * `declaredPropsOf(systemIR)` monta este resolvedor. **Ausente = nenhum call-site é tipado**:
+     * sem sistema não há o que comparar, e inventar um erro ali seria pior que o silêncio.
+     */
+    propsOf?: (type: string) => Schema | undefined;
+    /** o catálogo de tipos nomeados — o MESMO que foi para o `buildEnv`. Sem ele, um `TypeRef`
+     *  que seja nome de tipo é reportado como desconhecido, porque daqui ele não existe. */
+    types?: TypeCatalog;
+    /** o catálogo de CONTEXTOS do sistema (`nome → TypeRef`) — o que tipa um `provides`.
+     *  Ausente = as provisões não são provadas contra nada. */
+    contexts?: Record<string, TypeRef>;
+    /**
+     * O que cada componente REGISTRADO emite num evento (`descriptor.meta.emits`) — o tipo da raiz
+     * `event` nos `params` desse evento (ADR-018). Sem declaração, `event` é `unknown`, e `unknown`
+     * num param tipado é acusado: quem não declarou o que emite não ganha um tipo de graça.
+     */
+    emitsOf?: (type: string, event: string) => Schema | undefined;
+    /**
+     * A PORTA de ação do host — de onde sai a assinatura de uma ação que não é update local.
+     *
+     * Basta ter o `paramsOf` do Tier 1 (`ActionPort`, commander, ou um objeto com o método). Com
+     * ele, `events.params` de uma ação do host vira um call-site como o de componente: obrigatória
+     * faltando, tipo errado, chave a mais. **Ausente = a ação do host não é tipada** — e isso é
+     * silêncio, não erro: quem não publica assinatura não afirmou nada.
+     */
+    actions?: {
+        paramsOf?(action: string): unknown;
+        /** a forma do RETORNO, em JSON Schema — o tipo do `event` no `then` de quem a executa (ADR-018). */
+        resultOf?(action: string): unknown;
+        /** quanto vale a resposta — ver `ActionPort.provenanceOf`. Ausente = `declared`. */
+        provenanceOf?(query: string): string;
+    };
+    /**
+     * A montagem do sistema — `mountingOf(sys.components.values())`, do `@loom-forge/forge`. É o
+     * que responde o que um nome de COMANDO executa: um evento dentro do slot de uma sessão é
+     * provado contra a ação que o vocabulário da sessão escolhe.
+     *
+     * **Ausente = o documento é o sistema:** o que ele declara resolve dentro dele, e o resto vale
+     * como o id da porta.
+     */
+    mounting?: LowerOptions["mounting"];
+}
+/**
+ * A análise de um componente — o que o `checkComponent` deriva os issues, exposto para quem
+ * projeta OUTRA coisa da mesma passada: o serviço de linguagem lê o `overlay` do corpo para
+ * responder o escopo de um campo (`scopeAt` sobre `lowered.frames`), sem tipar de novo.
+ */
+interface ComponentAnalysis {
+    /** os diagnósticos, ao campo — o que o `checkComponent` devolve. */
+    readonly issues: readonly CheckIssue[];
+    readonly lowered: Lowered;
+    /** o resultado do checker sobre o corpo: o overlay de tipo e escopo por nó. */
+    readonly body: CheckResult;
+    /** o `Env` que semeia o estado (`props` e `ctx`) — o dos `init`, e o de um campo deles. */
+    readonly initEnv: Env;
+    /** idem sobre os `init`, quando há algum. */
+    readonly inits?: CheckResult;
+}
+/**
+ * Tipa todas as expressões de um componente contra o `env`.
+ *
+ * Pega campo que não existe numa raiz (`props.tituloo`), membro que não existe no item de um
+ * `each` — com o tipo do item **inferido** da coleção, sem anotação —, nome livre desconhecido,
+ * `when` que não rende `boolean`, e — com `propsOf` — o CALL-SITE: as props passadas a um
+ * componente custom contra o que ele declara, mesmo vindas de expressão.
+ */
+declare function checkComponent(def: ComponentDef, env: Env, opts?: CheckComponentOptions): CheckIssue[];
+/** A análise inteira — ver `ComponentAnalysis`. O `checkComponent` é a projeção dela. */
+declare function analyzeComponent(def: ComponentDef, env: Env, opts?: CheckComponentOptions): ComponentAnalysis;
+interface CheckExpressionOptions extends CheckComponentOptions {
+    /** o tipo que o slot espera render. Um `when` pede `boolean`. */
+    resultType?: Schema;
+}
+/**
+ * Tipa UMA expressão — o cano por slot, que é o que o drawer do editor liga quando o autor
+ * abre um campo. Roda **por tecla digitada**, daí os `limits`.
+ *
+ * `source` é a expressão nua (sem `{{ }}`); os `span` voltam relativos a ela. `path` é o caminho
+ * do campo que a contém — o issue o devolve, com o endereço derivado.
+ */
+declare function checkExpression(source: string, env: Env, path: CompiledPath, opts?: CheckExpressionOptions): CheckIssue[];
+
+export { type BuildEnvOptions, type CheckComponentOptions, type CheckExpressionOptions, type CheckIssue, type CompiledComponent, type ComponentAnalysis, type ComponentContract, type ComponentType, DEFAULT_ASSERTER, type DataflowIssue, type DeclarationIssue, type Lowered, type LoweredIsland, type NodeMap, type TsliteChecker, type TypeCatalog, analyzeComponent, buildEnv, buildInitEnv, checkComponent, checkContextCatalog, checkDeclarations, checkExpression, checkTree, checkerProfileOf, componentAssignable, componentType, createTsliteChecker, declaredContextsOf, declaredParamsOf, declaredPropsOf, lowerComponent, partialStateType, resolveProps, resolveTypeRef, stateTypeOf };