@skillstech/thunderlang 0.1.7 → 0.3.0

package/CHANGELOG.md

@@ -3,6 +3,59 @@
 All notable changes to `@skillstech/thunderlang`. Pre-1.0: the language and the
 `intent-graph-v1` schema version independently and may still change.
 
+## 0.3.0
+
+The 14-language lift release. Additive; no breaking changes. Restores the OpenThunder -> ThunderLang
+recover-intent loop for every language OpenThunder's archgraph core can now discover.
+
+- **Kotlin, Scala, and Elixir lift adapters.** `thunder lift` now extracts candidate intent from
+  `.kt`/`.kts`, `.scala`/`.sc`, and `.ex`/`.exs`, bringing the supported-language count to 14. A new
+  `name: Type` parameter parser handles the JVM signature shape; Elixir joins the dynamic-language set.
+- **Fix: repo-walk language coverage.** `LIFT_EXTS` was stale and silently skipped Python, Java, C#,
+  Go, C++, PHP, and Ruby during repo/`--all` lifts; it now mirrors the full adapter set.
+- **Fix: single-file lift language detection.** `thunder lift <file>` now auto-detects the language by
+  extension instead of defaulting to TypeScript, consistent with `--all`/repo modes.
+
+## 0.2.0
+
+The cross-language target execution release. Additive; no breaking changes.
+
+Version alignment: starting with 0.2.0, ThunderLang and OpenThunder version in lockstep, since most
+OpenThunder changes land in the language first. (0.1.8 and 0.1.9 were never published; the last
+release on npm was 0.1.7.)
+
+- **Live target adapters.** `thunder test <file> --target typescript|python|csharp|java` and
+  `thunder conform <file> --run <targets>` now compile the generated decision(s) and execute them
+  for real, grading the actual outputs instead of fed results. TypeScript/JS runs in-process,
+  Python through `python3`, C# through a throwaway `dotnet` console project, and Java through the
+  JDK 11+ single-file launcher (`java ThunderTarget.java`).
+- **`--all-targets`.** `thunder test <file> --all-targets` and `thunder conform <file> --all-targets`
+  run every target whose toolchain is available in one pass, side by side, and skip any target whose
+  runtime is absent (it stays declared in the conformance matrix) rather than failing.
+- **Static-target type inference.** Because C# and Java are statically typed, each decision
+  parameter's type is inferred from the test-case values it receives (numeric wins, then boolean,
+  else string), and each language gets its own equality translation.
+- Missing toolchains are detected via cached smoke checks and skipped cleanly, so builds never fail
+  for a runtime that is not installed.
+
+## 0.1.8
+
+The testing and verification release. Additive; no breaking changes.
+
+- **Rename to ThunderLang.** Package is `@skillstech/thunderlang`; the CLI binary is `thunder`
+  (with `intent` kept as a legacy alias). `.thunder` is the canonical source extension; `.tl` and
+  `.intent` are accepted. The Intent Graph and Intent-Oriented Programming vocabulary are retained.
+- **`thunder prove`** emits an `intent-proof-v1` artifact with honest per-claim verdicts
+  (verified / failed / declared / needs_verification, with `provenBy`). An unverified claim never
+  reads as proven.
+- **`thunder test --contracts [--strict]`** derives an obligation from every `guarantee` and
+  `never`, resolved against the specific test that verifies it. `--strict` fails CI on any unverified.
+- **Verification classification**: `verify by assertion|static|runtime|evidence|tool|approval|formal`.
+- **Stable IDs**: explicit `id INV-G-001` on guarantees / never-rules (slug fallback).
+- **Proof freshness**: the proof records intent hash, compiler, git commit, dependency-lockfile hash,
+  and environment; `thunder verify` marks a proof STALE when the implementation, dependencies, or
+  compiler move since it was generated.
+
 ## 0.1.6
 
 The agent-conformance release (skills on intents + 12-factor scoring). Additive; no breaking

package/dist/core.cjs

@@ -789,6 +789,60 @@ function parseDecision(name, node2) {
   }
   return dec;
 }
+function parseProperty(name, node2) {
+  const prop = { name, vars: [], decide: null, expects: [], line: node2.line };
+  for (const c of node2.children.filter((x) => !isNote(x))) {
+    const k = firstWord(c.text);
+    const a = rest(c.text);
+    if (k === "forAll" || k === "forall") {
+      for (const v of c.children.filter((x) => !isNote(x))) {
+        const m = v.text.trim().match(/^([A-Za-z_]\w*)\s*:\s*(\w+)(?:\s+where\s+(.+))?$/);
+        if (!m) continue;
+        const whereChild = (v.children || []).find((x) => firstWord(x.text) === "where");
+        prop.vars.push({ name: m[1], type: m[2], where: m[3] || (whereChild ? rest(whereChild.text) : null) });
+      }
+    } else if (k === "decide") prop.decide = a || c.children[0] && c.children[0].text.trim() || null;
+    else if (k === "when") {
+      const dm = a.match(/(?:decide|execute)\s+(\w+)/);
+      if (dm) prop.decide = dm[1];
+    } else if (k === "expect") for (const e of c.children.filter((x) => !isNote(x))) prop.expects.push(e.text.trim());
+  }
+  return prop;
+}
+function parseEvaluation(name, node2) {
+  const ev = { name, dataset: null, requires: [], line: node2.line };
+  for (const c of node2.children.filter((x) => !isNote(x))) {
+    const k = firstWord(c.text);
+    const a = rest(c.text);
+    if (k === "dataset") ev.dataset = a || c.children[0] && c.children[0].text.trim() || null;
+    else if (k === "require") {
+      for (const r of c.children.filter((x) => !isNote(x))) {
+        const m = r.text.trim().match(/^([A-Za-z_][\w.]*)\s*(>=|<=|==|!=|>|<)\s*(-?[\d.]+)$/);
+        if (m) ev.requires.push({ metric: m[1], op: m[2], threshold: parseFloat(m[3]) });
+      }
+    }
+  }
+  return ev;
+}
+function parseScenario(name, node2) {
+  const sc = { name, given: [], when: [], then: [], never: [], eventually: [], line: node2.line };
+  const clausesOf = (c) => {
+    const items = leafItems(c);
+    return items.length ? items : rest(c.text) ? [rest(c.text)] : [];
+  };
+  for (const c of node2.children.filter((x) => !isNote(x))) {
+    const k = firstWord(c.text);
+    if (k === "given") sc.given.push(...clausesOf(c));
+    else if (k === "when") sc.when.push(...clausesOf(c));
+    else if (k === "then") sc.then.push(...clausesOf(c));
+    else if (k === "never") sc.never.push(...clausesOf(c));
+    else if (k === "eventually") {
+      const within = (rest(c.text).match(/within\s+(.+)/) || [])[1] || null;
+      sc.eventually.push({ within, clauses: leafItems(c) });
+    }
+  }
+  return sc;
+}
 function parseLifecycle(name, node2) {
   const lc = { name, states: [], transitions: [], terminals: [], line: node2.line };
   for (const c of node2.children.filter((x) => !isNote(x))) {
@@ -821,7 +875,13 @@ function parseInvariant(name, node2) {
   for (const c of kids(node2)) {
     const k = firstWord(c.text);
     if (k === "verify") inv.verify.push(rest(c.text));
-    else if (k === "because") inv.because = rest(c.text);
+    else if (k === "id") {
+      const v = rest(c.text);
+      if (v) {
+        inv.id = v;
+        inv.stableId = v;
+      }
+    } else if (k === "because") inv.because = rest(c.text);
     else if (k === "statement") inv.statement = rest(c.text) || leafItems(c).join(" ");
     else if (k === "scope") inv.scope = (rest(c.text) || leafItems(c).join(" ")).toLowerCase();
     else if (k === "severity") inv.severity = (rest(c.text) || leafItems(c).join(" ")).toLowerCase();
@@ -907,11 +967,12 @@ function parseHandler(trigger, node2) {
     actions
   };
 }
+var VERIFY_KINDS = /* @__PURE__ */ new Set(["assertion", "static", "runtime", "evidence", "tool", "approval", "formal"]);
 function upsertRule(list, statement, line) {
   const id = slug(statement);
   let r = list.find((x) => x.id === id);
   if (!r) {
-    r = { id, statement, because: null, verify: [], notes: [], line };
+    r = { id, statement, because: null, verify: [], verifications: [], notes: [], line };
     list.push(r);
   }
   return r;
@@ -920,8 +981,28 @@ function applyDetail(rule, node2) {
   for (const c of node2.children) {
     const kw = firstWord(c.text);
     if (kw === "because") rule.because = rest(c.text) || c.children[0] && c.children[0].text || null;
-    else if (kw === "verify") rule.verify.push(rest(c.text) || c.children[0] && c.children[0].text || "");
-    else if (isNote(c)) rule.notes.push(parseNoteNode(c));
+    else if (kw === "verify") {
+      const a = rest(c.text);
+      const m = a && a.match(/^by\s+(\w+)/i);
+      if (m) {
+        const kind = m[1].toLowerCase();
+        const details = (c.children || []).filter((x) => !isNote(x)).map((x) => x.text.trim()).filter(Boolean);
+        rule.verifications.push({ kind: VERIFY_KINDS.has(kind) ? kind : "unknown", declared: kind, details });
+        rule.verify.push(details.length ? `${kind}: ${details.join("; ")}` : `by ${kind}`);
+      } else {
+        const v = a || c.children[0] && c.children[0].text || "";
+        if (v) {
+          rule.verify.push(v);
+          rule.verifications.push({ kind: "unclassified", declared: null, details: [v] });
+        }
+      }
+    } else if (kw === "id") {
+      const v = rest(c.text) || c.children[0] && c.children[0].text;
+      if (v) {
+        rule.id = v;
+        rule.stableId = v;
+      }
+    } else if (isNote(c)) rule.notes.push(parseNoteNode(c));
   }
   rule.verify = rule.verify.filter(Boolean);
 }
@@ -986,6 +1067,9 @@ function parseIntent(source) {
     handlers: [],
     // Decisions, rules, process (Gap 4)
     decisions: [],
+    properties: [],
+    scenarios: [],
+    evaluations: [],
     // Governance: waivers , governed exceptions to blocking diagnostics (Gap 5)
     waivers: [],
     // Data purpose + privacy , governed data elements (Gap 6)
@@ -1214,6 +1298,15 @@ function parseIntent(source) {
       case "decision":
         ast.decisions.push(parseDecision(arg, node2));
         break;
+      case "property":
+        ast.properties.push(parseProperty(arg, node2));
+        break;
+      case "scenario":
+        ast.scenarios.push(parseScenario(arg, node2));
+        break;
+      case "evaluation":
+        ast.evaluations.push(parseEvaluation(arg, node2));
+        break;
       // ── System profile ──
       case "capability": {
         const cap = { name: arg, description: null, implements: [], line: node2.line };
@@ -3198,21 +3291,23 @@ function compileExpr(src) {
 function evalExpr(src, inputs = {}) {
   return compileExpr(src)(inputs);
 }
+var C_LOGIC = { and: (a, b) => `(${a} && ${b})`, or: (a, b) => `(${a} || ${b})`, not: (a) => `!${a}`, bool: (v) => String(v) };
 var DIALECTS = {
-  js: { eq: (a, b) => `${a} === ${b}`, neq: (a, b) => `${a} !== ${b}`, inList: (list, x) => `[${list.join(", ")}].includes(${x})`, nil: "undefined" },
-  csharp: { eq: (a, b) => `${a} == ${b}`, neq: (a, b) => `${a} != ${b}`, inList: (list, x) => `new[]{${list.join(", ")}}.Contains(${x})`, nil: "null" },
-  java: { eq: (a, b) => `java.util.Objects.equals(${a}, ${b})`, neq: (a, b) => `!java.util.Objects.equals(${a}, ${b})`, inList: (list, x) => `java.util.List.of(${list.join(", ")}).contains(${x})`, nil: "null" }
+  js: { ...C_LOGIC, eq: (a, b) => `${a} === ${b}`, neq: (a, b) => `${a} !== ${b}`, inList: (list, x) => `[${list.join(", ")}].includes(${x})`, nil: "undefined" },
+  csharp: { ...C_LOGIC, eq: (a, b) => `${a} == ${b}`, neq: (a, b) => `${a} != ${b}`, inList: (list, x) => `new[]{${list.join(", ")}}.Contains(${x})`, nil: "null" },
+  java: { ...C_LOGIC, eq: (a, b) => `java.util.Objects.equals(${a}, ${b})`, neq: (a, b) => `!java.util.Objects.equals(${a}, ${b})`, inList: (list, x) => `java.util.List.of(${list.join(", ")}).contains(${x})`, nil: "null" },
+  python: { and: (a, b) => `(${a} and ${b})`, or: (a, b) => `(${a} or ${b})`, not: (a) => `(not ${a})`, bool: (v) => v ? "True" : "False", eq: (a, b) => `${a} == ${b}`, neq: (a, b) => `${a} != ${b}`, inList: (list, x) => `${x} in [${list.join(", ")}]`, nil: "None" }
 };
 function renderExpr(src, inputs, D) {
   const known = new Set(inputs);
   const r = (n) => {
     switch (n.k) {
       case "or":
-        return `(${r(n.a)} || ${r(n.b)})`;
+        return D.or(r(n.a), r(n.b));
       case "and":
-        return `(${r(n.a)} && ${r(n.b)})`;
+        return D.and(r(n.a), r(n.b));
       case "not":
-        return `!${r(n.a)}`;
+        return D.not(r(n.a));
       case "neg":
         return `-${r(n.a)}`;
       case "arith":
@@ -3226,7 +3321,7 @@ function renderExpr(src, inputs, D) {
       case "list":
         return `[${n.items.map(r).join(", ")}]`;
       case "lit":
-        return typeof n.v === "string" ? JSON.stringify(n.v) : String(n.v);
+        return typeof n.v === "string" ? JSON.stringify(n.v) : typeof n.v === "boolean" ? D.bool(n.v) : String(n.v);
       case "ref":
         return known.has(n.path) || known.has(n.path.split(".")[0]) ? n.path : JSON.stringify(n.path);
       default:
@@ -4193,7 +4288,7 @@ function notesSummary(ast) {
     byLens
   };
 }
-var COMPILER_VERSION = "0.1.0";
+var COMPILER_VERSION = "0.3.0";
 var PROOF_SCHEMA_VERSION = "0.1.0";
 var SOURCE_PRODUCT = "skillstech-compiler";
 function buildContractGraph(ast, generatedAt) {
@@ -4686,13 +4781,15 @@ function buildProof(ast, { sourceFile, sourceHash, targetsRequested, targetsGene
       id: g.id,
       text: g.statement,
       status: g.verify.length > 0 || verifiedText ? "planned" : "needs_verification",
-      evidence: g.verify
+      evidence: g.verify,
+      verifications: g.verifications || []
     })),
     neverRules: ast.neverRules.map((n) => ({
       id: n.id,
       text: n.statement,
       status: n.verify.length > 0 ? "planned" : "needs_verification",
-      evidence: n.verify
+      evidence: n.verify,
+      verifications: n.verifications || []
     })),
     errors: (ast.errors || []).map((e) => ({ name: e.name })),
     examples: (ast.examples || []).map((ex) => ({ given: ex.given, expect: ex.expect })),
@@ -5281,6 +5378,112 @@ function extractFactsRuby(source, file = "input.rb") {
   }
   return { schemaVersion: IR_SCHEMA_VERSION, sourceLanguage: "ruby", sourceRoot: file, functions, tests, errors };
 }
+function parseNameColonTypeParams(raw) {
+  return splitTopLevel(raw, ",").map((p) => p.trim()).filter(Boolean).map((p) => {
+    const cleaned = p.replace(/@\w+(\([^)]*\))?/g, "").replace(/^(?:val|var|vararg|implicit|final|lazy)\s+/, "").replace(/=.*$/, "").trim();
+    const mm = cleaned.match(/^([A-Za-z_]\w*)\s*:\s*(.+)$/);
+    if (mm) return { name: mm[1], type: mm[2].trim() };
+    return { name: cleaned.replace(/[^\w].*$/, "") || cleaned, type: null };
+  });
+}
+function extractFactsKotlin(source, file = "input.kt") {
+  let m;
+  const functions = [];
+  const tests = [];
+  const seen = /* @__PURE__ */ new Set();
+  const testMethods = /* @__PURE__ */ new Set();
+  const ta = /@Test\b[\s\S]{0,120}?\bfun\s+(?:`([^`]+)`|(\w+))\s*\(/g;
+  while (m = ta.exec(source)) testMethods.add(m[1] || m[2]);
+  const fnRe = /\bfun\s+(?:<[^>]*>\s*)?(?:[A-Za-z_][\w.]*\.)?(?:`([^`]+)`|([A-Za-z_]\w*))\s*\(([^)]*)\)\s*(?::\s*([^{=\n]+))?/g;
+  while (m = fnRe.exec(source)) {
+    const name = m[1] || m[2];
+    if (testMethods.has(name)) {
+      if (!tests.some((t) => t.name === name)) tests.push({ name, file, line: lineOf(source, m.index) });
+      continue;
+    }
+    if (seen.has(name)) continue;
+    seen.add(name);
+    functions.push({ name, file, line: lineOf(source, m.index), parameters: parseNameColonTypeParams(m[3] || ""), returnType: m[4] ? m[4].trim() : null, evidence: [{ kind: "fun", file, line: lineOf(source, m.index) }] });
+  }
+  const errors = [];
+  const addErr = addErrOf(errors, /* @__PURE__ */ new Set(), { _src: source, _file: file });
+  let mm;
+  const ce = /class\s+(\w*(?:Exception|Error))\b/g;
+  while (mm = ce.exec(source)) addErr(mm[1], mm.index);
+  const th = /throw\s+(\w+)\s*\(/g;
+  while (mm = th.exec(source)) addErr(mm[1], mm.index);
+  return { schemaVersion: IR_SCHEMA_VERSION, sourceLanguage: "kotlin", sourceRoot: file, functions, tests, errors };
+}
+function extractFactsScala(source, file = "input.scala") {
+  let m;
+  const functions = [];
+  const tests = [];
+  const seen = /* @__PURE__ */ new Set();
+  const fnRe = /\bdef\s+([A-Za-z_]\w*)\s*(?:\[[^\]]*\])?\s*\(([^)]*)\)\s*(?::\s*([^={\n]+))?/g;
+  while (m = fnRe.exec(source)) {
+    const name = m[1];
+    if (seen.has(name)) continue;
+    seen.add(name);
+    functions.push({ name, file, line: lineOf(source, m.index), parameters: parseNameColonTypeParams(m[2] || ""), returnType: m[3] ? m[3].trim() : null, evidence: [{ kind: "def", file, line: lineOf(source, m.index) }] });
+  }
+  const seenT = /* @__PURE__ */ new Set();
+  const addTest = (n, idx) => {
+    const k = String(n).toLowerCase();
+    if (n && !seenT.has(k)) {
+      seenT.add(k);
+      tests.push({ name: n, file, line: lineOf(source, idx) });
+    }
+  };
+  const tr = /\btest\s*\(\s*"([^"]+)"/g;
+  while (m = tr.exec(source)) addTest(m[1], m.index);
+  const inRe = /"([^"]+)"\s+(?:in|should|must)\b/g;
+  while (m = inRe.exec(source)) addTest(m[1], m.index);
+  const errors = [];
+  const addErr = addErrOf(errors, /* @__PURE__ */ new Set(), { _src: source, _file: file });
+  let mm;
+  const ce = /class\s+(\w*(?:Exception|Error))\b/g;
+  while (mm = ce.exec(source)) addErr(mm[1], mm.index);
+  const th = /throw\s+new\s+(\w+)\s*\(/g;
+  while (mm = th.exec(source)) addErr(mm[1], mm.index);
+  return { schemaVersion: IR_SCHEMA_VERSION, sourceLanguage: "scala", sourceRoot: file, functions, tests, errors };
+}
+function extractFactsElixir(source, file = "input.ex") {
+  let m;
+  const functions = [];
+  const tests = [];
+  const seen = /* @__PURE__ */ new Set();
+  const seenT = /* @__PURE__ */ new Set();
+  const addTest = (n, idx) => {
+    const k = String(n).toLowerCase();
+    if (n && !seenT.has(k)) {
+      seenT.add(k);
+      tests.push({ name: n, file, line: lineOf(source, idx) });
+    }
+  };
+  const tr = /\btest\s+"([^"]+)"/g;
+  while (m = tr.exec(source)) addTest(m[1], m.index);
+  const fnRe = /^[ \t]*defp?\s+([a-z_]\w*[!?]?)\s*(?:\(([^)]*)\))?/gm;
+  while (m = fnRe.exec(source)) {
+    const name = m[1];
+    if (seen.has(name)) continue;
+    seen.add(name);
+    const parameters = splitTopLevel(m[2] || "", ",").map((p) => p.trim()).filter(Boolean).map((p) => ({ name: p.split(/\\\\/)[0].trim().replace(/^%\{?/, "").replace(/[^\w].*$/, "") || p, type: null }));
+    functions.push({ name, file, line: lineOf(source, m.index), indent: (m[0].match(/^[ \t]*/) || [""])[0].length, parameters, returnType: null, evidence: [{ kind: "def", file, line: lineOf(source, m.index) }] });
+  }
+  const errors = [];
+  const seenErr = /* @__PURE__ */ new Set();
+  const addErr = (n, idx) => {
+    if (n && !seenErr.has(n)) {
+      seenErr.add(n);
+      errors.push({ name: n, file, line: lineOf(source, idx) });
+    }
+  };
+  const modErr = /defmodule\s+([\w.]*(?:Error|Exception))\b/g;
+  while (m = modErr.exec(source)) addErr(m[1].split(".").pop(), m.index);
+  const raiseRe = /raise\s+([A-Z][\w.]*)/g;
+  while (m = raiseRe.exec(source)) addErr(m[1].split(".").pop(), m.index);
+  return { schemaVersion: IR_SCHEMA_VERSION, sourceLanguage: "elixir", sourceRoot: file, functions, tests, errors };
+}
 var ADAPTERS = {
   typescript: extractFactsTypeScript,
   ts: extractFactsTypeScript,
@@ -5304,10 +5507,18 @@ var ADAPTERS = {
   cc: extractFactsCpp,
   php: extractFactsPhp,
   ruby: extractFactsRuby,
-  rb: extractFactsRuby
+  rb: extractFactsRuby,
+  kotlin: extractFactsKotlin,
+  kt: extractFactsKotlin,
+  kts: extractFactsKotlin,
+  scala: extractFactsScala,
+  sc: extractFactsScala,
+  elixir: extractFactsElixir,
+  ex: extractFactsElixir,
+  exs: extractFactsElixir
 };
-var SUPPORTED_LANGUAGES = ["typescript", "javascript", "python", "java", "csharp", "go", "rust", "cpp", "php", "ruby", "perl"];
-var DYNAMIC_LANGUAGES = /* @__PURE__ */ new Set(["perl", "javascript", "python", "ruby", "php"]);
+var SUPPORTED_LANGUAGES = ["typescript", "javascript", "python", "java", "csharp", "go", "rust", "cpp", "php", "ruby", "perl", "kotlin", "scala", "elixir"];
+var DYNAMIC_LANGUAGES = /* @__PURE__ */ new Set(["perl", "javascript", "python", "ruby", "php", "elixir"]);
 var LANG_DISPLAY = {
   typescript: "TypeScript",
   javascript: "JavaScript",
@@ -5319,7 +5530,10 @@ var LANG_DISPLAY = {
   cpp: "C++",
   php: "PHP",
   ruby: "Ruby",
-  perl: "Perl"
+  perl: "Perl",
+  kotlin: "Kotlin",
+  scala: "Scala",
+  elixir: "Elixir"
 };
 function unwrapReturn(ret) {
   if (!ret) return { output: null, error: null };
@@ -5443,6 +5657,9 @@ function languageForFile(file) {
   if (/\.(cpp|cc|cxx|hpp|hh|c|h)$/i.test(file)) return "cpp";
   if (/\.php$/i.test(file)) return "php";
   if (/\.rb$/i.test(file)) return "ruby";
+  if (/\.kts?$/i.test(file)) return "kotlin";
+  if (/\.(scala|sc)$/i.test(file)) return "scala";
+  if (/\.exs?$/i.test(file)) return "elixir";
   if (/\.(mjs|cjs|jsx?)$/i.test(file)) return "javascript";
   return "typescript";
 }
@@ -5450,7 +5667,7 @@ function isPublicFn(fn, language) {
   const name = fn.name || "";
   if (/(?:Internal|Impl|_impl|_helper|_test|Helper)$/.test(name)) return false;
   if (language === "go" || language === "golang") return /^[A-Z]/.test(name) && name !== "Test";
-  if (language === "python" || language === "ruby") return !name.startsWith("_") && (fn.indent == null || fn.indent <= 4);
+  if (language === "python" || language === "ruby" || language === "elixir") return !name.startsWith("_") && (fn.indent == null || fn.indent <= 4);
   return !name.startsWith("_") && name !== "init" && name !== "constructor";
 }
 function liftAll(source, { language = "typescript", file = "", publicOnly = true } = {}) {
@@ -5525,7 +5742,10 @@ var LANG_EXT = {
   cpp: "cpp",
   php: "php",
   ruby: "rb",
-  perl: "pl"
+  perl: "pl",
+  kotlin: "kt",
+  scala: "scala",
+  elixir: "ex"
 };
 function liftSource(source, { language = "typescript", file = "", seeds = void 0 } = {}) {
   const key = String(language).toLowerCase();