@loom-forge/check 0.1.0

package/dist/index.js

@@ -0,0 +1,867 @@
+import { s, format, subtype, isSerializable } from '@tslite/type-core';
+import { toJsonSchema, fromJsonSchema } from '@tslite/jsonschema';
+import { inferValue } from '@tslite/infer';
+import { s as s$1, createAnchors, check, spanOf, annotate, createEnv, anchorDiagnostics, lowerValue } from '@tslite/checker';
+import { ASSERTER, createBoundary } from '@tslite/validate';
+import { vanilla } from '@tslite/operators';
+import { addressOf, isLive, compileDefinition, mountScopesOf, mountingOf, compileComponent, EMPTY_MOUNT, settledRoute } from '@loom-forge/forge';
+import * as b from '@tslite/core/builders';
+import { isExprMarker, EXPR_MARKER } from '@tslite/core';
+import { parseExpression } from '@tslite/parser';
+import { compile, DEFAULT_PROFILE } from '@loom-forge/tslite/compile';
+import { FIELDS, slotOf, TREE } from '@loom-forge/core';
+import { PRESETS } from '@tslite/capability';
+
+// src/checker.ts
+function createTsliteChecker() {
+  const inferType = (value) => inferValue(value);
+  const fromJS = (jsonSchema) => fromJsonSchema(jsonSchema);
+  return {
+    subtype: (a, b2) => subtype(a, b2),
+    inferType,
+    fromJsonSchema: fromJS,
+    toJsonSchema: (schema) => toJsonSchema(schema),
+    assignable: (value, jsonSchema) => subtype(inferType(value), fromJS(jsonSchema)),
+    format: (schema) => format(schema)
+  };
+}
+function checkTree(node, registry, checker) {
+  const issues = [];
+  const visit = (n) => {
+    if (n.kind !== "node") return;
+    const descriptor = registry.get(n.type);
+    if (descriptor?.schema && !checker.assignable(n.props, descriptor.schema)) {
+      issues.push({
+        nodeId: n.id,
+        type: n.type,
+        expected: checker.format(checker.fromJsonSchema(descriptor.schema)),
+        got: checker.format(checker.inferType(n.props))
+      });
+    }
+    n.children.forEach(visit);
+  };
+  visit(node);
+  return issues;
+}
+var SCALARS = {
+  any: s.any,
+  unknown: s.unknown,
+  string: s.string,
+  number: s.number,
+  boolean: s.boolean,
+  null: s.null
+};
+function resolveTypeRef(ref, types = {}) {
+  if (typeof ref === "string") return types[ref] ?? SCALARS[ref] ?? s.unknown;
+  const o = ref;
+  if (typeof o.t === "string") return ref;
+  return fromJsonSchema(ref);
+}
+var unresolvedName = (ref, types) => typeof ref === "string" && !(ref in types) && !(ref in SCALARS) ? ref : void 0;
+function resolveProps(props, types = {}) {
+  const shape = {};
+  for (const [rawKey, ref] of Object.entries(props ?? {})) {
+    const optional = rawKey.endsWith("?");
+    const key = optional ? rawKey.slice(0, -1) : rawKey;
+    const type = resolveTypeRef(ref, types);
+    shape[key] = optional ? { type: s.union([type, s.undefined]), optional: true } : { type };
+  }
+  return s.object(shape);
+}
+function componentType(ir, types = {}) {
+  return {
+    props: resolveProps(ir.props, types),
+    ...ir.category ? { category: ir.category } : {},
+    entry: ir.entry
+  };
+}
+function componentAssignable(child, contract, types = {}) {
+  if (contract.props === void 0) return true;
+  return subtype(child.props, resolveProps(contract.props, types));
+}
+function checkDeclarations(def, types = {}) {
+  const issues = [];
+  const report = (path, name) => {
+    issues.push({
+      code: "unknown-type-name",
+      message: `Type '${name}' is not declared: it is neither a scalar (${Object.keys(SCALARS).join(", ")}) nor a name in the type catalog.`,
+      severity: "error",
+      path,
+      address: addressOf(path),
+      source: name
+    });
+  };
+  for (const [rawKey, ref] of Object.entries(def.props ?? {})) {
+    const name = unresolvedName(ref, types);
+    if (name !== void 0) report(["props", rawKey], name);
+  }
+  for (const [key, decl] of Object.entries(def.state ?? {})) {
+    const name = unresolvedName(decl.type, types);
+    if (name !== void 0) report(["state", key], name);
+  }
+  return issues;
+}
+function declaredContextsOf(catalog, types = {}) {
+  const cache = /* @__PURE__ */ new Map();
+  return (name) => {
+    if (cache.has(name)) return cache.get(name);
+    const ref = catalog?.[name];
+    const schema = ref ? resolveTypeRef(ref, types) : void 0;
+    const ok = schema && isSerializable(schema) ? schema : void 0;
+    cache.set(name, ok);
+    return ok;
+  };
+}
+function checkContextCatalog(catalog, types = {}) {
+  const issues = [];
+  for (const [name, ref] of Object.entries(catalog ?? {})) {
+    const unresolved = unresolvedName(ref, types);
+    if (unresolved !== void 0) {
+      issues.push({
+        code: "unknown-type-name",
+        message: `Type '${unresolved}' is not declared: it is neither a scalar (${Object.keys(SCALARS).join(", ")}) nor a name in the type catalog.`,
+        severity: "error",
+        path: ["contexts", name],
+        address: addressOf(["contexts", name]),
+        source: unresolved
+      });
+      continue;
+    }
+    if (!isSerializable(resolveTypeRef(ref, types)))
+      issues.push({
+        code: "unknown-type-name",
+        message: `Context '${name}' must be serializable DATA: a contract with functions (or \`unknown\`/\`any\`) is not a contract. Behavior goes through events \u2192 ActionPort, which is the door that creates an edge in the graph.`,
+        severity: "error",
+        path: ["contexts", name],
+        address: addressOf(["contexts", name]),
+        source: name
+      });
+  }
+  return issues;
+}
+function declaredParamsOf(updates, types = {}) {
+  return (action) => {
+    const decl = updates?.[action]?.params;
+    return decl ? resolveProps(decl, types) : void 0;
+  };
+}
+function hostParamsOf(port, types = {}) {
+  return (action) => {
+    const schema = port?.paramsOf?.(action);
+    return schema === void 0 || schema === null ? void 0 : resolveTypeRef(schema, types);
+  };
+}
+function paramsResolver(...resolvers) {
+  return (action) => {
+    for (const resolve of resolvers) {
+      const found = resolve(action);
+      if (found) return found;
+    }
+    return void 0;
+  };
+}
+function partialStateType(state, types = {}) {
+  return s.object(
+    Object.fromEntries(
+      Object.entries(state ?? {}).map(([k, decl]) => [
+        k,
+        { type: resolveTypeRef(decl.type, types), optional: true }
+      ])
+    )
+  );
+}
+function partialOf(schema) {
+  const o = schema;
+  if (o?.t !== "object" || !o.props) return schema;
+  return {
+    ...o,
+    props: Object.fromEntries(
+      Object.entries(o.props).map(([key, field]) => [
+        key,
+        { ...field, optional: true }
+      ])
+    )
+  };
+}
+function declaredPropsOf(sys, types = {}) {
+  const cache = /* @__PURE__ */ new Map();
+  return (type) => {
+    if (cache.has(type)) return cache.get(type);
+    const ir = sys.components.get(type);
+    const schema = ir ? componentType(ir, types).props : void 0;
+    cache.set(type, schema);
+    return schema;
+  };
+}
+function stateTypeOf(state, types = {}) {
+  return (key) => {
+    const decl = state?.[key];
+    return decl ? resolveTypeRef(decl.type, types) : void 0;
+  };
+}
+function propTypeOf(schema, key) {
+  const o = schema;
+  return o?.t === "object" ? o.props?.[key]?.type : void 0;
+}
+function hostResultOf(port, types = {}) {
+  return (action) => {
+    const schema = port?.resultOf?.(action);
+    return schema === void 0 || schema === null ? void 0 : resolveTypeRef(schema, types);
+  };
+}
+var DEFAULT_ASSERTER = ASSERTER;
+var ctxRoot = (def, contexts) => {
+  const uses = def.context?.uses ?? [];
+  if (!contexts || uses.length === 0) return void 0;
+  const shape = {};
+  for (const name of uses)
+    if (contexts[name]) shape[name] = { type: contexts[name] };
+  return { ctx: s.object(shape) };
+};
+var stateSchema = (state, types) => s.object(
+  Object.fromEntries(
+    Object.entries(state ?? {}).map(([k, decl]) => [
+      k,
+      { type: resolveTypeRef(decl.type, types) }
+    ])
+  )
+);
+var envOf = (vars, opts) => {
+  const operators = opts.operators ?? vanilla;
+  const boundary = createBoundary({
+    types: opts.types ?? {},
+    reserved: [...Object.keys(operators), ...Object.keys(vars)]
+  });
+  return createEnv(
+    { ...operators, ...boundary.check.vars, ...vars },
+    { types: boundary.check.types, asserters: boundary.check.asserters }
+  );
+};
+function buildEnv(def, opts = {}) {
+  const types = opts.types ?? {};
+  return envOf(
+    {
+      props: resolveProps(def.props, types),
+      state: stateSchema(def.state, types),
+      ...opts.data ? { data: opts.data } : {},
+      ...ctxRoot(def, opts.contexts) ?? {},
+      // o PENDENTE é fato de uma INSTÂNCIA, e instância é o boundary de um componente vivo: só
+      // ele tem a raiz. Num componente puro, `pending` é `unknown-name` — e o remédio é um update
+      // ou um efeito, que é o que o torna vivo (ADR-018).
+      ...isLive(def) ? { pending: PENDING } : {}
+    },
+    opts
+  );
+}
+var PENDING = s.record(s.boolean);
+function buildInitEnv(def, opts = {}) {
+  return envOf(
+    {
+      props: resolveProps(def.props, opts.types ?? {}),
+      ...ctxRoot(def, opts.contexts) ?? {}
+    },
+    opts
+  );
+}
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && !isExprMarker(v);
+var NO_SYSTEM = {
+  slotScopesOf: () => void 0,
+  vocabulary: /* @__PURE__ */ new Set()
+};
+var ACTION_ERROR = s$1.object({
+  code: { type: s$1.string },
+  message: { type: s$1.string, optional: true },
+  data: { type: s$1.unknown, optional: true }
+});
+function lowerComponent(authored, opts = {}) {
+  const shapeOf = opts.shapeOf ?? (() => "list");
+  const propsOf = opts.propsOf ?? (() => void 0);
+  const paramsOf = opts.paramsOf ?? (() => void 0);
+  const exhaustiveParams = opts.exhaustiveParams ?? (() => true);
+  const weak = /* @__PURE__ */ new Set();
+  const contextOf = opts.contextOf ?? (() => void 0);
+  const emitsOf = opts.emitsOf ?? (() => void 0);
+  const resultOf = opts.resultOf ?? (() => void 0);
+  const compiled = opts.compiled ?? compileDefinition(authored, compile);
+  const def = compiled.def;
+  const nodes = /* @__PURE__ */ new Map();
+  const texts = /* @__PURE__ */ new Map();
+  const failed = /* @__PURE__ */ new Set();
+  const sugared = (address) => address.startsWith("provides.") || address.startsWith("commands.") ? `#0.${address}` : void 0;
+  for (const island of compiled.islands) {
+    nodes.set(island.address, island.node);
+    texts.set(island.address, island.text);
+    const alias = sugared(island.address);
+    if (alias !== void 0 && !nodes.has(alias)) {
+      nodes.set(alias, island.node);
+      texts.set(alias, island.text);
+    }
+  }
+  for (const d of compiled.diagnostics) {
+    failed.add(d.address);
+    const alias = sugared(d.address);
+    if (alias !== void 0) failed.add(alias);
+  }
+  const anchors = createAnchors();
+  const islands = [];
+  const frames = /* @__PURE__ */ new Map();
+  const pendingFrames = [];
+  let temp = 0;
+  let call = 0;
+  let act = 0;
+  let evt = 0;
+  let ctxn = 0;
+  let ini = 0;
+  let aln = 0;
+  const root = {
+    ...def.body,
+    ...def.provides ? { provides: { ...def.provides, ...def.body.provides } } : {},
+    ...def.commands ? { commands: { ...def.commands, ...def.body.commands } } : {}
+  };
+  const mounting = opts.mounting ?? NO_SYSTEM;
+  const scopesAt = mountScopesOf(root, mounting);
+  const routing = {
+    updates: new Set(Object.keys(def.updates ?? {})),
+    vocabulary: /* @__PURE__ */ new Set([
+      ...mountingOf([
+        compileComponent(def, { components: /* @__PURE__ */ new Set([def.component]) })
+      ]).vocabulary,
+      ...mounting.vocabulary
+    ])
+  };
+  const nameNode = (name, path) => {
+    const address = addressOf(path);
+    texts.set(address, name);
+    const node = b.identifier(name);
+    islands.push({ node, path, address, source: name });
+    return anchors.stamp(node, path);
+  };
+  const fromPath = (observed, path) => {
+    try {
+      const node = parseExpression(observed);
+      const address = addressOf(path);
+      texts.set(address, observed);
+      islands.push({ node, path, address, source: observed });
+      return anchors.stamp(node, path);
+    } catch {
+      return void 0;
+    }
+  };
+  const lowerAt = (value, path, extras = []) => {
+    const expr = lowerValue(prepared(value, path), path, anchors, {
+      child: (p, key) => [...p, key],
+      island: (marker, p) => {
+        const address = addressOf(p);
+        const node = nodes.get(address) ?? b.fromExprMarker(marker);
+        const source = texts.get(address);
+        islands.push({
+          node,
+          path: p,
+          address,
+          ...source ? { source } : {}
+        });
+        return node;
+      }
+    });
+    if (extras.length > 0 && expr.type === "ObjectExpression")
+      for (const extra of extras)
+        expr.properties.push(
+          anchors.stamp(
+            b.property(
+              b.literal(extra.key),
+              extra.value
+            ),
+            extra.path
+          )
+        );
+    return expr;
+  };
+  const ISLAND = { [EXPR_MARKER]: "Island" };
+  const prepared = (value, path) => {
+    const address = addressOf(path);
+    if (nodes.has(address)) return ISLAND;
+    if (typeof value === "string") return failed.has(address) ? null : value;
+    if (Array.isArray(value))
+      return value.map((x, i) => prepared(x, [...path, i]));
+    if (isRecord(value))
+      return Object.fromEntries(
+        Object.entries(value).map(([k, v]) => [k, prepared(v, [...path, k])])
+      );
+    return value;
+  };
+  const stmt = (e) => b.expressionStatement(e);
+  const body = [];
+  const initBody = [];
+  const push = (st) => {
+    if (st) body.push(st);
+  };
+  const hasIsland = (v) => {
+    if (isExprMarker(v)) return true;
+    if (Array.isArray(v)) return v.some(hasIsland);
+    if (v && typeof v === "object") return Object.values(v).some(hasIsland);
+    return false;
+  };
+  const emitValue = (v, path, expects) => {
+    if (!hasIsland(v)) return;
+    const e = lowerAt(v, path);
+    push(
+      expects === "boolean" ? b.variableDeclaration("const", [
+        b.variableDeclarator(
+          annotate(b.identifier(`__t${temp++}`), s$1.boolean),
+          e
+        )
+      ]) : stmt(e)
+    );
+  };
+  const emitIntent = (intent, path, scopes, received) => {
+    const at = [...path, "params"];
+    const route = typeof intent.action === "string" ? settledRoute(intent.action, scopes, routing) : void 0;
+    const target = route === void 0 || route.kind === "command" ? void 0 : route.action;
+    const declared = target === void 0 ? void 0 : paramsOf(target);
+    if (declared && target !== void 0 && !exhaustiveParams(target))
+      weak.add(addressOf(at));
+    const supplied = [];
+    for (const key of intent.resolve ?? [])
+      if (typeof key === "string")
+        supplied.push({
+          key,
+          ...declared && propTypeOf(declared, key) ? { type: propTypeOf(declared, key) } : {},
+          path: [...path, "resolve"]
+        });
+    if (declared && route && route.kind !== "command" && isRecord(route.bound)) {
+      const written = isRecord(intent.params) ? intent.params : {};
+      for (const key of Object.keys(route.bound))
+        if (!(key in written) && !supplied.some((s4) => s4.key === key) && propTypeOf(declared, key))
+          supplied.push({
+            key,
+            type: propTypeOf(declared, key),
+            path: [...path, "action"]
+          });
+    }
+    const named = supplied.map((s4, i) => ({
+      ...s4,
+      local: IDENTIFIER.test(s4.key) && s4.key !== "event" ? s4.key : `__s${i}`
+    }));
+    const inner = [];
+    if (intent.params !== void 0) {
+      if (declared && isRecord(intent.params))
+        inner.push(
+          b.variableDeclaration("const", [
+            b.variableDeclarator(
+              annotate(b.identifier(`__e${evt++}`), declared),
+              lowerAt(
+                intent.params,
+                at,
+                named.map((s4) => ({
+                  key: s4.key,
+                  value: b.identifier(s4.local),
+                  path: s4.path
+                }))
+              )
+            )
+          ])
+        );
+      else if (hasIsland(intent.params))
+        inner.push(stmt(lowerAt(intent.params, at)));
+    } else if (declared && named.length > 0)
+      inner.push(
+        b.variableDeclaration("const", [
+          b.variableDeclarator(
+            annotate(b.identifier(`__e${evt++}`), declared),
+            lowerAt(
+              {},
+              at,
+              named.map((s4) => ({
+                key: s4.key,
+                value: b.identifier(s4.local),
+                path: s4.path
+              }))
+            )
+          )
+        ])
+      );
+    const outer = body.length;
+    if (intent.then)
+      emitIntent(
+        intent.then,
+        [...path, "then"],
+        scopes,
+        route?.kind === "update" ? s$1.undefined : (target === void 0 ? void 0 : resultOf(target)) ?? s$1.unknown
+      );
+    if (intent.catch)
+      emitIntent(intent.catch, [...path, "catch"], scopes, ACTION_ERROR);
+    inner.push(...body.splice(outer));
+    if (inner.length === 0) return;
+    const event = annotate(b.identifier("event"), received);
+    anchors.stamp(event, path);
+    push(
+      stmt(
+        b.arrowFunctionExpression(
+          [
+            event,
+            ...named.map((s4) => {
+              const param = nameNode(s4.local, s4.path);
+              return s4.type ? annotate(param, s4.type) : param;
+            })
+          ],
+          b.blockStatement(inner)
+        )
+      )
+    );
+  };
+  const wholeOf = (v) => isExprMarker(v) ? v : void 0;
+  const emitInits = () => {
+    for (const [key, decl] of Object.entries(def.state ?? {})) {
+      if (decl.init === void 0) continue;
+      const at = ["state", key, "init"];
+      if (!hasIsland(decl.init) && failed.has(addressOf(at))) continue;
+      const expr = lowerAt(decl.init, at);
+      const type = opts.stateTypeOf?.(key);
+      const id = b.identifier(`__i${ini++}`);
+      initBody.push(
+        b.variableDeclaration("const", [
+          b.variableDeclarator(
+            type ? annotate(id, type) : id,
+            expr
+          )
+        ])
+      );
+    }
+  };
+  const emitActions = () => {
+    const setType = opts.setType;
+    if (!setType) return;
+    for (const [name, action] of Object.entries(def.updates ?? {})) {
+      const set = action.set;
+      if (set === void 0) continue;
+      const frame = ["updates", name];
+      const decl = b.variableDeclaration("const", [
+        b.variableDeclarator(
+          annotate(b.identifier(`__s${act++}`), setType),
+          lowerAt(set, [...frame, "set"])
+        )
+      ]);
+      const param = annotate(
+        b.identifier("params"),
+        paramsOf(name) ?? s$1.unknown
+      );
+      anchors.stamp(param, frame);
+      const block = b.blockStatement([decl]);
+      frames.set(addressOf(frame), block);
+      push(
+        stmt(
+          b.arrowFunctionExpression(
+            [param],
+            block
+          )
+        )
+      );
+    }
+  };
+  const emitEffects = () => {
+    for (const [name, effect] of Object.entries(def.effects ?? {})) {
+      const at = ["effects", name];
+      effect.on.forEach((observed, i) => {
+        const e = fromPath(observed, [...at, "on", i]);
+        if (e) push(stmt(e));
+      });
+      emitIntent(effect, at, [EMPTY_MOUNT], s$1.undefined);
+      if (effect.cleanup)
+        emitIntent(
+          effect.cleanup,
+          [...at, "cleanup"],
+          [EMPTY_MOUNT],
+          s$1.undefined
+        );
+    }
+  };
+  const walk = (node, path) => {
+    const base = path;
+    const data = wholeOf(node.each);
+    const binding = typeof node.as === "string" ? node.as : void 0;
+    const inner = [];
+    const outer = body.length;
+    const pending = pendingFrames.length;
+    pendingFrames.push(addressOf(base));
+    const callee = node.el == null && typeof node.type === "string" ? propsOf(node.type) : void 0;
+    for (const [field, role] of Object.entries(FIELDS)) {
+      if (role !== "slot" || field === "each") continue;
+      if (field === "props" && callee) continue;
+      if (field === "provides") continue;
+      const value = node[field];
+      if (value === void 0) continue;
+      const decl = slotOf(field);
+      if (field === "commands") {
+        for (const [name, alias] of Object.entries(
+          value
+        )) {
+          if (typeof alias === "string") continue;
+          const at = [...base, "commands", name, "params"];
+          const declared = paramsOf(alias.action);
+          if (!declared || !isRecord(alias.params)) {
+            emitValue(alias.params, at);
+            continue;
+          }
+          if (!exhaustiveParams(alias.action)) weak.add(addressOf(at));
+          push(
+            b.variableDeclaration("const", [
+              b.variableDeclarator(
+                annotate(
+                  b.identifier(`__a${aln++}`),
+                  partialOf(declared)
+                ),
+                lowerAt(alias.params, at)
+              )
+            ])
+          );
+        }
+      } else if (decl?.shape === "intentParams") {
+        const scopes = scopesAt.get(node) ?? [];
+        for (const [name, binding2] of Object.entries(
+          value
+        ))
+          emitIntent(
+            binding2,
+            [...base, field, name],
+            scopes,
+            (node.el == null && node.type !== void 0 ? emitsOf(node.type, name) : void 0) ?? s$1.unknown
+          );
+      } else emitValue(value, [...base, field], decl?.expects);
+    }
+    if (node.provides)
+      for (const [name, value] of Object.entries(node.provides)) {
+        const declared = contextOf(name);
+        const at = [...base, "provides", name];
+        if (!declared) {
+          emitValue(value, at);
+          continue;
+        }
+        const e = lowerAt(value, at);
+        push(
+          b.variableDeclaration("const", [
+            b.variableDeclarator(
+              annotate(b.identifier(`__x${ctxn++}`), declared),
+              e
+            )
+          ])
+        );
+      }
+    if (callee)
+      push(
+        b.variableDeclaration("const", [
+          b.variableDeclarator(
+            annotate(b.identifier(`__c${call++}`), callee),
+            lowerAt(node.props ?? {}, [...base, "props"])
+          )
+        ])
+      );
+    for (const [field, shape] of Object.entries(TREE)) {
+      const value = node[field];
+      if (value === void 0) continue;
+      if (shape === "list" && Array.isArray(value))
+        value.forEach((child, i) => walk(child, [...path, i]));
+      else if (shape === "node" && value && typeof value === "object")
+        walk(value, [...path, field]);
+    }
+    if (!data || !binding) return;
+    inner.push(...body.splice(outer));
+    const coll = lowerAt(data, [...base, "each"]);
+    const param = nameNode(binding, [...base, "as"]);
+    const block = b.blockStatement(inner);
+    for (const address of pendingFrames.splice(pending))
+      frames.set(address, block);
+    const fn = b.arrowFunctionExpression(
+      [param],
+      block
+    );
+    push(
+      stmt(
+        shapeOf(coll) === "list" ? b.callExpression(b.identifier("map"), [
+          fn,
+          coll
+        ]) : b.callExpression(fn, [
+          coll
+        ])
+      )
+    );
+  };
+  walk(root, [0]);
+  emitInits();
+  emitActions();
+  emitEffects();
+  const rootBlock = b.blockStatement(body);
+  for (const address of pendingFrames.splice(0)) frames.set(address, rootBlock);
+  const program = b.arrowFunctionExpression(
+    [],
+    rootBlock
+  );
+  const inits = initBody.length ? b.arrowFunctionExpression(
+    [],
+    b.blockStatement(initBody)
+  ) : void 0;
+  return {
+    program,
+    anchors,
+    texts,
+    frames,
+    islands,
+    compiled,
+    weak,
+    ...inits ? { inits } : {}
+  };
+}
+var checkerProfileOf = (deploy) => ({
+  ...PRESETS.complete,
+  name: `${deploy.name}:types`,
+  ...deploy.types ? { types: deploy.types } : {}
+});
+var isWeak = (address, weak) => {
+  for (const prefix of weak)
+    if (address === prefix || address.startsWith(`${prefix}.`)) return true;
+  return false;
+};
+var exhaustiveHostParams = (port) => {
+  const level = port?.provenanceOf?.("params");
+  return level === "inferred" || level === "verified";
+};
+var issuesOf = (root, diagnostics, lowered, fallback) => anchorDiagnostics(root, diagnostics, lowered.anchors, {
+  fallback,
+  textOf: (path) => lowered.texts.get(addressOf(path))
+}).map(({ diagnostic, anchor, span }) => {
+  const address = addressOf(anchor);
+  const source = lowered.texts.get(address);
+  return {
+    code: String(diagnostic.code ?? "error"),
+    message: String(diagnostic.message ?? ""),
+    severity: diagnostic.severity === "warning" ? "warning" : "error",
+    path: anchor,
+    address,
+    ...source === void 0 ? {} : { source },
+    ...span === void 0 ? {} : { span }
+  };
+});
+function checkComponent(def, env, opts = {}) {
+  return [...analyzeComponent(def, env, opts).issues];
+}
+function analyzeComponent(def, env, opts = {}) {
+  const profile = checkerProfileOf(opts.profile ?? DEFAULT_PROFILE);
+  const lowered = lowerComponent(def, {
+    ...opts.compiled ? { compiled: opts.compiled } : {},
+    shapeOf: (expression) => dataShape(expression, env),
+    ...opts.propsOf ? { propsOf: opts.propsOf } : {},
+    // o `set` de um update local é um call-site sobre o ESTADO: mesmo mecanismo, outra
+    // superfície. O tipo sai das declarações do próprio componente, então não há seam.
+    setType: partialStateType(def.state, opts.types),
+    // a MESMA ordem do runtime: update local primeiro, e o que não resolve aqui sai pela porta.
+    paramsOf: paramsResolver(
+      declaredParamsOf(def.updates, opts.types),
+      hostParamsOf(opts.actions, opts.types)
+    ),
+    // um update local é sempre exaustivo (a declaração É a verdade); a ação do host vale o que
+    // a proveniência disser.
+    exhaustiveParams: (action) => def.updates?.[action] !== void 0 || exhaustiveHostParams(opts.actions),
+    ...opts.emitsOf ? { emitsOf: opts.emitsOf } : {},
+    resultOf: hostResultOf(opts.actions, opts.types),
+    ...opts.mounting ? { mounting: opts.mounting } : {},
+    stateTypeOf: stateTypeOf(def.state, opts.types),
+    contextOf: declaredContextsOf(opts.contexts, opts.types)
+  });
+  const { program, inits, weak, compiled } = lowered;
+  const issues = [
+    ...checkDeclarations(def, opts.types),
+    ...checkContextCatalog(opts.contexts, opts.types)
+  ];
+  if (opts.compiled === void 0)
+    issues.push(
+      ...compiled.diagnostics.map((d) => ({
+        code: d.code,
+        message: d.message,
+        severity: d.severity,
+        path: d.path,
+        address: d.address,
+        ...d.source === void 0 ? {} : { source: d.source },
+        ...d.span === void 0 ? {} : { span: d.span }
+      }))
+    );
+  const initEnv = buildInitEnv(def, {
+    ...opts.types ? { types: opts.types } : {},
+    ...opts.contexts ? {
+      contexts: Object.fromEntries(
+        Object.entries(opts.contexts).map(([name, ref]) => [
+          name,
+          resolveTypeRef(ref, opts.types ?? {})
+        ])
+      )
+    } : {}
+  });
+  const seeded = inits ? check(inits, initEnv, {
+    profile,
+    ...opts.limits ? { limits: opts.limits } : {}
+  }) : void 0;
+  if (inits && seeded)
+    issues.push(
+      ...issuesOf(inits, seeded.diagnostics, lowered, ["state"])
+    );
+  const body = check(program, env, {
+    profile,
+    ...opts.limits ? { limits: opts.limits } : {}
+  });
+  issues.push(...issuesOf(program, body.diagnostics, lowered, [0]));
+  return {
+    issues: issues.map(
+      (issue) => issue.code === "excess-property" && isWeak(issue.address, weak) ? { ...issue, severity: "warning" } : issue
+    ),
+    lowered,
+    body,
+    initEnv,
+    ...seeded ? { inits: seeded } : {}
+  };
+}
+function checkExpression(source, env, path, opts = {}) {
+  const address = addressOf(path);
+  let ast;
+  try {
+    ast = parseExpression(source);
+  } catch (error) {
+    return [
+      {
+        code: "parse-error",
+        message: String(error?.message ?? error),
+        severity: "error",
+        path,
+        address,
+        source
+      }
+    ];
+  }
+  const { diagnostics } = check(ast, env, {
+    profile: checkerProfileOf(opts.profile ?? DEFAULT_PROFILE),
+    ...opts.resultType ? { resultType: opts.resultType } : {},
+    ...opts.limits ? { limits: opts.limits } : {}
+  });
+  return diagnostics.map((d) => {
+    const span = spanOf(source, d.node?.loc);
+    return {
+      code: String(d.code ?? "error"),
+      message: String(d.message ?? ""),
+      severity: d.severity === "warning" ? "warning" : "error",
+      path,
+      address,
+      source,
+      ...span === void 0 ? {} : { span }
+    };
+  });
+}
+function dataShape(expression, env) {
+  try {
+    const t = check(expression, env).type;
+    return t?.t === "array" ? "list" : "value";
+  } catch {
+    return "list";
+  }
+}
+
+export { DEFAULT_ASSERTER, analyzeComponent, buildEnv, buildInitEnv, checkComponent, checkContextCatalog, checkDeclarations, checkExpression, checkTree, checkerProfileOf, componentAssignable, componentType, createTsliteChecker, declaredContextsOf, declaredParamsOf, declaredPropsOf, lowerComponent, partialStateType, resolveProps, resolveTypeRef, stateTypeOf };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map