@loom-forge/tslite 0.1.0

package/README.md

@@ -0,0 +1,192 @@
+# @loom-forge/tslite
+
+**loom** · a linguagem de expressão da definição. Duas fases, e elas são dois relógios: a
+**compilação** traduz o texto autorado (`"{{ props.nome }}"`) numa ilha `#expr`, e o **bind**
+executa o que ela produziu contra um escopo. Implementa o port `BindingEngine` do
+[`@loom-forge/core`](../core/README.md).
+
+```bash
+pnpm add @loom-forge/tslite
+```
+
+```ts
+import { compile, createTsliteBinder } from "@loom-forge/tslite";
+
+const { def, diagnostics } = compile(autorada); // texto → ilha #expr. NÃO avalia.
+const engine = createEngine({
+  binder: createTsliteBinder({ globals: { upper } }),
+});
+```
+
+Quem só **consolida** (um servidor que compila a definição no save) importa o subpath, que não
+carrega o `check` nem a stdlib de runtime — só o que interpreta a string e a lista do que o deploy
+recusaria:
+
+```ts
+import { compile } from "@loom-forge/tslite/compile";
+```
+
+---
+
+## `compile(def)` — a fase de compilação
+
+```ts
+compile(root: DefNode, opts?: { profile?: CapabilityProfile }):
+  { def: DefNode; diagnostics: CompileDiagnostic[]; islands: CompiledIsland[] }
+```
+
+A definição **autorada** carrega a expressão como texto e é o SoT — é o que o autor edita, o
+canvas desenha e o editor diffa. A **compilada** carrega o AST como ilha `#expr` no lugar, e é
+derivada. A forma é a mesma dos dois lados, então o endereço (`#0.1.props.title`) vale para ambos
+e não há source map.
+
+- **não avalia** — não tem dados e não computa valor;
+- **não lança** — o campo que não compila fica com o texto original e sai um diagnóstico, com o
+  **endereço** do campo, o caminho como lista (`path`, índice e chave distintos), o texto do campo
+  (`source`) e o trecho culpado nele (`span`). Os códigos são os do TSLite: `parse-error` ·
+  `lex-error` · `island-not-a-value` · `unserializable-expression` · `node-not-allowed` ·
+  `forbidden-key` · `forbidden-identifier` · `dynamic-computed`; e o nosso `missing-binding`;
+- **quem interpreta a string é o `parseValue` do `@tslite/template`**, com o `directives` que o
+  slot declara (`SLOTS` do core; hoje `false` em todos — `{%` e `{#` são texto). Só string é
+  ambígua; `{{ e }}` ocupando a string inteira preserva o tipo de `e`; texto com ilha rende
+  string; o que não parseia, não rende valor (`{{ }}`) ou não volta pelo `fromJson` do codec fica
+  texto. A string é derivada **uma** vez: a forma serializada vai para `def` — a ilha é o nó como
+  está, **normalizada** pelo `@tslite/normalize` (sem posição e sem o type-node sintático; o
+  `Schema` de cada anotação fica) —, e as `islands` saem em memória, com `loc` no texto do campo
+  — é o que o `check` tipa com span, sem reparsear;
+- **com o `profile` de quem executa, acusa o que o bind recusaria** — pela mesma lista que o
+  `compile` do `@tslite/interpret` usa para recusar (`compileViolations`): nó fora do profile e o
+  que o sanitize barra, com a precedência de lá. Sem `profile`, isso não é julgado: quem só traduz
+  ou tipa não executa. Uma bancada compila com o `DEFAULT_PROFILE`, que é o do binder, e a
+  recusa aparece no campo, e não no console;
+- **onde cabe expressão** é a tabela de slots (`FIELDS`/`SLOTS`/`TREE`, exportada pelo core):
+  `props`, `events[*].params`, `placement`, `each`, `when`. Campo fora dela não tem porta.
+
+A marca da ilha (`EXPR_MARKER`) e o predicado (`isExprMarker`) são do `@tslite/core`, e é de lá
+que o [`@loom-forge/check`](../check/README.md) e o `eject` os importam — a pergunta "isto é uma
+ilha?" tem uma resposta só, e ela é do dono do marcador.
+
+---
+
+## `createTsliteBinder(opts?)` — o bind
+
+```ts
+import { createTsliteBinder } from "@loom-forge/tslite";
+const engine = createEngine({
+  binder: createTsliteBinder({ globals: { upper } }),
+});
+```
+
+Expande a definição contra `data`: `{{expr}}` em strings (parser TS-like) e ilhas `#expr` (serializável).
+Pipeline **100% TSLite, sem `new Function`**: a fase `compile()` traduz o texto em ilha `#expr`;
+o bind faz `fromJson → compile (gateado pelo
+CapabilityProfile + sanitize) → runner`.
+
+**Os `params` de uma intenção não são avaliados no render.** Um evento (`events.onX`), um efeito
+e cada elo da cadeia `then`/`catch` (ADR-018 do root) saem do `bind` com o `params` **compilado**
+e o escopo do render guardado no binding; quem avalia é o despacho, sobre esse escopo mais a raiz
+`event` — o valor emitido pelo widget, o `data` de um `then`, o `error` de um `catch`. É o
+`intentParams` do `@loom-forge/core`, ligando um nó-fantasma pelo mesmo binder. A compilação
+endereça cada elo pelo caminho dele (`#0.events.onClick.then.params.valido`).
+
+```ts
+interface TsliteBinderOptions {
+  globals?: Record<string, unknown>; // helpers no escopo
+  profile?: CapabilityProfile; // o que a definição pode programar (default: DEFAULT_PROFILE)
+  boundary?: { runtime }; // a metade de runtime de um `createBoundary` do @tslite/validate
+  budget?: Budget | false; // custo por avaliação: { steps?, depth?, size? } (default: EXPRESSION_BUDGET)
+  onError?(error, source); // falhou ao EXECUTAR (unknown-name, host lançou, orçamento estourado)
+  onReject?(error, source); // recusada na COMPILAÇÃO (node-not-allowed, sanitize)
+}
+```
+
+**Seguro por construção:** o `compile` só vê o escopo passado — globais (`fetch`/`process`) não
+existem. **Política = dado:** o `CapabilityProfile` é serializável e viaja com a definição. O
+default, `DEFAULT_PROFILE` (`PRESETS["pure-fp"]`), libera expressão, chamada ao host e lambda —
+inclusive com corpo em bloco — e fecha mutação, laço, `throw` e `async`.
+
+**Com lambda, uma expressão consegue não terminar**, e por isso o bind vem com orçamento: o
+`EXPRESSION_BUDGET` do `@tslite/capability` (`steps` 1 milhão · `depth` 256 · `size` 10 milhões)
+entra quando nem a opção nem o profile trazem um. Os números foram medidos aqui (ADR-114) e
+provados lá: um `filter` sobre 10 mil linhas custa ~90 mil passos, e uma recursão infinita para
+em `depth`. Apertar ou afrouxar é trocar o
+profile ou o orçamento, não ligar flags:
+
+```ts
+import { PRESETS } from "@tslite/capability";
+createTsliteBinder({ profile: PRESETS.data }); // fecha a lambda: "JSON com lógica"
+createTsliteBinder({ budget: { steps: 10_000, depth: 32 } }); // orçamento mais apertado
+createTsliteBinder({ budget: false }); // sem contagem, e sem proteção contra recursão sem fim
+```
+
+O `compile` também roda o **sanitize fail-closed** (substrato `__proto__`/`constructor` + autoridade
+ambiente) por default. Ver [docs/ARCHITECTURE](./docs/ARCHITECTURE.md).
+
+### Diretivas de template (`each` / `when`)
+
+Estruturais (mudam a árvore, não só valores) — tornam listas/condicionais **declarativas no JSON**:
+
+```jsonc
+{
+  "type": "List",
+  "children": [
+    // each array → repete o nó por item; o item ganha o nome do `as` (+ `$index`)
+    {
+      "type": "Row",
+      "each": "{{ data.users }}",
+      "as": "u",
+      "props": { "name": "{{ u.name }}" },
+      // when → dropa se falsy (por item dentro do each)
+      "when": "{{ u.active }}",
+    },
+  ],
+}
+// each objeto re-escopa a subárvore: { "each": "{{ data.user }}", "as": "u", "props": { "n": "{{ u.name }}" } }
+```
+
+- ids dos repetidos são estáveis: `row.${item.id ?? $index}`.
+- **`as` é obrigatório** — sem ele o item não teria nome, e a compilação acusa `missing-binding`.
+- as diretivas são **consumidas** (não aparecem na saída resolvida) e **guardadas** (mesma Linguagem
+  do bind);
+- o escopo do item **estende** o do pai — um `each` aninhado enxerga o item de fora, e a raiz
+  `data` continua alcançável de qualquer profundidade.
+
+> A camada de **tipos** não está aqui — vive em [`@loom-forge/check`](../check/README.md), para o
+> bind de runtime nunca arrastar `@tslite/checker`/`jsonschema`/`infer`. Ali é que se prova que um
+> `when` rende `boolean` e que `{{ item.nomee }}` não existe na coleção.
+
+---
+
+## Stdlib
+
+O escopo carrega os **53 operadores** do `@tslite/operators` por default (`length`, `map`,
+`filter`, `prop`, `pick`…). Não é conveniência: a Linguagem é FP e **não tem protótipo**, então
+`xs.length` é erro e a forma é `length(xs)`. Sob o profile default a composição point-free
+funciona inteira — `map(prop("nome"), xs)`, `filter(propEq("ativo", true), xs)` —, e a lambda
+também: `map((p) => p.nome, xs)`. A ordem é a do Ramda, com a função primeiro.
+
+O mesmo vocabulário aparece tipado no [`@loom-forge/check`](../check/README.md) (`vanilla`, as
+assinaturas) — é o que faz o checker provar o que o executor vai rodar.
+
+## O asserter, quando há um
+
+O `check` pode tipar `{{ parseAs(Address, props.bruto) }}` contra um catálogo de tipos nomeados.
+Tipar é metade; **provar** é runtime, e runtime é aqui. As duas metades saem de **uma**
+declaração — o `createBoundary` do `@tslite/validate` monta, do mesmo catálogo, o que o checker
+precisa e o que o interpret precisa —, e o host entrega a metade certa a cada lado:
+
+```ts
+import { createBoundary } from "@tslite/validate";
+import { vanilla } from "@tslite/operators";
+
+const boundary = createBoundary({
+  types: { Address },
+  reserved: Object.keys(vanilla),
+});
+createTsliteBinder({ boundary }); //             a metade de runtime: o catálogo e o `parseAs`
+buildEnv(def, { boundary }); // no `check`:     a metade de tipos, do mesmo objeto
+```
+
+Não vem embutido: quem não usa asserter não deve pagar o validador, e este package não o importa
+— a opção recebe só o `runtime` da fronteira. Ver a fronteira do `unknown` no
+[`@loom-forge/check`](../check/README.md).

package/dist/chunk-7C76HX6B.js

@@ -0,0 +1,135 @@
+import { parseValue } from '@tslite/template';
+import { compileViolations } from '@tslite/interpret';
+import { PRESETS } from '@tslite/capability';
+import { valueAt, createPositionMap } from '@tslite/language-service';
+import { expr } from '@tslite/core/builders';
+import { normalize } from '@tslite/normalize';
+import { FIELDS, slotOf, TREE } from '@loom-forge/core';
+
+// src/compile.ts
+var DEFAULT_PROFILE = PRESETS["pure-fp"];
+var addressOf = (path) => `#${path.join(".")}`;
+var spanOf = (text, loc) => {
+  if (!loc?.start) return void 0;
+  const map = createPositionMap(text);
+  const at = (p) => map.offsetAt({ line: p.line - 1, column: p.column });
+  const from = at(loc.start);
+  return { from, to: loc.end ? at(loc.end) : from };
+};
+var setIn = (target, path, value) => {
+  if (path.length === 0) return value;
+  const [head, ...rest] = path;
+  if (Array.isArray(target)) {
+    const out = target.slice();
+    out[head] = setIn(out[head], rest, value);
+    return out;
+  }
+  const record = target;
+  return { ...record, [head]: setIn(record[head], rest, value) };
+};
+var normalized = (node) => expr(normalize(node));
+function compile(root, opts = {}) {
+  const diagnostics = [];
+  const islands = [];
+  const gate = opts.profile ? { profile: opts.profile } : void 0;
+  const fail = (code, message, path, extra = {}) => {
+    diagnostics.push({
+      code,
+      message,
+      address: addressOf(path),
+      path,
+      severity: extra.severity ?? "error",
+      ...extra.source === void 0 ? {} : { source: extra.source },
+      ...extra.span === void 0 ? {} : { span: extra.span }
+    });
+  };
+  const refused = (island, path) => {
+    if (!gate) return false;
+    const violations = compileViolations(island.node, gate);
+    for (const v of violations)
+      fail(v.code, v.message, path, {
+        source: island.text,
+        span: spanOf(island.text, v.node.loc)
+      });
+    return violations.length > 0;
+  };
+  const compileValue = (value, path, directives) => {
+    const parsed = parseValue(value, { directives });
+    let out = parsed.value;
+    for (const d of parsed.diagnostics) {
+      const text = valueAt(value, d.path);
+      fail(d.code, d.message, [...path, ...d.path], {
+        severity: d.severity,
+        ...typeof text === "string" ? { source: text } : {},
+        ...d.span === void 0 ? {} : { span: d.span }
+      });
+    }
+    for (const island of parsed.islands) {
+      const at = [...path, ...island.path];
+      if (refused(island, at)) {
+        out = setIn(out, island.path, island.text);
+        continue;
+      }
+      out = setIn(out, island.path, normalized(island.node));
+      islands.push({
+        address: addressOf(at),
+        path: at,
+        text: island.text,
+        node: island.node
+      });
+    }
+    return out;
+  };
+  const compileIntent = (intent, path, directives) => ({
+    ...intent,
+    ...intent.params === void 0 ? {} : {
+      params: compileValue(intent.params, [...path, "params"], directives)
+    },
+    ...intent.then ? { then: compileIntent(intent.then, [...path, "then"], directives) } : {},
+    ...intent.catch ? { catch: compileIntent(intent.catch, [...path, "catch"], directives) } : {}
+  });
+  const compileIntents = (intents, path, directives) => {
+    const out = {};
+    for (const [name, intent] of Object.entries(intents))
+      out[name] = typeof intent === "string" ? intent : compileIntent(intent, [...path, name], directives);
+    return out;
+  };
+  const compileNode = (node, path) => {
+    const out = { ...node };
+    const read = (field) => node[field];
+    for (const [field, role] of Object.entries(FIELDS)) {
+      if (role !== "slot") continue;
+      const value = read(field);
+      if (value === void 0) continue;
+      const decl = slotOf(field);
+      if (!decl) continue;
+      out[field] = decl.shape === "intentParams" ? compileIntents(
+        value,
+        [...path, field],
+        decl.directives
+      ) : compileValue(value, [...path, field], decl.directives);
+    }
+    if (node.each !== void 0 && typeof node.as !== "string")
+      fail(
+        "missing-binding",
+        "`each` exige `as` \u2014 o nome pelo qual o item entra no escopo",
+        [...path, "each"]
+      );
+    for (const [field, shape] of Object.entries(TREE)) {
+      const value = read(field);
+      if (value === void 0) continue;
+      if (shape === "list" && Array.isArray(value))
+        out[field] = value.map(
+          (c, i) => compileNode(c, [...path, i])
+        );
+      else if (shape === "node" && value && typeof value === "object")
+        out[field] = compileNode(value, [...path, field]);
+    }
+    return out;
+  };
+  return { def: compileNode(root, [0]), diagnostics, islands };
+}
+
+export { DEFAULT_PROFILE, addressOf, compile };
+//# sourceMappingURL=chunk-7C76HX6B.js.map
+//# sourceMappingURL=chunk-7C76HX6B.js.map

package/dist/chunk-7C76HX6B.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/compile.ts"],"names":[],"mappings":"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","file":"chunk-7C76HX6B.js","sourcesContent":["import { parseValue, type ValueIsland } from \"@tslite/template\";\nimport { compileViolations } from \"@tslite/interpret\";\nimport { PRESETS, type CapabilityProfile } from \"@tslite/capability\";\nimport {\n  createPositionMap,\n  valueAt,\n  type DocumentSegment,\n  type Span,\n} from \"@tslite/language-service\";\nimport type { Expression } from \"@tslite/core\";\nimport { expr } from \"@tslite/core/builders\";\nimport { normalize } from \"@tslite/normalize\";\nimport type { ViolationKind } from \"@tslite/sanitize\";\nimport { FIELDS, slotOf, TREE } from \"@loom-forge/core\";\nimport type { CommandAlias, DefNode, EventBinding } from \"@loom-forge/core\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n   COMPILAÇÃO — definição AUTORADA (expressão em texto) → definição COMPILADA\n   (expressão em AST, como ilha `#expr`). Mesma forma dos dois lados: nada é\n   re-parenteado, absorvido ou podado, então o endereço vale para ambos e não há\n   source map.\n\n   COMPILAR NÃO AVALIA. Não há dados aqui. `{{ x }}` vira a PERGUNTA em forma de\n   árvore; quem responde é o bind, a cada render, contra o escopo vivo. Dobrar uma\n   expressão constante aqui apagaria a reatividade em silêncio.\n\n   E NUNCA LANÇA. Um `{{` recém-digitado é o estado normal de quem está escrevendo:\n   o campo degrada para o texto e sai um diagnóstico. O autor tem o direito de\n   escrever errado e ver o erro; o que ele não pode é escrever pela metade e ver a\n   tela cair.\n\n   QUEM INTERPRETA A STRING É O TSLITE. O `parseValue` do `@tslite/template` aplica a\n   regra — só string é ambígua; `{{ e }}` inteira preserva o tipo; texto com ilha rende\n   string; o que não parseia ou não volta pelo codec fica texto e sai como diagnóstico —\n   e devolve as duas coisas de que este repo precisa: a forma SERIALIZADA (o que o bind\n   executa e o que se persiste) e os nós EM MEMÓRIA, com posição no texto do campo (o\n   que o `check` tipa com span). A string é derivada UMA vez.\n   ────────────────────────────────────────────────────────────────────────────── */\n\nexport type CompileCode =\n  /** a expressão não está na gramática da Linguagem (os códigos do parser). */\n  | \"parse-error\"\n  | \"lex-error\"\n  /** a ilha parseia mas não rende um VALOR — o caso comum é a ilha vazia, `{{ }}`. */\n  | \"island-not-a-value\"\n  /** a expressão parseia, mas a ilha que ela vira não é lida de volta pelo codec — o bind a\n   *  recusaria, e o campo renderia sem ela. */\n  | \"unserializable-expression\"\n  /** a expressão usa um nó que o `CapabilityProfile` do deploy fecha (o código é o do TSLite). */\n  | \"node-not-allowed\"\n  /** o sanitize recusa a expressão — os códigos são os `ViolationKind` do `@tslite/sanitize`. */\n  | ViolationKind\n  /** `each` sem `as`: o item não teria nome, e nada dentro do laço o alcançaria. */\n  | \"missing-binding\";\n\n/**\n * O profile que o bind usa quando ninguém passa outro: **`pure-fp`** — lambda (inclusive com corpo\n * em bloco), ternário, template, spread, `?.`/`??`, sem mutação, laço, `throw` nem `async`.\n *\n * Mora AQUI, e não no binder, porque a pergunta \"o deploy deixa isto rodar?\" também é da autoria: a\n * bancada compila com o mesmo profile que o palco executa, e as duas respostas não podem divergir.\n */\nexport const DEFAULT_PROFILE: CapabilityProfile = PRESETS[\"pure-fp\"];\n\nexport interface CompileOptions {\n  /**\n   * O `CapabilityProfile` de quem vai EXECUTAR. Com ele, a compilação acusa o que o bind recusaria\n   * — nó fora do profile e o que o sanitize barra, pela mesma lista que o `compile` do interpret\n   * usa para recusar (`compileViolations`) —, e o campo fica com o texto. Sem ele, nada disso é\n   * julgado: quem só traduz (eject) ou só tipa (check) não executa.\n   */\n  profile?: CapabilityProfile;\n}\n\n/**\n * O caminho de um campo a partir da raiz: `[0, 1, \"props\", \"title\"]`. Índice e chave são\n * distintos no tipo — `2` anda em array, `\"2\"` em objeto —, e o `address` é só a exibição dele.\n */\nexport type CompilePath = readonly DocumentSegment[];\n\n/** `#0.1.props.title` — o caminho como o autor o lê. Derivado; ninguém o lê de volta. */\nexport const addressOf = (path: CompilePath): string => `#${path.join(\".\")}`;\n\nexport interface CompileDiagnostic {\n  code: CompileCode;\n  message: string;\n  address: string;\n  path: CompilePath;\n  severity: \"error\" | \"warning\";\n  /** o texto do campo, como o autor o escreveu, quando há um. */\n  source?: string;\n  /** offsets em `source` — o trecho culpado. Ausente quando o problema é do campo inteiro. */\n  span?: Span;\n}\n\n/**\n * Uma ilha compilada, em memória: o texto do campo e o nó com `loc` relativo a ele. É o que o\n * `check` tipa — com o span no texto que o autor vê, sem reparsear a string.\n */\nexport interface CompiledIsland {\n  address: string;\n  path: CompilePath;\n  text: string;\n  node: Expression;\n}\n\nexport interface CompileResult {\n  /** a definição compilada. Em erro, o campo culpado fica com o texto original. */\n  def: DefNode;\n  diagnostics: CompileDiagnostic[];\n  /** as ilhas que entraram em `def`, na ordem em que foram encontradas. */\n  islands: CompiledIsland[];\n}\n\n/**\n * `loc` do nó (linha 1-based, coluna 0-based) → offsets no texto do campo. É a mesma conversão do\n * `spanOf` do `@tslite/checker`; ela é refeita aqui porque o checker é package de dev, e este\n * subpath é o que um servidor de consolidação carrega sem o executor de tipos.\n */\nconst spanOf = (\n  text: string,\n  loc: Expression[\"loc\"] | null | undefined,\n): Span | undefined => {\n  if (!loc?.start) return undefined;\n  const map = createPositionMap(text);\n  const at = (p: { line: number; column: number }): number =>\n    map.offsetAt({ line: p.line - 1, column: p.column });\n  const from = at(loc.start);\n  return { from, to: loc.end ? at(loc.end) : from };\n};\n\n/** escreve `value` no caminho, sem tocar no resto — a ilha recusada volta a ser o texto. */\nconst setIn = (target: unknown, path: CompilePath, value: unknown): unknown => {\n  if (path.length === 0) return value;\n  const [head, ...rest] = path;\n  if (Array.isArray(target)) {\n    const out = target.slice();\n    out[head as number] = setIn(out[head as number], rest, value);\n    return out;\n  }\n  const record = target as Record<string, unknown>;\n  return { ...record, [head!]: setIn(record[head!], rest, value) };\n};\n\n/**\n * A ilha NORMALIZADA, num clone — a que vai para a DEFINIÇÃO.\n *\n * O codec entrega a ilha como o nó está: `start`/`end`/`loc` em cada nó no referencial do texto\n * do campo, e o type-node sintático ao lado do `Schema` de cada anotação. Na definição compilada\n * o texto não existe mais (o bind não usa posição, e o `check` a tem pelas ilhas em memória —\n * `islands[].node`, que ficam inteiras), e o type-node é lido só por quem imprime fonte a partir\n * dele — o `@tslite/emit` cai para o `Schema` quando ele não está. Guardar os dois seria persistir\n * um número relativo a um texto ausente e duas árvores do mesmo tipo. Quem sabe a lista do que\n * é artefato é o `@tslite/normalize` (a `ERASABLE_TYPE_NODE_KEYS` do core, D47): um filtro\n * próprio divergiria dela no primeiro campo novo. O `normalize` clona — a ilha da definição e a\n * ilha em memória compartilham nós.\n */\nconst normalized = (node: Expression): unknown => expr(normalize(node));\n\nexport function compile(\n  root: DefNode,\n  opts: CompileOptions = {},\n): CompileResult {\n  const diagnostics: CompileDiagnostic[] = [];\n  const islands: CompiledIsland[] = [];\n  const gate = opts.profile ? { profile: opts.profile } : undefined;\n\n  const fail = (\n    code: CompileCode,\n    message: string,\n    path: CompilePath,\n    extra: {\n      source?: string;\n      span?: Span;\n      severity?: \"error\" | \"warning\";\n    } = {},\n  ): void => {\n    diagnostics.push({\n      code,\n      message,\n      address: addressOf(path),\n      path,\n      severity: extra.severity ?? \"error\",\n      ...(extra.source === undefined ? {} : { source: extra.source }),\n      ...(extra.span === undefined ? {} : { span: extra.span }),\n    });\n  };\n\n  /**\n   * O que o bind deste deploy recusaria ao compilar a ilha — um diagnóstico por violação, pela\n   * MESMA lista que o `compile` do interpret usa para recusar. Aqui não há lista de nós proibidos\n   * nem precedência de sanitize para envelhecer.\n   */\n  const refused = (island: ValueIsland, path: CompilePath): boolean => {\n    if (!gate) return false;\n    const violations = compileViolations(island.node, gate);\n    for (const v of violations)\n      fail(v.code, v.message, path, {\n        source: island.text,\n        span: spanOf(island.text, (v.node as Expression).loc),\n      });\n    return violations.length > 0;\n  };\n\n  /**\n   * O valor de um slot. Só string é ambígua, e quem decide o que uma string é — dado, expressão\n   * crua, template — é o `parseValue`, com o `directives` que o SLOT declara. O que ele recusa\n   * fica texto; o que o deploy recusaria idem.\n   */\n  const compileValue = (\n    value: unknown,\n    path: CompilePath,\n    directives: boolean,\n  ): unknown => {\n    const parsed = parseValue(value, { directives });\n    let out = parsed.value;\n    for (const d of parsed.diagnostics) {\n      const text = valueAt(value, d.path);\n      fail(d.code as CompileCode, d.message, [...path, ...d.path], {\n        severity: d.severity,\n        ...(typeof text === \"string\" ? { source: text } : {}),\n        ...(d.span === undefined ? {} : { span: d.span }),\n      });\n    }\n    for (const island of parsed.islands) {\n      const at = [...path, ...island.path];\n      if (refused(island, at)) {\n        out = setIn(out, island.path, island.text);\n        continue;\n      }\n      // a definição leva a ilha NORMALIZADA; a memória leva o nó inteiro, com `loc`\n      out = setIn(out, island.path, normalized(island.node));\n      islands.push({\n        address: addressOf(at),\n        path: at,\n        text: island.text,\n        node: island.node,\n      });\n    }\n    return out;\n  };\n\n  /** UMA intenção: os `params` dela, e os da cadeia (`then`/`catch`), cada elo no caminho dele. */\n  const compileIntent = (\n    intent: EventBinding,\n    path: CompilePath,\n    directives: boolean,\n  ): EventBinding => ({\n    ...intent,\n    ...(intent.params === undefined\n      ? {}\n      : {\n          params: compileValue(intent.params, [...path, \"params\"], directives),\n        }),\n    ...(intent.then\n      ? { then: compileIntent(intent.then, [...path, \"then\"], directives) }\n      : {}),\n    ...(intent.catch\n      ? { catch: compileIntent(intent.catch, [...path, \"catch\"], directives) }\n      : {}),\n  });\n\n  /** um mapa de INTENÇÕES (`events`, `commands`): o compilável é o `params` de cada entrada — e,\n   *  num evento, os da cadeia. A forma curta de um alias (`\"limpar\": \"form/clear\"`) é só um nome,\n   *  e atravessa intacta. */\n  const compileIntents = (\n    intents: Record<string, EventBinding | CommandAlias>,\n    path: CompilePath,\n    directives: boolean,\n  ): Record<string, EventBinding | CommandAlias> => {\n    const out: Record<string, EventBinding | CommandAlias> = {};\n    for (const [name, intent] of Object.entries(intents))\n      out[name] =\n        typeof intent === \"string\"\n          ? intent\n          : compileIntent(intent as EventBinding, [...path, name], directives);\n    return out;\n  };\n\n  const compileNode = (node: DefNode, path: CompilePath): DefNode => {\n    const out: Record<string, unknown> = { ...node };\n    const read = (field: string): unknown =>\n      (node as unknown as Record<string, unknown>)[field];\n\n    // os SLOTS — onde expressão pode morar, e o que cada um declara que uma string contém\n    for (const [field, role] of Object.entries(FIELDS)) {\n      if (role !== \"slot\") continue;\n      const value = read(field);\n      if (value === undefined) continue;\n      const decl = slotOf(field);\n      if (!decl) continue; // FIELDS e SLOTS discordaram — há teste cravando que não discordam\n      out[field] =\n        decl.shape === \"intentParams\"\n          ? compileIntents(\n              value as Record<string, EventBinding | CommandAlias>,\n              [...path, field],\n              decl.directives,\n            )\n          : compileValue(value, [...path, field], decl.directives);\n    }\n\n    // `each` liga um nome, e o nome é obrigatório: sem ele o item fica inalcançável —\n    // o laço repetiria o nó e nada dentro dele veria o item, sem erro nenhum.\n    if (node.each !== undefined && typeof node.as !== \"string\")\n      fail(\n        \"missing-binding\",\n        \"`each` exige `as` — o nome pelo qual o item entra no escopo\",\n        [...path, \"each\"],\n      );\n\n    // a ÁRVORE — dirigida pela tabela, não por `children`/`fallback` na mão\n    for (const [field, shape] of Object.entries(TREE)) {\n      const value = read(field);\n      if (value === undefined) continue;\n      if (shape === \"list\" && Array.isArray(value))\n        out[field] = value.map((c, i) =>\n          compileNode(c as DefNode, [...path, i]),\n        );\n      else if (shape === \"node\" && value && typeof value === \"object\")\n        out[field] = compileNode(value as DefNode, [...path, field]);\n    }\n\n    return out as unknown as DefNode;\n  };\n\n  return { def: compileNode(root, [0]), diagnostics, islands };\n}\n"]}

package/dist/compile.d.ts

@@ -0,0 +1,75 @@
+import { CapabilityProfile } from '@tslite/capability';
+import { DocumentSegment, Span } from '@tslite/language-service';
+import { Expression } from '@tslite/core';
+import { ViolationKind } from '@tslite/sanitize';
+import { DefNode } from '@loom-forge/core';
+
+type CompileCode = 
+/** a expressão não está na gramática da Linguagem (os códigos do parser). */
+"parse-error" | "lex-error"
+/** a ilha parseia mas não rende um VALOR — o caso comum é a ilha vazia, `{{ }}`. */
+ | "island-not-a-value"
+/** a expressão parseia, mas a ilha que ela vira não é lida de volta pelo codec — o bind a
+ *  recusaria, e o campo renderia sem ela. */
+ | "unserializable-expression"
+/** a expressão usa um nó que o `CapabilityProfile` do deploy fecha (o código é o do TSLite). */
+ | "node-not-allowed"
+/** o sanitize recusa a expressão — os códigos são os `ViolationKind` do `@tslite/sanitize`. */
+ | ViolationKind
+/** `each` sem `as`: o item não teria nome, e nada dentro do laço o alcançaria. */
+ | "missing-binding";
+/**
+ * O profile que o bind usa quando ninguém passa outro: **`pure-fp`** — lambda (inclusive com corpo
+ * em bloco), ternário, template, spread, `?.`/`??`, sem mutação, laço, `throw` nem `async`.
+ *
+ * Mora AQUI, e não no binder, porque a pergunta "o deploy deixa isto rodar?" também é da autoria: a
+ * bancada compila com o mesmo profile que o palco executa, e as duas respostas não podem divergir.
+ */
+declare const DEFAULT_PROFILE: CapabilityProfile;
+interface CompileOptions {
+    /**
+     * O `CapabilityProfile` de quem vai EXECUTAR. Com ele, a compilação acusa o que o bind recusaria
+     * — nó fora do profile e o que o sanitize barra, pela mesma lista que o `compile` do interpret
+     * usa para recusar (`compileViolations`) —, e o campo fica com o texto. Sem ele, nada disso é
+     * julgado: quem só traduz (eject) ou só tipa (check) não executa.
+     */
+    profile?: CapabilityProfile;
+}
+/**
+ * O caminho de um campo a partir da raiz: `[0, 1, "props", "title"]`. Índice e chave são
+ * distintos no tipo — `2` anda em array, `"2"` em objeto —, e o `address` é só a exibição dele.
+ */
+type CompilePath = readonly DocumentSegment[];
+/** `#0.1.props.title` — o caminho como o autor o lê. Derivado; ninguém o lê de volta. */
+declare const addressOf: (path: CompilePath) => string;
+interface CompileDiagnostic {
+    code: CompileCode;
+    message: string;
+    address: string;
+    path: CompilePath;
+    severity: "error" | "warning";
+    /** o texto do campo, como o autor o escreveu, quando há um. */
+    source?: string;
+    /** offsets em `source` — o trecho culpado. Ausente quando o problema é do campo inteiro. */
+    span?: Span;
+}
+/**
+ * Uma ilha compilada, em memória: o texto do campo e o nó com `loc` relativo a ele. É o que o
+ * `check` tipa — com o span no texto que o autor vê, sem reparsear a string.
+ */
+interface CompiledIsland {
+    address: string;
+    path: CompilePath;
+    text: string;
+    node: Expression;
+}
+interface CompileResult {
+    /** a definição compilada. Em erro, o campo culpado fica com o texto original. */
+    def: DefNode;
+    diagnostics: CompileDiagnostic[];
+    /** as ilhas que entraram em `def`, na ordem em que foram encontradas. */
+    islands: CompiledIsland[];
+}
+declare function compile(root: DefNode, opts?: CompileOptions): CompileResult;
+
+export { type CompileCode, type CompileDiagnostic, type CompileOptions, type CompilePath, type CompileResult, type CompiledIsland, DEFAULT_PROFILE, addressOf, compile };

package/dist/compile.js

@@ -0,0 +1,3 @@
+export { DEFAULT_PROFILE, addressOf, compile } from './chunk-7C76HX6B.js';
+//# sourceMappingURL=compile.js.map
+//# sourceMappingURL=compile.js.map

package/dist/compile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"compile.js"}

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+import { CapabilityProfile, Budget } from '@tslite/capability';
+import { BindingEngine } from '@loom-forge/core';
+export { CompileCode, CompileDiagnostic, CompileOptions, CompilePath, CompileResult, CompiledIsland, DEFAULT_PROFILE, addressOf, compile } from './compile.js';
+import '@tslite/language-service';
+import '@tslite/core';
+import '@tslite/sanitize';
+
+interface TsliteBinderOptions {
+    /**
+     * A STDLIB e os helpers do host, planos no escopo. Default: `vanillaRuntime` do
+     * `@tslite/operators` — os 53 operadores (`length`, `map`, `filter`, `pick`…).
+     *
+     * Não é conveniência: o TSLite é FP e **não tem protótipo**, então `xs.length` é erro e a
+     * forma é `length(xs)`. Sem os operadores, uma expressão não consegue fazer quase nada.
+     * Passar `globals` SUBSTITUI a stdlib; para acrescentar, espalhe: `{ ...vanillaRuntime, meu }`.
+     */
+    globals?: Record<string, unknown>;
+    /**
+     * A metade de RUNTIME da fronteira de tipos — o `runtime` de um `createBoundary` do
+     * `@tslite/validate`: o catálogo de tipos nomeados como valor e o asserter (`parseAs`) que
+     * prova. O host monta a fronteira UMA vez, do mesmo catálogo que dá ao `check`, e entrega a
+     * metade certa a cada lado; quem não usa asserter não instala o validador.
+     */
+    boundary?: {
+        readonly runtime: Readonly<Record<string, unknown>>;
+    };
+    /** o que a definição pode programar — `CapabilityProfile` (dado puro, serializável).
+     *  Default: `DEFAULT_PROFILE` (`PRESETS["pure-fp"]`: lambda, sem mutação/laço/`throw`/async).
+     *  Apertar ou afrouxar = passar outro preset (`PRESETS.data` fecha a lambda) ou um profile
+     *  próprio. */
+    profile?: CapabilityProfile;
+    /** orçamento de EXECUÇÃO por avaliação (`steps`/`depth`/`size`, em unidades da Linguagem).
+     *  Vence o do profile; sem nenhum dos dois, vale o `EXPRESSION_BUDGET` do `@tslite/capability`
+     *  — o orçamento MEDIDO para uma expressão vinda de um documento. `false` desliga a contagem:
+     *  o runner fica idêntico ao sem instrumentação, e uma recursão sem fim só para quando a pilha
+     *  do JS estoura. */
+    budget?: Budget | false;
+    /** erro de execução (ex.: nome desconhecido). Default: warn em dev + `undefined`. */
+    onError?(error: unknown, source: string): void;
+    /** expressão recusada na COMPILAÇÃO — fora do profile (`node-not-allowed`) ou barrada pelo
+     *  sanitize (`__proto__`/`constructor`, autoridade ambiente). Default: warn em dev + `undefined`. */
+    onReject?(error: unknown, source: string): void;
+}
+declare function createTsliteBinder(opts?: TsliteBinderOptions): BindingEngine;
+
+export { type TsliteBinderOptions, createTsliteBinder };

package/dist/index.js

@@ -0,0 +1,225 @@
+import { DEFAULT_PROFILE, compile } from './chunk-7C76HX6B.js';
+export { DEFAULT_PROFILE, addressOf, compile } from './chunk-7C76HX6B.js';
+import { fromJson } from '@tslite/codec';
+import { isExprMarker, EXPR_MARKER } from '@tslite/core';
+import { vanillaRuntime } from '@tslite/operators';
+import { createBaseScope, compile as compile$1 } from '@tslite/interpret';
+import { hasIslands } from '@tslite/template';
+import { compileProfile, EXPRESSION_BUDGET } from '@tslite/capability';
+import { SLOTS } from '@loom-forge/core';
+
+var marker = (v) => `${EXPR_MARKER}:${String(v[EXPR_MARKER])}`;
+var isTsliteError = (e) => !!e && typeof e === "object" && "code" in e;
+var isDev = () => {
+  const g = globalThis;
+  return g.process?.env?.NODE_ENV !== "production";
+};
+function createTsliteBinder(opts = {}) {
+  const globals = {
+    ...opts.globals ?? vanillaRuntime,
+    ...opts.boundary?.runtime ?? {}
+  };
+  const profile = opts.profile ?? DEFAULT_PROFILE;
+  const budget = opts.budget === false ? void 0 : opts.budget ?? (compileProfile(profile).budget === null ? EXPRESSION_BUDGET : void 0);
+  const base = createBaseScope(globals);
+  const compileOpts = budget ? { profile, budget, base } : { profile, base };
+  const onError = opts.onError ?? ((error, source) => {
+    if (isDev())
+      console.warn(`[loom/tslite] erro avaliando "${source}":`, error);
+  });
+  const onReject = opts.onReject ?? ((error, source) => {
+    if (isDev())
+      console.warn(`[loom/tslite] express\xE3o recusada "${source}":`, error);
+  });
+  const islands = /* @__PURE__ */ new WeakMap();
+  const exec = (entry, scope, source) => {
+    if (!entry.ok) {
+      onReject(entry.error, source);
+      return void 0;
+    }
+    try {
+      return entry.run(scope);
+    } catch (error) {
+      onError(error, source);
+      return void 0;
+    }
+  };
+  const evalIsland = (value, scope) => {
+    let entry = islands.get(value);
+    if (entry === void 0) {
+      try {
+        entry = {
+          ok: true,
+          run: compile$1(fromJson(value), compileOpts)
+        };
+      } catch (error) {
+        entry = {
+          ok: false,
+          phase: isTsliteError(error) ? "compile" : "decode",
+          error
+        };
+      }
+      islands.set(value, entry);
+    }
+    return exec(entry, scope, marker(value));
+  };
+  const bindValue = (v, scope) => {
+    if (isExprMarker(v)) return evalIsland(v, scope);
+    if (Array.isArray(v)) return v.map((x) => bindValue(x, scope));
+    if (v && typeof v === "object") {
+      const out = {};
+      for (const [k, val] of Object.entries(v)) out[k] = bindValue(val, scope);
+      return out;
+    }
+    return v;
+  };
+  const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+  const dir = (node, key) => node[key];
+  const evalDirective = (v, scope) => isExprMarker(v) ? evalIsland(v, scope) : v;
+  const rootScope = (scope) => isObj(scope) ? scope : {};
+  const childScope = (parent, binding, item, index) => ({
+    ...parent,
+    ...binding ? { [binding]: item } : {},
+    ...index != null ? { $index: index } : {}
+  });
+  const repeatId = (baseId, item, index) => `${baseId}.${isObj(item) && "id" in item ? String(item.id) : index}`;
+  const stripDir = (node) => {
+    if (dir(node, "when") === void 0 && dir(node, "each") === void 0 && node.as === void 0)
+      return node;
+    const n = { ...node };
+    delete n.when;
+    delete n.each;
+    delete n.as;
+    return n;
+  };
+  const VALUE_SLOTS = Object.entries(SLOTS).filter(
+    ([, decl]) => decl.stage === "value"
+  );
+  const slotDyn = (node, field, shape) => {
+    const v = dir(node, field);
+    if (v === void 0) return false;
+    if (shape === "intentParams")
+      return Object.values(
+        v
+      ).some((b) => typeof b !== "string" && intentHasIsland(b));
+    return containsIsland(v);
+  };
+  const intentHasIsland = (b) => b.params !== void 0 && containsIsland(b.params) || b.then !== void 0 && intentHasIsland(b.then) || b.catch !== void 0 && intentHasIsland(b.catch);
+  const bindValues = (node, scope) => {
+    const hasDir = dir(node, "when") !== void 0 || dir(node, "each") !== void 0 || node.as !== void 0;
+    const dyn = VALUE_SLOTS.filter(
+      ([field, decl]) => slotDyn(node, field, decl.shape)
+    );
+    if (!hasDir && dyn.length === 0) return node;
+    const out = { ...node };
+    delete out.when;
+    delete out.each;
+    delete out.as;
+    for (const [field, decl] of dyn) {
+      const value = dir(node, field);
+      if (decl.shape === "intentParams") {
+        const intents = {};
+        for (const [k, b] of Object.entries(
+          value
+        ))
+          intents[k] = typeof b !== "string" && intentHasIsland(b) ? { ...b, scope } : b;
+        out[field] = intents;
+      } else out[field] = bindValue(value, scope);
+    }
+    return out;
+  };
+  const renderResolved = (node, scope) => {
+    const next = bindValues(node, scope);
+    if (!node.children) return next;
+    const kids = node.children.flatMap((c) => expandChild(c, scope));
+    return next.children === kids ? next : { ...next, children: kids };
+  };
+  const expandChild = (child, parentScope) => {
+    const dataDir = dir(child, "each");
+    const when = dir(child, "when");
+    const binding = typeof child.as === "string" ? child.as : void 0;
+    const dataVal = dataDir !== void 0 ? evalDirective(dataDir, parentScope) : void 0;
+    if (Array.isArray(dataVal)) {
+      const out = [];
+      dataVal.forEach((item, i) => {
+        const s2 = childScope(parentScope, binding, item, i);
+        if (when !== void 0 && !evalDirective(when, s2)) return;
+        out.push(
+          renderResolved(
+            stripDir({ ...child, id: repeatId(child.id, item, i) }),
+            s2
+          )
+        );
+      });
+      return out;
+    }
+    const s = dataVal !== void 0 ? childScope(parentScope, binding, dataVal) : parentScope;
+    if (when !== void 0 && !evalDirective(when, s)) return [];
+    return [renderResolved(stripDir(child), s)];
+  };
+  const compiled = /* @__PURE__ */ new WeakMap();
+  return {
+    compile(node) {
+      const hit = compiled.get(node);
+      if (hit !== void 0) return hit;
+      const { def, diagnostics } = compile(node, { profile });
+      for (const d of diagnostics)
+        if (d.severity === "error") onReject(d.message, d.source ?? d.address);
+      compiled.set(node, def);
+      compiled.set(def, def);
+      return def;
+    },
+    bind(node, data) {
+      if (isDev()) warnIfAuthored(node);
+      const out = expandChild(node, rootScope(data));
+      return out[0] ?? stripDir(node);
+    }
+  };
+}
+var warned = /* @__PURE__ */ new WeakSet();
+function warnIfAuthored(node) {
+  if (warned.has(node)) return;
+  warned.add(node);
+  const found = findAuthoredSlot(node);
+  if (found)
+    console.warn(
+      `[loom/tslite] defini\xE7\xE3o N\xC3O COMPILADA: ${found} tem "{{ }}" em texto, e o bind trata string como dado. Passe a defini\xE7\xE3o por compile() antes \u2014 o ponto de entrada (resolveTree / a expans\xE3o do forge) faz isso pelo port.`
+    );
+}
+function findAuthoredSlot(node, path = "#0") {
+  for (const [field, decl] of Object.entries(SLOTS)) {
+    const value = node[field];
+    if (hasAuthoredText(value, decl.directives)) return `${path}.${field}`;
+  }
+  for (const [i, child] of (node.children ?? []).entries()) {
+    const found = findAuthoredSlot(child, `${path}.${i}`);
+    if (found) return found;
+  }
+  return void 0;
+}
+function hasAuthoredText(v, directives) {
+  if (typeof v === "string") return hasIslands(v, { directives });
+  if (Array.isArray(v)) return v.some((x) => hasAuthoredText(x, directives));
+  if (v && typeof v === "object")
+    return Object.values(v).some((x) => hasAuthoredText(x, directives));
+  return false;
+}
+function scan(v) {
+  if (isExprMarker(v)) return true;
+  if (Array.isArray(v)) return v.some(containsIsland);
+  if (v && typeof v === "object") return Object.values(v).some(containsIsland);
+  return false;
+}
+var scanned = /* @__PURE__ */ new WeakMap();
+function containsIsland(v) {
+  if (v === null || typeof v !== "object") return false;
+  const hit = scanned.get(v);
+  if (hit !== void 0) return hit;
+  const r = scan(v);
+  scanned.set(v, r);
+  return r;
+}
+
+export { createTsliteBinder };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bind.ts"],"names":["compile","s"],"mappings":"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","file":"index.js","sourcesContent":["import { fromJson } from \"@tslite/codec\";\nimport { EXPR_MARKER, isExprMarker } from \"@tslite/core\";\nimport { vanillaRuntime } from \"@tslite/operators\";\nimport { compile, createBaseScope } from \"@tslite/interpret\";\nimport { hasIslands } from \"@tslite/template\";\nimport {\n  compileProfile,\n  EXPRESSION_BUDGET,\n  type Budget,\n  type CapabilityProfile,\n} from \"@tslite/capability\";\nimport type {\n  BindingEngine,\n  CommandAlias,\n  DefNode,\n  EventBinding,\n} from \"@loom-forge/core\";\nimport { compile as compileDefinition, DEFAULT_PROFILE } from \"./compile\";\nimport { SLOTS } from \"@loom-forge/core\";\n\n/* ──────────────────────────────────────────────────────────────────────────────\n   Adapter de BIND via TSLite — implementa o `BindingEngine` (port). Expande a definição\n   contra `data` em DOIS estágios, sobre uma cadeia de escopos léxicos (não global):\n\n     ESTRUTURAL (when/each)        →   VALOR ({{}} / #expr)\n      muda a ÁRVORE (expansão 1:N)        liga VALORES (1:1)\n\n   • ESTRUTURAL: `when` dropa o nó se falsy (por item dentro de `each`); `each` array repete\n     o nó por item (o item entra pelo nome do `as`, + `$index`); `each` objeto re-escopa a\n     subárvore. Ids dos repetidos = `id.${item.id ?? índice}` (estáveis). Diretivas consumidas.\n   • VALOR: `{{expr}}` em strings (parser, TS-like) e ilha `#expr` (JsonExpression).\n   • EXECUÇÃO (valor E diretivas): parseExpression/decode → compile (eval-free, GATEADO pelo\n     CapabilityProfile) → runner. O profile é DADO serializável: diz o que a definição pode\n     programar, e o `compile` recusa (hard) o nó fora dele. NÃO há `new Function`;\n     identificadores só resolvem pelo escopo — globais (`fetch`/`process`) não existem.\n   ────────────────────────────────────────────────────────────────────────────── */\n\nexport interface TsliteBinderOptions {\n  /**\n   * A STDLIB e os helpers do host, planos no escopo. Default: `vanillaRuntime` do\n   * `@tslite/operators` — os 53 operadores (`length`, `map`, `filter`, `pick`…).\n   *\n   * Não é conveniência: o TSLite é FP e **não tem protótipo**, então `xs.length` é erro e a\n   * forma é `length(xs)`. Sem os operadores, uma expressão não consegue fazer quase nada.\n   * Passar `globals` SUBSTITUI a stdlib; para acrescentar, espalhe: `{ ...vanillaRuntime, meu }`.\n   */\n  globals?: Record<string, unknown>;\n  /**\n   * A metade de RUNTIME da fronteira de tipos — o `runtime` de um `createBoundary` do\n   * `@tslite/validate`: o catálogo de tipos nomeados como valor e o asserter (`parseAs`) que\n   * prova. O host monta a fronteira UMA vez, do mesmo catálogo que dá ao `check`, e entrega a\n   * metade certa a cada lado; quem não usa asserter não instala o validador.\n   */\n  boundary?: { readonly runtime: Readonly<Record<string, unknown>> };\n  /** o que a definição pode programar — `CapabilityProfile` (dado puro, serializável).\n   *  Default: `DEFAULT_PROFILE` (`PRESETS[\"pure-fp\"]`: lambda, sem mutação/laço/`throw`/async).\n   *  Apertar ou afrouxar = passar outro preset (`PRESETS.data` fecha a lambda) ou um profile\n   *  próprio. */\n  profile?: CapabilityProfile;\n  /** orçamento de EXECUÇÃO por avaliação (`steps`/`depth`/`size`, em unidades da Linguagem).\n   *  Vence o do profile; sem nenhum dos dois, vale o `EXPRESSION_BUDGET` do `@tslite/capability`\n   *  — o orçamento MEDIDO para uma expressão vinda de um documento. `false` desliga a contagem:\n   *  o runner fica idêntico ao sem instrumentação, e uma recursão sem fim só para quando a pilha\n   *  do JS estoura. */\n  budget?: Budget | false;\n  /** erro de execução (ex.: nome desconhecido). Default: warn em dev + `undefined`. */\n  onError?(error: unknown, source: string): void;\n  /** expressão recusada na COMPILAÇÃO — fora do profile (`node-not-allowed`) ou barrada pelo\n   *  sanitize (`__proto__`/`constructor`, autoridade ambiente). Default: warn em dev + `undefined`. */\n  onReject?(error: unknown, source: string): void;\n}\n\n/** rótulo da ilha para o diagnóstico: o tipo do nó raiz. */\nconst marker = (v: object): string =>\n  `${EXPR_MARKER}:${String((v as Record<string, unknown>)[EXPR_MARKER])}`;\n\nconst isTsliteError = (e: unknown): boolean =>\n  !!e && typeof e === \"object\" && \"code\" in (e as object);\n\nconst isDev = (): boolean => {\n  const g = globalThis as { process?: { env?: { NODE_ENV?: string } } };\n  return g.process?.env?.NODE_ENV !== \"production\";\n};\n\nexport function createTsliteBinder(\n  opts: TsliteBinderOptions = {},\n): BindingEngine {\n  const globals = {\n    ...(opts.globals ?? vanillaRuntime),\n    ...(opts.boundary?.runtime ?? {}),\n  };\n  const profile = opts.profile ?? DEFAULT_PROFILE;\n  // a precedência do `interpret`: o `budget` explícito vence o do profile. O default só entra\n  // quando nenhum dos dois declara — um profile com orçamento próprio (`server`) segue o dele.\n  const budget =\n    opts.budget === false\n      ? undefined\n      : (opts.budget ??\n        (compileProfile(profile).budget === null\n          ? EXPRESSION_BUDGET\n          : undefined));\n  // a BASE do escopo: os `globals` montados UMA vez, e cada avaliação abre o próprio root como\n  // filho dela — em vez de copiar os 53 operadores a cada render e a cada item de um `each`.\n  // Ela é só leitura: um programa que reatribuísse `map` mudaria todas as execuções seguintes.\n  const base = createBaseScope(globals);\n  const compileOpts = budget ? { profile, budget, base } : { profile, base };\n  const onError =\n    opts.onError ??\n    ((error, source) => {\n      if (isDev())\n        console.warn(`[loom/tslite] erro avaliando \"${source}\":`, error);\n    });\n  const onReject =\n    opts.onReject ??\n    ((error, source) => {\n      if (isDev())\n        console.warn(`[loom/tslite] expressão recusada \"${source}\":`, error);\n    });\n\n  /* ── TABELA DE COMPILAÇÃO ────────────────────────────────────────────────────────\n     O binder consome a definição COMPILADA: expressão já é ÁRVORE (ilha `#expr`), nunca\n     texto. Aqui não há parser — só `fromJson` (valor com ilhas → AST) e o `compile` do\n     TSLite, cada ilha uma vez. String é DADO, sempre.\n\n     A tabela é chaveada pela IDENTIDADE da ilha (WeakMap): a ilha é um objeto da definição,\n     estável entre renders. E é POR BINDER porque o runner carrega o gating do `profile` —\n     dois binders com profiles diferentes não podem compartilhar runner.\n\n     As falhas são memoizadas (não o efeito: os callbacks seguem disparando a cada avaliação)\n     — uma ilha recusada não deve ser recompilada a cada render só pra ser recusada de novo. */\n  type Compiled =\n    | { ok: true; run: ReturnType<typeof compile> }\n    | { ok: false; phase: \"decode\" | \"compile\"; error: unknown };\n\n  const islands = new WeakMap<object, Compiled>();\n\n  /** Executa uma entrada da tabela. Recusa (compilação/decode) → `onReject`; falha de\n   *  execução (escopo sem o nome, host lançou, orçamento estourado) → `onError`. Nunca lança. */\n  const exec = (\n    entry: Compiled,\n    scope: Record<string, unknown>,\n    source: string,\n  ): unknown => {\n    if (!entry.ok) {\n      onReject(entry.error, source);\n      return undefined;\n    }\n    try {\n      return entry.run(scope);\n    } catch (error) {\n      onError(error, source);\n      return undefined;\n    }\n  };\n\n  const evalIsland = (\n    value: object,\n    scope: Record<string, unknown>,\n  ): unknown => {\n    let entry = islands.get(value);\n    if (entry === undefined) {\n      try {\n        entry = {\n          ok: true,\n          run: compile(fromJson(value as never), compileOpts),\n        };\n      } catch (error) {\n        entry = {\n          ok: false,\n          phase: isTsliteError(error) ? \"compile\" : \"decode\",\n          error,\n        };\n      }\n      islands.set(value, entry);\n    }\n    return exec(entry, scope, marker(value));\n  };\n  /**\n   * Valor compilado → valor ligado. **String é DADO** — na definição compilada não existe\n   * expressão em texto, então não há o que farejar. Só a ilha computa, e o estático desce\n   * intacto: o custo é proporcional ao dinamismo.\n   */\n  const bindValue = (v: unknown, scope: Record<string, unknown>): unknown => {\n    if (isExprMarker(v)) return evalIsland(v as object, scope);\n    if (Array.isArray(v)) return v.map((x) => bindValue(x, scope));\n    if (v && typeof v === \"object\") {\n      const out: Record<string, unknown> = {};\n      for (const [k, val] of Object.entries(v)) out[k] = bindValue(val, scope);\n      return out;\n    }\n    return v;\n  };\n\n  /* ── estágio estrutural: when (drop) + each (repeat/re-scope) ──────────────── */\n\n  const isObj = (v: unknown): v is Record<string, unknown> =>\n    !!v && typeof v === \"object\" && !Array.isArray(v);\n\n  const dir = (node: DefNode, key: string): unknown =>\n    (node as unknown as Record<string, unknown>)[key];\n\n  /** avalia `when`/`each`: ilha → executa; literal → o próprio valor. */\n  const evalDirective = (\n    v: unknown,\n    scope: Record<string, unknown>,\n  ): unknown => (isExprMarker(v) ? evalIsland(v as object, scope) : v);\n\n  /* ── ESCOPO: raízes nomeadas, nada implícito ──────────────────────────────────────\n     Todo nome ou é RAIZ (o mapa que o chamador passa: `data` no render, `props`/`state`\n     no corpo de um componente) ou foi DECLARADO — o `as` de um `each`. Não há nome\n     achatado: prop e state não disputam espaço, e o checker consegue montar o `env` como\n     projeção direta do que o `ComponentDef` declara.\n\n     Os `globals` ficam planos e moram na BASE do escopo: são o vocabulário da Linguagem\n     (`length`, `map`), não dado do programa — e um nome do escopo os sombreia.\n\n     O escopo do item ESTENDE o do pai — `each` aninhado enxerga o item de fora, que é o\n     que \"escopo léxico\" quer dizer. */\n  const rootScope = (scope: unknown): Record<string, unknown> =>\n    isObj(scope) ? scope : {};\n\n  const childScope = (\n    parent: Record<string, unknown>,\n    binding: string | undefined,\n    item: unknown,\n    index?: number,\n  ): Record<string, unknown> => ({\n    ...parent,\n    ...(binding ? { [binding]: item } : {}),\n    ...(index != null ? { $index: index } : {}),\n  });\n\n  const repeatId = (baseId: string, item: unknown, index: number): string =>\n    `${baseId}.${isObj(item) && \"id\" in item ? String(item.id) : index}`;\n\n  /** as diretivas são CONSUMIDAS: não aparecem na saída resolvida. */\n  const stripDir = (node: DefNode): DefNode => {\n    if (\n      dir(node, \"when\") === undefined &&\n      dir(node, \"each\") === undefined &&\n      node.as === undefined\n    )\n      return node;\n    const n = { ...node } as unknown as Record<string, unknown>;\n    delete n.when;\n    delete n.each;\n    delete n.as;\n    return n as unknown as DefNode;\n  };\n\n  /** os campos que este estágio liga — os de VALOR. Os estruturais (`each`/`when`) são do\n   *  outro estágio, e quem diz qual é qual é a TABELA, não uma lista aqui: campo novo passa a\n   *  ser coberto sem ninguém lembrar. É para isso que ela existe. */\n  const VALUE_SLOTS = Object.entries(SLOTS).filter(\n    ([, decl]) => decl.stage === \"value\",\n  );\n\n  /** o campo tem alguma ilha para avaliar? */\n  const slotDyn = (node: DefNode, field: string, shape: string): boolean => {\n    const v = dir(node, field);\n    if (v === undefined) return false;\n    if (shape === \"intentParams\")\n      return Object.values(\n        v as Record<string, EventBinding | CommandAlias>,\n      ).some((b) => typeof b !== \"string\" && intentHasIsland(b));\n    return containsIsland(v);\n  };\n\n  /** a intenção — ou algum elo da cadeia dela — tem ilha nos `params`? */\n  const intentHasIsland = (b: EventBinding): boolean =>\n    (b.params !== undefined && containsIsland(b.params)) ||\n    (b.then !== undefined && intentHasIsland(b.then)) ||\n    (b.catch !== undefined && intentHasIsland(b.catch));\n\n  /** constrói o nó final: remove as diretivas estruturais + liga os slots de VALOR. Mantém a\n   *  ref se nada muda. NÃO recursa filhos. */\n  const bindValues = (\n    node: DefNode,\n    scope: Record<string, unknown>,\n  ): DefNode => {\n    const hasDir =\n      dir(node, \"when\") !== undefined ||\n      dir(node, \"each\") !== undefined ||\n      node.as !== undefined;\n    const dyn = VALUE_SLOTS.filter(([field, decl]) =>\n      slotDyn(node, field, decl.shape),\n    );\n    if (!hasDir && dyn.length === 0) return node;\n    const out = { ...node } as unknown as Record<string, unknown>;\n    delete out.when;\n    delete out.each;\n    delete out.as;\n    for (const [field, decl] of dyn) {\n      const value = dir(node, field);\n      if (decl.shape === \"intentParams\") {\n        // `events` ou `commands`: os `params` de uma intenção NÃO são avaliados aqui — ficam\n        // compilados, e o binding guarda o escopo do render. Quem avalia é o despacho, sobre\n        // esse escopo mais a raiz `event` (ADR-018). A forma curta de um alias é só um nome, e\n        // atravessa intacta.\n        const intents: Record<string, EventBinding | CommandAlias> = {};\n        for (const [k, b] of Object.entries(\n          value as Record<string, EventBinding | CommandAlias>,\n        ))\n          intents[k] =\n            typeof b !== \"string\" && intentHasIsland(b) ? { ...b, scope } : b;\n        out[field] = intents;\n      } else out[field] = bindValue(value, scope);\n    }\n    return out as unknown as DefNode;\n  };\n\n  /** renderiza um nó que VAI aparecer (escopo já decidido pelo caller): bind de valores +\n   *  expande os filhos via `expandChild`. */\n  const renderResolved = (\n    node: DefNode,\n    scope: Record<string, unknown>,\n  ): DefNode => {\n    const next = bindValues(node, scope);\n    if (!node.children) return next;\n    const kids = node.children.flatMap((c) => expandChild(c, scope));\n    return next.children === kids ? next : { ...next, children: kids };\n  };\n\n  /** expande UM filho → 0+ nós: `when` (drop), `each` array (repeat por item), objeto\n   *  (re-escopa a subárvore). O item entra no escopo pelo nome que o `as` declara. */\n  const expandChild = (\n    child: DefNode,\n    parentScope: Record<string, unknown>,\n  ): DefNode[] => {\n    const dataDir = dir(child, \"each\");\n    const when = dir(child, \"when\");\n    const binding = typeof child.as === \"string\" ? child.as : undefined;\n    const dataVal =\n      dataDir !== undefined ? evalDirective(dataDir, parentScope) : undefined;\n\n    if (Array.isArray(dataVal)) {\n      const out: DefNode[] = [];\n      dataVal.forEach((item, i) => {\n        const s = childScope(parentScope, binding, item, i);\n        if (when !== undefined && !evalDirective(when, s)) return; // when por item\n        out.push(\n          renderResolved(\n            stripDir({ ...child, id: repeatId(child.id, item, i) }),\n            s,\n          ),\n        );\n      });\n      return out;\n    }\n\n    const s =\n      dataVal !== undefined\n        ? childScope(parentScope, binding, dataVal)\n        : parentScope;\n    if (when !== undefined && !evalDirective(when, s)) return []; // drop\n    return [renderResolved(stripDir(child), s)];\n  };\n\n  /* ── A FASE DE COMPILAÇÃO ────────────────────────────────────────────────────────\n     Memoizada por identidade do nó e idempotente: chamar de novo é barato, e chamar\n     sobre já-compilado é no-op. Os diagnósticos vão pro `onReject` — recusar é da\n     compilação, que é exatamente o que eles são. */\n  const compiled = new WeakMap<DefNode, DefNode>();\n\n  return {\n    compile(node: DefNode): DefNode {\n      const hit = compiled.get(node);\n      if (hit !== undefined) return hit;\n      // com o profile deste binder: o que ele recusaria sai aqui, uma vez, com endereço — e não\n      // a cada avaliação, sem ele\n      const { def, diagnostics } = compileDefinition(node, { profile });\n      for (const d of diagnostics)\n        if (d.severity === \"error\") onReject(d.message, d.source ?? d.address);\n      compiled.set(node, def);\n      compiled.set(def, def); // recompilar a saída é no-op\n      return def;\n    },\n\n    bind(node: DefNode, data: unknown): DefNode {\n      if (isDev()) warnIfAuthored(node);\n      // a raiz é tratada como qualquer nó (suporta each-objeto/when); raiz nunca é dropada.\n      const out = expandChild(node, rootScope(data));\n      return out[0] ?? stripDir(node);\n    },\n  };\n}\n\n/* ── O guarda ────────────────────────────────────────────────────────────────────\n   O `bind` consome COMPILADO. Se chegar definição autorada, a expressão em texto seria\n   tratada como dado e o nó renderizaria `\"olá {{ nome }}\"` literalmente — o código parece\n   certo, não levanta erro, e custa horas. O guarda roda só em dev e só olha os SLOTS. */\nconst warned = new WeakSet<object>();\n\nfunction warnIfAuthored(node: DefNode): void {\n  if (warned.has(node)) return;\n  warned.add(node);\n  const found = findAuthoredSlot(node);\n  if (found)\n    console.warn(\n      `[loom/tslite] definição NÃO COMPILADA: ${found} tem \"{{ }}\" em texto, e o bind ` +\n        `trata string como dado. Passe a definição por compile() antes — o ponto de entrada ` +\n        `(resolveTree / a expansão do forge) faz isso pelo port.`,\n    );\n}\n\n/** o primeiro slot com expressão em texto, ou `undefined`. */\nfunction findAuthoredSlot(node: DefNode, path = \"#0\"): string | undefined {\n  for (const [field, decl] of Object.entries(SLOTS)) {\n    const value = (node as unknown as Record<string, unknown>)[field];\n    if (hasAuthoredText(value, decl.directives)) return `${path}.${field}`;\n  }\n  for (const [i, child] of (node.children ?? []).entries()) {\n    const found = findAuthoredSlot(child, `${path}.${i}`);\n    if (found) return found;\n  }\n  return undefined;\n}\n\n/** há marcação em alguma string daqui? Pelo scanner do TSLite, com o `directives` do slot — um\n *  `includes(\"{{\")` erraria num `{{` dentro de uma string literal. */\nfunction hasAuthoredText(v: unknown, directives: boolean): boolean {\n  if (typeof v === \"string\") return hasIslands(v, { directives });\n  if (Array.isArray(v)) return v.some((x) => hasAuthoredText(x, directives));\n  if (v && typeof v === \"object\")\n    return Object.values(v).some((x) => hasAuthoredText(x, directives));\n  return false;\n}\n\n/** Há ilha na subárvore? Evita rebuild de props 100% estáticas (preserva a referência → memo\n *  do React). Na definição compilada a pergunta é ESTRUTURAL: procura o marcador, não texto. */\nfunction scan(v: unknown): boolean {\n  if (isExprMarker(v)) return true;\n  if (Array.isArray(v)) return v.some(containsIsland);\n  if (v && typeof v === \"object\") return Object.values(v).some(containsIsland);\n  return false;\n}\n\n/* Memoizado por IDENTIDADE do objeto: \"tem ilha?\" é propriedade da DEFINIÇÃO, não do dado —\n   a resposta não muda entre renders, e um `each` de N itens reusa o mesmo objeto de props N\n   vezes. A definição é imutável (todo o desenho é dado imutável), então a identidade é chave\n   legítima. Global e sem profile: a pergunta é estrutural. */\nconst scanned = new WeakMap<object, boolean>();\n\nfunction containsIsland(v: unknown): boolean {\n  if (v === null || typeof v !== \"object\") return false;\n  const hit = scanned.get(v);\n  if (hit !== undefined) return hit;\n  const r = scan(v);\n  scanned.set(v, r);\n  return r;\n}\n"]}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@loom-forge/tslite",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "loom · o adapter de BIND via TSLite: compile() (expressão em texto → ilha #expr) e o binder que a executa, gateado por CapabilityProfile, eval-free, com a stdlib do @tslite/operators no escopo.",
+  "keywords": [
+    "tslite",
+    "expression",
+    "template",
+    "json",
+    "dsl",
+    "compile"
+  ],
+  "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/tslite"
+  },
+  "homepage": "https://github.com/andersondrosa/loom-forge/tree/main/packages/tslite#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"
+    },
+    "./compile": {
+      "types": "./dist/compile.d.ts",
+      "import": "./dist/compile.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@tslite/capability": "^0.6.0",
+    "@tslite/codec": "^0.8.1",
+    "@tslite/core": "^0.11.0",
+    "@tslite/interpret": "^0.5.2",
+    "@tslite/language-service": "^0.4.0",
+    "@tslite/normalize": "^0.2.0",
+    "@tslite/operators": "^1.0.4",
+    "@tslite/parser": "^1.4.0",
+    "@tslite/sanitize": "^0.1.12",
+    "@tslite/template": "^0.3.1",
+    "@loom-forge/core": "0.1.0"
+  },
+  "devDependencies": {
+    "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"
+  }
+}