typeglish 0.1.0

package/dist/compile-DViQS2oG.d.ts

@@ -0,0 +1,310 @@
+import { S as Severity, R as RubricDim, a as SpellChecker, D as Diagnostic } from './diagnostics-BWJ_oMd8.js';
+
+/** Half-open [start, end) char offsets of a node within its source clause. */
+interface Span {
+    start: number;
+    end: number;
+}
+
+type Frame = 'emit' | 'suppress' | 'route' | 'communicate-tell' | 'communicate-ask' | 'confirm' | 'capture' | 'execute' | 'query' | 'greet' | 'start' | 'stop' | 'permit';
+
+interface PredicateIR {
+    /** Canonical head: a canon verb ('transfer'), an antonym-normalized positive pole
+     *  ('emit' for 'withhold', lexicalPolarity −1), or the folded surface verb as fallback. */
+    head: string;
+    /** The verb as written, particle included ('hand off', 'read back'). */
+    surface: string;
+    frame?: Frame;
+    particle?: string;
+    /** Normalized object NP — article-stripped, last word singularized ('the calls' → 'call'). */
+    theme?: string;
+    roles: Partial<Record<'goal' | 'source' | 'instrument' | 'beneficiary', string>>;
+    /** Bound $IMPORT tool key — only via a light verb + manifest/snake_case object. */
+    tool?: string;
+    /** −1 when the surface verb is the negative pole of an antonym pair (withhold = ¬emit). */
+    lexicalPolarity: 1 | -1;
+    confidence: 'lexicon' | 'heuristic';
+}
+
+/** A boolean condition over named atoms (flat AND / OR / NOT — the shape conditions take today). */
+type Cond = {
+    t: 'true';
+} | {
+    t: 'false';
+} | {
+    t: 'atom';
+    key: string;
+    text: string;
+} | {
+    t: 'not';
+    f: Cond;
+} | {
+    t: 'and';
+    fs: Cond[];
+} | {
+    t: 'or';
+    fs: Cond[];
+};
+/** Deontic force of a directive, normalized from its modal. Obligate/prohibit are the hard pair the
+ *  consistency check keys on; the soft forms are defeasible and never hard-conflict. */
+type Deontic = 'obligate' | 'prohibit' | 'permit' | 'recommend' | 'discourage';
+/** A numeric bound parsed from a directive's action — `at most 3 sentences`, `at least 5 words`. The
+ *  SMT theory propositional reasoning can't reach: each bound alone is satisfiable, but two on the
+ *  same quantity may be jointly empty (`≤ 3` ∧ `≥ 5`), which only integer arithmetic decides. */
+type NumericOp = 'le' | 'ge' | 'lt' | 'gt' | 'eq';
+interface NumericConstraint {
+    /** The measured unit, singularized (`sentence`, `word`). Two bounds conflict only on a shared quantity. */
+    quantity: string;
+    op: NumericOp;
+    n: number;
+    text: string;
+}
+interface DirectiveIR {
+    kind: 'directive';
+    deontic: Deontic;
+    /** Normalized subject the directive scopes to; '' is the implicit agent ("you"). */
+    subject: string;
+    /** The action as a normalized atom key plus its original text. */
+    action: {
+        key: string;
+        text: string;
+    };
+    /** A numeric bound parsed from the action (`at most 3 sentences`), or null. */
+    numeric: NumericConstraint | null;
+    /** The parsed predicate (verb + theme + roles + tool binding), or null when the head isn't a
+     *  catalog verb. Lexicon-confidence canon/tool parses also shape `action.key`. */
+    predicate: PredicateIR | null;
+    /** Guard under which the directive applies (TRUE when unconditional). */
+    cond: Cond;
+    line: number;
+    span: Span;
+}
+interface DeclarationIR {
+    kind: 'declaration';
+    name: string;
+    value: string;
+    /** True for a negated copula (`IS NOT`) — a negative fact rather than a binding. */
+    negated: boolean;
+    line: number;
+    span: Span;
+}
+type IRNode = DirectiveIR | DeclarationIR;
+interface IR {
+    nodes: IRNode[];
+}
+
+type ParamType = 'string' | 'number' | 'integer' | 'boolean';
+interface ToolParam {
+    name: string;
+    type: ParamType;
+    /** A `list of <type>s` open array, or — with `enum` set — an `any of a, b` pick-many set. */
+    array?: boolean;
+    required: boolean;
+    description?: string;
+    /** The closed set: `one of a, b` (pick one) or, with `array`, `any of a, b` (pick many). */
+    enum?: string[];
+    /** `default to <value>`. A param with a default is optional by definition. */
+    default?: string | number | boolean;
+}
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+/** How the tool EXECUTES — the declarative HTTP binding. Authored as `request: METHOD https://…` or
+ *  `request: METHOD <service> /path`; either way it is stored RESOLVED (absolute URL, service headers merged
+ *  in), so the runner never needs the service table. `@{param}` pointers interpolate from the model's
+ *  input; `@{env.NAME}` from the runner's environment (secrets never live in the file). A tool WITHOUT a
+ *  binding is still legal — schema-only, executed by the host runtime (the $IMPORT-style case). */
+interface ToolBinding {
+    method: HttpMethod;
+    url: string;
+    headers: {
+        name: string;
+        value: string;
+    }[];
+    /** The $SERVICE this binding resolved through, when it used the `METHOD service /path` form. */
+    service?: string;
+    line: number;
+}
+interface ToolDef {
+    name: string;
+    description: string;
+    params: ToolParam[];
+    binding?: ToolBinding;
+    /** The 0-based line of the block's `$TOOL name` opener. */
+    line: number;
+}
+/** A shared external backend: `base:` + `headers:`, referenced by tool bindings. */
+interface ServiceDef {
+    name: string;
+    base: string;
+    headers: {
+        name: string;
+        value: string;
+    }[];
+    line: number;
+}
+interface ToolConflict {
+    lines: number[];
+    message: string;
+    code: string;
+    severity: Severity;
+}
+/** Parse every $TOOL block (resolving `request: METHOD service /path` through the $SERVICE table) and every
+ *  $SERVICE block. Indentation-scoped and fence-aware, mirroring toolBlockMask exactly, so what parses here is
+ *  precisely what render() strips and what the scopes exclude. Pure. */
+declare function parseTools(rawLines: string[]): {
+    tools: ToolDef[];
+    services: ServiceDef[];
+    conflicts: ToolConflict[];
+};
+/** The tool's parameters as a JSON-Schema object — the `input_schema` (Anthropic) / `parameters` (OpenAI)
+ *  shape, so a compiled agent bundle is directly consumable by a function-calling API. */
+declare function toolInputSchema(tool: ToolDef): {
+    type: 'object';
+    properties: Record<string, Record<string, unknown>>;
+    required: string[];
+};
+
+type Expr = {
+    kind: 'read';
+    name: string;
+} | {
+    kind: 'not';
+    arg: Expr;
+} | {
+    kind: 'and';
+    left: Expr;
+    right: Expr;
+} | {
+    kind: 'or';
+    left: Expr;
+    right: Expr;
+} | {
+    kind: 'is';
+    name: string;
+    value: string;
+    negate: boolean;
+} | {
+    kind: 'oneOf';
+    name: string;
+    values: string[];
+} | {
+    kind: 'cmp';
+    name: string;
+    op: '>' | '>=' | '<' | '<=';
+    n: number;
+};
+type Bag = Record<string, string | number | boolean>;
+interface ExprParse {
+    ast: Expr | null;
+    error: string | null;
+}
+/** Parse a guard/predicate expression. Returns the AST, or a human-readable `error` (never both). Pure. */
+declare function parseExpr(text: string): ExprParse;
+/** Evaluate a guard against the variable bag. Total and deterministic — a missing variable reads as
+ *  falsy/absent, never throws (out-of-domain values simply don't match). Pure. */
+declare function evalExpr(e: Expr, bag: Bag): boolean;
+interface Atom {
+    name: string;
+    test: 'bool' | 'value' | 'numeric';
+    values: string[];
+}
+/** Every leaf atom in the expression, so the checker can verify each input is declared and used at the right
+ *  type (a bare read wants a bool; a value comparison wants an enum member; a `>`/`<` wants a number). Pure. */
+declare function exprAtoms(e: Expr): Atom[];
+
+interface CompileOptions {
+    /** Rubric dimensions — lets the checker flag a constraint that nothing measures. */
+    rubric?: RubricDim[];
+    /** The Instructions body, compiled into the XML after the System body. */
+    instructions?: string;
+    /** An injected dictionary predicate (from the edge — nspell in the browser/CLI). Turns on the unknown-word
+     *  check; when omitted the pure core ships no dictionary and that check is skipped. */
+    isWord?: SpellChecker;
+    /** Extra ADDRESSEE nouns that resolve to `you` (the glish.tgc `$CONFIG addressee` dial, already parsed —
+     *  config-schema.ts parseAddresseeConfig). The declared rules (aliases, roles) need no opt-in. */
+    addressees?: readonly string[];
+    /** The project's `glish.tgc` raw source — the config-schema extension layer. When present, config diagnostics
+     *  resolve the glish-extended schema + cross-field rules; when absent, the built-in schema only. */
+    glishConfig?: string;
+}
+/** Everything a `.tg` file declares BEYOND the prompt — what makes a single file a whole agent. The prompt
+ *  itself is `xml`; this is the rest: the compile-time settings and the inline tool definitions, ready for a
+ *  runner (`toolInputSchema` converts a tool to the Anthropic/OpenAI schema shape). */
+/** The resolved MODEL config: the `$CONFIG model <id>` block's id + numeric params, with `via` resolved to its
+ *  `$SERVICE` transport (base + headers; the runner fills the secret from env, never the file). This is the
+ *  agent's whole model definition — endpoint + params — living in TG, not hardcoded in the harness. */
+interface ResolvedModel {
+    id: string;
+    maxTokens?: number;
+    temperature?: number;
+    service?: {
+        name: string;
+        base: string;
+        headers: {
+            name: string;
+            value: string;
+        }[];
+    };
+}
+interface AgentBundle {
+    /** Compile-time settings from `$CONFIG` — the simple, header-only kinds (modality, language, …). */
+    config: Record<string, string>;
+    /** The resolved model config (id + params + transport) — from `$CONFIG model <id>` + params. */
+    model?: ResolvedModel;
+    /** Inline `$TOOL name` definitions — interface + optional HTTP binding. */
+    tools: ToolDef[];
+}
+interface CompileResult {
+    /** The lowered logical form: directives (with guards / numeric bounds) and declarations. */
+    ir: IR;
+    /** Every problem found, each with a line/column range and an optional quick-fix. */
+    diagnostics: Diagnostic[];
+    /** False when a hard logic error (contradiction / conflicting declaration) is present. */
+    consistent: boolean;
+    /** False when a structural error (missing/duplicate step, dangling reference, undeclared tool) is present.
+     *  Orthogonal to `consistent` — a prompt can be logically consistent yet structurally broken. */
+    wellFormed: boolean;
+    /** The compiled, XML-tagged prompt the agent runs. */
+    xml: string;
+    /** The agent bundle: `$CONFIG` settings + inline tool definitions. With `xml`, everything a runner needs. */
+    agent: AgentBundle;
+}
+/**
+ * Compile TypeGlish source: parse → lower to IR → run every diagnostic → decide consistency → emit XML.
+ * Synchronous and self-contained. The numeric (Z3) tier is layered on by Node callers via checkNumeric +
+ * {@link numericDiagnostics}; the browser routes that one async check through the server.
+ */
+declare function compile(source: string, opts?: CompileOptions): CompileResult;
+/**
+ * Fold numeric (Z3/SMT) conflicts into the diagnostics stream. The numeric tier runs out-of-process — in
+ * Node directly, or through the server for the browser — so its results arrive separately and merge here,
+ * sharing the line-range + cross-reference formatting with every other diagnostic. Kept z3-free on purpose.
+ */
+declare function numericDiagnostics(conflicts: {
+    lines: number[];
+    message: string;
+}[], source: string): Diagnostic[];
+/**
+ * Fold the solver's STRUCTURAL conflicts — predicate-chain exhaustiveness gaps Z3 finds — into the
+ * diagnostics stream. Same out-of-process path as {@link numericDiagnostics}, but carrying `structure/<code>`
+ * and the conflict's own severity, so a solver-found gap reads identically to a sync structural one and folds
+ * into `wellFormed`. Kept z3-free: the solver runs elsewhere; this only shapes its results.
+ */
+declare function structuralDiagnostics(conflicts: {
+    lines: number[];
+    message: string;
+    code: string;
+    severity: Severity;
+}[], source: string): Diagnostic[];
+
+interface PreparedTemplate {
+    readonly source: string;
+    /** Apply the bag → the resolved source (bound switches/guards collapsed; the rest left for render). */
+    resolve(bag: Bag): string;
+    /** Apply the bag AND render → the model-facing prompt. Unbound switches become conditional prose. */
+    render(bag: Bag): string;
+}
+/** Parse the state-independent structure of a template ONCE; the returned object resolves/renders per bag
+ *  without re-parsing. Use this on the hot path where one prompt serves many turns. */
+declare function prepareTemplate(source: string): PreparedTemplate;
+
+export { type AgentBundle as A, type Bag as B, type CompileOptions as C, type Deontic as D, type Expr as E, type HttpMethod as H, type IR as I, type ParamType as P, type ResolvedModel as R, type Span as S, type ToolBinding as T, type CompileResult as a, type IRNode as b, type PreparedTemplate as c, type ToolDef as d, type ToolParam as e, compile as f, evalExpr as g, exprAtoms as h, parseTools as i, prepareTemplate as j, type PredicateIR as k, numericDiagnostics as n, parseExpr as p, structuralDiagnostics as s, toolInputSchema as t };

package/dist/diagnostics-BWJ_oMd8.d.ts

@@ -0,0 +1,49 @@
+interface InlineToken {
+    text: string;
+    cls?: string;
+}
+
+type Severity = 'info' | 'warn' | 'error';
+interface Diagnostic {
+    source: string;
+    severity: Severity;
+    line: number;
+    start: number;
+    end: number;
+    message: string;
+    fix?: {
+        title: string;
+        replacement: string;
+    };
+}
+interface RubricDim {
+    key: string;
+    description: string;
+}
+type SpellChecker = (word: string) => boolean;
+/** Collect static diagnostics. Skips comments, blanks, headings, and fenced code. An injected `isWord`
+ *  dictionary (from the edge) turns on the unknown-word check; without it the pure core ships no dictionary. */
+declare function runDiagnostics(rawLines: string[], _rubric: RubricDim[], opts?: {
+    isWord?: SpellChecker;
+    addressees?: readonly string[];
+    glishConfig?: string;
+}): Diagnostic[];
+/** Apply a quick-fix's text replacement at the diagnostic's range. */
+declare function applyFix(value: string, d: Diagnostic): string;
+interface RenderSpan {
+    text: string;
+    cls?: string;
+}
+/**
+ * Merge a line's markdown tokens with its diagnostic ranges into final overlay spans.
+ * Each output span carries the markdown class of its source token plus a `diag-<sev>`
+ * class where a diagnostic covers it — splitting at every boundary so underlines land on
+ * exactly the offending characters while the text stays byte-for-byte identical.
+ */
+declare function composeSpans(tokens: InlineToken[], diags: {
+    start: number;
+    end: number;
+    severity: Severity;
+}[]): RenderSpan[];
+
+export { type Diagnostic as D, type RubricDim as R, type Severity as S, type SpellChecker as a, applyFix as b, composeSpans as c, runDiagnostics as r };

package/dist/exhaustiveness-VBVWCX5W.js

@@ -0,0 +1,123 @@
+import { buildStructure, parseSwitches, predicateEncodable, parseExpr } from './chunk-YH4ZLQ4G.js';
+import { z3 } from './chunk-VMACILYN.js';
+import './chunk-Y64EAEYB.js';
+import './chunk-PR4QN5HX.js';
+
+// src/core/solver/exhaustiveness.ts
+function constFor(e, name, type) {
+  const existing = e.vars.get(name);
+  if (existing) return existing;
+  let v;
+  if (type.kind === "number") v = e.ctx.Real.const(name);
+  else if (type.kind === "enum") {
+    v = e.ctx.Int.const(name);
+    e.bounds.push(e.ctx.And(v.ge(0), v.lt(type.members.length)));
+  } else v = e.ctx.Bool.const(name);
+  e.vars.set(name, v);
+  return v;
+}
+function encode(e, expr, seen) {
+  switch (expr.kind) {
+    case "not": {
+      const a = encode(e, expr.arg, seen);
+      return a === null ? null : e.ctx.Not(a);
+    }
+    case "and":
+    case "or": {
+      const l = encode(e, expr.left, seen);
+      const r = encode(e, expr.right, seen);
+      if (l === null || r === null) return null;
+      return expr.kind === "and" ? e.ctx.And(l, r) : e.ctx.Or(l, r);
+    }
+    case "read": {
+      if (e.defines.has(expr.name)) {
+        if (seen.has(expr.name)) return null;
+        const ast = parseExpr(e.defines.get(expr.name)?.expr ?? "").ast;
+        return ast === null ? null : encode(e, ast, /* @__PURE__ */ new Set([...seen, expr.name]));
+      }
+      const t = e.types.get(expr.name);
+      return t?.kind === "bool" ? constFor(e, expr.name, t) : null;
+    }
+    case "is": {
+      const t = e.types.get(expr.name);
+      if (t?.kind !== "enum") return null;
+      const idx = t.members.indexOf(expr.value);
+      const eq = idx < 0 ? e.ctx.Bool.val(false) : constFor(e, expr.name, t).eq(idx);
+      return expr.negate ? e.ctx.Not(eq) : eq;
+    }
+    case "oneOf": {
+      const t = e.types.get(expr.name);
+      if (t?.kind !== "enum") return null;
+      const v = constFor(e, expr.name, t);
+      const eqs = expr.values.map((val) => {
+        const i = t.members.indexOf(val);
+        return i < 0 ? e.ctx.Bool.val(false) : v.eq(i);
+      });
+      return eqs.length ? e.ctx.Or(...eqs) : e.ctx.Bool.val(false);
+    }
+    case "cmp": {
+      const t = e.types.get(expr.name);
+      if (t?.kind !== "number") return null;
+      const v = constFor(e, expr.name, t);
+      return expr.op === ">" ? v.gt(expr.n) : expr.op === ">=" ? v.ge(expr.n) : expr.op === "<" ? v.lt(expr.n) : v.le(expr.n);
+    }
+  }
+}
+function counterexample(solver, e) {
+  try {
+    const model = solver.model();
+    const parts = [];
+    for (const [name, v] of e.vars) {
+      const t = e.types.get(name);
+      const raw = model.eval(v, true).toString();
+      if (t?.kind === "enum") parts.push(`@{${name}}=${t.members[Number(raw)] ?? raw}`);
+      else parts.push(`@{${name}}=${raw}`);
+    }
+    return parts.length ? parts.join(", ") : "some combination of inputs";
+  } catch {
+    return "some combination of inputs";
+  }
+}
+async function predicateExhaustiveness(source) {
+  const lines = source.split("\n");
+  const doc = buildStructure(lines);
+  const candidates = parseSwitches(lines).filter(
+    (b) => b.kind === "predicate" && b.error === null && !b.arms.some((a) => a.kind === "else")
+  );
+  if (candidates.length === 0) return [];
+  const encodable = candidates.filter((b) => predicateEncodable(b, doc.inputTypes, doc.defines));
+  if (encodable.length === 0) return [];
+  const ctx = await z3();
+  const out = [];
+  for (const block of encodable) {
+    const e = { ctx, types: doc.inputTypes, defines: doc.defines, vars: /* @__PURE__ */ new Map(), bounds: [] };
+    const encoded = [];
+    let ok = true;
+    for (const arm of block.arms) {
+      if (arm.kind !== "case" || arm.predicate === void 0) continue;
+      const ast = parseExpr(arm.predicate).ast;
+      const enc = ast === null ? null : encode(e, ast, /* @__PURE__ */ new Set());
+      if (enc === null) {
+        ok = false;
+        break;
+      }
+      encoded.push(enc);
+    }
+    if (!ok || encoded.length === 0) continue;
+    const solver = new ctx.Solver();
+    for (const b of e.bounds) solver.add(b);
+    solver.add(ctx.Not(ctx.Or(...encoded)));
+    if (await solver.check() !== "sat") continue;
+    out.push({
+      lines: [block.headerLine],
+      message: `This chain isn't exhaustive \u2014 no arm handles ${counterexample(solver, e)}. Add an arm or an ELSE.`,
+      code: "non-exhaustive-switch",
+      severity: "error"
+    });
+  }
+  return out;
+}
+
+export { predicateExhaustiveness };
+//# sourceMappingURL=exhaustiveness-VBVWCX5W.js.map
+//# sourceMappingURL=exhaustiveness-VBVWCX5W.js.map

package/dist/exhaustiveness-VBVWCX5W.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/solver/exhaustiveness.ts"],"names":[],"mappings":"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","file":"exhaustiveness-VBVWCX5W.js","sourcesContent":["// ── Z3-backed predicate-chain exhaustiveness ────────────────────────────────────────────────────────────\n// A predicate chain (mixed-condition IF / ELSE IF arms) chooses the first true arm over arbitrary boolean conditions. Enumeration can't prove\n// such a set total (the state space is exponential, and numeric ranges are infinite), so the structural checker\n// conservatively requires an ELSE. This tier does better: encode each arm condition as an SMT formula over the\n// declared input domains and ask Z3 whether their disjunction is a TAUTOLOGY — i.e. whether `domains ∧ ¬(C₁ ∨ … ∨\n// Cₙ)` is UNSAT. UNSAT ⇒ provably total ⇒ no ELSE needed. SAT ⇒ the model is an uncovered state (the\n// counterexample we report). Runs server-side (Node/CLI or the /api/logic route), like the numeric tier.\n//\n// Scope (this slice): predicate chains with NO `ELSE`, whose every arm condition is over encodable inputs —\n// bool, enum, or number, plus `$DEFINE` names (inlined to their base expression). A condition touching a string\n// or untyped input isn't encodable, so that switch is left to the structural tier's require-ELSE rule.\n\nimport { type Expr, parseExpr } from '../expr';\nimport { type InputType, type StructConflict, buildStructure, predicateEncodable } from '../structure';\nimport { parseSwitches } from '../switch';\nimport { z3 } from './z3';\n\n// The z3-solver high-level API is heavily generic; this boundary stays `any`-typed, exactly like z3.ts. The\n// safety is in the InputType-driven encoding on the way in and the tests on the way out.\ntype Z3 = any; // eslint-disable-line @typescript-eslint/no-explicit-any\n\ninterface EncCtx {\n  ctx: Z3;\n  types: Map<string, InputType>;\n  defines: Map<string, { expr: string }>;\n  vars: Map<string, Z3>; // one interned const per input actually used\n  bounds: Z3[]; // enum domain constraints (0 ≤ v < |members|), added to the solver\n}\n\n/** The interned Z3 const for an input, created with its domain constraint the first time it's seen. */\nfunction constFor(e: EncCtx, name: string, type: InputType): Z3 {\n  const existing = e.vars.get(name);\n  if (existing) return existing;\n  let v: Z3;\n  if (type.kind === 'number') v = e.ctx.Real.const(name);\n  else if (type.kind === 'enum') {\n    v = e.ctx.Int.const(name); // enum modelled as an index into its members\n    e.bounds.push(e.ctx.And(v.ge(0), v.lt(type.members.length)));\n  } else v = e.ctx.Bool.const(name); // bool (string never reaches here — encode() returns null for it first)\n  e.vars.set(name, v);\n  return v;\n}\n\n/** Encode an expression to a Z3 bool, or `null` if any leaf is unencodable (string / untyped / a type mismatch).\n *  `$DEFINE` reads are inlined to their base expression; `seen` guards the (checker-forbidden) cyclic case. */\nfunction encode(e: EncCtx, expr: Expr, seen: Set<string>): Z3 | null {\n  switch (expr.kind) {\n    case 'not': {\n      const a = encode(e, expr.arg, seen);\n      return a === null ? null : e.ctx.Not(a);\n    }\n    case 'and':\n    case 'or': {\n      const l = encode(e, expr.left, seen);\n      const r = encode(e, expr.right, seen);\n      if (l === null || r === null) return null;\n      return expr.kind === 'and' ? e.ctx.And(l, r) : e.ctx.Or(l, r);\n    }\n    case 'read': {\n      if (e.defines.has(expr.name)) {\n        if (seen.has(expr.name)) return null; // a cycle — the checker flags it; bail rather than loop\n        const ast = parseExpr(e.defines.get(expr.name)?.expr ?? '').ast;\n        return ast === null ? null : encode(e, ast, new Set([...seen, expr.name]));\n      }\n      const t = e.types.get(expr.name);\n      return t?.kind === 'bool' ? constFor(e, expr.name, t) : null; // a bare read needs a bool\n    }\n    case 'is': {\n      const t = e.types.get(expr.name);\n      if (t?.kind !== 'enum') return null; // `is <value>` needs an enum\n      const idx = t.members.indexOf(expr.value);\n      const eq = idx < 0 ? e.ctx.Bool.val(false) : constFor(e, expr.name, t).eq(idx); // impossible value never matches\n      return expr.negate ? e.ctx.Not(eq) : eq;\n    }\n    case 'oneOf': {\n      const t = e.types.get(expr.name);\n      if (t?.kind !== 'enum') return null;\n      const v = constFor(e, expr.name, t);\n      const eqs = expr.values.map((val) => {\n        const i = t.members.indexOf(val);\n        return i < 0 ? e.ctx.Bool.val(false) : v.eq(i);\n      });\n      return eqs.length ? e.ctx.Or(...eqs) : e.ctx.Bool.val(false);\n    }\n    case 'cmp': {\n      const t = e.types.get(expr.name);\n      if (t?.kind !== 'number') return null; // `>`/`<` needs a number\n      const v = constFor(e, expr.name, t);\n      return expr.op === '>' ? v.gt(expr.n) : expr.op === '>=' ? v.ge(expr.n) : expr.op === '<' ? v.lt(expr.n) : v.le(expr.n);\n    }\n  }\n}\n\n/** Read the SAT model back into a readable uncovered state (`$tier=free, $flagged=false`), best-effort. */\nfunction counterexample(solver: Z3, e: EncCtx): string {\n  try {\n    const model = solver.model();\n    const parts: string[] = [];\n    for (const [name, v] of e.vars) {\n      const t = e.types.get(name);\n      const raw = model.eval(v, true).toString();\n      if (t?.kind === 'enum') parts.push(`@{${name}}=${t.members[Number(raw)] ?? raw}`);\n      else parts.push(`@{${name}}=${raw}`);\n    }\n    return parts.length ? parts.join(', ') : 'some combination of inputs';\n  } catch {\n    return 'some combination of inputs';\n  }\n}\n\n/** Every predicate chain (no ELSE, all conditions encodable) that Z3 can't prove total, as a\n *  `structure/non-exhaustive-switch` conflict naming an uncovered state. A switch it CAN prove total yields\n *  nothing (the mandatory-ELSE requirement is lifted); an unencodable one is skipped (left to the sync tier). */\nexport async function predicateExhaustiveness(source: string): Promise<StructConflict[]> {\n  const lines = source.split('\\n');\n  const doc = buildStructure(lines);\n  const candidates = parseSwitches(lines).filter(\n    (b) => b.kind === 'predicate' && b.error === null && !b.arms.some((a) => a.kind === 'else'),\n  );\n  if (candidates.length === 0) return [];\n\n  const encodable = candidates.filter((b) => predicateEncodable(b, doc.inputTypes, doc.defines)); // the sync tier's exact deferral set\n  if (encodable.length === 0) return [];\n\n  const ctx = await z3();\n  const out: StructConflict[] = [];\n  for (const block of encodable) {\n    const e: EncCtx = { ctx, types: doc.inputTypes, defines: doc.defines, vars: new Map(), bounds: [] };\n    const encoded: Z3[] = [];\n    let ok = true; // predicateEncodable already vetted this block; the null-branch is a defensive backstop\n    for (const arm of block.arms) {\n      if (arm.kind !== 'case' || arm.predicate === undefined) continue;\n      const ast = parseExpr(arm.predicate).ast;\n      const enc = ast === null ? null : encode(e, ast, new Set());\n      if (enc === null) {\n        ok = false;\n        break;\n      }\n      encoded.push(enc);\n    }\n    if (!ok || encoded.length === 0) continue;\n\n    const solver = new ctx.Solver();\n    for (const b of e.bounds) solver.add(b);\n    solver.add(ctx.Not(ctx.Or(...encoded))); // a state no arm covers\n    if ((await solver.check()) !== 'sat') continue; // UNSAT ⇒ the CASEs are total ⇒ no ELSE needed\n\n    out.push({\n      lines: [block.headerLine],\n      message: `This chain isn't exhaustive — no arm handles ${counterexample(solver, e)}. Add an arm or an ELSE.`,\n      code: 'non-exhaustive-switch',\n      severity: 'error',\n    });\n  }\n  return out;\n}\n"]}