@tslite/checker 1.5.0 → 1.8.0

package/dist/index.d.ts

@@ -1,12 +1,52 @@
 import { VarSchema, Schema, Schemes, TypeScheme, ObjectSchema, Completion } from './types/index.js';
-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, widen, widenInferred, widenLiteral, widenOrigin, widenType, withUndefined, withoutUndefined } from './types/index.js';
-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.js';
+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[]>>;
 
+/** 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>;
+}
+/** 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.
@@ -25,8 +65,21 @@ declare const lookup: (scope: Scope, name: string) => Schema | undefined;
  * 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.
@@ -91,6 +144,14 @@ interface Env {
      * 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;
 }
 /**
  * O que um `Env` tem além das variáveis. Cada campo espelha o de {@link Env}, e
@@ -139,7 +200,7 @@ declare const resolveNamed: (env: Env, name: string) => Schema | undefined;
 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" | "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" | "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
@@ -187,6 +248,16 @@ type DiagnosticData = {
     readonly kind: "implicit-coercion";
     readonly textConvertible: boolean;
 };
+/**
+ * Outro lugar do programa que explica o diagnóstico — o `DiagnosticRelatedInformation` do
+ * tsc (`types.ts`), que o `addRelatedInfo` anexa, e o `relatedInformation` do LSP. O nó é
+ * por referência, como o do diagnóstico; a mensagem diz o papel dele ("This spread always
+ * overwrites this property.").
+ */
+interface DiagnosticRelatedInformation {
+    readonly node: BaseNode;
+    readonly message: string;
+}
 interface Diagnostic {
     readonly code: DiagnosticCode;
     /** A classe do diagnóstico (deriva do `code`) — ver {@link DiagnosticKind}. */
@@ -197,6 +268,8 @@ interface Diagnostic {
     readonly message: string;
     /** Ver {@link DiagnosticData}. Presente só onde há o que agir. */
     readonly data?: DiagnosticData;
+    /** Ver {@link DiagnosticRelatedInformation}. Presente só onde o tsc a anexa. */
+    readonly relatedInformation?: readonly DiagnosticRelatedInformation[];
 }
 /**
  * Builder genérico de diagnóstico (severidade configurável). Usado pelos
@@ -244,7 +317,28 @@ declare const diag: {
     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;
@@ -265,12 +359,41 @@ declare const diag: {
     requiredAfterOptional: (node: BaseNode) => Diagnostic;
     notIterable: (node: BaseNode, type: Schema) => Diagnostic;
     /**
-     * O rest de um padrão de objeto (`{ a, ...rest }`) sobre uma fonte que não é objeto — o
-     * TS2700 do tsc, no elemento do rest (`getTypeForBindingElement`, `checker.ts:7439`: o
-     * `isValidSpreadType` da fonte). O código é o do conceito — a fonte não se espalha —, par do
-     * `not-iterable` do padrão de array.
+     * A fonte não se espalha: o `isValidSpreadType` do tsc (`checker.ts:23342`) a recusa. O
+     * código é o do conceito, par do `not-iterable` do padrão de array; a mensagem diz o caso.
+     */
+    notSpreadable: {
+        /** TS2700: o rest de um padrão de objeto (`{ a, ...rest }`), no elemento do rest
+         *  (`getTypeForBindingElement`, `checker.ts:7439`). D80. */
+        rest: (node: BaseNode) => Diagnostic;
+        /** TS2698: o spread num literal de objeto (`{ ...x }`), no membro `...x`
+         *  (`checkObjectLiteral`, `checker.ts:23254`). */
+        spread: (node: BaseNode) => Diagnostic;
+    };
+    /**
+     * A chave escrita duas vezes num literal de objeto. O tsc a acusa por três mecanismos, e
+     * cada um é um diagnóstico com o texto e o nó dele; o conceito é um só, o do
+     * `cannot-redeclare` (D25).
+     */
+    duplicateKey: {
+        /** TS1117: a chave IDENTIFICADOR repetida, no modo estrito (o `bindObjectLiteralExpression`
+         *  do binder, `binder.ts:2037`), na repetição. */
+        strict: (node: BaseNode) => Diagnostic;
+        /** TS2300: o nome repetido (o `checkGrammarObjectLiteralExpression`), na repetição, com o
+         *  texto do nome como escrito. */
+        identifier: (node: BaseNode, text: string) => Diagnostic;
+        /** TS2718: a chave computada ligada tarde com o nome de uma prop ligada cedo (o
+         *  `lateBindMember`), na chave tardia. */
+        lateBound: (node: BaseNode, name: string) => Diagnostic;
+        /** TS2733: a primeira declaração ligada cedo desse nome, no mesmo `lateBindMember`. */
+        alsoDeclared: (node: BaseNode, name: string) => Diagnostic;
+    };
+    /**
+     * TS2783: a prop escrita num literal de objeto que um spread seguinte sempre sobrescreve,
+     * na prop escrita, com o spread na informação relacionada (TS2785) — o
+     * `checkSpreadPropOverrides` do tsc (`checker.ts:23558`).
      */
-    notSpreadable: (node: BaseNode) => Diagnostic;
+    overwrittenProperty: (node: BaseNode, name: string, spread: BaseNode) => Diagnostic;
     /**
      * O `any` que ninguém escreveu — o `noImplicitAny` do tsc 3.9.10, que faz parte do
      * `--strict` e está sempre ligado aqui (D81). Um código só, com o texto de cada caso (o
@@ -305,6 +428,43 @@ 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 contexto ambiente (`declare namespace`) 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
@@ -329,7 +489,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
@@ -338,6 +498,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;
@@ -377,6 +541,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).
      *
@@ -399,11 +586,13 @@ declare const diag: {
 /**
  * Coletor de diagnósticos — acumula durante o walk, sem `throw`.
  *
- * Guarda cada diagnóstico UMA vez: um segundo com o mesmo nó, o mesmo código e a mesma
- * mensagem não entra. É a coleção do tsc (`createDiagnosticCollection`, que insere pelo
- * `insertSorted` e não repete o que o `compareDiagnostics` acha igual), e é o que deixa
- * um argumento ser tipado mais de uma vez — as rodadas da chamada (D53, D81) — sem que o
- * erro de dentro dele saia duas vezes.
+ * Guarda cada diagnóstico UMA vez: um segundo com o mesmo nó, o mesmo código, a mesma
+ * mensagem e a mesma informação relacionada não entra. É a coleção do tsc
+ * (`createDiagnosticCollection`, que insere pelo `insertSorted` e não repete o que o
+ * `compareDiagnostics` acha igual — ele compara também o `relatedInformation`), e é o que
+ * deixa um argumento ser tipado mais de uma vez — as rodadas da chamada (D53, D81) — sem
+ * que o erro de dentro dele saia duas vezes. Dois diagnósticos que só diferem na
+ * informação relacionada são dois: `{ a: 1, ...o1, ...o2 }` acusa o `a` uma vez por spread.
  */
 interface DiagnosticSink {
     /** Diagnósticos coletados, na ordem em que foram reportados, sem repetição. */
@@ -464,7 +653,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;
     /**
@@ -578,6 +768,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;
 /**
@@ -876,4 +1075,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 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 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, resolvesToEnvironment, resultType, rootScope, sameSymbol, scopeAt, scopeCompletions, spanOf, typeAt, unaryOpsProducing, visibleNames };