@polycode-projects/seonix 0.7.3 → 0.9.0

package/src/ask-browser.bundle.js

@@ -0,0 +1,3040 @@
+(() => {
+  // node_modules/@polycode-projects/the-mechanical-code-talker/src/prose.mjs
+  var STOPWORDS = new Set(
+    "a an and or but the of to in on at for with from by as is are was were be been being it its this that these those i you he she they we me my your our do does did not no yes if then else than so such can will would should could may might about into over under out up down off again more most some any all what which who whom whose when where why how".split(/\s+/)
+  );
+  var MAX_TOKEN_LEN = 40;
+  var MAX_TOKENS_PER_DOC = 120;
+  function splitIdentifierWords(raw) {
+    if (!raw) return [];
+    let s = String(raw).replace(/\.[A-Za-z0-9]+$/, "");
+    s = s.replace(/[/\\]/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/([A-Za-z])([0-9])/g, "$1 $2").replace(/([0-9])([A-Za-z])/g, "$1 $2").replace(/[_\-.]+/g, " ");
+    return s.split(/\s+/).map((w) => w.toLowerCase()).filter((w) => w.length > 1 && w.length <= MAX_TOKEN_LEN);
+  }
+  function tokenizeProse(text) {
+    if (!text) return [];
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const raw of String(text).toLowerCase().split(/[^a-z0-9]+/)) {
+      if (raw.length < 2 || raw.length > MAX_TOKEN_LEN || STOPWORDS.has(raw)) continue;
+      if (seen.has(raw)) continue;
+      seen.add(raw);
+      out.push(raw);
+      if (out.length >= MAX_TOKENS_PER_DOC) break;
+    }
+    return out;
+  }
+  function lookupByProseTokens(proseIndex, query, { limit = 10 } = {}) {
+    const queryTokens = [.../* @__PURE__ */ new Set([...splitIdentifierWords(query), ...tokenizeProse(query)])];
+    if (!queryTokens.length) return [];
+    const scoreById = /* @__PURE__ */ new Map();
+    for (const word of queryTokens) {
+      for (const id of proseIndex?.[word] || []) {
+        scoreById.set(id, (scoreById.get(id) || 0) + 1);
+      }
+    }
+    return [...scoreById.entries()].sort((a, b) => b[1] - a[1] || String(a[0]).localeCompare(b[0])).slice(0, limit).map(([id, score]) => ({ id, score }));
+  }
+
+  // node-stub:node:fs
+  var unavailable = (name) => () => {
+    throw new Error(name + " unavailable in the browser ask bundle");
+  };
+  var createRequire = unavailable("createRequire");
+  var readFileSync = unavailable("readFileSync");
+  var randomBytes = unavailable("randomBytes");
+
+  // node-stub:node:path
+  var unavailable2 = (name) => () => {
+    throw new Error(name + " unavailable in the browser ask bundle");
+  };
+  var createRequire2 = unavailable2("createRequire");
+  var readFileSync2 = unavailable2("readFileSync");
+  var randomBytes2 = unavailable2("randomBytes");
+
+  // node-stub:node:url
+  var unavailable3 = (name) => () => {
+    throw new Error(name + " unavailable in the browser ask bundle");
+  };
+  var createRequire3 = unavailable3("createRequire");
+  var readFileSync3 = unavailable3("readFileSync");
+  var randomBytes3 = unavailable3("randomBytes");
+
+  // node_modules/@polycode-projects/the-mechanical-code-talker/src/codegraph.mjs
+  var PROP_KIND = {
+    // v2.0 faithful tokens (SEON-faithful realign)
+    "mgx:importsnamespace": "imports",
+    "mgx:callscoarse": "calls",
+    "seon:declaresmethod": "defines",
+    "mgx:testscoverage": "tests",
+    "mgx:touchedbycommit": "touches",
+    "seon:containscodeentity": "contains",
+    "seon:hassupertype": "inherits",
+    "mgx:changecoupledwith": "cochange",
+    "mgx:reexports": "reexports",
+    // fine-grained symbol-level edges (Commit→symbol history, fn→fn in-repo calls).
+    // These stay SEPARATE kinds from the module-coarse "touches"/"calls" so the impact
+    // closure (module-coarse) is unchanged.
+    "mgx:touchessymbol": "touchesSymbol",
+    "mgx:callssymbol": "callsSymbol",
+    // legacy tokens (pre-realign graphs) — kept so a stale artifact still classifies
+    "seon:usescomplextype": "imports",
+    "seon:invokesmethod": "calls",
+    "seon:history": "touches",
+    "mgx:subclassof": "inherits",
+    "mg:imports": "imports",
+    "mg:calls": "calls",
+    "mg:defines": "defines",
+    "mg:tests": "tests",
+    "mg:touches": "touches"
+  };
+  function relationKind(group) {
+    const prop = String(group?.prop || "").toLowerCase();
+    if (PROP_KIND[prop]) return PROP_KIND[prop];
+    const pred = String(group?.predicate || "").toLowerCase();
+    if (/symbol/.test(pred)) {
+      if (/\b(call|invoke)/.test(pred)) return "callsSymbol";
+      if (/(touch|chang|modif)/.test(pred)) return "touchesSymbol";
+    }
+    if (/\bimport/.test(pred)) return "imports";
+    if (/\b(call|invoke)/.test(pred)) return "calls";
+    if (/\b(define|export|declare)/.test(pred)) return "defines";
+    if (/\b(test|cover)/.test(pred)) return "tests";
+    if (/\b(touch|chang|modif)/.test(pred)) return "touches";
+    if (/\bcontain/.test(pred)) return "contains";
+    if (/\b(inherit|subclass|extend|specializ)/.test(pred)) return "inherits";
+    return null;
+  }
+  function siteOf(ind) {
+    const a = (ind?.attributes || []).find((x) => x.key === "site");
+    if (!a) return null;
+    const m = String(a.value).match(/^(.*):(\d+)(?:-(\d+))?$/);
+    if (!m) return null;
+    return { path: m[1], start: Number(m[2]), end: m[3] ? Number(m[3]) : Number(m[2]) };
+  }
+  function impactClosure(graph, ind, { maxDepth = 8 } = {}) {
+    const dependents = /* @__PURE__ */ new Map();
+    const coveredBy = /* @__PURE__ */ new Map();
+    const addDependent = (objectId, subjectId, subjectLabel, via) => {
+      if (!objectId || !subjectId || objectId === subjectId) return;
+      if (!dependents.has(objectId)) dependents.set(objectId, []);
+      dependents.get(objectId).push({ id: subjectId, label: subjectLabel, via });
+    };
+    for (const g of graph.relations) {
+      const kind = relationKind(g);
+      if (kind === "imports" || kind === "calls") {
+        for (const e of g.edges) addDependent(e.object, e.subject, e.subjectLabel || e.subject, g.predicate);
+      } else if (kind === "callsSymbol") {
+        for (const e of g.edges) {
+          const subjModId = moduleIdOfId(graph, e.subject);
+          const objModId = moduleIdOfId(graph, e.object);
+          if (!subjModId || !objModId) continue;
+          const subjLabel = graph.byId.get(subjModId)?.label || subjModId;
+          addDependent(objModId, subjModId, subjLabel, g.predicate);
+        }
+      } else if (kind === "tests") {
+        for (const e of g.edges) {
+          if (!coveredBy.has(e.object)) coveredBy.set(e.object, []);
+          coveredBy.get(e.object).push(e.subjectLabel || e.subject);
+        }
+      }
+    }
+    const levels = [];
+    const visited = /* @__PURE__ */ new Set([ind.id]);
+    let frontier = [ind.id];
+    for (let depth = 1; depth <= maxDepth && frontier.length; depth += 1) {
+      const next = [];
+      const level = [];
+      for (const id of frontier) {
+        for (const dep of dependents.get(id) || []) {
+          if (visited.has(dep.id)) continue;
+          visited.add(dep.id);
+          level.push({ ...dep, tests: coveredBy.get(dep.id) || [] });
+          next.push(dep.id);
+        }
+      }
+      if (level.length) {
+        level.sort((a, b) => String(a.label).localeCompare(String(b.label)));
+        levels.push(level);
+      }
+      frontier = next;
+    }
+    return levels;
+  }
+  function moduleIdOfId(graph, id) {
+    const ind = graph.byId?.get?.(id);
+    if (ind) return moduleIdOf(graph, ind);
+    const m = String(id || "").match(/^fn:(.+)#/);
+    return m ? `mod:${m[1]}` : null;
+  }
+  function moduleIdOf(graph, ind) {
+    if ((ind?.class || "") === "Module") return ind.id;
+    const site = siteOf(ind);
+    if (site) return `mod:${site.path}`;
+    const m = String(ind?.id || "").match(/^fn:(.+)#/);
+    return m ? `mod:${m[1]}` : null;
+  }
+
+  // node_modules/@polycode-projects/the-mechanical-code-talker/src/ask-vocab.mjs
+  var RELATIONS = {
+    imports: {
+      comment: "Module -> Module: subject's import graph references object (usesComplexType).",
+      verbs: [
+        // formal/neutral ("uses"/"use" moved to the `uses` union family, 2026-07-02 —
+        // "uses code from" stays here: its phrasing is specifically import-flavored)
+        "couples to",
+        "couple to",
+        "depends on",
+        "imports",
+        "import",
+        "relies on",
+        "rely on",
+        "requires",
+        "require",
+        "references",
+        "reference",
+        "pulls in",
+        "pull in",
+        "built on",
+        "builds on",
+        "build on",
+        "uses code from",
+        // casual/colloquial
+        "grabs",
+        "grab",
+        "pulls from",
+        "pull from",
+        "leans on",
+        "lean on",
+        "is wired to",
+        "are wired to",
+        "is hooked up to",
+        "are hooked up to",
+        // gerund (g-drop normalization turns dialectal "importin'" into this — §3.5)
+        "importing"
+      ]
+    },
+    // "uses" is a QUERY-side union family, not a stored predicate (2026-07-02 query
+    // families): "what uses X" honestly means BOTH the import graph and the call
+    // graph, so ask.mjs traverses it as imports + calls + callsSymbol together
+    // (KIND_UNIONS there). The verbs moved here FROM imports — "which modules use X"
+    // still answers with the importing modules (the asked Module grain filters the
+    // union down to module-grain subjects), and "what uses <function>" now also
+    // reaches the symbol-grain callers instead of silently ignoring them.
+    uses: {
+      comment: "query-side union: imports (Module->Module) + calls (Module->Module) + callsSymbol (fn->fn).",
+      verbs: [
+        "uses",
+        "use",
+        "used by",
+        "makes use of",
+        "make use of",
+        // gerund (g-drop normalization — §3.5)
+        "using"
+      ]
+    },
+    calls: {
+      comment: "Function/Method -> Function/Class (symbol-grain) or Module -> Module (coarse): subject invokes object.",
+      verbs: [
+        // formal
+        "invokes",
+        "invoke",
+        // neutral
+        "calls",
+        "call",
+        "runs",
+        "run",
+        "executes",
+        "execute",
+        // casual/colloquial
+        "hits",
+        "hit",
+        "triggers",
+        "trigger",
+        "fires",
+        "fire",
+        "kicks off",
+        "kick off",
+        // gerund (g-drop normalization turns dialectal "callin'" into this — §3.5)
+        "calling"
+      ]
+    },
+    defines: {
+      comment: "Module -> top-level Function/Class/Method/Attribute: subject declares object.",
+      verbs: [
+        "defines",
+        "define",
+        "declares",
+        "declare",
+        "has",
+        "have",
+        "holds",
+        "hold",
+        // gerund (g-drop normalization — §3.5)
+        "defining"
+      ]
+    },
+    contains: {
+      comment: "Class -> Method/Attribute: subject's membership includes object.",
+      verbs: [
+        "contains",
+        "contain",
+        "lives in",
+        "live in",
+        "is defined in",
+        "are defined in",
+        "is part of",
+        "are part of",
+        "sits in",
+        "sit in",
+        "sits inside",
+        "sit inside",
+        // gerund (g-drop normalization — §3.5)
+        "containing"
+      ]
+    },
+    tests: {
+      comment: "Module -> Module: subject is a test module importing/covering object.",
+      verbs: [
+        "tests",
+        "test",
+        "covers",
+        "cover",
+        "verifies",
+        "verify",
+        "exercises",
+        "exercise",
+        "checks",
+        "check",
+        "makes sure of",
+        "make sure of",
+        // gerund (g-drop normalization — §3.5)
+        "testing"
+      ]
+    },
+    inherits: {
+      comment: "Class -> Class: subject's declared base resolves to object (subclassOf).",
+      verbs: [
+        "inherits from",
+        "inherit from",
+        "extends",
+        "extend",
+        "subclasses",
+        "subclass",
+        "derives from",
+        "derive from",
+        "is a subclass of",
+        "are a subclass of",
+        "is a kind of",
+        "are a kind of",
+        "is built off",
+        "are built off",
+        "is built on top of",
+        "are built on top of",
+        // gerund (g-drop normalization — §3.5, and the compositional grammar's
+        // gerund-led boolean gate: "classes inheriting from Base but not tested").
+        // Both the two-word "inheriting from" (so "from" is consumed into the verb
+        // phrase, not the object term) and the bare "inheriting" (the single token
+        // the gerund-lead check reads) are listed; longest-match-first prefers the
+        // two-word form when "from" follows.
+        "extending",
+        "inheriting from",
+        "inheriting",
+        "subclassing",
+        "extends from"
+      ]
+    },
+    touches: {
+      comment: "Commit -> Module (coarse) or Commit -> symbol (fine, touchesSymbol): a commit's changed-line-range intersects object.",
+      verbs: [
+        "touched",
+        "touches",
+        "changed",
+        "change",
+        "modified",
+        "modifies",
+        "was changed in",
+        "were changed in",
+        "was edited in",
+        "were edited in",
+        "was modified by",
+        "were modified by",
+        "was tweaked in",
+        "were tweaked in",
+        "got changed in",
+        "got edited in",
+        // commit-question forms (2026-07-02, viewer commit-chat fix): the same touch
+        // relation asked from the commit's side — "which changes touch commit <sha>",
+        // "what did commit <sha> touch", "which functions changed in <sha>", "which
+        // changes landed in commit <sha>", "what was touched by commit <sha>". Bare
+        // "touch" completes the touched/touches pair for the "did … touch" auxiliary
+        // form; the "by"/"in" phrases are the passive/locative counterparts of forms
+        // already above (curated per register spread, not a thesaurus dump).
+        "touch",
+        "touched by",
+        "modified by",
+        "changed by",
+        "changed in",
+        "landed in",
+        "land in",
+        // contents-of-a-commit forms (2026-07-02, operator screenshot: "what was in
+        // commit <sha>" missed on the live site). "was in"/"went into" only read as
+        // touch questions when the object is a commit — the sha-shaped object keeps
+        // them from firing on structural questions ("is X in the graph" has no verb
+        // match anyway). Judgment call: "is in" omitted — too generic without the
+        // past-tense anchor and risks matching containment phrasings.
+        "was in",
+        "were in",
+        "went into",
+        "included in",
+        // when-question forms (2026-07-02 query families): "when was X last
+        // updated/edited" — bare past participles that only read naturally in the
+        // temporal shape; the when template routes them, but they are ordinary
+        // touches verbs so "which modules were updated ..." keeps working too.
+        "updated",
+        "edited",
+        // gerund (g-drop normalization — §3.5)
+        "touching"
+      ]
+    },
+    cochange: {
+      comment: "Module -> Module: subject and object are frequently committed together (changeCoupledWith).",
+      verbs: [
+        "changed with",
+        "co-changes with",
+        "co-change with",
+        "changes alongside",
+        "change alongside",
+        "shares commits with",
+        "share commits with",
+        "tends to change together with",
+        "tend to change together with",
+        "moves together with",
+        "move together with"
+      ]
+    },
+    reexports: {
+      comment: "Module -> exported symbol: subject's public API surface (__all__/export list).",
+      verbs: [
+        "exports",
+        "export",
+        "re-exports",
+        "re-export",
+        "passes through",
+        "pass through",
+        // API-surface phrasing (2026-07-02 query families): "what does <module>
+        // expose". Bare "exposed" is NOT listed — the lemma tier maps it here when
+        // an adapter is present, and "how does the API get exposed" has no
+        // traversal either way (pinned as an honest miss in the tests).
+        "exposes",
+        "expose",
+        // gerund (g-drop normalization — §3.5)
+        "exporting"
+      ]
+    }
+  };
+  var WHERE_MARKERS = Object.freeze(["defined", "declared", "located", "implemented"]);
+  var MENTION_MARKERS = Object.freeze(["mentioned", "referenced"]);
+  var VERB_TO_KIND = Object.freeze(
+    Object.fromEntries(
+      Object.entries(RELATIONS).flatMap(([kind, { verbs }]) => verbs.map((v) => [v, kind]))
+    )
+  );
+  var ENTITY_TO_TYPE = Object.freeze({
+    function: "Function",
+    functions: "Function",
+    method: "Method",
+    methods: "Method",
+    class: "Class",
+    classes: "Class",
+    module: "Module",
+    modules: "Module",
+    file: "Module",
+    files: "Module",
+    attribute: "Attribute",
+    attributes: "Attribute",
+    field: "Attribute",
+    fields: "Attribute",
+    variable: "GlobalVariable",
+    variables: "GlobalVariable",
+    global: "GlobalVariable",
+    globals: "GlobalVariable",
+    // "changes" in a touch question ("which changes touch commit <sha>") means the
+    // code entities on the other end of the touch edges, at WHATEVER grain the graph
+    // recorded — module (touches) and symbol (touchesSymbol) together when the commit
+    // is the given side, and the touching commits themselves when a module/symbol is
+    // the given side. Mapped to the pseudo-type "Change" (not a node class): ask.mjs's
+    // traverse() reads it as a wildcard over the touch traversal's results rather than
+    // aliasing it to ONE real class and silently dropping the other grain of the
+    // answer. Listed BEFORE commit/commits: findPhrase (ask.mjs) takes the first
+    // same-length phrase in table order, so in "which changes touch commit <sha>" the
+    // entity slot must consume "changes" and leave "commit <sha>" intact as the
+    // object term.
+    change: "Change",
+    changes: "Change",
+    commit: "Commit",
+    commits: "Commit"
+  });
+  var MODIFIER_TO_KIND = Object.freeze({
+    explicitly: "direct",
+    directly: "direct",
+    transitively: "transitive",
+    indirectly: "transitive"
+  });
+  var PASSIVE_PARTICIPLE_TO_KIND = Object.freeze({
+    imported: "imports",
+    called: "calls",
+    used: "uses",
+    tested: "tests",
+    covered: "tests",
+    verified: "tests",
+    exercised: "tests",
+    checked: "tests",
+    defined: "defines",
+    declared: "defines",
+    inherited: "inherits",
+    extended: "inherits",
+    subclassed: "inherits",
+    contained: "contains",
+    exported: "reexports",
+    "re-exported": "reexports",
+    exposed: "reexports",
+    touched: "touches",
+    changed: "touches",
+    modified: "touches",
+    edited: "touches",
+    updated: "touches"
+  });
+  var CONTRACTIONS = Object.freeze({
+    "ain't": "is not",
+    "aint": "is not",
+    "isn't": "is not",
+    "isnt": "is not",
+    "aren't": "are not",
+    "arent": "are not",
+    "doesn't": "does not",
+    "doesnt": "does not",
+    "don't": "do not",
+    "dont": "do not",
+    "didn't": "did not",
+    "didnt": "did not",
+    "there's": "there is",
+    "theres": "there is",
+    "what's": "what is",
+    "whats": "what is",
+    "who's": "who is",
+    "whos": "who is",
+    "gonna": "going to",
+    "wanna": "want to",
+    "gotta": "got to",
+    "yer": "your",
+    "ur": "your",
+    "gimme": "give me"
+  });
+  var MISSPELLINGS = Object.freeze({
+    // entity nouns
+    "funtion": "function",
+    "funtions": "functions",
+    "fucntion": "function",
+    "fucntions": "functions",
+    "functoin": "function",
+    "functoins": "functions",
+    "calss": "class",
+    "calsses": "classes",
+    "classs": "class",
+    "clases": "classes",
+    "modul": "module",
+    "moduls": "modules",
+    "moduel": "module",
+    "moduels": "modules",
+    "moudle": "module",
+    "moudles": "modules",
+    "methdo": "method",
+    "methdos": "methods",
+    "mehtod": "method",
+    "mehtods": "methods",
+    "comit": "commit",
+    "comits": "commits",
+    "commmit": "commit",
+    "commmits": "commits",
+    "varaible": "variable",
+    "varaibles": "variables",
+    "varibale": "variable",
+    "varibales": "variables",
+    "atribute": "attribute",
+    "atributes": "attributes",
+    // relation verbs
+    "improt": "import",
+    "improts": "imports",
+    "imoprt": "import",
+    "imoprts": "imports",
+    "inherts": "inherits",
+    "inheirts": "inherits",
+    "extands": "extends",
+    "extneds": "extends",
+    "depnds": "depends",
+    "touchs": "touches",
+    "tuoches": "touches",
+    "touhced": "touched",
+    "chagned": "changed",
+    "chnaged": "changed",
+    "chagnes": "changes",
+    "chnages": "changes",
+    "calles": "calls",
+    "exprot": "export",
+    "exprots": "exports",
+    "tets": "tests",
+    // grammar anchor words
+    "whcih": "which",
+    "wich": "which",
+    "whihc": "which",
+    // "wat" (chatbench cycle 2, tf-wat-calls): the internet-casual spelling of
+    // "what" — neither curated noise nor a restorable trigger typo, so "wat calls
+    // fnAlpha" used to die as "couldn't resolve one of the terms". Restored here
+    // so BOTH parse strategies and the relaxation cascade see the canonical
+    // anchor; the correction regex's dotted-extension guard keeps a module
+    // literally named "wat.mjs" untouched, same residual trade as every entry.
+    "waht": "what",
+    "wat": "what",
+    "dose": "does",
+    "doess": "does",
+    "teh": "the",
+    // aggregate/list TRIGGER words (2026-07-02, trigger-typo work) — a typo of a count
+    // or list trigger used to be DROPPED as unmatched by the relaxation cascade, losing
+    // the aggregate/list INTENT entirely ("how manyn classes" → the count was lost);
+    // curated here so the intended trigger is restored BEFORE parsing (the general
+    // bounded fuzzy path in ask.mjs's cascade is the backstop for uncurated typos).
+    "manyn": "many",
+    "mnay": "many",
+    "amny": "many",
+    "mnany": "many",
+    "coutn": "count",
+    "conut": "count",
+    "cuont": "count",
+    "ocunt": "count",
+    "numer": "number",
+    "nubmer": "number",
+    "numbr": "number",
+    "nmuber": "number",
+    "lst": "list",
+    "lsit": "list",
+    "ilst": "list",
+    "shwo": "show",
+    "hsow": "show",
+    "dispaly": "display",
+    "dsiplay": "display",
+    "funtcions": "functions",
+    "funciton": "function",
+    "funcitons": "functions"
+  });
+  var WRONG_WORDS = Object.freeze({
+    // neither a folder nor a directory grain exists in this graph — in "which
+    // folders import X" the only honest referent is the module/file grain.
+    "folder": "module",
+    "folders": "modules",
+    "directory": "module",
+    "directories": "modules",
+    // unambiguous abbreviation of an entity noun this grammar owns
+    "func": "function",
+    "funcs": "functions",
+    // VCS terms whose canonical schema class here is Commit
+    "changeset": "commit",
+    "changesets": "commits",
+    "revision": "commit",
+    "revisions": "commits",
+    // code-graph "property" is the Attribute grain in this schema
+    "property": "attribute",
+    "properties": "attributes"
+  });
+  var G_DROP = /\b([a-z]{3,})in'/gi;
+  var FILLER_WORDS = Object.freeze([
+    "um",
+    "uh",
+    "erm",
+    "so",
+    "like",
+    "yo",
+    "hey",
+    "bru",
+    "bro",
+    "fam",
+    "mate",
+    "please",
+    "could you",
+    "can you",
+    "would you",
+    "tell me",
+    "i wonder",
+    "just wondering",
+    "quickly",
+    "real quick",
+    "kinda",
+    "sorta"
+  ]);
+  var CONTEXT_PRONOUNS = Object.freeze(["this", "it", "that", "here", "this one", "that one"]);
+  var NEGATION_FRAMES = Object.freeze([
+    // "there ain't nothin' calling it" / "there isn't nothing that calls it"
+    //   -> "what calls it"
+    { re: /\bthere\s+is\s+not\s+(?:anything|nothing)\s+(?:that\s+)?(\S.*)$/i, to: (m) => `what ${m[1]}` },
+    // "there's no module that imports auth" -> "what imports auth"
+    { re: /\bthere\s+is\s+no\s+\S+\s+(?:that\s+)?(\S.*)$/i, to: (m) => `what ${m[1]}` },
+    // "isn't there anything calling it" -> "what calls it" (question-inverted form)
+    { re: /\bis\s+not\s+there\s+(?:anything|nothing)\s+(?:that\s+)?(\S.*)$/i, to: (m) => `what ${m[1]}` },
+    // "nobody/nothing calls it, does it" (tag-question double-negative) -> "what calls it"
+    { re: /\b(?:nobody|nothing|no one)\s+(\S.*?)(?:,?\s+does\s+it\??|,?\s+do\s+they\??)?$/i, to: (m) => `what ${m[1]}` }
+  ]);
+  var COMMIT_CONTENT_FRAMES = Object.freeze([
+    // "what was in commit ef74e44e25c8" / "what is in ef74e44e" / "what's in commit <sha>"
+    { re: /^what\s+(?:is|was|were|are)\s+in\s+((?:commit\s+)?[0-9a-f]{7,40})\??$/i, to: (m) => `what did ${m[1]} touch` },
+    // "what went into commit ef74e44e25c8" / casual "what got into <sha>"
+    { re: /^what\s+(?:went|got)\s+into\s+((?:commit\s+)?[0-9a-f]{7,40})\??$/i, to: (m) => `what did ${m[1]} touch` },
+    // "what made it into commit ef74e44e25c8"
+    { re: /^what\s+made\s+it\s+into\s+((?:commit\s+)?[0-9a-f]{7,40})\??$/i, to: (m) => `what did ${m[1]} touch` }
+  ]);
+  var META_MEANING_VERBS = Object.freeze([
+    "mean",
+    "means",
+    "stand for",
+    "stands for",
+    "signify",
+    "signifies",
+    "represent",
+    "represents",
+    "refer to",
+    "refers to"
+  ]);
+  var RELATIVE_PRONOUNS = Object.freeze(["that", "which", "who"]);
+  var PLACEHOLDER_NOUNS = Object.freeze([
+    "something",
+    "anything",
+    "everything",
+    "somethings",
+    "things",
+    "thing",
+    "entities",
+    "entity",
+    "nodes",
+    "node",
+    "stuff",
+    "code",
+    // "symbol(s)" is a grain-agnostic stand-in for any code entity — "exported
+    // symbols of X" means whatever X defines, at any grain, filtered by the qualifier.
+    "symbol",
+    "symbols"
+  ]);
+  var BOOLEAN_CONNECTIVES = Object.freeze({
+    "but not": "difference",
+    "and not": "difference",
+    "except": "difference",
+    "without": "difference",
+    "and": "intersection",
+    "plus": "intersection",
+    "or": "union"
+  });
+  var QUALIFIERS = Object.freeze({
+    public: { via: "visibility", value: "public" },
+    private: { via: "visibility", value: "private" },
+    protected: { via: "visibility", value: "protected" },
+    static: { via: "attr", attr: "isStatic" },
+    abstract: { via: "attr", attr: "isAbstract" },
+    constant: { via: "attr", attr: "isConstant" },
+    exported: { via: "exported" },
+    "re-exported": { via: "exported" },
+    tested: { via: "tested", value: true },
+    covered: { via: "tested", value: true },
+    untested: { via: "tested", value: false },
+    uncovered: { via: "tested", value: false }
+  });
+  var AGGREGATE_TRIGGERS = Object.freeze([
+    // formal ("the number of classes" reaches "number of" once the cascade strips the
+    // leading article — keeping the trigger list clear of "the" so it never enters
+    // CONTENT_VOCAB and blocks the article's own noise-strip)
+    "how many",
+    "how much",
+    "how many of",
+    "number of",
+    "total number of",
+    "quantity of",
+    // "<measure> of <kind>" cardinality forms (widened net, cycle W2P): count = sum = total
+    // = tally = number of. The bare single words (sum/total/tally) stay CASCADE_SYNONYMS-
+    // mapped to "count" (identifier-fragment risk without the "of" anchor — see that table's
+    // note); the multi-word "of" forms are safe to promote to direct triggers because the
+    // trailing "of <kind>" pins them to a cardinality question, not a stray identifier.
+    "tally of",
+    "sum of",
+    "total of",
+    "amount of",
+    // neutral / imperative (bare "tally"/"sum"/"total" stay CASCADE_SYNONYMS-mapped so the
+    // "tally the classes" relaxation path — pinned by a cascade test — is preserved).
+    "count",
+    "count up",
+    "count of",
+    "tot up"
+  ]);
+  var LIST_TRIGGERS = Object.freeze([
+    // imperative — "<verb> [me/us] [the] <kind>"
+    "list",
+    "show",
+    "show me",
+    "show us",
+    "display",
+    "print",
+    "print out",
+    "dump",
+    "enumerate",
+    "name",
+    "give me",
+    "get me",
+    "spit out",
+    "rattle off",
+    "run down",
+    "run through",
+    "ls",
+    // interrogative — "what/which are [the] <kind>"
+    "what are",
+    "which are"
+  ]);
+  var SUPERLATIVE_EXTREMES = Object.freeze({
+    most: "most",
+    greatest: "most",
+    highest: "most",
+    biggest: "most",
+    largest: "most",
+    "most-connected": "most",
+    "most connected": "most",
+    fewest: "fewest",
+    least: "fewest",
+    smallest: "fewest",
+    lowest: "fewest"
+  });
+  var EDGE_NOUN_TO_METRIC = Object.freeze({
+    imports: { kind: "imports", dir: "out" },
+    dependencies: { kind: "imports", dir: "out" },
+    importers: { kind: "imports", dir: "in" },
+    dependents: { kind: "imports", dir: "in" },
+    callers: { kind: "calls", dir: "in", sibling: "callsSymbol" },
+    callees: { kind: "calls", dir: "out", sibling: "callsSymbol" },
+    calls: { kind: "calls", dir: "out", sibling: "callsSymbol" },
+    methods: { kind: "contains", dir: "out", filter: "Method" },
+    members: { kind: "contains", dir: "out" },
+    tests: { kind: "tests", dir: "in" },
+    subclasses: { kind: "inherits", dir: "in" },
+    connections: { kind: "*", dir: "both" },
+    edges: { kind: "*", dir: "both" },
+    connected: { kind: "*", dir: "both" },
+    // participle degree-nouns (widened net, cycle W2P): "the most imported / most
+    // depended-on / most used <module>" ranks by IN-degree — how many things import/depend
+    // on/use it — the ARGMAX-by-degree intent a developer expresses with a passive
+    // participle rather than the noun ("importers"). "depended" catches "depended-on" /
+    // "depended on" (both tokenize to a bare "depended"); "used" folds the symbol-grain
+    // callsSymbol callers in alongside importers so "most used" reads as most-relied-upon.
+    imported: { kind: "imports", dir: "in" },
+    "depended-on": { kind: "imports", dir: "in" },
+    depended: { kind: "imports", dir: "in" },
+    used: { kind: "imports", dir: "in", sibling: "callsSymbol" },
+    called: { kind: "calls", dir: "in", sibling: "callsSymbol" }
+  });
+  var ANAPHORA_TRIGGERS = Object.freeze(["those", "them", "these"]);
+  var MEMBERSHIP_KINDS = Object.freeze(["contains", "defines"]);
+  var CASCADE_NOISE = Object.freeze([
+    // articles / vague determiners (kept OUT of content vocab so they're strippable;
+    // the aggregate/where parsers already tolerate a stray "the"/"a", so stripping is
+    // belt-and-braces, not load-bearing)
+    "the",
+    "a",
+    "an",
+    "some",
+    // topic lead-in filler — "what about the modules", "how about classes": "about"
+    // carries no graph meaning here, so stripping it lets the bare kind noun surface for
+    // the cascade's bare-kind-noun terminal rule (ask.mjs). ("what"/"how" are structural
+    // question words the drop-pass keeps; only the "about" between them and the kind is
+    // noise.) A module literally named "about" is safe-listed by relaxParse's resolvesExact
+    // guard, same as every other noise token.
+    "about",
+    // politeness / hedges (single-token; multi-word "could you"/"please" etc. are
+    // FILLER_WORDS, stripped earlier during normalization)
+    "please",
+    "pls",
+    "plz",
+    "kindly",
+    "just",
+    "simply",
+    "maybe",
+    "perhaps",
+    "thanks",
+    "thank",
+    "ta",
+    "cheers",
+    // greetings a question sometimes opens with (chat.mjs owns standalone greetings;
+    // here they're only stripped when embedded in an otherwise-real question)
+    "hi",
+    "hello",
+    "hey",
+    "yo",
+    "hiya",
+    "howdy",
+    "ok",
+    "okay",
+    // vocatives / terms of address (the "matey" of the worked example, and its kin)
+    "matey",
+    "mate",
+    "buddy",
+    "pal",
+    "dude",
+    "man",
+    "bro",
+    "bru",
+    "fam",
+    "friend",
+    "sir",
+    "maam",
+    "folks",
+    "guys",
+    "everyone",
+    "dear",
+    // the product's OWN name used as an address (chatbench cycle 2, ns-hey-tmct:
+    // "hey tmct, what calls fnAlpha thanks") — a vocative like "matey", stripped
+    // by the same rules: relaxParse's resolvesExact guard still protects a module
+    // literally named "tmct", and noise-strip's template/keyword-spot acceptance
+    // bounds the cost of a mid-question strip to an honest object-miss.
+    "tmct",
+    // presentation frames — the keyword-spotting strategy's blind spot: the
+    // compositional grammar skips these as FRAME_WORDS, but "show me what imports X"
+    // otherwise decomposes (via keyword-spot) to ask{subject:"show me"}. Stripping
+    // them on a miss recovers the underlying reverse/forward question. ("count" is NOT
+    // here — it is an aggregate trigger; "find"/"search" are here as presentation
+    // verbs, not the tmct_search tool, which ask.mjs never dispatches.)
+    "show",
+    "tell",
+    "give",
+    "list",
+    "find",
+    "me",
+    "us",
+    "lemme"
+  ]);
+  var CASCADE_SYNONYMS = Object.freeze({
+    tally: "count",
+    tallies: "count",
+    sum: "count",
+    total: "count",
+    totals: "count"
+  });
+  var HELP_TRIGGERS = Object.freeze([
+    "help",
+    "help me",
+    "how do i ask",
+    "how do i use this",
+    "what can i ask",
+    "what can you ask",
+    "usage",
+    "commands",
+    "examples",
+    "syntax",
+    "options"
+  ]);
+
+  // node_modules/@polycode-projects/the-mechanical-code-talker/src/interpret/normalize.mjs
+  function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  var tableRe = (table) => new RegExp(
+    "\\b(" + Object.keys(table).sort((a, b) => b.length - a.length).map(escapeRegex).join("|") + ")\\b",
+    "gi"
+  );
+  var CONTRACTION_RE = tableRe(CONTRACTIONS);
+  var correctionRe = (table) => new RegExp(
+    "\\b(" + Object.keys(table).sort((a, b) => b.length - a.length).map(escapeRegex).join("|") + ")\\b(?!\\.[a-z0-9])",
+    "gi"
+  );
+  var MISSPELLING_RE = correctionRe(MISSPELLINGS);
+  var WRONG_WORD_RE = correctionRe(WRONG_WORDS);
+  function normalizeQuery(text) {
+    let q = String(text || "");
+    q = q.replace(CONTRACTION_RE, (m) => CONTRACTIONS[m.toLowerCase()]);
+    q = q.replace(MISSPELLING_RE, (m) => MISSPELLINGS[m.toLowerCase()]);
+    q = q.replace(WRONG_WORD_RE, (m) => WRONG_WORDS[m.toLowerCase()]);
+    q = q.replace(G_DROP, "$1ing");
+    if (FILLER_WORDS.length) {
+      const fillerRe = new RegExp(
+        "\\b(" + [...FILLER_WORDS].sort((a, b) => b.length - a.length).map(escapeRegex).join("|") + ")\\b",
+        "gi"
+      );
+      q = q.replace(fillerRe, " ");
+    }
+    q = q.replace(/\?{2,}\s*$/, "?");
+    return q.replace(/\s+/g, " ").trim();
+  }
+  function applyNegationFrames(text) {
+    for (const frame of [...COMMIT_CONTENT_FRAMES, ...NEGATION_FRAMES]) {
+      const m = text.match(frame.re);
+      if (m) return frame.to(m).replace(/\s+/g, " ").trim();
+    }
+    return text;
+  }
+  var NEGATION_SET_RE = new RegExp(
+    "^(?:which|what|who|list|show(?:\\s+me)?|find|give\\s+me)?\\s*(?:the\\s+|all\\s+)?([a-z][a-z-]*)\\s+(?:(?:that|which|who)\\s+)?(?:(?:do|does|did|are|is|was|were|have|has)\\s+)?not\\s+(.+)$",
+    // the negation marker + (2) the predicate
+    "i"
+  );
+  function matchNegationSet(text) {
+    const m = String(text || "").match(NEGATION_SET_RE);
+    if (!m) return null;
+    const entWord = m[1].toLowerCase();
+    const predicate = m[2].trim();
+    if (!predicate) return null;
+    return { entWord, predicate };
+  }
+  var STOPWORDS2 = /* @__PURE__ */ new Set([
+    "what",
+    "who",
+    "which",
+    "where",
+    "when",
+    "why",
+    "how",
+    "does",
+    "do",
+    "did",
+    "is",
+    "are",
+    "was",
+    "were",
+    "the",
+    "a",
+    "an",
+    "of",
+    "to",
+    "from",
+    "at",
+    "in",
+    "on",
+    "there",
+    "something",
+    "anything",
+    "nothing",
+    "one",
+    "any",
+    // temporal filler in when-questions ("when was X last touched") — a symbol
+    // literally named "last" would be the accepted residual cost, same trade as
+    // every other stopword.
+    "last"
+  ]);
+  var splitWords = (text) => String(text).replace(/\?+\s*$/, "").replace(/,/g, " ").split(/\s+/).filter(Boolean);
+  var wordsOf = (arr) => arr.flatMap((p) => String(p).toLowerCase().split(" "));
+
+  // node_modules/@polycode-projects/the-mechanical-code-talker/src/interpret/fuzzy.mjs
+  function editDistance(a, b, max) {
+    if (a === b) return 0;
+    if (Math.abs(a.length - b.length) > max) return max + 1;
+    let prev2 = null;
+    let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+    for (let i = 1; i <= a.length; i += 1) {
+      const cur = [i];
+      let rowMin = i;
+      for (let j = 1; j <= b.length; j += 1) {
+        const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+        let v = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost);
+        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) v = Math.min(v, prev2[j - 2] + cost);
+        cur[j] = v;
+        if (v < rowMin) rowMin = v;
+      }
+      if (rowMin > max) return max + 1;
+      prev2 = prev;
+      prev = cur;
+    }
+    return prev[b.length];
+  }
+  var fuzzyBound = (s) => s.length <= 5 ? 1 : 2;
+  var VOCAB_WORDS = new Set(
+    [...Object.keys(VERB_TO_KIND), ...Object.keys(ENTITY_TO_TYPE), ...Object.keys(MODIFIER_TO_KIND)].flatMap((p) => p.split(" "))
+  );
+  var FUZZY_TARGET_WORDS = [...new Set(
+    [...Object.keys(VERB_TO_KIND), ...Object.keys(MODIFIER_TO_KIND)].flatMap((p) => p.split(" ")).filter((w) => w.length >= 4)
+  )];
+  function eligibleForCanon(w) {
+    return /^[a-z]+$/.test(w) && !STOPWORDS2.has(w) && !VOCAB_WORDS.has(w);
+  }
+  function fuzzyVocabWord(w) {
+    const bound = fuzzyBound(w);
+    let best = bound + 1;
+    let hit = null;
+    let tied = false;
+    for (const target of FUZZY_TARGET_WORDS) {
+      const d = editDistance(w, target, Math.min(best, bound));
+      if (d < best) {
+        best = d;
+        hit = target;
+        tied = false;
+      } else if (d === best && d <= bound && target !== hit) tied = true;
+    }
+    return best <= bound && !tied ? hit : null;
+  }
+
+  // node_modules/@polycode-projects/the-mechanical-code-talker/src/interpret/strategies/grammar.mjs
+  var VERB_ALT = Object.keys(VERB_TO_KIND).sort((a, b) => b.length - a.length).map(escapeRegex).join("|");
+  var ENTITY_ALT = Object.keys(ENTITY_TO_TYPE).sort((a, b) => b.length - a.length).map(escapeRegex).join("|");
+  var MODIFIER_ALT = Object.keys(MODIFIER_TO_KIND).sort((a, b) => b.length - a.length).map(escapeRegex).join("|");
+  var META_ALT = META_MEANING_VERBS.slice().sort((a, b) => b.length - a.length).map(escapeRegex).join("|");
+  var TEMPLATES = [
+    // T1 ASK: "does X import Y" / "is X a subclass of Y" -> Yes/No. Tried FIRST: it starts with
+    // does/is/do/did, which the reverse/forward templates below never match (those start with
+    // which/what), so precedence between T1 and the rest is structural, not a tie-break guess.
+    // "did" joins does/do for the past-tense commit forms ("did commit <sha> touch X").
+    {
+      name: "ask",
+      re: new RegExp(`^(?:does|do|did)\\s+(.+?)\\s+(${VERB_ALT})\\s+(.+?)\\??$`, "i"),
+      build: (m) => ({
+        shape: "ask",
+        entityType: null,
+        modifier: "direct",
+        kind: VERB_TO_KIND[m[2].toLowerCase()],
+        subject: m[1].trim(),
+        object: m[3].trim()
+      })
+    },
+    // T2 reverse: "which <entity> [<modifier>] <verb> <object>" — the operator's own example shape.
+    {
+      name: "reverse",
+      re: new RegExp(`^which\\s+(${ENTITY_ALT})\\s+(?:(${MODIFIER_ALT})\\s+)?(${VERB_ALT})\\s+(.+?)\\??$`, "i"),
+      build: (m) => ({
+        shape: "reverse",
+        entityType: ENTITY_TO_TYPE[m[1].toLowerCase()],
+        modifier: m[2] ? MODIFIER_TO_KIND[m[2].toLowerCase()] : "direct",
+        kind: VERB_TO_KIND[m[3].toLowerCase()],
+        object: m[4].trim()
+      })
+    },
+    // T3 forward: "what does <object> <verb>" — X is given, list its R-related things.
+    // "did" joins does/do for the past-tense commit forms ("what did commit <sha> touch").
+    {
+      name: "forward",
+      re: new RegExp(`^what\\s+(?:does|do|did)\\s+(.+?)\\s+(${VERB_ALT})\\??$`, "i"),
+      build: (m) => ({
+        shape: "forward",
+        entityType: null,
+        modifier: "direct",
+        kind: VERB_TO_KIND[m[2].toLowerCase()],
+        object: m[1].trim()
+      })
+    },
+    // T4 meta: "what does <term> mean" — a question about the GRAPH'S OWN VOCABULARY
+    // (a SchemaClass/SchemaPredicate label, e.g. "cochange", or a raw prop token, e.g.
+    // "mgx:callsSymbol"), not a graph traversal over code edges. Tried after T3: T3 also
+    // starts "what does/do", but T3 only fires when the tail is a relation VERB_ALT
+    // phrase ("import"/"calls"/…), which "mean"/"means"/etc never are (disjoint tables —
+    // ask-vocab.mjs's file comment explains why they're kept separate), so the two never
+    // actually compete for the same input.
+    {
+      name: "meta-mean",
+      re: new RegExp(`^what\\s+(?:does|do|is|are)\\s+(.+?)\\s+(?:${META_ALT})\\??$`, "i"),
+      build: (m) => ({ shape: "meta", entityType: null, modifier: "direct", kind: "meta", object: m[1].trim() })
+    },
+    // T5 meta: "what is a/an <term>" — the OTHER worked phrasing ("what is a Commit").
+    // The indefinite article is REQUIRED (not optional): a bare "what is <anything>"
+    // would also swallow "what is the meaning of this codebase" (an existing, deliberately
+    // honest grammar-miss regression case — ask.test.mjs/ask-dual-strategy.test.mjs both
+    // assert it stays null), which never mentions "a"/"an" before its tail. Requiring the
+    // article keeps this template's reach to the one worked shape without reopening that.
+    {
+      name: "meta-whatis",
+      re: new RegExp(`^what\\s+(?:is|are)\\s+(?:an?)\\s+(.+?)\\??$`, "i"),
+      build: (m) => ({ shape: "meta", entityType: null, modifier: "direct", kind: "meta", object: m[1].trim() })
+    },
+    // T6 mention: "where is <term> mentioned/referenced" — the prose/mentions surface
+    // (2026-07-02 query families). Tried BEFORE T7: T7's trailing marker is optional,
+    // so without this ordering it would swallow the mention question and lose the
+    // marker that distinguishes "locate the definition" from "list the prose mentions".
+    {
+      name: "mention",
+      re: new RegExp(`^where\\s+(?:is|are|was|were)\\s+(.+?)\\s+(?:${MENTION_MARKERS.map(escapeRegex).join("|")})\\??$`, "i"),
+      build: (m) => ({ shape: "mentions", entityType: null, modifier: "direct", kind: "mentions", object: m[1].trim() })
+    },
+    // T7 where: "where is <term> [defined|declared|located|implemented]" — definition
+    // location off the site attribute / defining module. "where" starts no other
+    // template, so precedence against T1-T5 is structural.
+    {
+      name: "where",
+      re: new RegExp(`^where\\s+(?:is|are|was|were)\\s+(.+?)(?:\\s+(?:${WHERE_MARKERS.map(escapeRegex).join("|")}))?\\??$`, "i"),
+      build: (m) => ({ shape: "where", entityType: null, modifier: "direct", kind: "where", object: m[1].trim() })
+    },
+    // T8 when: "when did <term> [last] change/touched/updated…" — temporal shape over
+    // the touches edges + commit date attributes. The verb slot reuses VERB_ALT, but
+    // only the touches family carries dates to answer with, so build() rejects any
+    // other kind (returning null falls through — parseAnchored tolerates it) rather
+    // than pretending "when did X import Y" has a temporal answer.
+    {
+      name: "when",
+      re: new RegExp(`^when\\s+(?:did|does|do|was|were|is)\\s+(.+?)\\s+(?:last\\s+)?(${VERB_ALT})\\??$`, "i"),
+      build: (m) => VERB_TO_KIND[m[2].toLowerCase()] === "touches" ? { shape: "when", entityType: null, modifier: "direct", kind: "touches", object: m[1].trim() } : null
+    }
+  ];
+  function parseAnchored(text) {
+    for (const t of TEMPLATES) {
+      const m = text.match(t.re);
+      if (m) {
+        const parsed = t.build(m);
+        if (parsed) return parsed;
+      }
+    }
+    return null;
+  }
+  var grammarStrategy = {
+    id: "grammar",
+    class: "graph-query",
+    run(text) {
+      const parsed = parseAnchored(text);
+      return parsed ? { strategyId: "grammar", class: "graph-query", candidates: [{ parsed, confidence: 0.9 }] } : null;
+    }
+  };
+
+  // node_modules/@polycode-projects/the-mechanical-code-talker/src/interpret/strategies/keywords.mjs
+  var PASSIVE_AUX = /* @__PURE__ */ new Set(["is", "are", "was", "were", "be", "been", "being", "get", "gets", "got"]);
+  var WH_WORDS = /* @__PURE__ */ new Set(["which", "what", "who", "whom", "whose"]);
+  var PLACEHOLDER_SET = new Set(PLACEHOLDER_NOUNS.map((w) => w.toLowerCase()));
+  function findPhrase(lcWords, table, consumed = null) {
+    const phrases = Object.keys(table).sort((a, b) => b.split(" ").length - a.split(" ").length);
+    for (const p of phrases) {
+      const pWords = p.split(" ");
+      for (let i = 0; i <= lcWords.length - pWords.length; i += 1) {
+        if (consumed && pWords.some((_, j) => consumed.has(i + j))) continue;
+        if (pWords.every((w, j) => lcWords[i + j] === w)) return { kind: table[p], start: i, end: i + pWords.length };
+      }
+    }
+    return null;
+  }
+  function parseKeywordSpot(text, nlp = null) {
+    const words = text.replace(/\?+\s*$/, "").replace(/,/g, " ").split(/\s+/).filter(Boolean);
+    const lcWords = words.map((w) => w.toLowerCase());
+    if (lcWords.includes("where") && !findPhrase(lcWords, VERB_TO_KIND)) {
+      const mention = lcWords.some((w) => MENTION_MARKERS.includes(w));
+      const markers = /* @__PURE__ */ new Set([...WHERE_MARKERS, ...MENTION_MARKERS]);
+      const objText = words.filter((w, i) => !STOPWORDS2.has(lcWords[i]) && !markers.has(lcWords[i])).join(" ").trim();
+      if (objText) {
+        const kind2 = mention ? "mentions" : "where";
+        return { shape: kind2, entityType: null, modifier: "direct", kind: kind2, object: objText };
+      }
+    }
+    let canonWords = lcWords;
+    let verbHit = findPhrase(lcWords, VERB_TO_KIND);
+    if (!verbHit && nlp) {
+      const lemmaWords = lcWords.map((w) => {
+        if (!eligibleForCanon(w)) return w;
+        const l = nlp.lemma(w);
+        return VOCAB_WORDS.has(l) ? l : w;
+      });
+      verbHit = findPhrase(lemmaWords, VERB_TO_KIND);
+      if (verbHit) canonWords = lemmaWords;
+    }
+    if (!verbHit) {
+      const fuzzyWords = lcWords.map((w) => w.length >= 4 && eligibleForCanon(w) ? fuzzyVocabWord(w) || w : w);
+      verbHit = findPhrase(fuzzyWords, VERB_TO_KIND);
+      if (verbHit) canonWords = fuzzyWords;
+    }
+    if (!verbHit && lcWords.includes("by")) {
+      for (let i = 0; i < lcWords.length; i += 1) {
+        const k = PASSIVE_PARTICIPLE_TO_KIND[lcWords[i]];
+        if (k && lcWords.slice(0, i).some((w) => PASSIVE_AUX.has(w))) {
+          verbHit = { kind: k, start: i, end: i + 1 };
+          break;
+        }
+      }
+    }
+    if (!verbHit) return null;
+    if (nlp && verbHit.end - verbHit.start === 1) {
+      const i = verbHit.start;
+      const det = lcWords[i - 1];
+      if ((det === "the" || det === "these" || det === "those") && lcWords[i + 1] === "of") {
+        const tags = nlp.posTags(words);
+        if (tags[i] === "NOUN") {
+          const objText = words.slice(i + 2).filter((w, j) => !STOPWORDS2.has(lcWords[i + 2 + j])).join(" ").trim();
+          if (objText) return { shape: "forward", entityType: null, modifier: "direct", kind: verbHit.kind, object: objText };
+        }
+      }
+    }
+    const consumed = /* @__PURE__ */ new Set();
+    const mark = (hit) => {
+      if (hit) for (let i = hit.start; i < hit.end; i += 1) consumed.add(i);
+    };
+    mark(verbHit);
+    const entityHit = findPhrase(canonWords, ENTITY_TO_TYPE, consumed);
+    mark(entityHit);
+    const modifierHit = findPhrase(canonWords, MODIFIER_TO_KIND, consumed);
+    mark(modifierHit);
+    const sideText = (from, to) => words.slice(from, to).filter((_, j) => !consumed.has(from + j) && !STOPWORDS2.has(lcWords[from + j])).join(" ").trim();
+    const beforeText = sideText(0, verbHit.start);
+    const afterText = sideText(verbHit.end, words.length);
+    const kind = verbHit.kind;
+    const entityType = entityHit ? ENTITY_TO_TYPE[canonWords.slice(entityHit.start, entityHit.end).join(" ")] : null;
+    const modifier = modifierHit ? MODIFIER_TO_KIND[canonWords.slice(modifierHit.start, modifierHit.end).join(" ")] : "direct";
+    if (kind === "touches" && lcWords.includes("when")) {
+      const objText = beforeText || afterText;
+      if (objText) return { shape: "when", entityType: null, modifier: "direct", kind: "touches", object: objText };
+    }
+    const byIdx = lcWords.indexOf("by");
+    const hasPassiveAux = lcWords.slice(0, verbHit.start).some((w) => PASSIVE_AUX.has(w));
+    if (byIdx >= 0 && !consumed.has(byIdx) && hasPassiveAux) {
+      const roleWords = [];
+      for (let i = 0; i < words.length; i += 1) {
+        const w = lcWords[i];
+        if (consumed.has(i) || STOPWORDS2.has(w) || w === "by" || PASSIVE_AUX.has(w) || WH_WORDS.has(w) || PLACEHOLDER_SET.has(w)) continue;
+        roleWords.push(words[i]);
+      }
+      const object = roleWords.join(" ").trim();
+      if (object) {
+        let nextAfterBy = null;
+        for (let i = byIdx + 1; i < lcWords.length; i += 1) {
+          if (lcWords[i] === "the" || lcWords[i] === "a" || lcWords[i] === "an") continue;
+          nextAfterBy = lcWords[i];
+          break;
+        }
+        const agentNamed = nextAfterBy != null && !WH_WORDS.has(nextAfterBy) && !ENTITY_TO_TYPE[nextAfterBy];
+        return { shape: agentNamed ? "forward" : "reverse", entityType, modifier, kind, object };
+      }
+    }
+    if (beforeText && afterText) return { shape: "ask", entityType: null, modifier: "direct", kind, subject: beforeText, object: afterText };
+    if (afterText) return { shape: "reverse", entityType, modifier, kind, object: afterText };
+    if (beforeText) return { shape: "forward", entityType, modifier: "direct", kind, object: beforeText };
+    return null;
+  }
+  var keywordSpotStrategy = {
+    id: "keyword-spot",
+    class: "graph-query",
+    run(text, ctx = {}) {
+      const parsed = parseKeywordSpot(text, ctx.nlp || null);
+      return parsed ? { strategyId: "keyword-spot", class: "graph-query", candidates: [{ parsed, confidence: 0.7 }] } : null;
+    }
+  };
+
+  // node_modules/@polycode-projects/the-mechanical-code-talker/src/interpret/strategies/noise-strip.mjs
+  var KEEP = /* @__PURE__ */ new Set([
+    ...STOPWORDS2,
+    ...wordsOf(CONTEXT_PRONOUNS),
+    ...wordsOf(Object.keys(VERB_TO_KIND)),
+    ...wordsOf(Object.keys(ENTITY_TO_TYPE)),
+    ...wordsOf(Object.keys(MODIFIER_TO_KIND)),
+    ...wordsOf(Object.keys(QUALIFIERS)),
+    ...wordsOf(AGGREGATE_TRIGGERS),
+    ...wordsOf(LIST_TRIGGERS),
+    ...wordsOf(Object.keys(SUPERLATIVE_EXTREMES)),
+    ...wordsOf(Object.keys(EDGE_NOUN_TO_METRIC)),
+    ...wordsOf(Object.keys(BOOLEAN_CONNECTIVES)),
+    ...wordsOf(PLACEHOLDER_NOUNS),
+    ...wordsOf(ANAPHORA_TRIGGERS),
+    ...wordsOf(META_MEANING_VERBS),
+    ...wordsOf(WHERE_MARKERS),
+    ...wordsOf(MENTION_MARKERS),
+    ...wordsOf(RELATIVE_PRONOUNS),
+    ...wordsOf(Object.keys(CASCADE_SYNONYMS))
+  ]);
+  var CURATED_NOISE = /* @__PURE__ */ new Set([...wordsOf(FILLER_WORDS), ...wordsOf(CASCADE_NOISE)]);
+  function stripNoise(text, nlp = null) {
+    const kept = [];
+    const dropped = [];
+    for (const w of splitWords(text)) {
+      const lc = w.toLowerCase();
+      const strippable = /^[a-z]+$/.test(w) && !KEEP.has(lc) && (CURATED_NOISE.has(lc) || nlp && typeof nlp.isStopWord === "function" && nlp.isStopWord(lc));
+      if (strippable) dropped.push(w);
+      else kept.push(w);
+    }
+    return { text: kept.join(" "), dropped };
+  }
+  var noiseStripStrategy = {
+    id: "noise-strip",
+    class: "noise-stripped",
+    run(text, ctx = {}) {
+      if (parseAnchored(text)) return null;
+      const { text: stripped, dropped } = stripNoise(text, ctx.nlp || null);
+      if (!dropped.length || !stripped) return null;
+      const parsed = parseAnchored(stripped) || parseKeywordSpot(stripped, ctx.nlp || null);
+      if (!parsed) return null;
+      return {
+        strategyId: "noise-strip",
+        class: "noise-stripped",
+        candidates: [{ parsed, confidence: 0.75, note: `noise-stripped to "${stripped}"` }]
+      };
+    }
+  };
+
+  // node_modules/@polycode-projects/the-mechanical-code-talker/src/interpret/merge.mjs
+  var DEFAULT_CONFIDENCE = 0.5;
+  var cmpTerm = (s) => String(s || "").trim().toLowerCase().replace(/\s+/g, " ").replace(/^commit\s+(?=[0-9a-f]{7,40}$)/, "");
+  function sameParse(p, q) {
+    if (p.shape !== q.shape || p.kind !== q.kind) return false;
+    if (p.shape === "ask") return cmpTerm(p.subject) === cmpTerm(q.subject) && cmpTerm(p.object) === cmpTerm(q.object);
+    return cmpTerm(p.object) === cmpTerm(q.object);
+  }
+  var APPROXIMATE_VIAS = /* @__PURE__ */ new Set(["fuzzy", "lemma", "spell"]);
+  var isApproximate = (c) => APPROXIMATE_VIAS.has(c.via);
+  function mergeStrategyResults(results) {
+    const valid = (results || []).filter((r) => r && Array.isArray(r.candidates) && r.candidates.length);
+    if (!valid.length) return null;
+    let flat = [];
+    for (const r of valid) {
+      for (const c of r.candidates) {
+        if (!c || !c.parsed) continue;
+        flat.push({
+          parsed: c.parsed,
+          confidence: typeof c.confidence === "number" ? c.confidence : DEFAULT_CONFIDENCE,
+          note: c.note || null,
+          via: c.via || null,
+          strategyId: r.strategyId,
+          class: r.class
+        });
+      }
+    }
+    if (flat.some((c) => !isApproximate(c))) flat = flat.filter((c) => !isApproximate(c));
+    if (!flat.length) return null;
+    const groups = /* @__PURE__ */ new Map();
+    for (const c of flat) {
+      if (!groups.has(c.class)) groups.set(c.class, []);
+      groups.get(c.class).push(c);
+    }
+    const merged = [];
+    for (const [cls, cands] of groups) {
+      const distinct = [];
+      for (const c of cands) {
+        const dup = distinct.find((d) => sameParse(d.parsed, c.parsed) && d.via === c.via);
+        if (dup) {
+          dup.agreed += 1;
+          dup.confidence = Math.max(dup.confidence, c.confidence);
+          continue;
+        }
+        distinct.push({ ...c, agreed: 1 });
+      }
+      if (distinct.length) merged.push({ class: cls, candidates: distinct });
+    }
+    if (!merged.length) return null;
+    const top = (g) => Math.max(...g.candidates.map((c) => c.confidence));
+    let winner = merged[0];
+    for (const g of merged) if (top(g) > top(winner)) winner = g;
+    const parsed = winner.candidates.length === 1 ? winner.candidates[0].parsed : { ambiguousParse: true, candidates: winner.candidates.map((c) => c.parsed) };
+    const alternates = merged.filter((g) => g !== winner).map((g) => g.candidates[0]).filter((a) => !winner.candidates.some((w) => sameParse(w.parsed, a.parsed)));
+    return { class: winner.class, parsed, winner: winner.candidates[0], alternates };
+  }
+
+  // node-stub:node:module
+  var unavailable4 = (name) => () => {
+    throw new Error(name + " unavailable in the browser ask bundle");
+  };
+  var createRequire4 = unavailable4("createRequire");
+  var readFileSync4 = unavailable4("readFileSync");
+  var randomBytes4 = unavailable4("randomBytes");
+
+  // node_modules/@polycode-projects/the-mechanical-code-talker/src/wink-model.mjs
+  var import_meta = {};
+  var injected;
+  var cached;
+  function loadWinkModel() {
+    if (cached !== void 0) return cached;
+    try {
+      const pair = injected ? injected() : nodeRequireWink();
+      cached = pair && pair.winkNLP && pair.model ? pair : null;
+    } catch {
+      cached = null;
+    }
+    return cached;
+  }
+  function nodeRequireWink() {
+    const require2 = createRequire4(import_meta.url);
+    return {
+      winkNLP: require2("wink-nlp"),
+      model: require2("wink-eng-lite-web-model")
+    };
+  }
+  function winkInstance() {
+    const loaded = loadWinkModel();
+    if (!loaded) return null;
+    try {
+      return loaded.winkNLP(loaded.model);
+    } catch {
+      return null;
+    }
+  }
+
+  // node_modules/@polycode-projects/the-mechanical-code-talker/src/ask-nlp.mjs
+  var cached2;
+  function nlpAdapter() {
+    if (cached2 !== void 0) return cached2;
+    try {
+      const nlp = winkInstance();
+      if (!nlp) {
+        cached2 = null;
+        return cached2;
+      }
+      const its = nlp.its;
+      cached2 = {
+        /** Lowercase lemma of a single token ("imported" -> "import"); the word
+         *  itself when wink has nothing better (unknown words come back as-is). */
+        lemma(word) {
+          const w = String(word || "");
+          try {
+            const out = nlp.readDoc(w).tokens().out(its.lemma);
+            return String(out[0] || w).toLowerCase();
+          } catch {
+            return w.toLowerCase();
+          }
+        },
+        /** True when wink's lexicon flags the word as an English stop word
+         *  ("anyway", "well", "also", …). Consulted by the noise-strip strategy
+         *  (interpret/strategies/noise-strip.mjs) as its wink tier — the strategy's
+         *  own KEEP set screens out the grammar's load-bearing words (which/what/
+         *  does/…) BEFORE this is asked, so wink flagging a question word is
+         *  harmless by construction. False on any surprise, never a throw. */
+        isStopWord(word) {
+          try {
+            const out = nlp.readDoc(String(word || "")).tokens().out(its.stopWordFlag);
+            return out[0] === true;
+          } catch {
+            return false;
+          }
+        },
+        /** UPOS tags aligned to the CALLER's word array. wink re-tokenizes (it
+         *  splits "walk.mjs" into three tokens), so each input word is greedily
+         *  matched to the run of wink tokens that spell it and takes its FIRST
+         *  sub-token's tag; null per word on any surprise, never a throw. */
+        posTags(words) {
+          try {
+            const toks = nlp.readDoc(words.join(" ")).tokens();
+            const texts = toks.out();
+            const tags = toks.out(its.pos);
+            const out = [];
+            let k = 0;
+            for (const w of words) {
+              if (k >= texts.length) {
+                out.push(null);
+                continue;
+              }
+              out.push(tags[k]);
+              let acc = texts[k];
+              k += 1;
+              while (acc.length < w.length && k < texts.length) {
+                acc += texts[k];
+                k += 1;
+              }
+            }
+            return out;
+          } catch {
+            return words.map(() => null);
+          }
+        }
+      };
+    } catch {
+      cached2 = null;
+    }
+    return cached2;
+  }
+
+  // node_modules/@polycode-projects/the-mechanical-code-talker/src/interpret/pipeline.mjs
+  var STRATEGIES = [grammarStrategy, keywordSpotStrategy, noiseStripStrategy];
+  function runStrategiesSync(text, ctx = {}, strategies = STRATEGIES) {
+    const results = [];
+    for (const s of strategies) {
+      try {
+        const r = s.run(text, ctx);
+        if (r && typeof r.then !== "function") results.push(r);
+      } catch {
+      }
+    }
+    return results;
+  }
+
+  // node_modules/@polycode-projects/the-mechanical-code-talker/src/ask.mjs
+  function edgesOfKind(graph, kind) {
+    const out = [];
+    for (const g of graph.relations) if (relationKind(g) === kind) out.push(...g.edges);
+    return out;
+  }
+  var SYMBOL_GRAIN_SIBLING = { calls: "callsSymbol", touches: "touchesSymbol" };
+  var FINE_ENTITY_TYPES = /* @__PURE__ */ new Set(["Function", "Method", "Class", "Attribute", "GlobalVariable"]);
+  var KIND_UNIONS = { uses: ["imports", "calls", "callsSymbol"] };
+  var kindsFor = (kind) => KIND_UNIONS[kind] || [kind];
+  var OVERFLOW_CAP = 12;
+  var PLURAL_FORMS = {
+    Function: ["function", "functions"],
+    Method: ["method", "methods"],
+    Class: ["class", "classes"],
+    Module: ["module", "modules"],
+    Attribute: ["attribute", "attributes"],
+    GlobalVariable: ["variable", "variables"],
+    Commit: ["commit", "commits"],
+    // "Change" is ask-vocab.mjs's pseudo-type (a wildcard over the touch traversal's
+    // results, never a node class) — it still needs noun forms for zero-hit templates.
+    Change: ["change", "changes"]
+  };
+  function nounFor(entityType, n) {
+    const [s, p] = PLURAL_FORMS[entityType] || ["result", "results"];
+    return n === 1 ? s : p;
+  }
+  var REVERSE_MISS_VERB = { cochange: "cochanges" };
+  function verbFor(kind) {
+    return REVERSE_MISS_VERB[kind] || kind;
+  }
+  function defaultNlp() {
+    return typeof nlpAdapter === "function" ? nlpAdapter() : null;
+  }
+  function parseQuery(query, { nlp = void 0 } = {}) {
+    const adapter = nlp === void 0 ? defaultNlp() : nlp;
+    const raw = String(query || "").trim().replace(/\s+/g, " ");
+    if (!raw) return null;
+    const text = applyNegationFrames(normalizeQuery(raw));
+    if (!text) return null;
+    const composite = parseComposite(text, adapter);
+    if (composite) return composite;
+    const merged = mergeStrategyResults(runStrategiesSync(text, { nlp: adapter, raw }));
+    return merged ? merged.parsed : null;
+  }
+  var MAX_COMPOSE_DEPTH = 4;
+  var NEST_SENTINEL = "zzinnerset";
+  var PRED_LEAD_SKIP = /* @__PURE__ */ new Set(["that", "which", "who", "are", "is", "was", "were", "do", "does", "also", "still", "both", "and"]);
+  var FRAME_WORDS = /* @__PURE__ */ new Set(["which", "what", "who", "list", "show", "find", "give", "me", "us", "all"]);
+  var entityNoun = (w) => ENTITY_TO_TYPE[w] ? { entityType: ENTITY_TO_TYPE[w], placeholder: false } : PLACEHOLDER_NOUNS.includes(w) ? { entityType: null, placeholder: true } : null;
+  var isGerundVerb = (w) => !!VERB_TO_KIND[w] && w.endsWith("ing");
+  function parseSimpleClause(text, nlp) {
+    return parseAnchored(text) || parseKeywordSpot(text, nlp);
+  }
+  function parseComposite(text, nlp) {
+    const w = splitWords(text);
+    const lc = w.map((x) => x.toLowerCase());
+    return parseNegation(text, nlp, 0) || parseForwardNegation(w, lc, nlp) || parseAnaphora(w, lc, nlp) || parseAggregate(w, lc, nlp) || parseSuperlative(w, lc, nlp) || parseList(w, lc, nlp, 0) || parseNested(w, lc, nlp, 0) || parseRelationalOrQualified(w, lc, nlp, 0);
+  }
+  function complementAst(entityType, diffAtom) {
+    return {
+      node: "boolean",
+      entityType,
+      atoms: [
+        { op: "seed", kind: "set", ast: { node: "allOfClass", entityType } },
+        diffAtom
+      ]
+    };
+  }
+  function parseNegation(text, nlp, depth = 0) {
+    const neg = matchNegationSet(text);
+    if (!neg) return null;
+    const noun = entityNoun(neg.entWord);
+    if (!noun || noun.placeholder || !noun.entityType) return null;
+    const entityType = noun.entityType;
+    if (entityType === "Change") {
+      return { node: "miss", reason: `"${neg.entWord}" isn't an enumerable kind \u2014 a set complement needs a concrete kind (functions, classes, modules, \u2026)` };
+    }
+    const predWords = splitWords(neg.predicate);
+    const predLc = predWords.map((x) => x.toLowerCase());
+    if (predLc.length && predLc.every((x) => QUALIFIERS[x])) {
+      return complementAst(entityType, { op: "difference", kind: "qual", filters: predLc });
+    }
+    const vh = findPhrase(predLc, VERB_TO_KIND);
+    if (!vh) return { node: "miss", reason: "a negated set query needs a known relation verb (import, call, inherit from, test, \u2026)" };
+    const objWords = predWords.filter((_, i) => (i < vh.start || i >= vh.end) && !STOPWORDS2.has(predLc[i]) && predLc[i] !== "from");
+    if (!objWords.length) {
+      return complementAst(entityType, { op: "difference", kind: "set", ast: { node: "existsEdge", entityType, kind: vh.kind } });
+    }
+    const positive = parseSetPhrase(`which ${neg.entWord} ${neg.predicate}`, nlp, depth + 1);
+    if (!positive || positive.node === "miss") {
+      return { node: "miss", reason: positive && positive.reason || "the negated clause didn't parse" };
+    }
+    return complementAst(entityType, { op: "difference", kind: "set", ast: positive });
+  }
+  var FWD_NEG_FRAME = /* @__PURE__ */ new Set(["what", "which", "thing", "things", "one", "ones", "stuff"]);
+  function parseForwardNegation(w, lc, nlp) {
+    let i = 0;
+    while (i < lc.length && FWD_NEG_FRAME.has(lc[i])) i += 1;
+    if (!["do", "does", "did"].includes(lc[i])) return null;
+    i += 1;
+    const rest = w.slice(i);
+    const restLc = lc.slice(i);
+    const notIdx = restLc.indexOf("not");
+    if (notIdx < 0) return null;
+    const vh = findPhrase(restLc, VERB_TO_KIND);
+    if (!vh) return null;
+    const subjTokens = rest.filter((_, j) => j !== notIdx && (j < vh.start || j >= vh.end) && restLc[j] !== "from" && !STOPWORDS2.has(restLc[j]));
+    const subjectTerm = subjTokens.join(" ").trim();
+    if (!subjectTerm) return null;
+    return { node: "forwardComplement", kind: vh.kind, subjectTerm };
+  }
+  function kindObjectClass(graph, kind) {
+    const classes = /* @__PURE__ */ new Set();
+    for (const k of kindsFor(kind)) {
+      for (const e of edgesOfKind(graph, k)) {
+        const o = graph.byId.get(e.object);
+        if (o && o.class) classes.add(o.class);
+      }
+    }
+    return classes.size === 1 ? [...classes][0] : null;
+  }
+  function parseSetPhrase(text, nlp, depth) {
+    if (depth > MAX_COMPOSE_DEPTH) return { node: "miss", reason: "too deep to resolve" };
+    const negated = parseNegation(text, nlp, depth);
+    if (negated) return negated;
+    const w = splitWords(text);
+    const lc = w.map((x) => x.toLowerCase());
+    const nested = parseNested(w, lc, nlp, depth);
+    if (nested) return nested;
+    const rel = parseRelationalOrQualified(w, lc, nlp, depth);
+    if (rel) return rel;
+    const clause = parseSimpleClause(text, nlp);
+    if (clause) return { node: "clause", clause };
+    return null;
+  }
+  function parseNested(w, lc, nlp, depth) {
+    for (let r = 1; r < lc.length; r += 1) {
+      if (!RELATIVE_PRONOUNS.includes(lc[r])) continue;
+      if (r + 1 >= lc.length) continue;
+      const noun = entityNoun(lc[r - 1]);
+      if (!noun) continue;
+      const head = w.slice(0, r - 1);
+      if (!head.length) continue;
+      const outer = parseSimpleClause([...head, NEST_SENTINEL].join(" "), nlp);
+      if (!outer || outer.shape !== "reverse" && outer.shape !== "forward") continue;
+      if (outer.modifier && outer.modifier !== "direct") continue;
+      const innerText = `which ${lc[r - 1]} ${w.slice(r + 1).join(" ")}`;
+      const inner = parseSetPhrase(innerText, nlp, depth + 1);
+      if (!inner || inner.node === "miss") return inner ? { node: "miss", reason: inner.reason || "inner clause didn't parse" } : { node: "miss", reason: "inner clause didn't parse" };
+      return { node: outer.shape === "reverse" ? "reverseSet" : "forwardSet", kind: outer.kind, entityType: outer.entityType, inner };
+    }
+    return null;
+  }
+  function parseAnaphora(w, lc, nlp) {
+    let p = -1;
+    let viaOf = false;
+    for (let i = 1; i < lc.length; i += 1) {
+      if (!ANAPHORA_TRIGGERS.includes(lc[i])) continue;
+      if (lc[i - 1] === "of") {
+        p = i;
+        viaOf = true;
+        break;
+      }
+      const headSoFar = lc.slice(0, i).join(" ");
+      if (i === lc.length - 1 && (AGGREGATE_TRIGGERS.includes(headSoFar) || LIST_TRIGGERS.includes(headSoFar))) {
+        p = i;
+        break;
+      }
+    }
+    if (p < 0) return null;
+    const head = (viaOf ? lc.slice(0, p - 1) : lc.slice(0, p)).join(" ");
+    const mode = AGGREGATE_TRIGGERS.includes(head) || /^(how many|how much|count|number|quantity|total)\b/.test(head) ? "count" : "list";
+    const filter = parsePredicateFilter(w.slice(p + 1), nlp);
+    if (filter === void 0) return { node: "miss", reason: "the follow-up filter didn't parse" };
+    return { node: "anaphora", mode, filter };
+  }
+  function parsePredicateFilter(words, nlp) {
+    let i = 0;
+    const lc = words.map((x) => x.toLowerCase());
+    while (i < lc.length && PRED_LEAD_SKIP.has(lc[i])) i += 1;
+    const rest = words.slice(i);
+    const restLc = lc.slice(i);
+    if (!rest.length) return { type: "all" };
+    if (restLc.every((x) => QUALIFIERS[x])) return { type: "qual", filters: restLc };
+    const clause = parseSimpleClause(`what ${rest.join(" ")}`, nlp);
+    if (clause && (clause.shape === "reverse" || clause.shape === "forward") && clause.object) {
+      return { type: "clause", clause };
+    }
+    return void 0;
+  }
+  var AGG_TAIL_FILLER = /* @__PURE__ */ new Set([
+    "total",
+    "altogether",
+    "overall",
+    "exist",
+    "exists",
+    "existing",
+    "present",
+    "here",
+    "now",
+    "currently",
+    "graph",
+    "index",
+    "codebase",
+    "repo",
+    "repository"
+  ]);
+  function parseAggregate(w, lc, nlp) {
+    const trig = AGGREGATE_TRIGGERS.find((t) => lc.slice(0, t.split(" ").length).join(" ") === t);
+    if (!trig) return null;
+    let i = trig.split(" ").length;
+    while (i < lc.length && (lc[i] === "the" || lc[i] === "a" || lc[i] === "all")) i += 1;
+    const quals = [];
+    while (i < lc.length && QUALIFIERS[lc[i]]) {
+      quals.push(lc[i]);
+      i += 1;
+    }
+    const noun = i < lc.length ? entityNoun(lc[i]) : null;
+    if (!noun) return { node: "miss", reason: "count needs a known entity kind (functions, classes, modules, \u2026)" };
+    const entWord = lc[i];
+    i += 1;
+    const tail = w.slice(i);
+    const tailMeaningful = lc.slice(i).some((t) => !STOPWORDS2.has(t) && !AGG_TAIL_FILLER.has(t));
+    let base;
+    if (tailMeaningful) {
+      const setAst = parseSetPhrase(`which ${entWord} ${tail.join(" ")}`, nlp, 1);
+      if (!setAst || setAst.node === "miss") return { node: "miss", reason: "the count restrictor didn't parse" };
+      base = setAst;
+    } else {
+      base = { node: "allOfClass", entityType: noun.entityType };
+    }
+    if (quals.length) base = { node: "qualifier", filters: quals, inner: base };
+    return { node: "count", entityType: noun.entityType, base };
+  }
+  var LIST_SKIP = /* @__PURE__ */ new Set(["the", "a", "an", "all", "me", "us"]);
+  var LIST_TRIGGERS_SORTED = [...LIST_TRIGGERS].sort((a, b) => b.split(" ").length - a.split(" ").length);
+  var LISTABLE_KINDS = "functions, classes, methods, modules, attributes, variables, or commits";
+  function parseList(w, lc, nlp, depth) {
+    let i = 0;
+    let interrogative = false;
+    let matched = null;
+    for (const t of LIST_TRIGGERS_SORTED) {
+      const tw = t.split(" ");
+      if (lc.slice(0, tw.length).join(" ") === t) {
+        matched = t;
+        i = tw.length;
+        break;
+      }
+    }
+    if (!matched) {
+      if (lc[0] === "what" || lc[0] === "which") {
+        interrogative = true;
+        i = 1;
+      } else return null;
+    }
+    while (i < lc.length && LIST_SKIP.has(lc[i])) i += 1;
+    const quals = [];
+    while (i < lc.length && QUALIFIERS[lc[i]]) {
+      quals.push(lc[i]);
+      i += 1;
+    }
+    const noun = i < lc.length ? entityNoun(lc[i]) : null;
+    if (!noun || noun.placeholder || noun.entityType === "Change") {
+      if (!interrogative && i < lc.length && i === lc.length - 1 && /^[a-z]+$/.test(lc[i]) && !VERB_TO_KIND[lc[i]] && !PLACEHOLDER_NOUNS.includes(lc[i])) {
+        return { node: "miss", reason: `"${lc[i]}" isn't a listable kind \u2014 try ${LISTABLE_KINDS}` };
+      }
+      return null;
+    }
+    const entityType = noun.entityType;
+    const entWord = lc[i];
+    i += 1;
+    const tail = w.slice(i);
+    const tailMeaningful = lc.slice(i).some((t) => !STOPWORDS2.has(t) && !AGG_TAIL_FILLER.has(t));
+    if (interrogative && (tailMeaningful || tail.length === 0)) return null;
+    let base;
+    let scoped = false;
+    if (tailMeaningful) {
+      const setAst = parseSetPhrase(`which ${[...quals, entWord, ...tail].join(" ")}`, nlp, (depth || 0) + 1);
+      if (!setAst || setAst.node === "miss") return { node: "miss", reason: setAst && setAst.reason || "the list filter didn't parse" };
+      base = setAst;
+      scoped = true;
+    } else {
+      base = { node: "allOfClass", entityType };
+      if (quals.length) base = { node: "qualifier", filters: quals, inner: base };
+    }
+    return { node: "list", entityType, base, scoped };
+  }
+  function parseSuperlative(w, lc, nlp) {
+    let ext = null;
+    let extIdx = -1;
+    for (let i = 0; i < lc.length; i += 1) {
+      const two = lc.slice(i, i + 2).join(" ");
+      if (SUPERLATIVE_EXTREMES[two]) {
+        ext = SUPERLATIVE_EXTREMES[two];
+        extIdx = i;
+        break;
+      }
+      if (SUPERLATIVE_EXTREMES[lc[i]]) {
+        ext = SUPERLATIVE_EXTREMES[lc[i]];
+        extIdx = i;
+        break;
+      }
+    }
+    if (!ext) return null;
+    let entityType;
+    let entWord = null;
+    for (const x of lc) {
+      const n = entityNoun(x);
+      if (n && !n.placeholder) {
+        entityType = n.entityType;
+        entWord = x;
+        break;
+      }
+    }
+    if (!entWord) return { node: "miss", reason: "a superlative needs an entity kind (module, class, function, \u2026)" };
+    let metric = null;
+    let metricNoun = null;
+    for (let i = extIdx; i < lc.length; i += 1) {
+      if (EDGE_NOUN_TO_METRIC[lc[i]]) {
+        metric = EDGE_NOUN_TO_METRIC[lc[i]];
+        metricNoun = lc[i];
+        break;
+      }
+    }
+    const connectivity = lc.includes("connected") || lc.slice(extIdx, extIdx + 2).join(" ") === "most connected" || ["largest", "biggest", "smallest"].includes(lc[extIdx]);
+    if (!metric) {
+      if (connectivity) {
+        metric = EDGE_NOUN_TO_METRIC.connections;
+        metricNoun = "connections";
+      } else return { node: "miss", reason: "name what to rank by (imports, callers, methods, tests, or connections)" };
+    }
+    return { node: "superlative", entityType, metric, metricNoun, extreme: ext };
+  }
+  function parseRelationalOrQualified(w, lc, nlp, depth) {
+    let i = 0;
+    while (i < lc.length && FRAME_WORDS.has(lc[i])) i += 1;
+    const framed = i > 0;
+    const quals = [];
+    while (i < lc.length && QUALIFIERS[lc[i]]) {
+      quals.push(lc[i]);
+      i += 1;
+    }
+    const noun = i < lc.length ? entityNoun(lc[i]) : null;
+    if (!noun) {
+      if ((framed || quals.length) && i + 1 < lc.length && /^[a-z]+$/.test(lc[i]) && !VERB_TO_KIND[lc[i]] && !STOPWORDS2.has(lc[i]) && entityNoun(lc[i + 1])) {
+        return { node: "miss", reason: `unknown qualifier "${lc[i]}" \u2014 supported: ${Object.keys(QUALIFIERS).join(", ")}` };
+      }
+      return null;
+    }
+    const entityType = noun.entityType;
+    const entWord = lc[i];
+    i += 1;
+    let predLc = lc.slice(i);
+    let predWords = w.slice(i);
+    let relFlag = false;
+    if (predLc.length && RELATIVE_PRONOUNS.includes(predLc[0])) {
+      relFlag = true;
+      predLc = predLc.slice(1);
+      predWords = predWords.slice(1);
+    }
+    const membershipLed = predLc[0] === "of" || predLc[0] === "in";
+    const gerundLed = predLc.length > 0 && isGerundVerb(predLc[0]);
+    if (!(quals.length || relFlag || membershipLed || gerundLed)) return null;
+    if (!predWords.length) {
+      let base = { node: "allOfClass", entityType };
+      if (!quals.length) return { node: "miss", reason: "nothing to filter or traverse" };
+      return { node: "qualifier", filters: quals, inner: base };
+    }
+    const subjPrefix = noun.placeholder ? "what" : `which ${entWord}`;
+    const { branches, ops } = splitBoolean(predLc, predWords);
+    let prevVerb = null;
+    const atoms = [];
+    for (let b = 0; b < branches.length; b += 1) {
+      const bw = branches[b];
+      const blc = bw.map((x) => x.toLowerCase());
+      const op = b === 0 ? "seed" : ops[b - 1];
+      if (bw.length && blc.every((x) => QUALIFIERS[x])) {
+        atoms.push({ op, kind: "qual", filters: blc });
+        continue;
+      }
+      if (blc[0] === "of" || blc[0] === "in") {
+        atoms.push({ op, kind: "set", ast: { node: "membership", entityType, term: bw.slice(1).join(" ") } });
+        continue;
+      }
+      let phrase = bw;
+      const vh = findPhrase(blc, VERB_TO_KIND);
+      if (vh) prevVerb = bw.slice(vh.start, vh.end);
+      else if (prevVerb) phrase = [...prevVerb, ...bw];
+      const ast = parseBranchAst(`${subjPrefix} ${phrase.join(" ")}`, nlp, depth + 1);
+      if (!ast || ast.node === "miss") return { node: "miss", reason: ast && ast.reason || "a clause in the combination didn't parse" };
+      atoms.push({ op, kind: "set", ast });
+    }
+    if (atoms[0].kind !== "set") return { node: "miss", reason: "start with a clause, then combine with and/or/but-not" };
+    let result;
+    if (atoms.length === 1) {
+      result = atoms[0].ast;
+    } else {
+      result = { node: "boolean", entityType, atoms };
+    }
+    if (quals.length) result = { node: "qualifier", filters: quals, inner: result };
+    return result;
+  }
+  function parseBranchAst(text, nlp, depth) {
+    if (depth > MAX_COMPOSE_DEPTH) return { node: "miss", reason: "too deep to resolve" };
+    const w = splitWords(text);
+    const lc = w.map((x) => x.toLowerCase());
+    const nested = parseNested(w, lc, nlp, depth);
+    if (nested) return nested;
+    const clause = parseSimpleClause(text, nlp);
+    return clause ? { node: "clause", clause } : null;
+  }
+  function splitBoolean(predLc, predWords) {
+    const conns = Object.keys(BOOLEAN_CONNECTIVES).sort((a, z) => z.split(" ").length - a.split(" ").length);
+    const branches = [];
+    const ops = [];
+    let start = 0;
+    let i = 0;
+    while (i < predLc.length) {
+      let hit = null;
+      for (const c of conns) {
+        const cw = c.split(" ");
+        if (predLc.slice(i, i + cw.length).join(" ") === c) {
+          hit = { c, len: cw.length };
+          break;
+        }
+      }
+      if (hit && i > start) {
+        branches.push(predWords.slice(start, i));
+        ops.push(BOOLEAN_CONNECTIVES[hit.c]);
+        i += hit.len;
+        start = i;
+      } else if (hit) {
+        i += hit.len;
+        start = i;
+      } else i += 1;
+    }
+    branches.push(predWords.slice(start));
+    return { branches, ops };
+  }
+  function reverseOverSet(graph, kind, entityType, objectIds) {
+    const symbolKind = SYMBOL_GRAIN_SIBLING[kind];
+    if (symbolKind && FINE_ENTITY_TYPES.has(entityType)) {
+      const edges2 = edgesOfKind(graph, symbolKind).filter((e) => objectIds.has(e.object));
+      return uniqueById(edges2.map((e) => graph.byId.get(e.subject)).filter((s) => s && s.class === entityType));
+    }
+    const edges = kindsFor(kind).flatMap((k) => edgesOfKind(graph, k)).filter((e) => objectIds.has(e.object));
+    const subjects = uniqueById(edges.map((e) => graph.byId.get(e.subject)).filter(Boolean));
+    if (!entityType || entityType === "Change") return subjects;
+    const direct = subjects.filter((s) => s.class === entityType);
+    if (direct.length) return direct;
+    if (entityType !== "Module" && subjects.some((s) => s.class === "Module")) {
+      return refineToEntities(graph, new Set(subjects.filter((s) => s.class === "Module").map((s) => s.id)), entityType);
+    }
+    return [];
+  }
+  function forwardOverSet(graph, kind, subjectIds) {
+    const edges = kindsFor(kind).flatMap((k) => edgesOfKind(graph, k)).filter((e) => subjectIds.has(e.subject));
+    return uniqueById(edges.map((e) => graph.byId.get(e.object)).filter(Boolean));
+  }
+  function uniqueById(inds) {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const x of inds) if (x && !seen.has(x.id)) {
+      seen.add(x.id);
+      out.push(x);
+    }
+    return out;
+  }
+  var qualCache = /* @__PURE__ */ new WeakMap();
+  function qualSets(graph) {
+    let c = qualCache.get(graph);
+    if (c) return c;
+    const exported = /* @__PURE__ */ new Set();
+    for (const e of edgesOfKind(graph, "reexports")) {
+      exported.add(String(e.object).toLowerCase());
+      const ind = graph.byId.get(e.object);
+      if (ind) exported.add(String(ind.label).toLowerCase());
+    }
+    const testedModules = new Set(edgesOfKind(graph, "tests").map((e) => e.object));
+    const moduleOfSymbol = /* @__PURE__ */ new Map();
+    for (const e of edgesOfKind(graph, "defines")) moduleOfSymbol.set(e.object, e.subject);
+    c = { exported, testedModules, moduleOfSymbol };
+    qualCache.set(graph, c);
+    return c;
+  }
+  function moduleIdOf2(graph, ind) {
+    if (!ind) return null;
+    if (ind.class === "Module") return ind.id;
+    return qualSets(graph).moduleOfSymbol.get(ind.id) || null;
+  }
+  function qualHolds(graph, ind, spec) {
+    if (!spec) return false;
+    switch (spec.via) {
+      case "visibility": {
+        const v = String((ind.attributes || []).find((a) => a.key === "visibility")?.value || "public").toLowerCase();
+        return v === spec.value;
+      }
+      case "attr":
+        return !!(ind.attributes || []).find((a) => a.key === spec.attr)?.value;
+      case "exported": {
+        const ex = qualSets(graph).exported;
+        return ex.has(String(ind.label).toLowerCase()) || ex.has(String(ind.id).toLowerCase());
+      }
+      case "tested": {
+        const mid = moduleIdOf2(graph, ind);
+        return (!!mid && qualSets(graph).testedModules.has(mid)) === spec.value;
+      }
+      default:
+        return false;
+    }
+  }
+  function evalSet(graph, ast, opts) {
+    switch (ast.node) {
+      case "clause":
+        return traverse(graph, ast.clause, opts).matches || [];
+      case "allOfClass":
+        return graph.individuals.filter((i) => i.class === ast.entityType);
+      // the SUBJECTS that have ANY edge of a kind (the existential "modules that import
+      // anything") — the positive set an existential negation ("do not import anything")
+      // differences off allOfClass to yield "modules that import nothing".
+      case "existsEdge": {
+        const subs = new Set(kindsFor(ast.kind).flatMap((k) => edgesOfKind(graph, k)).map((e) => e.subject));
+        return graph.individuals.filter((i) => subs.has(i.id) && (!ast.entityType || i.class === ast.entityType));
+      }
+      // forward complement: the verb's object-grain universe MINUS what the (late-resolved,
+      // focus-bindable) subject reaches via that verb — "what doesn't it import".
+      case "forwardComplement": {
+        const r = resolveTermOrContext(graph, ast.subjectTerm, opts && opts.contextId);
+        if (!r.match) return [];
+        const universeType = kindObjectClass(graph, ast.kind);
+        if (!universeType) return [];
+        const positive = new Set(forwardOverSet(graph, ast.kind, /* @__PURE__ */ new Set([r.match.id])).map((x) => x.id));
+        return graph.individuals.filter((i) => i.class === universeType && !positive.has(i.id));
+      }
+      case "reverseSet": {
+        const ids = new Set(evalSet(graph, ast.inner, opts).map((i) => i.id));
+        return reverseOverSet(graph, ast.kind, ast.entityType, ids);
+      }
+      case "forwardSet": {
+        const ids = new Set(evalSet(graph, ast.inner, opts).map((i) => i.id));
+        return forwardOverSet(graph, ast.kind, ids);
+      }
+      case "membership": {
+        const r = resolveObject(graph, ast.term);
+        if (!r.match) return [];
+        const ids = /* @__PURE__ */ new Set([r.match.id]);
+        const objs = uniqueById(MEMBERSHIP_KINDS.flatMap((k) => forwardOverSet(graph, k, ids)));
+        return ast.entityType ? objs.filter((o) => o.class === ast.entityType) : objs;
+      }
+      case "qualifier": {
+        const base = evalSet(graph, ast.inner, opts);
+        return base.filter((ind) => ast.filters.every((f) => qualHolds(graph, ind, QUALIFIERS[f])));
+      }
+      case "boolean":
+        return evalBoolean(graph, ast, opts);
+      case "anaphora":
+        return evalAnaphora(graph, ast, opts).matches;
+      default:
+        return [];
+    }
+  }
+  function evalBoolean(graph, ast, opts) {
+    let acc = [];
+    for (const atom of ast.atoms) {
+      if (atom.op === "seed") {
+        acc = evalSet(graph, atom.ast, opts);
+        continue;
+      }
+      if (atom.kind === "qual") {
+        const holds = (ind) => atom.filters.every((f) => qualHolds(graph, ind, QUALIFIERS[f]));
+        acc = atom.op === "difference" ? acc.filter((i) => !holds(i)) : acc.filter((i) => holds(i));
+        continue;
+      }
+      const oids = new Set(evalSet(graph, atom.ast, opts).map((i) => i.id));
+      if (atom.op === "intersection") acc = acc.filter((i) => oids.has(i.id));
+      else if (atom.op === "difference") acc = acc.filter((i) => !oids.has(i.id));
+      else if (atom.op === "union") {
+        const seen = new Set(acc.map((i) => i.id));
+        for (const other of evalSet(graph, atom.ast, opts)) if (!seen.has(other.id)) {
+          seen.add(other.id);
+          acc.push(other);
+        }
+      }
+    }
+    return acc;
+  }
+  function evalAnaphora(graph, ast, opts) {
+    const prev = opts && opts.prev;
+    if (!Array.isArray(prev) || !prev.length) return { compositeMiss: true, reason: "no-prev", matches: [] };
+    let items = prev.map((id) => graph.byId.get(id)).filter(Boolean);
+    const f = ast.filter;
+    if (f && f.type === "qual") {
+      items = items.filter((ind) => f.filters.every((q) => qualHolds(graph, ind, QUALIFIERS[q])));
+    } else if (f && f.type === "clause") {
+      const r = resolveObject(graph, f.clause.object);
+      if (!r.match) items = [];
+      else {
+        const sib = SYMBOL_GRAIN_SIBLING[f.clause.kind];
+        const kinds = [...kindsFor(f.clause.kind), ...sib ? [sib] : []];
+        const ok = new Set(kinds.flatMap((k) => edgesOfKind(graph, k)).filter((e) => e.object === r.match.id).map((e) => e.subject));
+        items = items.filter((ind) => ok.has(ind.id));
+      }
+    }
+    const common = items.length && items.every((x) => x.class === items[0].class) ? items[0].class : null;
+    if (ast.mode === "count") return { compositeKind: "count", count: items.length, entityType: common, matches: [] };
+    return { compositeKind: "set", matches: items, entityType: common };
+  }
+  var DEGREE_KINDS = ["imports", "calls", "callsSymbol", "inherits", "contains", "tests"];
+  function degreeMetric(graph, ind, metric) {
+    const kinds = metric.kind === "*" ? DEGREE_KINDS : [metric.kind, ...metric.sibling ? [metric.sibling] : []];
+    let n = 0;
+    for (const k of kinds) for (const e of edgesOfKind(graph, k)) {
+      const out = e.subject === ind.id;
+      const inc = e.object === ind.id;
+      if (metric.dir === "out" && out) {
+        if (metric.filter) {
+          const o = graph.byId.get(e.object);
+          if (!o || o.class !== metric.filter) continue;
+        }
+        n += 1;
+      } else if (metric.dir === "in" && inc) n += 1;
+      else if (metric.dir === "both" && (out || inc)) n += 1;
+    }
+    return n;
+  }
+  function evalSuperlative(graph, ast) {
+    const pool = graph.individuals.filter((i) => i.class === ast.entityType);
+    const scored = pool.map((ind) => ({ ind, score: degreeMetric(graph, ind, ast.metric) })).sort((a, z) => ast.extreme === "most" ? z.score - a.score : a.score - z.score);
+    if (!scored.length) return { compositeKind: "superlative", entityType: ast.entityType, matches: [] };
+    const best = scored[0].score;
+    const winners = scored.filter((s) => s.score === best).map((s) => s.ind);
+    return { compositeKind: "superlative", entityType: ast.entityType, metricNoun: ast.metricNoun, extreme: ast.extreme, score: best, matches: winners };
+  }
+  function evalComposite(graph, ast, opts = {}) {
+    if (ast.node === "miss") return { compositeMiss: true, reason: ast.reason || null, matches: [] };
+    if (ast.node === "count") return { compositeKind: "count", count: evalSet(graph, ast.base, opts).length, entityType: ast.entityType, matches: [] };
+    if (ast.node === "list") return { compositeKind: "list", matches: evalSet(graph, ast.base, opts), entityType: ast.entityType, scoped: ast.scoped };
+    if (ast.node === "superlative") return evalSuperlative(graph, ast);
+    if (ast.node === "anaphora") return evalAnaphora(graph, ast, opts);
+    return { compositeKind: "set", matches: evalSet(graph, ast, opts), entityType: ast.entityType || null };
+  }
+  var compositeList = (matches) => listJoin(matches.slice(0, OVERFLOW_CAP).map((m) => ["Function", "Method"].includes(m.class) ? `${m.label}()` : m.label)) + (matches.length > OVERFLOW_CAP ? `, \u2026and ${matches.length - OVERFLOW_CAP} more` : "");
+  function compositionalHint() {
+    return 'compositional queries also work: "which functions call X and call Y", "what calls something that imports X", "public methods of X", "list functions" / "show me the classes", "how many classes", "which module has the most imports", or (after a listing) "which of those are tested"';
+  }
+  function renderComposite(parsed, result) {
+    if (result.compositeMiss) {
+      if (result.reason === "no-prev") {
+        return { content: `"those"/"them" needs a previous answer to refer to \u2014 ask a listing question first, then follow up.`, miss: true, ambiguous: false };
+      }
+      return { content: `couldn't compile this compositional question${result.reason ? ` (${result.reason})` : ""}. ${compositionalHint()}.`, miss: true, ambiguous: false };
+    }
+    if (result.compositeKind === "count") {
+      const noun = result.entityType ? nounFor(result.entityType, result.count) : result.count === 1 ? "result" : "results";
+      return { content: `${result.count} ${noun}.`, miss: false, ambiguous: false, matches: [] };
+    }
+    if (result.compositeKind === "list") {
+      if (!result.matches.length) {
+        return { content: `no ${nounFor(result.entityType, 2)} in this index.`, miss: true, ambiguous: false, matches: [] };
+      }
+      const scopeable = !["Module", "Commit"].includes(result.entityType);
+      const hint = !result.scoped && scopeable && result.matches.length > OVERFLOW_CAP ? ` \u2014 narrow with "${nounFor(result.entityType, 2)} in <module>"` : "";
+      return { content: `${compositeList(result.matches)}${hint}.`, miss: false, ambiguous: false, matches: result.matches };
+    }
+    if (result.compositeKind === "superlative") {
+      if (!result.matches.length) return { content: `no ${nounFor(result.entityType, 2)} to rank in this index.`, miss: true, ambiguous: false };
+      const lead = result.extreme === "most" ? "the most" : "the fewest";
+      const tie = result.matches.length > 1 ? ` (${result.matches.length}-way tie)` : "";
+      return {
+        content: `${compositeList(result.matches)} \u2014 ${lead} ${result.metricNoun} (${result.score})${tie}.`,
+        miss: false,
+        ambiguous: false,
+        matches: result.matches
+      };
+    }
+    if (!result.matches.length) {
+      return { content: `nothing in the index matches that${result.entityType ? ` (${nounFor(result.entityType, 2)})` : ""}.`, miss: true, ambiguous: false, matches: [] };
+    }
+    return { content: `${compositeList(result.matches)}.`, miss: false, ambiguous: false, matches: result.matches };
+  }
+  function rephraseHint() {
+    return `"which <functions|classes|modules> <imports|calls|uses|inherits from|tests|touched> <name>" or "what does <name> <import|call|export>" or "what uses <name>" or "where is <name> defined" / "where is <name> mentioned" or "when did <name> change" or "which changes touch commit <sha>"/"what did commit <sha> touch" (a commit's own changes) or plainly "what calls this" (about a selected node) or "what does <term> mean"/"what is a <ClassName>" (about the graph's own vocabulary). ` + compositionalHint();
+  }
+  function componentSet(s) {
+    return new Set(String(s).toLowerCase().split(/[^a-z0-9]+/).filter(Boolean));
+  }
+  function resolveObject(graph, term) {
+    const t = String(term || "").trim();
+    if (!t) return { match: null, candidates: [], tier: null, ambiguous: false };
+    const tLc = t.toLowerCase();
+    const pool = graph.individuals;
+    const shaTerm = tLc.match(/^(commit[:\s])?([0-9a-f]{7,40})$/);
+    if (shaTerm) {
+      const sha = shaTerm[2];
+      const hits = pool.filter((i) => i.class === "Commit" && (String(i.id).toLowerCase().startsWith(`commit:${sha}`) || String(i.label).toLowerCase().startsWith(sha)));
+      if (hits.length === 1) return { match: hits[0], candidates: [], tier: 1, ambiguous: false };
+      if (hits.length > 1) return { match: hits[0], candidates: hits.slice(1, 5), tier: 1, ambiguous: true };
+      if (shaTerm[1]) return { match: null, candidates: [], tier: null, ambiguous: false };
+    }
+    const exact = pool.find((i) => String(i.label).toLowerCase() === tLc || String(i.id).toLowerCase() === tLc);
+    if (exact) return { match: exact, candidates: [], tier: 1, ambiguous: false };
+    const extLc = `ext:${tLc}`;
+    let extId = null;
+    outer: for (const g of graph.relations) {
+      for (const e of g.edges) {
+        if (String(e.object).toLowerCase() === extLc) {
+          extId = e.object;
+          break outer;
+        }
+      }
+    }
+    if (extId) return { match: { id: extId, label: t, class: null }, candidates: [], tier: 2, ambiguous: false };
+    const scored = [];
+    const dotted = !tLc.includes("/") && /^[\w$]+(\.[\w$]+)+$/.test(tLc);
+    if (dotted) {
+      const lastSeg = tLc.split(".").pop();
+      for (const m of pool) {
+        const label = String(m.label || "").toLowerCase();
+        if (m.class === "Module") {
+          if (label.split("/").pop() === tLc) scored.push({ ind: m, score: 1e3 - Math.abs(label.length - tLc.length) });
+        } else if (label.includes(tLc)) {
+          scored.push({ ind: m, score: 2e3 - Math.abs(label.length - tLc.length) });
+        } else if (label.endsWith(`.${lastSeg}`)) {
+          scored.push({ ind: m, score: 1500 - Math.abs(label.length - tLc.length) });
+        }
+      }
+    } else {
+      const termComps = componentSet(t);
+      for (const m of pool) {
+        const label = String(m.label || "").toLowerCase();
+        if (label.includes(tLc)) {
+          scored.push({ ind: m, score: 1e3 - Math.abs(label.length - tLc.length) });
+          continue;
+        }
+        const overlap = [...termComps].filter((c) => componentSet(m.label).has(c)).length;
+        if (overlap > 0) scored.push({ ind: m, score: overlap * 10 });
+      }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    if (scored.length) {
+      const [best, ...rest] = scored;
+      const tied = rest.filter((x) => x.score === best.score);
+      return {
+        match: best.ind,
+        candidates: rest.slice(0, 4).map((x) => x.ind),
+        tier: 3,
+        ambiguous: tied.length > 0
+      };
+    }
+    let proseResult = null;
+    const proseHits = !dotted && typeof lookupByProseTokens === "function" ? lookupByProseTokens(graph.proseIndex, t) : [];
+    if (proseHits.length) {
+      const [best, ...rest] = proseHits;
+      const bestInd = graph.byId.get(best.id);
+      if (bestInd) {
+        const tied = rest.filter((h) => h.score === best.score);
+        proseResult = {
+          match: bestInd,
+          candidates: rest.slice(0, 4).map((h) => graph.byId.get(h.id)).filter(Boolean),
+          tier: 4,
+          ambiguous: tied.length > 0,
+          matchedVia: "prose"
+        };
+        if (!proseResult.ambiguous && best.via !== "spell") return proseResult;
+      }
+    }
+    if (!shaTerm && tLc.length >= 4) {
+      const bound = fuzzyBound(tLc);
+      let best = bound + 1;
+      let hits = [];
+      for (const m of pool) {
+        let d = editDistance(String(m.label || "").toLowerCase(), tLc, bound);
+        if (d > 0) {
+          for (const comp of componentSet(m.label)) {
+            if (d <= 0) break;
+            d = Math.min(d, editDistance(comp, tLc, bound));
+          }
+        }
+        if (d < best) {
+          best = d;
+          hits = [m];
+        } else if (d === best && d <= bound) hits.push(m);
+      }
+      if (best <= bound && hits.length === 1) {
+        return { match: hits[0], candidates: [], tier: 5, ambiguous: false, matchedVia: "fuzzy" };
+      }
+      if (best <= bound && hits.length > 1 && !proseResult) {
+        const [bestInd, ...rest] = hits;
+        return { match: bestInd, candidates: rest.slice(0, 4), tier: 5, ambiguous: true, matchedVia: "fuzzy" };
+      }
+    }
+    return proseResult || { match: null, candidates: [], tier: null, ambiguous: false };
+  }
+  function resolveTermOrContext(graph, term, contextId) {
+    if (CONTEXT_PRONOUNS.includes(String(term || "").trim().toLowerCase())) {
+      if (!contextId) return { match: null, candidates: [], tier: null, ambiguous: false, unresolvedPronoun: true };
+      const ind = graph.byId.get(contextId);
+      return ind ? { match: ind, candidates: [], tier: 1, ambiguous: false } : { match: null, candidates: [], tier: null, ambiguous: false, unresolvedPronoun: true };
+    }
+    return resolveObject(graph, term);
+  }
+  function refineToEntities(graph, moduleIds, entityType) {
+    const out = [];
+    for (const e of edgesOfKind(graph, "defines")) {
+      if (!moduleIds.has(e.subject)) continue;
+      const ind = graph.byId.get(e.object);
+      if (ind && ind.class === entityType) out.push(ind);
+    }
+    return out;
+  }
+  function commitTouches(graph, commit, entityType, extra = {}) {
+    const wildcard = !entityType || entityType === "Change" || entityType === "Commit";
+    const wantCoarse = wildcard || entityType === "Module";
+    const wantFine = wildcard || FINE_ENTITY_TYPES.has(entityType);
+    const kinds = [...wantCoarse ? ["touches"] : [], ...wantFine ? ["touchesSymbol"] : []];
+    let matches = kinds.flatMap((k) => edgesOfKind(graph, k)).filter((e) => e.subject === commit.id).map((e) => graph.byId.get(e.object)).filter(Boolean);
+    if (entityType && FINE_ENTITY_TYPES.has(entityType)) matches = matches.filter((m) => m.class === entityType);
+    return {
+      matches,
+      objMatch: commit,
+      commitSubject: true,
+      ambiguous: false,
+      candidates: [],
+      traversal: `${kinds.join("+")} edges where subject = commit ${commit.label}`,
+      ...extra
+    };
+  }
+  function modifierIsWired(shape, kind, entityType) {
+    return shape === "reverse" && (kind === "imports" || kind === "calls") && (!entityType || entityType === "Module");
+  }
+  var TRANSITIVE_MAX_DEPTH = 8;
+  function traverse(graph, parsed, { contextId = null, prev = null } = {}) {
+    if (!parsed) return { matches: [], objMatch: null, candidates: [], traversal: null, ambiguous: false };
+    if (parsed.node) return evalComposite(graph, parsed, { contextId, prev });
+    if (parsed.ambiguousParse) return { matches: [], objMatch: null, candidates: [], traversal: null, ambiguous: false };
+    const { shape, kind, entityType } = parsed;
+    if (shape === "meta") {
+      const term = String(parsed.object || "").trim();
+      const termLc = term.toLowerCase();
+      const match = (graph.individuals || []).find((i) => {
+        if (i.class !== "SchemaClass" && i.class !== "SchemaPredicate") return false;
+        if (String(i.label).toLowerCase() === termLc) return true;
+        const token = (i.attributes || []).find((a) => a.key === "token")?.value;
+        return token && String(token).toLowerCase() === termLc;
+      });
+      if (!match) return { matches: [], objMatch: null, candidates: [], traversal: `schema lookup for "${term}"`, ambiguous: false };
+      return {
+        matches: [match],
+        objMatch: match,
+        candidates: [],
+        traversal: `schema lookup for "${term}"`,
+        ambiguous: false
+      };
+    }
+    if (shape === "mentions") {
+      const term = String(parsed.object || "").trim();
+      const hits = typeof lookupByProseTokens === "function" ? lookupByProseTokens(graph.proseIndex, term) : [];
+      const matches2 = hits.map((h) => graph.byId.get(h.id)).filter(Boolean);
+      return {
+        matches: matches2,
+        objMatch: null,
+        candidates: [],
+        ambiguous: false,
+        mentionsShape: true,
+        traversal: `proseIndex word lookup for "${term}"`
+      };
+    }
+    if (parsed.modifier && parsed.modifier !== "direct" && !modifierIsWired(shape, kind, entityType)) {
+      return {
+        matches: [],
+        objMatch: null,
+        candidates: [],
+        ambiguous: false,
+        unsupportedModifier: true,
+        traversal: `modifier "${parsed.modifier}" requested for a "${kind}" query \u2014 no closure traversal exists for this combination yet`
+      };
+    }
+    if (shape === "ask") {
+      const subj = resolveTermOrContext(graph, parsed.subject, contextId);
+      const obj = resolveTermOrContext(graph, parsed.object, contextId);
+      if (!subj.match || !obj.match) {
+        return {
+          matches: [],
+          objMatch: obj.match,
+          candidates: obj.candidates,
+          traversal: null,
+          ambiguous: false,
+          answer: null,
+          unresolvedPronoun: !!(subj.unresolvedPronoun || obj.unresolvedPronoun)
+        };
+      }
+      let [from, to] = [subj.match, obj.match];
+      let kinds = kindsFor(kind);
+      if (kind === "touches") {
+        if (to.class === "Commit" && from.class !== "Commit") [from, to] = [to, from];
+        if (from.class === "Commit") kinds = ["touches", "touchesSymbol"];
+      }
+      const edges2 = kinds.flatMap((k) => edgesOfKind(graph, k)).filter((e) => e.subject === from.id && e.object === to.id);
+      return {
+        matches: edges2,
+        answer: edges2.length > 0,
+        objMatch: obj.match,
+        subjMatch: subj.match,
+        candidates: [],
+        traversal: `${kinds.join("+")} edge from ${from.label} to ${to.label}`,
+        ambiguous: false
+      };
+    }
+    const { match: objMatch, candidates, ambiguous, unresolvedPronoun, matchedVia } = resolveTermOrContext(graph, parsed.object, contextId);
+    if (!objMatch) return { matches: [], objMatch: null, candidates, traversal: null, ambiguous: false, unresolvedPronoun };
+    if (shape === "where") {
+      const site = (objMatch.attributes || []).find((a) => a.key === "site")?.value || null;
+      return {
+        matches: [objMatch],
+        objMatch,
+        candidates,
+        ambiguous,
+        matchedVia,
+        whereShape: true,
+        site,
+        traversal: site ? `site attribute of ${objMatch.label}` : `class + defining module of ${objMatch.label}`
+      };
+    }
+    if (shape === "when") {
+      const dateOf = (c) => String((c.attributes || []).find((a) => a.key === "date")?.value || "");
+      let commits;
+      if (objMatch.class === "Commit") {
+        commits = [objMatch];
+      } else {
+        const edges2 = ["touches", "touchesSymbol"].flatMap((k) => edgesOfKind(graph, k)).filter((e) => e.object === objMatch.id);
+        const seen = /* @__PURE__ */ new Set();
+        commits = [];
+        for (const e of edges2) {
+          if (seen.has(e.subject)) continue;
+          seen.add(e.subject);
+          const c = graph.byId.get(e.subject);
+          if (c && c.class === "Commit") commits.push(c);
+        }
+        commits.sort((a, b) => dateOf(b).localeCompare(dateOf(a)));
+      }
+      return {
+        matches: commits,
+        objMatch,
+        candidates,
+        ambiguous,
+        matchedVia,
+        whenShape: true,
+        traversal: `touches+touchesSymbol edges where object = ${objMatch.label}, newest commit date first`
+      };
+    }
+    if (kind === "touches" && objMatch.class === "Commit") {
+      return commitTouches(graph, objMatch, entityType, { candidates, ambiguous, matchedVia });
+    }
+    if (shape === "forward") {
+      const edges2 = kindsFor(kind).flatMap((k) => edgesOfKind(graph, k)).filter((e) => e.subject === objMatch.id);
+      const matches2 = edges2.map((e) => graph.byId.get(e.object)).filter(Boolean);
+      return { matches: matches2, objMatch, candidates, traversal: `${kindsFor(kind).join("+")} edges where subject = ${objMatch.label}`, ambiguous, matchedVia };
+    }
+    if (parsed.modifier === "transitive") {
+      const levels = impactClosure(graph, objMatch, { maxDepth: TRANSITIVE_MAX_DEPTH });
+      const matches2 = levels.flat().map((d) => graph.byId.get(d.id)).filter(Boolean);
+      return {
+        matches: matches2,
+        objMatch,
+        candidates,
+        ambiguous,
+        matchedVia,
+        traversal: `reverse dependency closure over imports+calls edges from ${objMatch.label} (impactClosure, maxDepth=${TRANSITIVE_MAX_DEPTH})`
+      };
+    }
+    const symbolKind = SYMBOL_GRAIN_SIBLING[kind];
+    const objIsFineSymbol = !!(objMatch.class && FINE_ENTITY_TYPES.has(objMatch.class));
+    if (symbolKind && (FINE_ENTITY_TYPES.has(entityType) || objIsFineSymbol)) {
+      const edges2 = edgesOfKind(graph, symbolKind).filter((e) => e.object === objMatch.id);
+      const subjects2 = uniqueById(edges2.map((e) => graph.byId.get(e.subject)).filter(Boolean));
+      const matches2 = !entityType || entityType === "Change" ? subjects2 : subjects2.filter((i) => i.class === entityType);
+      return { matches: matches2, objMatch, candidates, traversal: `${symbolKind} edges where object = ${objMatch.label}`, ambiguous, matchedVia };
+    }
+    let edges = kindsFor(kind).flatMap((k) => edgesOfKind(graph, k)).filter((e) => e.object === objMatch.id);
+    let extNote = "";
+    if (!edges.length && objMatch.class) {
+      const extId = `ext:${String(objMatch.label).toLowerCase()}`;
+      edges = kindsFor(kind).flatMap((k) => edgesOfKind(graph, k)).filter((e) => String(e.object).toLowerCase() === extId);
+      if (edges.length) extNote = ` (by name, via unresolved ${extId} references)`;
+    }
+    const subjects = [];
+    const seenSubjects = /* @__PURE__ */ new Set();
+    for (const e of edges) {
+      const s = graph.byId.get(e.subject);
+      if (s && !seenSubjects.has(s.id)) {
+        seenSubjects.add(s.id);
+        subjects.push(s);
+      }
+    }
+    let matches, grainNote = "";
+    if (!entityType || entityType === "Change") {
+      matches = subjects;
+    } else {
+      const direct = subjects.filter((s) => s.class === entityType);
+      if (direct.length) {
+        matches = direct;
+      } else if (entityType !== "Module" && subjects.some((s) => s.class === "Module")) {
+        const moduleIds = new Set(subjects.filter((s) => s.class === "Module").map((s) => s.id));
+        matches = refineToEntities(graph, moduleIds, entityType);
+        grainNote = `, then ${entityType} defined in the matched module(s)`;
+      } else {
+        matches = [];
+      }
+    }
+    return { matches, objMatch, candidates, traversal: `${kindsFor(kind).join("+")} edges where object = ${objMatch.label}${extNote}${grainNote}`, ambiguous, matchedVia };
+  }
+  function moduleLabelOf(ind) {
+    if (ind.class === "Module") return ind.label;
+    const site = (ind.attributes || []).find((a) => a.key === "site")?.value;
+    if (site) return String(site).split(":")[0];
+    const m = String(ind.id || "").match(/^fn:(.+)#/);
+    return m ? m[1] : "(unknown module)";
+  }
+  function symbolLabelOf(ind) {
+    const label = String(ind.label || ind.id || "");
+    return ["Function", "Method"].includes(ind.class) ? `function ${label}()` : label;
+  }
+  function listJoin(syms) {
+    return syms.length > 1 ? `${syms.slice(0, -1).join(", ")} and ${syms[syms.length - 1]}` : syms[0];
+  }
+  function describeParse(p) {
+    const obj = p.object ?? p.subject ?? "?";
+    const ent = p.entityType ? nounFor(p.entityType, 2) + " that " : "";
+    return `${ent}${p.kind} "${obj}"`;
+  }
+  function render(parsed, result) {
+    const r = renderCore(parsed, result);
+    if (result && result.matchedVia === "fuzzy" && result.objMatch && !r.ambiguous) {
+      r.content = `assuming you meant ${result.objMatch.label}: ${r.content}`;
+    }
+    return r;
+  }
+  function renderCore(parsed, result) {
+    if (!parsed) {
+      return { content: `couldn't parse this as a graph question. Try: ${rephraseHint()}`, miss: true, ambiguous: false };
+    }
+    if (parsed.node) return renderComposite(parsed, result);
+    if (parsed.ambiguousParse) {
+      const options = parsed.candidates.map((p, i) => `${i + 1}) ${describeParse(p)}`).join(" or ");
+      return {
+        content: `this could mean more than one thing: ${options} \u2014 try rephrasing more specifically.`,
+        miss: false,
+        ambiguous: true,
+        candidates: parsed.candidates.map(describeParse)
+      };
+    }
+    if (result.unresolvedPronoun) {
+      return {
+        content: `"${parsed.object ?? parsed.subject}" needs a selected node to refer to \u2014 click a node first, or name it directly.`,
+        miss: true,
+        ambiguous: false
+      };
+    }
+    if (result.unsupportedModifier) {
+      return {
+        content: `the "${parsed.modifier}" modifier isn't supported for "${parsed.kind}" queries yet \u2014 only imports/calls (module-level) have a transitive closure today.`,
+        miss: true,
+        ambiguous: false
+      };
+    }
+    if (parsed.shape === "meta") {
+      if (!result.objMatch) {
+        return {
+          content: `"${parsed.object}" isn't a term in this graph's own vocabulary (no matching class or predicate).`,
+          miss: true,
+          ambiguous: false
+        };
+      }
+      const doc = (result.objMatch.attributes || []).find((a) => a.key === "doc")?.value || "";
+      const kindWord = result.objMatch.class === "SchemaClass" ? "a class in the graph's schema" : "a predicate (relation) in the graph's schema";
+      return { content: `${result.objMatch.label} is ${kindWord}: ${doc}`, miss: false, ambiguous: false, matches: result.matches };
+    }
+    if (result.mentionsShape) {
+      if (!result.matches.length) {
+        return {
+          content: `"${parsed.object}" is not mentioned in any indexed identifier or doc-comment prose. (traversal: ${result.traversal})`,
+          miss: true,
+          ambiguous: false
+        };
+      }
+      const shown = result.matches.slice(0, OVERFLOW_CAP).map((m) => `${m.label} (${nounFor(m.class, 1)})`);
+      const extra2 = result.matches.length > OVERFLOW_CAP ? `, \u2026and ${result.matches.length - OVERFLOW_CAP} more` : "";
+      return {
+        content: `"${parsed.object}" is mentioned in the prose tokens of ${listJoin(shown)}${extra2}.`,
+        miss: false,
+        ambiguous: false,
+        matches: result.matches
+      };
+    }
+    if (!result.objMatch && (!result.candidates || result.candidates.length === 0) && parsed.shape !== "ask") {
+      const objText = String(parsed.object || "").trim();
+      const what = /^(?:commit[:\s])?[0-9a-f]{7,40}$/i.test(objText) ? "commit" : !objText.includes("/") && /^[\w$]+(\.[\w$]+)+$/.test(objText) ? "symbol" : "module";
+      return {
+        content: `no ${what} matching "${parsed.object}" found in the index.`,
+        miss: true,
+        ambiguous: false,
+        candidates: []
+      };
+    }
+    if (result.ambiguous) {
+      const pool = [result.objMatch, ...result.candidates || []].filter(Boolean);
+      const noun = pool.length && pool.every((i) => i.class === "Commit") ? "commit" : "module";
+      return {
+        content: `"${parsed.object}" matches more than one ${noun} ambiguously \u2014 please narrow the term.`,
+        miss: false,
+        ambiguous: true,
+        candidates: pool.map((i) => i.label)
+      };
+    }
+    if (result.whereShape) {
+      const ind = result.objMatch;
+      if (ind.class === "Module") {
+        return { content: `${ind.label} is a module \u2014 the label is its repo path.`, miss: false, ambiguous: false, matches: result.matches };
+      }
+      if (ind.class === "Commit") {
+        return { content: `${ind.label} is a commit, not a code location \u2014 try "what did commit ${ind.label} touch".`, miss: true, ambiguous: false };
+      }
+      const m = String(result.site || "").match(/^(.*):(\d+)(?:-(\d+))?$/);
+      if (m) {
+        const lines = m[3] && m[3] !== m[2] ? `lines ${m[2]}-${m[3]}` : `line ${m[2]}`;
+        return { content: `${symbolLabelOf(ind)} is defined in ${m[1]} at ${lines}.`, miss: false, ambiguous: false, matches: result.matches };
+      }
+      return {
+        content: `${symbolLabelOf(ind)} is defined in ${moduleLabelOf(ind)} (no line span recorded in this index).`,
+        miss: false,
+        ambiguous: false,
+        matches: result.matches
+      };
+    }
+    if (result.whenShape) {
+      const subject = result.objMatch.label;
+      if (!result.matches.length) {
+        return { content: `no recorded commit touches ${subject} in this index. (traversal: ${result.traversal})`, miss: true, ambiguous: false };
+      }
+      const newest = result.matches[0];
+      const date = (newest.attributes || []).find((a) => a.key === "date")?.value || "";
+      if (!date) {
+        return {
+          content: `commit ${newest.label} touched ${subject}, but this index records no commit dates \u2014 regenerate the graph to attach mgx:commitDate.`,
+          miss: true,
+          ambiguous: false
+        };
+      }
+      const msg = (newest.attributes || []).find((a) => a.key === "message")?.value || "";
+      const day = String(date).slice(0, 10);
+      if (newest.id === result.objMatch.id) {
+        return { content: `commit ${newest.label} is dated ${day}${msg ? ` ("${msg}")` : ""}.`, miss: false, ambiguous: false, matches: result.matches };
+      }
+      const more = result.matches.length - 1;
+      return {
+        content: `${subject} was last touched by commit ${newest.label} on ${day}${msg ? ` ("${msg}")` : ""}${more ? `; ${more} earlier commit${more === 1 ? "" : "s"} recorded` : ""}.`,
+        miss: false,
+        ambiguous: false,
+        matches: result.matches
+      };
+    }
+    if (result.commitSubject) {
+      const cite = `commit ${result.objMatch.label}`;
+      if (!result.matches.length) {
+        return {
+          content: `${cite} touched nothing recorded in the index. (traversal: ${result.traversal})`,
+          miss: true,
+          ambiguous: false
+        };
+      }
+      const byClass = /* @__PURE__ */ new Map();
+      for (const m of result.matches.slice(0, OVERFLOW_CAP)) {
+        const cls = m.class || "Module";
+        if (!byClass.has(cls)) byClass.set(cls, []);
+        byClass.get(cls).push(["Function", "Method"].includes(cls) ? `${m.label}()` : m.label);
+      }
+      const clauses2 = [...byClass.entries()].map(([cls, labels]) => `${nounFor(cls, labels.length)} ${listJoin(labels)}`);
+      const extra2 = result.matches.length > OVERFLOW_CAP ? `; \u2026and ${result.matches.length - OVERFLOW_CAP} more` : "";
+      return { content: `${cite} touched ${clauses2.join("; ")}${extra2}.`, miss: false, ambiguous: false, matches: result.matches };
+    }
+    if (parsed.shape === "ask") {
+      if (!result.objMatch || !result.subjMatch) {
+        return { content: `couldn't resolve one of the terms in this question.`, miss: true, ambiguous: false };
+      }
+      return {
+        content: result.answer ? `Yes. (${result.traversal})` : `No \u2014 no ${parsed.kind} edge found from ${result.subjMatch.label} to ${result.objMatch.label}.`,
+        miss: !result.answer,
+        ambiguous: false
+      };
+    }
+    if (!result.matches.length) {
+      if (parsed.shape === "forward") {
+        return {
+          content: `${result.objMatch.label} has no ${parsed.kind} edges in the index. (traversal: ${result.traversal || "no traversal resolved"})`,
+          miss: true,
+          ambiguous: false
+        };
+      }
+      const entityWord = nounFor(parsed.entityType || "Module", 2);
+      return {
+        content: `No ${entityWord} found whose module directly ${verbFor(parsed.kind)} ${parsed.object}. (traversal: ${result.traversal || "no traversal resolved"})`,
+        miss: true,
+        ambiguous: false
+      };
+    }
+    if (parsed.shape === "forward" || parsed.entityType === "Module" || result.matches.every((m) => !FINE_ENTITY_TYPES.has(m.class))) {
+      const shown = result.matches.slice(0, OVERFLOW_CAP).map((m) => m.label);
+      const extra2 = result.matches.length > OVERFLOW_CAP ? `, \u2026and ${result.matches.length - OVERFLOW_CAP} more` : "";
+      return { content: shown.join(" and ") + extra2 + ".", miss: false, ambiguous: false, matches: result.matches };
+    }
+    const byModule = /* @__PURE__ */ new Map();
+    for (const m of result.matches.slice(0, OVERFLOW_CAP)) {
+      const mod = moduleLabelOf(m);
+      if (!byModule.has(mod)) byModule.set(mod, []);
+      byModule.get(mod).push(symbolLabelOf(m));
+    }
+    const clauses = [...byModule.entries()].map(([mod, syms], i) => {
+      const list = listJoin(syms);
+      return i === 0 ? `in ${mod} there is ${list}` : `there is ${list} in ${mod}`;
+    });
+    const extra = result.matches.length > OVERFLOW_CAP ? ` \u2026and ${result.matches.length - OVERFLOW_CAP} more` : "";
+    return { content: clauses.join(" and ") + extra + ".", miss: false, ambiguous: false, matches: result.matches };
+  }
+  var CONTENT_VOCAB = /* @__PURE__ */ new Set([
+    ...wordsOf(Object.keys(VERB_TO_KIND)),
+    ...wordsOf(Object.keys(ENTITY_TO_TYPE)),
+    ...wordsOf(Object.keys(MODIFIER_TO_KIND)),
+    ...wordsOf(Object.keys(QUALIFIERS)),
+    ...wordsOf(AGGREGATE_TRIGGERS),
+    ...wordsOf(Object.keys(SUPERLATIVE_EXTREMES)),
+    ...wordsOf(Object.keys(EDGE_NOUN_TO_METRIC)),
+    ...wordsOf(Object.keys(BOOLEAN_CONNECTIVES)),
+    ...wordsOf(PLACEHOLDER_NOUNS),
+    ...wordsOf(ANAPHORA_TRIGGERS),
+    ...wordsOf(META_MEANING_VERBS),
+    ...wordsOf(WHERE_MARKERS),
+    ...wordsOf(MENTION_MARKERS),
+    ...wordsOf(RELATIVE_PRONOUNS),
+    ...wordsOf(Object.keys(CASCADE_SYNONYMS))
+  ]);
+  var STRUCTURAL_WORDS = /* @__PURE__ */ new Set([...STOPWORDS2, ...FRAME_WORDS, ...CONTEXT_PRONOUNS]);
+  var CASCADE_NOISE_SET = new Set(wordsOf(CASCADE_NOISE));
+  var NOISE_OR_SCAFFOLD = /* @__PURE__ */ new Set([...CASCADE_NOISE_SET, ...STRUCTURAL_WORDS]);
+  var TRIGGER_FUZZY_WORDS = [
+    "many",
+    "count",
+    "number",
+    "quantity",
+    "total",
+    "tally",
+    "list",
+    "show",
+    "display",
+    "print",
+    "dump",
+    "enumerate",
+    "name"
+  ];
+  var CASCADE_FUZZY_TARGETS = [.../* @__PURE__ */ new Set([
+    ...wordsOf(Object.keys(VERB_TO_KIND)),
+    ...Object.keys(ENTITY_TO_TYPE),
+    ...TRIGGER_FUZZY_WORDS
+  ])].filter((wd) => /^[a-z]+$/.test(wd) && wd.length >= 4 && !STOPWORDS2.has(wd));
+  function fuzzyCascadeWord(w) {
+    const bound = fuzzyBound(w);
+    let best = bound + 1;
+    let hit = null;
+    let tied = false;
+    for (const target of CASCADE_FUZZY_TARGETS) {
+      const d = editDistance(w, target, Math.min(best, bound));
+      if (d < best) {
+        best = d;
+        hit = target;
+        tied = false;
+      } else if (d === best && d <= bound && target !== hit) tied = true;
+    }
+    return best <= bound && !tied ? hit : null;
+  }
+  function schemaTypoTrap(resolution, term) {
+    if (!resolution?.match || resolution.matchedVia !== "fuzzy" || resolution.ambiguous) return false;
+    const cls = resolution.match.class;
+    if (cls !== "SchemaClass" && cls !== "SchemaPredicate") return false;
+    const lc = String(term || "").trim().toLowerCase();
+    const kindNoun = fuzzyCascadeWord(lc);
+    return !!kindNoun && kindNoun !== lc && !!ENTITY_TO_TYPE[kindNoun];
+  }
+  function answerable(graph, parsed, contextId) {
+    if (!parsed) return false;
+    if (parsed.ambiguousParse) return "ambiguous";
+    if (parsed.node) return parsed.node !== "miss";
+    if (parsed.shape === "meta" || parsed.shape === "mentions") return true;
+    const o = resolveTermOrContext(graph, parsed.object, contextId);
+    if (o.unresolvedPronoun) return "pronoun";
+    if (!o.match || schemaTypoTrap(o, parsed.object)) return false;
+    if (parsed.shape === "ask") {
+      const s = resolveTermOrContext(graph, parsed.subject, contextId);
+      if (s.unresolvedPronoun) return "pronoun";
+      return s.match && !schemaTypoTrap(s, parsed.subject) ? true : false;
+    }
+    return true;
+  }
+  function isHelpRequest(query) {
+    const q = String(query || "").trim().toLowerCase().replace(/[?.!\s]+$/, "");
+    return HELP_TRIGGERS.includes(q);
+  }
+  function relaxParse(graph, query, { nlp = void 0, contextId = null, prev = null } = {}) {
+    const from = applyNegationFrames(normalizeQuery(String(query || "")));
+    let tokens = splitWords(from);
+    if (!tokens.length) return null;
+    const dropped = [];
+    const steps = [];
+    const resolvesExact = (t) => {
+      const r = resolveObject(graph, t);
+      return !!r.match && r.tier != null && r.tier <= 2;
+    };
+    const resolvesLiteral = (t) => {
+      const r = resolveObject(graph, t);
+      return !!r.match && r.tier != null && r.tier <= 3;
+    };
+    const hasRealTerm = (s) => splitWords(String(s || "")).some((w) => {
+      const lc = w.toLowerCase();
+      return !CONTENT_VOCAB.has(lc) && !STRUCTURAL_WORDS.has(lc);
+    });
+    const TERM_SHAPES = /* @__PURE__ */ new Set(["reverse", "forward", "where", "when", "ask"]);
+    const attempt = (toks) => {
+      const text = toks.join(" ");
+      const p = parseQuery(text, { nlp });
+      if (answerable(graph, p, contextId) !== true) return null;
+      if (p && !p.node && TERM_SHAPES.has(p.shape)) {
+        if (p.object != null && !hasRealTerm(p.object)) return null;
+        if (p.shape === "ask" && p.subject != null && !hasRealTerm(p.subject)) return null;
+      }
+      const rendered = render(p, traverse(graph, p, { contextId, prev }));
+      return rendered.miss ? null : { parsed: p, text };
+    };
+    const done = (hit) => ({ parsed: hit.parsed, from, to: hit.text, dropped: [...dropped], steps });
+    let guard = 0;
+    const hardCap = Math.max(tokens.length, 1) + 12;
+    for (; guard < hardCap; guard += 1) {
+      let idx = -1;
+      for (let i = 0; i < tokens.length; i += 1) {
+        const lc = tokens[i].toLowerCase();
+        if (CASCADE_NOISE_SET.has(lc) && !CONTENT_VOCAB.has(lc) && !resolvesExact(tokens[i])) {
+          idx = i;
+          break;
+        }
+      }
+      if (idx < 0) break;
+      const removed = tokens[idx];
+      tokens = tokens.filter((_, i) => i !== idx);
+      dropped.push(removed);
+      steps.push(`strip noise "${removed}" \u2192 "${tokens.join(" ")}"`);
+      const hit = attempt(tokens);
+      if (hit) return done(hit);
+    }
+    const survivors = [];
+    const nowDropped = [];
+    const corrected = [];
+    for (const t of tokens) {
+      const lc = t.toLowerCase();
+      const plain = /^[a-z]+$/.test(lc);
+      if (!plain || CONTENT_VOCAB.has(lc) || STRUCTURAL_WORDS.has(lc) || resolvesLiteral(t)) {
+        survivors.push(t);
+        continue;
+      }
+      const fix = fuzzyCascadeWord(lc);
+      if (fix && fix !== lc) {
+        survivors.push(fix);
+        corrected.push(`${t}\u2192${fix}`);
+        continue;
+      }
+      nowDropped.push(t);
+    }
+    if ((corrected.length || nowDropped.length) && survivors.length) {
+      tokens = survivors;
+      dropped.push(...nowDropped);
+      if (corrected.length) steps.push(`fuzzy-correct ${JSON.stringify(corrected)} \u2192 "${tokens.join(" ")}"`);
+      if (nowDropped.length) steps.push(`drop unmatched ${JSON.stringify(nowDropped)} \u2192 "${tokens.join(" ")}"`);
+      const hit = attempt(tokens);
+      if (hit) return done(hit);
+    }
+    let changed = false;
+    const normed = tokens.map((t) => {
+      const lc = t.toLowerCase();
+      if (CASCADE_SYNONYMS[lc] && !resolvesLiteral(t)) {
+        changed = true;
+        return CASCADE_SYNONYMS[lc];
+      }
+      return t;
+    });
+    if (changed) {
+      steps.push(`normalise synonyms \u2192 "${normed.join(" ")}"`);
+      const hit = attempt(normed);
+      if (hit) return done(hit);
+    }
+    const bareLc = splitWords(from).map((t) => t.toLowerCase());
+    const kindWords = [];
+    const others = [];
+    for (const t of bareLc) {
+      if (NOISE_OR_SCAFFOLD.has(t)) continue;
+      const et = ENTITY_TO_TYPE[t];
+      if (et && et !== "Change") kindWords.push(t);
+      else others.push(t);
+    }
+    if (kindWords.length === 1 && others.length === 0) {
+      const hit = attempt(["count", kindWords[0]]);
+      if (hit) {
+        steps.push(`bare kind "${kindWords[0]}" \u2192 count`);
+        return done(hit);
+      }
+    }
+    return null;
+  }
+  function ask(graph, query, { contextId = null, nlp = void 0, prev = null } = {}) {
+    if (isHelpRequest(query)) {
+      return {
+        content: rephraseHint(),
+        tmct_ask: {
+          mechanical: true,
+          parsed: null,
+          matches: [],
+          traversal: null,
+          miss: true,
+          ambiguous: false,
+          matchedVia: null,
+          help: true,
+          relaxed: null
+        }
+      };
+    }
+    const direct = parseQuery(query, { nlp });
+    let parsed = direct;
+    let relaxed = null;
+    if (answerable(graph, direct, contextId) === false) {
+      const r = relaxParse(graph, query, { nlp, contextId, prev });
+      if (r) {
+        parsed = r.parsed;
+        relaxed = { from: r.from, to: r.to, dropped: r.dropped, steps: r.steps };
+      }
+    }
+    const result = traverse(graph, parsed, { contextId, prev });
+    const rendered = render(parsed, result);
+    const content = relaxed && !rendered.miss && relaxed.to !== relaxed.from ? `read as "${relaxed.to}" \u2014 ${rendered.content}` : rendered.content;
+    return {
+      content,
+      tmct_ask: {
+        mechanical: true,
+        parsed: parsed && !parsed.ambiguousParse ? parsed : null,
+        matches: (result.matches || []).map((m) => ({
+          id: m.id,
+          label: m.label,
+          type: m.class,
+          module: m.class ? moduleLabelOf(m) : void 0
+        })),
+        traversal: result.traversal || null,
+        miss: !!rendered.miss,
+        ambiguous: !!rendered.ambiguous,
+        // The relaxation trace: null when the direct parse was used as-is (a clean hit or
+        // an honest miss the cascade couldn't/shouldn't rescue), else what the cascade
+        // dropped/normalised to reach an answer. A caller can assert relaxed===null to
+        // prove the cascade never touched a direct hit.
+        relaxed,
+        // Confidence provenance: "prose" when resolveObject fell through to the tier-4
+        // prose-index fallback (PLAN_PROSE_INDEX.md §6 — matched what the symbol talks
+        // about, not its name); "fuzzy" when the tier-5 bounded-edit-distance pass
+        // resolved a typo'd term (the rendered content also announces it: "assuming you
+        // meant <label>"); null for every literal-identifier tier.
+        matchedVia: result.matchedVia || null,
+        ...rendered.ambiguous ? { candidates: rendered.candidates } : {}
+      }
+    };
+  }
+
+  // packages/seonix/src/ask-browser-entry.mjs
+  function parseEntities(payload) {
+    const individuals = Array.isArray(payload?.individuals) ? payload.individuals : [];
+    const byId = /* @__PURE__ */ new Map();
+    for (const ind of individuals) if (ind && ind.id) byId.set(ind.id, ind);
+    const relations = (Array.isArray(payload?.objectProperties) ? payload.objectProperties : []).map((g) => {
+      const edges = (Array.isArray(g?.examples) ? g.examples : []).filter((e) => e && e.subject && e.object);
+      return { predicate: String(g?.predicate || ""), prop: g?.prop ?? null, count: Number(g?.count) || edges.length, edges };
+    });
+    return {
+      individuals,
+      byId,
+      relations,
+      truncated: Boolean(payload?.truncated),
+      generatedAt: payload?.generated_at || "",
+      proseIndex: payload?.proseIndex || {}
+    };
+  }
+  function ask2(graph, query, opts) {
+    const r = ask(graph, query, opts);
+    return { content: r.content, seonix_ask: r.tmct_ask };
+  }
+  globalThis.parseEntities = parseEntities;
+  globalThis.ask = ask2;
+})();