@tslite/checker 1.8.0 → 1.9.0

package/dist/index.d.ts

@@ -7,200 +7,8 @@ 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.
- */
-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;
-}
-/**
- * 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" | "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";
+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
@@ -277,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`.
@@ -311,6 +135,9 @@ 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;
@@ -455,8 +282,17 @@ declare const diag: {
         /** 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á. */
+    /** 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;
@@ -607,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. */
@@ -1075,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, resolvesToEnvironment, 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 };