@tslite/checker 1.6.0 → 1.9.0

package/dist/index.d.cts

@@ -1,145 +1,14 @@
 import { VarSchema, Schema, Schemes, TypeScheme, ObjectSchema, Completion } from './types/index.cjs';
-export { AnySchema, ApplySchema, ArraySchema, Bindings, DEFAULT_TYPE_LIMITS, Discovery, ElementFlag, FnSchema, GuardSig, INSTANTIATION_COUNT_LIMIT, INSTANTIATION_DEPTH_LIMIT, Incompatibility, IncompatibilityKind, IndexSchema, Instantiation, InstantiationLimitError, KeyofSchema, LiteralSchema, MappedSchema, OverloadSchema, Param, PathSegment, Prop, ScalarSchema, TYPE_EVAL_DEPTH_LIMIT, TupleSchema, TypeEvalLimitError, TypeEvalLimits, TypeForm, TypePosition, UnionSchema, UnionTooComplexError, UnknownSchema, VarCandidates, WriteKey, apparentType, asLiteralOrigin, baseLiteralType, bindTypeParams, comparable, configureTypeLimits, contravariantInference, covariantInference, discover, equals, erasedSignature, expand1, flagAt, format, formatTypeArgs, formatTypeDiff, freeVars, groundVars, inferFromCandidates, inferredTypes, instantiate, instantiateInContextOf, instantiateLoose, isMissingType, isNumericLiteralName, isObjectOrArrayLiteral, isScheme, isSerializable, isVariadicTuple, join, joinAll, missingType, normalizeUnion, ownProp, readonlyMember, renameTypeParams, resetInstantiationCount, resetTypeLimits, resolveConditional, resolveOp, resolveTypeOp, restIndex, restTypeAtPosition, s, sampleValue, silentNever, substitute, subtype, typeAtPosition, typeDiff, typeFeatures, typeLimits, typeNeedsParens, typeParamArity, unify, version, widen, widenInferred, widenLiteral, widenOrigin, widenType, withUndefined, withoutUndefined } from './types/index.cjs';
-import { Scope as Scope$1, BaseNode, Node, types, SourceLocation, Expression } from '@tslite/ast';
+export { AnySchema, ApplySchema, ArraySchema, Bindings, Candidates, DEFAULT_TYPE_LIMITS, Discovery, ElementFlag, FnSchema, GuardSig, INSTANTIATION_COUNT_LIMIT, INSTANTIATION_DEPTH_LIMIT, Incompatibility, IncompatibilityKind, IndexSchema, InferencePriority, Instantiation, InstantiationLimitError, KeyofSchema, LiteralSchema, MappedSchema, OverloadSchema, Param, PathSegment, Prop, ScalarSchema, TYPE_EVAL_DEPTH_LIMIT, TupleSchema, TypeEvalLimitError, TypeEvalLimits, TypeForm, TypePosition, UnionSchema, UnionTooComplexError, UnknownSchema, VarCandidates, WriteKey, apparentType, asLiteralOrigin, baseLiteralType, bindTypeParams, comparable, configureTypeLimits, contravariantInference, covariantInference, createInferences, discover, equals, erasedSignature, expand1, flagAt, format, formatTypeArgs, formatTypeDiff, freeVars, groundVars, inferFromCandidates, inferTypes, inferredBindings, inferredTypes, instantiateInContextOf, instantiateLoose, isMissingType, isNumericLiteralName, isObjectOrArrayLiteral, isScheme, isSerializable, isVariadicTuple, join, joinAll, missingType, normalizeUnion, ownProp, readonlyMember, renameTypeParams, resetInstantiationCount, resetTypeLimits, resolveConditional, resolveOp, resolveTypeOp, restIndex, restTypeAtPosition, s, sampleValue, silentNever, substitute, subtype, typeAtPosition, typeDiff, typeFeatures, typeLimits, typeNameOf, typeNeedsParens, typeParamArity, version, widen, widenInferred, widenLiteral, widenOrigin, widenType, withUndefined, withoutUndefined } from './types/index.cjs';
+import { BaseNode, Scope as Scope$1, Node, types, SourceLocation, Expression } from '@tslite/ast';
 import { CapabilityProfile, CompiledProfile } from '@tslite/capability';
 import { Span } from '@tslite/language-service';
 
 /** As declarações de tipo nominal: o nome e os type params, em ordem. */
 type Nominals = Readonly<Record<string, readonly VarSchema[]>>;
 
-/**
- * Um nível de escopo léxico (nome → `Schema`), sobre o `Scope<T>` genérico do
- * `ast` — a mesma cadeia que o `behavior` usa, com o payload do eixo de tipos.
- */
-type Scope = Scope$1<Schema>;
-/** Cria um escopo raiz (sem pai). */
-declare const rootScope: (vars?: Record<string, Schema>) => Scope;
-/** Estende `parent` com novos bindings, criando um escopo filho. */
-declare const childScope: (parent: Scope, vars: Record<string, Schema>) => Scope;
-/** Resolve `name` subindo a cadeia léxica. `undefined` se não existir. */
-declare const lookup: (scope: Scope, name: string) => Schema | undefined;
-/**
- * Todos os nomes visíveis a partir de `scope`, com shadowing — o binding mais
- * interno vence. É o que alimenta o autocomplete de identificadores. Duas
- * chaves moram no mesmo escopo e não são nomes: a que tem `.` é um caminho
- * estreitado por guard (`narrow`, D13), e a que termina em `#` é o tipo
- * DECLARADO de um binding mutável (D63) — nenhum identificador tem esses
- * caracteres.
- */
-declare const visibleNames: (scope: Scope) => Map<string, Schema>;
-/**
- * O ambiente injetado pela aplicação — a fronteira de tipos do sistema.
- * `scope` é a raiz da DI; `types` resolve tipos nomeados em anotações.
- */
-/**
- * O ambiente é **só tipos** (a fronteira da DI). Capability — o que pode ser
- * programado — é ortogonal e mora no `CapabilityProfile` (`@tslite/capability`),
- * passado ao `check` por `{ profile }`. Não há mais noção de capability no Env.
- */
-interface Env {
-    readonly scope: Scope;
-    readonly types: Readonly<Record<string, Schema>>;
-    /** Type schemes parametrizados (`type Pair<A, B> = …`), expandidos sob demanda. */
-    readonly schemes: Schemes;
-    /**
-     * Acessores **indexados por path literal**: nome → schema-base que ele navega.
-     * Ex.: `get` sobre o schema dos States → `get("hp","value")` tipa como
-     * `discover(base, ["hp","value"])`. É como a fronteira tipa leituras de estado
-     * sem `unknown` (o app declara o shape; o checker indexa). Default: nenhum.
-     */
-    readonly accessors?: Readonly<Record<string, Schema>>;
-    /**
-     * **Asserters** (a fronteira sã): nomes de funções cujo retorno é o **tipo do
-     * schema nomeado** no 1º argumento. Ex.: com `parse` aqui, `parse(User, x)`
-     * tipa como `User` (e em runtime o `@tslite/validate` valida o valor). É o
-     * `parse()` estilo zod: fecha `unknown`/complexidade — o tipo "reseta" limpo
-     * na fronteira, **provado** em runtime (≠ `as`). Default: nenhum.
-     */
-    readonly asserters?: ReadonlySet<string>;
-    /**
-     * **Matchers de props** (o diferencial): nomes de funções que checam, em
-     * edit-time, se um **payload** (saída de um serviço de automação / nocode) é
-     * **compatível com as props de um componente** react-like. Ex.: com
-     * `matchesProps` aqui, `matchesProps(Card, request)` extrai as props de `Card`
-     * (`(props) => Element`, agnóstico ao framework — Element é `apply` opaco) e
-     * verifica `request ≤ props` (campos a mais no request são OK; faltar/tipo-errado
-     * em prop obrigatória → diagnóstico `props-mismatch`). Retorna `boolean`. Default:
-     * nenhum.
-     */
-    readonly matchers?: ReadonlySet<string>;
-    /**
-     * **Módulos** (a borda DI NOMEADA): especificador → o `object` Schema dos
-     * exports daquele módulo (`{ map: fn, filter: fn, …, default: … }`). É o D3
-     * estendido a módulos: `import { map } from "@x/ops"` liga `map` ao
-     * `modules["@x/ops"].props.map`. O checker **não resolve** o módulo (sem file
-     * system) — consome o tipo já provido; a *resolução* (qual módulo é o
-     * especificador) é da app (Proposal 005). Default: nenhum.
-     */
-    readonly modules?: Readonly<Record<string, Schema>>;
-    /**
-     * Os aliases da **lib padrão** (`Partial`, `Pick`, `Record`, `Omit`, `ReturnType`…),
-     * o texto do `lib.es5.d.ts` do tsc 3.9.10 com o corte do TSLite (D79). Ficam ABAIXO
-     * de tudo: um tipo do host ou um alias do programa com o mesmo nome os sombreia.
-     * Vazio com `noLib`.
-     */
-    readonly lib?: Schemes;
-    /**
-     * Os tipos **nominais** que um texto de tipo pode citar pelo nome: o nome e os type
-     * params de cada um. São os `interface` da lib (`Array`, `ReadonlyArray`, `Promise`)
-     * e os que o host declara (`Map`, `Element`…). Um nominal é o `apply` opaco (types
-     * TC2): o texto `Promise<User>` e o construtor `s.apply("Promise", [User])` são o
-     * mesmo tipo, e a aridade é cobrada como a de um alias.
-     */
-    readonly nominals?: Nominals;
-}
-/**
- * O que um `Env` tem além das variáveis. Cada campo espelha o de {@link Env}, e
- * todos são opcionais.
- */
-interface EnvOptions {
-    readonly types?: Readonly<Record<string, Schema>>;
-    readonly schemes?: Readonly<Record<string, TypeScheme>>;
-    readonly accessors?: Readonly<Record<string, Schema>>;
-    readonly asserters?: ReadonlySet<string>;
-    readonly matchers?: ReadonlySet<string>;
-    readonly modules?: Readonly<Record<string, Schema>>;
-    /** Os nominais do host, somados aos da lib (ver {@link Env.nominals}). */
-    readonly nominals?: Nominals;
-    /**
-     * Sem a lib padrão — nem os aliases, nem os nominais dela. É o `--noLib` do tsc: os
-     * nomes da lib passam a ser `unknown-name`, como lá.
-     */
-    readonly noLib?: boolean;
-}
-/**
- * Um catálogo (`Record<string, Schema>`) passado no lugar das opções é o erro que a
- * forma antiga convida (`createEnv(vars, types)`), e o TypeScript o aceitaria em
- * silêncio: um tipo com índice de string cabe num objeto de opções todas
- * opcionais. Este tipo o recusa na compilação — `keyof` de um catálogo é `string`.
- */
-type NoCatalog<O> = string extends keyof O ? never : unknown;
-/**
- * Cria um `Env`: as variáveis injetadas (a raiz da DI) e, por nome, o resto —
- * tipos nomeados, type schemes, acessores, asserters, matchers, módulos.
- * Capability é separada (passe um `profile` ao `check`).
- *
- * As opções são NOMEADAS porque a forma posicional já custou um defeito: uma
- * chamada que parava no quarto argumento compilava, e o asserter (o quinto) ficava
- * fora do ambiente — `parseAs` virava `unknown-name` só naquele lugar. Uma chave
- * fora do vocabulário (um catálogo no lugar das opções, um `type` no lugar de
- * `types`) é `invalid-env-options`, na montagem: o `Env` não nasce com uma metade
- * calada.
- */
-declare const createEnv: <O extends EnvOptions = EnvOptions>(vars?: Readonly<Record<string, Schema>>, options?: O & NoCatalog<O>) => Env;
-/** Os erros que a MONTAGEM do ambiente lança (o `check` em si nunca lança — D2). */
-type CheckerErrorCode = "invalid-env-options";
-/** Resolve um tipo nomeado (`type User = …`) declarado no ambiente. */
-declare const resolveNamed: (env: Env, name: string) => Schema | undefined;
-/** Resolve um type scheme (`type Pair<A, B> = …`) declarado no ambiente. */
-declare const resolveScheme: (env: Env, name: string) => TypeScheme | undefined;
-
 type Severity = "error" | "warning";
-type DiagnosticCode = "not-assignable" | "unknown-name" | "not-callable" | "no-such-member" | "not-object" | "possibly-nullish" | "unknown-value" | "const-needs-init" | "cannot-redeclare" | "circular-type-alias" | "circular-type-annotation" | "unknown-module" | "not-a-schema" | "type-as-value" | "asserter-needs-name" | "shadows-schema" | "missing-argument" | "excess-argument" | "excess-property" | "spread-argument" | "required-after-optional" | "not-iterable" | "not-spreadable" | "overwritten-property" | "implicit-any" | "props-mismatch" | "no-matching-overload" | "constraint-violation" | "wrong-type-argument-count" | "unsupported" | "unused-name" | "assign-to-const" | "for-in-destructuring" | "readonly-write" | "cast-unsound" | "unprovable-value" | "not-arithmetic-operand" | "operator-not-applicable" | "implicit-coercion" | "node-not-allowed" | "name-not-allowed" | "type-feature-not-allowed" | "any-not-allowed" | "narrowing-cast-not-allowed" | "too-deep" | "too-complex-union" | "too-large" | "wrong-result-type";
+type DiagnosticCode = "not-assignable" | "unknown-name" | "not-callable" | "no-such-member" | "not-object" | "possibly-nullish" | "unknown-value" | "const-needs-init" | "cannot-redeclare" | "circular-type-alias" | "circular-type-annotation" | "unknown-module" | "not-a-schema" | "type-as-value" | "asserter-needs-name" | "shadows-schema" | "missing-argument" | "excess-argument" | "excess-property" | "spread-argument" | "required-after-optional" | "not-iterable" | "not-spreadable" | "overwritten-property" | "implicit-any" | "props-mismatch" | "no-matching-overload" | "constraint-violation" | "wrong-type-argument-count" | "unsupported" | "unused-name" | "assign-to-const" | "for-in-destructuring" | "for-in-not-object" | "readonly-write" | "cast-unsound" | "unprovable-value" | "not-arithmetic-operand" | "operator-not-applicable" | "no-overlap" | "uncalled-function-check" | "not-comparable" | "misplaced-namespace" | "misplaced-modifier" | "ambient-initializer" | "ambient-statement" | "used-before-assigned" | "used-before-declaration" | "implicit-coercion" | "node-not-allowed" | "name-not-allowed" | "type-feature-not-allowed" | "any-not-allowed" | "narrowing-cast-not-allowed" | "too-deep" | "too-complex-union" | "too-large" | "wrong-result-type";
 /**
  * A **classe** do diagnóstico — espelha a divisão de passes do `tsc` (que nós
  * fundimos num walk só): `semantic` é o que o **binder** do tsc pega (validade do
@@ -216,6 +85,22 @@ interface Diagnostic {
  * deriva do `code` (mesma fonte única).
  */
 declare const makeDiagnostic: (code: DiagnosticCode, node: BaseNode, message: string, severity?: Severity) => Diagnostic;
+/**
+ * Um diagnóstico do AMBIENTE (D93): o erro no contrato que o host declara pelo `createEnv` —
+ * o equivalente dos erros de um `.d.ts` no tsc, que são do arquivo de declarações, e não do
+ * programa que o usa. O ambiente não tem nó: o lugar é o caminho dentro das opções do
+ * `createEnv` — a opção, a chave, e o caminho no `Schema` até o nome (`["vars",
+ * "state.phase"]`, `["schemes", "state.R", "body", "props", "a", "type"]`).
+ */
+interface EnvDiagnostic {
+    readonly code: DiagnosticCode;
+    /** A classe do diagnóstico (deriva do `code`) — ver {@link DiagnosticKind}. */
+    readonly kind: DiagnosticKind;
+    readonly severity: Severity;
+    readonly message: string;
+    /** Onde, no ambiente: a opção, a chave e o caminho no `Schema`. */
+    readonly path: readonly (string | number)[];
+}
 /**
  * Fábricas de diagnósticos. Mensagens no estilo do tsc, com tipos renderizados
  * por `format`.
@@ -250,13 +135,37 @@ declare const diag: {
      */
     unknownValue: (node: BaseNode) => Diagnostic;
     constNeedsInit: (node: BaseNode) => Diagnostic;
+    /** TS1182: o padrão sem valor, de qualquer kind, fora do contexto ambiente — o
+     *  `checkGrammarVariableDeclaration` o testa antes do TS1155. */
+    destructuringNeedsInit: (node: BaseNode) => Diagnostic;
     missingArgument: (node: BaseNode, name: string, expected: Schema) => Diagnostic;
     notASchema: (node: BaseNode, name: string) => Diagnostic;
     typeAsValue: (node: BaseNode, name: string) => Diagnostic;
     asserterNeedsName: (node: BaseNode, asserter: string) => Diagnostic;
     shadowsSchema: (node: BaseNode, name: string) => Diagnostic;
     unknownModule: (node: BaseNode, source: string) => Diagnostic;
-    cannotRedeclare: (node: BaseNode, name: string) => Diagnostic;
+    /**
+     * O mesmo nome declarado de novo onde não pode, com o texto de cada mecanismo do tsc
+     * 3.9.10. O conceito é um só, o do `cannot-redeclare` (D2), e o nó é o NOME de cada
+     * declaração acusada.
+     */
+    redeclaration: {
+        /** TS2451: o que está na tabela é variável de escopo de bloco (o `declareSymbol` do
+         *  binder, `binder.ts:476`), em cada declaração. */
+        blockScoped: (node: BaseNode, name: string) => Diagnostic;
+        /** TS2300: o que está na tabela é outra coisa (um parâmetro, um import, um alias, um
+         *  namespace), em cada declaração. */
+        duplicate: (node: BaseNode, name: string) => Diagnostic;
+        /** TS2440: o import fundido com uma declaração local que ocupa o significado do alvo
+         *  dele (o `checkAliasSymbol`, `checker.ts:34279`), no especificador. */
+        importConflict: (node: BaseNode, name: string) => Diagnostic;
+        /** TS2492: o bloco do `catch` declara de novo o binding dele (o `checkTryStatement`,
+         *  `checker.ts:33056`), na declaração do bloco. */
+        catchClause: (node: BaseNode, name: string) => Diagnostic;
+        /** TS2395: declarações do mesmo símbolo, umas exportadas e outras locais, no mesmo
+         *  espaço (o `checkExportsOnMergedDeclarations`, `checker.ts:30401`), em cada uma. */
+        mixedExport: (node: BaseNode, name: string) => Diagnostic;
+    };
     circularTypeAlias: (node: BaseNode, name: string) => Diagnostic;
     circularTypeAnnotation: (node: BaseNode, name: string) => Diagnostic;
     excessArgument: (node: BaseNode, expected: number, got: number) => Diagnostic;
@@ -346,6 +255,52 @@ declare const diag: {
      *  lugar do `{1}`. */
     constraintViolation: (node: BaseNode, actual: Schema, bound: Schema) => Diagnostic;
     unsupported: (node: BaseNode, what: string) => Diagnostic;
+    /**
+     * O nome usado antes da declaração dele, com o texto de cada mecanismo do tsc 3.9.10. O
+     * conceito é um só (D2), e o nó é o USO.
+     */
+    usedBeforeDeclaration: {
+        /** TS2448: a variável de escopo de bloco (o `checkResolvedBlockScopedVariable`,
+         *  `checker.ts:2259`), com a declaração na informação relacionada (TS2728). */
+        blockScoped: (node: BaseNode, name: string, declaration: BaseNode) => Diagnostic;
+        /** TS2372: o default de um parâmetro cita o próprio parâmetro (`checker.ts:2009`). */
+        parameterSelf: (node: BaseNode, parameter: string) => Diagnostic;
+        /** TS2373: o default de um parâmetro cita um declarado depois dele (`checker.ts:2013`). */
+        parameterAfter: (node: BaseNode, parameter: string, name: string) => Diagnostic;
+    };
+    /** TS2454: a leitura de uma variável que, por algum caminho, ainda não recebeu valor. */
+    usedBeforeAssigned: (node: BaseNode, name: string) => Diagnostic;
+    /** O namespace (D83), com o texto do tsc em cada um. */
+    namespace: {
+        /** TS2503: o primeiro segmento de um nome qualificado não é namespace nenhum. O
+         *  código é o do nome que não existe, como o TS2304. */
+        notFound: (node: BaseNode, name: string) => Diagnostic;
+        /** TS2694: o namespace não exporta o membro, no segmento do membro. */
+        noExportedMember: (node: BaseNode, namespace: string, member: string) => Diagnostic;
+        /** TS2708: um namespace só de tipos numa posição de valor — o par do TS2693. */
+        asValue: (node: BaseNode, name: string) => Diagnostic;
+        /** TS1235: a declaração fora do topo e de outro namespace, no primeiro token. */
+        misplaced: (node: BaseNode) => Diagnostic;
+    };
+    /** O lugar do modificador `declare` — o `checkGrammarModifiers` do tsc, no primeiro token
+     *  da declaração, que é o `declare`. */
+    modifier: {
+        /** TS1184: o `declare` numa declaração fora do topo e do bloco de um namespace. */
+        cannotAppearHere: (node: BaseNode) => Diagnostic;
+        /** TS1038: o `declare` numa declaração que já está num contexto ambiente. */
+        alreadyAmbient: (node: BaseNode) => Diagnostic;
+    };
+    /** O contexto ambiente (`declare namespace`, e a declaração com `declare`) só declara — o
+     *  `checkAmbientInitializer` e o `checkGrammarStatementInAmbientContext` do tsc, no nó de
+     *  lá. */
+    ambient: {
+        /** TS1039: o inicializador que o contexto ambiente não aceita, nele. */
+        initializer: (node: BaseNode) => Diagnostic;
+        /** TS1254: o `const` sem anotação com um inicializador que não é literal, nele. */
+        constInitializer: (node: BaseNode) => Diagnostic;
+        /** TS1036: o statement que não é declaração, uma vez por bloco, no primeiro token. */
+        statement: (node: BaseNode) => Diagnostic;
+    };
     /**
      * Argumento de tipo explícito com aridade errada. Assinatura **sem** type params
      * declarados conta como `expected: 0` — é o que o tsc faz quando
@@ -370,7 +325,7 @@ declare const diag: {
      * a resposta é sempre não (D9 — o piso é `const`). Mensagem no texto do TS2588 /
      * TS2632 (import). Ver `mutation.ts`.
      */
-    assignToConst: (node: BaseNode, name: string, kind: "const" | "import") => Diagnostic;
+    assignToConst: (node: BaseNode, name: string, kind: "const" | "import" | "not-a-variable") => Diagnostic;
     /**
      * As chaves de um `for…in` não cabem no alvo dele (`let n: number; for (n in o)`). É a
      * relação que falha — o tipo das chaves contra o tipo declarado do alvo —, e por isso
@@ -379,6 +334,10 @@ declare const diag: {
     forInTarget: (node: BaseNode) => Diagnostic;
     /** `for ([a] in o)` — o alvo de um `for…in` é uma chave, não se desestrutura. TS2491. */
     forInDestructuring: (node: BaseNode) => Diagnostic;
+    /** `for (k in n)` com `n` que não é objeto, `any` nem type param — o TS2407 do
+     *  `checkForInStatement` do tsc (`checker.ts:32148`), no que se percorre, com o tipo sem o
+     *  nulo. */
+    forInNotObject: (node: BaseNode, type: Schema) => Diagnostic;
     /**
      * Escrita por um ÍNDICE readonly — `readonly T[]` ou `{ readonly [k: string]: V }`. É
      * a outra metade do modificador: a relação (TC29) diz quem pode ser ATRIBUÍDO a quem;
@@ -418,6 +377,29 @@ declare const diag: {
      * entre tipos incompatíveis. Espelha TS2365.
      */
     operatorNotApplicable: (node: BaseNode, op: string, left: Schema, right: Schema) => Diagnostic;
+    /**
+     * TS2678: o `case` de um `switch` que não é comparável ao discriminante, no `case` — o
+     * `checkTypeComparableTo` do `checkSwitchStatement` do tsc (`checker.ts:32977`). Os tipos
+     * chegam como a comparação os viu: alargados até a base, a menos que os dois sejam
+     * literais. O tsc elabora a relação num objeto (TS2741, TS2740); aqui a mensagem é a do
+     * TS2678, e o código é o contrato (D2).
+     */
+    notComparable: (node: BaseNode, source: Schema, target: Schema) => Diagnostic;
+    /**
+     * TS2774: a condição de um `if` ou de um `?:` é uma função que nunca é falsy, e o ramo
+     * verdadeiro não a usa — o `checkTestingKnownTruthyCallableType` do tsc
+     * (`checker.ts:31963`), na condição.
+     */
+    uncalledFunctionCheck: (node: BaseNode) => Diagnostic;
+    /**
+     * TS2367: uma igualdade entre tipos sem sobreposição, cujo resultado já é sabido — o
+     * `tryGiveBetterPrimaryError` do tsc (`checker.ts`, no `reportOperatorError`): `'false'`
+     * para `===`/`==`, `'true'` para `!==`/`!=`. Os tipos chegam como a mensagem os mostra
+     * (as bases, quando os literais também não se relacionam). Com `missingAwait`, os dois
+     * lados se relacionariam desembrulhando o `Promise`, e a informação relacionada é o
+     * TS2773 (o `errorAndMaybeSuggestAwait`).
+     */
+    noOverlap: (node: BaseNode, op: string, left: Schema, right: Schema, missingAwait: boolean) => Diagnostic;
     /**
      * `"x" + n` — o `+` não converte para texto (Proposal 009).
      *
@@ -461,6 +443,224 @@ interface DiagnosticSink {
 /** Cria um coletor vazio. */
 declare function createSink(): DiagnosticSink;
 
+/** O que uma declaração de namespace declara com um nome. */
+interface NamespaceMember {
+    /** Visível de fora: tem `export`, ou está num contexto ambiente que exporta tudo. */
+    readonly exported: boolean;
+    /** O nome, onde o diagnóstico sobre a declaração pousa; `null` num membro do ambiente,
+     *  que não tem texto. */
+    readonly id: BaseNode | null;
+    /** A chave do tipo no catálogo, quando não é o nome qualificado (`path.nome`): a de um
+     *  tipo que outra declaração do mesmo namespace também declara (checker D88). */
+    readonly key?: string;
+}
+/** Uma declaração de namespace — um bloco. `namespace A.B { … }` são duas: o `A` e o `B`. */
+interface NamespaceDeclaration {
+    /** O `TSModuleDeclaration`; `null` num namespace do ambiente, que vem das chaves do
+     *  catálogo e não de texto. */
+    readonly node: BaseNode | null;
+    /** O caminho qualificado (`app.router`). */
+    readonly path: string;
+    /** A declaração de fora, ou `null` no topo. */
+    readonly parent: NamespaceDeclaration | null;
+    /** No contexto ambiente (`declare namespace`, e o que está dentro dele). */
+    readonly ambient: boolean;
+    /** O bloco tem valores (o `Instantiated` do `getModuleInstanceState`). */
+    readonly instantiated: boolean;
+    /** Os tipos que ESTE bloco declara (os locais do tsc, com o sentido de tipo). Um tipo e
+     *  um namespace com o mesmo nome convivem, por isso as duas tabelas. */
+    readonly types: ReadonlyMap<string, NamespaceMember>;
+    /** Os namespaces que ESTE bloco declara. */
+    readonly namespaces: ReadonlyMap<string, NamespaceMember>;
+    /** Os valores que ESTE bloco declara — só no namespace do AMBIENTE (as variáveis do host
+     *  com o nome qualificado, D93). Os do programa são tipados pelo walk (D90). */
+    readonly values?: ReadonlyMap<string, NamespaceMember>;
+}
+/** As declarações de namespace de uma raiz — o programa, ou o ambiente. */
+interface Namespaces {
+    /** As declarações de cada namespace, pelo caminho, na ordem. */
+    readonly byPath: ReadonlyMap<string, readonly NamespaceDeclaration[]>;
+    /** A declaração de cada nó `TSModuleDeclaration` que está num lugar permitido. */
+    readonly byNode: WeakMap<BaseNode, NamespaceDeclaration>;
+    /** Os aliases escritos num namespace: o nó da declaração do alias → a do namespace. */
+    readonly aliasOwner: WeakMap<BaseNode, NamespaceDeclaration>;
+}
+
+/**
+ * Um nível de escopo léxico (nome → `Schema`), sobre o `Scope<T>` genérico do
+ * `ast` — a mesma cadeia que o `behavior` usa, com o payload do eixo de tipos.
+ */
+type Scope = Scope$1<Schema>;
+/** Cria um escopo raiz (sem pai). */
+declare const rootScope: (vars?: Record<string, Schema>) => Scope;
+/** Estende `parent` com novos bindings, criando um escopo filho. */
+declare const childScope: (parent: Scope, vars: Record<string, Schema>) => Scope;
+/** Resolve `name` subindo a cadeia léxica. `undefined` se não existir. */
+declare const lookup: (scope: Scope, name: string) => Schema | undefined;
+/**
+ * Todos os nomes visíveis a partir de `scope`, com shadowing — o binding mais
+ * interno vence. É o que alimenta o autocomplete de identificadores. Duas
+ * chaves moram no mesmo escopo e não são nomes: a que tem `.` é um caminho
+ * estreitado por guard (`narrow`, D13), e a que termina em `#` é o tipo
+ * DECLARADO de um binding mutável (D63) — nenhum identificador tem esses
+ * caracteres.
+ *
+ * Um binding do programa tem a chave do SÍMBOLO (`nome@id`, D87), e dois símbolos com
+ * o mesmo nome são chaves diferentes: o nome visível é o de fora do `@`, e vale o mais
+ * interno. A cadeia vem de dentro para fora, e um refinamento de um símbolo só existe
+ * onde o nome dele não está sombreado — então a primeira chave de cada nome é a que ele
+ * denota ali.
+ */
+declare const visibleNames: (scope: Scope) => Map<string, Schema>;
+/**
+ * `name`, visto de `scope`, denota um nome do AMBIENTE (a DI, a lib) — e não um símbolo
+ * do programa? É o que o tsc responde olhando a declaração do símbolo resolvido (o
+ * `defaultLibrary` do `classifier2020`). A primeira ligação do nome, de dentro para fora, é
+ * a que ele denota ali (ver `visibleNames`); `false` quando nada o liga.
+ */
+declare function resolvesToEnvironment(scope: Scope, name: string): boolean;
+/**
+ * O ambiente injetado pela aplicação — a fronteira de tipos do sistema.
+ * `scope` é a raiz da DI; `types` resolve tipos nomeados em anotações.
+ */
+/**
+ * O ambiente é **só tipos** (a fronteira da DI). Capability — o que pode ser
+ * programado — é ortogonal e mora no `CapabilityProfile` (`@tslite/capability`),
+ * passado ao `check` por `{ profile }`. Não há mais noção de capability no Env.
+ */
+interface Env {
+    readonly scope: Scope;
+    readonly types: Readonly<Record<string, Schema>>;
+    /** Type schemes parametrizados (`type Pair<A, B> = …`), expandidos sob demanda. */
+    readonly schemes: Schemes;
+    /**
+     * Acessores **indexados por path literal**: nome → schema-base que ele navega.
+     * Ex.: `get` sobre o schema dos States → `get("hp","value")` tipa como
+     * `discover(base, ["hp","value"])`. É como a fronteira tipa leituras de estado
+     * sem `unknown` (o app declara o shape; o checker indexa). Default: nenhum.
+     */
+    readonly accessors?: Readonly<Record<string, Schema>>;
+    /**
+     * **Asserters** (a fronteira sã): nomes de funções cujo retorno é o **tipo do
+     * schema nomeado** no 1º argumento. Ex.: com `parse` aqui, `parse(User, x)`
+     * tipa como `User` (e em runtime o `@tslite/validate` valida o valor). É o
+     * `parse()` estilo zod: fecha `unknown`/complexidade — o tipo "reseta" limpo
+     * na fronteira, **provado** em runtime (≠ `as`). Default: nenhum.
+     */
+    readonly asserters?: ReadonlySet<string>;
+    /**
+     * **Matchers de props** (o diferencial): nomes de funções que checam, em
+     * edit-time, se um **payload** (saída de um serviço de automação / nocode) é
+     * **compatível com as props de um componente** react-like. Ex.: com
+     * `matchesProps` aqui, `matchesProps(Card, request)` extrai as props de `Card`
+     * (`(props) => Element`, agnóstico ao framework — Element é `apply` opaco) e
+     * verifica `request ≤ props` (campos a mais no request são OK; faltar/tipo-errado
+     * em prop obrigatória → diagnóstico `props-mismatch`). Retorna `boolean`. Default:
+     * nenhum.
+     */
+    readonly matchers?: ReadonlySet<string>;
+    /**
+     * **Módulos** (a borda DI NOMEADA): especificador → o `object` Schema dos
+     * exports daquele módulo (`{ map: fn, filter: fn, …, default: … }`). É o D3
+     * estendido a módulos: `import { map } from "@x/ops"` liga `map` ao
+     * `modules["@x/ops"].props.map`. O checker **não resolve** o módulo (sem file
+     * system) — consome o tipo já provido; a *resolução* (qual módulo é o
+     * especificador) é da app (Proposal 005). Default: nenhum.
+     */
+    readonly modules?: Readonly<Record<string, Schema>>;
+    /**
+     * Os aliases da **lib padrão** (`Partial`, `Pick`, `Record`, `Omit`, `ReturnType`…),
+     * o texto do `lib.es5.d.ts` do tsc 3.9.10 com o corte do TSLite (D79). Ficam ABAIXO
+     * de tudo: um tipo do host ou um alias do programa com o mesmo nome os sombreia.
+     * Vazio com `noLib`.
+     */
+    readonly lib?: Schemes;
+    /**
+     * Os tipos **nominais** que um texto de tipo pode citar pelo nome: o nome e os type
+     * params de cada um. São os `interface` da lib (`Array`, `ReadonlyArray`, `Promise`)
+     * e os que o host declara (`Map`, `Element`…). Um nominal é o `apply` opaco (types
+     * TC2): o texto `Promise<User>` e o construtor `s.apply("Promise", [User])` são o
+     * mesmo tipo, e a aridade é cobrada como a de um alias.
+     */
+    readonly nominals?: Nominals;
+    /**
+     * Os namespaces do ambiente (D83), lidos das chaves de `types` e `schemes`: um tipo com o
+     * nome qualificado (`state.Config`) é o membro `Config` do namespace `state`, como num
+     * `.d.ts` com `declare namespace state { … }`. Os corpos já chegam com os nomes
+     * resolvidos a partir do namespace de cada um — um `Config` no corpo de `state.Result` é
+     * o `state.Config` —, sem o host reescrever nada.
+     */
+    readonly namespaces?: Namespaces;
+    /**
+     * Os erros do contrato que o host declarou (D93) — o equivalente dos erros de um `.d.ts`
+     * no tsc, que são do arquivo de declarações e não do programa que o usa. Achados uma vez,
+     * no `createEnv`; o `check` não os repete. Um nome que não resolve em lugar nenhum do
+     * ambiente é o `unknown-name` (TS2304), e vale o tipo-erro.
+     */
+    readonly diagnostics?: readonly EnvDiagnostic[];
+}
+/**
+ * O que um `Env` tem além das variáveis. Cada campo espelha o de {@link Env}, e
+ * todos são opcionais.
+ */
+interface EnvOptions {
+    readonly types?: Readonly<Record<string, Schema>>;
+    readonly schemes?: Readonly<Record<string, TypeScheme>>;
+    readonly accessors?: Readonly<Record<string, Schema>>;
+    readonly asserters?: ReadonlySet<string>;
+    readonly matchers?: ReadonlySet<string>;
+    readonly modules?: Readonly<Record<string, Schema>>;
+    /** Os nominais do host, somados aos da lib (ver {@link Env.nominals}). */
+    readonly nominals?: Nominals;
+    /**
+     * Sem a lib padrão — nem os aliases, nem os nominais dela. É o `--noLib` do tsc: os
+     * nomes da lib passam a ser `unknown-name`, como lá.
+     */
+    readonly noLib?: boolean;
+}
+/**
+ * Um catálogo (`Record<string, Schema>`) passado no lugar das opções é o erro que a
+ * forma antiga convida (`createEnv(vars, types)`), e o TypeScript o aceitaria em
+ * silêncio: um tipo com índice de string cabe num objeto de opções todas
+ * opcionais. Este tipo o recusa na compilação — `keyof` de um catálogo é `string`.
+ */
+type NoCatalog<O> = string extends keyof O ? never : unknown;
+/**
+ * Cria um `Env`: as variáveis injetadas (a raiz da DI) e, por nome, o resto —
+ * tipos nomeados, type schemes, acessores, asserters, matchers, módulos.
+ * Capability é separada (passe um `profile` ao `check`).
+ *
+ * As opções são NOMEADAS porque a forma posicional já custou um defeito: uma
+ * chamada que parava no quarto argumento compilava, e o asserter (o quinto) ficava
+ * fora do ambiente — `parseAs` virava `unknown-name` só naquele lugar. Uma chave
+ * fora do vocabulário (um catálogo no lugar das opções, um `type` no lugar de
+ * `types`) é `invalid-env-options`, na montagem: o `Env` não nasce com uma metade
+ * calada.
+ */
+declare const createEnv: <O extends EnvOptions = EnvOptions>(vars?: Readonly<Record<string, Schema>>, options?: O & NoCatalog<O>) => Env;
+/**
+ * Um `Schema` como se estivesse escrito DENTRO do namespace `namespace` do ambiente
+ * (`"state"`, `"app.router"`; `null` na raiz): os nomes dele resolvidos como os do `createEnv`
+ * — no namespace e nos de fora, depois entre os tipos do ambiente e da lib (D83, D93) —, com o
+ * nome qualificado no lugar. É o `getTypeFromTypeNode` do tsc, que resolve um tipo pelo
+ * contêiner em que ele está escrito; aqui o contêiner é dito, porque o `Schema` não tem
+ * posição. Serve ao host que monta tipos por código e os publica no namespace do dono.
+ *
+ * O que não resolve vale o tipo-erro, e volta em `diagnostics`, com o caminho a partir da raiz
+ * do `Schema`. Um namespace que o ambiente não declara resolve como o mais próximo de fora que
+ * ele declara. O mesmo `Schema` volta quando nada muda (os caches são por referência, TC17).
+ */
+declare function resolveTypeNamesIn(env: Env, namespace: string | null, type: Schema): {
+    readonly type: Schema;
+    readonly diagnostics: readonly EnvDiagnostic[];
+};
+/** Os erros que a MONTAGEM do ambiente lança (o `check` em si nunca lança — D2). */
+type CheckerErrorCode = "invalid-env-options";
+/** Resolve um tipo nomeado (`type User = …`) declarado no ambiente. */
+declare const resolveNamed: (env: Env, name: string) => Schema | undefined;
+/** Resolve um type scheme (`type Pair<A, B> = …`) declarado no ambiente. */
+declare const resolveScheme: (env: Env, name: string) => TypeScheme | undefined;
+
 /** Liga a análise de não-usados. Dois eixos independentes, como no tsc. */
 interface UnusedOptions {
     /** ≅ `noUnusedLocals`: `const` e `import` nunca lidos. */
@@ -507,7 +707,8 @@ interface CheckResult {
      * forma de scheme. Publicado porque QUEM CONSULTA precisa dele: `discover`
      * (completions, navegação de membro) só expande um `apply` se receber este
      * catálogo. Sem publicar, cada consumidor re-derivaria a união — e derivações
-     * paralelas divergem.
+     * paralelas divergem. Num programa sem alias é o catálogo do `Env`, o mesmo objeto em
+     * toda checagem, e congelado (D87).
      */
     readonly schemes: Schemes;
     /**
@@ -621,6 +822,15 @@ declare const FUNCTION_KINDS: readonly ["ArrowFunctionExpression", "FunctionExpr
  * nó proibido por `compiled` — via `nodeViolation`, a **fonte única** de gating
  * compartilhada com o interpret e o codegen. É o que `fromCapability` monta (+ o
  * host allowlist). Garante que os 3 consumidores concordam por construção.
+ *
+ * Cada nó vai com o pai: é ele que separa o `export` de um membro de namespace
+ * (a visibilidade, como o modificador do tsc) do `export` de módulo do teto
+ * (capability CP1).
+ *
+ * O profile diz o que um lugar da aplicação pode EXECUTAR, e o corpo de um namespace que não
+ * vira código não executa: o nó do namespace é gateado, e o corpo dele não
+ * (`bodyDoesNotRun`). Os guards de autoria de tipo, abaixo, julgam o texto escrito e descem
+ * nele.
  */
 declare function capabilityNodes(compiled: CompiledProfile, severity?: Severity): Guard;
 /**
@@ -919,4 +1129,4 @@ declare function anchorDiagnostics<A>(root: object, diagnostics: readonly Diagno
  */
 declare function spanOf(text: string, loc: SourceLocation | null | undefined): Span | undefined;
 
-export { type AnchorDiagnosticsOptions, type AnchoredDiagnostic, type Anchors, BINARY_OP, BINARY_OPS, type BinaryOpCategory, type BinaryOpSpec, type BindingMap, type CheckOptions, type CheckResult, type CheckerErrorCode, Completion, type Diagnostic, type DiagnosticCode, type DiagnosticData, type DiagnosticKind, type DiagnosticRelatedInformation, type DiagnosticSink, type Env, type EnvOptions, FUNCTION_KINDS, type Guard, type GuardContext, LOGICAL_OPS, type LogicalOpSpec, type LowerValueOptions, type MissingProperty, type Nominals, ObjectSchema, type Occurrence, type OpResult, type Profile, type ReferenceSymbol, Schema, Schemes, type Scope, type Severity, type Shorthand, type TypeOverlay, type TypeRefSite, TypeScheme, UNARY_OPS, type UnaryOpSpec, type UnusedOptions, VarSchema, anchorDiagnostics, annotate, annotateReturn, asExpression, binaryOpsProducing, calleeAllowlist, capabilityNodes, check, childScope, collectBindings, collectMutations, collectReferences, collectUnused, componentProps, componentPropsOf, contextualTypeAt, createAnchors, createEnv, createSink, diag, diagnosticsAt, extractModuleType, fromCapability, guard, guardsFromCompiled, lookup, lowerValue, makeDiagnostic, maxArgs, maxCallNesting, maxDepth, maxFunctionNesting, maxNestingOf, maxNodes, memberCompletions, memberDepth, opResultSchema, resolveNamed, resolveScheme, resultType, rootScope, sameSymbol, scopeAt, scopeCompletions, spanOf, typeAt, unaryOpsProducing, visibleNames };
+export { type AnchorDiagnosticsOptions, type AnchoredDiagnostic, type Anchors, BINARY_OP, BINARY_OPS, type BinaryOpCategory, type BinaryOpSpec, type BindingMap, type CheckOptions, type CheckResult, type CheckerErrorCode, Completion, type Diagnostic, type DiagnosticCode, type DiagnosticData, type DiagnosticKind, type DiagnosticRelatedInformation, type DiagnosticSink, type Env, type EnvDiagnostic, type EnvOptions, FUNCTION_KINDS, type Guard, type GuardContext, LOGICAL_OPS, type LogicalOpSpec, type LowerValueOptions, type MissingProperty, type Nominals, ObjectSchema, type Occurrence, type OpResult, type Profile, type ReferenceSymbol, Schema, Schemes, type Scope, type Severity, type Shorthand, type TypeOverlay, type TypeRefSite, TypeScheme, UNARY_OPS, type UnaryOpSpec, type UnusedOptions, VarSchema, anchorDiagnostics, annotate, annotateReturn, asExpression, binaryOpsProducing, calleeAllowlist, capabilityNodes, check, childScope, collectBindings, collectMutations, collectReferences, collectUnused, componentProps, componentPropsOf, contextualTypeAt, createAnchors, createEnv, createSink, diag, diagnosticsAt, extractModuleType, fromCapability, guard, guardsFromCompiled, lookup, lowerValue, makeDiagnostic, maxArgs, maxCallNesting, maxDepth, maxFunctionNesting, maxNestingOf, maxNodes, memberCompletions, memberDepth, opResultSchema, resolveNamed, resolveScheme, resolveTypeNamesIn, resolvesToEnvironment, resultType, rootScope, sameSymbol, scopeAt, scopeCompletions, spanOf, typeAt, unaryOpsProducing, visibleNames };