typeglish 0.1.0

package/dist/chunk-YH4ZLQ4G.js

@@ -0,0 +1,4260 @@
+import { COMPARISON_KEYWORDS, COMPARISON_SYMBOLS, CARDINAL_QUANTITIES, EXACTNESS_MARKERS, QUANTIFIER_KEYWORDS, copulaAlternation, examplesMask, configSectionMask, toolBlockMask, stripPunct, stripInlineComment, splitSentences, stripAnnotation, maskQuotes, CONFIG_RE, TRANSCLUSION_LINE_RE, IMPORT_FILE_RE, REQUIRE_RE, IMPORT_RE, DEFINE_RE, CONFIG_SECTION_OPEN, CONFIG_SECTION_CLOSE, annotationAlias, isAnnotationLine, TAG_NAME_SRC, SNAKE_RE, BARE_COMMAND_RE, NUMBER_WORDS, NAME_PHRASE, bindsHere, toolsFromLines, literalSectionMask, defListMask, defEntries, renderDefBlock, stripQuotes, HONORIFIC_PREFIX_SRC, NAME_WORD, copulaConnector, SERVICE_DECL_RE, TOOL_DECL_RE } from './chunk-Y64EAEYB.js';
+import { __commonJS, __require, __toESM } from './chunk-PR4QN5HX.js';
+
+// node_modules/pluralize/pluralize.js
+var require_pluralize = __commonJS({
+  "node_modules/pluralize/pluralize.js"(exports, module) {
+    (function(root, pluralize) {
+      if (typeof __require === "function" && typeof exports === "object" && typeof module === "object") {
+        module.exports = pluralize();
+      } else if (typeof define === "function" && define.amd) {
+        define(function() {
+          return pluralize();
+        });
+      } else {
+        root.pluralize = pluralize();
+      }
+    })(exports, function() {
+      var pluralRules = [];
+      var singularRules = [];
+      var uncountables = {};
+      var irregularPlurals = {};
+      var irregularSingles = {};
+      function sanitizeRule(rule) {
+        if (typeof rule === "string") {
+          return new RegExp("^" + rule + "$", "i");
+        }
+        return rule;
+      }
+      function restoreCase(word, token) {
+        if (word === token) return token;
+        if (word === word.toLowerCase()) return token.toLowerCase();
+        if (word === word.toUpperCase()) return token.toUpperCase();
+        if (word[0] === word[0].toUpperCase()) {
+          return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+        }
+        return token.toLowerCase();
+      }
+      function interpolate(str, args) {
+        return str.replace(/\$(\d{1,2})/g, function(match, index) {
+          return args[index] || "";
+        });
+      }
+      function replace(word, rule) {
+        return word.replace(rule[0], function(match, index) {
+          var result = interpolate(rule[1], arguments);
+          if (match === "") {
+            return restoreCase(word[index - 1], result);
+          }
+          return restoreCase(match, result);
+        });
+      }
+      function sanitizeWord(token, word, rules) {
+        if (!token.length || uncountables.hasOwnProperty(token)) {
+          return word;
+        }
+        var len = rules.length;
+        while (len--) {
+          var rule = rules[len];
+          if (rule[0].test(word)) return replace(word, rule);
+        }
+        return word;
+      }
+      function replaceWord(replaceMap, keepMap, rules) {
+        return function(word) {
+          var token = word.toLowerCase();
+          if (keepMap.hasOwnProperty(token)) {
+            return restoreCase(word, token);
+          }
+          if (replaceMap.hasOwnProperty(token)) {
+            return restoreCase(word, replaceMap[token]);
+          }
+          return sanitizeWord(token, word, rules);
+        };
+      }
+      function checkWord(replaceMap, keepMap, rules, bool) {
+        return function(word) {
+          var token = word.toLowerCase();
+          if (keepMap.hasOwnProperty(token)) return true;
+          if (replaceMap.hasOwnProperty(token)) return false;
+          return sanitizeWord(token, token, rules) === token;
+        };
+      }
+      function pluralize(word, count, inclusive) {
+        var pluralized = count === 1 ? pluralize.singular(word) : pluralize.plural(word);
+        return (inclusive ? count + " " : "") + pluralized;
+      }
+      pluralize.plural = replaceWord(
+        irregularSingles,
+        irregularPlurals,
+        pluralRules
+      );
+      pluralize.isPlural = checkWord(
+        irregularSingles,
+        irregularPlurals,
+        pluralRules
+      );
+      pluralize.singular = replaceWord(
+        irregularPlurals,
+        irregularSingles,
+        singularRules
+      );
+      pluralize.isSingular = checkWord(
+        irregularPlurals,
+        irregularSingles,
+        singularRules
+      );
+      pluralize.addPluralRule = function(rule, replacement) {
+        pluralRules.push([sanitizeRule(rule), replacement]);
+      };
+      pluralize.addSingularRule = function(rule, replacement) {
+        singularRules.push([sanitizeRule(rule), replacement]);
+      };
+      pluralize.addUncountableRule = function(word) {
+        if (typeof word === "string") {
+          uncountables[word.toLowerCase()] = true;
+          return;
+        }
+        pluralize.addPluralRule(word, "$0");
+        pluralize.addSingularRule(word, "$0");
+      };
+      pluralize.addIrregularRule = function(single, plural) {
+        plural = plural.toLowerCase();
+        single = single.toLowerCase();
+        irregularSingles[single] = plural;
+        irregularPlurals[plural] = single;
+      };
+      [
+        // Pronouns.
+        ["I", "we"],
+        ["me", "us"],
+        ["he", "they"],
+        ["she", "they"],
+        ["them", "them"],
+        ["myself", "ourselves"],
+        ["yourself", "yourselves"],
+        ["itself", "themselves"],
+        ["herself", "themselves"],
+        ["himself", "themselves"],
+        ["themself", "themselves"],
+        ["is", "are"],
+        ["was", "were"],
+        ["has", "have"],
+        ["this", "these"],
+        ["that", "those"],
+        // Words ending in with a consonant and `o`.
+        ["echo", "echoes"],
+        ["dingo", "dingoes"],
+        ["volcano", "volcanoes"],
+        ["tornado", "tornadoes"],
+        ["torpedo", "torpedoes"],
+        // Ends with `us`.
+        ["genus", "genera"],
+        ["viscus", "viscera"],
+        // Ends with `ma`.
+        ["stigma", "stigmata"],
+        ["stoma", "stomata"],
+        ["dogma", "dogmata"],
+        ["lemma", "lemmata"],
+        ["schema", "schemata"],
+        ["anathema", "anathemata"],
+        // Other irregular rules.
+        ["ox", "oxen"],
+        ["axe", "axes"],
+        ["die", "dice"],
+        ["yes", "yeses"],
+        ["foot", "feet"],
+        ["eave", "eaves"],
+        ["goose", "geese"],
+        ["tooth", "teeth"],
+        ["quiz", "quizzes"],
+        ["human", "humans"],
+        ["proof", "proofs"],
+        ["carve", "carves"],
+        ["valve", "valves"],
+        ["looey", "looies"],
+        ["thief", "thieves"],
+        ["groove", "grooves"],
+        ["pickaxe", "pickaxes"],
+        ["passerby", "passersby"]
+      ].forEach(function(rule) {
+        return pluralize.addIrregularRule(rule[0], rule[1]);
+      });
+      [
+        [/s?$/i, "s"],
+        [/[^\u0000-\u007F]$/i, "$0"],
+        [/([^aeiou]ese)$/i, "$1"],
+        [/(ax|test)is$/i, "$1es"],
+        [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, "$1es"],
+        [/(e[mn]u)s?$/i, "$1s"],
+        [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, "$1"],
+        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1i"],
+        [/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"],
+        [/(seraph|cherub)(?:im)?$/i, "$1im"],
+        [/(her|at|gr)o$/i, "$1oes"],
+        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, "$1a"],
+        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, "$1a"],
+        [/sis$/i, "ses"],
+        [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"],
+        [/([^aeiouy]|qu)y$/i, "$1ies"],
+        [/([^ch][ieo][ln])ey$/i, "$1ies"],
+        [/(x|ch|ss|sh|zz)$/i, "$1es"],
+        [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"],
+        [/\b((?:tit)?m|l)(?:ice|ouse)$/i, "$1ice"],
+        [/(pe)(?:rson|ople)$/i, "$1ople"],
+        [/(child)(?:ren)?$/i, "$1ren"],
+        [/eaux$/i, "$0"],
+        [/m[ae]n$/i, "men"],
+        ["thou", "you"]
+      ].forEach(function(rule) {
+        return pluralize.addPluralRule(rule[0], rule[1]);
+      });
+      [
+        [/s$/i, ""],
+        [/(ss)$/i, "$1"],
+        [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"],
+        [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"],
+        [/ies$/i, "y"],
+        [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, "$1ie"],
+        [/\b(mon|smil)ies$/i, "$1ey"],
+        [/\b((?:tit)?m|l)ice$/i, "$1ouse"],
+        [/(seraph|cherub)im$/i, "$1"],
+        [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, "$1"],
+        [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, "$1sis"],
+        [/(movie|twelve|abuse|e[mn]u)s$/i, "$1"],
+        [/(test)(?:is|es)$/i, "$1is"],
+        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1us"],
+        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, "$1um"],
+        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, "$1on"],
+        [/(alumn|alg|vertebr)ae$/i, "$1a"],
+        [/(cod|mur|sil|vert|ind)ices$/i, "$1ex"],
+        [/(matr|append)ices$/i, "$1ix"],
+        [/(pe)(rson|ople)$/i, "$1rson"],
+        [/(child)ren$/i, "$1"],
+        [/(eau)x?$/i, "$1"],
+        [/men$/i, "man"]
+      ].forEach(function(rule) {
+        return pluralize.addSingularRule(rule[0], rule[1]);
+      });
+      [
+        // Singular words with no plurals.
+        "adulthood",
+        "advice",
+        "agenda",
+        "aid",
+        "aircraft",
+        "alcohol",
+        "ammo",
+        "analytics",
+        "anime",
+        "athletics",
+        "audio",
+        "bison",
+        "blood",
+        "bream",
+        "buffalo",
+        "butter",
+        "carp",
+        "cash",
+        "chassis",
+        "chess",
+        "clothing",
+        "cod",
+        "commerce",
+        "cooperation",
+        "corps",
+        "debris",
+        "diabetes",
+        "digestion",
+        "elk",
+        "energy",
+        "equipment",
+        "excretion",
+        "expertise",
+        "firmware",
+        "flounder",
+        "fun",
+        "gallows",
+        "garbage",
+        "graffiti",
+        "hardware",
+        "headquarters",
+        "health",
+        "herpes",
+        "highjinks",
+        "homework",
+        "housework",
+        "information",
+        "jeans",
+        "justice",
+        "kudos",
+        "labour",
+        "literature",
+        "machinery",
+        "mackerel",
+        "mail",
+        "media",
+        "mews",
+        "moose",
+        "music",
+        "mud",
+        "manga",
+        "news",
+        "only",
+        "personnel",
+        "pike",
+        "plankton",
+        "pliers",
+        "police",
+        "pollution",
+        "premises",
+        "rain",
+        "research",
+        "rice",
+        "salmon",
+        "scissors",
+        "series",
+        "sewage",
+        "shambles",
+        "shrimp",
+        "software",
+        "species",
+        "staff",
+        "swine",
+        "tennis",
+        "traffic",
+        "transportation",
+        "trout",
+        "tuna",
+        "wealth",
+        "welfare",
+        "whiting",
+        "wildebeest",
+        "wildlife",
+        "you",
+        /pok[eé]mon$/i,
+        // Regexes.
+        /[^aeiou]ese$/i,
+        // "chinese", "japanese"
+        /deer$/i,
+        // "deer", "reindeer"
+        /fish$/i,
+        // "fish", "blowfish", "angelfish"
+        /measles$/i,
+        /o[iu]s$/i,
+        // "carnivorous"
+        /pox$/i,
+        // "chickpox", "smallpox"
+        /sheep$/i
+      ].forEach(pluralize.addUncountableRule);
+      return pluralize;
+    });
+  }
+});
+
+// src/core/expr.ts
+var KEYWORDS = /* @__PURE__ */ new Set(["not", "and", "or", ...COMPARISON_KEYWORDS.flatMap((p) => p.toLowerCase().split(" "))]);
+var TOKEN = /@\{([a-z][a-z0-9_]*)\}|\$([a-z][a-z0-9_]*)|([a-z][a-z0-9_]*)|(,)|(\()|(\))|(-?\d+(?:\.\d+)?)|(>=|<=|>|<|==|!=|=)/gi;
+function pointerRewrite(text) {
+  return text.replace(/\$([a-z][a-z0-9_]*)/gi, (_, n) => `@{${n.toLowerCase()}}`);
+}
+var SYMBOL_REWRITE = Object.fromEntries(
+  COMPARISON_SYMBOLS.flatMap((c) => c.symbols.map((s) => [s, c.machine]))
+);
+function tokenize(s) {
+  const toks = [];
+  TOKEN.lastIndex = 0;
+  let m;
+  while ((m = TOKEN.exec(s)) !== null) {
+    if (m[1] !== void 0) toks.push({ t: "var", v: m[1].toLowerCase() });
+    else if (m[2] !== void 0) toks.push({ t: "legacyvar", v: m[2].toLowerCase() });
+    else if (m[3] !== void 0) {
+      const w = m[3].toLowerCase();
+      toks.push(KEYWORDS.has(w) ? { t: "kw", v: w } : { t: "word", v: w });
+    } else if (m[4] !== void 0) toks.push({ t: "comma" });
+    else if (m[5] !== void 0) toks.push({ t: "lp" });
+    else if (m[6] !== void 0) toks.push({ t: "rp" });
+    else if (m[7] !== void 0) toks.push({ t: "num", v: Number(m[7]) });
+    else if (m[8] !== void 0) toks.push({ t: "op", v: m[8] });
+  }
+  return toks;
+}
+function parseExpr(text) {
+  const toks = tokenize(text);
+  if (toks.length === 0) return { ast: null, error: "empty condition" };
+  let i = 0;
+  let error = null;
+  const peek = () => toks[i];
+  const kw = (v) => peek()?.t === "kw" && peek().v === v;
+  const fail = (msg) => {
+    if (error === null) error = msg;
+    return null;
+  };
+  const parseValue = () => {
+    const tk = peek();
+    if (tk?.t === "word") {
+      i += 1;
+      return tk.v;
+    }
+    if (tk?.t === "num") {
+      i += 1;
+      return String(tk.v);
+    }
+    return fail("expected a value (a plain word or number, e.g. `booking`)");
+  };
+  const parseNumber = (op, name) => {
+    const tk = peek();
+    if (tk?.t === "num") {
+      i += 1;
+      return tk.v;
+    }
+    fail(`\`is ${op}\` compares numbers \u2014 write \`@{${name}} is ${op} 100\`. For a value match, write \`@{${name}} is equal to \u2026\`.`);
+    return null;
+  };
+  const parseAtom = () => {
+    const tk = peek();
+    if (tk?.t === "lp") {
+      i += 1;
+      const inner = parseOr();
+      if (!inner) return null;
+      if (peek()?.t !== "rp") return fail("missing `)`");
+      i += 1;
+      return inner;
+    }
+    if (tk?.t === "legacyvar") {
+      return fail(`a variable in a condition is a pointer \u2014 \`@{${tk.v}}\`, never \`$${tk.v}\`. Write the condition as: \`${pointerRewrite(text)}\`.`);
+    }
+    if (tk?.t !== "var") return fail("expected a `@{variable}` pointer");
+    i += 1;
+    const name = tk.v;
+    const opTok = peek();
+    if (opTok?.t === "op") {
+      i += 1;
+      const num = peek();
+      const operand = num?.t === "num" ? ` ${num.v}` : num?.t === "word" ? ` ${num.v}` : " \u2026";
+      return fail(`comparisons are English \u2014 \`${opTok.v}\` is not an operator. Write \`@{${name}} ${SYMBOL_REWRITE[opTok.v] ?? "is equal to"}${operand}\`.`);
+    }
+    if (!kw("is")) return { kind: "read", name };
+    i += 1;
+    const negate = kw("not");
+    if (negate) i += 1;
+    const wrap = (e) => negate ? { kind: "not", arg: e } : e;
+    if (kw("equal")) {
+      i += 1;
+      if (!kw("to")) return fail("expected `to` after `equal` \u2014 the operator is `is equal to`");
+      i += 1;
+      const value = parseValue();
+      return value === null ? null : { kind: "is", name, value, negate };
+    }
+    if (kw("greater")) {
+      i += 1;
+      if (!kw("than")) return fail("expected `than` after `greater` \u2014 the operator is `is greater than`");
+      i += 1;
+      const n = parseNumber("greater than", name);
+      return n === null ? null : wrap({ kind: "cmp", name, op: ">", n });
+    }
+    if (kw("less")) {
+      i += 1;
+      if (!kw("than")) return fail("expected `than` after `less` \u2014 the operator is `is less than`");
+      i += 1;
+      const n = parseNumber("less than", name);
+      return n === null ? null : wrap({ kind: "cmp", name, op: "<", n });
+    }
+    if (kw("at")) {
+      i += 1;
+      const bound = kw("least") ? "least" : kw("most") ? "most" : null;
+      if (bound === null) return fail("expected `least` or `most` after `at` \u2014 the operators are `is at least` / `is at most`");
+      i += 1;
+      const n = parseNumber(`at ${bound}`, name);
+      if (n === null) return null;
+      if (negate) {
+        const positive = bound === "least" ? `is less than ${n}` : `is greater than ${n}`;
+        return fail(`\`is not at ${bound}\` has a positive form \u2014 write \`@{${name}} ${positive}\`.`);
+      }
+      return { kind: "cmp", name, op: bound === "least" ? ">=" : "<=", n };
+    }
+    if (kw("one")) {
+      i += 1;
+      if (!kw("of")) return fail("expected `of` after `one` \u2014 the operator is `is one of`");
+      i += 1;
+      const values = [];
+      const first = parseValue();
+      if (first === null) return null;
+      values.push(first);
+      while (peek()?.t === "comma") {
+        i += 1;
+        const v = parseValue();
+        if (v === null) return null;
+        values.push(v);
+      }
+      return wrap({ kind: "oneOf", name, values });
+    }
+    const vTok = peek();
+    const shown = vTok?.t === "word" ? vTok.v : vTok?.t === "num" ? String(vTok.v) : "\u2026";
+    return fail(`equality is written \`is equal to\` \u2014 write \`@{${name}} is ${negate ? "not " : ""}equal to ${shown}\` (every comparison reads \`is [not] <operator> <operand>\`).`);
+  };
+  const parseUnary = () => {
+    if (kw("not")) {
+      i += 1;
+      const arg = parseUnary();
+      return arg === null ? null : { kind: "not", arg };
+    }
+    return parseAtom();
+  };
+  const parseAnd = () => {
+    let left = parseUnary();
+    if (!left) return null;
+    while (kw("and")) {
+      i += 1;
+      const right = parseUnary();
+      if (!right) return null;
+      left = { kind: "and", left, right };
+    }
+    return left;
+  };
+  function parseOr() {
+    let left = parseAnd();
+    if (!left) return null;
+    while (kw("or")) {
+      i += 1;
+      const right = parseAnd();
+      if (!right) return null;
+      left = { kind: "or", left, right };
+    }
+    return left;
+  }
+  const ast = parseOr();
+  if (error !== null) return { ast: null, error };
+  if (i < toks.length) {
+    const tk = toks[i];
+    const shown = tk === void 0 ? "end" : tk.t === "var" ? `@{${tk.v}}` : tk.t === "legacyvar" ? `$${tk.v}` : "v" in tk ? tk.v : tk.t;
+    return { ast: null, error: `unexpected \`${shown}\`` };
+  }
+  return { ast, error: null };
+}
+var norm = (v) => String(v ?? "").trim().toLowerCase();
+function evalExpr(e, bag) {
+  switch (e.kind) {
+    case "read": {
+      const v = bag[e.name];
+      return v === true || norm(v) === "true";
+    }
+    case "not":
+      return !evalExpr(e.arg, bag);
+    case "and":
+      return evalExpr(e.left, bag) && evalExpr(e.right, bag);
+    case "or":
+      return evalExpr(e.left, bag) || evalExpr(e.right, bag);
+    case "is": {
+      const hit = norm(bag[e.name]) === norm(e.value);
+      return e.negate ? !hit : hit;
+    }
+    case "oneOf": {
+      const v = norm(bag[e.name]);
+      return e.values.some((x) => norm(x) === v);
+    }
+    case "cmp": {
+      const v = Number(bag[e.name]);
+      if (Number.isNaN(v)) return false;
+      return e.op === ">" ? v > e.n : e.op === ">=" ? v >= e.n : e.op === "<" ? v < e.n : v <= e.n;
+    }
+  }
+}
+function exprAtoms(e) {
+  switch (e.kind) {
+    case "read":
+      return [{ name: e.name, test: "bool", values: [] }];
+    case "is":
+      return [{ name: e.name, test: "value", values: [e.value] }];
+    case "oneOf":
+      return [{ name: e.name, test: "value", values: e.values }];
+    case "cmp":
+      return [{ name: e.name, test: "numeric", values: [] }];
+    case "not":
+      return exprAtoms(e.arg);
+    case "and":
+    case "or":
+      return [...exprAtoms(e.left), ...exprAtoms(e.right)];
+  }
+}
+
+// src/core/switch.ts
+var DET_IF = /^(\s*)\$IF\s+([^:]*?)\s*:\s*(.*)$/i;
+var ELSE_IF = /^(\s*)\$ELSE\s+IF\s+([^:]*?)\s*:\s*(.*)$/i;
+var ELSE_A = /^(\s*)\$ELSE\s*:\s*(.*)$/i;
+var PROSE_IF_LEAD = /^\s*IF\b[^:]*:\s*/i;
+var LEGACY_DET_IF = /^(\s*)IF\s+([^:]*(?:\$|@\{)[a-z][a-z0-9_]*[^:]*?)\s*:\s*(.*)$/i;
+var LEGACY_ELSE_IF = /^(\s*)ELSE\s+IF\s+([^:]*?)\s*:\s*(.*)$/i;
+var LEGACY_ELSE = /^(\s*)ELSE\s*:\s*(.*)$/i;
+var NEW_HEADER = /^(\s*)\$SWITCH\s+ON\s+@\{([a-z][a-z0-9_]*)\}\s*$/i;
+var NEW_ARM = /^(\s*)-\s+([A-Za-z][A-Za-z0-9_]*)\s*::\s*(.*)$/;
+var NEW_ARM_ANY = /^(\s*)-\s+(.*?)\s*::\s*(.*)$/;
+var OLD_VALUE_HEADER = /^(\s*)\$SWITCH\s+ON\s+\$([a-z][a-z0-9_]*)\s*:\s*$/i;
+var OLD_TUPLE_HEADER = /^(\s*)\$SWITCH\s+ON\s+(\$[a-z][a-z0-9_]*(?:\s*,\s*\$[a-z][a-z0-9_]*)+)\s*:\s*$/i;
+var OLD_PRED_HEADER = /^(\s*)\$SWITCH\s*:\s*$/i;
+var OLD_CASE_ARM = /^\s*CASE\b\s*(.*?)\s*:\s*(.*)$/i;
+var OLD_ELSE_ARM = /^\s*ELSE\s*:\s*(.*)$/i;
+var ANY_OLD_SWITCH = /^\s*\$SWITCH\b/i;
+var leading = (s) => s.length - s.trimStart().length;
+function andLeaves(e) {
+  return e.kind === "and" ? [...andLeaves(e.left), ...andLeaves(e.right)] : [e];
+}
+function classifyChain(arms, conds) {
+  const caseArms = arms.filter((a) => a.kind === "case");
+  const asPredicate = () => {
+    caseArms.forEach((a) => {
+      a.predicate = a.condition ?? "";
+    });
+    return { kind: "predicate", varName: "" };
+  };
+  if (conds.some((c) => c === null)) return asPredicate();
+  const valueOf = (e) => e.kind === "is" && !e.negate ? { name: e.name, values: [e.value] } : e.kind === "oneOf" ? { name: e.name, values: e.values } : null;
+  const vals = conds.map((c) => valueOf(c));
+  if (vals.every((v) => v !== null) && new Set(vals.map((v) => v.name)).size === 1) {
+    caseArms.forEach((a, i) => {
+      a.values = (vals[i]?.values ?? []).map((v) => v.toLowerCase());
+    });
+    return { kind: "value", varName: vals[0].name };
+  }
+  const rows = conds.map((c) => {
+    const leaves = andLeaves(c);
+    const row = /* @__PURE__ */ new Map();
+    for (const l of leaves) {
+      if (l.kind !== "is" || l.negate || row.has(l.name)) return null;
+      row.set(l.name, l.value.toLowerCase());
+    }
+    return row;
+  });
+  if (rows.every((r) => r !== null)) {
+    const order = [];
+    for (const r of rows) for (const name of r.keys()) if (!order.includes(name)) order.push(name);
+    if (order.length >= 2) {
+      caseArms.forEach((a, i) => {
+        a.patterns = order.map((name) => rows[i].get(name) ?? "_");
+      });
+      return { kind: "tuple", varName: "", varNames: order };
+    }
+  }
+  return asPredicate();
+}
+function composeBlockRewrite(lines, headerLine, blockEnd, varName) {
+  const pad = " ".repeat(leading(lines[headerLine] ?? ""));
+  const out = [`${pad}$SWITCH ON @{${varName}}`];
+  for (let k = headerLine + 1; k < blockEnd; k += 1) {
+    const raw = lines[k] ?? "";
+    if (raw.trim() === "") continue;
+    const em = raw.match(OLD_ELSE_ARM);
+    const cm = em ? null : raw.match(OLD_CASE_ARM);
+    if (em) {
+      out.push(`${pad}  - otherwise::${(em[1] ?? "").trim() !== "" ? ` ${(em[1] ?? "").trim()}` : ""}`);
+      continue;
+    }
+    if (!cm) continue;
+    const members = (cm[1] ?? "").split(",").map((v) => v.trim()).filter((v) => v !== "");
+    if (members.length !== 1 || !/^[A-Za-z][A-Za-z0-9_]*$/.test(members[0] ?? "")) return null;
+    out.push(`${pad}  - ${members[0]}::${(cm[2] ?? "").trim() !== "" ? ` ${(cm[2] ?? "").trim()}` : ""}`);
+  }
+  return out.join("\n");
+}
+function composeChainRewrite(lines, headerLine, blockEnd, kind, varName, varNames) {
+  const pad = " ".repeat(leading(lines[headerLine] ?? ""));
+  const out = [];
+  let first = true;
+  for (let k = headerLine + 1; k < blockEnd; k += 1) {
+    const raw = lines[k] ?? "";
+    if (raw.trim() === "") continue;
+    const em = raw.match(OLD_ELSE_ARM);
+    const cm = em ? null : raw.match(OLD_CASE_ARM);
+    if (em) {
+      out.push(`${pad}$ELSE:${(em[1] ?? "").trim() !== "" ? ` ${(em[1] ?? "").trim()}` : ""}`);
+      continue;
+    }
+    if (!cm) continue;
+    const label = (cm[1] ?? "").trim();
+    const body = (cm[2] ?? "").trim();
+    let cond;
+    if (kind === "value") {
+      const members = label.split(",").map((v) => v.trim()).filter((v) => v !== "");
+      cond = members.length > 1 ? `@{${varName}} is one of ${members.join(", ")}` : `@{${varName}} is equal to ${members[0] ?? ""}`;
+    } else if (kind === "tuple") {
+      const pats = label.split(",").map((v) => v.trim());
+      const parts = pats.map((p, i) => p === "_" || p === "" ? null : `@{${varNames[i] ?? ""}} is equal to ${p}`).filter((p) => p !== null);
+      if (parts.length === 0) {
+        out.push(`${pad}$ELSE:${body !== "" ? ` ${body}` : ""}`);
+        continue;
+      }
+      cond = parts.join(" and ");
+    } else {
+      cond = pointerRewrite(label);
+    }
+    out.push(`${pad}${first ? "$IF" : "$ELSE IF"} ${cond}:${body !== "" ? ` ${body}` : ""}`);
+    first = false;
+  }
+  return out.join("\n");
+}
+function parseSwitches(lines) {
+  const blocks = [];
+  const exMask = examplesMask(lines);
+  const cfgMask = configSectionMask(lines);
+  const toolMask = toolBlockMask(lines);
+  let inFence = false;
+  const skip = lines.map((raw, i2) => {
+    const t = raw.trim();
+    if (t.startsWith("```") || t.startsWith("~~~")) {
+      inFence = !inFence;
+      return true;
+    }
+    return inFence || exMask[i2] === true || cfgMask[i2] === true || toolMask[i2] === true;
+  });
+  let i = 0;
+  while (i < lines.length) {
+    if (skip[i]) {
+      i += 1;
+      continue;
+    }
+    const raw0 = lines[i] ?? "";
+    const nm = raw0.match(NEW_HEADER);
+    if (nm) {
+      const headerIndent = (nm[1] ?? "").length;
+      const varName = (nm[2] ?? "").toLowerCase();
+      const arms = [];
+      let error = null;
+      let errorCode;
+      let armIndent = -1;
+      let k = i + 1;
+      while (k < lines.length) {
+        const raw = lines[k] ?? "";
+        if (raw.trim() === "") {
+          k += 1;
+          continue;
+        }
+        if (skip[k]) break;
+        const lead = leading(raw);
+        if (lead <= headerIndent) break;
+        if (armIndent === -1) armIndent = lead;
+        if (lead > armIndent) {
+          k += 1;
+          continue;
+        }
+        const am = raw.match(NEW_ARM);
+        if (am) {
+          const key = am[2] ?? "";
+          const body = (am[3] ?? "").trim();
+          if (/^otherwise$/i.test(key)) {
+            arms.push({ kind: "else", values: [], headerLine: k, spanEnd: k + 1, inlineBody: body });
+          } else {
+            const member = key.toLowerCase();
+            arms.push({ kind: "case", values: [member], condition: `@{${varName}} is equal to ${member}`, headerLine: k, spanEnd: k + 1, inlineBody: body });
+          }
+          k += 1;
+          continue;
+        }
+        const pm = raw.match(NEW_ARM_ANY);
+        if (pm) {
+          const label = (pm[2] ?? "").trim();
+          const pad = " ".repeat(headerIndent);
+          error ??= `a $SWITCH arm is a MEMBER of @{${varName}}'s domain, never a condition \u2014 "- ${label}::" asks a question, and questions are a chain's job. Write it as a chain:
+${pad}$IF ${/@\{/.test(label) ? label : pointerRewrite(label)}: \u2026
+${pad}$ELSE: \u2026`;
+          errorCode ??= "switch-arm";
+          k += 1;
+          continue;
+        }
+        error ??= `every row under $SWITCH ON is an arm \u2014 "- member:: \u2026" (or "- otherwise:: \u2026"); an arm's body sits on the lines indented beneath its row.`;
+        errorCode ??= "switch-arm";
+        k += 1;
+      }
+      const blockEnd = k;
+      for (let a = 0; a < arms.length; a += 1) {
+        const arm = arms[a];
+        if (arm) arm.spanEnd = arms[a + 1]?.headerLine ?? blockEnd;
+      }
+      if (arms.length === 0) {
+        error ??= 'the $SWITCH ON block has no arms \u2014 add "- member:: \u2026" rows one unit beneath the header.';
+        errorCode ??= "switch-arm";
+      }
+      blocks.push({ kind: "value", form: "block", headerLine: i, blockEnd, indent: headerIndent, varName, arms, error, ...errorCode !== void 0 ? { errorCode } : {} });
+      i = blockEnd;
+      continue;
+    }
+    const om = raw0.match(OLD_VALUE_HEADER);
+    const otm = om ? null : raw0.match(OLD_TUPLE_HEADER);
+    const opm = om || otm ? null : raw0.match(OLD_PRED_HEADER);
+    if (om || otm || opm) {
+      const indent = ((om ?? otm ?? opm)?.[1] ?? "").length;
+      let j = i + 1;
+      while (j < lines.length) {
+        const l = lines[j] ?? "";
+        if (l.trim() !== "" && leading(l) <= indent) break;
+        j += 1;
+      }
+      const kind = om ? "value" : otm ? "tuple" : "predicate";
+      const varName = (om?.[2] ?? "").toLowerCase();
+      const varNames = otm ? (otm[2] ?? "").split(",").map((v) => v.trim().replace(/^\$/, "").toLowerCase()) : [];
+      const blockRewrite = om ? composeBlockRewrite(lines, i, j, varName) : null;
+      const rewrite = blockRewrite ?? composeChainRewrite(lines, i, j, kind, varName, varNames);
+      blocks.push({
+        kind: "predicate",
+        form: "block",
+        headerLine: i,
+        blockEnd: j,
+        indent,
+        varName: "",
+        arms: [],
+        error: blockRewrite !== null ? `the CASE form is retired \u2014 a $SWITCH block's arms are "- member::" rows under a "@{name}" header. Replace the block with:
+${rewrite}` : `this $SWITCH form is retired \u2014 conditions belong to a $IF chain (members-only blocks use "$SWITCH ON @{x}" with "- member::" rows). Replace the block with:
+${rewrite}`
+      });
+      i = j;
+      continue;
+    }
+    if (ANY_OLD_SWITCH.test(raw0)) {
+      blocks.push({ kind: "predicate", form: "block", headerLine: i, blockEnd: i + 1, indent: leading(raw0), varName: "", arms: [], error: `malformed $SWITCH \u2014 the block form is "$SWITCH ON @{x}" (a pointer, no colon) with "- member:: \u2026" arm rows one unit beneath; for conditions, write a $IF chain instead.` });
+      i += 1;
+      continue;
+    }
+    const m = raw0.match(DET_IF);
+    const lm = m ? null : raw0.match(LEGACY_DET_IF);
+    if (m || lm) {
+      const head = m ?? lm;
+      const indent = (head[1] ?? "").length;
+      const legacyArms = lm ? [i] : [];
+      const arms = [{ kind: "case", values: [], condition: (head[2] ?? "").trim(), headerLine: i, spanEnd: i + 1, inlineBody: (head[3] ?? "").trim() }];
+      let error = null;
+      let k = i + 1;
+      while (k < lines.length) {
+        const raw = lines[k] ?? "";
+        if (raw.trim() === "") {
+          k += 1;
+          continue;
+        }
+        if (skip[k]) break;
+        const lead = leading(raw);
+        if (lead > indent) {
+          if (DET_IF.test(raw) || LEGACY_DET_IF.test(raw)) error ??= "a nested deterministic $IF is not supported \u2014 combine the conditions with `and`, or lift the inner chain out.";
+          k += 1;
+          continue;
+        }
+        if (lead < indent) break;
+        const eim = raw.match(ELSE_IF);
+        const lei = eim ? null : raw.match(LEGACY_ELSE_IF);
+        const em = eim ?? lei ? null : raw.match(ELSE_A);
+        const lem = eim ?? lei ?? em ? null : raw.match(LEGACY_ELSE);
+        if (eim || lei) {
+          const am = eim ?? lei;
+          const cond = (am[2] ?? "").trim();
+          if (lei) legacyArms.push(k);
+          if (!/@\{[a-z]|\$[a-z]/i.test(cond)) error ??= `$ELSE IF binds to the deterministic plane \u2014 its condition must read a @{variable} pointer (found "${cond}"). For a prose alternative, write it as its own sentence.`;
+          arms.push({ kind: "case", values: [], condition: cond, headerLine: k, spanEnd: k + 1, inlineBody: (am[3] ?? "").trim() });
+          k += 1;
+          continue;
+        }
+        if (em || lem) {
+          const am = em ?? lem;
+          if (lem) legacyArms.push(k);
+          arms.push({ kind: "else", values: [], headerLine: k, spanEnd: k + 1, inlineBody: (am[2] ?? "").trim() });
+          k += 1;
+          continue;
+        }
+        break;
+      }
+      const blockEnd = k;
+      for (let a = 0; a < arms.length; a += 1) {
+        const arm = arms[a];
+        if (arm) arm.spanEnd = arms[a + 1]?.headerLine ?? blockEnd;
+      }
+      if (legacyArms.length > 0) {
+        const pad = " ".repeat(indent);
+        const rewritten = arms.map(
+          (a, ix) => a.kind === "else" ? `${pad}$ELSE:${a.inlineBody !== "" ? ` ${a.inlineBody}` : ""}` : `${pad}${ix === 0 ? "$IF" : "$ELSE IF"} ${pointerRewrite(a.condition ?? "")}:${a.inlineBody !== "" ? ` ${a.inlineBody}` : ""}`
+        ).join("\n");
+        error = `a deterministic chain leads with $ \u2014 the arms are commands ($IF / $ELSE IF / $ELSE), and a variable in a condition is a @{name} pointer. Replace the arm lines with:
+${rewritten}`;
+      }
+      const conds = arms.filter((a) => a.kind === "case").map((a) => parseExpr(a.condition ?? "").ast);
+      const cls = classifyChain(arms, conds);
+      blocks.push({ kind: cls.kind, form: "chain", headerLine: i, blockEnd, indent, varName: cls.varName, ...cls.varNames !== void 0 ? { varNames: cls.varNames } : {}, arms, error });
+      i = blockEnd;
+      continue;
+    }
+    const strayElseIf = raw0.match(ELSE_IF) ?? raw0.match(LEGACY_ELSE_IF);
+    const strayElse = strayElseIf ? null : raw0.match(ELSE_A) ?? raw0.match(LEGACY_ELSE);
+    if (strayElseIf || strayElse) {
+      let p = i - 1;
+      while (p >= 0 && ((lines[p] ?? "").trim() === "" || leading(lines[p] ?? "") > leading(raw0) || /^\s*(?:[-*+]|\d+[.)])\s/.test(lines[p] ?? ""))) p -= 1;
+      const prev = lines[p] ?? "";
+      const afterProseIf = PROSE_IF_LEAD.test(prev) && !DET_IF.test(prev) && !LEGACY_DET_IF.test(prev);
+      blocks.push({
+        kind: "predicate",
+        form: "chain",
+        headerLine: i,
+        blockEnd: i + 1,
+        indent: leading(raw0),
+        varName: "",
+        arms: [],
+        error: afterProseIf ? `$ELSE binds to a deterministic $IF \u2014 the IF above is prose, so the model weighs it. Write the alternative as prose (e.g. lead with OTHERWISE), or make the chain deterministic: lead it with $IF and read a @{variable} pointer in the condition.` : `$ELSE without a deterministic $IF above it at the same column \u2014 a chain reads $IF @{x} \u2026: / $ELSE IF \u2026: / $ELSE:.`
+      });
+      i += 1;
+      continue;
+    }
+    if (OLD_CASE_ARM.test(raw0) && /^\s*CASE\b/i.test(raw0)) {
+      blocks.push({ kind: "predicate", form: "block", headerLine: i, blockEnd: i + 1, indent: leading(raw0), varName: "", arms: [], error: `CASE is retired \u2014 a $SWITCH block's arms are "- member:: \u2026" rows (or write a $IF chain: "$IF @{x} is equal to <value>: \u2026").` });
+      i += 1;
+      continue;
+    }
+    i += 1;
+  }
+  return blocks;
+}
+function selectArm(block, value) {
+  const v = value.trim().toLowerCase();
+  return block.arms.find((a) => a.kind === "case" && a.values.includes(v)) ?? block.arms.find((a) => a.kind === "else") ?? null;
+}
+function selectPredicateArm(block, test) {
+  for (const a of block.arms) {
+    if (a.kind === "else") return a;
+    if (a.predicate !== void 0 && test(a.predicate)) return a;
+  }
+  return null;
+}
+function selectTupleArm(block, values) {
+  const v = values.map((x) => x.trim().toLowerCase());
+  const match = block.arms.find(
+    (a) => a.kind === "case" && a.patterns !== void 0 && a.patterns.length === v.length && a.patterns.every((p, i) => p === "_" || p === v[i])
+  );
+  return match ?? block.arms.find((a) => a.kind === "else") ?? null;
+}
+var INLINE_SWITCH = /\$SWITCH\s+ON\s+\$([a-z][a-z0-9_]*)\s*\(([^)]*)\)/gi;
+function parseInlineCases(body) {
+  const cases = [];
+  let error = null;
+  for (const seg of body.split("|")) {
+    if (seg.trim() === "") continue;
+    const colon = seg.indexOf(":");
+    if (colon < 0) {
+      error ??= "each arm needs a `value: fragment`.";
+      continue;
+    }
+    const label = seg.slice(0, colon).trim();
+    const frag = seg.slice(colon + 1).trim();
+    if (label === "_" || /^else$/i.test(label)) {
+      cases.push({ values: [], isDefault: true, frag });
+      continue;
+    }
+    const values = label.split(",").map((v) => v.trim().toLowerCase()).filter((v) => v !== "");
+    if (values.length === 0) {
+      error ??= "an arm has no value before its colon.";
+      continue;
+    }
+    cases.push({ values, isDefault: false, frag });
+  }
+  if (cases.length === 0) error ??= "the inline $SWITCH has no arms.";
+  return { cases, error };
+}
+function parseInlineSwitches(lines) {
+  const out = [];
+  lines.forEach((line, i) => {
+    for (const m of line.matchAll(INLINE_SWITCH)) {
+      const { cases, error } = parseInlineCases(m[2] ?? "");
+      const start = m.index ?? 0;
+      out.push({ line: i, start, end: start + m[0].length, varName: (m[1] ?? "").toLowerCase(), cases, error });
+    }
+  });
+  return out;
+}
+function resolveInlineText(text, pick) {
+  return text.replace(INLINE_SWITCH, (whole, varName, body) => {
+    const { cases, error } = parseInlineCases(body);
+    if (error !== null) return whole;
+    const v = pick(String(varName).toLowerCase()).trim().toLowerCase();
+    const arm = cases.find((c) => !c.isDefault && c.values.includes(v)) ?? cases.find((c) => c.isDefault) ?? null;
+    return arm ? arm.frag : "";
+  });
+}
+function maskInlineSwitches(source) {
+  return source.replace(INLINE_SWITCH, (m) => " ".repeat(m.length));
+}
+function joinOr(values) {
+  if (values.length <= 1) return values[0] ?? "";
+  return `${values.slice(0, -1).join(", ")} or ${values[values.length - 1]}`;
+}
+function conditionPhrase(_block, arm) {
+  if (arm.kind === "else") return "Otherwise";
+  const smoothed = (arm.condition ?? arm.predicate ?? "").replace(/@\{([a-z][a-z0-9_]*)\}/gi, "$1").replace(/\$/g, "").trim().replace(/\bis\s+not\s+equal\s+to\s+/gi, "is not ").replace(/\bis\s+equal\s+to\s+/gi, "is ").replace(/\bis\s+one\s+of\s+((?:[a-z0-9_-]+\s*,\s*)*[a-z0-9_-]+)/gi, (_m, list) => `is ${joinOr(list.split(",").map((v) => v.trim()).filter((v) => v !== ""))}`);
+  return `If ${smoothed}`;
+}
+function switchBlockMask(lines) {
+  const mask = new Array(lines.length).fill(false);
+  for (const block of parseSwitches(lines)) {
+    if (block.error !== null) continue;
+    for (let l = block.headerLine; l < block.blockEnd && l < mask.length; l += 1) mask[l] = true;
+  }
+  return mask;
+}
+function switchProseRewrite(lines) {
+  const rw = /* @__PURE__ */ new Map();
+  for (const block of parseSwitches(lines)) {
+    if (block.error !== null) continue;
+    const pad = " ".repeat(block.indent);
+    for (let l = block.headerLine; l < block.blockEnd; l += 1) rw.set(l, null);
+    for (const arm of block.arms) {
+      const cond = conditionPhrase(block, arm);
+      rw.set(arm.headerLine, arm.inlineBody !== "" ? `${pad}${cond}: ${arm.inlineBody}` : `${pad}${cond}:`);
+      const bodyLines = [];
+      for (let l = arm.headerLine + 1; l < arm.spanEnd; l += 1) bodyLines.push(l);
+      const nonBlank = bodyLines.filter((l) => (lines[l] ?? "").trim() !== "");
+      if (nonBlank.length === 0) continue;
+      const base = Math.min(...nonBlank.map((l) => leading(lines[l] ?? "")));
+      for (const l of bodyLines) {
+        const raw = lines[l] ?? "";
+        if (raw.trim() === "") {
+          rw.set(l, "");
+          continue;
+        }
+        rw.set(l, " ".repeat(block.indent + 2 + Math.max(0, leading(raw) - base)) + raw.trimStart());
+      }
+    }
+  }
+  return rw;
+}
+function expandInlineToProse(text) {
+  return text.replace(INLINE_SWITCH, (whole, _v, body) => {
+    const { cases, error } = parseInlineCases(body);
+    if (error !== null) return whole;
+    const arm = cases.find((c) => c.isDefault) ?? cases[0];
+    return arm ? arm.frag : "";
+  });
+}
+
+// src/core/type-system.ts
+var PRIM_TYPES = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean"]);
+var PLURAL_PRIMS = { strings: "string", numbers: "number", integers: "integer", booleans: "boolean" };
+var PRIM_SYNONYMS = { bool: "boolean", int: "integer", text: "string" };
+var MEMBER_RE = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+var QUANT_RE = /^(one|any)\s+of\s+(.+)$/i;
+var LIST_RE = /^list\s+of\s+(\S+)$/i;
+function parseMembers(quant, tail) {
+  const members = tail.split(",").map((m) => m.trim()).filter((m) => m !== "");
+  if (members.length < 2) return { reason: `"${quant} of" declares a closed set \u2014 it needs at least two comma-separated members.` };
+  const bad = members.find((m) => !MEMBER_RE.test(m));
+  if (bad !== void 0) return { reason: `"${bad}" is not a valid set member \u2014 members are bare names (letters, digits, _ or -); the description sits after a ":".` };
+  const dup = members.find((m, i) => members.findIndex((x) => x.toLowerCase() === m.toLowerCase()) !== i);
+  if (dup !== void 0) return { reason: `"${dup}" is listed twice in the ${quant} of set.` };
+  return { members };
+}
+function typeIntended(text) {
+  const t = text.trim();
+  if (QUANT_RE.test(t) || /^list\s+of\b/i.test(t) || /^optional\b/i.test(t)) return true;
+  const first = (t.split(/[\s,]/, 1)[0] ?? "").toLowerCase();
+  if (PRIM_TYPES.has(first) || first in PRIM_SYNONYMS) return true;
+  const segs = t.split(",").map((s) => s.trim());
+  return segs.length >= 2 && segs.every((s) => MEMBER_RE.test(s));
+}
+var REFINEMENT_KEYWORDS = ["BETWEEN", "AT LEAST", "AT MOST", "UP TO", "MATCHING"];
+var REFINE_HEAD = new RegExp(`^(${REFINEMENT_KEYWORDS.map((k) => k.toLowerCase().replace(/ /g, "\\s+")).join("|")})\\b`, "i");
+var NUM = String.raw`(-?\d+(?:\.\d+)?)`;
+function parseRefinement(prim, tail) {
+  const raw = tail.trim();
+  if (!REFINE_HEAD.test(raw)) return null;
+  if (prim === "boolean") return { reason: `boolean takes no constraint \u2014 drop "${raw}".` };
+  const mm = raw.match(/^matching\s+\/(.+)\/$/i);
+  if (mm) {
+    if (prim !== "string") return { reason: `"matching" applies to string, not ${prim}.` };
+    try {
+      new RegExp(mm[1]);
+    } catch {
+      return { reason: `"/${mm[1]}/" is not a valid regular expression.` };
+    }
+    return { refine: { pattern: mm[1] } };
+  }
+  if (/^matching\b/i.test(raw)) return { reason: `"matching" takes a /regex/ \u2014 e.g. matching /^[a-z]+$/.` };
+  const isLen = /\bcharacters?\b/i.test(raw);
+  if (isLen && prim !== "string") return { reason: `a character-length constraint applies to string, not ${prim}.` };
+  if (!isLen && prim === "string") return { reason: `a numeric range applies to number|integer; for string, add "characters" or use a pattern.` };
+  const body = raw.replace(/\s+characters?\s*$/i, "").trim();
+  let m;
+  let bounds = null;
+  if (m = body.match(new RegExp(`^between\\s+${NUM}\\s+and\\s+${NUM}$`, "i"))) {
+    const lo = Number(m[1]);
+    const hi = Number(m[2]);
+    if (lo > hi) return { reason: `the lower bound (${lo}) is above the upper (${hi}).` };
+    bounds = { min: lo, max: hi };
+  } else if (m = body.match(new RegExp(`^at\\s+least\\s+${NUM}$`, "i"))) bounds = { min: Number(m[1]) };
+  else if (m = body.match(new RegExp(`^at\\s+most\\s+${NUM}$`, "i"))) bounds = { max: Number(m[1]) };
+  else if (m = body.match(new RegExp(`^up\\s+to\\s+${NUM}$`, "i"))) bounds = { max: Number(m[1]) };
+  if (!bounds) return { reason: `"${raw}" isn't a recognized ${prim} constraint \u2014 try "between A and B", "at least N", "at most N"${prim === "string" ? ', "up to N characters"' : ""}.` };
+  const key = isLen ? ["minLen", "maxLen"] : ["min", "max"];
+  const refine = {};
+  if (bounds.min !== void 0) refine[key[0]] = bounds.min;
+  if (bounds.max !== void 0) refine[key[1]] = bounds.max;
+  return { refine };
+}
+function parseTypeExpr(text) {
+  const t = text.trim();
+  if (t === "") return null;
+  const q = t.match(QUANT_RE);
+  if (q) {
+    const quant = (q[1] ?? "one").toLowerCase();
+    const r = parseMembers(quant, q[2] ?? "");
+    if ("reason" in r) return { ok: false, ...r };
+    return { ok: true, expr: quant === "one" ? { kind: "oneOf", members: r.members } : { kind: "anyOf", members: r.members } };
+  }
+  const l = t.match(LIST_RE);
+  if (l) {
+    const unit = (l[1] ?? "").toLowerCase();
+    const prim = PLURAL_PRIMS[unit];
+    if (prim) return { ok: true, expr: { kind: "list", prim } };
+    if (PRIM_TYPES.has(unit)) return { ok: false, reason: `"list of" takes a plural base type.`, rewrite: `list of ${unit}s` };
+    return { ok: false, reason: `"list of ${l[1] ?? ""}" is not a type \u2014 the base types are strings, numbers, integers, booleans.` };
+  }
+  if (/^list\s+of\b/i.test(t)) return { ok: false, reason: `"list of" takes exactly one plural base type: strings, numbers, integers, or booleans.` };
+  const low = t.toLowerCase();
+  const primHead = t.match(/^(string|number|integer|boolean)\b\s*(.*)$/i);
+  if (primHead) {
+    const prim = primHead[1].toLowerCase();
+    const rest = (primHead[2] ?? "").trim();
+    if (rest === "") return { ok: true, expr: { kind: "prim", prim } };
+    const ref = parseRefinement(prim, rest);
+    if (ref === null) return null;
+    if ("reason" in ref) return { ok: false, reason: ref.reason };
+    return { ok: true, expr: { kind: "prim", prim, refine: ref.refine } };
+  }
+  const syn = PRIM_SYNONYMS[low];
+  if (syn) return { ok: false, reason: `"${t}" is not a canonical type \u2014 TypeGlish has one spelling per type.`, rewrite: syn };
+  const segs = t.split(",").map((s) => s.trim());
+  if (segs.length >= 2 && segs.every((s) => MEMBER_RE.test(s))) {
+    return {
+      ok: false,
+      reason: `"${t}" doesn't say whether to pick one or many \u2014 write "one of ${segs.join(", ")}" (exactly one) or "any of ${segs.join(", ")}" (one or more).`,
+      rewrite: `one of ${segs.join(", ")}`
+    };
+  }
+  return null;
+}
+function translateLegacyTypeHead(head) {
+  const t = head.trim();
+  const arr = t.match(/^(string|number|integer|boolean)\[\]$/);
+  if (arr) return `list of ${arr[1]}s`;
+  const dflt = t.match(/^(string|number|integer|boolean)\s*=\s*(\S.*?)$/);
+  if (dflt) return `${dflt[1]} default to ${(dflt[2] ?? "").trim()}`;
+  if (t.includes("|")) {
+    const members = t.split("|").map((m) => m.trim()).filter((m) => m !== "");
+    if (members.length >= 2) return `one of ${members.join(", ")}`;
+  }
+  const syn = PRIM_SYNONYMS[t.toLowerCase()];
+  if (syn) return syn;
+  return null;
+}
+function renderRefine(r) {
+  if (r.pattern !== void 0) return `matching /${r.pattern}/`;
+  if (r.minLen !== void 0 && r.maxLen !== void 0) return `between ${r.minLen} and ${r.maxLen} characters`;
+  if (r.minLen !== void 0) return `at least ${r.minLen} characters`;
+  if (r.maxLen !== void 0) return `up to ${r.maxLen} characters`;
+  if (r.min !== void 0 && r.max !== void 0) return `between ${r.min} and ${r.max}`;
+  if (r.min !== void 0) return `at least ${r.min}`;
+  if (r.max !== void 0) return `at most ${r.max}`;
+  return "";
+}
+function renderTypeExpr(e) {
+  switch (e.kind) {
+    case "prim":
+      return e.refine ? `${e.prim} ${renderRefine(e.refine)}` : e.prim;
+    case "list":
+      return `list of ${e.prim}s`;
+    case "oneOf":
+      return `one of ${e.members.join(", ")}`;
+    case "anyOf":
+      return `any of ${e.members.join(", ")}`;
+  }
+}
+
+// src/core/tool.ts
+var TOOL_KEYS = /* @__PURE__ */ new Set(["description", "input", "request", "headers"]);
+var SERVICE_KEYS = /* @__PURE__ */ new Set(["base", "headers"]);
+var FIELD_RE = /^(\s+)-\s+([a-z][a-z0-9_-]*)::\s*(.*)$/;
+var PARAM_RE = /^-\s+([a-z][a-z0-9_]*)(\?)?::\s*(.*)$/;
+var HEADER_RE = /^-\s+([A-Za-z0-9-]+)::\s*(\S.*?)\s*$/;
+var LEGACY_FIELD_RE = /^\s*(?:[-*+]\s+)?([A-Za-z][\w-]*)(\??):(?!:)\s*(.*)$/;
+var BARE_FIELD_RE = /^\s*([A-Za-z][\w-]*)(\??)::\s*(.*)$/;
+var BINDING_ABS_RE = /^(GET|POST|PUT|PATCH|DELETE)\s+(https?:\/\/\S+)$/;
+var BINDING_SVC_RE = /^(GET|POST|PUT|PATCH|DELETE)\s+([a-z][a-z0-9_]*)\s+(\/\S*)$/;
+var OPTIONAL_LEAD_RE = /^optional\b\s*/i;
+var DEFAULT_TAIL_RE = /\s+default\s+to\s+(\S.*)$/i;
+var BAD_DEFAULT_TAIL_RE = /\s+(?:=\s*(\S.*)|defaults\s+to\s+(\S.*)|default\s+(?!to\b)(\S.*))$/i;
+var PLACEHOLDER_RE = /@\{([A-Za-z][A-Za-z0-9_.]*)\}/g;
+var LEGACY_PLACEHOLDER_RE = /(?<!@)\{([A-Za-z][A-Za-z0-9_.]*)\}/g;
+var SECRET_RE = /\b(?:sk-[A-Za-z0-9_-]{10,}|ghp_[A-Za-z0-9]{20,}|xoxb-[A-Za-z0-9-]{10,}|AKIA[0-9A-Z]{16})\b|^Bearer\s+[A-Za-z0-9._~+/=-]{20,}$/;
+function scanBlocks(rawLines, decl) {
+  const blocks = [];
+  let inFence = false;
+  for (let i = 0; i < rawLines.length; i += 1) {
+    const trimmed = (rawLines[i] ?? "").trim();
+    if (trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
+      inFence = !inFence;
+      continue;
+    }
+    const m = inFence ? null : (rawLines[i] ?? "").match(decl);
+    if (!m) continue;
+    const headerIndent = ((rawLines[i] ?? "").match(/^[ \t]*/) ?? [""])[0].length;
+    const body = [];
+    for (let j = i + 1; j < rawLines.length; j += 1) {
+      const line = rawLines[j] ?? "";
+      if (line.trim() === "") continue;
+      if ((line.match(/^[ \t]*/) ?? [""])[0].length <= headerIndent) break;
+      body.push({ raw: line, line: j });
+    }
+    blocks.push({ name: (m[1] ?? "").toLowerCase(), line: i, body });
+    if (body.length > 0) i = body[body.length - 1]?.line ?? i;
+  }
+  return blocks;
+}
+function rewriteRow(key, opt, value) {
+  const translated = translateLegacyValue(value.trim()) ?? value.trim();
+  const v = opt === "?" && translated !== "" ? `optional ${translated}` : opt === "?" ? "optional" : translated;
+  const row = `- ${key}:: ${v}`.trimEnd();
+  return /[.!?:]["')\]]*$/.test(row) ? row : `${row}.`;
+}
+function translateLegacyValue(value) {
+  const comma = value.indexOf(",");
+  const head = stripPunct(comma >= 0 ? value.slice(0, comma) : value);
+  const desc = comma >= 0 ? value.slice(comma + 1).trim() : "";
+  let newHead = translateLegacyTypeHead(head);
+  if (newHead === null && desc !== "" && parseTypeExpr(head)?.ok) newHead = head;
+  if (newHead === null) return null;
+  return desc !== "" ? `${newHead}: ${desc}` : newHead;
+}
+function composeValue(optional, head, dflt, desc) {
+  const type = `${optional ? "optional " : ""}${head}${dflt !== null && dflt !== "" ? ` default to ${dflt}` : ""}`.trim();
+  return desc !== "" ? `${type}: ${desc}` : type;
+}
+function buildParam(expr, dfltRaw, desc) {
+  const base = expr.kind === "prim" ? { type: expr.prim } : expr.kind === "list" ? { type: expr.prim, array: true } : expr.kind === "oneOf" ? { type: "string", enum: expr.members } : { type: "string", array: true, enum: expr.members };
+  if (dfltRaw !== null) {
+    if (expr.kind === "list" || expr.kind === "anyOf") return { reason: `"default to" doesn't apply to a list \u2014 a default is one value.` };
+    const raw = dfltRaw.trim().replace(/^["']|["']$/g, "");
+    if (expr.kind === "prim" && (expr.prim === "number" || expr.prim === "integer")) {
+      const n = Number(raw);
+      if (Number.isNaN(n)) return { reason: `"default to ${raw}" isn't a number \u2014 if a description follows the default, it sits after ":", never a comma.` };
+      base.default = n;
+    } else if (expr.kind === "prim" && expr.prim === "boolean") {
+      if (raw !== "true" && raw !== "false") return { reason: `"default to ${raw}" isn't a boolean \u2014 write true or false.` };
+      base.default = raw === "true";
+    } else if (expr.kind === "oneOf") {
+      if (!expr.members.includes(raw)) return { reason: `"default to ${raw}" isn't a member of the set (${expr.members.join(", ")}).` };
+      base.default = raw;
+    } else {
+      base.default = raw;
+    }
+  }
+  if (desc !== "") base.description = desc;
+  return base;
+}
+function shapedChildren(children, proseSafe) {
+  const out = [];
+  for (const c of children) {
+    const bare = c.text.match(BARE_FIELD_RE);
+    const legacy = c.text.match(LEGACY_FIELD_RE);
+    if (bare) out.push({ line: c.line, rewrite: rewriteRow(bare[1] ?? "", bare[2] ?? "", bare[3] ?? "") });
+    else if (legacy && (!proseSafe || legacy[2] === "?")) out.push({ line: c.line, rewrite: rewriteRow(legacy[1] ?? "", legacy[2] ?? "", legacy[3] ?? "") });
+  }
+  return out;
+}
+function scanFields(block) {
+  const bodyIndent = (block.body[0]?.raw.match(/^[ \t]+/)?.[0] ?? "").length;
+  const fields = [];
+  for (const b of block.body) {
+    if (b.raw.trim().startsWith("//")) continue;
+    const indent = (b.raw.match(/^[ \t]+/)?.[0] ?? "").length;
+    if (indent === bodyIndent) {
+      const f = b.raw.match(FIELD_RE);
+      if (f) fields.push({ key: (f[2] ?? "").toLowerCase(), value: (f[3] ?? "").trim(), line: b.line, children: [] });
+      else fields.push({ key: "", value: b.raw.trim(), line: b.line, children: [] });
+    } else if (fields.length > 0) {
+      fields[fields.length - 1]?.children.push({ text: b.raw.trim(), line: b.line });
+    } else {
+      fields.push({ key: "", value: b.raw.trim(), line: b.line, children: [] });
+    }
+  }
+  return fields;
+}
+function parseParamValue(value) {
+  const v = value.trim();
+  if (v === "") return { ok: true, param: { type: "string" }, optional: false };
+  const legacy = translateLegacyValue(v);
+  if (legacy !== null) {
+    const reason = v.includes("|") ? `Closed sets are English \u2014 "one of a, b" (pick one) or "any of a, b" (pick many) \u2014 never "|" pipes.` : /\[\]/.test(v) ? `Arrays are English \u2014 "list of strings" (numbers, integers, booleans) \u2014 never "[]".` : /=/.test(v) ? `Defaults are English \u2014 "default to <value>" \u2014 never "=".` : /^(bool|int|text)\b/i.test(v) ? `TypeGlish has one spelling per type \u2014 string, number, integer, boolean.` : `The type and the description are separated by ":" \u2014 commas belong to lists and prose.`;
+    return { ok: false, reason, value: legacy };
+  }
+  const ci = v.indexOf(":");
+  const rawHead = ci >= 0 ? v.slice(0, ci) : v;
+  const desc = ci >= 0 ? v.slice(ci + 1).trim() : "";
+  let head = ci >= 0 ? rawHead.trim() : stripPunct(rawHead);
+  const optional = OPTIONAL_LEAD_RE.test(head);
+  if (optional) head = head.replace(OPTIONAL_LEAD_RE, "").trim();
+  let dflt = null;
+  const dm = head.match(DEFAULT_TAIL_RE);
+  if (dm) {
+    dflt = (dm[1] ?? "").trim();
+    head = head.slice(0, dm.index).trim();
+  } else {
+    const bad = head.match(BAD_DEFAULT_TAIL_RE);
+    if (bad) {
+      const dv = (bad[1] ?? bad[2] ?? bad[3] ?? "").trim();
+      return { ok: false, reason: `Defaults are written "default to ${dv}" \u2014 one canonical form, like "one of" and "at least".`, value: composeValue(optional, head.slice(0, bad.index).trim(), dv, desc) };
+    }
+  }
+  const parsed = head === "" ? null : parseTypeExpr(head);
+  if (parsed?.ok) {
+    const built = buildParam(parsed.expr, dflt, desc);
+    if ("reason" in built) return { ok: false, reason: built.reason };
+    return { ok: true, param: built, optional };
+  }
+  if (parsed && !parsed.ok) {
+    return { ok: false, reason: parsed.reason, ...parsed.rewrite !== void 0 ? { value: composeValue(optional, parsed.rewrite, dflt, desc) } : {} };
+  }
+  if (head === "" && (optional || dflt !== null)) {
+    const built = buildParam({ kind: "prim", prim: "string" }, dflt, desc);
+    if ("reason" in built) return { ok: false, reason: built.reason };
+    return { ok: true, param: built, optional: true };
+  }
+  if (optional && head !== "" || dflt !== null || typeIntended(head)) {
+    return {
+      ok: false,
+      reason: `"${head}" is not a type expression. The forms: string, number, integer, boolean, "list of strings", "one of a, b", "any of a, b", "optional <type>", "<type> default to <value>". If this is prose, reword it so it doesn't open with a type keyword.`
+    };
+  }
+  return { ok: true, param: { type: "string", description: v }, optional: false };
+}
+function checkPlaceholders(text, line, allowedParams, where, flag) {
+  PLACEHOLDER_RE.lastIndex = 0;
+  let m;
+  while ((m = PLACEHOLDER_RE.exec(text)) !== null) {
+    const key = (m[1] ?? "").toLowerCase();
+    if (key.startsWith("env.")) continue;
+    if (allowedParams?.has(key)) continue;
+    flag(
+      line,
+      allowedParams === null ? `@{${m[1]}} in ${where} \u2014 a $SERVICE is shared by many tools, so its values may only use @{env.NAME}.` : `@{${m[1]}} in ${where} isn't a declared parameter \u2014 declare it under input:, or use @{env.NAME} for environment values.`,
+      "dangling-binding-param",
+      "error"
+    );
+  }
+  LEGACY_PLACEHOLDER_RE.lastIndex = 0;
+  while ((m = LEGACY_PLACEHOLDER_RE.exec(text)) !== null) {
+    flag(
+      line,
+      `A binding placeholder is a pointer \u2014 \`@{${m[1]}}\`, never \`{${m[1]}}\`. Rewrite the value as: "${text.replace(LEGACY_PLACEHOLDER_RE, "@{$1}").trim()}".`,
+      "malformed-binding",
+      "error"
+    );
+    break;
+  }
+}
+function parseServices(rawLines) {
+  const services = [];
+  const conflicts = [];
+  const flag = (line, message, code, severity) => {
+    conflicts.push({ lines: [line], message, code, severity });
+  };
+  for (const block of scanBlocks(rawLines, SERVICE_DECL_RE)) {
+    if (block.body.length === 0) {
+      flag(block.line, `$SERVICE ${block.name} has no body \u2014 indent its fields (base::, headers::) beneath it.`, "empty-service", "error");
+      continue;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    let base = "";
+    const headers = [];
+    for (const f of scanFields(block)) {
+      if (f.key === "") {
+        {
+          const legacy = f.value.match(LEGACY_FIELD_RE);
+          const bare = f.value.match(BARE_FIELD_RE);
+          flag(
+            f.line,
+            legacy ? `Tool fields use the definition marker "::" with a leading bullet, never a single colon. Replace this line with: "${rewriteRow(legacy[1] ?? "", legacy[2] ?? "", legacy[3] ?? "")}".` : bare ? `Every tool field is a bullet row (the bullets are the compiled schema's nesting). Replace this line with: "${rewriteRow(bare[1] ?? "", bare[2] ?? "", bare[3] ?? "")}".` : `This line isn't a field of $SERVICE ${block.name}. A field is "- key:: value" (keys: base, headers). Found: "${f.value.slice(0, 60)}".`,
+            "malformed-service",
+            "error"
+          );
+          for (const kid of shapedChildren(f.children, false)) {
+            flag(kid.line, `Unreachable \u2014 it sits under the malformed field above. After fixing that line, write this one as: "${kid.rewrite}".`, "malformed-service", "error");
+          }
+        }
+        continue;
+      }
+      if (seen.has(f.key)) {
+        flag(f.line, `Duplicate "${f.key}::" in $SERVICE ${block.name} \u2014 one per service.`, "duplicate-key", "error");
+        continue;
+      }
+      seen.add(f.key);
+      if (!SERVICE_KEYS.has(f.key)) {
+        flag(f.line, `Unknown key "${f.key}::" in $SERVICE ${block.name} \u2014 known keys: base, headers.`, "unknown-service-key", "warn");
+      } else if (f.key === "base") {
+        const baseValue = stripPunct(f.value);
+        if (/^https?:\/\/\S+$/.test(baseValue)) {
+          base = baseValue.replace(/\/+$/, "");
+          checkPlaceholders(base, f.line, null, `$SERVICE ${block.name}'s base`, flag);
+        } else {
+          flag(f.line, `Malformed base in $SERVICE ${block.name} \u2014 the value must be an absolute URL. Replace this line with the form: "- base:: https://api.example.com".`, "malformed-service", "error");
+        }
+      } else {
+        for (const c of f.children) {
+          const hm = c.text.match(HEADER_RE);
+          if (!hm) {
+            flag(c.line, `This isn't a header. A header is "- Header-Name:: value". Found: "${c.text.slice(0, 60)}".`, "malformed-header", "error");
+            continue;
+          }
+          headers.push({ name: hm[1] ?? "", value: stripPunct(hm[2] ?? ""), line: c.line });
+          checkPlaceholders(hm[2] ?? "", c.line, null, `$SERVICE ${block.name}'s headers`, flag);
+          if (!/\{env\./.test(hm[2] ?? "") && SECRET_RE.test(hm[2] ?? "")) {
+            flag(c.line, `This looks like a credential literal \u2014 never put secrets in the file; use @{env.NAME} instead.`, "secret-literal", "warn");
+          }
+        }
+      }
+    }
+    if (base === "") {
+      flag(block.line, `$SERVICE ${block.name} has no base \u2014 add a base field beneath it, like: "- base:: https://api.example.com".`, "service-no-base", "error");
+      continue;
+    }
+    services.push({ name: block.name, base, headers: headers.map((h) => ({ name: h.name, value: h.value })), line: block.line });
+  }
+  const byName = /* @__PURE__ */ new Map();
+  for (const s of services) {
+    const list = byName.get(s.name) ?? [];
+    list.push(s);
+    byName.set(s.name, list);
+  }
+  for (const [dup, list] of byName) {
+    if (list.length > 1) conflicts.push({ lines: list.map((s) => s.line), message: `$SERVICE ${dup} is defined ${list.length} times.`, code: "duplicate-service", severity: "error" });
+  }
+  return { services, conflicts };
+}
+function parseTools(rawLines) {
+  const svc = parseServices(rawLines);
+  const services = new Map(svc.services.map((s) => [s.name, s]));
+  const usedServices = /* @__PURE__ */ new Set();
+  const tools = [];
+  const conflicts = [...svc.conflicts];
+  const flag = (line, message, code, severity) => {
+    conflicts.push({ lines: [line], message, code, severity });
+  };
+  for (const block of scanBlocks(rawLines, TOOL_DECL_RE)) {
+    const name = block.name;
+    if (block.body.length === 0) {
+      flag(block.line, `$TOOL ${name} has no body \u2014 indent its fields (description::, input::, request::) beneath it.`, "empty-tool", "error");
+      tools.push({ name, description: "", params: [], line: block.line });
+      continue;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const descParts = [];
+    const params = [];
+    let binding;
+    const headers = [];
+    for (const f of scanFields(block)) {
+      if (f.key === "") {
+        {
+          const legacy = f.value.match(LEGACY_FIELD_RE);
+          const bare = f.value.match(BARE_FIELD_RE);
+          flag(
+            f.line,
+            legacy ? `Tool fields use the definition marker "::" with a leading bullet, never a single colon. Replace this line with: "${rewriteRow(legacy[1] ?? "", legacy[2] ?? "", legacy[3] ?? "")}".` : bare ? `Every tool field is a bullet row (the bullets are the compiled schema's nesting). Replace this line with: "${rewriteRow(bare[1] ?? "", bare[2] ?? "", bare[3] ?? "")}".` : `This line isn't a field of $TOOL ${name}. A field is "- key:: value" (keys: description, input, request, headers). Found: "${f.value.slice(0, 60)}".`,
+            "malformed-tool",
+            "error"
+          );
+          for (const kid of shapedChildren(f.children, false)) {
+            flag(kid.line, `Unreachable \u2014 it sits under the malformed field above. After fixing that line, write this one as: "${kid.rewrite}".`, "malformed-param", "error");
+          }
+        }
+        continue;
+      }
+      if (seen.has(f.key)) {
+        flag(f.line, `Duplicate "${f.key}::" in $TOOL ${name} \u2014 one per tool.`, "duplicate-key", "error");
+        continue;
+      }
+      seen.add(f.key);
+      if (!TOOL_KEYS.has(f.key)) {
+        flag(f.line, `Unknown key "${f.key}::" in $TOOL ${name} \u2014 known keys: description, input, request, headers.`, "unknown-tool-key", "warn");
+      } else if (f.key === "description") {
+        if (f.value !== "") descParts.push(f.value);
+        const misplaced = new Set(shapedChildren(f.children, true).map((k) => k.line));
+        for (const kid of shapedChildren(f.children, true)) {
+          flag(kid.line, `This looks like a parameter, but it sits inside description:: text (deeper lines continue the description) \u2014 it would never reach the schema. Move it under "- input::" as: "${kid.rewrite}".`, "misplaced-param", "error");
+        }
+        for (const c of f.children) if (!misplaced.has(c.line)) descParts.push(c.text);
+      } else if (f.key === "input") {
+        for (const c of f.children) {
+          const pm = c.text.match(PARAM_RE);
+          if (pm) {
+            const pname = (pm[1] ?? "").toLowerCase();
+            if (pm[2] === "?") {
+              flag(c.line, `Optional parameters are written with the "optional" prefix, never a "?" sigil. Replace this line with: "${rewriteRow(pname, "?", pm[3] ?? "")}".`, "malformed-param", "error");
+              continue;
+            }
+            const parsed = parseParamValue(pm[3] ?? "");
+            if (parsed.ok) {
+              params.push({ name: pname, required: !parsed.optional && parsed.param.default === void 0, ...parsed.param });
+            } else {
+              flag(c.line, parsed.value !== void 0 ? `${parsed.reason} Replace this line with: "${rewriteRow(pname, "", parsed.value)}".` : parsed.reason, "malformed-param", "error");
+            }
+            continue;
+          }
+          const legacy = c.text.match(LEGACY_FIELD_RE);
+          const bare = c.text.match(BARE_FIELD_RE);
+          flag(
+            c.line,
+            legacy ? `Parameters use the definition marker "::" with a leading bullet, never a single colon. Replace this line with: "${rewriteRow(legacy[1] ?? "", legacy[2] ?? "", legacy[3] ?? "")}".` : bare ? `Every parameter is a bullet row under input:: (a sub-bullet is the schema's nesting). Replace this line with: "${rewriteRow(bare[1] ?? "", bare[2] ?? "", bare[3] ?? "")}".` : `This isn't a parameter. A parameter is "- name:: description." or "- name:: type: description." \u2014 the type is English, like "one of a, b" or "optional string". Found: "${c.text.slice(0, 60)}".`,
+            "malformed-param",
+            "error"
+          );
+        }
+      } else if (f.key === "request") {
+        const reqValue = stripPunct(f.value);
+        const abs = reqValue.match(BINDING_ABS_RE);
+        const via = reqValue.match(BINDING_SVC_RE);
+        if (abs) {
+          binding = { method: abs[1] ?? "GET", url: abs[2] ?? "", headers: [], line: f.line };
+        } else if (via) {
+          const svcName = (via[2] ?? "").toLowerCase();
+          const service = services.get(svcName);
+          if (!service) {
+            flag(f.line, `Request references $SERVICE "${svcName}", which is not defined.`, "dangling-service", "error");
+          } else {
+            usedServices.add(svcName);
+            binding = { method: via[1] ?? "GET", url: `${service.base}${via[3] ?? ""}`, headers: [], service: svcName, line: f.line };
+          }
+        } else {
+          flag(f.line, `Malformed request in $TOOL ${name}. The value is "METHOD url": either absolute, like "- request:: GET https://api.example.com/orders", or through a $SERVICE, like "- request:: POST acme /orders" (acme names a $SERVICE). METHOD is uppercase: GET, POST, PUT, PATCH, DELETE.`, "malformed-binding", "error");
+        }
+      } else {
+        for (const c of f.children) {
+          const hm = c.text.match(HEADER_RE);
+          if (hm) headers.push({ name: hm[1] ?? "", value: stripPunct(hm[2] ?? ""), line: c.line });
+          else flag(c.line, `This isn't a header. A header is "- Header-Name:: value". Found: "${c.text.slice(0, 60)}".`, "malformed-header", "error");
+        }
+      }
+    }
+    const pseen = /* @__PURE__ */ new Set();
+    for (const p of params) {
+      if (pseen.has(p.name)) flag(block.line, `Parameter "${p.name}" is defined more than once in $TOOL ${name}.`, "duplicate-param", "error");
+      pseen.add(p.name);
+    }
+    if (descParts.length === 0) {
+      flag(block.line, `$TOOL ${name} has no description \u2014 the model has nothing to decide WHEN to call it.`, "tool-no-description", "warn");
+    }
+    if (binding) {
+      const fromService = binding.service ? services.get(binding.service)?.headers ?? [] : [];
+      const own = headers.map((h) => ({ name: h.name, value: h.value }));
+      binding.headers = [...fromService.filter((sh) => !own.some((th) => th.name.toLowerCase() === sh.name.toLowerCase())), ...own];
+    } else if (headers.length > 0) {
+      flag(headers[0]?.line ?? block.line, `$TOOL ${name} has headers but no request \u2014 headers ride an HTTP binding. Add one, like: "- request:: GET https://api.example.com/orders", or delete the headers.`, "header-without-binding", "warn");
+    }
+    if (binding) {
+      const paramNames = new Set(params.map((p) => p.name));
+      checkPlaceholders(binding.url.slice(binding.service ? services.get(binding.service)?.base.length ?? 0 : 0), binding.line, paramNames, "the request", flag);
+      for (const h of headers) {
+        checkPlaceholders(h.value, h.line, paramNames, "this header", flag);
+        if (!/\{env\./.test(h.value) && SECRET_RE.test(h.value)) {
+          flag(h.line, `This looks like a credential literal \u2014 never put secrets in the file; use @{env.NAME} instead.`, "secret-literal", "warn");
+        }
+      }
+    }
+    tools.push({ name, description: descParts.join(" "), params, ...binding ? { binding } : {}, line: block.line });
+  }
+  const byName = /* @__PURE__ */ new Map();
+  for (const tl of tools) {
+    const list = byName.get(tl.name) ?? [];
+    list.push(tl);
+    byName.set(tl.name, list);
+  }
+  for (const [dup, list] of byName) {
+    if (list.length > 1) conflicts.push({ lines: list.map((tl) => tl.line), message: `$TOOL ${dup} is defined ${list.length} times.`, code: "duplicate-tool", severity: "error" });
+  }
+  for (const s of svc.services) {
+    if (!usedServices.has(s.name)) conflicts.push({ lines: [s.line], message: `$SERVICE ${s.name} is never used by any tool's request.`, code: "unused-service", severity: "warn" });
+  }
+  return { tools, services: svc.services, conflicts };
+}
+function toolInputSchema(tool) {
+  const properties = {};
+  for (const p of tool.params) {
+    const base = { type: p.type };
+    if (p.enum !== void 0) base["enum"] = p.enum;
+    if (p.default !== void 0) base["default"] = p.default;
+    if (p.description !== void 0) base["description"] = p.description;
+    properties[p.name] = p.array ? { type: "array", items: { type: p.type, ...p.enum !== void 0 ? { enum: p.enum } : {} }, ...p.description !== void 0 ? { description: p.description } : {} } : base;
+  }
+  return { type: "object", properties, required: tool.params.filter((p) => p.required).map((p) => p.name) };
+}
+
+// src/core/cardinality.ts
+var import_pluralize = __toESM(require_pluralize(), 1);
+import_pluralize.default.addUncountableRule("sms");
+var EXISTENTIAL_FRAME_SRC = "there\\s+(?:is|are|was|were|exists|exist)";
+var POSSESSIVE_FRAME_SRC = "(?:has|have)";
+function singularizeNoun(s) {
+  return import_pluralize.default.singular(s.trim().toLowerCase());
+}
+function pluralizeNoun(s) {
+  return import_pluralize.default.plural(s.trim().toLowerCase());
+}
+var numOf = (w) => NUMBER_WORDS[w] ?? (/^\d+$/.test(w) ? Number(w) : null);
+var FIXED = new Map(CARDINAL_QUANTITIES.map((q) => [q.phrase, { lo: q.lo, hi: q.hi ?? Infinity }]));
+var EXACT = new Set(EXACTNESS_MARKERS.map((m) => m.toLowerCase()));
+var QUANT_WORD_SET = new Set(QUANTIFIER_KEYWORDS.map((w) => w.toLowerCase()));
+function classifyCardinal(tokens) {
+  const [a, b] = [tokens[0] ?? "", tokens[1] ?? ""];
+  const fixed = FIXED.get(tokens.join(" "));
+  if (fixed) return fixed;
+  if (EXACT.has(a) && tokens.length === 2) {
+    const n = numOf(b);
+    return n === null ? null : { lo: n, hi: n };
+  }
+  if (a === "at" && b === "least" && tokens.length === 3) {
+    const n = numOf(tokens[2] ?? "");
+    return n === null ? null : { lo: n, hi: Infinity };
+  }
+  if (a === "at" && b === "most" && tokens.length === 3) {
+    const n = numOf(tokens[2] ?? "");
+    return n === null ? null : { lo: 0, hi: n };
+  }
+  if (tokens.length === 1) {
+    const n = numOf(a);
+    return n === null ? null : { lo: n, hi: Infinity };
+  }
+  return null;
+}
+function normTail(words) {
+  return words.join(" ");
+}
+function quantityAndNoun(rest) {
+  const words = rest.toLowerCase().split(/\s+/).map((w) => w.replace(/[.,;:!?]+$/, "")).filter((w) => w !== "");
+  for (const take of [3, 2, 1]) {
+    if (words.length <= take) continue;
+    const iv = classifyCardinal(words.slice(0, take));
+    if (iv === null) continue;
+    const noun = singularizeNoun(words[take] ?? "");
+    if (noun === "" || numOf(noun) !== null) return null;
+    return { noun, lo: iv.lo, hi: iv.hi, text: words.slice(0, take + 1).join(" "), phrase: words.slice(0, take).join(" "), tail: normTail(words.slice(take + 1)) };
+  }
+  return null;
+}
+var THERE_RE = new RegExp(`^${EXISTENTIAL_FRAME_SRC}\\s+(.+)$`, "i");
+var SUBJECT_SRC = "(?:the\\s+|an?\\s+)?([A-Za-z][A-Za-z0-9_]*(?:\\s+[A-Za-z][A-Za-z0-9_]*)?)";
+var HAVE_RE = new RegExp(`^${SUBJECT_SRC}\\s+(${POSSESSIVE_FRAME_SRC})\\s+(.+)$`, "i");
+var MANY_CLASS = CARDINAL_QUANTITIES.filter((q) => q.lo === 2 && q.hi === null && !q.phrase.includes(" ")).map((q) => q.phrase);
+var ONE_OF_RE = new RegExp(`^${SUBJECT_SRC}\\s+(?:${copulaAlternation})\\s+one\\s+of\\s+(?:the\\s+)?((?:${MANY_CLASS.join("|")})|[a-z0-9]+)\\s+(.+)$`, "i");
+var THE_ONLY_RE = new RegExp(`^${SUBJECT_SRC}\\s+(?:${copulaAlternation})\\s+the\\s+only\\s+(.+)$`, "i");
+var subjectAbstains = (subject) => subject === "" || subject.split(/\s+/).some((w) => QUANT_WORD_SET.has(w) || numOf(w) !== null);
+function isCardinalQuantityLead(text) {
+  const first = (text.trim().toLowerCase().split(/\s+/)[0] ?? "").replace(/[.,;:!?]+$/, "");
+  return FIXED.has(first) || EXACT.has(first) || numOf(first) !== null;
+}
+function parseCardinalBody(body) {
+  const trimmed = body.trim();
+  const there = trimmed.match(THERE_RE);
+  if (there) {
+    const q = quantityAndNoun(there[1] ?? "");
+    return q === null ? null : q;
+  }
+  const have = trimmed.match(HAVE_RE);
+  if (have) {
+    const owner = (have[1] ?? "").toLowerCase().trim();
+    if (subjectAbstains(owner)) return null;
+    const q = quantityAndNoun(have[3] ?? "");
+    if (q === null) return null;
+    if (q.phrase === "a" || q.phrase === "an") return null;
+    return { ...q, owner, text: `${owner} ${(have[2] ?? "").toLowerCase()} ${q.text}` };
+  }
+  const only = trimmed.match(THE_ONLY_RE);
+  if (only) {
+    const subject = (only[1] ?? "").toLowerCase().trim();
+    if (subjectAbstains(subject)) return null;
+    const words = (only[2] ?? "").toLowerCase().split(/\s+/).map((w) => w.replace(/[.,;:!?]+$/, "")).filter((w) => w !== "");
+    const noun = singularizeNoun(words[0] ?? "");
+    if (noun === "" || numOf(noun) !== null) return null;
+    return { noun, lo: 1, hi: 1, text: `the only ${words[0] ?? ""}`, phrase: "the only", tail: normTail(words.slice(1)) };
+  }
+  const oneOf = trimmed.match(ONE_OF_RE);
+  if (oneOf) {
+    const subject = (oneOf[1] ?? "").toLowerCase().trim();
+    if (subjectAbstains(subject)) return null;
+    const quantity = (oneOf[2] ?? "").toLowerCase();
+    const n = numOf(quantity);
+    const lo = n !== null ? Math.max(n, 2) : MANY_CLASS.includes(quantity) ? 2 : null;
+    if (lo === null || n !== null && n < 2) return null;
+    const words = (oneOf[3] ?? "").toLowerCase().split(/\s+/).map((w) => w.replace(/[.,;:!?]+$/, "")).filter((w) => w !== "");
+    const noun = singularizeNoun(words[0] ?? "");
+    if (noun === "" || numOf(noun) !== null) return null;
+    return { noun, lo, hi: Infinity, text: `one of ${quantity} ${words[0] ?? ""}`, phrase: `one of ${quantity}`, tail: normTail(words.slice(1)) };
+  }
+  return null;
+}
+var NON_ACTION_LEADS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "they",
+  "we",
+  "i",
+  "he",
+  "she",
+  "you",
+  "there",
+  "is",
+  "are",
+  "was",
+  "were",
+  "am",
+  "be",
+  "been",
+  "being",
+  "if",
+  "then",
+  "otherwise",
+  "and",
+  "or",
+  "not",
+  "have",
+  "has",
+  "had"
+  // the POSSESSIVE-have frame owns these (owner-scoped set sizes) — never double-read
+]);
+function parseActionCount(segment) {
+  const m = segment.trim().match(/^([A-Za-z][A-Za-z-]*)\s+(.+)$/);
+  if (!m) return null;
+  const verb = (m[1] ?? "").toLowerCase();
+  if (NON_ACTION_LEADS.has(verb) || QUANT_WORD_SET.has(verb) || numOf(verb) !== null || FIXED.has(verb) || EXACT.has(verb)) return null;
+  const q = quantityAndNoun(m[2] ?? "");
+  if (q === null) return null;
+  if (q.phrase === "a" || q.phrase === "an") return null;
+  return { verb, noun: q.noun, lo: q.lo, hi: q.hi, text: `${verb} ${q.text}`, tail: q.tail };
+}
+function boundText(lo, hi) {
+  if (lo === hi) return `exactly ${lo}`;
+  if (hi === Infinity) return `${lo} or more`;
+  if (lo === 0) return `at most ${hi}`;
+  return `${lo} to ${hi}`;
+}
+
+// src/core/possession.ts
+var DETERMINER = {
+  my: "i",
+  your: "you",
+  its: "it",
+  their: "they",
+  our: "we",
+  his: "he",
+  her: "she",
+  whose: "who"
+};
+var ABSOLUTE = {
+  mine: "i",
+  yours: "you",
+  hers: "she",
+  ours: "we",
+  theirs: "they",
+  his: "he",
+  its: "it"
+};
+var NOTS = "((?:not\\s+)*)";
+var COP = `(${copulaAlternation})`;
+var DET_ALT = Object.keys(DETERMINER).join("|");
+var ABS_ALT = Object.keys(ABSOLUTE).join("|");
+var ART = "(?:(?:the|a|an)\\s+)?";
+var PRENOMINAL_DET = new RegExp(`\\b(${DET_ALT})\\s+(.+?)\\s+${COP}\\s+${NOTS}(.+)$`, "di");
+var PRENOMINAL_SAXON = new RegExp(`\\b${ART}(${HONORIFIC_PREFIX_SRC}${NAME_PHRASE})(?:'s|')\\s+(.+?)\\s+${COP}\\s+${NOTS}(.+)$`, "diu");
+var OF_GENITIVE = new RegExp(`^\\s*the\\s+(${NAME_PHRASE})\\s+of\\s+${ART}(${HONORIFIC_PREFIX_SRC}${NAME_PHRASE})\\s+${COP}\\s+${NOTS}(.+)$`, "diu");
+var HAVE_OF = new RegExp(`^\\s*${ART}(${HONORIFIC_PREFIX_SRC}${NAME_PHRASE})\\s+(?:has|have)\\s+${ART}(${NAME_PHRASE})\\s+of\\s+(.+)$`, "diu");
+var OWNERSHIP_ABS = new RegExp(`^\\s*${ART}(.+?)\\s+(?:${copulaAlternation})\\s+(${ABS_ALT})\\s*\\.?$`, "di");
+var OWNERSHIP_SAXON = new RegExp(`^\\s*${ART}(.+?)\\s+(?:${copulaAlternation})\\s+(${HONORIFIC_PREFIX_SRC}${NAME_PHRASE})(?:'s|')\\s*\\.?$`, "diu");
+function sliceAt(clean, m, i) {
+  const ix = m.indices?.[i];
+  return ix ? clean.slice(ix[0], ix[1]) : "";
+}
+function foldNegation(nots) {
+  return (nots.match(/\bnot\b/gi) ?? []).length % 2 === 1;
+}
+function stripArticle(s) {
+  return s.replace(/^(?:the|a|an)\s+/i, "").trim();
+}
+function splitPath(raw) {
+  return raw.split(/'s\b\s*/).map((s) => s.trim()).filter((s) => s !== "");
+}
+function resolveOwnerPhrase(phrase) {
+  const trimmed = phrase.trim();
+  const of = trimmed.match(/^(.+?)\s+of\s+(.+)$/i);
+  if (of) {
+    const base = resolveOwnerPhrase((of[2] ?? "").trim().replace(/^(?:the|a|an)\s+/i, ""));
+    return { owner: base.owner, prefix: [...base.prefix, (of[1] ?? "").trim()] };
+  }
+  const m = trimmed.match(/^([A-Za-z]+)\s+(.+)$/);
+  const det = m ? (m[1] ?? "").toLowerCase() : "";
+  if (m && DETERMINER[det]) return { owner: DETERMINER[det] ?? det, prefix: [(m[2] ?? "").trim()] };
+  return { owner: trimmed, prefix: [] };
+}
+var CLAUSE_RE = new RegExp(`^(${NAME_PHRASE})\\s+(${copulaAlternation})\\s+(.+)$`, "iu");
+var PRONOUN_SUBJECTS = /* @__PURE__ */ new Set(["it", "this", "that", "they", "these", "those", "he", "she", "we", "i", "you"]);
+function makeProperties(owner, headPath, rawValue, headCopula, negated) {
+  if (headPath.length === 0) return [];
+  const conjuncts = stripQuotes(rawValue.trim()).split(/\s*,\s*|\s+and\s+/i).map((s) => s.trim()).filter((s) => s !== "");
+  const out = [];
+  let cur = { owner, path: headPath, many: /are/i.test(headCopula), values: [] };
+  const flush = () => {
+    const items = cur.values.map(stripPunct).filter((v) => v !== "");
+    if (cur.path.length > 0 && items.length > 0) {
+      const path = cur.path.map((p) => p.toLowerCase());
+      out.push({ kind: "property", owner: cur.owner, path, items, negated, cardinality: cur.many || items.length > 1 ? "many" : "one" });
+    }
+  };
+  conjuncts.forEach((c, i) => {
+    if (i === 0) {
+      cur.values.push(c);
+      return;
+    }
+    const sub = parsePossessions(c)[0];
+    if (sub) {
+      flush();
+      if (sub.kind === "property") {
+        cur = { owner: sub.owner, path: sub.path, many: sub.cardinality === "many", values: [...sub.items] };
+      } else {
+        out.push(sub);
+        cur = { owner, path: [], many: false, values: [] };
+      }
+      return;
+    }
+    const clause = c.match(CLAUSE_RE);
+    if (clause) {
+      const noun = clause[1]?.trim() ?? "";
+      if (PRONOUN_SUBJECTS.has(noun.toLowerCase())) return;
+      flush();
+      cur = { owner, path: splitPath(noun), many: /are/i.test(clause[2] ?? "is"), values: [clause[3] ?? ""] };
+      return;
+    }
+    cur.values.push(c);
+  });
+  flush();
+  return out;
+}
+function parsePossessions(text) {
+  const clean = stripInlineComment(text);
+  if (!bindsHere(clean)) return [];
+  const masked = maskQuotes(clean);
+  let m = masked.match(HAVE_OF);
+  if (m?.indices) {
+    const { owner, prefix } = resolveOwnerPhrase(sliceAt(clean, m, 1));
+    return makeProperties(owner, [...prefix, sliceAt(clean, m, 2).trim()], sliceAt(clean, m, 3), "", false);
+  }
+  m = masked.match(OF_GENITIVE);
+  if (m?.indices) {
+    const { owner, prefix } = resolveOwnerPhrase(sliceAt(clean, m, 2));
+    return makeProperties(owner, [...prefix, sliceAt(clean, m, 1).trim()], sliceAt(clean, m, 5), sliceAt(clean, m, 3), foldNegation(sliceAt(clean, m, 4)));
+  }
+  m = masked.match(PRENOMINAL_DET);
+  if (m?.indices) {
+    const det = sliceAt(clean, m, 1).toLowerCase();
+    return makeProperties(DETERMINER[det] ?? det, splitPath(sliceAt(clean, m, 2)), sliceAt(clean, m, 5), sliceAt(clean, m, 3), foldNegation(sliceAt(clean, m, 4)));
+  }
+  m = masked.match(PRENOMINAL_SAXON);
+  if (m?.indices) {
+    return makeProperties(sliceAt(clean, m, 1), splitPath(sliceAt(clean, m, 2)), sliceAt(clean, m, 5), sliceAt(clean, m, 3), foldNegation(sliceAt(clean, m, 4)));
+  }
+  m = masked.match(OWNERSHIP_ABS);
+  if (m?.indices) {
+    const abs = sliceAt(clean, m, 2).toLowerCase();
+    return [{ kind: "ownership", owner: ABSOLUTE[abs] ?? abs, thing: stripArticle(sliceAt(clean, m, 1)) }];
+  }
+  m = masked.match(OWNERSHIP_SAXON);
+  if (m?.indices) {
+    return [{ kind: "ownership", owner: sliceAt(clean, m, 2), thing: stripArticle(sliceAt(clean, m, 1)) }];
+  }
+  return [];
+}
+function parsePossession(text) {
+  return parsePossessions(text)[0] ?? null;
+}
+
+// src/core/testblock.ts
+var TEST_HEADER = /^(\s*)\$TEST\s+([A-Za-z][A-Za-z0-9_-]*)\s*$/i;
+var FIELD = /^(\s*)-\s+([a-z][a-z0-9_]*)::\s*(.*)$/i;
+var SUBITEM = /^\s*-\s+(.+?)\s*$/;
+var ANY_TEST = /^\s*\$TEST\b/i;
+var RETIRED_EXPECT = /^\s*EXPECT\b/;
+var CONTAINS = /^contains\s+"(.+)"\s*$/i;
+var MATCHES = /^matches\s+\/(.+)\/([a-z]*)\s*$/i;
+var BOUND = /^at\s+(most|least)\s+(\d+)\s+(sentences?|words?|characters?)\s*$/i;
+var leading2 = (s) => s.length - s.trimStart().length;
+function parseExpect(text) {
+  const t = text.trim();
+  if (t === "") return { assert: null, error: "an expectation has no condition after it." };
+  const c = CONTAINS.exec(t);
+  if (c) return { assert: { kind: "contains", value: c[1] ?? "" }, error: null };
+  const m = MATCHES.exec(t);
+  if (m) {
+    try {
+      void new RegExp(m[1] ?? "", m[2] ?? "");
+      return { assert: { kind: "matches", source: m[1] ?? "", flags: m[2] ?? "" }, error: null };
+    } catch {
+      return { assert: null, error: `the expectation \`matches /${m[1] ?? ""}/\` is not a valid regular expression.` };
+    }
+  }
+  const b = BOUND.exec(t);
+  if (b) {
+    const unit = (b[3] ?? "").toLowerCase().replace(/s?$/, "s");
+    return { assert: { kind: b[1]?.toLowerCase() === "most" ? "atMost" : "atLeast", n: Number(b[2]), unit }, error: null };
+  }
+  return { assert: { kind: "rubric", text: t }, error: null };
+}
+function parseTests(lines) {
+  const blocks = [];
+  const seen = /* @__PURE__ */ new Set();
+  let i = 0;
+  while (i < lines.length) {
+    const m = (lines[i] ?? "").match(TEST_HEADER);
+    if (!m) {
+      i += 1;
+      continue;
+    }
+    const indent = (m[1] ?? "").length;
+    const id = (m[2] ?? "").toLowerCase();
+    let j = i + 1;
+    while (j < lines.length) {
+      const l = lines[j] ?? "";
+      if (l.trim() !== "" && leading2(l) <= indent) break;
+      j += 1;
+    }
+    const blockEnd = j;
+    let input = null;
+    const expects = [];
+    const rubricLines = [];
+    let error = null;
+    let k = i + 1;
+    while (k < blockEnd && error === null) {
+      const raw = lines[k] ?? "";
+      if (raw.trim() === "") {
+        k += 1;
+        continue;
+      }
+      if (ANY_TEST.test(raw)) {
+        error = "a nested $TEST is not supported \u2014 dedent it to start a new test.";
+        break;
+      }
+      const fm = raw.match(FIELD);
+      if (!fm) {
+        error = `only "- input::" and "- expect::" fields belong in $TEST ${id} \u2014 "${raw.trim().slice(0, 48)}" is not one.`;
+        break;
+      }
+      const fieldIndent = (fm[1] ?? "").length;
+      const key = (fm[2] ?? "").toLowerCase();
+      const value = (fm[3] ?? "").trim();
+      if (key === "input") {
+        if (value === "") {
+          error = `$TEST ${id} needs the user turn on the "- input::" line.`;
+          break;
+        }
+        input = value;
+        k += 1;
+      } else if (key === "expect") {
+        if (value !== "") {
+          error = `"- expect::" is a list \u2014 put each expectation on its own "- " sub-bullet beneath it.`;
+          break;
+        }
+        k += 1;
+        let count = 0;
+        while (k < blockEnd) {
+          const sub = lines[k] ?? "";
+          if (sub.trim() === "") {
+            k += 1;
+            continue;
+          }
+          if (leading2(sub) <= fieldIndent) break;
+          const sm = sub.match(SUBITEM);
+          if (sm === null) {
+            error = `each expectation is a "- " sub-bullet under "- expect::" \u2014 "${sub.trim().slice(0, 48)}" is not.`;
+            break;
+          }
+          const parsed = parseExpect(sm[1] ?? "");
+          if (parsed.error !== null) {
+            error = parsed.error;
+            break;
+          }
+          if (parsed.assert) {
+            expects.push(parsed.assert);
+            if (parsed.assert.kind === "rubric") rubricLines.push({ line: k, start: (sub.match(/^\s*-\s+/)?.[0] ?? "").length, text: parsed.assert.text });
+          }
+          count += 1;
+          k += 1;
+        }
+        if (error === null && count === 0) error = `$TEST ${id}'s "- expect::" has no expectations \u2014 add a "- " sub-bullet.`;
+      } else {
+        error = `only "- input::" and "- expect::" fields belong in $TEST ${id} \u2014 "- ${key}::" is neither.`;
+        break;
+      }
+    }
+    if (error === null && input === null) error = `$TEST ${id} needs an "- input:: \u2026" line.`;
+    if (error === null && expects.length === 0) error = `$TEST ${id} needs at least one expectation under "- expect::".`;
+    if (error === null && seen.has(id)) error = `duplicate $TEST id "${id}".`;
+    seen.add(id);
+    blocks.push({ headerLine: i, blockEnd, indent, id, input: input ?? "", expects, rubricLines, error });
+    i = blockEnd;
+  }
+  return blocks;
+}
+function testBlockLines(lines) {
+  const out = /* @__PURE__ */ new Set();
+  for (const b of parseTests(lines)) for (let i = b.headerLine; i < b.blockEnd; i += 1) out.add(i);
+  return out;
+}
+function rubricExpectLines(lines) {
+  return parseTests(lines).filter((b) => b.error === null).flatMap((b) => b.rubricLines);
+}
+function strayExpects(lines) {
+  const out = [];
+  lines.forEach((raw, i) => {
+    if (RETIRED_EXPECT.test(raw)) out.push(i);
+  });
+  return out;
+}
+var slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 48) || "expectation";
+function extractSuite(source) {
+  const blocks = parseTests(source.replace(/\r\n/g, "\n").split("\n")).filter((b) => b.error === null);
+  const testCases = [];
+  const caseRubrics = {};
+  const asserts = {};
+  const union = /* @__PURE__ */ new Map();
+  for (const b of blocks) {
+    const rubricTexts = b.expects.filter((e) => e.kind === "rubric");
+    const detAsserts = b.expects.filter((e) => e.kind !== "rubric");
+    const dims = rubricTexts.map((r) => ({ key: slug(r.text), description: r.text }));
+    for (const d of dims) if (!union.has(d.key)) union.set(d.key, d);
+    testCases.push({
+      id: b.id,
+      input: b.input,
+      expectation: rubricTexts.length > 0 ? rubricTexts.map((r) => r.text).join("; ") : void 0
+    });
+    caseRubrics[b.id] = { dimensions: dims };
+    asserts[b.id] = detAsserts;
+  }
+  return { testCases, rubric: { dimensions: [...union.values()] }, caseRubrics, asserts };
+}
+
+// src/core/exampleblock.ts
+var EXAMPLE_HEADER = /^(\s*)\$EXAMPLE\s+([A-Za-z][A-Za-z0-9_-]*)\s*$/i;
+var FIELD2 = /^(\s*)-\s+([a-z][a-z0-9_]*)::\s*(.*)$/i;
+var ANY_EXAMPLE = /^\s*\$EXAMPLE\b/i;
+var leading3 = (s) => s.length - s.trimStart().length;
+function parseExamples(lines) {
+  const blocks = [];
+  const seen = /* @__PURE__ */ new Set();
+  let i = 0;
+  while (i < lines.length) {
+    const m = (lines[i] ?? "").match(EXAMPLE_HEADER);
+    if (!m) {
+      i += 1;
+      continue;
+    }
+    const indent = (m[1] ?? "").length;
+    const id = (m[2] ?? "").toLowerCase();
+    let j = i + 1;
+    while (j < lines.length) {
+      const l = lines[j] ?? "";
+      if (l.trim() !== "" && leading3(l) <= indent) break;
+      j += 1;
+    }
+    const blockEnd = j;
+    let input = null;
+    let good = null;
+    let bad = null;
+    let error = null;
+    let k = i + 1;
+    while (k < blockEnd && error === null) {
+      const raw = lines[k] ?? "";
+      if (raw.trim() === "") {
+        k += 1;
+        continue;
+      }
+      if (ANY_EXAMPLE.test(raw)) {
+        error = "a nested $EXAMPLE is not supported \u2014 dedent it to start a new example.";
+        break;
+      }
+      const fm = raw.match(FIELD2);
+      if (!fm) {
+        error = `only "- input::", "- good::", and "- bad::" fields belong in $EXAMPLE ${id} \u2014 "${raw.trim().slice(0, 48)}" is not one.`;
+        break;
+      }
+      const key = (fm[2] ?? "").toLowerCase();
+      const value = (fm[3] ?? "").trim();
+      if (key === "input" || key === "good" || key === "bad") {
+        if (value === "") {
+          error = `$EXAMPLE ${id}'s "- ${key}::" needs its text on the same line.`;
+          break;
+        }
+        if (key === "input") input = value;
+        else if (key === "good") good = value;
+        else bad = value;
+        k += 1;
+      } else {
+        error = `only "- input::", "- good::", and "- bad::" fields belong in $EXAMPLE ${id} \u2014 "- ${key}::" is neither.`;
+        break;
+      }
+    }
+    if (error === null && input === null) error = `$EXAMPLE ${id} needs an "- input:: \u2026" line.`;
+    if (error === null && good === null) error = `$EXAMPLE ${id} needs a "- good:: \u2026" line \u2014 the ideal response to demonstrate.`;
+    if (error === null && seen.has(id)) error = `duplicate $EXAMPLE id "${id}".`;
+    seen.add(id);
+    blocks.push({ headerLine: i, blockEnd, indent, id, input: input ?? "", good: good ?? "", bad, error });
+    i = blockEnd;
+  }
+  return blocks;
+}
+function exampleBlockLines(lines) {
+  const out = /* @__PURE__ */ new Set();
+  for (const b of parseExamples(lines)) for (let i = b.headerLine; i < b.blockEnd; i += 1) out.add(i);
+  return out;
+}
+function renderExample(b) {
+  if (b.error !== null) return [];
+  return ["<example>", `User: ${b.input}`, `Assistant: ${b.good}`, "</example>"];
+}
+
+// src/core/prompt.ts
+function classifyLines(rawLines) {
+  const kinds = [];
+  let inBlock = false;
+  let inFence = false;
+  for (const raw of rawLines) {
+    const t = raw.trim();
+    const isFence = t.startsWith("```") || t.startsWith("~~~");
+    if (inFence) {
+      if (isFence) inFence = false;
+      kinds.push(t === "" ? "blank" : "content");
+      continue;
+    }
+    if (inBlock) {
+      kinds.push("comment");
+      if (t.includes("*/")) inBlock = false;
+      continue;
+    }
+    if (isFence) {
+      inFence = true;
+      kinds.push("content");
+      continue;
+    }
+    if (t.startsWith("/*")) {
+      kinds.push("comment");
+      if (!t.includes("*/")) inBlock = true;
+      continue;
+    }
+    if (t.startsWith("//")) {
+      kinds.push("comment");
+      continue;
+    }
+    kinds.push(t === "" ? "blank" : "content");
+  }
+  return kinds;
+}
+function isHeadingLine(text) {
+  return /^\s*#{1,6}\s/.test(text);
+}
+function fenceMask(rawLines) {
+  const mask = [];
+  let inFence = false;
+  for (const raw of rawLines) {
+    const t = raw.trim();
+    const isFence = t.startsWith("```") || t.startsWith("~~~");
+    if (inFence) {
+      mask.push(true);
+      if (isFence) inFence = false;
+    } else if (isFence) {
+      inFence = true;
+      mask.push(true);
+    } else {
+      mask.push(false);
+    }
+  }
+  return mask;
+}
+function stripIndent(source) {
+  const lines = source.split("\n");
+  const mask = fenceMask(lines);
+  const tools = toolBlockMask(lines);
+  const switches = switchBlockMask(lines);
+  const defs = defListMask(lines);
+  const dedent = new Array(lines.length).fill(0);
+  const markRuns = (m) => {
+    for (let i = 0; i < lines.length; i += 1) {
+      if (m[i] !== true || i > 0 && m[i - 1] === true) continue;
+      const anchor = ((lines[i] ?? "").match(/^ */) ?? [""])[0].length;
+      for (let j = i; j < lines.length && m[j] === true; j += 1) dedent[j] = anchor;
+    }
+  };
+  markRuns(tools);
+  markRuns(switches);
+  markRuns(defs);
+  return lines.map((l, i) => {
+    if (mask[i]) return l;
+    if (tools[i] || switches[i] || defs[i]) {
+      const lead = (l.match(/^ */) ?? [""])[0].length;
+      return l.slice(Math.min(dedent[i] ?? 0, lead));
+    }
+    return l.replace(/^[ \t]+/, "");
+  }).join("\n");
+}
+function matchDeclaration(re, text) {
+  const m = maskQuotes(text).match(re);
+  if (!m?.indices) return null;
+  const at = (i) => {
+    const ix = m.indices?.[i];
+    return ix ? text.slice(ix[0], ix[1]) : "";
+  };
+  const nots = (at(2).match(/NOT/gi) ?? []).length;
+  return { name: at(1), negated: nots % 2 === 1, value: stripQuotes(stripPunct(at(3))) };
+}
+var ANYWHERE_DECLARATION_RE = new RegExp(
+  `\\b(${HONORIFIC_PREFIX_SRC}${NAME_WORD})${copulaConnector}\\s+((?:(?:NOT|not)\\s+)*)(.+)$`,
+  "du"
+);
+var QUANTIFIER_LED_RE = new RegExp(`\\b(?:${QUANTIFIER_KEYWORDS.map((w) => w.toLowerCase()).join("|")})\\s+$`, "i");
+function findDeclaration(text) {
+  if (isHeadingLine(text)) return null;
+  if (!bindsHere(text)) return null;
+  if (parsePossession(text)) return null;
+  const m = matchDeclaration(ANYWHERE_DECLARATION_RE, text);
+  if (!m) return null;
+  if (m.name.toLowerCase() === "there") return null;
+  const at = maskQuotes(text).match(ANYWHERE_DECLARATION_RE)?.indices?.[1]?.[0] ?? 0;
+  if (QUANTIFIER_LED_RE.test(text.slice(0, at))) return null;
+  return m;
+}
+var INCLUDING_RE = new RegExp(`\\b(${NAME_WORD})\\s+(?:INCLUDING|including)\\s+(.+)$`, "du");
+function findDeclaredItems(text) {
+  const clean = stripInlineComment(text);
+  if (!bindsHere(clean)) return null;
+  const inc = maskQuotes(clean).match(INCLUDING_RE);
+  if (inc?.indices) {
+    const nameIx = inc.indices[1];
+    const listIx = inc.indices[2];
+    const name = nameIx ? clean.slice(nameIx[0], nameIx[1]) : "";
+    const list = listIx ? clean.slice(listIx[0], listIx[1]) : "";
+    const items2 = stripQuotes(stripPunct(list)).split(",").map((s) => s.trim()).filter((s) => s !== "");
+    return { name, items: items2, negated: false, list: true };
+  }
+  const d = findDeclaration(clean);
+  if (!d) return null;
+  const items = d.value.split(/\s+AND\s+/i).map((s) => s.trim()).filter((s) => s !== "");
+  return { name: d.name, items, negated: d.negated };
+}
+var BULLET_RE = /^\s*(?:[-*+]|\d+[.)])\s+(.+)$/;
+var LIST_HEADER_RE = new RegExp(`^(${NAME_PHRASE})\\s+(?:is|are|am)(\\s+not)?\\s*:\\s*$`, "iu");
+function pushDecls(seg, declText, i, out) {
+  const possessions = parsePossessions(seg);
+  if (possessions.length > 0) {
+    for (const poss of possessions) {
+      out.push(
+        poss.kind === "property" ? { line: i, name: poss.owner, items: poss.items, negated: poss.negated, path: poss.path, cardinality: poss.cardinality } : { line: i, name: poss.owner, items: [], negated: false, owns: poss.thing }
+      );
+    }
+    return true;
+  }
+  const d = findDeclaredItems(declText);
+  if (d) {
+    out.push({ line: i, name: d.name, items: d.items, negated: d.negated, ...d.list ? { list: true } : {} });
+    return true;
+  }
+  return false;
+}
+function resolveDeclarations(rawLines) {
+  const out = [];
+  let header = null;
+  const toolMask = toolBlockMask(rawLines);
+  rawLines.forEach((raw, i) => {
+    if (toolMask[i]) return;
+    const trimmed = raw.trim();
+    if (trimmed === "" || isHeadingLine(trimmed)) {
+      header = null;
+      return;
+    }
+    const bullet = raw.match(BULLET_RE);
+    const clause = stripInlineComment(bullet ? bullet[1] ?? "" : trimmed).trim();
+    if (bullet && header && clause !== "") {
+      out.push({ line: i, name: header.name, items: [stripPunct(clause)], negated: header.negated });
+      return;
+    }
+    if (!bullet) {
+      const hm = clause.match(LIST_HEADER_RE);
+      if (hm) {
+        header = { name: (hm[1] ?? "").trim(), negated: Boolean(hm[2]) };
+        out.push({ line: i, name: header.name, items: [], negated: header.negated });
+        return;
+      }
+    }
+    const sentences = splitSentences(clause);
+    if (sentences.length > 1) {
+      let matched = false;
+      for (const s of sentences) if (pushDecls(s.text, s.text, i, out)) matched = true;
+      if (matched) {
+        header = null;
+        return;
+      }
+    } else if (pushDecls(clause, raw, i, out)) {
+      header = null;
+      return;
+    }
+    if (!bullet) header = null;
+  });
+  return out;
+}
+function properNounAlias(value) {
+  const first = (value.split(",")[0] ?? "").trim();
+  if (first === "" || /^(?:a|an|the)\s/i.test(first)) return null;
+  return /^\p{Lu}[\p{L}.]*(?:\s+\p{Lu}[\p{L}.]*)*$/u.test(first) ? first : null;
+}
+function declaredObjectNames(decls) {
+  return new Set(decls.filter((d) => !d.negated && !d.path && !d.owns).map((d) => d.name.toLowerCase()));
+}
+function objectRefAlias(value, declaredNames) {
+  const first = (value.split(",")[0] ?? "").trim();
+  const key = stripPunct(first).toLowerCase();
+  return first !== "" && UNHIGHLIGHTED_NAMES.has(key) && declaredNames.has(key) ? first : null;
+}
+function aliasMap(decls) {
+  const direct = /* @__PURE__ */ new Map();
+  const declaredNames = declaredObjectNames(decls);
+  for (const d of decls) {
+    if (d.negated || d.path || d.owns) continue;
+    for (const item of d.items) {
+      const nm = properNounAlias(item) ?? objectRefAlias(item, declaredNames);
+      if (!nm) continue;
+      const ak = stripPunct(nm).toLowerCase();
+      const ck = d.name.toLowerCase();
+      if (ak !== ck && !direct.has(ak)) direct.set(ak, ck);
+    }
+  }
+  const canon = (k) => {
+    const seen = /* @__PURE__ */ new Set();
+    let cur = k;
+    while (direct.has(cur) && !seen.has(cur)) {
+      seen.add(cur);
+      cur = direct.get(cur) ?? cur;
+    }
+    return cur;
+  };
+  const resolved = /* @__PURE__ */ new Map();
+  for (const k of direct.keys()) resolved.set(k, canon(k));
+  return resolved;
+}
+function collectObjects(rawLines) {
+  const literal = examplesMask(rawLines);
+  const decls = resolveDeclarations(rawLines.map((l, i) => literal[i] ? "" : stripAnnotation(l)));
+  const aliases = aliasMap(decls);
+  const declaredNames = declaredObjectNames(decls);
+  const canon = (key) => aliases.get(key) ?? key;
+  const objects = /* @__PURE__ */ new Map();
+  for (const d of decls) {
+    if (d.negated) continue;
+    const subjKey = d.name.toLowerCase();
+    const key = canon(subjKey);
+    let obj = objects.get(key);
+    if (!obj) {
+      obj = { name: d.name, items: [], properties: /* @__PURE__ */ new Map(), owns: [], aliases: [], lines: [] };
+      objects.set(key, obj);
+    }
+    if (subjKey === key) obj.name = d.name;
+    if (!obj.lines.includes(d.line)) obj.lines.push(d.line);
+    if (d.owns) {
+      if (!obj.owns.includes(d.owns)) obj.owns.push(d.owns);
+    } else if (d.path) {
+      const pathKey = d.path.join(".");
+      const pv = obj.properties.get(pathKey) ?? { values: [], cardinality: "one", lines: [] };
+      if (d.cardinality === "many") pv.cardinality = "many";
+      for (const it of d.items) if (!pv.values.includes(it)) pv.values.push(it);
+      if (!pv.lines.includes(d.line)) pv.lines.push(d.line);
+      obj.properties.set(pathKey, pv);
+    } else {
+      if (d.list) {
+        const members = obj.listMembers ?? [];
+        for (const it of d.items) if (!members.includes(it)) members.push(it);
+        obj.listMembers = members;
+      }
+      for (const it of d.items) {
+        const nm = properNounAlias(it) ?? objectRefAlias(it, declaredNames);
+        if (nm) {
+          const alias = stripPunct(nm);
+          if (alias.toLowerCase() !== key && !obj.aliases.includes(alias)) obj.aliases.push(alias);
+          const rest = it.slice(nm.length).replace(/^\s*,\s*/, "").trim();
+          if (rest !== "" && !obj.items.includes(rest)) obj.items.push(rest);
+        } else if (!obj.items.includes(it)) {
+          obj.items.push(it);
+        }
+      }
+    }
+  }
+  rawLines.forEach((raw, i) => {
+    if (literal[i]) return;
+    const line = stripInlineComment(stripAnnotation(raw));
+    const text = line.replace(BULLET_RE, "$1").trim();
+    if (text === "" || text.startsWith("//") || isHeadingLine(text)) return;
+    if (/^\$?(?:IF|ELSE)\b/i.test(text) || /\bIF\b.+\bTHEN\b/i.test(text)) return;
+    const bound = parseCardinalBody(maskQuotes(text));
+    if (!bound) return;
+    if (bound.tail !== "") return;
+    if (bound.owner !== void 0) {
+      const ownerKey = canon(bound.owner);
+      let owner = objects.get(ownerKey);
+      if (!owner) {
+        owner = { name: bound.owner, items: [], properties: /* @__PURE__ */ new Map(), owns: [], aliases: [], lines: [] };
+        objects.set(ownerKey, owner);
+      }
+      if (!owner.lines.includes(i)) owner.lines.push(i);
+      const pv = owner.properties.get(bound.noun) ?? { values: [], cardinality: "one", lines: [] };
+      const plo = Math.max(pv.count?.lo ?? 0, bound.lo);
+      const phi = Math.min(pv.count?.hi ?? Infinity, bound.hi);
+      pv.count = plo <= phi ? { lo: plo, hi: phi, lines: [...pv.count?.lines ?? [], i] } : { lo: pv.count?.lo ?? bound.lo, hi: pv.count?.hi ?? bound.hi, lines: [...pv.count?.lines ?? [], i] };
+      if (!pv.lines.includes(i)) pv.lines.push(i);
+      owner.properties.set(bound.noun, pv);
+      return;
+    }
+    const candidates = [bound.noun, pluralizeNoun(bound.noun)].map((k) => canon(k));
+    const key = candidates.find((k) => objects.has(k)) ?? bound.noun;
+    let obj = objects.get(key);
+    if (!obj) {
+      obj = { name: bound.noun, items: [], properties: /* @__PURE__ */ new Map(), owns: [], aliases: [], lines: [] };
+      objects.set(key, obj);
+    }
+    if (!obj.lines.includes(i)) obj.lines.push(i);
+    const prev = obj.count;
+    const lo = Math.max(prev?.lo ?? 0, bound.lo);
+    const hi = Math.min(prev?.hi ?? Infinity, bound.hi);
+    obj.count = lo <= hi ? { lo, hi, lines: [...prev?.lines ?? [], i] } : { lo: prev?.lo ?? bound.lo, hi: prev?.hi ?? bound.hi, lines: [...prev?.lines ?? [], i] };
+  });
+  return objects;
+}
+var UNHIGHLIGHTED_NAMES = /* @__PURE__ */ new Set([
+  "you",
+  "your",
+  "yours",
+  "i",
+  "me",
+  "my",
+  "mine",
+  "we",
+  "us",
+  "our",
+  "ours",
+  "it",
+  "its",
+  "they",
+  "them",
+  "their",
+  "theirs",
+  "he",
+  "him",
+  "his",
+  "she",
+  "her",
+  "hers",
+  "this",
+  "that",
+  "these",
+  "those"
+]);
+var NEVER_ADDRESSEE = /* @__PURE__ */ new Set(["user", "customer", "caller", "human", "visitor", "they", "them"]);
+function addresseeSubjects(rawLines, extra = []) {
+  const decls = resolveDeclarations(rawLines);
+  const aliases = aliasMap(decls);
+  const out = /* @__PURE__ */ new Set();
+  const add = (phrase) => {
+    const stripped = phrase.trim().toLowerCase().replace(/^(?:the|a|an)\s+/, "").replace(/[.,;:!?]+$/, "").trim();
+    if (stripped === "" || stripped === "you") return;
+    const words = stripped.split(/\s+/);
+    const last = words[words.length - 1] ?? "";
+    if (NEVER_ADDRESSEE.has(stripped) || NEVER_ADDRESSEE.has(singularizeNoun(last))) return;
+    out.add(stripped);
+    const other = singularizeNoun(last) === last ? pluralizeNoun(last) : singularizeNoun(last);
+    if (other !== last && other.length > 1) out.add([...words.slice(0, -1), other].join(" "));
+  };
+  for (const [alias, target] of aliases) if (target === "you") add(alias);
+  for (const d of decls) {
+    const canon = aliases.get(d.name.toLowerCase()) ?? d.name.toLowerCase();
+    if (canon !== "you" || d.negated) continue;
+    for (const item of d.items) if (/^an?\s+/i.test(item)) add(item);
+  }
+  for (const e of extra) add(e);
+  return out;
+}
+function findEnumDeclaration(text) {
+  const d = findDeclaration(stripInlineComment(text));
+  if (!d || d.negated) return null;
+  const m = d.value.match(/^one\s+of\s*(:)?\s*(.+)$/i);
+  if (!m) return null;
+  const members = (m[2] ?? "").split(",").map((s) => s.trim()).filter((s) => s !== "");
+  if (m[1] === void 0 && members.length === 1 && isCardinalQuantityLead(members[0] ?? "")) return null;
+  return members.length > 0 ? { name: d.name, members } : null;
+}
+function expandToolRefs(text, tools, imported) {
+  if (tools.size === 0 && (imported?.size ?? 0) === 0) return text;
+  const standalone = /^\s*(?:[-*]\s+)?@\[[a-z][a-z0-9_]*\]\s*\.?\s*$/i.test(text);
+  return text.replace(/@\[([a-z][a-z0-9_]*)\]/gi, (whole, name) => {
+    const key = name.toLowerCase();
+    if (tools.has(key)) {
+      const desc = tools.get(key) ?? "";
+      return standalone && desc !== "" ? `${name} \u2014 ${desc}` : name;
+    }
+    return imported?.has(key) === true ? name : whole;
+  });
+}
+function expandRefs(text, decls) {
+  let cur = text;
+  for (let pass = 0; pass < 5; pass += 1) {
+    const next = cur.replace(/@\{([A-Za-z0-9_.]+)\}/g, (_whole, name) => decls.get(name.toLowerCase()) ?? `{${name}}`);
+    if (next === cur) break;
+    cur = next;
+  }
+  return cur;
+}
+var COMPILED_LIST_ITEM = /^\s*(?:[-*+]\s|(?:\d{1,9}|[a-z])[.)]\s)/i;
+function classifyCompiledLine(text) {
+  if (text.trim() === "") return "blank";
+  const t = text.trimStart();
+  if (t.startsWith("<") || t.startsWith("#") || COMPILED_LIST_ITEM.test(text)) return "keep";
+  return "flow";
+}
+function joinCompiledLines(lines, kinds) {
+  const res = [];
+  let buf = null;
+  let bufIndent = "";
+  let pendingBlank = false;
+  const flush = () => {
+    if (buf !== null) {
+      res.push(buf);
+      buf = null;
+      bufIndent = "";
+    }
+  };
+  for (let i = 0; i < lines.length; i += 1) {
+    const text = lines[i] ?? "";
+    const kind = kinds[i] ?? "flow";
+    if (kind === "blank") {
+      pendingBlank = true;
+      continue;
+    }
+    if (kind === "flow") {
+      const indent = (text.match(/^ */) ?? [""])[0];
+      if (buf !== null && !pendingBlank && indent === bufIndent) {
+        buf += ` ${text.slice(indent.length)}`;
+      } else {
+        flush();
+        if (pendingBlank && res.length > 0) res.push("");
+        buf = text;
+        bufIndent = indent;
+      }
+    } else {
+      flush();
+      if (pendingBlank && res.length > 0) res.push("");
+      res.push(text);
+    }
+    pendingBlank = false;
+  }
+  flush();
+  while (res.length > 0 && (res[0] ?? "").trim() === "") res.shift();
+  while (res.length > 0 && (res[res.length - 1] ?? "").trim() === "") res.pop();
+  return res;
+}
+var PromptDoc = class _PromptDoc {
+  lines;
+  constructor(lines) {
+    this.lines = lines;
+  }
+  static parse(text) {
+    const raw = text.replace(/\r\n/g, "\n").split("\n");
+    if (raw.length > 1 && raw[raw.length - 1] === "") raw.pop();
+    const kinds = classifyLines(raw);
+    const lines = raw.map(
+      (t, i) => ({
+        id: `L${i + 1}`,
+        n: i + 1,
+        text: t,
+        enabled: true,
+        kind: kinds[i] ?? "content"
+      })
+    );
+    return new _PromptDoc(lines);
+  }
+  /** Content lines — the candidates for ablation (blank and comment lines are excluded). */
+  contentLines() {
+    return this.lines.filter((l) => l.kind === "content");
+  }
+  byId(id) {
+    return this.lines.find((l) => l.id === id);
+  }
+  // Enabled, non-comment lines joined back to a prompt string. Whole-line comments are dropped; trailing
+  // `//` inline comments are stripped (but left intact inside fenced code). A declaration (`Name IS value`)
+  // BOTH registers `Name` (so {Name} places its value, and the consistency checker reasons over it) AND
+  // renders as the instruction it is — binding and use are the same statement, not a hidden definition. Only
+  // IMPORT lines and comments are stripped; everything else reaches the model.
+  render() {
+    const texts = this.lines.map((l) => l.text);
+    const mask = fenceMask(texts);
+    const toolMask = toolBlockMask(texts);
+    const toolDescs = /* @__PURE__ */ new Map();
+    for (const t of parseTools(texts).tools) toolDescs.set(t.name.toLowerCase(), t.description);
+    const importedToolKeys = toolsFromLines(texts);
+    const decls = /* @__PURE__ */ new Map();
+    this.lines.forEach((l, i) => {
+      if (!l.enabled || l.kind === "comment" || mask[i] || toolMask[i]) return;
+      const d = findDeclaration(stripAnnotation(stripInlineComment(l.text)));
+      if (d && !d.negated) decls.set(d.name.toLowerCase(), d.value);
+    });
+    const active = this.lines.filter((l) => l.enabled && l.kind !== "comment").map((l) => l.text);
+    for (const [key, obj] of collectObjects(active)) {
+      for (const [path, pv] of obj.properties) {
+        const value = pv.values.join(", ");
+        decls.set(`${key}.${path}`, value);
+        for (const alias of obj.aliases) decls.set(`${alias.toLowerCase()}.${path}`, value);
+      }
+    }
+    const out = [];
+    const kinds = [];
+    const testLines = testBlockLines(texts);
+    const exampleLines = exampleBlockLines(texts);
+    const exampleStart = new Map(parseExamples(texts).filter((e) => e.error === null).map((e) => [e.headerLine, e]));
+    const cfgMask = configSectionMask(texts);
+    const switchRw = switchProseRewrite(texts);
+    const QUIET_WRAPPER = /<\/?\?[a-z][a-z0-9_]*(?:\s[^>]*)?>/gi;
+    const litMask = literalSectionMask(texts);
+    const defMask = defListMask(texts);
+    const defStart = new Map(defEntries(texts).map((e) => [e.line, e]));
+    const LITERAL_SIGIL = /<(\/?)"([a-z][a-z0-9_]*)"(?=[\s>])/gi;
+    this.lines.forEach((l, i) => {
+      if (!l.enabled || l.kind === "comment" || toolMask[i] || cfgMask[i]) return;
+      if (testLines.has(i)) return;
+      const ex = exampleStart.get(i);
+      if (ex) {
+        const block = renderExample(ex);
+        out.push(...block);
+        for (let b = 0; b < block.length; b += 1) kinds.push("keep");
+        return;
+      }
+      if (exampleLines.has(i)) return;
+      if (defMask[i]) {
+        const eDef = defStart.get(i);
+        if (eDef) {
+          const block = renderDefBlock(texts, eDef);
+          out.push(...block);
+          for (let b = 0; b < block.length; b += 1) kinds.push("keep");
+        }
+        return;
+      }
+      if (mask[i]) {
+        out.push(l.text);
+        kinds.push("keep");
+        return;
+      }
+      if (litMask[i]) {
+        out.push(l.text);
+        kinds.push("keep");
+        return;
+      }
+      const swr = switchRw.get(i);
+      if (swr === null) return;
+      if (isAnnotationLine(swr ?? l.text)) return;
+      const stripped = stripAnnotation(stripInlineComment(swr ?? l.text));
+      if (IMPORT_RE.test(stripped) || IMPORT_FILE_RE.test(stripped) || REQUIRE_RE.test(stripped) || CONFIG_RE.test(stripped) || DEFINE_RE.test(stripped)) return;
+      const unwrapped = stripped.replace(QUIET_WRAPPER, "");
+      const hadWrapper = unwrapped !== stripped;
+      const body = hadWrapper ? unwrapped.trim() : stripped;
+      if (hadWrapper && body === "") return;
+      const emitted = expandToolRefs(expandRefs(stripQuotes(expandInlineToProse(body)), decls), toolDescs, importedToolKeys).replace(LITERAL_SIGIL, "<$1$2");
+      out.push(emitted);
+      kinds.push(classifyCompiledLine(emitted));
+    });
+    return joinCompiledLines(out, kinds).join("\n");
+  }
+  /** A copy of this doc with the given line disabled (leave-one-out ablation). */
+  without(id) {
+    return new _PromptDoc(this.lines.map((l) => l.id === id ? { ...l, enabled: false } : { ...l }));
+  }
+  toData() {
+    return { lines: this.lines.map((l) => ({ ...l })) };
+  }
+};
+
+// src/core/xml.ts
+function tagName(heading) {
+  return heading.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "section";
+}
+function compileToXml(systemContent, instructionsContent) {
+  const parts = [];
+  const sys = PromptDoc.parse(stripIndent(systemContent)).render();
+  if (sys) parts.push(sys);
+  const instr = PromptDoc.parse(stripIndent(instructionsContent)).render();
+  if (instr) parts.push(instr);
+  return parts.join("\n\n");
+}
+
+// src/core/config-schema.ts
+var BUILTIN_CONFIG_SCHEMA = {
+  model: {
+    detail: "the target model \u2014 id on the header, settings as params",
+    placeholder: "claude-opus-4",
+    params: {
+      via: { detail: "the $SERVICE that carries the request", type: { kind: "service" }, required: true, placeholder: "service_name" },
+      max_tokens: { detail: "the output token cap", type: { kind: "prim", prim: "number" }, placeholder: "8192" },
+      temperature: { detail: "sampling temperature (0.0\u20132.0)", type: { kind: "prim", prim: "number" }, placeholder: "0.3" }
+    }
+  },
+  modality: { detail: "the interaction channel", values: ["voice", "chat"] },
+  language: { detail: "a language code", placeholder: "en" },
+  // A SIMPLE kind: extra addressee nouns are a flat list on the header/domain form, no params needed.
+  addressee: { detail: 'extra subjects that mean "you" (the addressee model, SPEC \xA77)', placeholder: "one of assistant, support_agent" }
+};
+function renderParamType(t) {
+  if (t.kind === "service") return "a $SERVICE name";
+  if (t.kind === "object") return "a nested block";
+  return renderTypeExpr(t);
+}
+function placeholderFor(t) {
+  if (t.kind === "service") return "service_name";
+  if (t.kind === "prim") return t.prim === "boolean" ? "true" : t.prim === "string" ? "text" : "0";
+  if (t.kind === "oneOf" || t.kind === "anyOf") return t.members[0];
+  if (t.kind === "list") return `${t.prim}, \u2026`;
+  return void 0;
+}
+function paramFromType(text) {
+  let t = text.trim();
+  let required;
+  const marker = t.match(/^(required|optional)\s+(.+)$/i);
+  if (marker) {
+    required = marker[1].toLowerCase() === "required";
+    t = marker[2].trim();
+  }
+  let type;
+  if (/^service$/i.test(t)) {
+    type = { kind: "service" };
+  } else {
+    const parsed = parseTypeExpr(t);
+    type = parsed?.ok ? parsed.expr : { kind: "prim", prim: "string" };
+  }
+  return { detail: renderParamType(type), type, required, placeholder: placeholderFor(type) };
+}
+function paramsFromBody(leaves, objects) {
+  const out = {};
+  for (const [name, typeText] of leaves) out[name] = paramFromType(typeText);
+  for (const [name, obj] of objects ?? /* @__PURE__ */ new Map()) {
+    out[name] = { detail: "a nested block", type: { kind: "object", params: paramsFromBody(obj.params, obj.objects) } };
+  }
+  return out;
+}
+function parseGlishConfigSchema(glishSource) {
+  const out = {};
+  for (const block of parseConfigBlocks(glishSource.split("\n"))) {
+    const key = { detail: "" };
+    if (block.value) {
+      const parsed = parseTypeExpr(block.value);
+      if (parsed?.ok && (parsed.expr.kind === "oneOf" || parsed.expr.kind === "anyOf")) {
+        key.values = parsed.expr.members;
+        key.detail = `one of: ${parsed.expr.members.join(", ")}`;
+      } else {
+        key.placeholder = block.value;
+      }
+    }
+    const params = paramsFromBody(block.params, block.objects);
+    if (Object.keys(params).length > 0) key.params = params;
+    out[block.kind] = key;
+  }
+  return out;
+}
+function resolveConfigSchema(glishSource) {
+  if (!glishSource) return BUILTIN_CONFIG_SCHEMA;
+  const out = { ...BUILTIN_CONFIG_SCHEMA };
+  for (const [kind, gk] of Object.entries(parseGlishConfigSchema(glishSource))) {
+    const base = out[kind];
+    out[kind] = base ? {
+      detail: gk.detail || base.detail,
+      values: gk.values ?? base.values,
+      placeholder: gk.placeholder ?? base.placeholder,
+      ...base.params || gk.params ? { params: { ...base.params, ...gk.params } } : {}
+    } : { ...gk, detail: gk.detail || "declared in glish.tgc" };
+  }
+  return out;
+}
+var CONFIG_HEADER_RE = /^\s*\$CONFIG\s+([a-z][\w-]*)(?:\s+(\S.*?))?\s*$/i;
+var CONFIG_PARAM_RE = /^\s*-\s+([a-z][a-z0-9_]*)::\s*(.*?)\s*$/i;
+var indentWidth = (line) => (line.match(/^[ \t]*/) ?? [""])[0].length;
+function parseParamBody(rawLines, start, parentIndent) {
+  const params = /* @__PURE__ */ new Map();
+  const objects = /* @__PURE__ */ new Map();
+  let j = start;
+  while (j < rawLines.length) {
+    const line = rawLines[j] ?? "";
+    if (line.trim() === "") {
+      j += 1;
+      continue;
+    }
+    if (indentWidth(line) <= parentIndent) break;
+    const pm = line.match(CONFIG_PARAM_RE);
+    if (!pm) {
+      j += 1;
+      continue;
+    }
+    const name = (pm[1] ?? "").toLowerCase();
+    const value = (pm[2] ?? "").trim();
+    let nextDeeper = false;
+    for (let k = j + 1; k < rawLines.length; k += 1) {
+      const nl = rawLines[k] ?? "";
+      if (nl.trim() === "") continue;
+      nextDeeper = indentWidth(nl) > indentWidth(line);
+      break;
+    }
+    if (value === "" && nextDeeper) {
+      const sub = parseParamBody(rawLines, j + 1, indentWidth(line));
+      objects.set(name, { params: sub.params, ...sub.objects.size ? { objects: sub.objects } : {}, line: j });
+      j = sub.end;
+    } else {
+      params.set(name, value);
+      j += 1;
+    }
+  }
+  return { params, objects, end: j };
+}
+function parseConfigBlocks(rawLines) {
+  const blocks = [];
+  let inFence = false;
+  for (let i = 0; i < rawLines.length; i += 1) {
+    const t = (rawLines[i] ?? "").trim();
+    if (t.startsWith("```") || t.startsWith("~~~")) {
+      inFence = !inFence;
+      continue;
+    }
+    const h = inFence ? null : (rawLines[i] ?? "").match(CONFIG_HEADER_RE);
+    if (!h) continue;
+    const body = parseParamBody(rawLines, i + 1, indentWidth(rawLines[i] ?? ""));
+    blocks.push({ kind: (h[1] ?? "").toLowerCase(), value: (h[2] ?? "").trim(), params: body.params, ...body.objects.size ? { objects: body.objects } : {}, line: i });
+    i = body.end - 1;
+  }
+  return blocks;
+}
+function refineViolation(t, value) {
+  if (t.kind !== "prim" || !t.refine) return null;
+  const r = t.refine;
+  if (t.prim === "string") {
+    if (r.pattern !== void 0 && !new RegExp(r.pattern).test(value)) return `must match /${r.pattern}/`;
+    if (r.minLen !== void 0 && value.length < r.minLen) return `must be at least ${r.minLen} characters`;
+    if (r.maxLen !== void 0 && value.length > r.maxLen) return `must be at most ${r.maxLen} characters`;
+    return null;
+  }
+  const n = Number(value);
+  if (!Number.isFinite(n)) return null;
+  if (r.min !== void 0 && n < r.min) return `must be at least ${r.min}`;
+  if (r.max !== void 0 && n > r.max) return `must be at most ${r.max}`;
+  return null;
+}
+function configParamDiagnostics(rawLines, schema, serviceNames) {
+  const out = [];
+  const range = (line) => {
+    const raw = rawLines[line] ?? "";
+    return { line, start: raw.length - raw.trimStart().length, end: raw.trimEnd().length };
+  };
+  const indentOf = (line) => ((rawLines[line] ?? "").match(/^\s*/)?.[0] ?? "").length;
+  const paramLine = (headerLine, name) => {
+    const re = new RegExp(`^\\s*-\\s+${name}::`, "i");
+    for (let j = headerLine + 1; j < rawLines.length; j += 1) {
+      const l = rawLines[j] ?? "";
+      if (l.trim() === "") continue;
+      if (indentOf(j) <= indentOf(headerLine)) break;
+      if (re.test(l)) return j;
+    }
+    return headerLine;
+  };
+  const checkBody = (schemaParams, leaves, objects, kind, headerLine) => {
+    for (const [name, p] of Object.entries(schemaParams)) {
+      const present = p.type.kind === "object" ? !!objects?.has(name) : leaves.has(name);
+      if (p.required && !present) {
+        out.push({ ...range(headerLine), severity: "warn", code: "config/missing-param", message: `$CONFIG ${kind} is missing the required "${name}" \u2014 add "- ${name}:: \u2026" beneath it.` });
+      }
+    }
+    leaves.forEach((value, name) => {
+      const p = schemaParams[name];
+      const ln = paramLine(headerLine, name);
+      if (p === void 0) {
+        out.push({ ...range(ln), severity: "info", code: "config/unknown-param", message: `"${name}" isn't a known param of $CONFIG ${kind}.` });
+      } else if (p.type.kind === "object") {
+        out.push({ ...range(ln), severity: "info", code: "config/unknown-param", message: `$CONFIG ${kind} \u2192 ${name} is a nested block \u2014 give it indented "- \u2026::" rows, not a value.` });
+      } else if (value !== "") {
+        const t = p.type;
+        const num = Number(value);
+        if (t.kind === "service" && !serviceNames.has(value)) {
+          out.push({ ...range(ln), severity: "error", code: "config/dangling-service", message: `$CONFIG ${kind} \u2192 ${name} names "${value}", but no "$SERVICE ${value}" is defined.` });
+        } else if (t.kind === "prim" && (t.prim === "number" || t.prim === "integer") && !Number.isFinite(num)) {
+          out.push({ ...range(ln), severity: "warn", code: "config/bad-number", message: `$CONFIG ${kind} \u2192 ${name} should be a number \u2014 got "${value}".` });
+        } else if (t.kind === "prim" && t.prim === "integer" && !Number.isInteger(num)) {
+          out.push({ ...range(ln), severity: "warn", code: "config/bad-number", message: `$CONFIG ${kind} \u2192 ${name} should be a whole number \u2014 got "${value}".` });
+        } else {
+          const v = refineViolation(t, value);
+          if (v) out.push({ ...range(ln), severity: "warn", code: "config/out-of-range", message: `$CONFIG ${kind} \u2192 ${name} ${v} \u2014 got "${value}".` });
+        }
+      }
+    });
+    objects?.forEach((obj, name) => {
+      const p = schemaParams[name];
+      if (p === void 0) {
+        out.push({ ...range(obj.line), severity: "info", code: "config/unknown-param", message: `"${name}" isn't a known param of $CONFIG ${kind}.` });
+      } else if (p.type.kind !== "object") {
+        out.push({ ...range(obj.line), severity: "info", code: "config/unknown-param", message: `$CONFIG ${kind} \u2192 ${name} takes a value, not a nested block.` });
+      } else {
+        checkBody(p.type.params, obj.params, obj.objects, `${kind} \u2192 ${name}`, obj.line);
+      }
+    });
+  };
+  for (const block of parseConfigBlocks(rawLines)) {
+    const params = schema[block.kind]?.params;
+    if (params) checkBody(params, block.params, block.objects, block.kind, block.line);
+  }
+  return out;
+}
+var CONFIG_RULE_RE = /^\s*\$REQUIRE\s+([a-z][\w-]*)\s+when\s+([a-z][\w-]*)\s+is\s+(\S.*?)\s*$/i;
+function parseConfigRules(glishSource) {
+  const rules = [];
+  glishSource.split("\n").forEach((raw, line) => {
+    const m = raw.match(CONFIG_RULE_RE);
+    if (m) rules.push({ target: (m[1] ?? "").toLowerCase(), whenKind: (m[2] ?? "").toLowerCase(), whenValue: (m[3] ?? "").trim(), line });
+  });
+  return rules;
+}
+function configRuleDiagnostics(rawLines, rules) {
+  if (rules.length === 0) return [];
+  const byKind = new Map(parseConfigBlocks(rawLines).map((b) => [b.kind, b]));
+  const out = [];
+  for (const rule of rules) {
+    const cond = byKind.get(rule.whenKind);
+    if (cond && cond.value === rule.whenValue && !byKind.has(rule.target)) {
+      const raw = rawLines[cond.line] ?? "";
+      out.push({ line: cond.line, start: raw.length - raw.trimStart().length, end: raw.trimEnd().length, severity: "warn", code: "config/missing-conditional", message: `$CONFIG ${rule.whenKind} is "${rule.whenValue}", so $CONFIG ${rule.target} is required \u2014 add it.` });
+    }
+  }
+  return out;
+}
+
+// src/core/models.generated.ts
+var MODELS_GENERATED_AT = "2026-07-01";
+var KNOWN_MODELS = [
+  // Anthropic — https://api.anthropic.com/v1/models
+  // Current line-up, confirmed against the live endpoint 2026-07-09 (a full refresh would drop the
+  // committed OpenAI/Google entries when those keys are absent, so these three merged surgically).
+  { id: "claude-opus-4-8", vendor: "anthropic" },
+  { id: "claude-sonnet-4-6", vendor: "anthropic" },
+  { id: "claude-haiku-4-5-20251001", vendor: "anthropic", aliases: ["claude-haiku-4-5"] },
+  { id: "claude-opus-4-1-20250805", vendor: "anthropic", aliases: ["claude-opus-4-1"] },
+  { id: "claude-opus-4-20250514", vendor: "anthropic", aliases: ["claude-opus-4-0"] },
+  { id: "claude-sonnet-4-20250514", vendor: "anthropic", aliases: ["claude-sonnet-4-0"] },
+  { id: "claude-3-7-sonnet-20250219", vendor: "anthropic", aliases: ["claude-3-7-sonnet-latest"] },
+  { id: "claude-3-5-sonnet-20241022", vendor: "anthropic", aliases: ["claude-3-5-sonnet-latest"] },
+  { id: "claude-3-5-haiku-20241022", vendor: "anthropic", aliases: ["claude-3-5-haiku-latest"] },
+  { id: "claude-3-haiku-20240307", vendor: "anthropic" },
+  // OpenAI — https://api.openai.com/v1/models (chat/reasoning models only)
+  { id: "gpt-4o", vendor: "openai" },
+  { id: "gpt-4o-mini", vendor: "openai" },
+  { id: "gpt-4.1", vendor: "openai" },
+  { id: "gpt-4.1-mini", vendor: "openai" },
+  { id: "o3", vendor: "openai" },
+  { id: "o4-mini", vendor: "openai" },
+  // Google — https://generativelanguage.googleapis.com/v1beta/models
+  { id: "gemini-2.5-pro", vendor: "google" },
+  { id: "gemini-2.5-flash", vendor: "google" },
+  { id: "gemini-2.0-flash", vendor: "google" }
+];
+
+// src/core/models.ts
+var norm2 = (id) => id.trim().toLowerCase();
+var stem = (id) => norm2(id).replace(/-\d{4,}$/, "");
+var CANDIDATES = /* @__PURE__ */ new Map();
+var KNOWN = /* @__PURE__ */ new Set();
+for (const m of [...KNOWN_MODELS].sort((a, b) => a.id.length - b.id.length)) {
+  const id = norm2(m.id);
+  KNOWN.add(id);
+  if (!CANDIDATES.has(id)) CANDIDATES.set(id, m.id);
+  const s = stem(m.id);
+  if (!CANDIDATES.has(s)) CANDIDATES.set(s, m.id);
+  for (const a of m.aliases ?? []) {
+    KNOWN.add(norm2(a));
+    if (!CANDIDATES.has(norm2(a))) CANDIDATES.set(norm2(a), m.id);
+  }
+}
+var CANONICAL_IDS = [...new Set(KNOWN_MODELS.map((m) => m.id))];
+var FAMILIES = ["claude-", "gpt-", "gemini-", "o1", "o3", "o4", "text-", "chatgpt-"];
+function damerau(a, b) {
+  const al = a.length;
+  const bl = b.length;
+  if (al === 0) return bl;
+  if (bl === 0) return al;
+  const d = Array.from({ length: al + 1 }, () => new Array(bl + 1).fill(0));
+  for (let i = 0; i <= al; i += 1) d[i][0] = i;
+  for (let j = 0; j <= bl; j += 1) d[0][j] = j;
+  for (let i = 1; i <= al; i += 1) {
+    for (let j = 1; j <= bl; j += 1) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+      }
+    }
+  }
+  return d[al][bl];
+}
+function classifyModel(id) {
+  const n = norm2(id);
+  if (KNOWN.has(n)) return { kind: "known" };
+  const dated = /-\d{4,}$/.test(n);
+  if (!dated) {
+    const prefixed = CANONICAL_IDS.filter((k) => norm2(k).startsWith(`${n}-`)).sort((a, b) => a.length - b.length);
+    if (prefixed.length > 0) return { kind: "incomplete", suggest: prefixed[0] };
+    let best = null;
+    for (const [cand, canonical] of CANDIDATES) {
+      const dist = damerau(n, cand);
+      if (!best || dist < best.dist) best = { suggest: canonical, dist };
+    }
+    if (best && best.dist <= Math.max(1, Math.floor(n.length * 0.2))) return { kind: "typo", suggest: best.suggest };
+  }
+  if (FAMILIES.some((f) => n.startsWith(f))) return { kind: "maybe-newer" };
+  return { kind: "unknown" };
+}
+function checkModel(rawLines) {
+  const out = [];
+  for (let i = 0; i < rawLines.length; i += 1) {
+    const raw = rawLines[i] ?? "";
+    const m = raw.match(CONFIG_RE);
+    if (!m || (m[1] ?? "").toLowerCase() !== "model") continue;
+    const value = (m[2] ?? "").split(",")[0].trim();
+    if (value === "") continue;
+    const start = raw.length - raw.trimStart().length;
+    const end = raw.trimEnd().length;
+    const v = classifyModel(value);
+    if (v.kind === "known") continue;
+    if (v.kind === "maybe-newer") {
+      out.push({
+        line: i,
+        start,
+        end,
+        severity: "info",
+        message: `"${value}" isn't in the known-model list (as of ${MODELS_GENERATED_AT}). If it's newer than the list, ignore this \u2014 the list refreshes from the vendors.`
+      });
+      continue;
+    }
+    const suggest = v.kind === "incomplete" || v.kind === "typo" ? ` Did you mean "${v.suggest}"?` : "";
+    out.push({
+      line: i,
+      start,
+      end,
+      severity: "warn",
+      message: `Unknown model "${value}".${suggest} $CONFIG model isn't validated at runtime, so a wrong id fails only when the agent runs.`
+    });
+  }
+  return out;
+}
+
+// src/core/structure.ts
+var STEP = /^(\d+(?:\.\d+)*)[.)]\s+(.*)$/;
+var ANCHOR_DECL = /^#([a-z][a-z0-9_]*)\s+(.*)$/i;
+function splitAnchor(text) {
+  const m = text.match(ANCHOR_DECL);
+  return m ? { anchor: (m[1] ?? "").toLowerCase(), text: m[2] ?? "" } : { anchor: null, text };
+}
+var SECTION_LEAD = new RegExp(`^\\s*<(\\/?)(${TAG_NAME_SRC})(?:\\s[^>]*)?>`, "i");
+var SECTION_CLOSE_TAIL = new RegExp(`<\\/(${TAG_NAME_SRC})>\\s*$`, "i");
+function matchSectionTag(raw) {
+  const lead = raw.match(SECTION_LEAD);
+  if (lead) {
+    const name = (lead[2] ?? "").toLowerCase();
+    if (lead[1] === "/") return { open: null, close: name, inline: false };
+    const closeM2 = raw.slice((lead.index ?? 0) + lead[0].length).match(SECTION_CLOSE_TAIL);
+    return closeM2 ? { open: name, close: (closeM2[1] ?? "").toLowerCase(), inline: true } : { open: name, close: null, inline: false };
+  }
+  const closeM = raw.match(SECTION_CLOSE_TAIL);
+  return closeM ? { open: null, close: (closeM[1] ?? "").toLowerCase(), inline: false } : null;
+}
+var HEADING = /^\s*(#{1,6})\s+(.+?)\s*$/;
+var VARREF = /@\{([a-z][a-z0-9_]*)\}/g;
+function parseWhenAttr(raw) {
+  const m = raw.match(/\bwhen=/i);
+  if (!m || m.index === void 0) return null;
+  const col = m.index + m[0].length;
+  const gt = raw.indexOf(">", col);
+  return gt < 0 ? null : { text: raw.slice(col, gt).trim(), col };
+}
+function collectVarUses(masked, line, vars) {
+  VARREF.lastIndex = 0;
+  let m;
+  while ((m = VARREF.exec(masked)) !== null) {
+    const base = (m[1] ?? "").toLowerCase();
+    const sym = vars.get(base) ?? { base, notations: [] };
+    sym.notations.push({ form: "curly", line, start: m.index, end: m.index + m[0].length });
+    vars.set(base, sym);
+  }
+}
+var INPUT_IDENT = /^[a-z][a-z0-9_]*$/i;
+function parseInputType(typeStr) {
+  const parsed = parseTypeExpr(typeStr);
+  if (parsed?.ok) {
+    const e = parsed.expr;
+    if (e.kind === "prim") {
+      return { type: e.prim === "boolean" ? { kind: "bool" } : e.prim === "string" ? { kind: "string" } : { kind: "number" }, error: null };
+    }
+    if (e.kind === "oneOf") {
+      const members = e.members.map((m) => m.toLowerCase());
+      const bad = members.find((v) => !INPUT_IDENT.test(v));
+      if (bad !== void 0) return { type: null, error: `Set member "${bad}" is not a valid identifier (letters, digits, _ \u2014 starting with a letter).` };
+      return { type: { kind: "enum", members }, error: null };
+    }
+    return { type: null, error: `A variable's domain is ONE value \u2014 a primitive or a "one of a, b" set, never a list ("${typeStr.trim()}").` };
+  }
+  if (parsed && !parsed.ok) {
+    return { type: null, error: `${parsed.reason}${parsed.rewrite !== void 0 ? ` Replace the type with: "${parsed.rewrite}".` : ""}` };
+  }
+  const legacy = translateLegacyTypeHead(typeStr);
+  if (legacy !== null) {
+    return { type: null, error: `Domains are English \u2014 "one of a, b" for a closed set \u2014 never "|" pipes. Replace the type with: "${legacy}".` };
+  }
+  return { type: null, error: `"${typeStr.trim()}" is not a domain. The forms: boolean, number, integer, string, or "one of a, b".` };
+}
+function parseTypedInput(payload) {
+  const ci = payload.indexOf(":");
+  const name = payload.slice(0, ci).trim();
+  const typeStr = payload.slice(ci + 1).trim();
+  if (!INPUT_IDENT.test(name)) return { name, type: null, error: `"${name || "(empty)"}" is not a valid input name.` };
+  if (typeStr === "") return { name, type: null, error: `Input "${name}" has no domain after ":" \u2014 write ": boolean", ": number", ": string", or ": one of a, b".` };
+  const { type, error } = parseInputType(typeStr);
+  return { name, type, error: error === null ? null : `Input "${name}": ${error}` };
+}
+function looseContentLines(rawLines) {
+  const kinds = classifyLines(rawLines);
+  const toolMask = toolBlockMask(rawLines);
+  const exMask = examplesMask(rawLines);
+  const cover = [];
+  const loose = [];
+  let sawSection = false;
+  let inFence = false;
+  rawLines.forEach((raw, i) => {
+    const t = raw.trim();
+    if (t.startsWith("```") || t.startsWith("~~~")) {
+      inFence = !inFence;
+      return;
+    }
+    if (inFence || kinds[i] !== "content" || toolMask[i] || exMask[i]) return;
+    if (TRANSCLUSION_LINE_RE.test(raw)) return;
+    const hm = raw.match(HEADING);
+    if (hm) {
+      const level = (hm[1] ?? "").length;
+      while (cover.length > 0) {
+        const top = cover[cover.length - 1];
+        if (top.kind === "heading" && top.level >= level) cover.pop();
+        else break;
+      }
+      cover.push({ kind: "heading", level });
+      sawSection = true;
+      return;
+    }
+    const st = matchSectionTag(raw);
+    if (st) {
+      if (st.open) {
+        while (cover.length > 0 && cover[cover.length - 1].kind === "heading") cover.pop();
+        cover.push({ kind: "tag", name: st.open });
+        sawSection = true;
+      }
+      if (st.close) {
+        for (let s = cover.length - 1; s >= 0; s -= 1) {
+          const c = cover[s];
+          if (c.kind === "tag" && c.name === st.close) {
+            cover.length = s;
+            break;
+          }
+        }
+      }
+      const leadClose = raw.match(/^\s*<\/(?:\$?[a-z][a-z0-9_]*)>/i);
+      if (leadClose && sawSection && cover.length === 0 && raw.slice(leadClose[0].length).trim() !== "") {
+        loose.push({ line: i, start: leadClose[0].length });
+      }
+      return;
+    }
+    if (t.startsWith("$")) return;
+    if (sawSection && cover.length === 0) loose.push({ line: i, start: raw.length - raw.trimStart().length });
+  });
+  return loose;
+}
+function headingsOutsideSections(rawLines) {
+  const doc = buildStructure(rawLines);
+  const xml = doc.sections.filter((s) => s.syntax === "xml" && s.control !== true);
+  if (xml.length === 0) return [];
+  const fenced = /* @__PURE__ */ new Set();
+  let inFence = false;
+  rawLines.forEach((raw, i) => {
+    const t = raw.trim();
+    if (t.startsWith("```") || t.startsWith("~~~")) {
+      fenced.add(i);
+      inFence = !inFence;
+      return;
+    }
+    if (inFence) fenced.add(i);
+  });
+  const out = [];
+  for (const h of doc.sections) {
+    if (h.syntax !== "heading" || fenced.has(h.startLine)) continue;
+    const inside = xml.some((x) => h.startLine >= x.startLine && h.startLine < x.endLine);
+    if (inside) continue;
+    const raw = rawLines[h.startLine] ?? "";
+    out.push({ line: h.startLine, start: raw.length - raw.trimStart().length });
+  }
+  return out;
+}
+function buildStructure(rawLines) {
+  const kinds = classifyLines(rawLines);
+  const steps = [];
+  const sections = [];
+  const variables = /* @__PURE__ */ new Map();
+  const imports = [];
+  const fileImports = [];
+  const importLines = /* @__PURE__ */ new Set();
+  const config = /* @__PURE__ */ new Map();
+  const configLines = /* @__PURE__ */ new Set();
+  const inputTypes = /* @__PURE__ */ new Map();
+  const defines = /* @__PURE__ */ new Map();
+  const defineLines = /* @__PURE__ */ new Set();
+  const xmlStack = [];
+  const strayCloses = [];
+  const headingStack = [];
+  const toolMask = toolBlockMask(rawLines);
+  const exMask = examplesMask(rawLines);
+  rawLines.forEach((raw, i) => {
+    if (kinds[i] === "comment" || toolMask[i] || exMask[i]) return;
+    collectVarUses(maskQuotes(raw), i, variables);
+    const fileImp = raw.match(IMPORT_FILE_RE);
+    if (fileImp) {
+      importLines.add(i);
+      fileImports.push({ alias: fileImp[2] ?? "", key: (fileImp[2] ?? "").toLowerCase(), path: fileImp[1] ?? "", line: i });
+      return;
+    }
+    const rq = raw.match(REQUIRE_RE);
+    const im = rq ? null : raw.match(IMPORT_RE);
+    if (rq || im) {
+      importLines.add(i);
+      const kind = rq ? "variable" : im[1] === "input" ? "variable" : im[1];
+      const payload = (rq ? rq[1] : im[2]) ?? "";
+      if (kind === "variable" && payload.includes(":")) {
+        const { name, type } = parseTypedInput(payload);
+        if (INPUT_IDENT.test(name)) {
+          imports.push({ kind, name, key: name.toLowerCase(), line: i, ...type ? { type } : {} });
+          if (type) inputTypes.set(name.toLowerCase(), type);
+        }
+        return;
+      }
+      for (const rawName of payload.split(",")) {
+        const name = rawName.trim().replace(/^["']|["']$/g, "").trim();
+        if (name !== "") imports.push({ kind, name, key: name.toLowerCase(), line: i });
+      }
+      return;
+    }
+    const cf = raw.match(CONFIG_RE);
+    if (cf) {
+      configLines.add(i);
+      const key = (cf[1] ?? "").toLowerCase();
+      if (!config.has(key)) config.set(key, (cf[2] ?? "").trim());
+      return;
+    }
+    const df = raw.match(DEFINE_RE);
+    if (df) {
+      defineLines.add(i);
+      const name = (df[1] ?? "").toLowerCase();
+      if (!defines.has(name)) defines.set(name, { expr: (df[2] ?? "").trim(), line: i });
+      return;
+    }
+    if (CONFIG_SECTION_OPEN.test(raw)) {
+      xmlStack.push({ tag: "$config", line: i });
+      return;
+    }
+    if (CONFIG_SECTION_CLOSE.test(raw)) {
+      let matched = false;
+      for (let s = xmlStack.length - 1; s >= 0; s -= 1) {
+        if (xmlStack[s]?.tag === "$config") {
+          const o = xmlStack.splice(s, 1)[0];
+          if (o) sections.push({ tag: "$config", name: "<$config>", syntax: "xml", startLine: o.line, endLine: i + 1, depth: s, control: true });
+          matched = true;
+          break;
+        }
+      }
+      if (!matched) strayCloses.push({ tag: "$config", line: i });
+      return;
+    }
+    const st = matchSectionTag(raw);
+    if (st) {
+      if (st.open) {
+        const guard = parseWhenAttr(raw);
+        xmlStack.push({ tag: st.open, line: i, ...guard ? { guard } : {} });
+      }
+      if (st.close) {
+        const tag = st.close;
+        let matched = false;
+        for (let s = xmlStack.length - 1; s >= 0; s -= 1) {
+          if (xmlStack[s]?.tag === tag) {
+            const o = xmlStack.splice(s, 1)[0];
+            const literal = tag.startsWith('"');
+            if (o) sections.push({ tag: literal ? tag.slice(1, -1) : tag, name: `<${o.tag}>`, syntax: "xml", startLine: o.line, endLine: i + 1, depth: s, ...literal ? { literal: true } : {}, ...o.guard ? { guard: o.guard } : {} });
+            matched = true;
+            break;
+          }
+        }
+        if (!matched) strayCloses.push({ tag, line: i });
+      }
+      return;
+    }
+    const h = raw.match(HEADING);
+    if (h) {
+      const level = (h[1] ?? "").length;
+      const name = h[2] ?? "";
+      while (headingStack.length && (headingStack[headingStack.length - 1]?.level ?? 0) >= level) {
+        const closed = headingStack.pop();
+        if (closed) closed.sec.endLine = i;
+      }
+      const sec = { tag: tagName(name), name: `# ${name}`, syntax: "heading", startLine: i, endLine: rawLines.length, depth: headingStack.length };
+      sections.push(sec);
+      headingStack.push({ level, sec });
+      return;
+    }
+    const m = raw.trimStart().match(STEP);
+    if (m) {
+      const ord = m[1] ?? "";
+      const segments = ord.split(".").map(Number);
+      const { anchor, text } = splitAnchor(m[2] ?? "");
+      steps.push({
+        ord,
+        segments,
+        major: segments[0] ?? 0,
+        parent: segments.length > 1 ? segments.slice(0, -1).join(".") : null,
+        line: i,
+        text,
+        depth: segments.length - 1,
+        anchor
+      });
+    }
+  });
+  const toolDefs = parseTools(rawLines).tools;
+  const toolKeys = /* @__PURE__ */ new Set([...imports.filter((x) => x.kind === "tool").map((x) => x.key), ...toolDefs.map((t) => t.name)]);
+  const routeKeys = new Set(imports.filter((x) => x.kind === "route").map((x) => x.key));
+  const inputKeys = new Set(imports.filter((x) => x.kind === "variable").map((x) => x.key));
+  const tests = parseTests(rawLines);
+  const examples = parseExamples(rawLines);
+  const aliases = [];
+  {
+    let inFence = false;
+    for (let i = 0; i < rawLines.length; i += 1) {
+      const raw = rawLines[i] ?? "";
+      if (raw.trim().startsWith("```") || raw.trim().startsWith("~~~")) {
+        inFence = !inFence;
+        continue;
+      }
+      if (inFence) continue;
+      const name = annotationAlias(raw);
+      if (name === null) continue;
+      let target = null;
+      let f2 = false;
+      for (let j = i + 1; j < rawLines.length; j += 1) {
+        const r2 = rawLines[j] ?? "";
+        const s2 = r2.trim();
+        if (s2.startsWith("```") || s2.startsWith("~~~")) {
+          f2 = !f2;
+          continue;
+        }
+        if (f2) {
+          target = j;
+          break;
+        }
+        if (s2 === "" || /^\s*\/\//.test(r2) || isAnnotationLine(r2)) continue;
+        target = j;
+        break;
+      }
+      aliases.push({ name, line: i, target });
+    }
+  }
+  return {
+    steps,
+    sections,
+    variables,
+    imports,
+    fileImports,
+    importLines,
+    config,
+    configLines,
+    defines,
+    defineLines,
+    inputTypes,
+    toolDefs,
+    tests,
+    testLines: testBlockLines(rawLines),
+    examples,
+    exampleLines: exampleBlockLines(rawLines),
+    unclosedTags: xmlStack.map((o) => ({ tag: o.tag, line: o.line })),
+    // opens still on the stack at EOF
+    strayCloses,
+    aliases,
+    index: {
+      steps: new Set(steps.map((s) => s.ord)),
+      anchors: new Set(steps.map((s) => s.anchor).filter((a) => a !== null)),
+      sections: new Set(sections.map((s) => s.tag)),
+      tools: toolKeys,
+      routes: routeKeys,
+      inputs: inputKeys,
+      aliases: new Set(aliases.map((a) => a.name))
+    }
+  };
+}
+function resolveAnchors(source) {
+  const lines = source.split("\n");
+  const anchored = buildStructure(lines).steps.filter((s) => s.anchor !== null);
+  if (anchored.length === 0) return source;
+  const label = /* @__PURE__ */ new Map();
+  for (const s of anchored) {
+    if (!s.anchor) continue;
+    label.set(s.anchor, (lines[s.line] ?? "").match(/^\s*(\d+(?:\.\d+)*)/)?.[1] ?? s.ord);
+    lines[s.line] = (lines[s.line] ?? "").replace(/^(\s*\d+(?:\.\d+)*[.)]\s+)#[a-z][a-z0-9_]*\s+/i, "$1");
+  }
+  let inFence = false;
+  return lines.map((line) => {
+    const t = line.trim();
+    if (t.startsWith("```") || t.startsWith("~~~")) {
+      inFence = !inFence;
+      return line;
+    }
+    return inFence ? line : line.replace(/#([a-z][a-z0-9_]*)/gi, (whole, name) => label.get(name.toLowerCase()) ?? whole);
+  }).join("\n");
+}
+function renumberSubSteps(lines) {
+  const doc = buildStructure(lines);
+  const oldToNew = /* @__PURE__ */ new Map();
+  const ambiguous = /* @__PURE__ */ new Set();
+  const childCount = /* @__PURE__ */ new Map();
+  for (const s of [...doc.steps].sort((a, b) => a.line - b.line)) {
+    let neu;
+    if (s.parent === null) neu = String(s.major);
+    else {
+      const parentNew = oldToNew.get(s.parent) ?? s.parent;
+      const n = (childCount.get(parentNew) ?? 0) + 1;
+      childCount.set(parentNew, n);
+      neu = `${parentNew}.${n}`;
+    }
+    if (oldToNew.has(s.ord) && oldToNew.get(s.ord) !== neu) ambiguous.add(s.ord);
+    else oldToNew.set(s.ord, neu);
+  }
+  for (const a of ambiguous) oldToNew.delete(a);
+  const edits = [];
+  for (const s of doc.steps) {
+    const neu = oldToNew.get(s.ord);
+    if (neu === void 0 || neu === s.ord) continue;
+    const m = (lines[s.line] ?? "").match(/^(\s*)(\d+(?:\.\d+)*)/);
+    if (m) edits.push({ line: s.line, start: (m[1] ?? "").length, end: (m[1] ?? "").length + (m[2] ?? "").length, text: neu });
+  }
+  if (edits.length === 0) return lines;
+  for (const r of findReferences(lines, doc)) {
+    if (r.kind !== "step") continue;
+    const neu = oldToNew.get(r.key);
+    if (neu === void 0 || neu === r.key) continue;
+    const text = (lines[r.line] ?? "").slice(r.start, r.end);
+    const rewritten = text.replace(/\d+(?:\.\d+)*/, neu);
+    if (rewritten !== text) edits.push({ line: r.line, start: r.start, end: r.end, text: rewritten });
+  }
+  const out = [...lines];
+  const byLine = /* @__PURE__ */ new Map();
+  for (const e of edits) {
+    const list = byLine.get(e.line) ?? [];
+    list.push(e);
+    byLine.set(e.line, list);
+  }
+  for (const [ln, es] of byLine) {
+    es.sort((a, b) => b.start - a.start);
+    let text = out[ln] ?? "";
+    for (const e of es) text = text.slice(0, e.start) + e.text + text.slice(e.end);
+    out[ln] = text;
+  }
+  return out;
+}
+var STEP_REF_PATTERNS = [
+  /\b(?:flow\s+)?step\s+(\d+(?:\.\d+)*)/gi,
+  // step 2 / flow step 2.1.3
+  /\(step\s+(\d+(?:\.\d+)*)\)/gi,
+  // (step 8) — explicit keyword
+  /\((\d+\.\d+(?:\.\d+)*)\)/gi,
+  // (2.1) — a DOTTED ord; a bare (1)/(2) is a prose enumeration, not a step ref
+  /\b(\d+(?:\.\d+)*)\s*=\s*[a-z]+/gi
+  // 2.1=yes
+];
+var STEP_ORD = /^[1-9]\d*(?:\.[1-9]\d*)*$/;
+var STEP_RANGE = /\b(\d+\.\d+(?:\.\d+)*)\s*[–-]\s*(\d+\.\d+(?:\.\d+)*)\b/g;
+var STEP_POINTER = /\b(?:to|into|goto|see|per|then|at|from)\s+(\d+\.\d+(?:\.\d+)*)\b/gi;
+var INLINE_TAG = /<([a-z][a-z0-9_]*)>/gi;
+var TRANSREF = /@<([a-z][a-z0-9_]*)((?:\.|#)[a-z][a-z0-9_]*)?>/gi;
+var TOOLINLINE = /@\[([a-z][a-z0-9_]*)\]/gi;
+var ANCHOR_REF = /#([a-z][a-z0-9_]*)/gi;
+var MARKER_PREFIX = /^\s*\d+(?:\.\d+)*[.)]\s+$/i;
+function blank(s, re) {
+  return s.replace(re, (m) => " ".repeat(m.length));
+}
+function findReferences(rawLines, doc) {
+  const kinds = classifyLines(rawLines);
+  const xmlOpenLines = new Set(doc.sections.filter((s) => s.syntax === "xml").map((s) => s.startLine));
+  const hasToolImport = doc.imports.some((x) => x.kind === "tool") || doc.toolDefs.length > 0;
+  const fileImportKeys = new Set(doc.fileImports.map((f) => f.key));
+  const toolMask = toolBlockMask(rawLines);
+  const out = [];
+  const cfgMask = configSectionMask(rawLines);
+  const litMask = examplesMask(rawLines);
+  let inFence = false;
+  rawLines.forEach((raw, i) => {
+    const t = raw.trim();
+    if (t.startsWith("```") || t.startsWith("~~~")) {
+      inFence = !inFence;
+      return;
+    }
+    if (inFence || litMask[i]) return;
+    if (toolMask[i]) return;
+    if (cfgMask[i] && (CONFIG_SECTION_OPEN.test(raw) || CONFIG_SECTION_CLOSE.test(raw))) return;
+    if (kinds[i] === "comment" || doc.importLines.has(i) || doc.configLines.has(i) || doc.defineLines.has(i) || doc.testLines.has(i) || doc.exampleLines.has(i) || isHeadingLine(raw) || isAnnotationLine(raw)) return;
+    const masked = maskQuotes(raw).replace(/\s+\/\/.*$/, (m2) => " ".repeat(m2.length)).replace(/\bwhen=[^>]*(?=>)/gi, (m2) => " ".repeat(m2.length)).replace(/^\s*\$SWITCH\b.*$/i, (m2) => " ".repeat(m2.length)).replace(/^(\s*\$(?:IF|ELSE\s+IF)\b[^:]*:|\s*\$ELSE\s*:)/i, (m2) => " ".repeat(m2.length)).replace(/^(\s*(?:CASE\b[^:]*|ELSE(?:\s+IF\b[^:]*)?)\s*:)/i, (m2) => " ".repeat(m2.length));
+    const covered = [];
+    const overlaps = (s, e) => covered.some(([a, b]) => s < b && e > a);
+    const add = (kind, s, e, key, resolved) => {
+      if (overlaps(s, e)) return;
+      covered.push([s, e]);
+      out.push({ kind, line: i, start: s, end: e, key, resolved });
+    };
+    let m;
+    STEP_RANGE.lastIndex = 0;
+    while ((m = STEP_RANGE.exec(masked)) !== null) {
+      const a = (m[1] ?? "").toLowerCase();
+      const b = (m[2] ?? "").toLowerCase();
+      const bStart = m.index + m[0].length - b.length;
+      add("step", m.index, m.index + a.length, a, doc.index.steps.has(a));
+      add("step", bStart, m.index + m[0].length, b, doc.index.steps.has(b));
+    }
+    for (const re of STEP_REF_PATTERNS) {
+      re.lastIndex = 0;
+      while ((m = re.exec(masked)) !== null) {
+        const key = (m[1] ?? "").toLowerCase();
+        if (!STEP_ORD.test(key)) continue;
+        add("step", m.index, m.index + m[0].length, key, doc.index.steps.has(key));
+      }
+    }
+    STEP_POINTER.lastIndex = 0;
+    while ((m = STEP_POINTER.exec(masked)) !== null) {
+      const key = (m[1] ?? "").toLowerCase();
+      if (!STEP_ORD.test(key)) continue;
+      const ordStart = m.index + m[0].length - (m[1] ?? "").length;
+      add("step", ordStart, m.index + m[0].length, key, doc.index.steps.has(key));
+    }
+    ANCHOR_REF.lastIndex = 0;
+    while ((m = ANCHOR_REF.exec(masked)) !== null) {
+      if (MARKER_PREFIX.test(masked.slice(0, m.index))) continue;
+      const name = (m[1] ?? "").toLowerCase();
+      add("step", m.index, m.index + m[0].length, name, doc.index.anchors.has(name));
+    }
+    TRANSREF.lastIndex = 0;
+    while ((m = TRANSREF.exec(masked)) !== null) {
+      const [ts, te] = [m.index, m.index + m[0].length];
+      const key = (m[1] ?? "").toLowerCase();
+      const addressed = !!m[2];
+      if (!addressed && doc.index.sections.has(key)) add("section", ts, te, key, true);
+      else if (fileImportKeys.has(key)) add("alias", ts, te, key, true);
+      else covered.push([ts, te]);
+    }
+    TOOLINLINE.lastIndex = 0;
+    while ((m = TOOLINLINE.exec(masked)) !== null) {
+      const [is, ie] = [m.index, m.index + m[0].length];
+      const key = (m[1] ?? "").toLowerCase();
+      if (doc.index.tools.has(key)) add("tool", is, ie, key, true);
+      else covered.push([is, ie]);
+    }
+    if (!xmlOpenLines.has(i) && !matchSectionTag(raw)?.open) {
+      INLINE_TAG.lastIndex = 0;
+      while ((m = INLINE_TAG.exec(masked)) !== null) {
+        const key = (m[1] ?? "").toLowerCase();
+        if (masked.slice(m.index + m[0].length).toLowerCase().includes(`</${key}>`)) continue;
+        add("section", m.index, m.index + m[0].length, key, doc.index.sections.has(key));
+      }
+    }
+    VARREF.lastIndex = 0;
+    while ((m = VARREF.exec(masked)) !== null) add("variable", m.index, m.index + m[0].length, (m[1] ?? "").toLowerCase(), true);
+    for (const r of doc.imports) {
+      if (r.kind !== "route") continue;
+      let from = 0;
+      const lower = masked.toLowerCase();
+      let at;
+      while ((at = lower.indexOf(r.key, from)) >= 0) {
+        add("route", at, at + r.key.length, r.key, true);
+        from = at + r.key.length;
+      }
+    }
+    if (hasToolImport) {
+      const noVars = blank(blank(masked, new RegExp(`<\\/?${TAG_NAME_SRC}(?:\\s[^>]*)?>`, "gi")), /[{[][^}\]]*[}\]]/g);
+      SNAKE_RE.lastIndex = 0;
+      while ((m = SNAKE_RE.exec(noVars)) !== null) {
+        const key = m[0].toLowerCase();
+        if (doc.index.inputs.has(key)) continue;
+        add("tool", m.index, m.index + m[0].length, key, doc.index.tools.has(key));
+      }
+    }
+  });
+  return out;
+}
+var IF_BRANCH = /^\s*if\b\s*(.*)$/i;
+var OTHERWISE_BRANCH = /^\s*otherwise\b[,:]?\s*(.*)$/i;
+var DECISION_HEADER = /^(?:based|depending)\s+on\b.*:\s*$/i;
+function isDecisionHeader(text) {
+  return DECISION_HEADER.test(text.trim());
+}
+function parseBranch(text) {
+  const ow = text.match(OTHERWISE_BRANCH);
+  if (ow) return { kind: "otherwise", guard: "", outcome: (ow[1] ?? "").trim() };
+  const iff = text.match(IF_BRANCH);
+  if (!iff) return null;
+  const rest = iff[1] ?? "";
+  const comma = rest.indexOf(",");
+  return comma >= 0 ? { kind: "if", guard: rest.slice(0, comma).trim(), outcome: rest.slice(comma + 1).trim() } : { kind: "if", guard: rest.trim(), outcome: "" };
+}
+function branchGroups(doc) {
+  const byOrd = /* @__PURE__ */ new Map();
+  const byParent = /* @__PURE__ */ new Map();
+  for (const s of doc.steps) {
+    byOrd.set(s.ord, s);
+    if (s.parent === null) continue;
+    const list = byParent.get(s.parent) ?? [];
+    list.push(s);
+    byParent.set(s.parent, list);
+  }
+  const groups = [];
+  for (const [parent, children] of byParent) {
+    const branches = [];
+    for (const s of [...children].sort((a, b) => a.line - b.line)) {
+      const p = parseBranch(s.text);
+      if (p) branches.push({ line: s.line, ord: s.ord, kind: p.kind, guard: p.guard, outcome: p.outcome });
+    }
+    if (branches.length === 0) continue;
+    const header = byOrd.get(parent);
+    groups.push({ parent, headerLine: header?.line ?? branches[0]?.line ?? 0, headerText: header?.text ?? "", branches });
+  }
+  return groups;
+}
+function normValue(s) {
+  return s.trim().toLowerCase().replace(/[.,;:!?]+$/, "").replace(/^(?:an?|the)\s+/, "").trim();
+}
+function guardValues(guard) {
+  const head = guard.trim().toLowerCase().replace(/^(?:it'?s|it\s+is)\s+/, "");
+  return head.split(/\s*(?:,|\bor\b)\s*/).map(normValue).filter((s) => s !== "");
+}
+var MAX_TUPLE_PRODUCT = 256;
+function firstUncovered(domains, patterns) {
+  const total = domains.reduce((n, d) => n * d.length, 1);
+  for (let idx = 0; idx < total; idx += 1) {
+    const tuple = [];
+    let rem = idx;
+    for (const d of domains) {
+      tuple.push(d[rem % d.length] ?? "");
+      rem = Math.floor(rem / d.length);
+    }
+    if (!patterns.some((p) => p.every((cell, i) => cell === "_" || cell === tuple[i]))) return tuple;
+  }
+  return null;
+}
+function predicateEncodable(block, inputTypes, defines) {
+  const okAtom = (name, test, seen) => {
+    if (defines.has(name)) {
+      if (test !== "bool" || seen.has(name)) return false;
+      const ast = parseExpr(defines.get(name)?.expr ?? "").ast;
+      return ast !== null && exprAtoms(ast).every((a) => okAtom(a.name, a.test, /* @__PURE__ */ new Set([...seen, name])));
+    }
+    const t = inputTypes.get(name);
+    if (!t) return false;
+    return test === "bool" ? t.kind === "bool" : test === "numeric" ? t.kind === "number" : t.kind === "enum";
+  };
+  for (const arm of block.arms) {
+    if (arm.kind !== "case" || arm.predicate === void 0) continue;
+    const ast = parseExpr(arm.predicate).ast;
+    if (ast === null || !exprAtoms(ast).every((a) => okAtom(a.name, a.test, /* @__PURE__ */ new Set()))) return false;
+  }
+  return true;
+}
+function structuralConflicts(rawLines) {
+  const doc = buildStructure(rawLines);
+  const refs = findReferences(rawLines, doc);
+  const out = [];
+  for (const t of doc.tests) {
+    if (t.error !== null) out.push({ lines: [t.headerLine], message: t.error, code: "bad-test", severity: "error" });
+  }
+  for (const line of strayExpects(rawLines)) {
+    out.push({ lines: [line], message: 'EXPECT is retired \u2014 write each expectation as a "- " sub-bullet under "- expect::" inside a $TEST block.', code: "bad-test", severity: "error" });
+  }
+  for (const e of doc.examples) {
+    if (e.error !== null) out.push({ lines: [e.headerLine], message: e.error, code: "bad-example", severity: "error" });
+  }
+  const cfgMask = configSectionMask(rawLines);
+  if (cfgMask.some(Boolean)) {
+    const kinds2 = classifyLines(rawLines);
+    const defMask = toolBlockMask(rawLines);
+    rawLines.forEach((raw, i) => {
+      if (!cfgMask[i]) return;
+      if (CONFIG_SECTION_OPEN.test(raw) || CONFIG_SECTION_CLOSE.test(raw)) return;
+      if (raw.trim() === "" || kinds2[i] === "comment") return;
+      if (doc.importLines.has(i) || doc.configLines.has(i) || doc.defineLines.has(i) || doc.testLines.has(i) || defMask[i]) return;
+      out.push({
+        lines: [i],
+        message: "Content inside <$CONFIG> never reaches the model \u2014 only $-commands ($IMPORT, $CONFIG, $TOOL, $DEFINE, $TEST) belong here. Move prompt content outside the section.",
+        code: "config-section-content",
+        severity: "error"
+      });
+    });
+  }
+  for (const u of doc.unclosedTags) {
+    out.push({ lines: [u.line], message: `Tag <${u.tag}> is opened but never closed \u2014 add a </${u.tag}>.`, code: "unclosed-tag", severity: "error" });
+  }
+  for (const c of doc.strayCloses) {
+    out.push({ lines: [c.line], message: `</${c.tag}> has no matching <${c.tag}> to close.`, code: "stray-close-tag", severity: "error" });
+  }
+  const byOrd = /* @__PURE__ */ new Map();
+  for (const s of doc.steps) {
+    const list = byOrd.get(s.ord);
+    if (list) list.push(s);
+    else byOrd.set(s.ord, [s]);
+  }
+  for (const [ord, list] of byOrd) {
+    if (list.length > 1) out.push({ lines: list.map((s) => s.line), message: `Duplicate step "${ord}" \u2014 ${list.length} steps carry this number, so a reference to it is ambiguous. Renumber one of them.`, code: "duplicate-step", severity: "error" });
+  }
+  {
+    const kindOf = (n) => doc.index.tools.has(n) ? "tool" : doc.index.routes.has(n) ? "route" : doc.index.inputs.has(n) ? "input" : doc.index.sections.has(n) ? "section" : doc.variables.has(n) ? "variable" : null;
+    const seenAlias = /* @__PURE__ */ new Set();
+    for (const a of doc.aliases) {
+      if (seenAlias.has(a.name)) {
+        out.push({ lines: [a.line], message: `Statement alias @@ ${a.name}: is already used by another annotation \u2014 a name can point at only one statement.`, code: "alias-collision", severity: "warn" });
+      } else {
+        const k = kindOf(a.name);
+        if (k) out.push({ lines: [a.line], message: `Statement alias @@ ${a.name}: collides with an existing ${k} of that name. Rename the alias.`, code: "alias-collision", severity: "warn" });
+      }
+      seenAlias.add(a.name);
+    }
+  }
+  {
+    const named = doc.sections.filter((s) => s.control !== true);
+    const REPEATABLE = /* @__PURE__ */ new Set(["example", "case", "item", "option", "step", "turn", "message", "exchange", "entry"]);
+    const byTag = /* @__PURE__ */ new Map();
+    for (const s of named) {
+      const list = byTag.get(s.tag) ?? [];
+      list.push(s);
+      byTag.set(s.tag, list);
+    }
+    for (const [tag, list] of byTag) {
+      if (list.length > 1 && !REPEATABLE.has(tag)) {
+        out.push({ lines: list.map((s) => s.startLine), message: `Duplicate section "${tag}" \u2014 ${list.length} sections share this name. Give each a distinct name; the structure (and any reference to "${tag}") is ambiguous.`, code: "duplicate-section", severity: "error" });
+      }
+    }
+    const nearDup = (a, b) => a + "s" === b || b + "s" === a || a + "es" === b || b + "es" === a || b.startsWith(`${a}_`) || a.startsWith(`${b}_`);
+    const tags = [...byTag.keys()];
+    for (let i = 0; i < tags.length; i += 1) {
+      for (let j = i + 1; j < tags.length; j += 1) {
+        const a = tags[i] ?? "";
+        const b = tags[j] ?? "";
+        if (!nearDup(a, b)) continue;
+        const lines = named.filter((s) => s.tag === a || s.tag === b).map((s) => s.startLine);
+        out.push({ lines, message: `Near-duplicate section names "${a}" and "${b}" \u2014 consolidate them or give each a clearly distinct name.`, code: "near-duplicate-section", severity: "error" });
+      }
+    }
+    const VAGUE = /* @__PURE__ */ new Set(["section", "content", "contents", "data", "info", "text", "stuff", "misc", "part", "tmp", "temp", "block", "tag", "thing", "things", "general", "main", "body", "other", "extra"]);
+    for (const s of named) {
+      if (s.syntax !== "xml") continue;
+      if (s.tag.length <= 2) {
+        out.push({ lines: [s.startLine], message: `Section name "${s.tag}" is too short to be meaningful \u2014 name it for what it contains.`, code: "vague-section-name", severity: "warn" });
+        continue;
+      }
+      const stem2 = s.tag.replace(/\d+$/, "");
+      if (stem2 === "" || VAGUE.has(stem2)) {
+        out.push({ lines: [s.startLine], message: `Section name "${s.tag}" is vague \u2014 name it for what it contains (e.g. <escalation_rules>, not <${s.tag}>).`, code: "vague-section-name", severity: "warn" });
+      }
+    }
+  }
+  const siblings = /* @__PURE__ */ new Map();
+  for (const s of doc.steps) {
+    const key = s.parent ?? "";
+    const list = siblings.get(key) ?? [];
+    list.push(s);
+    siblings.set(key, list);
+  }
+  const lastSeg = (s) => s.segments[s.segments.length - 1] ?? 0;
+  const label = (parent, n) => parent ? `${parent}.${n}` : `${n}`;
+  for (const [parent, kids] of siblings) {
+    const byLine = [...kids].sort((a, b) => a.line - b.line);
+    const nums = [...new Set(byLine.map(lastSeg))].sort((a, b) => a - b);
+    for (let k = 1; k < nums.length; k += 1) {
+      const prev = nums[k - 1] ?? 0;
+      const cur = nums[k] ?? 0;
+      for (let g = prev + 1; g < cur; g += 1) {
+        const line = byLine.find((s) => lastSeg(s) === cur)?.line ?? 0;
+        out.push({ lines: [line], message: `Missing step ${label(parent, g)} \u2014 the sequence jumps from ${label(parent, prev)} to ${label(parent, cur)}.`, code: "missing-step", severity: "error" });
+      }
+    }
+    for (let k = 1; k < byLine.length; k += 1) {
+      const cur = byLine[k];
+      const prevStep = byLine[k - 1];
+      if (cur && prevStep && lastSeg(cur) < lastSeg(prevStep)) {
+        out.push({ lines: [cur.line], message: `Step ${cur.ord} appears after step ${prevStep.ord} \u2014 steps are out of order.`, code: "unordered-step", severity: "warn" });
+      }
+    }
+  }
+  for (const r of refs) {
+    if (r.resolved) continue;
+    if (r.kind === "step") out.push({ lines: [r.line], message: `Reference to step ${r.key}, which is not defined.`, code: "dangling-step-ref", severity: "error" });
+    else if (r.kind === "section") out.push({ lines: [r.line], message: `Reference to section <${r.key}>, which is not defined.`, code: "dangling-section-ref", severity: "error" });
+    else if (r.kind === "tool") out.push({ lines: [r.line], message: `Tool "${r.key}" is used but never imported (add it to a $IMPORT tool line).`, code: "undeclared-tool", severity: "error" });
+  }
+  const guardVars = /* @__PURE__ */ new Set();
+  for (const sec of doc.sections) {
+    if (sec.syntax !== "xml" || !sec.guard) continue;
+    const parsed = parseExpr(sec.guard.text).ast;
+    if (parsed) for (const a of exprAtoms(parsed)) guardVars.add(a.name);
+  }
+  for (const d of doc.defines.values()) {
+    const parsed = parseExpr(d.expr).ast;
+    if (parsed) for (const a of exprAtoms(parsed)) guardVars.add(a.name);
+  }
+  const switches = parseSwitches(rawLines);
+  for (const b of switches) {
+    guardVars.add(b.varName);
+    for (const n of b.varNames ?? []) guardVars.add(n);
+    for (const a of b.arms) {
+      if (a.predicate === void 0) continue;
+      const parsed = parseExpr(a.predicate).ast;
+      if (parsed) for (const at of exprAtoms(parsed)) guardVars.add(at.name);
+    }
+  }
+  const inlineSwitches = parseInlineSwitches(rawLines);
+  for (const sw of inlineSwitches) guardVars.add(sw.varName);
+  const referenced = /* @__PURE__ */ new Set([...refs.map((r) => r.key), ...guardVars]);
+  const isCondVar = (name) => doc.index.inputs.has(name) || doc.defines.has(name);
+  const condType = (name) => doc.inputTypes.get(name) ?? (doc.defines.has(name) ? { kind: "bool" } : void 0);
+  const modular = rawLines.some((l) => IMPORT_FILE_RE.test(l));
+  for (const im of doc.imports) {
+    if (!modular && !referenced.has(im.key)) out.push({ lines: [im.line], message: im.kind === "variable" ? `Required variable "${im.name}" is never used.` : `Imported ${im.kind} "${im.name}" is never used.`, code: "unused-import", severity: "warn" });
+  }
+  out.push(...parseTools(rawLines).conflicts);
+  const importedTools = new Map(doc.imports.filter((x) => x.kind === "tool").map((x) => [x.key, x.line]));
+  for (const t of doc.toolDefs) {
+    const importLine = importedTools.get(t.name);
+    if (importLine !== void 0) {
+      out.push({ lines: [t.line, importLine], message: `Tool "${t.name}" is both DEFINED here and $IMPORTed \u2014 pick one: drop the import (it's defined in-file) or the definition.`, code: "tool-defined-and-imported", severity: "warn" });
+    }
+    if (!referenced.has(t.name)) {
+      out.push({ lines: [t.line], message: `Defined tool "${t.name}" is never used in the prompt \u2014 the model cannot discover a tool no rule mentions. Reference it in a rule (e.g. "call ${t.name} when ...") or delete the definition.`, code: "unused-tool", severity: "warn" });
+    }
+  }
+  for (const line of doc.importLines) {
+    const raw = rawLines[line] ?? "";
+    const rq = raw.match(REQUIRE_RE);
+    const im = rq ? null : raw.match(IMPORT_RE);
+    const payload = rq ? rq[1] ?? null : im && im[1] === "input" ? im[2] ?? null : null;
+    if (payload === null || !payload.includes(":")) continue;
+    const { error } = parseTypedInput(payload);
+    if (error !== null) out.push({ lines: [line], message: error, code: "bad-input-type", severity: "error" });
+  }
+  for (const sec of doc.sections) {
+    if (sec.syntax !== "xml" || !sec.guard) continue;
+    const at = sec.startLine;
+    const { ast, error } = parseExpr(sec.guard.text);
+    if (error !== null || ast === null) {
+      out.push({ lines: [at], message: `Guard on <${sec.tag}> is not a valid condition: ${error ?? "parse error"}.`, code: "bad-guard-expr", severity: "error" });
+      continue;
+    }
+    for (const atom of exprAtoms(ast)) {
+      if (!isCondVar(atom.name)) {
+        out.push({ lines: [at], message: `Guard on <${sec.tag}> reads @{${atom.name}}, which isn't a declared input or $DEFINE.`, code: "undeclared-input", severity: "error" });
+        continue;
+      }
+      const type = condType(atom.name);
+      if (type === void 0) continue;
+      if (atom.test === "bool" && type.kind !== "bool") {
+        out.push({ lines: [at], message: `Guard on <${sec.tag}> uses @{${atom.name}} as a boolean, but it's ${type.kind === "enum" ? "an enum" : `a ${type.kind}`} \u2014 compare it, e.g. ${type.kind === "number" ? `\`@{${atom.name}} is at least <n>\`` : `\`@{${atom.name}} is equal to <value>\``}.`, code: "guard-type-mismatch", severity: "error" });
+      } else if (atom.test === "value" && type.kind === "bool") {
+        out.push({ lines: [at], message: `Guard on <${sec.tag}> compares @{${atom.name}} to a value, but it's a bool \u2014 use \`@{${atom.name}}\` or \`not @{${atom.name}}\`.`, code: "guard-type-mismatch", severity: "error" });
+      } else if (atom.test === "value" && type.kind === "enum") {
+        const bad = atom.values.filter((v) => !type.members.includes(v));
+        if (bad.length > 0) out.push({ lines: [at], message: `Guard on <${sec.tag}>: @{${atom.name}} is never ${bad.join(", ")} (it's one of ${type.members.join(", ")}).`, code: "impossible-value", severity: "error" });
+      } else if (atom.test === "numeric" && type.kind !== "number") {
+        out.push({ lines: [at], message: `Guard on <${sec.tag}> compares @{${atom.name}} numerically (is greater than / is at least \u2026), but it's ${type.kind === "enum" ? "an enum" : `a ${type.kind}`} \u2014 a numeric comparison needs a number input.`, code: "guard-type-mismatch", severity: "error" });
+      }
+    }
+  }
+  for (const block of switches) {
+    const at = block.headerLine;
+    const isBlock = block.form === "block";
+    const fallbackName = isBlock ? '"- otherwise::"' : "ELSE";
+    if (block.error !== null) {
+      out.push({ lines: [at], message: block.error, code: block.errorCode ?? "bad-switch", severity: "error" });
+      continue;
+    }
+    const elseIdx = block.arms.findIndex((a) => a.kind === "else");
+    for (const a of elseIdx >= 0 ? block.arms.slice(elseIdx + 1) : []) {
+      out.push({ lines: [a.headerLine], message: `This arm comes after ${fallbackName}, so it can never run \u2014 move it above the ${isBlock ? "otherwise row" : "ELSE"}.`, code: "unreachable-case", severity: "error" });
+    }
+    const hasElse = elseIdx >= 0;
+    if (block.kind === "predicate") {
+      for (const a of block.arms) {
+        if (a.kind !== "case" || a.predicate === void 0) continue;
+        const { ast, error } = parseExpr(a.predicate);
+        if (error !== null || ast === null) {
+          out.push({ lines: [a.headerLine], message: `This arm's condition doesn't parse: ${error ?? "parse error"}.`, code: "bad-case-expr", severity: "error" });
+          continue;
+        }
+        for (const atom of exprAtoms(ast)) {
+          if (!isCondVar(atom.name)) {
+            out.push({ lines: [a.headerLine], message: `This arm's condition reads @{${atom.name}}, which isn't a declared input or $DEFINE.`, code: "undeclared-input", severity: "error" });
+            continue;
+          }
+          const t = condType(atom.name);
+          if (t === void 0) continue;
+          if (atom.test === "bool" && t.kind !== "bool") out.push({ lines: [a.headerLine], message: `This arm's condition uses @{${atom.name}} as a boolean, but it's ${t.kind === "enum" ? "an enum" : `a ${t.kind}`} \u2014 compare it, e.g. ${t.kind === "number" ? `\`@{${atom.name}} is at least <n>\`` : `\`@{${atom.name}} is equal to <value>\``}.`, code: "guard-type-mismatch", severity: "error" });
+          else if (atom.test === "value" && t.kind === "bool") out.push({ lines: [a.headerLine], message: `This arm's condition compares @{${atom.name}} to a value, but it's a bool \u2014 use \`@{${atom.name}}\` or \`not @{${atom.name}}\`.`, code: "guard-type-mismatch", severity: "error" });
+          else if (atom.test === "value" && t.kind === "enum") {
+            const bad = atom.values.filter((v) => !t.members.includes(v));
+            if (bad.length > 0) out.push({ lines: [a.headerLine], message: `This arm's condition: @{${atom.name}} is never ${bad.join(", ")} (it's one of ${t.members.join(", ")}).`, code: "impossible-value", severity: "error" });
+          } else if (atom.test === "numeric" && t.kind !== "number") out.push({ lines: [a.headerLine], message: `This arm's condition compares @{${atom.name}} numerically (is greater than / is at least \u2026), but it's ${t.kind === "enum" ? "an enum" : `a ${t.kind}`} \u2014 a numeric comparison needs a number input.`, code: "guard-type-mismatch", severity: "error" });
+        }
+      }
+      if (!hasElse && !predicateEncodable(block, doc.inputTypes, doc.defines))
+        out.push({ lines: [at], message: `A chain over open-ended conditions can't be proven exhaustive \u2014 add an ELSE arm.`, code: "non-exhaustive-switch", severity: "error" });
+      continue;
+    }
+    if (block.kind === "tuple") {
+      const vars = block.varNames ?? [];
+      const undeclared = vars.filter((n) => !isCondVar(n));
+      if (undeclared.length > 0) {
+        for (const n of undeclared) out.push({ lines: [at], message: `This chain reads @{${n}}, which isn't a declared input or $DEFINE.`, code: "undeclared-input", severity: "error" });
+        continue;
+      }
+      const domains = vars.map((n) => {
+        const t = condType(n);
+        return t?.kind === "enum" ? t.members : t?.kind === "bool" ? ["true", "false"] : null;
+      });
+      const seen = /* @__PURE__ */ new Set();
+      const covering = [];
+      for (const a of block.arms) {
+        if (a.kind !== "case" || a.patterns === void 0) continue;
+        a.patterns.forEach((p, i) => {
+          const dom = domains[i];
+          if (p !== "_" && dom && !dom.includes(p)) out.push({ lines: [a.headerLine], message: `@{${vars[i]}} is never ${p} (it's one of ${dom.join(", ")}).`, code: "impossible-case", severity: "error" });
+        });
+        const key = JSON.stringify(a.patterns);
+        if (seen.has(key)) out.push({ lines: [a.headerLine], message: `The combination (${a.patterns.join(", ")}) is matched by an earlier arm \u2014 this arm can never run.`, code: "duplicate-case", severity: "error" });
+        else {
+          seen.add(key);
+          covering.push(a.patterns);
+        }
+      }
+      if (!hasElse) {
+        const open = domains.some((d) => d === null);
+        const product = open ? Infinity : domains.reduce((n, d) => n * d.length, 1);
+        if (open || product > MAX_TUPLE_PRODUCT) {
+          out.push({ lines: [at], message: `This chain on ${vars.map((v) => `@{${v}}`).join(", ")} ranges over ${open ? "an open domain" : "too many combinations"} to enumerate \u2014 add an ELSE arm.`, code: "opaque-switch", severity: "error" });
+        } else {
+          const gap = firstUncovered(domains, covering);
+          if (gap) out.push({ lines: [at], message: `No arm handles ${vars.map((v, i) => `@{${v}}=${gap[i]}`).join(", ")} \u2014 add an arm or an ELSE.`, code: "non-exhaustive-switch", severity: "error" });
+        }
+      }
+      continue;
+    }
+    if (!isCondVar(block.varName)) {
+      out.push({ lines: [at], message: `This ${isBlock ? "$SWITCH reads" : "chain reads"} @{${block.varName}}, which isn't a declared input or $DEFINE.`, code: "undeclared-input", severity: "error" });
+      continue;
+    }
+    const firstUse = /* @__PURE__ */ new Map();
+    for (const a of block.arms) {
+      if (a.kind !== "case") continue;
+      for (const v of a.values) {
+        const prev = firstUse.get(v);
+        if (prev === void 0) firstUse.set(v, a.headerLine);
+        else out.push({ lines: [a.headerLine, prev], message: `${isBlock ? `Member "${v}" already has an arm` : `Value "${v}" is matched by more than one arm`} \u2014 only the first can run.`, code: "duplicate-case", severity: "error" });
+      }
+    }
+    const covered = new Set(firstUse.keys());
+    const type = condType(block.varName);
+    const domain = type?.kind === "enum" ? type.members : type?.kind === "bool" ? ["true", "false"] : null;
+    if (domain !== null) {
+      for (const a of block.arms) {
+        if (a.kind !== "case") continue;
+        const bad = a.values.filter((v) => !domain.includes(v));
+        if (bad.length > 0)
+          out.push({
+            lines: [a.headerLine],
+            message: isBlock ? `"${bad.join('", "')}" is not a member of @{${block.varName}}'s domain \u2014 one of ${domain.join(", ")}.` : `@{${block.varName}} is never ${bad.join(", ")} (it's one of ${domain.join(", ")}).`,
+            code: "impossible-case",
+            severity: "error"
+          });
+      }
+      if (!hasElse) {
+        const missing = domain.filter((m) => !covered.has(m));
+        if (missing.length > 0)
+          out.push({
+            lines: [at],
+            message: isBlock ? `@{${block.varName}} can be ${missing.join(", ")}, but no arm handles ${missing.length > 1 ? "them" : "it"} \u2014 add a "- <member>::" row for each (or a deliberate "- otherwise::" fallback).` : `@{${block.varName}} can be ${missing.join(", ")}, but no arm handles ${missing.length > 1 ? "them" : "it"} \u2014 add an arm or an ELSE.`,
+            code: "non-exhaustive-switch",
+            severity: "error"
+          });
+      } else if (isBlock) {
+        const missing = domain.filter((m) => !covered.has(m));
+        const elseArm = block.arms[elseIdx];
+        if (missing.length === 0 && elseArm !== void 0) {
+          out.push({ lines: [elseArm.headerLine], message: `Every member of @{${block.varName}} has its own arm \u2014 "- otherwise::" can never run, and it would silently absorb members added to the domain later. Remove the row.`, code: "unreachable-otherwise", severity: "error" });
+        }
+      }
+    } else if (!hasElse) {
+      out.push({ lines: [at], message: isBlock ? `@{${block.varName}} has an open domain (${type?.kind ?? "untyped"}) \u2014 a $SWITCH on it needs a "- otherwise::" row (members can't cover an open domain).` : `@{${block.varName}} has an open domain (${type?.kind ?? "untyped"}) \u2014 a chain on it needs an ELSE arm.`, code: "opaque-switch", severity: "error" });
+    }
+    if (!isBlock && domain !== null && block.arms.length >= 2 && block.arms.every((a) => a.kind === "else" || a.values.length === 1 && a.inlineBody !== "" && a.headerLine + 1 === a.spanEnd)) {
+      const pad = " ".repeat(block.indent);
+      const missing = domain.filter((m) => !covered.has(m));
+      const rows = block.arms.filter((a) => a.kind === "case" || missing.length > 0).map((a) => a.kind === "else" ? `${pad}  - otherwise:: ${a.inlineBody}` : `${pad}  - ${a.values[0]}:: ${a.inlineBody}`);
+      out.push({
+        lines: [at],
+        message: `Every arm tests @{${block.varName}} for one member \u2014 this chain is a $SWITCH in disguise. The block form proves coverage by construction (a member added to the domain later fails loudly here instead of falling through). Replace the chain with:
+${pad}$SWITCH ON @{${block.varName}}
+${rows.join("\n")}`,
+        code: "switch-shaped-chain",
+        severity: "info"
+      });
+    }
+    if (isBlock) {
+      const armStmts = block.arms.map((a) => {
+        const stmts = [];
+        if (a.inlineBody !== "") stmts.push({ text: a.inlineBody.trim(), line: a.headerLine });
+        for (let l = a.headerLine + 1; l < a.spanEnd; l += 1) {
+          const t = (rawLines[l] ?? "").trim();
+          if (t === "" || t.startsWith("//") || t.startsWith("@@")) continue;
+          stmts.push({ text: t, line: l });
+        }
+        return stmts;
+      });
+      if (block.arms.length >= 2) {
+        const first = armStmts[0] ?? [];
+        for (const s of first) {
+          if (armStmts.every((stmts) => stmts.some((x) => x.text === s.text))) {
+            const sites = armStmts.map((stmts) => stmts.find((x) => x.text === s.text)?.line).filter((l) => l !== void 0);
+            out.push({ lines: sites, message: `Every arm repeats "${s.text}" \u2014 shared content is branch-independent, so hoist it above the $SWITCH.`, code: "hoist-arm", severity: "info" });
+          }
+        }
+      }
+      block.arms.forEach((a, i) => {
+        const n = (armStmts[i] ?? []).length;
+        if (a.kind === "case" && n > 8) {
+          out.push({ lines: [a.headerLine], message: `This arm carries ${n} statements \u2014 extract the body to a section and point: "- ${a.values[0] ?? "member"}:: @<section_name>".`, code: "large-arm", severity: "info" });
+        }
+      });
+    }
+  }
+  for (const sw of inlineSwitches) {
+    const at = sw.line;
+    const raw = rawLines[at] ?? "";
+    const pad = " ".repeat(raw.length - raw.trimStart().length);
+    const sentence = (frag) => (raw.slice(0, sw.start) + frag + raw.slice(sw.end)).trim();
+    const arms = [];
+    for (const c of sw.cases) {
+      if (c.isDefault) arms.push(`${pad}$ELSE: ${sentence(c.frag)}`);
+      else {
+        const cond = c.values.length > 1 ? `@{${sw.varName}} is one of ${c.values.join(", ")}` : `@{${sw.varName}} is equal to ${c.values[0] ?? ""}`;
+        arms.push(`${pad}${arms.length === 0 ? "$IF" : "$ELSE IF"} ${cond}: ${sentence(c.frag)}`);
+      }
+    }
+    const rewrite = arms.length > 0 ? ` Replace the line with:
+${arms.join("\n")}` : "";
+    out.push({ lines: [at], message: `The inline $SWITCH is retired \u2014 a deterministic branch is a block $IF chain, one full sentence per arm.${rewrite}`, code: "bad-switch", severity: "error" });
+  }
+  const seenDefine = /* @__PURE__ */ new Map();
+  for (const line of doc.defineLines) {
+    const raw = rawLines[line] ?? "";
+    const name = (raw.match(DEFINE_RE)?.[1] ?? "").toLowerCase();
+    if (name === "") continue;
+    const legacy = raw.match(/^(\s*)\$DEFINE\s+([a-z][a-z0-9_]*)\s*=\s*(\S.*)$/i);
+    if (legacy) {
+      out.push({ lines: [line], message: `The $DEFINE binder is AS, never "=". Replace this line with: "${legacy[1] ?? ""}$DEFINE ${legacy[2] ?? ""} AS ${(legacy[3] ?? "").trim()}".`, code: "define-binder", severity: "error" });
+    }
+    const prev = seenDefine.get(name);
+    if (prev !== void 0) out.push({ lines: [line, prev], message: `$DEFINE ${name} is defined more than once.`, code: "duplicate-define", severity: "error" });
+    else seenDefine.set(name, line);
+  }
+  const defineDeps = /* @__PURE__ */ new Map();
+  for (const [name, d] of doc.defines) {
+    const { ast, error } = parseExpr(d.expr);
+    if (error !== null || ast === null) {
+      out.push({ lines: [d.line], message: `$DEFINE ${name} is not a valid condition: ${error ?? "parse error"}.`, code: "bad-define-expr", severity: "error" });
+      defineDeps.set(name, []);
+      continue;
+    }
+    const atoms = exprAtoms(ast);
+    defineDeps.set(name, atoms.map((a) => a.name).filter((n) => doc.defines.has(n)));
+    for (const atom of atoms) {
+      if (!isCondVar(atom.name)) {
+        out.push({ lines: [d.line], message: `$DEFINE ${name} reads @{${atom.name}}, which isn't a declared input or $DEFINE.`, code: "undeclared-input", severity: "error" });
+        continue;
+      }
+      const type = condType(atom.name);
+      if (type === void 0) continue;
+      if (atom.test === "bool" && type.kind !== "bool") out.push({ lines: [d.line], message: `$DEFINE ${name} uses @{${atom.name}} as a boolean, but it's ${type.kind === "enum" ? "an enum" : `a ${type.kind}`} \u2014 compare it, e.g. ${type.kind === "number" ? `\`@{${atom.name}} is at least <n>\`` : `\`@{${atom.name}} is equal to <value>\``}.`, code: "guard-type-mismatch", severity: "error" });
+      else if (atom.test === "value" && type.kind === "bool") out.push({ lines: [d.line], message: `$DEFINE ${name} compares @{${atom.name}} to a value, but it's a bool.`, code: "guard-type-mismatch", severity: "error" });
+      else if (atom.test === "value" && type.kind === "enum") {
+        const bad = atom.values.filter((v) => !type.members.includes(v));
+        if (bad.length > 0) out.push({ lines: [d.line], message: `$DEFINE ${name}: @{${atom.name}} is never ${bad.join(", ")} (it's one of ${type.members.join(", ")}).`, code: "impossible-value", severity: "error" });
+      } else if (atom.test === "numeric" && type.kind !== "number") out.push({ lines: [d.line], message: `$DEFINE ${name} compares @{${atom.name}} numerically (is greater than / is at least \u2026), but it's ${type.kind === "enum" ? "an enum" : `a ${type.kind}`} \u2014 a numeric comparison needs a number input.`, code: "guard-type-mismatch", severity: "error" });
+    }
+    if (!referenced.has(name)) out.push({ lines: [d.line], message: `$DEFINE ${name} is never used.`, code: "unused-define", severity: "warn" });
+  }
+  for (const [start, d] of doc.defines) {
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [...defineDeps.get(start) ?? []];
+    let cyclic = false;
+    while (stack.length > 0) {
+      const n = stack.pop() ?? "";
+      if (n === start) {
+        cyclic = true;
+        break;
+      }
+      if (seen.has(n)) continue;
+      seen.add(n);
+      stack.push(...defineDeps.get(n) ?? []);
+    }
+    if (cyclic) out.push({ lines: [d.line], message: `$DEFINE ${start} depends on itself \u2014 remove the cycle.`, code: "define-cycle", severity: "error" });
+  }
+  const enums = rawLines.map((l) => findEnumDeclaration(l)).filter((e) => e !== null).map((e) => ({ name: e.name, members: new Set(e.members.map(normValue)) }));
+  for (const g of branchGroups(doc)) {
+    const owIdx = g.branches.findIndex((b) => b.kind === "otherwise");
+    const ifs = g.branches.filter((b) => b.kind === "if");
+    const perBranch = ifs.map((b) => new Set(guardValues(b.guard)));
+    const allVals = perBranch.flatMap((s) => [...s]);
+    const on = allVals.length > 0 ? enums.filter((e) => allVals.every((v) => e.members.has(v))) : [];
+    const enumOf = on.length === 1 ? on[0] : void 0;
+    const isDecision = enumOf !== void 0 || isDecisionHeader(g.headerText);
+    for (const b of owIdx >= 0 ? g.branches.slice(owIdx + 1) : []) {
+      out.push({ lines: [b.line], message: `This branch comes after "Otherwise", so it can never run \u2014 move it above the Otherwise.`, code: "unreachable-branch", severity: "error" });
+    }
+    if (isDecision) {
+      const firstUse = /* @__PURE__ */ new Map();
+      const warned = /* @__PURE__ */ new Set();
+      perBranch.forEach((vals, i) => {
+        for (const v of vals) {
+          const prev = firstUse.get(v);
+          if (prev === void 0) firstUse.set(v, i);
+          else if (!warned.has(v)) {
+            warned.add(v);
+            out.push({ lines: [ifs[i]?.line ?? g.headerLine, ifs[prev]?.line ?? g.headerLine], message: `"${v}" is handled by more than one branch \u2014 in a decision only one runs, and an LLM won't reliably pick the first. Make the branches mutually exclusive.`, code: "overlapping-guard", severity: "warn" });
+          }
+        }
+      });
+    }
+    if (owIdx >= 0) continue;
+    if (enumOf) {
+      const covered = new Set(allVals);
+      const missing = [...enumOf.members].filter((v) => !covered.has(v));
+      if (missing.length > 0) {
+        out.push({
+          lines: [g.headerLine],
+          message: `${enumOf.name} can be ${missing.join(", ")}, but no branch handles ${missing.length > 1 ? "them" : "it"} \u2014 add a branch or an "Otherwise".`,
+          code: "non-exhaustive-branch",
+          severity: "error"
+        });
+      }
+    } else if (isDecisionHeader(g.headerText)) {
+      out.push({
+        lines: [g.headerLine],
+        message: `This decision has no "Otherwise" \u2014 a state matching none of the branches would be unhandled. Add an "Otherwise" branch.`,
+        code: "no-default-branch",
+        severity: "error"
+      });
+    }
+  }
+  const kinds = classifyLines(rawLines);
+  const cmdToolMask = toolBlockMask(rawLines);
+  let firstContent = rawLines.length;
+  for (let i = 0; i < rawLines.length; i += 1) {
+    if (kinds[i] !== "content" || cmdToolMask[i] || cfgMask[i]) continue;
+    const line = rawLines[i] ?? "";
+    if (IMPORT_RE.test(line) || IMPORT_FILE_RE.test(line) || REQUIRE_RE.test(line) || CONFIG_RE.test(line)) continue;
+    firstContent = i;
+    break;
+  }
+  for (const line of [...doc.importLines, ...doc.configLines]) {
+    if (line >= firstContent && !cfgMask[line]) {
+      out.push({ lines: [line], message: `A $-command must sit at the top of the file, outside any content section (it currently follows content on line ${firstContent + 1}).`, code: "misplaced-command", severity: "error" });
+    }
+  }
+  rawLines.forEach((raw, i) => {
+    if (kinds[i] !== "content" || cmdToolMask[i] || !BARE_COMMAND_RE.test(raw)) return;
+    const kw = /^\s*IMPORT\b/.test(raw) ? "$IMPORT" : /^\s*TOOL\b/.test(raw) ? "$TOOL" : /^\s*SERVICE\b/.test(raw) ? "$SERVICE" : /^\s*DEFINE\b/.test(raw) ? "$DEFINE" : "$CONFIG";
+    out.push({ lines: [i], message: `Commands must start with "$" \u2014 did you mean "${kw}"?`, code: "needs-sigil", severity: "error" });
+  });
+  return out;
+}
+function structure(source) {
+  const rawLines = source.split("\n");
+  const doc = buildStructure(rawLines);
+  const refs = findReferences(rawLines, doc);
+  const conflicts = structuralConflicts(rawLines);
+  const declarations = [];
+  const byId = {};
+  const reg = (d) => {
+    declarations.push(d);
+    byId[d.id] = d;
+  };
+  for (const s of doc.steps) {
+    const decl = { id: `step:${s.ord}`, kind: "step", label: s.ord, loc: { line: s.line, start: 0, end: 0 }, depth: s.depth, ordinal: s.major, ...s.parent ? { parentId: `step:${s.parent}` } : {} };
+    reg(decl);
+    if (s.anchor) byId[`step:${s.anchor}`] = decl;
+  }
+  for (const s of doc.sections) reg({ id: `section:${s.tag}`, kind: "section", label: s.tag, loc: { line: s.startLine, start: 0, end: 0 }, depth: s.depth });
+  for (const im of doc.imports) reg({ id: `${im.kind}:${im.key}`, kind: im.kind, label: im.name, loc: { line: im.line, start: 0, end: 0 }, depth: 0 });
+  for (const f of doc.fileImports) {
+    const id = `alias:${f.key}`;
+    if (!byId[id]) reg({ id, kind: "alias", label: f.alias, loc: { line: f.line, start: 0, end: 0 }, depth: 0 });
+  }
+  for (const t of doc.toolDefs) {
+    const id = `tool:${t.name.toLowerCase()}`;
+    if (!byId[id]) reg({ id, kind: "tool", label: t.name, loc: { line: t.line, start: 0, end: 0 }, depth: 0 });
+  }
+  const declaredVarKeys = new Set(doc.imports.filter((im) => im.kind === "variable").map((im) => im.key));
+  for (const v of doc.variables.values()) {
+    if (declaredVarKeys.has(v.base)) continue;
+    const first = v.notations[0];
+    if (first) reg({ id: `variable:${v.base}`, kind: "variable", label: v.base, loc: { line: first.line, start: first.start, end: first.end }, depth: 0 });
+  }
+  for (const a of doc.aliases) if (!byId[`alias:${a.name}`]) reg({ id: `alias:${a.name}`, kind: "alias", label: a.name, loc: { line: a.line, start: 0, end: 0 }, depth: 0 });
+  const references = refs.map((r) => {
+    const id = `${r.kind}:${r.key}`;
+    return { loc: { line: r.line, start: r.start, end: r.end }, targetId: r.resolved && byId[id] ? id : null };
+  });
+  const perLine = rawLines.map(() => ({ depth: 0, sectionId: null }));
+  for (const s of doc.sections) {
+    for (let l = s.startLine; l < s.endLine && l < perLine.length; l += 1) {
+      const p = perLine[l];
+      if (!p) continue;
+      p.depth = Math.max(p.depth, s.depth);
+      p.sectionId = `section:${s.tag}`;
+    }
+  }
+  const sortedSteps = [...doc.steps].sort((a, b) => a.line - b.line);
+  sortedSteps.forEach((s, k) => {
+    if (s.depth === 0) return;
+    const sec = doc.sections.filter((x) => s.line >= x.startLine && s.line < x.endLine).reduce((best, x) => !best || x.depth > best.depth ? x : best, void 0);
+    let end = sortedSteps[k + 1]?.line ?? rawLines.length;
+    if (sec) end = Math.min(end, sec.endLine);
+    for (let l = s.line; l < end && l < perLine.length; l += 1) {
+      const p = perLine[l];
+      if (p) p.depth = Math.max(p.depth, (sec?.depth ?? 0) + s.depth);
+    }
+  });
+  return { declarations, references, byId, perLine, wellFormed: !conflicts.some((c) => c.severity === "error") };
+}
+var COMPLETION_TRIGGERS = ["$", "<", "{", "[", "@", "#", " ", ":"];
+
+export { BUILTIN_CONFIG_SCHEMA, COMPLETION_TRIGGERS, MANY_CLASS, NON_ACTION_LEADS, PRIM_TYPES, REFINEMENT_KEYWORDS, addresseeSubjects, aliasMap, boundText, buildStructure, checkModel, classifyLines, collectObjects, compileToXml, configParamDiagnostics, configRuleDiagnostics, evalExpr, exampleBlockLines, exprAtoms, extractSuite, findEnumDeclaration, headingsOutsideSections, isHeadingLine, looseContentLines, maskInlineSwitches, matchSectionTag, parseActionCount, parseCardinalBody, parseConfigBlocks, parseConfigRules, parseExpr, parseInlineSwitches, parseServices, parseSwitches, parseTools, pluralizeNoun, predicateEncodable, renumberSubSteps, resolveAnchors, resolveConfigSchema, resolveDeclarations, resolveInlineText, rubricExpectLines, selectArm, selectPredicateArm, selectTupleArm, singularizeNoun, structuralConflicts, structure, switchBlockMask, testBlockLines, toolInputSchema };
+//# sourceMappingURL=chunk-YH4ZLQ4G.js.map
+//# sourceMappingURL=chunk-YH4ZLQ4G.js.map