@loom-forge/check 0.1.0

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/checker.ts","../src/props.ts","../src/env.ts","../src/lower.ts","../src/profile.ts","../src/component.ts"],"names":["b","fromJsonSchema","subtype","s","addressOf","binding","parseExpression"],"mappings":"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","file":"index.js","sourcesContent":["import { subtype, format, type Schema } from \"@tslite/type-core\";\nimport { fromJsonSchema, toJsonSchema } from \"@tslite/jsonschema\";\nimport { inferValue } from \"@tslite/infer\";\nimport type {\n  DescriptorRegistry,\n  ResolvedNode,\n  TypeChecker,\n} from \"@loom-forge/core\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n   Adapter de TIPOS via @tslite/type-core — implementa o `TypeChecker` (port) e prova\n   compatibilidade estrutural (`A ≤ B`). É o motor da intercambiabilidade\n   `action.return ≤ component.props` / `args ≤ action.params`: tudo é DTO serializável,\n   o checker decide a atribuibilidade. Pontes: dados→Schema (infer), JSON Schema↔Schema.\n\n   (A camada de TIPOS de componente — `componentType`/`componentAssignable`/o call-site —\n   vive em `props.ts`, ao lado.)\n   ────────────────────────────────────────────────────────────────────────────── */\n\nexport interface TsliteChecker extends TypeChecker {\n  /** infere o Schema (forma) de um valor/dados (escalares alargam à base). */\n  inferType(value: unknown): Schema;\n  /** JSON Schema → Schema do TSLite. */\n  fromJsonSchema(jsonSchema: unknown): Schema;\n  /** Schema do TSLite → JSON Schema. */\n  toJsonSchema(schema: Schema): unknown;\n  /** a forma de `value` é atribuível ao tipo descrito por `jsonSchema`? (infer + subtype) */\n  assignable(value: unknown, jsonSchema: unknown): boolean;\n  /** representação textual de um Schema (diagnóstico). */\n  format(schema: Schema): string;\n}\n\nexport function createTsliteChecker(): TsliteChecker {\n  const inferType = (value: unknown): Schema => inferValue(value as never);\n  const fromJS = (jsonSchema: unknown): Schema =>\n    fromJsonSchema(jsonSchema as never);\n  return {\n    subtype: (a, b) => subtype(a as Schema, b as Schema),\n    inferType,\n    fromJsonSchema: fromJS,\n    toJsonSchema: (schema) => toJsonSchema(schema),\n    assignable: (value, jsonSchema) =>\n      subtype(inferType(value), fromJS(jsonSchema)),\n    format: (schema) => format(schema),\n  };\n}\n\n/* ── validação de dataflow (dev/CI/authoring — NÃO no hot path de render) ─────── */\n\nexport interface DataflowIssue {\n  nodeId: string;\n  type: string;\n  /** tipo declarado pelo descriptor (props esperadas). */\n  expected: string;\n  /** forma efetiva das props resolvidas. */\n  got: string;\n}\n\n/**\n * Percorre uma `ResolvedNode` e checa, em cada nó, se as props resolvidas são atribuíveis\n * ao `schema` declarado no descriptor (quando há). É a verificação ponta-a-ponta da\n * Linguagem: a mesma máquina que, com o actions plugado, prova `action.return ≤ props`.\n */\nexport function checkTree(\n  node: ResolvedNode,\n  registry: DescriptorRegistry,\n  checker: TsliteChecker,\n): DataflowIssue[] {\n  const issues: DataflowIssue[] = [];\n  const visit = (n: ResolvedNode): void => {\n    if (n.kind !== \"node\") return;\n    const descriptor = registry.get(n.type);\n    if (descriptor?.schema && !checker.assignable(n.props, descriptor.schema)) {\n      issues.push({\n        nodeId: n.id,\n        type: n.type,\n        expected: checker.format(checker.fromJsonSchema(descriptor.schema)),\n        got: checker.format(checker.inferType(n.props)),\n      });\n    }\n    n.children.forEach(visit);\n  };\n  visit(node);\n  return issues;\n}\n","import { s, subtype, isSerializable, type Schema } from \"@tslite/type-core\";\nimport { fromJsonSchema } from \"@tslite/jsonschema\";\nimport {\n  addressOf,\n  type CompiledPath,\n  type ComponentIR,\n  type PropsDecl,\n  type SystemIR,\n  type TypeRef,\n} from \"@loom-forge/forge\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n   O TIPO DE UM COMPONENTE — a camada de tipos de um componente custom. Dev/CI, via\n   `subtype` do TSLite (NÃO validação runtime ajv/zod). É a fundação dos slots tipados e da\n   composição tipada (`B muda params → A quebra`).\n\n   O CALL-SITE não mora aqui, e é decisão. Provar `passadas ≤ declaradas` andando o `SystemIR`\n   plano só alcança literal: uma prop vinda de expressão precisa do ESCOPO de quem chama — um\n   `{{ item.x }}` dentro de um `each` não existe fora do laço que o lowering cria. Então quem\n   prova o call-site é o `checkComponent`, e o que este módulo oferece é o `declaredPropsOf`: o\n   seam que diz, para um `type`, o que ele declara.\n\n   Houve aqui um `checkProps` que comparava o objeto inteiro por `subtype` e tratava expressão\n   como `any`. Ele saiu quando o motor passou a provar a mesma coisa melhor — com escopo, por\n   campo, e ancorado na chave. Duas vozes para a mesma causa é o que se desfaz, não o que se\n   mantém por compatibilidade.\n   ────────────────────────────────────────────────────────────────────────────── */\n\nconst SCALARS: Record<string, Schema> = {\n  any: s.any,\n  unknown: s.unknown,\n  string: s.string,\n  number: s.number,\n  boolean: s.boolean,\n  null: s.null,\n};\n\n/** O catálogo de tipos NOMEADOS — o mesmo que o `buildEnv` recebe. Um nome declarado aqui vale\n *  como `TypeRef` numa declaração (`props: { addr: \"Address\" }`). */\nexport type TypeCatalog = Record<string, Schema>;\n\n/**\n * `TypeRef` (nome do catálogo | shorthand escalar | Schema do TSLite | JSON Schema) → Schema.\n *\n * O que NÃO resolve vira **`unknown`**, não `any`. `any` desligaria toda a prova daquela prop em\n * silêncio — call-site, membro, span —, e um erro de digitação na declaração apagaria a máquina\n * inteira sem dizer nada. `unknown` obriga o programa a lidar; quem diz o que houve é o\n * `checkDeclarations`, que reporta o nome que não existe.\n */\nexport function resolveTypeRef(ref: TypeRef, types: TypeCatalog = {}): Schema {\n  if (typeof ref === \"string\") return types[ref] ?? SCALARS[ref] ?? s.unknown;\n  const o = ref as Record<string, unknown>;\n  if (typeof o.t === \"string\") return ref as Schema; // já é Schema do TSLite\n  return fromJsonSchema(ref as never); // JSON Schema na borda\n}\n\n/** O nome de um `TypeRef` que não resolve — `undefined` quando ele resolve. */\nconst unresolvedName = (\n  ref: TypeRef,\n  types: TypeCatalog,\n): string | undefined =>\n  typeof ref === \"string\" && !(ref in types) && !(ref in SCALARS)\n    ? ref\n    : undefined;\n\n/**\n * `PropsDecl` → Schema de objeto. Prop com nome terminando em `?` é OPCIONAL (`{ \"title?\": … }`)\n * — TS-like, JSON-native; o `?` é tirado do nome e marca `optional`.\n *\n * **Opcional aqui significa `T | undefined`**, e a razão é do MEIO, não de leniência: uma prop\n * viaja como JSON, e em JSON `undefined` não existe — `{}` e `{ body: undefined }` são o mesmo\n * documento. Distinguir \"ausente\" de \"presente e indefinido\" (o que o `exactOptionalPropertyTypes`\n * do tsc faz, e o que o `subtype` do TSLite implementa) é uma distinção que este formato não\n * consegue expressar. Sem isso, passar um campo opcional de um dado para uma prop opcional —\n * o caso mais comum que existe — não tiparia.\n */\nexport function resolveProps(\n  props: PropsDecl | undefined,\n  types: TypeCatalog = {},\n): Schema {\n  const shape: Record<string, { type: Schema; optional?: boolean }> = {};\n  for (const [rawKey, ref] of Object.entries(props ?? {})) {\n    const optional = rawKey.endsWith(\"?\");\n    const key = optional ? rawKey.slice(0, -1) : rawKey;\n    const type = resolveTypeRef(ref, types);\n    shape[key] = optional\n      ? { type: s.union([type, s.undefined]), optional: true }\n      : { type };\n  }\n  return s.object(shape);\n}\n\n/**\n * O TIPO de um componente — o que ele declara sobre si.\n *\n * Não carrega tags: tag é **fato** derivado sobre a árvore, não tipo, e desde a separação\n * árvore × fatos ela mora em `@loom-forge/forge` (`effectiveTags(sys.facts, id)`, que é a\n * propagada — mais útil que a própria). Uma função que resolve o TIPO não deve ser a porta\n * dos fatos.\n */\nexport interface ComponentType {\n  props: Schema;\n  category?: string;\n  entry: boolean;\n}\n\n/** Resolve o TIPO de um `ComponentIR`: props → Schema, mais categoria e entry. */\nexport function componentType(\n  ir: ComponentIR,\n  types: TypeCatalog = {},\n): ComponentType {\n  return {\n    props: resolveProps(ir.props, types),\n    ...(ir.category ? { category: ir.category } : {}),\n    entry: ir.entry,\n  };\n}\n\n/** Contrato no eixo de PROPS (`Component<C>`): o conjunto de props que o componente precisa\n *  aceitar — mesma forma de `ComponentDef.props` (um `PropsDecl`). */\nexport interface ComponentContract {\n  props?: PropsDecl;\n}\n\n/**\n * O componente `child` satisfaz o contrato (eixo de props)? `subtype(child.props, contrato)`\n * — um componente com props MAIS amplas serve onde se exige menos (estrutural). É a máquina\n * de `child ≤ Component<C>` e do `action.return ≤ component.props`. Os eixos estruturais\n * (categoria/tags/cardinalidade/leaf) ficam no `checkSlots`.\n */\nexport function componentAssignable(\n  child: ComponentType,\n  contract: ComponentContract,\n  types: TypeCatalog = {},\n): boolean {\n  if (contract.props === undefined) return true;\n  return subtype(child.props, resolveProps(contract.props, types));\n}\n\n/**\n * As DECLARAÇÕES de um componente também são conferidas — `props` e `state`.\n *\n * Um `TypeRef` que não resolve é o furo mais caro que restava: ele não quebra nada na hora, e\n * desliga a prova daquela prop para sempre. O endereço é o da declaração (`props.n`,\n * `state.aberto`), não o de um nó — não há nó: é a superfície do componente.\n */\nexport function checkDeclarations(\n  def: { props?: PropsDecl; state?: Record<string, { type: TypeRef }> },\n  types: TypeCatalog = {},\n): DeclarationIssue[] {\n  const issues: DeclarationIssue[] = [];\n  const report = (path: CompiledPath, name: string): void => {\n    issues.push({\n      code: \"unknown-type-name\",\n      message: `Type '${name}' is not declared: it is neither a scalar (${Object.keys(SCALARS).join(\", \")}) nor a name in the type catalog.`,\n      severity: \"error\",\n      path,\n      address: addressOf(path),\n      source: name,\n    });\n  };\n  for (const [rawKey, ref] of Object.entries(def.props ?? {})) {\n    const name = unresolvedName(ref, types);\n    if (name !== undefined) report([\"props\", rawKey], name);\n  }\n  for (const [key, decl] of Object.entries(def.state ?? {})) {\n    const name = unresolvedName(decl.type, types);\n    if (name !== undefined) report([\"state\", key], name);\n  }\n  return issues;\n}\n\n/**\n * O resolvedor do catálogo de contextos: `nome → Schema`. É o que tipa a raiz `ctx` e o que\n * prova um `provides`.\n *\n * **Um contrato de contexto precisa ser SERIALIZÁVEL** — dado, não comportamento. Efeito já\n * tem porta aqui (`events` → `ActionPort`), e uma função no contexto seria uma segunda, que\n * não cria aresta no grafo e some da análise. O predicado é o `isSerializable` do\n * `@tslite/type-core`; um contrato que não passa vira `undefined` (não tipa), e quem acusa é o\n * `checkContextCatalog`.\n */\nexport function declaredContextsOf(\n  catalog: Record<string, TypeRef> | undefined,\n  types: TypeCatalog = {},\n): (name: string) => Schema | undefined {\n  const cache = new Map<string, Schema | undefined>();\n  return (name) => {\n    if (cache.has(name)) return cache.get(name);\n    const ref = catalog?.[name];\n    const schema = ref ? resolveTypeRef(ref, types) : undefined;\n    const ok = schema && isSerializable(schema) ? schema : undefined;\n    cache.set(name, ok);\n    return ok;\n  };\n}\n\n/**\n * O catálogo de contextos, conferido: um contrato que não resolve, ou que não é dado\n * serializável, não é contrato.\n */\nexport function checkContextCatalog(\n  catalog: Record<string, TypeRef> | undefined,\n  types: TypeCatalog = {},\n): DeclarationIssue[] {\n  const issues: DeclarationIssue[] = [];\n  for (const [name, ref] of Object.entries(catalog ?? {})) {\n    const unresolved = unresolvedName(ref, types);\n    if (unresolved !== undefined) {\n      issues.push({\n        code: \"unknown-type-name\",\n        message: `Type '${unresolved}' is not declared: it is neither a scalar (${Object.keys(SCALARS).join(\", \")}) nor a name in the type catalog.`,\n        severity: \"error\",\n        path: [\"contexts\", name],\n        address: addressOf([\"contexts\", name]),\n        source: unresolved,\n      });\n      continue;\n    }\n    if (!isSerializable(resolveTypeRef(ref, types)))\n      issues.push({\n        code: \"unknown-type-name\",\n        message: `Context '${name}' must be serializable DATA: a contract with functions (or \\`unknown\\`/\\`any\\`) is not a contract. Behavior goes through events → ActionPort, which is the door that creates an edge in the graph.`,\n        severity: \"error\",\n        path: [\"contexts\", name],\n        address: addressOf([\"contexts\", name]),\n        source: name,\n      });\n  }\n  return issues;\n}\n\n/**\n * O resolvedor de `params` dos UPDATES locais de um componente: `action` → o `Schema` declarado.\n * Ausente para o update que não os declara (e para a ação do host, que não mora aqui).\n */\nexport function declaredParamsOf(\n  updates: Record<string, { params?: PropsDecl }> | undefined,\n  types: TypeCatalog = {},\n): (action: string) => Schema | undefined {\n  return (action) => {\n    const decl = updates?.[action]?.params;\n    return decl ? resolveProps(decl, types) : undefined;\n  };\n}\n\n/**\n * O resolvedor de `params` das ações do HOST — o `paramsOf` do Tier 1 do contrato, projetado\n * pelo `ActionPort`.\n *\n * A forma que o contrato publica é **JSON Schema**, que é a borda que o `TypeRef` já atravessa.\n * Sem porta, ou sem `paramsOf` nela, o resolvedor devolve `undefined` em tudo — e **ausente não\n * é erro**: uma implementação que não publica assinatura não afirmou nada, e quem não afirmou não\n * pode ser contrariado. É a mesma assimetria do contexto.\n */\nexport function hostParamsOf(\n  port: { paramsOf?(action: string): unknown } | undefined,\n  types: TypeCatalog = {},\n): (action: string) => Schema | undefined {\n  return (action) => {\n    const schema = port?.paramsOf?.(action);\n    return schema === undefined || schema === null\n      ? undefined\n      : resolveTypeRef(schema as TypeRef, types);\n  };\n}\n\n/**\n * A ordem de resolução do RUNTIME, espelhada no check: **update local primeiro, host depois**.\n *\n * Espelhar não é elegância — é correção. Se o check consultasse o host antes, um componente com\n * um update chamado `salvar` seria provado contra a action `salvar` da aplicação, que é outra\n * coisa, e o erro apontaria para um contrato que aquele nome nem alcança em runtime.\n */\nexport function paramsResolver(\n  ...resolvers: readonly ((action: string) => Schema | undefined)[]\n): (action: string) => Schema | undefined {\n  return (action) => {\n    for (const resolve of resolvers) {\n      const found = resolve(action);\n      if (found) return found;\n    }\n    return undefined;\n  };\n}\n\n/**\n * O tipo de um `set` de ação local: o estado declarado, com **tudo opcional**.\n *\n * Um `set` é uma atualização PARCIAL — escrever um campo não obriga a escrever os outros. É o\n * mesmo mecanismo do call-site, sobre outra superfície: o objeto vai anotado com este tipo, e o\n * motor acusa `not-assignable` no campo com o tipo errado e `excess-property` na chave que o\n * estado não declara.\n *\n * O `optional` aqui é por outra razão que o das props, e por isso o tipo NÃO ganha `| undefined`:\n * o campo do estado não é opcional — a ESCRITA é que é parcial. Escrever `undefined` num campo\n * `number` continua errado.\n */\nexport function partialStateType(\n  state: Record<string, { type: TypeRef }> | undefined,\n  types: TypeCatalog = {},\n): Schema {\n  return s.object(\n    Object.fromEntries(\n      Object.entries(state ?? {}).map(([k, decl]) => [\n        k,\n        { type: resolveTypeRef(decl.type, types), optional: true },\n      ]),\n    ),\n  );\n}\n\n/**\n * Um tipo de objeto com TODO campo opcional — a forma de uma aplicação PARCIAL.\n *\n * É o que prova um alias de comando: os params que ele liga têm de caber na ação e não podem\n * sobrar, mas faltar é legítimo, porque o resto vem de quem dispara. Não ganha `| undefined`\n * pela mesma razão do `partialStateType`: o que é parcial é a escrita, não o campo.\n */\nexport function partialOf(schema: Schema): Schema {\n  const o = schema as {\n    t?: string;\n    props?: Record<string, { type: Schema; optional?: boolean }>;\n  };\n  if (o?.t !== \"object\" || !o.props) return schema;\n  return {\n    ...o,\n    props: Object.fromEntries(\n      Object.entries(o.props).map(([key, field]) => [\n        key,\n        { ...field, optional: true },\n      ]),\n    ),\n  } as Schema;\n}\n\n/** um `TypeRef` que não resolve. Mesma forma do `CheckIssue`, sem `span`: não há texto onde\n *  pousar — a declaração É o nome. */\nexport interface DeclarationIssue {\n  code: \"unknown-type-name\";\n  message: string;\n  severity: \"error\";\n  /** o caminho da declaração: `[\"props\", \"n\"]`, `[\"state\", \"aberto\"]`, `[\"contexts\", \"@app/x\"]`. */\n  path: CompiledPath;\n  address: string;\n  source: string;\n}\n\n/**\n * O resolvedor de props para o call-site: `type` → o `Schema` que o componente declara.\n *\n * É o seam entre o `SystemIR` (quem sabe o que existe) e o lowering (que é transformação de\n * forma e não conhece registry). Memoiza: o mesmo chamado aparece em muitos call-sites.\n */\nexport function declaredPropsOf(\n  sys: SystemIR,\n  types: TypeCatalog = {},\n): (type: string) => Schema | undefined {\n  const cache = new Map<string, Schema | undefined>();\n  return (type) => {\n    if (cache.has(type)) return cache.get(type);\n    const ir = sys.components.get(type);\n    const schema = ir ? componentType(ir, types).props : undefined;\n    cache.set(type, schema);\n    return schema;\n  };\n}\n\n/**\n * O tipo declarado de cada chave do estado — o que o `init` dela tem de render.\n *\n * É o mesmo `resolveTypeRef` das props: o `init` é uma expressão como qualquer outra, e o tipo\n * contra o qual ela é provada é o que o autor declarou ao lado.\n */\nexport function stateTypeOf(\n  state: Record<string, { type: TypeRef }> | undefined,\n  types: TypeCatalog = {},\n): (key: string) => Schema | undefined {\n  return (key) => {\n    const decl = state?.[key];\n    return decl ? resolveTypeRef(decl.type, types) : undefined;\n  };\n}\n\n/**\n * O tipo de UMA propriedade de um Schema de objeto — `undefined` quando não é objeto ou a\n * chave não existe.\n *\n * Lê a forma pública do `Schema` do TSLite (`{ t: \"object\", props: { k: { type } } }`), que é o\n * SSOT do tipo aqui. Serve ao `as` de um evento: quando o componente não declara o que emite, o\n * valor emitido vale o que a ação declarou para aquele param — quem não afirmou não é\n * contrariado.\n */\nexport function propTypeOf(schema: Schema, key: string): Schema | undefined {\n  const o = schema as { t?: string; props?: Record<string, { type?: Schema }> };\n  return o?.t === \"object\" ? o.props?.[key]?.type : undefined;\n}\n\n/**\n * O que uma ação do HOST devolve — o `resultOf` do Tier 1 da porta, em JSON Schema — como\n * `Schema`. É o tipo da raiz `event` no `then` de quem a executou (ADR-018). Ausente para a ação\n * sem retorno declarado: ali `event` é `unknown`.\n */\nexport function hostResultOf(\n  port: { resultOf?(action: string): unknown } | undefined,\n  types: TypeCatalog = {},\n): (action: string) => Schema | undefined {\n  return (action) => {\n    const schema = port?.resultOf?.(action);\n    return schema === undefined || schema === null\n      ? undefined\n      : resolveTypeRef(schema as TypeRef, types);\n  };\n}\n","import { createEnv, type Env } from \"@tslite/checker\";\nimport { ASSERTER, createBoundary } from \"@tslite/validate\";\nimport { s, type Schema } from \"@tslite/type-core\";\nimport { vanilla } from \"@tslite/operators\";\nimport { resolveProps, resolveTypeRef } from \"./props\";\nimport { isLive, type ComponentDef, type StateDecl } from \"@loom-forge/forge\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n   O AMBIENTE do checker — a projeção DIRETA do que o `ComponentDef` declara.\n\n   É isto que os namespaces compram: com raízes nomeadas, o `env` é um mapa\n   um-para-um (`props` → o schema das props, `state` → o schema do estado) e não há\n   regra de sombreamento para replicar. Com escopo achatado o checker teria de\n   reproduzir a precedência do binder, e regra duplicada diverge — quando divergisse,\n   o tipo mentiria.\n\n   A STDLIB entra por default (`vanilla`, as 53 assinaturas TSL). Não é conveniência:\n   o TSLite é FP e não tem protótipo, então sem operadores uma expressão não faz nada.\n\n   ── A FRONTEIRA DO `unknown`: o catálogo de tipos nomeados + o asserter ─────────\n   Não saber o tipo de algo não é errado; `any` é. O certo é `unknown` — e a única ponte\n   de `unknown` para tipado é o ASSERTER, que tipa em build e **prova em runtime**. Cast\n   não existe aqui: `as` seria tipar sem prova.\n\n   `types` registra cada tipo nomeado como HÍBRIDO — o mesmo nome como VALOR (em `vars`)\n   e como TIPO (em `types`) —, que é o que o checker exige, e declara o asserter. Quem monta\n   as duas metades é o `createBoundary` do `@tslite/validate`: a do checker entra aqui, a de\n   runtime vai para o binder, e as duas saem do MESMO catálogo. Errar\n   a referência deixou de ser silêncio: o `@tslite/checker` (≥ 0.9) diagnostica cada\n   forma no nó do argumento — `unknown-name` (o nome não existe), `type-as-value`,\n   `not-a-schema`, `asserter-needs-name`, `missing-argument` — e acusa `shadows-schema`\n   quando um binding local toma o nome de um schema.\n\n   E a sombra por `as` entra nessa conta **porque o lowering faz do `as` um parâmetro**\n   (`map((item) => …, xs)`): é um binding do programa, e o checker o vê. Fosse o item\n   injetado aqui como raiz, não haveria binding nenhum para o checker morder.\n\n   Sem `types`, nada disso custa: não há asserter no `env` e a guarda é gratuita.\n\n   ── A OUTRA METADE mora no BINDER, e é do chamador ──────────────────────────────\n   Tipar é metade; a outra é PROVAR, em runtime. O host monta a fronteira uma vez, do\n   mesmo catálogo, e entrega ao binder a metade de runtime:\n\n       const boundary = createBoundary({ types: { Address }, reserved: Object.keys(vanilla) });\n       createTsliteBinder({ boundary });\n\n   Não embutimos isso no binder: quem não usa asserter não deve pagar o validador, e o\n   `@loom-forge/tslite` não importa o `validate` — recebe só o `runtime`. Provisão é do\n   host — a mesma doutrina do `ActionPort`.\n   ────────────────────────────────────────────────────────────────────────────── */\n\n/**\n * O nome do asserter no escopo: `parseAs`, publicado pelo `@tslite/validate`. Não é `parse` porque\n * a stdlib já tem um — o `JSON.parse` (`(text: string) => unknown`) —, e os dois consumidores do\n * TSLite chegaram ao mesmo nome pelo mesmo obstáculo.\n */\nexport const DEFAULT_ASSERTER: string = ASSERTER;\n\n/**\n * A raiz `ctx` — só o que o componente DECLAROU usar, e só se o catálogo conhecer o nome.\n *\n * Um nome usado e ausente do catálogo não vira `unknown` calado: ele simplesmente não entra,\n * e a expressão que o lê acusa `no-such-member` no `ctx`. Quem diz que o contrato não existe\n * é a análise de contexto (`checkContexts`), que é quem tem o sistema na mão.\n */\nconst ctxRoot = (\n  def: ComponentDef,\n  contexts: Record<string, Schema> | undefined,\n): { ctx: Schema } | undefined => {\n  const uses = def.context?.uses ?? [];\n  if (!contexts || uses.length === 0) return undefined;\n  const shape: Record<string, { type: Schema }> = {};\n  for (const name of uses)\n    if (contexts[name]) shape[name] = { type: contexts[name] };\n  return { ctx: s.object(shape) };\n};\n\nconst stateSchema = (\n  state: Record<string, StateDecl> | undefined,\n  types: Record<string, Schema>,\n): Schema =>\n  s.object(\n    Object.fromEntries(\n      Object.entries(state ?? {}).map(([k, decl]) => [\n        k,\n        { type: resolveTypeRef(decl.type, types) },\n      ]),\n    ),\n  );\n\nexport interface BuildEnvOptions {\n  /**\n   * O catálogo de contextos do sistema — `nome → tipo`. A raiz `ctx` do componente é a\n   * **projeção** dele: catálogo ∩ `context.uses`.\n   *\n   * É assim que se tipa um escopo DINÂMICO: o **valor** vem da posição (quem montou), o\n   * **tipo** é global. Se cada provedor declarasse o tipo, o tipo do consumidor dependeria de\n   * qual provedor está acima — tipagem dinâmica, e aí não há prova.\n   *\n   * Sem catálogo, `ctx` não é raiz: um `ctx` vazio resolvendo `undefined` em silêncio seria\n   * pior que a ausência.\n   */\n  contexts?: Record<string, Schema>;\n  /** o tipo dos dados do host — a raiz `data` do render. Sem ele, `data` não é raiz. */\n  data?: Schema;\n  /** substitui a stdlib. Para acrescentar, espalhe: `{ ...vanilla, meu }`. */\n  operators?: Record<string, Schema>;\n  /**\n   * o catálogo de tipos NOMEADOS. Cada um entra como híbrido (valor + tipo) e habilita\n   * o asserter: `{{ parseAs(Address, data.x) }}` rende `Address` em vez de `unknown`.\n   * O mesmo catálogo precisa estar no `globals` do binder para a prova acontecer.\n   *\n   * Ele vale também como `TypeRef` nas DECLARAÇÕES — `props: { addr: \"Address\" }`.\n   */\n  types?: Record<string, Schema>;\n}\n\n/**\n * A chamada ao `createEnv`, num lugar só.\n *\n * O `createEnv` do checker é posicional (vars, types, …, asserters), e cada cópia da chamada é\n * uma que pode parar num argumento a menos — foi assim que o node-actions perdeu o asserter: uma\n * cópia parou no quarto argumento e o `parseAs` virou `unknown-name` no campo. As duas raízes\n * daqui diferem só no que entra em `vars`; o resto — o catálogo como valor e como tipo, o\n * asserter — é uma decisão, tomada uma vez.\n */\nconst envOf = (vars: Record<string, Schema>, opts: BuildEnvOptions): Env => {\n  const operators = opts.operators ?? vanilla;\n  // a metade do CHECKER da fronteira: o catálogo como valor e como tipo, mais o asserter. Um\n  // tipo com o nome de um operador ou de uma raiz colide na montagem — erro de quem monta o\n  // sistema, não diagnóstico do programa.\n  const boundary = createBoundary({\n    types: opts.types ?? {},\n    reserved: [...Object.keys(operators), ...Object.keys(vars)],\n  });\n  return createEnv(\n    { ...operators, ...boundary.check.vars, ...vars },\n    { types: boundary.check.types, asserters: boundary.check.asserters },\n  );\n};\n\n/**\n * Monta o `Env` de um componente a partir das declarações. As raízes são as mesmas do\n * runtime — `props`, `state`, e `data` quando o chamador declara o tipo dos dados —, o\n * que é o que faz o que o checker prova valer para o que o binder executa.\n */\nexport function buildEnv(def: ComponentDef, opts: BuildEnvOptions = {}): Env {\n  const types = opts.types ?? {};\n  return envOf(\n    {\n      props: resolveProps(def.props, types),\n      state: stateSchema(def.state, types),\n      ...(opts.data ? { data: opts.data } : {}),\n      ...(ctxRoot(def, opts.contexts) ?? {}),\n      // o PENDENTE é fato de uma INSTÂNCIA, e instância é o boundary de um componente vivo: só\n      // ele tem a raiz. Num componente puro, `pending` é `unknown-name` — e o remédio é um update\n      // ou um efeito, que é o que o torna vivo (ADR-018).\n      ...(isLive(def) ? { pending: PENDING } : {}),\n    },\n    opts,\n  );\n}\n\n/** `pending[ação]` — `true` do despacho ao resultado de uma ação do host. */\nconst PENDING: Schema = s.record(s.boolean);\n\n/**\n * O `Env` do `init` — o escopo que SEMEIA o estado.\n *\n * Ele tem `props` e `ctx`, e **não** tem `state` (é o que está sendo definido) nem `params` (não\n * há chamada). É a mesma projeção que o runtime passa ao `initState`, e é por isso que ele existe\n * separado: no env do corpo, um `init` lendo `state` tiparia limpo e valeria `undefined`.\n */\nexport function buildInitEnv(\n  def: ComponentDef,\n  opts: BuildEnvOptions = {},\n): Env {\n  return envOf(\n    {\n      props: resolveProps(def.props, opts.types ?? {}),\n      ...(ctxRoot(def, opts.contexts) ?? {}),\n    },\n    opts,\n  );\n}\n","import * as b from \"@tslite/core/builders\";\nimport { EXPR_MARKER, isExprMarker } from \"@tslite/core\";\nimport type { Expression, Statement } from \"@tslite/core\";\nimport { parseExpression } from \"@tslite/parser\";\nimport { annotate, createAnchors, lowerValue, s } from \"@tslite/checker\";\nimport type { Anchors } from \"@tslite/checker\";\nimport type { Schema } from \"@tslite/type-core\";\nimport {\n  compile,\n  type CompileDiagnostic,\n  type CompiledIsland,\n} from \"@loom-forge/tslite/compile\";\nimport { FIELDS, slotOf, TREE } from \"@loom-forge/core\";\nimport type { CommandAlias, DefNode, EventBinding } from \"@loom-forge/core\";\nimport {\n  addressOf,\n  compileComponent,\n  compileDefinition,\n  EMPTY_MOUNT,\n  mountingOf,\n  mountScopesOf,\n  settledRoute,\n  type CompiledDefinition,\n  type CompiledPath,\n  type ComponentDef,\n  type Mounting,\n  type MountScope,\n  type RouteContext,\n} from \"@loom-forge/forge\";\nimport { partialOf, propTypeOf } from \"./props\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n   LOWERING — o componente vira um corpo de função TSL, e o `@tslite/checker` tipa.\n   Não se reimplementa typecheck: scope-flow, inferência e narrowing saem de graça, e\n   se faltar recurso de tipo ele nasce no TSLite, não aqui.\n\n   A FORMA BAIXADA NUNCA É EXECUTADA. Ela é uma ficção que existe só para ser tipada —\n   modela COMPORTAMENTO, não mecanismo. Por isso pode usar construções que o\n   `CapabilityProfile` do runtime proíbe: um `each` baixa como `map((item) => …)` mesmo\n   quando o profile do bind não permite lambda. Quem executa é o binder, sobre a árvore\n   compilada, e a expansão real produz N NÓS — não um valor.\n\n   ── CONSTRUA O AST, NÃO GERE TEXTO ──────────────────────────────────────────────\n   O corpo é montado com os `builders` do `@tslite/core` e entregue direto ao `check`.\n   Ele NUNCA vira texto: a partir de um parse os nós seriam do parser, e a volta do\n   diagnóstico ao campo passaria a depender de aritmética de posição — que é onde o\n   defeito silencioso mora. Sendo os nós NOSSOS, a âncora é a IDENTIDADE, e a posição\n   fica só para o span DENTRO do texto do campo que o autor escreveu.\n\n   ── A STRING É DERIVADA UMA VEZ ─────────────────────────────────────────────────\n   O lowering recebe a definição COMPILADA (a mesma que o bind executa) e as ilhas em\n   memória que a compilação guardou — nós do parser, com `loc` no texto do campo. Os\n   valores viram nós pelo `lowerValue` do checker, que carimba chave, `Property` e valor,\n   e entrega cada ilha pelo nó que já existe. Nada aqui reparseia o que o autor escreveu.\n\n   `print(ast)` (do `@tslite/printer`) deriva a forma legível quando alguém quer LER o\n   que está sendo tipado. É saída, não passo do pipeline.\n\n   É o padrão do `docs/LOWERING.md` do TSLite, e a prática do `checker-v2` do node-actions.\n   ────────────────────────────────────────────────────────────────────────────── */\n\n/** Um identificador JS válido? A chave de um param pode não ser (`\"user-id\"`), e aí o binding\n *  do frame ganha nome gerado — a chave do objeto continua sendo a literal exata. */\nconst IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;\n\nconst isRecord = (v: unknown): v is Record<string, unknown> =>\n  typeof v === \"object\" && v !== null && !Array.isArray(v) && !isExprMarker(v);\n\n/** sem sistema, nenhum `type` é componente conhecido: não há slot, e ninguém declara nada. */\nconst NO_SYSTEM: Pick<Mounting, \"slotScopesOf\" | \"vocabulary\"> = {\n  slotScopesOf: () => undefined,\n  vocabulary: new Set(),\n};\n\n/**\n * O que um `catch` recebe: o `error` do `ActionResult` — o contrato do `core`, fixo. O `data`\n * do erro é o que o host quiser, e por isso `unknown`.\n */\nconst ACTION_ERROR: Schema = s.object({\n  code: { type: s.string },\n  message: { type: s.string, optional: true },\n  data: { type: s.unknown, optional: true },\n});\n\n/** A definição compilada pela linguagem, com o que ela disse — o que o lowering consome. */\nexport type CompiledComponent = CompiledDefinition<\n  CompileDiagnostic,\n  CompiledIsland\n>;\n\n/**\n * A âncora de um nó do corpo baixado é o CAMINHO do campo que o produziu — a lista\n * (`[0, 1, \"props\", \"title\"]`, `[\"updates\", \"somar\", \"set\", \"n\"]`), em que índice e chave são\n * distintos no tipo. O endereço (`#0.1.props.title`) é derivado dela; o texto do campo, quando\n * há um, mora ao lado, em `texts`.\n */\nexport type NodeMap = Anchors<CompiledPath>;\n\n/** Uma raiz de expressão que o checker vai tipar, e de onde ela veio. */\nexport interface LoweredIsland {\n  readonly node: Expression;\n  readonly path: CompiledPath;\n  readonly address: string;\n  /** o texto do campo, como o autor o escreveu. Ausente quando a ilha já chegou compilada. */\n  readonly source?: string;\n}\n\nexport interface Lowered {\n  /** o corpo tipável. Entregue ao `check` como está — nunca impresso no caminho. */\n  program: Expression;\n  /** os `init` do estado, num corpo à parte: eles têm OUTRO escopo (`props` e `ctx`, só). */\n  inits?: Expression;\n  /** nó → caminho do campo, por identidade. */\n  anchors: NodeMap;\n  /** endereço → o texto do campo, para o span pousar nele. Inclui os nomes declarados (`as`). */\n  texts: ReadonlyMap<string, string>;\n  /**\n   * Endereço → o BLOCO do corpo baixado em que os slots daquele lugar foram emitidos: o de cada nó\n   * (`#0.1` — o bloco do `map` do `each` mais próximo, ou o do corpo) e o de cada update\n   * (`updates.somar` — o frame com `params`). É a porta para o escopo de um campo: o `scopeAt`\n   * do checker sobre esse bloco responde que nomes o campo enxerga, pela mesma análise que o tipa\n   * — inclusive para um campo vazio ou que não compilou. O que não está aqui (`effects`, o\n   * `provides` e os `commands` do componente) vive no bloco raiz de `program`; os `init`, em\n   * `inits`.\n   */\n  frames: ReadonlyMap<string, object>;\n  /** as raízes de expressão tipadas, na ordem em que foram emitidas. */\n  islands: readonly LoweredIsland[];\n  /** a definição que foi baixada — a compilada, com o que a compilação reclamou. */\n  compiled: CompiledComponent;\n  /**\n   * Endereços cujo `excess-property` não é confiável — a assinatura daquela ação pode ter\n   * envelhecido (ver `exhaustiveParams`). Quem julga é o `checkComponent`: ali o veredito vira\n   * aviso em vez de erro.\n   */\n  weak: ReadonlySet<string>;\n}\n\n/** A forma de um `each`: coleção (vira `map`) ou objeto (vira aplicação direta). */\nexport type DataShape = \"list\" | \"value\";\n\nexport interface LowerOptions {\n  /**\n   * A definição já COMPILADA pela linguagem — o mesmo artefato que a bancada mostra e o bind\n   * executa. Ausente, o lowering compila (`compileDefinition` com o `compile` da linguagem, sem\n   * profile: o eixo de sintaxe não é do check). Quem compilou uma vez passa o resultado, e a\n   * string não é derivada duas vezes.\n   */\n  compiled?: CompiledComponent;\n  /**\n   * A forma de cada `each` — quem chama sabe, porque já tipou a expressão.\n   * Default `\"list\"`: o caso do laço, que é o que o `as` existe para nomear.\n   */\n  shapeOf?: (expression: Expression) => DataShape;\n  /**\n   * *\"Que props este componente declara?\"* — a pergunta que o lowering FAZ e não responde.\n   *\n   * Ele é transformação de forma: não conhece registry, `SystemIR` nem `Schema`. Quem sabe é\n   * quem montou o sistema, e o seam entre os dois é este resolvedor (a mesma natureza do\n   * `TargetResolver` do `checker-v2`).\n   *\n   * **Ausente = nenhum call-site é tipado**, e não \"todos falham\": quem chama o lowering só\n   * para VER o corpo baixado não tem sistema para perguntar, e inventar um erro ali esconderia\n   * justamente o que essa pessoa foi olhar.\n   */\n  propsOf?: (type: string) => Schema | undefined;\n  /**\n   * O tipo declarado de cada contexto — o catálogo do sistema. É contra ele que um\n   * `provides` é provado: mesma máquina do call-site, quinta superfície.\n   * Ausente = as provisões não são tipadas.\n   */\n  contextOf?: (name: string) => Schema | undefined;\n  /**\n   * O tipo de um `set` de update local — o estado declarado, com tudo opcional\n   * (`partialStateType`). Ausente = as ações não são tipadas.\n   */\n  setType?: Schema;\n  /**\n   * O tipo dos `params` de cada update local, quando ela os declara. É o que tipa o corpo do update\n   * e o call-site do evento que a dispara. Sem declaração, `params` vale `unknown`.\n   */\n  paramsOf?: (action: string) => Schema | undefined;\n  /**\n   * A assinatura daquela ação é EXAUSTIVA? (default: sim)\n   *\n   * Só uma prova depende disso: \"esta chave não existe\". Com uma assinatura que pode divergir do\n   * que a implementação aceita — o `declared` do contrato —, acusar `excess-property` como ERRO é\n   * afirmar mais do que se sabe. Então o endereço entra em `weak`, e o julgamento vira aviso.\n   */\n  exhaustiveParams?: (action: string) => boolean;\n  /**\n   * O tipo declarado de cada chave do estado — o que o `init` dela tem de render.\n   *\n   * O `init` SEMEIA o estado a partir de `props`/`ctx`, e por isso ele é baixado num programa\n   * SEPARADO: o escopo dele não tem `state` (é o que está sendo definido) nem `params`. Tipar os\n   * dois no mesmo corpo deixaria passar um `init` que lê `state`, que em runtime é `undefined`.\n   */\n  stateTypeOf?: (key: string) => Schema | undefined;\n  /**\n   * O tipo do valor que um componente REGISTRADO emite num evento — `descriptor.meta.emits`.\n   *\n   * É o tipo da raiz `event` nos `params` desse evento (ADR-018). Sem declaração, `event` é\n   * `unknown` — e `unknown` num param tipado é acusado: quem não declarou o que emite não ganha\n   * um tipo de graça. Declarar é do kit; provar (`parseAs`) é do autor.\n   */\n  emitsOf?: (type: string, event: string) => Schema | undefined;\n  /**\n   * O tipo do que uma ação do HOST devolve — o `resultOf` do Tier 1 da porta. É o tipo da raiz\n   * `event` no `then` da intenção que a executou. Sem declaração, `unknown`.\n   */\n  resultOf?: (action: string) => Schema | undefined;\n  /**\n   * A montagem do SISTEMA (`mountingOf` do `@loom-forge/forge`) — o que responde o que um nome de\n   * comando EXECUTA num nó: o vocabulário que um chamado instala no próprio `$slot`, e os nomes\n   * que algum vocabulário declara.\n   *\n   * **Ausente = o documento é o sistema.** O que ele declara resolve dentro dele, um chamado\n   * desconhecido não tem slot, e um nome que só outro componente declararia vale como o id da\n   * porta — que é tudo o que dá para saber sem o resto.\n   */\n  mounting?: Pick<Mounting, \"slotScopesOf\" | \"vocabulary\">;\n}\n\n/** Baixa uma definição de componente num corpo TSL. */\nexport function lowerComponent(\n  authored: ComponentDef,\n  opts: LowerOptions = {},\n): Lowered {\n  const shapeOf = opts.shapeOf ?? ((): DataShape => \"list\");\n  const propsOf = opts.propsOf ?? ((): undefined => undefined);\n  const paramsOf = opts.paramsOf ?? ((): undefined => undefined);\n  const exhaustiveParams = opts.exhaustiveParams ?? ((): boolean => true);\n  /** endereços cuja prova de \"chave a mais\" não é confiável — ver `exhaustiveParams`. */\n  const weak = new Set<string>();\n  const contextOf = opts.contextOf ?? ((): undefined => undefined);\n  const emitsOf = opts.emitsOf ?? ((): undefined => undefined);\n  const resultOf = opts.resultOf ?? ((): undefined => undefined);\n\n  // a definição COMPILADA — a mesma que o bind executa —, e o que a compilação guardou dela: as\n  // ilhas em memória (com `loc` no texto do campo) e os campos que não compilaram\n  const compiled = opts.compiled ?? compileDefinition(authored, compile);\n  const def = compiled.def;\n  const nodes = new Map<string, Expression>();\n  const texts = new Map<string, string>();\n  /** o campo que não compilou ficou TEXTO na definição; tipá-lo como string seria uma cascata\n   *  do erro que a compilação já acusou. Ele entra como `null` — a ausência de valor. */\n  const failed = new Set<string>();\n  /* O `provides` e os `commands` do COMPONENTE são açúcar para os da raiz do corpo (a expansão\n     os junta, e a raiz ganha no mesmo nome), e o walk os baixa em `#0.provides.x`. A compilação\n     os endereça pelo caminho do slot (`provides.x`); aqui o mesmo nó responde pelos dois —\n     sem sobrescrever o que a raiz do corpo já declarou. */\n  const sugared = (address: string): string | undefined =>\n    address.startsWith(\"provides.\") || address.startsWith(\"commands.\")\n      ? `#0.${address}`\n      : undefined;\n  for (const island of compiled.islands) {\n    nodes.set(island.address, island.node);\n    texts.set(island.address, island.text);\n    const alias = sugared(island.address);\n    if (alias !== undefined && !nodes.has(alias)) {\n      nodes.set(alias, island.node);\n      texts.set(alias, island.text);\n    }\n  }\n  for (const d of compiled.diagnostics) {\n    failed.add(d.address);\n    const alias = sugared(d.address);\n    if (alias !== undefined) failed.add(alias);\n  }\n\n  const anchors = createAnchors<CompiledPath>();\n  const islands: LoweredIsland[] = [];\n  const frames = new Map<string, object>();\n  /** os nós cujo bloco ainda não existe — decidido quando o `each` mais próximo fecha o dele. */\n  const pendingFrames: string[] = [];\n  let temp = 0;\n  let call = 0;\n  let act = 0;\n  let evt = 0;\n  let ctxn = 0;\n  let ini = 0;\n  let aln = 0;\n\n  // o corpo com o açúcar do componente: o `provides` e os `commands` dele JUNTAM com os da raiz,\n  // como na expansão. É ESTE objeto que o walk anda — os escopos de montagem são por identidade.\n  const root: DefNode = {\n    ...def.body,\n    ...(def.provides\n      ? { provides: { ...def.provides, ...def.body.provides } }\n      : {}),\n    ...(def.commands\n      ? { commands: { ...def.commands, ...def.body.commands } }\n      : {}),\n  };\n\n  /* O que um nome de comando EXECUTA em cada nó — a resposta do forge, nos degraus da expansão.\n     O vocabulário do próprio documento conta mesmo sem sistema: um nome que ele declara em algum\n     lugar não é id só porque aquele nó não está coberto. */\n  const mounting = opts.mounting ?? NO_SYSTEM;\n  const scopesAt = mountScopesOf(root, mounting);\n  const routing: RouteContext = {\n    updates: new Set(Object.keys(def.updates ?? {})),\n    vocabulary: new Set([\n      ...mountingOf([\n        compileComponent(def, { components: new Set([def.component]) }),\n      ]).vocabulary,\n      ...mounting.vocabulary,\n    ]),\n  };\n\n  /** Um NOME que o autor escreveu num campo (o `as`, a chave de um param) — o campo inteiro é o\n   *  token. Carimbado e com texto, para o erro pousar nele. */\n  const nameNode = (name: string, path: CompiledPath): Expression => {\n    const address = addressOf(path);\n    texts.set(address, name);\n    const node = b.identifier(name) as unknown as Expression;\n    islands.push({ node, path, address, source: name });\n    return anchors.stamp(node, path);\n  };\n\n  /**\n   * Um CAMINHO observado (`effects.on`) é uma expressão tipável — `props.idd` baixa como\n   * `props.idd`, e o `no-such-member` cai do motor. Ele não é ilha e não passa pela compilação,\n   * então é parseado aqui; o que não parseia é ignorado (o texto do caminho não é slot).\n   */\n  const fromPath = (\n    observed: string,\n    path: CompiledPath,\n  ): Expression | undefined => {\n    try {\n      const node = parseExpression(observed) as unknown as Expression;\n      const address = addressOf(path);\n      texts.set(address, observed);\n      islands.push({ node, path, address, source: observed });\n      return anchors.stamp(node, path);\n    } catch {\n      return undefined;\n    }\n  };\n\n  /**\n   * Um VALOR compilado vira uma expressão tipável, de nós PRÓPRIOS e carimbados — o `lowerValue`\n   * do checker. Cada ilha entra pelo nó em memória que a compilação guardou (com `loc` no texto\n   * do campo); uma ilha que chegou já compilada (sem texto) é decodificada por ele, sem posição.\n   * O campo que não compilou é `null`.\n   *\n   * A construção é UMA, para todos os destinos: a posição solta, o objeto de props de um\n   * call-site, o `set` de um update. Um `excess-property` pousa na CHAVE (como o `tsc`); um\n   * `not-assignable` do objeto inteiro pousa no objeto.\n   */\n  const lowerAt = (\n    value: unknown,\n    path: CompiledPath,\n    /** As chaves que não vêm do documento — o valor EMITIDO (`as`) e o que a camada de\n     *  comando resolve. Cada uma traz o próprio caminho, para o erro pousar no campo que a\n     *  declarou, e não no objeto. */\n    extras: readonly {\n      key: string;\n      value: Expression;\n      path: CompiledPath;\n    }[] = [],\n  ): Expression => {\n    const expr = lowerValue(prepared(value, path), path, anchors, {\n      child: (p, key) => [...p, key],\n      island: (marker, p) => {\n        const address = addressOf(p);\n        const node =\n          nodes.get(address) ??\n          (b.fromExprMarker(marker as never) as Expression);\n        const source = texts.get(address);\n        islands.push({\n          node,\n          path: p,\n          address,\n          ...(source ? { source } : {}),\n        });\n        return node;\n      },\n    });\n    if (extras.length > 0 && expr.type === \"ObjectExpression\")\n      for (const extra of extras)\n        (expr as { properties: unknown[] }).properties.push(\n          anchors.stamp(\n            b.property(\n              b.literal(extra.key) as never,\n              extra.value as never,\n            ) as object,\n            extra.path,\n          ),\n        );\n    return expr;\n  };\n\n  /** a marca que faz o `lowerValue` pedir a ilha a nós — e nós respondemos pelo endereço. */\n  const ISLAND: object = { [EXPR_MARKER]: \"Island\" };\n\n  /**\n   * O valor pronto para baixar, decidido POR ENDEREÇO, e não pela forma:\n   *\n   * - onde a compilação guardou uma ilha em memória, entra a marca — mesmo que a forma\n   *   serializada ali seja um objeto, porque o codec ACHATA um literal (`{{ { a: x } }}` vira\n   *   `{ a: <ilha> }`). Descer por chave tiparia o objeto achatado, e o erro pousaria numa\n   *   chave que o autor não escreveu, sem o texto do campo;\n   * - o campo que não compilou (ficou texto) entra como `null`.\n   */\n  const prepared = (value: unknown, path: CompiledPath): unknown => {\n    const address = addressOf(path);\n    if (nodes.has(address)) return ISLAND;\n    if (typeof value === \"string\") return failed.has(address) ? null : value;\n    if (Array.isArray(value))\n      return value.map((x, i) => prepared(x, [...path, i]));\n    if (isRecord(value))\n      return Object.fromEntries(\n        Object.entries(value).map(([k, v]) => [k, prepared(v, [...path, k])]),\n      );\n    return value;\n  };\n\n  const stmt = (e: Expression): Statement =>\n    b.expressionStatement(e as never) as unknown as Statement;\n\n  const body: Statement[] = [];\n  const initBody: Statement[] = [];\n  const push = (st: Statement | undefined): void => {\n    if (st) body.push(st);\n  };\n\n  /** Tem alguma ilha aqui dentro? Valor 100% literal não tem o que tipar. */\n  const hasIsland = (v: unknown): boolean => {\n    if (isExprMarker(v)) return true;\n    if (Array.isArray(v)) return v.some(hasIsland);\n    if (v && typeof v === \"object\") return Object.values(v).some(hasIsland);\n    return false;\n  };\n\n  /**\n   * Um valor de slot vira UMA posição tipada.\n   *\n   * `expects` é o tipo que o slot EXIGE (`boolean` num `when`): ele entra como **anotação de\n   * Schema** num binding — `annotate` do checker —, não como texto de tipo. Um `when` que\n   * renda `string` vira `not-assignable` na autoria, em vez de um nó sempre-visível em produção.\n   */\n  const emitValue = (\n    v: unknown,\n    path: CompiledPath,\n    expects?: string,\n  ): void => {\n    if (!hasIsland(v)) return; // literal puro: dado do host, nada a tipar\n    const e = lowerAt(v, path);\n    push(\n      expects === \"boolean\"\n        ? (b.variableDeclaration(\"const\", [\n            b.variableDeclarator(\n              annotate(b.identifier(`__t${temp++}`), s.boolean) as never,\n              e as never,\n            ),\n          ]) as unknown as Statement)\n        : stmt(e),\n    );\n  };\n\n  /**\n   * UMA intenção — de um evento ou de um efeito — e a CADEIA dela (ADR-018).\n   *\n   * O objeto de `params` é um CALL-SITE sobre a assinatura da ação que ela EXECUTA, e quem diz\n   * qual é a rota do forge (`settledRoute`), nos degraus da expansão: update local, vocabulário\n   * de comando, porta. Ele é tipado DENTRO de um frame cujo parâmetro é `event` — o que a\n   * intenção recebeu, com o tipo que quem o produziu declarou: o `emits` do widget, o\n   * `resultOf` da ação anterior num `then`, o contrato do erro num `catch`, `undefined` depois de\n   * um update local. Sem declaração, `unknown` — e `unknown` num param tipado é o erro que é.\n   *\n   * Sem UMA ação em todo lugar onde a intenção monta — um nome de vocabulário que depende de onde\n   * o componente monta, ou dois lugares que o resolvem diferente —, não há assinatura contra a\n   * qual provar: só as expressões de dentro são tipadas. E sem assinatura publicada, idem.\n   *\n   * `then` e `catch` são emitidos DENTRO do frame: cada elo abre o próprio `event`, que sombreia\n   * o de fora — como numa promise chain.\n   */\n  const emitIntent = (\n    intent: EventBinding,\n    /** o caminho da intenção: `[0, \"events\", \"onClick\"]`, `[\"effects\", \"carregar\"]`. */\n    path: CompiledPath,\n    scopes: readonly MountScope[],\n    /** o tipo do `event` que esta intenção recebe. */\n    received: Schema,\n  ): void => {\n    const at: CompiledPath = [...path, \"params\"];\n    const route =\n      typeof intent.action === \"string\"\n        ? settledRoute(intent.action, scopes, routing)\n        : undefined;\n    const target =\n      route === undefined || route.kind === \"command\"\n        ? undefined\n        : route.action;\n    const declared = target === undefined ? undefined : paramsOf(target);\n    if (declared && target !== undefined && !exhaustiveParams(target))\n      weak.add(addressOf(at));\n\n    /* As chaves que NÃO vêm do objeto de params, e por isso não podem faltar: o que a camada de\n     * COMANDO preenche (`resolve`) e o que um apelido de sessão já ligou (a aplicação parcial).\n     * Cada uma vira um PARÂMETRO do frame, tipado, e o objeto de params o referencia — a chave\n     * deixa de faltar sem ninguém inventar um valor. */\n    const supplied: { key: string; type?: Schema; path: CompiledPath }[] = [];\n    for (const key of intent.resolve ?? [])\n      if (typeof key === \"string\")\n        supplied.push({\n          key,\n          ...(declared && propTypeOf(declared, key)\n            ? { type: propTypeOf(declared, key) }\n            : {}),\n          path: [...path, \"resolve\"],\n        });\n    if (\n      declared &&\n      route &&\n      route.kind !== \"command\" &&\n      isRecord(route.bound)\n    ) {\n      const written = isRecord(intent.params) ? intent.params : {};\n      for (const key of Object.keys(route.bound))\n        if (\n          !(key in written) &&\n          !supplied.some((s) => s.key === key) &&\n          propTypeOf(declared, key)\n        )\n          supplied.push({\n            key,\n            type: propTypeOf(declared, key),\n            path: [...path, \"action\"],\n          });\n    }\n    // o nome do parâmetro é a própria chave quando ela é um identificador; senão, um gerado —\n    // a chave do objeto continua sendo a literal exata, e só o binding muda de nome.\n    const named = supplied.map((s, i) => ({\n      ...s,\n      local: IDENTIFIER.test(s.key) && s.key !== \"event\" ? s.key : `__s${i}`,\n    }));\n\n    const inner: Statement[] = [];\n    if (intent.params !== undefined) {\n      if (declared && isRecord(intent.params))\n        inner.push(\n          b.variableDeclaration(\"const\", [\n            b.variableDeclarator(\n              annotate(b.identifier(`__e${evt++}`), declared) as never,\n              lowerAt(\n                intent.params,\n                at,\n                named.map((s) => ({\n                  key: s.key,\n                  value: b.identifier(s.local) as unknown as Expression,\n                  path: s.path,\n                })),\n              ) as never,\n            ),\n          ]) as unknown as Statement,\n        );\n      else if (hasIsland(intent.params))\n        inner.push(stmt(lowerAt(intent.params, at)));\n    } else if (declared && named.length > 0)\n      // sem `params` escritos, o que o alias e o `resolve` ligam ainda é o call-site inteiro\n      inner.push(\n        b.variableDeclaration(\"const\", [\n          b.variableDeclarator(\n            annotate(b.identifier(`__e${evt++}`), declared) as never,\n            lowerAt(\n              {},\n              at,\n              named.map((s) => ({\n                key: s.key,\n                value: b.identifier(s.local) as unknown as Expression,\n                path: s.path,\n              })),\n            ) as never,\n          ),\n        ]) as unknown as Statement,\n      );\n\n    // a CADEIA, dentro do frame: o `then` recebe o que a ação devolve (o `resultOf` do host; nada\n    // depois de um update local); o `catch`, o contrato do erro\n    const outer = body.length;\n    if (intent.then)\n      emitIntent(\n        intent.then,\n        [...path, \"then\"],\n        scopes,\n        route?.kind === \"update\"\n          ? s.undefined\n          : ((target === undefined ? undefined : resultOf(target)) ??\n              s.unknown),\n      );\n    if (intent.catch)\n      emitIntent(intent.catch, [...path, \"catch\"], scopes, ACTION_ERROR);\n    inner.push(...body.splice(outer));\n\n    if (inner.length === 0) return;\n    // o frame: `event` primeiro, com o tipo recebido; depois o que o alias e o `resolve` ligam\n    const event = annotate(b.identifier(\"event\"), received);\n    anchors.stamp(event as object, path);\n    push(\n      stmt(\n        b.arrowFunctionExpression(\n          [\n            event as never,\n            ...named.map((s) => {\n              const param = nameNode(s.local, s.path);\n              return (\n                s.type ? annotate(param as never, s.type) : param\n              ) as never;\n            }),\n          ],\n          b.blockStatement(inner as never) as never,\n        ) as unknown as Expression,\n      ),\n    );\n  };\n\n  /** a expressão de um campo que é `{{ e }}` inteira — `each` só aceita essa forma. Compilado,\n   *  ele é uma ilha; texto é o campo que não compilou (ou não era expressão). */\n  const wholeOf = (v: unknown): object | undefined =>\n    isExprMarker(v) ? (v as object) : undefined;\n\n  /**\n   * Os `init` do estado — o que SEMEIA cada chave.\n   *\n   * Eles vão para um corpo PRÓPRIO porque o escopo é outro: `props` e `ctx`, sem `state` (é o que\n   * está sendo definido) e sem `params` (não há chamada). No mesmo corpo, um `init` lendo `state`\n   * tiparia limpo e valeria `undefined` em runtime.\n   */\n  const emitInits = (): void => {\n    for (const [key, decl] of Object.entries(def.state ?? {})) {\n      if (decl.init === undefined) continue;\n      const at: CompiledPath = [\"state\", key, \"init\"];\n      if (!hasIsland(decl.init) && failed.has(addressOf(at))) continue;\n      const expr = lowerAt(decl.init, at);\n      const type = opts.stateTypeOf?.(key);\n      const id = b.identifier(`__i${ini++}`);\n      initBody.push(\n        b.variableDeclaration(\"const\", [\n          b.variableDeclarator(\n            (type ? annotate(id, type) : id) as never,\n            expr as never,\n          ),\n        ]) as unknown as Statement,\n      );\n    }\n  };\n\n  /**\n   * Os UPDATES LOCAIS — a perna que faltava do anel: props entram, `state` é lido, e aqui ele é\n   * ESCRITO. Um `set` é um call-site sobre o estado: o objeto vai anotado com o estado declarado\n   * (tudo opcional, porque a atualização é parcial), e o motor acusa o campo com o tipo errado e\n   * a chave que o estado não declara.\n   *\n   * O corpo de cada update abre um frame com `params` — os argumentos daquela chamada —, tipado\n   * com o que o update declara. Sem declaração, `unknown`: um binding do programa, honesto, em\n   * vez de um nome que não existe (que daria `unknown-name` num código legítimo).\n   */\n  const emitActions = (): void => {\n    const setType = opts.setType;\n    if (!setType) return;\n    for (const [name, action] of Object.entries(def.updates ?? {})) {\n      const set = (action as { set?: Record<string, unknown> }).set;\n      if (set === undefined) continue;\n      const frame: CompiledPath = [\"updates\", name];\n      const decl = b.variableDeclaration(\"const\", [\n        b.variableDeclarator(\n          annotate(b.identifier(`__s${act++}`), setType) as never,\n          lowerAt(set, [...frame, \"set\"]) as never,\n        ),\n      ]) as unknown as Statement;\n      const param = annotate(\n        b.identifier(\"params\"),\n        paramsOf(name) ?? s.unknown,\n      );\n      anchors.stamp(param as object, frame);\n      const block = b.blockStatement([decl] as never) as object;\n      frames.set(addressOf(frame), block);\n      // a arrow NÃO é chamada: o corpo tipa igual, e inventar um argumento inventaria um erro.\n      push(\n        stmt(\n          b.arrowFunctionExpression(\n            [param as never],\n            block as never,\n          ) as unknown as Expression,\n        ),\n      );\n    }\n  };\n\n  /**\n   * Os EFEITOS. Um efeito é um events-out cujo gatilho é uma mudança — então ele tipa como um\n   * evento, pelo mesmo `emitIntent`: os `params` contra a assinatura da ação que ele executa, e o\n   * cleanup igual.\n   *\n   * A rota é a do lugar onde o COMPONENTE montou: o efeito é intenção do componente, não de um nó\n   * do corpo, e o `commands` do componente instala para o corpo, não para si.\n   *\n   * E o `on` é tipado porque um CAMINHO é uma expressão: `on: [\"props.idd\"]` baixa como\n   * `props.idd` e o `no-such-member` cai do motor, sem regra nova.\n   */\n  const emitEffects = (): void => {\n    for (const [name, effect] of Object.entries(def.effects ?? {})) {\n      const at: CompiledPath = [\"effects\", name];\n      effect.on.forEach((observed, i) => {\n        const e = fromPath(observed, [...at, \"on\", i]);\n        if (e) push(stmt(e));\n      });\n      emitIntent(effect, at, [EMPTY_MOUNT], s.undefined);\n      if (effect.cleanup)\n        emitIntent(\n          effect.cleanup,\n          [...at, \"cleanup\"],\n          [EMPTY_MOUNT],\n          s.undefined,\n        );\n    }\n  };\n\n  const walk = (node: DefNode, path: CompiledPath): void => {\n    const base = path;\n    const data = wholeOf(node.each);\n    const binding = typeof node.as === \"string\" ? node.as : undefined;\n\n    const inner: Statement[] = [];\n    const outer = body.length;\n    // o bloco deste nó só existe quando o `each` mais próximo fechar o dele — ou o corpo\n    const pending = pendingFrames.length;\n    pendingFrames.push(addressOf(base));\n\n    // O CALL-SITE de um componente custom: as props passadas viram um objeto ANOTADO com o\n    // tipo que o chamado declara, e o `not-assignable`/`excess-property` cai do próprio motor,\n    // no nó certo. Sem isso, uma prop vinda de expressão passava como `any`.\n    //\n    // Note que o runtime INLINA o corpo do chamado (a expansão é macro, não chamada) — e ainda\n    // assim a forma tipável é a CHAMADA. Tipar o corpo inlinado conferiria as entranhas do\n    // chamado em cada call-site, e o erro apontaria dentro dele em vez de na chamada que o\n    // autor escreveu. O lowering modela COMPORTAMENTO, não mecanismo.\n    const callee =\n      node.el == null && typeof node.type === \"string\"\n        ? propsOf(node.type)\n        : undefined;\n\n    for (const [field, role] of Object.entries(FIELDS)) {\n      if (role !== \"slot\" || field === \"each\") continue;\n      if (field === \"props\" && callee) continue; // sai pelo call-site, logo abaixo\n      if (field === \"provides\") continue; // sai anotado contra o catálogo, logo abaixo\n      const value = (node as unknown as Record<string, unknown>)[field];\n      if (value === undefined) continue;\n      const decl = slotOf(field);\n      if (field === \"commands\") {\n        // um ALIAS é aplicação PARCIAL: o que ele liga tem de caber na ação e não pode sobrar,\n        // mas faltar é legítimo — o resto vem de quem dispara. Então ele é provado contra a\n        // assinatura com tudo opcional, e a chave a mais é acusada AQUI, onde foi escrita. O que\n        // falta é do disparo, e o disparo é provado no EVENTO, contra a ação resolvida.\n        for (const [name, alias] of Object.entries(\n          value as Record<string, CommandAlias>,\n        )) {\n          if (typeof alias === \"string\") continue;\n          const at: CompiledPath = [...base, \"commands\", name, \"params\"];\n          const declared = paramsOf(alias.action);\n          if (!declared || !isRecord(alias.params)) {\n            emitValue(alias.params, at);\n            continue;\n          }\n          if (!exhaustiveParams(alias.action)) weak.add(addressOf(at));\n          push(\n            b.variableDeclaration(\"const\", [\n              b.variableDeclarator(\n                annotate(\n                  b.identifier(`__a${aln++}`),\n                  partialOf(declared),\n                ) as never,\n                lowerAt(alias.params, at) as never,\n              ),\n            ]) as unknown as Statement,\n          );\n        }\n      } else if (decl?.shape === \"intentParams\") {\n        // cada evento, visto de TODO lugar onde este nó monta\n        const scopes = scopesAt.get(node) ?? [];\n        for (const [name, binding] of Object.entries(\n          value as Record<string, EventBinding>,\n        ))\n          emitIntent(\n            binding,\n            [...base, field, name],\n            scopes,\n            (node.el == null && node.type !== undefined\n              ? emitsOf(node.type, name)\n              : undefined) ?? s.unknown,\n          );\n      } else emitValue(value, [...base, field], decl?.expects);\n    }\n\n    // O `provides` é um call-site sobre o CATÁLOGO: cada nome provido é conferido contra o\n    // tipo que o sistema declarou para ele. Um nome fora do catálogo não tem contra o que\n    // provar — quem acusa isso é a análise de contexto, que tem o sistema na mão.\n    if (node.provides)\n      for (const [name, value] of Object.entries(node.provides)) {\n        const declared = contextOf(name);\n        const at: CompiledPath = [...base, \"provides\", name];\n        if (!declared) {\n          emitValue(value, at);\n          continue;\n        }\n        const e = lowerAt(value, at);\n        push(\n          b.variableDeclaration(\"const\", [\n            b.variableDeclarator(\n              annotate(b.identifier(`__x${ctxn++}`), declared) as never,\n              e as never,\n            ),\n          ]) as unknown as Statement,\n        );\n      }\n\n    if (callee)\n      push(\n        b.variableDeclaration(\"const\", [\n          b.variableDeclarator(\n            annotate(b.identifier(`__c${call++}`), callee) as never,\n            lowerAt(node.props ?? {}, [...base, \"props\"]) as never,\n          ),\n        ]) as unknown as Statement,\n      );\n\n    // a ÁRVORE — dirigida pela tabela, como na compilação: `children` e o `fallback`, que é nó\n    for (const [field, shape] of Object.entries(TREE)) {\n      const value = (node as unknown as Record<string, unknown>)[field];\n      if (value === undefined) continue;\n      if (shape === \"list\" && Array.isArray(value))\n        value.forEach((child, i) => walk(child as DefNode, [...path, i]));\n      else if (shape === \"node\" && value && typeof value === \"object\")\n        walk(value as DefNode, [...path, field]);\n    }\n\n    if (!data || !binding) return;\n\n    // coleção baixa como `map((item) => { … }, xs)`: o tipo do item vem INFERIDO da\n    // coleção, sem anotação nenhuma. Objeto re-escopado é aplicação direta.\n    inner.push(...body.splice(outer));\n    const coll = lowerAt(data, [...base, \"each\"]);\n\n    // o nome do `as` é um nó CARIMBADO: o `shadows-schema` (o `as` tomando o nome de um\n    // tipo do catálogo) nasce no parâmetro, e é no campo `as` que o autor precisa vê-lo.\n    const param = nameNode(binding, [...base, \"as\"]);\n    const block = b.blockStatement(inner as never) as object;\n    // este nó e os descendentes sem `each` próprio enxergam o item: o bloco deles é este\n    for (const address of pendingFrames.splice(pending))\n      frames.set(address, block);\n    const fn = b.arrowFunctionExpression(\n      [param as never],\n      block as never,\n    ) as unknown as Expression;\n\n    push(\n      stmt(\n        shapeOf(coll) === \"list\"\n          ? (b.callExpression(b.identifier(\"map\") as never, [\n              fn as never,\n              coll as never,\n            ]) as unknown as Expression)\n          : (b.callExpression(fn as never, [\n              coll as never,\n            ]) as unknown as Expression),\n      ),\n    );\n  };\n\n  walk(root, [0]);\n  emitInits();\n  emitActions();\n  emitEffects();\n  // o corpo inteiro numa arrow: um frame só, que é o que dá scope-flow entre as posições.\n  const rootBlock = b.blockStatement(body as never) as object;\n  for (const address of pendingFrames.splice(0)) frames.set(address, rootBlock);\n  const program = b.arrowFunctionExpression(\n    [],\n    rootBlock as never,\n  ) as unknown as Expression;\n  // os `init` num frame à parte — outro escopo, outro `env` (ver `stateTypeOf`).\n  const inits = initBody.length\n    ? (b.arrowFunctionExpression(\n        [],\n        b.blockStatement(initBody as never) as never,\n      ) as unknown as Expression)\n    : undefined;\n  return {\n    program,\n    anchors,\n    texts,\n    frames,\n    islands,\n    compiled,\n    weak,\n    ...(inits ? { inits } : {}),\n  };\n}\n","import { PRESETS, type CapabilityProfile } from \"@tslite/capability\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n   O PROFILE que o checker recebe — derivado do profile do DEPLOY, e não ele.\n\n   O `CapabilityProfile` tem dois eixos, e cada um tem um dono aqui:\n\n     sintaxe   que NÓS a expressão pode conter    →  a COMPILAÇÃO (ADR-114 do `tslite`),\n                                                     com o bind como limite duro\n     tipos     `strict`: o `any` autorado e o cast  →  o CHECK — só o checker vê tipo\n               que estreita\n\n   Passar o profile do deploy inteiro ao checker faria duas coisas erradas. O nó do autor fora\n   do profile seria acusado duas vezes — pela compilação e por aqui, no mesmo campo. E o corpo\n   baixado é ANDAIME nosso (arrow, bloco, `const`, o `map` do `each`): ele modela comportamento,\n   não mecanismo, e não tem por que caber na superfície que o autor pode escrever. Hoje ele\n   cabe no `pure-fp`, mas isso é estado — um deploy sem lambda voltaria a acusar o `map` que\n   ninguém escreveu.\n\n   Então a sintaxe vai inteira (o `complete`, que é a Linguagem toda), e do deploy fica o eixo\n   de TIPOS. É o mesmo corte do `BODY_PROFILE` do `checker-v2` do node-actions, com uma\n   diferença: lá o corpo baixado precisa de nós que a ilha não tem (`throw`, `try`), e o profile\n   do corpo os declara um a um; aqui a pergunta é só a de tipo.\n   ────────────────────────────────────────────────────────────────────────────── */\n\n/**\n * O profile que vai ao `@tslite/checker`, a partir do profile do deploy: a sintaxe da Linguagem\n * inteira e o eixo `types` do deploy. Sem `types` no deploy, vale o do `complete` (sem `strict`).\n */\nexport const checkerProfileOf = (\n  deploy: CapabilityProfile,\n): CapabilityProfile => ({\n  ...PRESETS.complete,\n  name: `${deploy.name}:types`,\n  ...(deploy.types ? { types: deploy.types } : {}),\n});\n","import { anchorDiagnostics, check, spanOf, type Env } from \"@tslite/checker\";\nimport type { CheckResult, Diagnostic } from \"@tslite/checker\";\nimport { parseExpression } from \"@tslite/parser\";\nimport type { Expression } from \"@tslite/core\";\nimport type { Schema } from \"@tslite/type-core\";\nimport type { Span } from \"@tslite/language-service\";\nimport type { CapabilityProfile } from \"@tslite/capability\";\nimport { DEFAULT_PROFILE } from \"@loom-forge/tslite/compile\";\nimport { checkerProfileOf } from \"./profile\";\nimport {\n  checkDeclarations,\n  checkContextCatalog,\n  declaredParamsOf,\n  hostParamsOf,\n  hostResultOf,\n  paramsResolver,\n  declaredContextsOf,\n  partialStateType,\n  resolveTypeRef,\n  stateTypeOf,\n  type TypeCatalog,\n} from \"./props\";\nimport { buildInitEnv } from \"./env\";\nimport {\n  lowerComponent,\n  type CompiledComponent,\n  type DataShape,\n  type Lowered,\n  type LowerOptions,\n} from \"./lower\";\nimport {\n  addressOf,\n  type CompiledPath,\n  type ComponentDef,\n  type TypeRef,\n} from \"@loom-forge/forge\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n   CHECK DE COMPONENTE — dev/CI, nunca no hot path (ADR-206). Baixa o componente num\n   corpo TSL (AST, construído — ver `lower.ts`), deixa o `@tslite/checker` tipar, e\n   devolve cada diagnóstico ao CAMPO de origem.\n\n   TRÊS NÍVEIS DE PROVENIÊNCIA, e eles são independentes: o CAMINHO (sempre — e o\n   endereço é a exibição dele), a FONTE (quando o campo era texto) e o SPAN dentro dela\n   (idem). Um diagnóstico que nasce numa ilha já compilada tem caminho e não tem span —\n   a posição não existe, e inventá-la seria pior que não tê-la.\n\n   A volta é curta aqui: como a definição compilada preserva a forma da autorada, o\n   caminho já é a coordenada final — não há reancoragem por source map.\n   ────────────────────────────────────────────────────────────────────────────── */\n\nexport interface CheckIssue {\n  /** o código do checker (`no-such-member`, `unknown-name`, `not-assignable`…). */\n  code: string;\n  message: string;\n  severity: \"error\" | \"warning\";\n  /** o caminho do campo, como lista: `[0, 1, \"props\", \"title\"]` na árvore (a raiz é o nó `0`),\n   *  `[\"updates\", \"somar\", \"set\", \"n\"]` fora dela. Índice e chave são distintos no tipo. */\n  path: CompiledPath;\n  /** o caminho como o autor o lê: `#0.1.props.title`. Derivado de `path`. */\n  address: string;\n  /** o texto do campo, como o autor o escreveu — com o `{{ }}`, quando há. Ausente quando o\n   *  campo já vinha compilado. */\n  source?: string;\n  /** offsets dentro de `source`, na forma do `@tslite/language-service` (fim exclusivo) —\n   *  `source.slice(span.from, span.to)` é o trecho aceso. */\n  span?: Span;\n}\n\nexport interface CheckComponentOptions {\n  /** limites estruturais — o drawer do editor roda isto por tecla digitada. */\n  limits?: { maxDepth?: number; maxNodes?: number };\n  /**\n   * A definição já COMPILADA pela linguagem (`compileDefinition(def, compile)`), quando quem\n   * chama já a tem — a bancada, o serviço de linguagem. A string não é derivada duas vezes, e os\n   * diagnósticos da compilação são de quem compilou: com `compiled`, este check não os repete.\n   * Ausente, o check compila (sem profile — o eixo de sintaxe não é dele) e os reporta.\n   */\n  compiled?: CompiledComponent;\n  /**\n   * O `CapabilityProfile` do DEPLOY — o mesmo que o binder executa. Default: `DEFAULT_PROFILE`\n   * do `@loom-forge/tslite`.\n   *\n   * Daqui sai só o eixo de TIPOS (`types.strict`): o `any` autorado e o cast que estreita\n   * (`{{ (props.bruto as Endereco).cep }}` é `narrowing-cast-not-allowed`). O eixo de sintaxe —\n   * que nós a expressão pode conter — é da compilação, e acusá-lo aqui de novo seria o mesmo\n   * erro duas vezes no campo. Ver `profile.ts`.\n   */\n  profile?: CapabilityProfile;\n  /**\n   * O tipo de props que cada componente CHAMADO declara — o que liga o call-site.\n   *\n   * `declaredPropsOf(systemIR)` monta este resolvedor. **Ausente = nenhum call-site é tipado**:\n   * sem sistema não há o que comparar, e inventar um erro ali seria pior que o silêncio.\n   */\n  propsOf?: (type: string) => Schema | undefined;\n  /** o catálogo de tipos nomeados — o MESMO que foi para o `buildEnv`. Sem ele, um `TypeRef`\n   *  que seja nome de tipo é reportado como desconhecido, porque daqui ele não existe. */\n  types?: TypeCatalog;\n  /** o catálogo de CONTEXTOS do sistema (`nome → TypeRef`) — o que tipa um `provides`.\n   *  Ausente = as provisões não são provadas contra nada. */\n  contexts?: Record<string, TypeRef>;\n  /**\n   * O que cada componente REGISTRADO emite num evento (`descriptor.meta.emits`) — o tipo da raiz\n   * `event` nos `params` desse evento (ADR-018). Sem declaração, `event` é `unknown`, e `unknown`\n   * num param tipado é acusado: quem não declarou o que emite não ganha um tipo de graça.\n   */\n  emitsOf?: (type: string, event: string) => Schema | undefined;\n  /**\n   * A PORTA de ação do host — de onde sai a assinatura de uma ação que não é update local.\n   *\n   * Basta ter o `paramsOf` do Tier 1 (`ActionPort`, commander, ou um objeto com o método). Com\n   * ele, `events.params` de uma ação do host vira um call-site como o de componente: obrigatória\n   * faltando, tipo errado, chave a mais. **Ausente = a ação do host não é tipada** — e isso é\n   * silêncio, não erro: quem não publica assinatura não afirmou nada.\n   */\n  actions?: {\n    paramsOf?(action: string): unknown;\n    /** a forma do RETORNO, em JSON Schema — o tipo do `event` no `then` de quem a executa (ADR-018). */\n    resultOf?(action: string): unknown;\n    /** quanto vale a resposta — ver `ActionPort.provenanceOf`. Ausente = `declared`. */\n    provenanceOf?(query: string): string;\n  };\n  /**\n   * A montagem do sistema — `mountingOf(sys.components.values())`, do `@loom-forge/forge`. É o\n   * que responde o que um nome de COMANDO executa: um evento dentro do slot de uma sessão é\n   * provado contra a ação que o vocabulário da sessão escolhe.\n   *\n   * **Ausente = o documento é o sistema:** o que ele declara resolve dentro dele, e o resto vale\n   * como o id da porta.\n   */\n  mounting?: LowerOptions[\"mounting\"];\n}\n\n/**\n * A assinatura que o HOST publica é EXAUSTIVA?\n *\n * Só com `inferred` (o corpo é dado, e não pode divergir) ou `verified` (declarado e conferido em\n * runtime) dá para afirmar que uma chave NÃO existe. Com `declared` — ou sem proveniência nenhuma,\n * que é o caso de quase todo host — a declaração pode ter envelhecido, e `excess-property` vira\n * AVISO. Quem não afirmou de onde veio a resposta não ganha o direito de proibir uma chave.\n */\n/** O endereço cai sob algum params de assinatura fraca? (`#0.events.onClick.params.x`) */\nconst isWeak = (address: string, weak: ReadonlySet<string>): boolean => {\n  for (const prefix of weak)\n    if (address === prefix || address.startsWith(`${prefix}.`)) return true;\n  return false;\n};\n\nconst exhaustiveHostParams = (port?: {\n  provenanceOf?(query: string): string;\n}): boolean => {\n  const level = port?.provenanceOf?.(\"params\");\n  return level === \"inferred\" || level === \"verified\";\n};\n\n/* ── a volta do diagnóstico: identidade, e walk-up quando o nó não é carimbado ──── */\n\n/**\n * Cada diagnóstico do checker, levado ao campo que o produziu — o `anchorDiagnostics` do\n * `@tslite/checker`: sobe do nó acusado até o primeiro carimbado (o membro de um acesso não é\n * carimbado, a raiz da expressão é), cai no `fallback` quando nada responde, e converte o `loc`\n * do nó em span no texto do campo. Nó sem `loc` (builder, ilha já compilada) não tem span —\n * *ausente ≠ inventado*.\n */\nconst issuesOf = (\n  root: object,\n  diagnostics: readonly Diagnostic[],\n  lowered: Pick<Lowered, \"anchors\" | \"texts\">,\n  fallback: CompiledPath,\n): CheckIssue[] =>\n  anchorDiagnostics(root, diagnostics, lowered.anchors, {\n    fallback,\n    textOf: (path) => lowered.texts.get(addressOf(path)),\n  }).map(({ diagnostic, anchor, span }) => {\n    const address = addressOf(anchor);\n    const source = lowered.texts.get(address);\n    return {\n      code: String(diagnostic.code ?? \"error\"),\n      message: String(diagnostic.message ?? \"\"),\n      severity: diagnostic.severity === \"warning\" ? \"warning\" : \"error\",\n      path: anchor,\n      address,\n      ...(source === undefined ? {} : { source }),\n      ...(span === undefined ? {} : { span }),\n    };\n  });\n\n/**\n * A análise de um componente — o que o `checkComponent` deriva os issues, exposto para quem\n * projeta OUTRA coisa da mesma passada: o serviço de linguagem lê o `overlay` do corpo para\n * responder o escopo de um campo (`scopeAt` sobre `lowered.frames`), sem tipar de novo.\n */\nexport interface ComponentAnalysis {\n  /** os diagnósticos, ao campo — o que o `checkComponent` devolve. */\n  readonly issues: readonly CheckIssue[];\n  readonly lowered: Lowered;\n  /** o resultado do checker sobre o corpo: o overlay de tipo e escopo por nó. */\n  readonly body: CheckResult;\n  /** o `Env` que semeia o estado (`props` e `ctx`) — o dos `init`, e o de um campo deles. */\n  readonly initEnv: Env;\n  /** idem sobre os `init`, quando há algum. */\n  readonly inits?: CheckResult;\n}\n\n/**\n * Tipa todas as expressões de um componente contra o `env`.\n *\n * Pega campo que não existe numa raiz (`props.tituloo`), membro que não existe no item de um\n * `each` — com o tipo do item **inferido** da coleção, sem anotação —, nome livre desconhecido,\n * `when` que não rende `boolean`, e — com `propsOf` — o CALL-SITE: as props passadas a um\n * componente custom contra o que ele declara, mesmo vindas de expressão.\n */\nexport function checkComponent(\n  def: ComponentDef,\n  env: Env,\n  opts: CheckComponentOptions = {},\n): CheckIssue[] {\n  return [...analyzeComponent(def, env, opts).issues];\n}\n\n/** A análise inteira — ver `ComponentAnalysis`. O `checkComponent` é a projeção dela. */\nexport function analyzeComponent(\n  def: ComponentDef,\n  env: Env,\n  opts: CheckComponentOptions = {},\n): ComponentAnalysis {\n  const profile = checkerProfileOf(opts.profile ?? DEFAULT_PROFILE);\n  const lowered = lowerComponent(def, {\n    ...(opts.compiled ? { compiled: opts.compiled } : {}),\n    shapeOf: (expression) => dataShape(expression, env),\n    ...(opts.propsOf ? { propsOf: opts.propsOf } : {}),\n    // o `set` de um update local é um call-site sobre o ESTADO: mesmo mecanismo, outra\n    // superfície. O tipo sai das declarações do próprio componente, então não há seam.\n    setType: partialStateType(def.state, opts.types),\n    // a MESMA ordem do runtime: update local primeiro, e o que não resolve aqui sai pela porta.\n    paramsOf: paramsResolver(\n      declaredParamsOf(def.updates, opts.types),\n      hostParamsOf(opts.actions, opts.types),\n    ),\n    // um update local é sempre exaustivo (a declaração É a verdade); a ação do host vale o que\n    // a proveniência disser.\n    exhaustiveParams: (action) =>\n      def.updates?.[action] !== undefined || exhaustiveHostParams(opts.actions),\n    ...(opts.emitsOf ? { emitsOf: opts.emitsOf } : {}),\n    resultOf: hostResultOf(opts.actions, opts.types),\n    ...(opts.mounting ? { mounting: opts.mounting } : {}),\n    stateTypeOf: stateTypeOf(def.state, opts.types),\n    contextOf: declaredContextsOf(opts.contexts, opts.types),\n  });\n  const { program, inits, weak, compiled } = lowered;\n\n  // as DECLARAÇÕES primeiro: um `TypeRef` que não resolve vira `unknown`, e o que vem depois\n  // acusa o efeito. Sem esta linha o autor veria o efeito e nunca a causa.\n  const issues: CheckIssue[] = [\n    ...checkDeclarations(def, opts.types),\n    ...checkContextCatalog(opts.contexts, opts.types),\n  ];\n\n  // o que a COMPILAÇÃO reclamou (sintaxe, ilha vazia, forma que não volta) sai daqui só quando\n  // foi este check que compilou: quem passa `compiled` já tem esses diagnósticos, e o mesmo\n  // erro não deve chegar ao autor duas vezes.\n  if (opts.compiled === undefined)\n    issues.push(\n      ...compiled.diagnostics.map((d) => ({\n        code: d.code,\n        message: d.message,\n        severity: d.severity,\n        path: d.path,\n        address: d.address,\n        ...(d.source === undefined ? {} : { source: d.source }),\n        ...(d.span === undefined ? {} : { span: d.span }),\n      })),\n    );\n\n  // os `init` são tipados à parte, no escopo que SEMEIA: `props` e `ctx`, sem `state` nem\n  // `params`. É o mesmo escopo que o `initState` passa ao binder — o checker prova o que o\n  // runtime executa.\n  const initEnv = buildInitEnv(def, {\n    ...(opts.types ? { types: opts.types } : {}),\n    ...(opts.contexts\n      ? {\n          contexts: Object.fromEntries(\n            Object.entries(opts.contexts).map(([name, ref]) => [\n              name,\n              resolveTypeRef(ref, opts.types ?? {}),\n            ]),\n          ),\n        }\n      : {}),\n  });\n  const seeded = inits\n    ? check(inits as never, initEnv, {\n        profile,\n        ...(opts.limits ? { limits: opts.limits } : {}),\n      })\n    : undefined;\n  if (inits && seeded)\n    issues.push(\n      ...issuesOf(inits as object, seeded.diagnostics, lowered, [\"state\"]),\n    );\n\n  const body = check(program as never, env, {\n    profile,\n    ...(opts.limits ? { limits: opts.limits } : {}),\n  });\n  // sem âncora o diagnóstico é sobre o corpo inteiro — o andaime que nós emitimos.\n  issues.push(...issuesOf(program as object, body.diagnostics, lowered, [0]));\n\n  // a DEGRADAÇÃO por proveniência: \"esta chave não existe\" é a única prova que exige a assinatura\n  // ser COMPLETA. Onde ela pode ter envelhecido, o veredito vira aviso — o autor continua vendo, e\n  // ninguém é contrariado por quem não afirmou de onde tirou a resposta.\n  return {\n    issues: issues.map((issue) =>\n      issue.code === \"excess-property\" && isWeak(issue.address, weak)\n        ? { ...issue, severity: \"warning\" as const }\n        : issue,\n    ),\n    lowered,\n    body,\n    initEnv,\n    ...(seeded ? { inits: seeded } : {}),\n  };\n}\n\nexport interface CheckExpressionOptions extends CheckComponentOptions {\n  /** o tipo que o slot espera render. Um `when` pede `boolean`. */\n  resultType?: Schema;\n}\n\n/**\n * Tipa UMA expressão — o cano por slot, que é o que o drawer do editor liga quando o autor\n * abre um campo. Roda **por tecla digitada**, daí os `limits`.\n *\n * `source` é a expressão nua (sem `{{ }}`); os `span` voltam relativos a ela. `path` é o caminho\n * do campo que a contém — o issue o devolve, com o endereço derivado.\n */\nexport function checkExpression(\n  source: string,\n  env: Env,\n  path: CompiledPath,\n  opts: CheckExpressionOptions = {},\n): CheckIssue[] {\n  const address = addressOf(path);\n  let ast: unknown;\n  try {\n    ast = parseExpression(source);\n  } catch (error) {\n    // sintaxe quebrada é do AUTOR e vira diagnóstico — nunca exceção na cara de quem digita.\n    return [\n      {\n        code: \"parse-error\",\n        message: String((error as Error)?.message ?? error),\n        severity: \"error\",\n        path,\n        address,\n        source,\n      },\n    ];\n  }\n\n  const { diagnostics } = check(ast as never, env, {\n    profile: checkerProfileOf(opts.profile ?? DEFAULT_PROFILE),\n    ...(opts.resultType ? { resultType: opts.resultType } : {}),\n    ...(opts.limits ? { limits: opts.limits } : {}),\n  });\n\n  return diagnostics.map((d) => {\n    const span = spanOf(source, d.node?.loc);\n    return {\n      code: String(d.code ?? \"error\"),\n      message: String(d.message ?? \"\"),\n      severity: d.severity === \"warning\" ? \"warning\" : \"error\",\n      path,\n      address,\n      source,\n      ...(span === undefined ? {} : { span }),\n    };\n  });\n}\n\n/**\n * A forma de um `each`: coleção ou objeto. O lowering precisa saber para escolher entre\n * `map` e aplicação direta, e quem sabe é o TIPO — então a expressão é tipada sozinha antes.\n * Sem tipo utilizável, assume coleção: é o caso que o `as` existe para nomear.\n */\nfunction dataShape(expression: Expression, env: Env): DataShape {\n  try {\n    const t = check(expression as never, env).type as Schema | undefined;\n    return (t as { t?: string } | undefined)?.t === \"array\" ? \"list\" : \"value\";\n  } catch {\n    return \"list\";\n  }\n}\n"]}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@loom-forge/check",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "forge · a camada de TIPOS (dev/CI, nunca no render): checkTree (props resolvidas ≤ descriptor.schema), a álgebra de tipo de um componente (componentType/componentAssignable) e o typecheck por lowering para TSL (buildEnv/checkComponent/checkExpression/analyzeComponent).",
+  "keywords": [
+    "typecheck",
+    "tslite",
+    "lowering",
+    "diagnostics",
+    "json",
+    "dsl"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Anderson D. Rosa",
+    "url": "https://github.com/andersondrosa"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/andersondrosa/loom-forge.git",
+    "directory": "packages/check"
+  },
+  "homepage": "https://github.com/andersondrosa/loom-forge/tree/main/packages/check#readme",
+  "bugs": {
+    "url": "https://github.com/andersondrosa/loom-forge/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@tslite/capability": "^0.6.0",
+    "@tslite/checker": "^0.12.0",
+    "@tslite/core": "^0.11.0",
+    "@tslite/infer": "^0.2.5",
+    "@tslite/jsonschema": "^0.3.4",
+    "@tslite/language-service": "^0.4.0",
+    "@tslite/operators": "^1.0.4",
+    "@tslite/parser": "^1.4.0",
+    "@tslite/type-core": "^0.6.0",
+    "@tslite/validate": "^0.3.1",
+    "@loom-forge/core": "0.1.0",
+    "@loom-forge/forge": "0.1.0",
+    "@loom-forge/tslite": "0.1.0"
+  },
+  "devDependencies": {
+    "@tslite/printer": "^0.5.7",
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}