@skillstech/thunderlang 0.1.6 → 0.2.0

package/src/property.mjs

@@ -0,0 +1,108 @@
+// Property-based testing for ThunderLang decisions. Deterministic and seeded: for each
+// `property`, generate many input cases that satisfy the `forAll` constraints, evaluate the
+// named decision, and assert the `expect` clauses hold for every case. On failure, binary-shrink
+// each numeric input toward its lower bound to report the smallest reproducible failure.
+import { evaluateDecision } from './runtime.mjs';
+import { compileExpr } from './expr.mjs';
+
+const DEFAULT_MIN = 0, DEFAULT_MAX = 1000;
+
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = (a + 0x6d2b79f5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+// Derive an integer [min, max] for a variable from its `where` clause (>=, >, <=, <, ==).
+function boundsFor(where, varName) {
+  let min = DEFAULT_MIN, max = DEFAULT_MAX;
+  if (!where) return { min, max };
+  const re = new RegExp(`\\b${varName}\\s*(>=|<=|>|<|==)\\s*(-?\\d+)`, 'g');
+  let m;
+  while ((m = re.exec(where))) {
+    const n = parseInt(m[2], 10);
+    if (m[1] === '>=') min = Math.max(min, n);
+    else if (m[1] === '>') min = Math.max(min, n + 1);
+    else if (m[1] === '<=') max = Math.min(max, n);
+    else if (m[1] === '<') max = Math.min(max, n - 1);
+    else if (m[1] === '==') { min = n; max = n; }
+  }
+  const unsat = min > max; // e.g. `where x >= 100 and x <= 0` , no integer satisfies it
+  if (unsat) max = min;
+  return { min, max, unsat };
+}
+
+const isBool = (t) => /bool/i.test(t || '');
+
+function satisfies(v, val) {
+  if (!v.where) return true;
+  try { return !!compileExpr(v.where)({ [v.name]: val }); } catch { return true; }
+}
+
+function genValue(v, rnd) {
+  if (isBool(v.type)) return rnd() < 0.5;
+  const { min, max } = boundsFor(v.where, v.name);
+  return Math.floor(min + rnd() * (max - min + 1));
+}
+
+// Evaluate the property's expect clauses against a decision run. Returns the first violation.
+function checkExpects(prop, run) {
+  for (const e of prop.expects) {
+    const m = e.match(/^(\w+)\s*(==|!=)\s*(.+?)\s*$/);
+    if (!m) continue;
+    const field = m[1] === 'matchedRule' || m[1] === 'rule' ? 'matched' : 'result';
+    const lhs = field === 'matched' ? run.matched : run.result;
+    const eq = String(lhs) === m[3];
+    if (m[2] === '==' ? !eq : eq) return { ok: false, expect: e, actual: lhs };
+  }
+  return { ok: true };
+}
+
+// Given the other inputs fixed, find the smallest value of `v` that still fails the property.
+function shrinkVar(prop, dec, inputs, v) {
+  if (isBool(v.type) || typeof inputs[v.name] !== 'number') return inputs[v.name];
+  const { min } = boundsFor(v.where, v.name);
+  const fails = (val) => satisfies(v, val) && !checkExpects(prop, evaluateDecision(dec, { ...inputs, [v.name]: val })).ok;
+  if (fails(min)) return min;
+  let lo = min, hi = inputs[v.name];
+  while (hi - lo > 1) { const mid = Math.floor((lo + hi) / 2); if (fails(mid)) hi = mid; else lo = mid; }
+  return hi;
+}
+
+function shrink(prop, dec, failing) {
+  const inputs = { ...failing.inputs };
+  for (const v of prop.vars) inputs[v.name] = shrinkVar(prop, dec, inputs, v);
+  const run = evaluateDecision(dec, inputs);
+  const chk = checkExpects(prop, run);
+  return { inputs, expect: chk.expect || failing.expect, actual: chk.actual };
+}
+
+export function runProperties(ast, { cases = 100, seed = 424242 } = {}) {
+  const decisions = new Map((ast.decisions || []).map((d) => [d.name, d]));
+  const results = [];
+  for (const prop of ast.properties || []) {
+    const dec = decisions.get(prop.decide);
+    if (!dec) { results.push({ property: prop.name, ok: false, cases: 0, seed, error: prop.decide ? `no decision named "${prop.decide}"` : 'property has no `decide <Decision>`' }); continue; }
+    const badVar = prop.vars.find((v) => !isBool(v.type) && boundsFor(v.where, v.name).unsat);
+    if (badVar) { results.push({ property: prop.name, ok: false, cases: 0, seed, error: `unsatisfiable constraint for "${badVar.name}": ${badVar.where}` }); continue; }
+    const rnd = mulberry32(seed);
+    let failure = null;
+    for (let i = 0; i < cases && !failure; i++) {
+      const inputs = {};
+      for (const v of prop.vars) {
+        let val, tries = 0;
+        do { val = genValue(v, rnd); tries++; } while (!satisfies(v, val) && tries < 50);
+        inputs[v.name] = val;
+      }
+      const chk = checkExpects(prop, evaluateDecision(dec, inputs));
+      if (!chk.ok) failure = { inputs, expect: chk.expect, actual: chk.actual };
+    }
+    if (failure) failure = shrink(prop, dec, failure);
+    results.push({ property: prop.name, ok: !failure, cases, seed, failure });
+  }
+  return { schema: 'thunder-properties-v1', total: results.length, passed: results.filter((r) => r.ok).length, results };
+}

package/src/report.mjs

@@ -1,4 +1,4 @@
-// Repo-wide intent health report (intent-report-v1). `intent check` gates a build pass/fail;
+// Repo-wide intent health report (intent-report-v1). `thunder check` gates a build pass/fail;
 // this AGGREGATES across every .intent file into a triage view a team adopting ThunderLang can
 // act on: how many missions, diagnostics by severity + area, the most common codes, and
 // coverage signals (are guarantees verified? do missions have tests? are outcomes contracted?).

package/src/sarif.mjs

@@ -1,4 +1,4 @@
-// SARIF 2.1.0 output for `intent check` , so ThunderLang diagnostics show up natively in the
+// SARIF 2.1.0 output for `thunder check` , so ThunderLang diagnostics show up natively in the
 // surfaces teams already use: GitHub / GitLab code scanning (inline PR annotations + the
 // Security tab) and any SARIF-aware IDE. Pure: reports in, one SARIF log object out.
 //

package/src/scan-queries.mjs

@@ -1,5 +1,5 @@
 // Scanner query views (intent-scan-view-v1) , the deterministic answers behind the Part 3
-// CLI verbs: `intent risks | gaps | unverified | coverage | unknowns | contradictions`.
+// CLI verbs: `thunder risks | gaps | unverified | coverage | unknowns | contradictions`.
 // These are pure derivations over a scanProject() result (its Intent IR + Fable findings) ,
 // no new analysis, no AI. They exist so a person can ask one focused question ("what is
 // unverified?", "what contradicts?") instead of reading the whole scan report.

package/src/style.mjs

@@ -85,7 +85,7 @@ function setPath(root, path, leaf) {
 /**
  * Deterministic diagnostics for every `style_intent` block. Returns an array of
  * { ruleId, severity, blocks, message, styleIntent, line } , the same shape the rest of
- * the compiler emits, so it composes into `intent check` with no special-casing.
+ * the compiler emits, so it composes into `thunder check` with no special-casing.
  */
 export function styleDiagnostics(ast) {
   const out = [];
@@ -199,7 +199,7 @@ export function toDesignTokens(ast) {
     });
     for (const t of si.tokens) {
       const leaf = { $value: coerceValue(t.value), $type: tokenType(t.path) };
-      if (!isKnownPath(t.path)) leaf.$extensions = { 'dev.thunderlang': { canonical: false } };
+      if (!isKnownPath(t.path)) leaf.$extensions = { 'dev.intentlanguage': { canonical: false } };
       setPath(root, t.path, leaf);
     }
   }
@@ -207,7 +207,7 @@ export function toDesignTokens(ast) {
     $description: `Design tokens for ${ast.title || ast.mission || 'intent'} (generated from style_intent by @skillstech/thunderlang)`,
     ...root,
     $extensions: {
-      'dev.thunderlang': {
+      'dev.intentlanguage': {
         schema: DESIGN_TOKENS_SCHEMA,
         format: 'W3C Design Tokens (DTCG)',
         source: ast.mission || null,

package/src/target-cs.mjs

@@ -0,0 +1,98 @@
+// C# target adapter. Emits a self-contained Program.cs that defines each decision as a typed
+// static method (using the same exprToCSharp translator the codegen uses), calls every test case
+// with typed literal arguments, and prints the results as one JSON line. It runs through a
+// throwaway `dotnet` console project (scaffold + `dotnet run`), so a live C# run grades real
+// compiled + executed code. Returns null (skip cleanly) when no usable .NET SDK exists.
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { exprToCSharp } from './expr.mjs';
+import { inputNames, inferInputTypes, buildCases, parseLastJsonObject, cachedSmoke, strLit, litFor } from './target-util.mjs';
+
+const CS_TYPE = { number: 'double', bool: 'bool', string: 'string' };
+
+// Scaffold a bare console project in `dir`, overwrite Program.cs with `source`, and run it.
+// Returns stdout, or null on any failure. A bare console app has no external packages, so the
+// implicit restore is offline.
+function dotnetRun(dir, source) {
+  const proj = join(dir, 'app');
+  const env = { ...process.env, DOTNET_CLI_TELEMETRY_OPTOUT: '1', DOTNET_NOLOGO: '1', DOTNET_SKIP_FIRST_TIME_EXPERIENCE: '1' };
+  const mk = spawnSync('dotnet', ['new', 'console', '-o', proj], { encoding: 'utf8', timeout: 120000, env });
+  if (mk.status !== 0) return null;
+  writeFileSync(join(proj, 'Program.cs'), source);
+  const run = spawnSync('dotnet', ['run', '--project', proj, '-c', 'Release'], { encoding: 'utf8', timeout: 240000, env });
+  if (run.status !== 0) return null;
+  return run.stdout;
+}
+
+// The emitted C# source (also usable for display / `gen`-parity).
+export function emitCSharpModule(ast, cases = buildCases(ast)) {
+  const L = [
+    'using System;',
+    'using System.Collections.Generic;',
+    'using System.Linq;',
+    'using System.Text;',
+    'class ThunderTarget {',
+  ];
+  const typesByDec = {};
+  for (const d of ast.decisions || []) {
+    const names = inputNames(d);
+    const types = inferInputTypes(ast, d);
+    typesByDec[d.name] = types;
+    const params = names.map((n) => `${CS_TYPE[types[n]] || 'string'} ${n}`).join(', ');
+    L.push(`  static string ${d.name}(${params}) {`);
+    for (const r of d.rules || []) {
+      let cond; try { cond = exprToCSharp(r.when, { inputs: names }); } catch { cond = 'false'; }
+      L.push(`    if (${cond}) return ${strLit(r.result)};`);
+    }
+    L.push(`    return ${d.default == null ? 'null' : strLit(d.default)};`, '  }');
+  }
+  L.push('  static string J(string s) {');
+  L.push('    if (s == null) return "null";');
+  L.push('    var b = new StringBuilder("\\"");');
+  L.push('    foreach (char c in s) {');
+  L.push('      if (c == \'\\\\\' || c == \'"\') b.Append(\'\\\\\').Append(c);');
+  L.push('      else if (c == \'\\n\') b.Append("\\\\n"); else b.Append(c); }');
+  L.push('    return b.Append(\'"\').ToString(); }');
+  L.push('  static void Main() {');
+  L.push('    var outp = new List<KeyValuePair<string,string>>();');
+  for (const c of cases) {
+    const dec = (ast.decisions || []).find((d) => d.name === c.fn);
+    if (!dec) continue;
+    const types = typesByDec[c.fn];
+    const argList = inputNames(dec).map((n) => litFor(types[n], c.given[n])).join(', ');
+    L.push(`    outp.Add(new KeyValuePair<string,string>(${strLit(c.key)}, ${c.fn}(${argList})));`);
+  }
+  L.push('    var sb = new StringBuilder("{"); bool first = true;');
+  L.push('    foreach (var e in outp) {');
+  L.push('      if (!first) sb.Append(","); first = false;');
+  L.push('      sb.Append(J(e.Key)).Append(":").Append(J(e.Value)); }');
+  L.push('    Console.WriteLine(sb.Append("}").ToString());');
+  L.push('  }');
+  L.push('}');
+  return L.join('\n');
+}
+
+export function csharpAvailable() {
+  return cachedSmoke('csharp', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'tl-cs-smoke-'));
+    try {
+      const src = 'using System; class ThunderTarget { static void Main(){ Console.WriteLine("{\\"ok\\":\\"1\\"}"); } }';
+      const out = dotnetRun(dir, src);
+      return !!out && /"ok"/.test(out);
+    } finally { try { rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ } }
+  });
+}
+
+// Run every decision test case through generated, compiled C#. Returns { "Test / case": actual }
+// or null when no usable .NET SDK is present.
+export function runCSharpTarget(ast) {
+  if (!csharpAvailable()) return null;
+  const cases = buildCases(ast);
+  const dir = mkdtempSync(join(tmpdir(), 'tl-cs-'));
+  try {
+    const out = dotnetRun(dir, emitCSharpModule(ast, cases));
+    return out == null ? null : parseLastJsonObject(out);
+  } finally { try { rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ } }
+}

package/src/target-java.mjs

@@ -0,0 +1,87 @@
+// Java target adapter. Emits a self-contained ThunderTarget.java that defines each decision as a
+// typed static method (using the same exprToJava translator the codegen uses), calls every test
+// case with typed literal arguments, and prints the results as one JSON line. It runs through the
+// JDK 11+ single-file source launcher (`java ThunderTarget.java`) , no separate javac step , so a
+// live Java run grades real executed code. Returns null (skip cleanly) when no usable JDK exists.
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { exprToJava } from './expr.mjs';
+import { inputNames, inferInputTypes, buildCases, parseLastJsonObject, cachedSmoke, strLit, litFor } from './target-util.mjs';
+
+const JAVA_TYPE = { number: 'double', bool: 'boolean', string: 'String' };
+
+// The emitted Java source (also usable for display / `gen`-parity).
+export function emitJavaModule(ast, cases = buildCases(ast)) {
+  const L = [
+    'import java.util.LinkedHashMap;',
+    'import java.util.Map;',
+    '',
+    'public class ThunderTarget {',
+  ];
+  const typesByDec = {};
+  for (const d of ast.decisions || []) {
+    const names = inputNames(d);
+    const types = inferInputTypes(ast, d);
+    typesByDec[d.name] = types;
+    const params = names.map((n) => `${JAVA_TYPE[types[n]] || 'String'} ${n}`).join(', ');
+    L.push(`  static String ${d.name}(${params}) {`);
+    for (const r of d.rules || []) {
+      let cond; try { cond = exprToJava(r.when, { inputs: names }); } catch { cond = 'false'; }
+      L.push(`    if (${cond}) return ${strLit(r.result)};`);
+    }
+    L.push(`    return ${d.default == null ? 'null' : strLit(d.default)};`, '  }');
+  }
+  L.push('  static String j(String s) {');
+  L.push('    if (s == null) return "null";');
+  L.push('    StringBuilder b = new StringBuilder("\\"");');
+  L.push('    for (int i = 0; i < s.length(); i++) { char c = s.charAt(i);');
+  L.push('      if (c == \'\\\\\' || c == \'"\') b.append(\'\\\\\').append(c);');
+  L.push('      else if (c == \'\\n\') b.append("\\\\n"); else b.append(c); }');
+  L.push('    return b.append(\'"\').toString(); }');
+  L.push('  public static void main(String[] args) {');
+  L.push('    Map<String,String> out = new LinkedHashMap<>();');
+  for (const c of cases) {
+    const dec = (ast.decisions || []).find((d) => d.name === c.fn);
+    if (!dec) continue;
+    const types = typesByDec[c.fn];
+    const argList = inputNames(dec).map((n) => litFor(types[n], c.given[n])).join(', ');
+    L.push(`    out.put(${strLit(c.key)}, ${c.fn}(${argList}));`);
+  }
+  L.push('    StringBuilder sb = new StringBuilder("{"); boolean first = true;');
+  L.push('    for (Map.Entry<String,String> e : out.entrySet()) {');
+  L.push('      if (!first) sb.append(","); first = false;');
+  L.push('      sb.append(j(e.getKey())).append(":").append(j(e.getValue())); }');
+  L.push('    System.out.println(sb.append("}").toString());');
+  L.push('  }');
+  L.push('}');
+  return L.join('\n');
+}
+
+export function javaAvailable() {
+  return cachedSmoke('java', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'tl-java-smoke-'));
+    try {
+      const f = join(dir, 'Hi.java');
+      writeFileSync(f, 'public class Hi { public static void main(String[] a){ System.out.println("{\\"ok\\":\\"1\\"}"); } }');
+      const r = spawnSync('java', [f], { encoding: 'utf8', timeout: 60000 });
+      return r.status === 0 && /"ok"/.test(r.stdout || '');
+    } finally { try { rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ } }
+  });
+}
+
+// Run every decision test case through generated, compiled Java. Returns { "Test / case": actual }
+// or null when no usable JDK is present.
+export function runJavaTarget(ast) {
+  if (!javaAvailable()) return null;
+  const cases = buildCases(ast);
+  const dir = mkdtempSync(join(tmpdir(), 'tl-java-'));
+  try {
+    const f = join(dir, 'ThunderTarget.java');
+    writeFileSync(f, emitJavaModule(ast, cases));
+    const r = spawnSync('java', [f], { encoding: 'utf8', timeout: 120000 });
+    if (r.status !== 0) return null;
+    return parseLastJsonObject(r.stdout);
+  } finally { try { rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ } }
+}

package/src/target-py.mjs

@@ -0,0 +1,90 @@
+// Python target adapter. Compiles each decision into an executable Python function using the
+// SAME expression translator the codegen uses (exprToPython), then runs the test cases through a
+// real `python3` child process and returns actual outputs. Like the TypeScript adapter, this makes
+// conformance "grade a live target" rather than "grade fed results" — the generated Python is
+// executed for real. Returns null (not a partial result) when python3 is unavailable, so callers
+// can report the target as skipped rather than failing.
+import { spawnSync } from 'node:child_process';
+import { exprToPython } from './expr.mjs';
+
+const inputNames = (dec) => (dec.inputs || []).map((i) => String(i).split(':')[0].trim()).filter(Boolean);
+
+function coerceVal(v) {
+  if (v == null || typeof v !== 'string') return v;
+  const s = v.trim();
+  if (/^-?\d+(\.\d+)?$/.test(s)) return Number(s);
+  if (s === 'true') return true;
+  if (s === 'false') return false;
+  return v;
+}
+
+// True when a runnable python3 interpreter is present on this machine.
+export function pythonAvailable() {
+  try {
+    const r = spawnSync('python3', ['--version'], { encoding: 'utf8', timeout: 10000 });
+    return r.status === 0;
+  } catch {
+    return false;
+  }
+}
+
+// The emitted Python source (for display / gen-parity).
+export function emitPythonModule(ast) {
+  const L = ['# Executable Python target compiled from the decision(s). Deterministic, no AI.'];
+  for (const d of ast.decisions || []) {
+    L.push(`def ${d.name}(${inputNames(d).join(', ')}):`);
+    for (const r of d.rules || []) {
+      let cond; try { cond = exprToPython(r.when, { inputs: inputNames(d) }); } catch { cond = 'False'; }
+      L.push(`    if ${cond}: return ${JSON.stringify(r.result)}`);
+    }
+    L.push(`    return ${d.default == null ? 'None' : JSON.stringify(d.default)}`);
+    L.push('');
+  }
+  return L.join('\n');
+}
+
+// Run every decision test case through generated Python. Returns { "Test / case": actual },
+// or null if python3 is unavailable or the interpreter failed to run the program.
+export function runPythonTarget(ast) {
+  if (!pythonAvailable()) return null;
+
+  // Build the list of calls to make, one per test case, in a stable order.
+  const cases = [];
+  for (const t of ast.tests || []) {
+    const dec = (ast.decisions || []).find((d) => d.name === t.name);
+    if (!dec) continue;
+    const names = inputNames(dec);
+    for (const c of t.cases || []) {
+      cases.push({
+        key: `${t.name} / ${c.name || 'case'}`,
+        fn: t.name,
+        args: names.map((n) => coerceVal((c.given || {})[n])),
+      });
+    }
+  }
+
+  // Emit a self-contained program: decision defs + a driver that runs each case and prints JSON.
+  // Cases (with already-coerced arg types) are handed in as a JSON literal parsed by json.loads,
+  // so Python receives real ints/floats/bools/strings rather than stringified values.
+  const program = [
+    'import json',
+    emitPythonModule(ast),
+    `CASES = json.loads(${JSON.stringify(JSON.stringify(cases))})`,
+    'out = {}',
+    'for c in CASES:',
+    '    fn = globals().get(c["fn"])',
+    '    try:',
+    '        out[c["key"]] = fn(*c["args"]) if callable(fn) else None',
+    '    except Exception:',
+    '        out[c["key"]] = None',
+    'print(json.dumps(out))',
+  ].join('\n');
+
+  const res = spawnSync('python3', ['-'], { input: program, encoding: 'utf8', timeout: 30000 });
+  if (res.status !== 0 || !res.stdout) return null;
+  try {
+    return JSON.parse(res.stdout.trim().split('\n').pop());
+  } catch {
+    return null;
+  }
+}

package/src/target-ts.mjs

@@ -0,0 +1,66 @@
+// TypeScript/JS target adapter. Compiles each decision into an executable function using the
+// SAME expression translator the TypeScript codegen uses (exprToJs), then runs the test cases
+// through the generated code and returns actual outputs. This turns conformance from "grade fed
+// results" into "grade a live target": the generated implementation is executed for real.
+// Type annotations are erased at runtime, so running the type-stripped JS is faithful to the TS.
+import { exprToJs } from './expr.mjs';
+
+const inputNames = (dec) => (dec.inputs || []).map((i) => String(i).split(':')[0].trim()).filter(Boolean);
+
+function coerceVal(v) {
+  if (v == null || typeof v !== 'string') return v;
+  const s = v.trim();
+  if (/^-?\d+(\.\d+)?$/.test(s)) return Number(s);
+  if (s === 'true') return true;
+  if (s === 'false') return false;
+  return v;
+}
+
+// The emitted source (for display / `gen`-parity); the runtime uses new Function on the body.
+export function emitDecisionModule(ast) {
+  const L = ['// Executable target compiled from the decision(s). Deterministic, no AI.'];
+  for (const d of ast.decisions || []) {
+    L.push(`export function ${d.name}(${inputNames(d).join(', ')}) {`);
+    for (const r of d.rules || []) {
+      let cond; try { cond = exprToJs(r.when, { inputs: inputNames(d) }); } catch { cond = 'false'; }
+      L.push(`  if (${cond}) return ${JSON.stringify(r.result)};`);
+    }
+    L.push(`  return ${JSON.stringify(d.default ?? null)};`, '}');
+  }
+  return L.join('\n');
+}
+
+// Compile each decision to a runnable function.
+function compileDecisionFns(ast) {
+  const fns = {};
+  for (const d of ast.decisions || []) {
+    const names = inputNames(d);
+    const body = [];
+    for (const r of d.rules || []) {
+      let cond; try { cond = exprToJs(r.when, { inputs: names }); } catch { cond = 'false'; }
+      body.push(`if (${cond}) return ${JSON.stringify(r.result)};`);
+    }
+    body.push(`return ${JSON.stringify(d.default ?? null)};`);
+    try { fns[d.name] = new Function(...names, body.join('\n')); } catch { fns[d.name] = null; }
+  }
+  return fns;
+}
+
+// Run every decision test case through the generated code. Returns { "Test / case": actual }.
+export function runTypescriptTarget(ast) {
+  const fns = compileDecisionFns(ast);
+  const out = {};
+  for (const t of ast.tests || []) {
+    const dec = (ast.decisions || []).find((d) => d.name === t.name);
+    if (!dec) continue;
+    const names = inputNames(dec);
+    const fn = fns[t.name];
+    for (const c of t.cases || []) {
+      const key = `${t.name} / ${c.name || 'case'}`;
+      if (typeof fn !== 'function') { out[key] = null; continue; }
+      const args = names.map((n) => coerceVal((c.given || {})[n]));
+      try { out[key] = fn(...args); } catch { out[key] = null; }
+    }
+  }
+  return out;
+}

package/src/target-util.mjs

@@ -0,0 +1,95 @@
+// Shared helpers for the compiled target adapters (Python/C#/Java). The statically typed targets
+// (C#, Java) need a declared type for every decision parameter, which ThunderLang source leaves
+// implicit, so we infer each input's type from the test-case values that will actually be passed.
+import { spawnSync } from 'node:child_process';
+
+export const inputNames = (dec) => (dec.inputs || []).map((i) => String(i).split(':')[0].trim()).filter(Boolean);
+
+export function coerceVal(v) {
+  if (v == null || typeof v !== 'string') return v;
+  const s = v.trim();
+  if (/^-?\d+(\.\d+)?$/.test(s)) return Number(s);
+  if (s === 'true') return true;
+  if (s === 'false') return false;
+  return v;
+}
+
+// Every case-call we will emit, in a stable order: { key, fn, given: {name: coercedValue} }.
+export function buildCases(ast) {
+  const cases = [];
+  for (const t of ast.tests || []) {
+    const dec = (ast.decisions || []).find((d) => d.name === t.name);
+    if (!dec) continue;
+    const names = inputNames(dec);
+    for (const c of t.cases || []) {
+      const given = {};
+      for (const n of names) given[n] = coerceVal((c.given || {})[n]);
+      cases.push({ key: `${t.name} / ${c.name || 'case'}`, fn: t.name, given });
+    }
+  }
+  return cases;
+}
+
+// Infer one type per input for a decision, scanning every case that targets it. Numeric usage
+// wins (a relational comparison must compile), then boolean, else string. Falls back to 'string'.
+export function inferInputTypes(ast, dec) {
+  const names = inputNames(dec);
+  const types = {};
+  for (const n of names) {
+    let t = 'string';
+    for (const test of (ast.tests || []).filter((x) => x.name === dec.name)) {
+      for (const c of test.cases || []) {
+        const raw = (c.given || {})[n];
+        if (raw == null) continue;
+        const cv = coerceVal(raw);
+        if (typeof cv === 'number') { t = 'number'; break; }
+        if (typeof cv === 'boolean' && t !== 'number') t = 'bool';
+      }
+      if (t === 'number') break;
+    }
+    types[n] = t;
+  }
+  return types;
+}
+
+// Pick the last line of stdout that parses as a JSON object , build/tool chatter may precede it.
+export function parseLastJsonObject(stdout) {
+  if (!stdout) return null;
+  const lines = stdout.split('\n').map((l) => l.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (!lines[i].startsWith('{')) continue;
+    try { return JSON.parse(lines[i]); } catch { /* keep scanning upward */ }
+  }
+  return null;
+}
+
+// Cached toolchain-availability smoke tests. Each actually exercises the exact invocation the
+// adapter uses (single-file `java`, or scaffold + `dotnet run`) so a target is only reported
+// runnable when it can genuinely compile and run, not merely because a binary is on PATH.
+const _cache = {};
+export function cachedSmoke(key, fn) {
+  if (key in _cache) return _cache[key];
+  let ok = false;
+  try { ok = !!fn(); } catch { ok = false; }
+  _cache[key] = ok;
+  return ok;
+}
+
+// A source literal for a value at an inferred type. JSON string escaping is valid in Java and C#
+// string literals too, so we reuse JSON.stringify for the string case.
+export const strLit = (s) => JSON.stringify(String(s));
+export function litFor(type, v) {
+  if (v == null) return type === 'string' ? '""' : type === 'bool' ? 'false' : '0';
+  if (type === 'number') return String(v);
+  if (type === 'bool') return v === true || v === 'true' ? 'true' : 'false';
+  return strLit(v);
+}
+
+export function toolOnPath(cmd, args = ['--version']) {
+  try {
+    const r = spawnSync(cmd, args, { encoding: 'utf8', timeout: 15000 });
+    return r.status === 0;
+  } catch {
+    return false;
+  }
+}

package/src/testing.mjs

@@ -42,7 +42,7 @@ export function runTests(ast) {
         const inputs = coerce(c.given);
         const run = evaluateDecision(dec, inputs);
         const pass = c.expect == null || String(run.result) === String(c.expect);
-        results.push({ ...label, kind: 'decision', expected: c.expect, actual: run.result, pass, ...(run.ok ? {} : { note: 'a condition failed to evaluate' }) });
+        results.push({ ...label, kind: 'decision', expected: c.expect, actual: run.result, matched: run.matched, pass, ...(run.ok ? {} : { note: 'a condition failed to evaluate' }) });
       } else if (lc) {
         const sim = simulateLifecycle(lc, c.events || []);
         const passState = c.expect == null || sim.finalState === c.expect;

package/src/twelve-factor.mjs

@@ -9,7 +9,7 @@
 //
 // Verdicts: 'satisfied' | 'partial' | 'absent'. Score = (satisfied + 0.5*partial) / 13.
 // Each factor cites the IL signal it inspects, the evidence found, and a concrete fix. The
-// finding ids (IL-12F-01..13) are in the canonical rule catalog for `intent explain`.
+// finding ids (IL-12F-01..13) are in the canonical rule catalog for `thunder explain`.
 
 export const TWELVE_FACTOR_SCHEMA = 'twelve-factor-v1';
 
@@ -44,7 +44,7 @@ const FACTORS = [
       const scoped = len(ast.scope?.include) + len(ast.scope?.exclude);
       if (scoped) return { verdict: 'satisfied', evidence: `context boundary declared (scope: ${len(ast.scope.include)} include / ${len(ast.scope.exclude)} exclude)` };
       if (len(ast.requires)) return { verdict: 'partial', evidence: 'dependencies declared but no explicit scope boundary', fix: 'Declare `scope include/exclude` so the context window is curated, not unbounded.' };
-      return { verdict: 'absent', evidence: 'no scope declared', fix: 'Add a `scope` block to bound what belongs in context (IntentLens/Focus narrows it further).' };
+      return { verdict: 'absent', evidence: 'no scope declared', fix: 'Add a `scope` block to bound what belongs in context (ThunderLens/Focus narrows it further).' };
     },
   },
   {