@chrisdudek/yg 5.2.4 → 5.2.6

package/dist/bin.js

@@ -10027,6 +10027,7 @@ var GRAMMAR_DIRS = [
 ];
 var initPromise = null;
 var langCache = /* @__PURE__ */ new Map();
+var parserCache = /* @__PURE__ */ new Map();
 function init() {
   if (initPromise === null) {
     initPromise = Parser.init();
@@ -10067,8 +10068,11 @@ async function getParser(extension) {
     });
   }
   const lang = await langP;
+  const existing = parserCache.get(cacheKey);
+  if (existing) return existing;
   const parser = new Parser();
   parser.setLanguage(lang);
+  parserCache.set(cacheKey, parser);
   return parser;
 }
 async function parseFile(filePath, content20) {
@@ -10080,6 +10084,14 @@ async function parseFile(filePath, content20) {
   }
   return tree;
 }
+async function withParsedFile(filePath, content20, fn) {
+  const tree = await parseFile(filePath, content20);
+  try {
+    return await fn(tree);
+  } finally {
+    tree.delete();
+  }
+}
 
 // src/structure/ctx-parsers.ts
 var ParseAstNotPrewarmedError = class extends Error {
@@ -10404,6 +10416,14 @@ function validateCheckModuleExport(mod, opts) {
   return { ok: true };
 }
 
+// src/ast/parse-cache.ts
+function destroyParseCache(cache) {
+  for (const { ast } of cache.values()) {
+    ast.delete();
+  }
+  cache.clear();
+}
+
 // src/structure/hook-loader.ts
 import * as fs4 from "fs";
 import * as path29 from "path";
@@ -10694,236 +10714,247 @@ function companionInfra(what, why, next) {
 }
 async function runCompanionHook(params) {
   const { aspectDir, aspectId, nodePath, graph, projectRoot, subjectScope } = params;
+  const ownCache = !params.parseCache;
   const astCache = params.parseCache ?? /* @__PURE__ */ new Map();
   const touchedFiles = [];
-  let mod;
-  try {
-    mod = await loadHookModule({
-      aspectDir,
-      projectRoot,
-      filename: "companion.mjs",
-      resolveFailedCode: "COMPANION_LOADER_RESOLVE_FAILED"
-    });
-  } catch (err) {
-    if (err instanceof StructureRunnerError) {
-      return { kind: "infra", messageData: err.messageData };
-    }
-    return companionInfra(
-      `Failed to load companion.mjs for aspect '${aspectId}': ${err.message}`,
-      `The runner dynamically imports the aspect's companion.mjs before resolving companions.`,
-      `Ensure companion.mjs exists at the aspect directory and has no unresolved imports.`
-    );
-  }
-  const fn = mod.companion;
-  if (typeof fn !== "function") {
-    return companionInfra(
-      `companion.mjs does not export a function named 'companion' (aspect '${aspectId}'; got ${typeof fn}).`,
-      `The runner imports the named export 'companion' and calls companion(ctx).`,
-      `Add 'export function companion(ctx) { ... }' to companion.mjs (it may be async).`
-    );
-  }
-  let built;
   try {
-    built = await buildUnitCtx({ aspectId, nodePath, graph, projectRoot, astCache, touchedFiles, subjectScope });
-  } catch (err) {
-    if (err instanceof StructureRunnerError) {
-      return { kind: "infra", messageData: err.messageData };
+    let mod;
+    try {
+      mod = await loadHookModule({
+        aspectDir,
+        projectRoot,
+        filename: "companion.mjs",
+        resolveFailedCode: "COMPANION_LOADER_RESOLVE_FAILED"
+      });
+    } catch (err) {
+      if (err instanceof StructureRunnerError) {
+        return { kind: "infra", messageData: err.messageData };
+      }
+      return companionInfra(
+        `Failed to load companion.mjs for aspect '${aspectId}': ${err.message}`,
+        `The runner dynamically imports the aspect's companion.mjs before resolving companions.`,
+        `Ensure companion.mjs exists at the aspect directory and has no unresolved imports.`
+      );
     }
-    throw err;
-  }
-  const { ctx, recorder } = built;
-  let out;
-  try {
-    out = await fn(ctx);
-  } catch (err) {
-    if (err instanceof UndeclaredFsReadError || err instanceof UndeclaredGraphReadError || err instanceof ParseAstNotPrewarmedError) {
+    const fn = mod.companion;
+    if (typeof fn !== "function") {
       return companionInfra(
-        `companion.mjs for aspect '${aspectId}' read an undeclared path or node: ${err.message}`,
-        `A companion resolves the prompt only \u2014 it cannot judge code, so an undeclared read is an infrastructure fault, not a code violation.`,
-        `Declare a relation in yg-node.yaml to the node owning that path, or read only relation-reachable files.`
+        `companion.mjs does not export a function named 'companion' (aspect '${aspectId}'; got ${typeof fn}).`,
+        `The runner imports the named export 'companion' and calls companion(ctx).`,
+        `Add 'export function companion(ctx) { ... }' to companion.mjs (it may be async).`
       );
     }
-    return companionInfra(
-      `companion hook threw while resolving companions (aspect '${aspectId}'): ${err.message}`,
-      `${err.stack ?? ""}`,
-      `Fix the bug in companion.mjs, then re-run: yg check --approve`
-    );
-  }
-  if (!Array.isArray(out)) {
-    return companionInfra(
-      `companion.mjs returned ${typeof out}, expected an array of { path: string, label?: string } (aspect '${aspectId}').`,
-      `The runner attaches each returned path to the reviewer prompt; a non-array return cannot be interpreted.`,
-      `Return [] or { path, label? }[] from companion.`
-    );
-  }
-  const descriptors = [];
-  for (const d of out) {
-    if (typeof d !== "object" || d === null || typeof d.path !== "string") {
+    let built;
+    try {
+      built = await buildUnitCtx({ aspectId, nodePath, graph, projectRoot, astCache, touchedFiles, subjectScope });
+    } catch (err) {
+      if (err instanceof StructureRunnerError) {
+        return { kind: "infra", messageData: err.messageData };
+      }
+      throw err;
+    }
+    const { ctx, recorder } = built;
+    let out;
+    try {
+      out = await fn(ctx);
+    } catch (err) {
+      if (err instanceof UndeclaredFsReadError || err instanceof UndeclaredGraphReadError || err instanceof ParseAstNotPrewarmedError) {
+        return companionInfra(
+          `companion.mjs for aspect '${aspectId}' read an undeclared path or node: ${err.message}`,
+          `A companion resolves the prompt only \u2014 it cannot judge code, so an undeclared read is an infrastructure fault, not a code violation.`,
+          `Declare a relation in yg-node.yaml to the node owning that path, or read only relation-reachable files.`
+        );
+      }
       return companionInfra(
-        `companion.mjs returned an entry that is not { path: string, label?: string } (aspect '${aspectId}').`,
-        `Each companion descriptor must carry a string 'path' (and an optional string 'label').`,
-        `Return objects shaped { path: string, label?: string } from companion.`
+        `companion hook threw while resolving companions (aspect '${aspectId}'): ${err.message}`,
+        `${err.stack ?? ""}`,
+        `Fix the bug in companion.mjs, then re-run: yg check --approve`
       );
     }
-    const dd = d;
-    if (dd.label !== void 0 && typeof dd.label !== "string") {
+    if (!Array.isArray(out)) {
       return companionInfra(
-        `companion.mjs returned an entry whose 'label' is not a string (aspect '${aspectId}'; got ${typeof dd.label}).`,
-        `A companion descriptor's optional 'label' is a human tag and must be a string when present.`,
-        `Omit 'label' or set it to a string in companion.`
+        `companion.mjs returned ${typeof out}, expected an array of { path: string, label?: string } (aspect '${aspectId}').`,
+        `The runner attaches each returned path to the reviewer prompt; a non-array return cannot be interpreted.`,
+        `Return [] or { path, label? }[] from companion.`
       );
     }
-    descriptors.push({ path: dd.path, ...dd.label !== void 0 ? { label: dd.label } : {} });
+    const descriptors = [];
+    for (const d of out) {
+      if (typeof d !== "object" || d === null || typeof d.path !== "string") {
+        return companionInfra(
+          `companion.mjs returned an entry that is not { path: string, label?: string } (aspect '${aspectId}').`,
+          `Each companion descriptor must carry a string 'path' (and an optional string 'label').`,
+          `Return objects shaped { path: string, label?: string } from companion.`
+        );
+      }
+      const dd = d;
+      if (dd.label !== void 0 && typeof dd.label !== "string") {
+        return companionInfra(
+          `companion.mjs returned an entry whose 'label' is not a string (aspect '${aspectId}'; got ${typeof dd.label}).`,
+          `A companion descriptor's optional 'label' is a human tag and must be a string when present.`,
+          `Omit 'label' or set it to a string in companion.`
+        );
+      }
+      descriptors.push({ path: dd.path, ...dd.label !== void 0 ? { label: dd.label } : {} });
+    }
+    return {
+      kind: "ok",
+      descriptors,
+      touchedFiles,
+      observations: recorder.snapshot(),
+      observationsTainted: recorder.tainted
+    };
+  } finally {
+    if (ownCache) destroyParseCache(astCache);
   }
-  return {
-    kind: "ok",
-    descriptors,
-    touchedFiles,
-    observations: recorder.snapshot(),
-    observationsTainted: recorder.tainted
-  };
 }
 
 // src/structure/runner.ts
 async function runStructureAspect(params) {
   const { aspectDir, aspectId, nodePath, graph, projectRoot, subjectScope } = params;
+  const ownCache = !params.parseCache;
   const astCache = params.parseCache ?? /* @__PURE__ */ new Map();
   const touchedFiles = [];
-  const mod = await loadHookModule({ aspectDir, projectRoot, filename: "check.mjs" });
-  const exportCheck = validateCheckModuleExport(mod, {
-    codePrefix: "STRUCTURE",
-    runnerLabel: `aspect '${aspectId}'`
-  });
-  if (!exportCheck.ok) {
-    throw new StructureRunnerError(exportCheck.code, exportCheck.message);
-  }
-  const checkFn = mod.check;
-  const { ctx, recorder, ownFiles, astInputSet } = await buildUnitCtx({
-    aspectId,
-    nodePath,
-    graph,
-    projectRoot,
-    astCache,
-    touchedFiles,
-    subjectScope
-  });
-  let raw;
   try {
-    raw = checkFn(ctx);
-  } catch (err) {
-    if (err instanceof UndeclaredFsReadError) {
-      return {
-        violations: [{
-          message: `Aspect tried to read undeclared path '${err.path}'. Add a relation in yg-node.yaml to the node owning this path.`,
-          kind: "structure-aspect-undeclared-fs-read",
-          file: `.yggdrasil/aspects/${aspectId}/check.mjs`
-        }],
-        touchedFiles: [],
-        succeeded: false,
-        observations: recorder.snapshot(),
-        observationsTainted: recorder.tainted
-      };
+    let rangesFor2 = function(filePath) {
+      const existing = rangesByFile.get(filePath);
+      if (existing !== void 0) return existing;
+      const cached = astCache.get(filePath);
+      let ranges;
+      if (cached) {
+        ranges = collectSuppressions(cached.ast, filePath, cached.content.split("\n").length, cached.content);
+      } else {
+        const content20 = contentByPath.get(filePath);
+        ranges = content20 !== void 0 ? collectSuppressions(void 0, filePath, content20.split("\n").length, content20) : null;
+      }
+      rangesByFile.set(filePath, ranges);
+      return ranges;
+    };
+    var rangesFor = rangesFor2;
+    const mod = await loadHookModule({ aspectDir, projectRoot, filename: "check.mjs" });
+    const exportCheck = validateCheckModuleExport(mod, {
+      codePrefix: "STRUCTURE",
+      runnerLabel: `aspect '${aspectId}'`
+    });
+    if (!exportCheck.ok) {
+      throw new StructureRunnerError(exportCheck.code, exportCheck.message);
     }
-    if (err instanceof UndeclaredGraphReadError) {
-      return {
-        violations: [{
-          message: `Aspect tried to read undeclared graph node '${err.nodePath}'. Add a relation in yg-node.yaml.`,
-          kind: "structure-aspect-undeclared-graph-read",
-          file: `.yggdrasil/aspects/${aspectId}/check.mjs`
-        }],
-        touchedFiles: [],
-        succeeded: false,
-        observations: recorder.snapshot(),
-        observationsTainted: recorder.tainted
-      };
+    const checkFn = mod.check;
+    const { ctx, recorder, ownFiles, astInputSet } = await buildUnitCtx({
+      aspectId,
+      nodePath,
+      graph,
+      projectRoot,
+      astCache,
+      touchedFiles,
+      subjectScope
+    });
+    let raw;
+    try {
+      raw = checkFn(ctx);
+    } catch (err) {
+      if (err instanceof UndeclaredFsReadError) {
+        return {
+          violations: [{
+            message: `Aspect tried to read undeclared path '${err.path}'. Add a relation in yg-node.yaml to the node owning this path.`,
+            kind: "structure-aspect-undeclared-fs-read",
+            file: `.yggdrasil/aspects/${aspectId}/check.mjs`
+          }],
+          touchedFiles: [],
+          succeeded: false,
+          observations: recorder.snapshot(),
+          observationsTainted: recorder.tainted
+        };
+      }
+      if (err instanceof UndeclaredGraphReadError) {
+        return {
+          violations: [{
+            message: `Aspect tried to read undeclared graph node '${err.nodePath}'. Add a relation in yg-node.yaml.`,
+            kind: "structure-aspect-undeclared-graph-read",
+            file: `.yggdrasil/aspects/${aspectId}/check.mjs`
+          }],
+          touchedFiles: [],
+          succeeded: false,
+          observations: recorder.snapshot(),
+          observationsTainted: recorder.tainted
+        };
+      }
+      if (err instanceof ParseAstNotPrewarmedError) {
+        return {
+          violations: [{
+            message: `Aspect called ctx.parseAst on '${err.filePath}', which was not pre-warmed by the dispatcher. Add a declared relation to the node owning this file, or use ctx.parseYaml/Json/Toml if AST is not required.`,
+            kind: "structure-aspect-parseast-not-prewarmed",
+            file: `.yggdrasil/model/${nodePath}/yg-node.yaml`
+          }],
+          touchedFiles: [],
+          succeeded: false,
+          observations: recorder.snapshot(),
+          observationsTainted: recorder.tainted
+        };
+      }
+      throw new StructureRunnerError("STRUCTURE_CHECK_THROWN", {
+        what: `check.mjs threw an exception while running (aspect '${aspectId}').`,
+        why: `${err.message}
+${err.stack ?? ""}`,
+        next: `Fix the bug in check.mjs, then re-run: yg check --approve`
+      });
     }
-    if (err instanceof ParseAstNotPrewarmedError) {
-      return {
-        violations: [{
-          message: `Aspect called ctx.parseAst on '${err.filePath}', which was not pre-warmed by the dispatcher. Add a declared relation to the node owning this file, or use ctx.parseYaml/Json/Toml if AST is not required.`,
-          kind: "structure-aspect-parseast-not-prewarmed",
-          file: `.yggdrasil/model/${nodePath}/yg-node.yaml`
-        }],
-        touchedFiles: [],
-        succeeded: false,
-        observations: recorder.snapshot(),
-        observationsTainted: recorder.tainted
-      };
+    if (raw !== null && typeof raw === "object" && typeof raw.then === "function") {
+      throw new StructureRunnerError("STRUCTURE_CHECK_ASYNC", {
+        what: `check.mjs returned a Promise; only synchronous returns are supported.`,
+        why: `The runner does not await check's return value.`,
+        next: `Refactor check to be synchronous.`
+      });
     }
-    throw new StructureRunnerError("STRUCTURE_CHECK_THROWN", {
-      what: `check.mjs threw an exception while running (aspect '${aspectId}').`,
-      why: `${err.message}
-${err.stack ?? ""}`,
-      next: `Fix the bug in check.mjs, then re-run: yg check --approve`
-    });
-  }
-  if (raw !== null && typeof raw === "object" && typeof raw.then === "function") {
-    throw new StructureRunnerError("STRUCTURE_CHECK_ASYNC", {
-      what: `check.mjs returned a Promise; only synchronous returns are supported.`,
-      why: `The runner does not await check's return value.`,
-      next: `Refactor check to be synchronous.`
-    });
-  }
-  if (!Array.isArray(raw)) {
-    throw new StructureRunnerError("STRUCTURE_CHECK_RETURN_SHAPE", {
-      what: `check.mjs returned ${typeof raw}, expected Violation[].`,
-      why: `The runner reports violations from the array returned by check.`,
-      next: `Return [] or Violation[] from check.`
-    });
-  }
-  const contextFiles = new Set(ownFiles.map((f) => f.path));
-  for (const t of touchedFiles) contextFiles.add(t);
-  const violations = [];
-  for (const v of raw) {
-    if (typeof v !== "object" || v === null || typeof v.message !== "string") {
+    if (!Array.isArray(raw)) {
       throw new StructureRunnerError("STRUCTURE_CHECK_RETURN_SHAPE", {
-        what: `Violation entry must be an object with a string 'message' field.`,
-        why: `The runner renders each violation from its message and optional file/line.`,
-        next: `Return objects shaped { message: string, file?: string, line?: number } from check.`
+        what: `check.mjs returned ${typeof raw}, expected Violation[].`,
+        why: `The runner reports violations from the array returned by check.`,
+        next: `Return [] or Violation[] from check.`
       });
     }
-    const vv = v;
-    if (typeof vv.file === "string" && !contextFiles.has(normalizeMappingPath(vv.file))) {
-      throw new StructureRunnerError("STRUCTURE_CHECK_FILE_NOT_IN_CONTEXT", {
-        what: `Violation references file '${vv.file}' not in ctx (own mapping or touched via ctx.fs/ctx.graph).`,
-        why: `Author cannot synthesize violations against files they were not given.`,
-        next: `Return only violations for files in ctx, or declare a relation to the node owning '${vv.file}'.`
-      });
+    const contextFiles = new Set(ownFiles.map((f) => f.path));
+    for (const t of touchedFiles) contextFiles.add(t);
+    const violations = [];
+    for (const v of raw) {
+      if (typeof v !== "object" || v === null || typeof v.message !== "string") {
+        throw new StructureRunnerError("STRUCTURE_CHECK_RETURN_SHAPE", {
+          what: `Violation entry must be an object with a string 'message' field.`,
+          why: `The runner renders each violation from its message and optional file/line.`,
+          next: `Return objects shaped { message: string, file?: string, line?: number } from check.`
+        });
+      }
+      const vv = v;
+      if (typeof vv.file === "string" && !contextFiles.has(normalizeMappingPath(vv.file))) {
+        throw new StructureRunnerError("STRUCTURE_CHECK_FILE_NOT_IN_CONTEXT", {
+          what: `Violation references file '${vv.file}' not in ctx (own mapping or touched via ctx.fs/ctx.graph).`,
+          why: `Author cannot synthesize violations against files they were not given.`,
+          next: `Return only violations for files in ctx, or declare a relation to the node owning '${vv.file}'.`
+        });
+      }
+      violations.push(vv);
     }
-    violations.push(vv);
-  }
-  const contentByPath = /* @__PURE__ */ new Map();
-  for (const f of [...ownFiles, ...astInputSet]) {
-    contentByPath.set(normalizeMappingPath(f.path), f.content);
-  }
-  const rangesByFile = /* @__PURE__ */ new Map();
-  function rangesFor(filePath) {
-    const existing = rangesByFile.get(filePath);
-    if (existing !== void 0) return existing;
-    const cached = astCache.get(filePath);
-    let ranges;
-    if (cached) {
-      ranges = collectSuppressions(cached.ast, filePath, cached.content.split("\n").length, cached.content);
-    } else {
-      const content20 = contentByPath.get(filePath);
-      ranges = content20 !== void 0 ? collectSuppressions(void 0, filePath, content20.split("\n").length, content20) : null;
+    const contentByPath = /* @__PURE__ */ new Map();
+    for (const f of [...ownFiles, ...astInputSet]) {
+      contentByPath.set(normalizeMappingPath(f.path), f.content);
     }
-    rangesByFile.set(filePath, ranges);
-    return ranges;
+    const rangesByFile = /* @__PURE__ */ new Map();
+    const visible = violations.filter((v) => {
+      if (typeof v.file !== "string" || typeof v.line !== "number") return true;
+      const ranges = rangesFor2(normalizeMappingPath(v.file));
+      if (!ranges) return true;
+      return !isLineSuppressed(ranges, aspectId, v.line);
+    });
+    return {
+      violations: visible,
+      touchedFiles,
+      succeeded: true,
+      observations: recorder.snapshot(),
+      observationsTainted: recorder.tainted
+    };
+  } finally {
+    if (ownCache) destroyParseCache(astCache);
   }
-  const visible = violations.filter((v) => {
-    if (typeof v.file !== "string" || typeof v.line !== "number") return true;
-    const ranges = rangesFor(normalizeMappingPath(v.file));
-    if (!ranges) return true;
-    return !isLineSuppressed(ranges, aspectId, v.line);
-  });
-  return {
-    violations: visible,
-    touchedFiles,
-    succeeded: true,
-    observations: recorder.snapshot(),
-    observationsTainted: recorder.tainted
-  };
 }
 
 // src/structure/suppress-ranges.ts
@@ -10933,12 +10964,12 @@ async function resolveSuppressedRangesForPrompt(subjects, aspectId) {
   for (const subject of subjects) {
     const content20 = subject.bytes.toString("utf8");
     const hasGrammar = getLanguageForExtension(extname5(subject.path).toLowerCase()) !== null;
-    let tree;
-    if (hasGrammar) {
-      tree = await parseFile(subject.path, content20);
-    }
     const totalLines = content20.split("\n").length;
-    const all = collectSuppressions(tree, subject.path, totalLines, content20);
+    const all = hasGrammar ? await withParsedFile(
+      subject.path,
+      content20,
+      (tree) => collectSuppressions(tree, subject.path, totalLines, content20)
+    ) : collectSuppressions(void 0, subject.path, totalLines, content20);
     const ranges = formatSuppressedRangesForAspect(all, aspectId);
     if (ranges.length > 0) {
       byFile.push({ path: subject.path, ranges });
@@ -12125,22 +12156,14 @@ async function runRelationPass(graph, projectRoot, deps) {
     }
   }
   const ownerIndex = buildOwnerIndex(graph.nodes);
-  const parseCache = /* @__PURE__ */ new Map();
-  async function getParsed(record) {
-    if (parseCache.has(record.path)) return parseCache.get(record.path) ?? null;
-    if (!record.language) {
-      parseCache.set(record.path, null);
-      return null;
-    }
-    let parsed;
+  async function parseSingle(record) {
+    if (!record.language) return null;
     try {
       const tree = await parseFile(record.path, record.content);
-      parsed = { path: record.path, content: record.content, tree, language: record.language };
+      return { path: record.path, content: record.content, tree, language: record.language };
     } catch {
-      parsed = null;
+      return null;
     }
-    parseCache.set(record.path, parsed);
-    return parsed;
   }
   const symbolTable = new SymbolTable();
   const recordsByLanguage = /* @__PURE__ */ new Map();
@@ -12164,11 +12187,15 @@ async function runRelationPass(graph, projectRoot, deps) {
     }
     const symbols = [];
     for (const record of records) {
-      const parsed = await getParsed(record);
+      const parsed = await parseSingle(record);
       if (!parsed) continue;
-      for (const decl of extractor.declarations(parsed)) {
-        symbols.push([decl.symbolKey, record.path]);
-        symbolTable.declare(language, decl.symbolKey, record.path);
+      try {
+        for (const decl of extractor.declarations(parsed)) {
+          symbols.push([decl.symbolKey, record.path]);
+          symbolTable.declare(language, decl.symbolKey, record.path);
+        }
+      } finally {
+        parsed.tree.delete();
       }
     }
     const toPersist = { builtFrom, symbols };
@@ -12178,10 +12205,14 @@ async function runRelationPass(graph, projectRoot, deps) {
   const projectGlobalUsings = /* @__PURE__ */ new Set();
   const projectGlobalUsingAliases = /* @__PURE__ */ new Map();
   for (const record of csharpRecords) {
-    const parsed = await getParsed(record);
+    const parsed = await parseSingle(record);
     if (!parsed) continue;
-    for (const prefix of collectGlobalUsings(parsed)) projectGlobalUsings.add(prefix);
-    for (const [name, fqn] of collectGlobalUsingAliases(parsed)) projectGlobalUsingAliases.set(name, fqn);
+    try {
+      for (const prefix of collectGlobalUsings(parsed)) projectGlobalUsings.add(prefix);
+      for (const [name, fqn] of collectGlobalUsingAliases(parsed)) projectGlobalUsingAliases.set(name, fqn);
+    } finally {
+      parsed.tree.delete();
+    }
   }
   const csharpGlobalUsings = [...projectGlobalUsings];
   const csharpGlobalUsingAliases = [...projectGlobalUsingAliases.entries()];
@@ -12216,17 +12247,21 @@ async function runRelationPass(graph, projectRoot, deps) {
       if (!record.language) continue;
       const extractor = deps.extractorFor(record.language);
       if (!extractor) continue;
-      const parsed = await getParsed(record);
+      const parsed = await parseSingle(record);
       if (!parsed) continue;
-      const detected = record.language === "csharp" ? csharpUses(parsed, {
-        projectGlobalUsings: csharpGlobalUsings,
-        projectGlobalUsingAliases: csharpGlobalUsingAliases
-      }) : extractor.uses(parsed);
-      for (const dep of detected) {
-        const ownerNode = resolveCandidateGroup(dep.candidates, resolver, record.path, record.language);
-        if (ownerNode !== void 0) {
-          resolvedDeps.push({ fromFile: record.path, line: dep.line, ownerNode });
+      try {
+        const detected = record.language === "csharp" ? csharpUses(parsed, {
+          projectGlobalUsings: csharpGlobalUsings,
+          projectGlobalUsingAliases: csharpGlobalUsingAliases
+        }) : extractor.uses(parsed);
+        for (const dep of detected) {
+          const ownerNode = resolveCandidateGroup(dep.candidates, resolver, record.path, record.language);
+          if (ownerNode !== void 0) {
+            resolvedDeps.push({ fromFile: record.path, line: dep.line, ownerNode });
+          }
         }
+      } finally {
+        parsed.tree.delete();
       }
     }
     const violations = verifyNodeDeps(nodeId, resolvedDeps, graphView);
@@ -15796,21 +15831,7 @@ async function runFill(graph, opts) {
 }
 
 // src/cli/check.ts
-import { execFileSync } from "child_process";
 import path48 from "path";
-function collectGitFiles(projectRoot) {
-  try {
-    const output = execFileSync("git", ["ls-files", "."], {
-      cwd: projectRoot,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return output.trim().split("\n").filter((f) => f.length > 0);
-  } catch (e) {
-    debugWrite(`[check] git ls-files failed: ${e instanceof Error ? e.message : String(e)}`);
-    return null;
-  }
-}
 function registerCheckCommand(program2) {
   program2.command("check").description("Unified graph gate \u2014 verification, coverage, completeness").option("--approve", "Fill every unverified pair (deterministic first, then LLM), then report").option("--only-deterministic", "With --approve: fill ONLY deterministic pairs (keyless, free); committed locks stay untouched. For CI and pre-commit.").option("--dry-run", "With --approve: free cost preview \u2014 print the budget + per-node/per-aspect breakdown, then exit 0 WITHOUT writing anything or calling the reviewer.").option("--top [n]", "Read-only triage: print only the N highest-priority issue blocks (bare --top = just the single suggestedNext block). Header counts + exit code stay TRUE.").option("--summary", "Read-only triage: print per-node counts only (no per-issue blocks). Header counts + exit code stay TRUE.").action(async (opts) => {
     try {
@@ -15818,7 +15839,7 @@ function registerCheckCommand(program2) {
       const graph = await loadGraphOrAbort(cwd, { tolerateInvalidConfig: true });
       initDebugLog(graph.rootPath, graph.config.debug ?? false, appendToDebugLog);
       const projectRoot = path48.dirname(graph.rootPath);
-      const gitFiles = collectGitFiles(projectRoot);
+      const gitFiles = await walkRepoFiles(projectRoot);
       const wantsTop = opts.top !== void 0;
       if (wantsTop && opts.summary) {
         process.stderr.write(chalk8.red(buildIssueMessage({
@@ -16212,86 +16233,96 @@ async function runAstAspect(params) {
     throw new AstRunnerError(exportCheck.code, exportCheck.message);
   }
   const checkFn = mod.check;
+  const localTrees = [];
   const sourceFiles = [];
-  for (const f of params.files) {
-    const cached = params.parseCache?.get(f.path);
-    if (cached !== void 0) {
-      sourceFiles.push({ path: f.path, content: cached.content, ast: cached.ast });
-      continue;
+  try {
+    for (const f of params.files) {
+      const cached = params.parseCache?.get(f.path);
+      if (cached !== void 0) {
+        sourceFiles.push({ path: f.path, content: cached.content, ast: cached.ast });
+        continue;
+      }
+      const content20 = await readFile16(path49.resolve(params.projectRoot, f.path), "utf-8");
+      if (getLanguageForExtension(path49.extname(f.path).toLowerCase()) === null) {
+        sourceFiles.push({ path: f.path, content: content20, ast: void 0 });
+        continue;
+      }
+      let ast;
+      try {
+        ast = await parseFile(f.path, content20);
+      } catch (e) {
+        const msg = e.message ?? String(e);
+        throw new AstRunnerError("AST_GRAMMAR_LOAD_FAILED", {
+          what: `Failed to load tree-sitter grammar for ${f.path}: ${msg}`,
+          why: `The bundled WASM grammar could not be loaded.`,
+          next: `Reinstall the CLI.`
+        });
+      }
+      if (!params.parseCache) {
+        localTrees.push(ast);
+      }
+      if (ast.rootNode.hasError) {
+        const err = findFirstErrorNode(ast.rootNode);
+        throw new AstRunnerError("AST_SOURCE_PARSE_ERROR", {
+          what: `Source file ${f.path} has a syntax error at line ${(err?.startPosition.row ?? 0) + 1}.`,
+          why: `Tree-sitter could not parse the file cleanly.`,
+          next: `Fix the syntax error in ${f.path}.`
+        });
+      }
+      if (params.parseCache) {
+        params.parseCache.set(f.path, { content: content20, ast });
+      }
+      sourceFiles.push({ path: f.path, content: content20, ast });
     }
-    const content20 = await readFile16(path49.resolve(params.projectRoot, f.path), "utf-8");
-    if (getLanguageForExtension(path49.extname(f.path).toLowerCase()) === null) {
-      sourceFiles.push({ path: f.path, content: content20, ast: void 0 });
-      continue;
+    const rangesPerFile = /* @__PURE__ */ new Map();
+    for (const f of sourceFiles) {
+      const totalLines = f.content.split("\n").length;
+      rangesPerFile.set(f.path, collectSuppressions(f.ast, f.path, totalLines, f.content));
     }
-    let ast;
+    const ctx = { files: sourceFiles };
+    let raw;
     try {
-      ast = await parseFile(f.path, content20);
+      raw = checkFn(ctx);
     } catch (e) {
-      const msg = e.message ?? String(e);
-      throw new AstRunnerError("AST_GRAMMAR_LOAD_FAILED", {
-        what: `Failed to load tree-sitter grammar for ${f.path}: ${msg}`,
-        why: `The bundled WASM grammar could not be loaded.`,
-        next: `Reinstall the CLI.`
+      throw new AstRunnerError("AST_CHECK_THROWN", {
+        what: `check.mjs threw an exception while running (aspect '${params.aspectId}').`,
+        why: (e instanceof Error ? e.stack : void 0) ?? String(e),
+        next: `Fix the bug in check.mjs, then re-run: yg check --approve`
       });
     }
-    if (ast.rootNode.hasError) {
-      const err = findFirstErrorNode(ast.rootNode);
-      throw new AstRunnerError("AST_SOURCE_PARSE_ERROR", {
-        what: `Source file ${f.path} has a syntax error at line ${(err?.startPosition.row ?? 0) + 1}.`,
-        why: `Tree-sitter could not parse the file cleanly.`,
-        next: `Fix the syntax error in ${f.path}.`
+    if (raw !== null && typeof raw === "object" && typeof raw.then === "function") {
+      throw new AstRunnerError("AST_CHECK_ASYNC", {
+        what: `check.mjs returned a Promise; only synchronous returns are supported in v1.`,
+        why: `The runner does not await check's return value.`,
+        next: `Refactor check to be synchronous.`
       });
     }
-    params.parseCache?.set(f.path, { content: content20, ast });
-    sourceFiles.push({ path: f.path, content: content20, ast });
-  }
-  const rangesPerFile = /* @__PURE__ */ new Map();
-  for (const f of sourceFiles) {
-    const totalLines = f.content.split("\n").length;
-    rangesPerFile.set(f.path, collectSuppressions(f.ast, f.path, totalLines, f.content));
-  }
-  const ctx = { files: sourceFiles };
-  let raw;
-  try {
-    raw = checkFn(ctx);
-  } catch (e) {
-    throw new AstRunnerError("AST_CHECK_THROWN", {
-      what: `check.mjs threw an exception while running (aspect '${params.aspectId}').`,
-      why: (e instanceof Error ? e.stack : void 0) ?? String(e),
-      next: `Fix the bug in check.mjs, then re-run: yg check --approve`
-    });
-  }
-  if (raw !== null && typeof raw === "object" && typeof raw.then === "function") {
-    throw new AstRunnerError("AST_CHECK_ASYNC", {
-      what: `check.mjs returned a Promise; only synchronous returns are supported in v1.`,
-      why: `The runner does not await check's return value.`,
-      next: `Refactor check to be synchronous.`
-    });
-  }
-  if (!Array.isArray(raw)) {
-    throw new AstRunnerError("AST_CHECK_RETURN_SHAPE", {
-      what: `check.mjs returned ${typeof raw}, expected Violation[].`,
-      why: `The runner reports violations from the array returned by check.`,
-      next: `Return [] or Violation[] from check.`
-    });
-  }
-  const contextPaths = new Set(sourceFiles.map((f) => f.path));
-  for (const v of raw) {
-    if (!contextPaths.has(v.file)) {
-      throw new AstRunnerError("AST_CHECK_FILE_NOT_IN_CONTEXT", {
-        what: `check.mjs returned a Violation referencing file '${v.file}' which is not in ctx.files (aspect '${params.aspectId}').`,
-        why: `Author cannot synthesize violations against files they were not given. Suppress markers cannot reach unknown files.`,
-        next: `Return only violations for files in ctx.files (the array passed to check).`
+    if (!Array.isArray(raw)) {
+      throw new AstRunnerError("AST_CHECK_RETURN_SHAPE", {
+        what: `check.mjs returned ${typeof raw}, expected Violation[].`,
+        why: `The runner reports violations from the array returned by check.`,
+        next: `Return [] or Violation[] from check.`
       });
     }
+    const contextPaths = new Set(sourceFiles.map((f) => f.path));
+    for (const v of raw) {
+      if (!contextPaths.has(v.file)) {
+        throw new AstRunnerError("AST_CHECK_FILE_NOT_IN_CONTEXT", {
+          what: `check.mjs returned a Violation referencing file '${v.file}' which is not in ctx.files (aspect '${params.aspectId}').`,
+          why: `Author cannot synthesize violations against files they were not given. Suppress markers cannot reach unknown files.`,
+          next: `Return only violations for files in ctx.files (the array passed to check).`
+        });
+      }
+    }
+    const filtered = raw.filter((v) => {
+      const ranges = rangesPerFile.get(v.file);
+      if (!ranges) return true;
+      return !isLineSuppressed(ranges, params.aspectId, v.line);
+    });
+    return { violations: filtered };
+  } finally {
+    for (const t of localTrees) t.delete();
   }
-  const filtered = raw.filter((v) => {
-    const ranges = rangesPerFile.get(v.file);
-    if (!ranges) return true;
-    return !isLineSuppressed(ranges, params.aspectId, v.line);
-  });
-  return { violations: filtered };
 }
 function findFirstErrorNode(node) {
   if (node.isError) return node;
@@ -21792,7 +21823,6 @@ function registerSchemasCommand(program2) {
 // src/cli/suppressions.ts
 import chalk14 from "chalk";
 import { readFileSync as readFileSync8, existsSync as existsSync9 } from "fs";
-import { execFileSync as execFileSync2 } from "child_process";
 import path57 from "path";
 function isBinaryContent(buf) {
   const checkLen = Math.min(buf.length, 8192);
@@ -21821,8 +21851,11 @@ async function scanMarkersForFile(relFile, text2) {
     return scanSuppressionMarkers(text2);
   }
   try {
-    const tree = await parseFile(relFile, text2);
-    return scanSuppressionMarkersInComments(tree, relFile);
+    return await withParsedFile(
+      relFile,
+      text2,
+      (tree) => scanSuppressionMarkersInComments(tree, relFile)
+    );
   } catch (error) {
     debugWrite(`[suppressions] parse fallback (raw scan): ${relFile}: ${error instanceof Error ? error.message : String(error)}`);
     return scanSuppressionMarkers(text2);
@@ -21941,17 +21974,7 @@ function registerSuppressionsCommand(program2) {
       const graph = await loadGraphOrAbort(cwd);
       initDebugLog(graph.rootPath, graph.config.debug ?? false, appendToDebugLog);
       const projectRoot = path57.dirname(graph.rootPath);
-      let gitFiles = [];
-      try {
-        const output = execFileSync2("git", ["ls-files", "."], {
-          cwd: projectRoot,
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        gitFiles = output.trim().split("\n").filter((f) => f.length > 0);
-      } catch (error) {
-        debugWrite(`[suppressions] git ls-files fallback: ${error instanceof Error ? error.message : String(error)}`);
-      }
+      const gitFiles = await walkRepoFiles(projectRoot);
       const knownAspectIds = new Set(graph.aspects.map((a) => a.id));
       const report2 = await runSuppressionsScan(projectRoot, gitFiles, knownAspectIds);
       process.stdout.write(formatSuppressionsOutput(report2));

package/dist/structure.js

@@ -549,6 +549,7 @@ var GRAMMAR_DIRS = [
 ];
 var initPromise = null;
 var langCache = /* @__PURE__ */ new Map();
+var parserCache = /* @__PURE__ */ new Map();
 function init() {
   if (initPromise === null) {
     initPromise = Parser.init();
@@ -589,8 +590,11 @@ async function getParser(extension) {
     });
   }
   const lang = await langP;
+  const existing = parserCache.get(cacheKey);
+  if (existing) return existing;
   const parser = new Parser();
   parser.setLanguage(lang);
+  parserCache.set(cacheKey, parser);
   return parser;
 }
 async function parseFile(filePath, content) {
@@ -602,6 +606,14 @@ async function parseFile(filePath, content) {
   }
   return tree;
 }
+async function withParsedFile(filePath, content, fn) {
+  const tree = await parseFile(filePath, content);
+  try {
+    return await fn(tree);
+  } finally {
+    tree.delete();
+  }
+}
 
 // src/structure/ctx-parsers.ts
 var ParseAstNotPrewarmedError = class extends Error {
@@ -876,6 +888,14 @@ function validateCheckModuleExport(mod, opts) {
   return { ok: true };
 }
 
+// src/ast/parse-cache.ts
+function destroyParseCache(cache) {
+  for (const { ast } of cache.values()) {
+    ast.delete();
+  }
+  cache.clear();
+}
+
 // src/structure/hook-loader.ts
 import * as fs4 from "fs";
 import * as path8 from "path";
@@ -1435,143 +1455,149 @@ async function buildUnitCtx(params) {
 // src/structure/runner.ts
 async function runStructureAspect(params) {
   const { aspectDir, aspectId, nodePath, graph, projectRoot, subjectScope } = params;
+  const ownCache = !params.parseCache;
   const astCache = params.parseCache ?? /* @__PURE__ */ new Map();
   const touchedFiles = [];
-  const mod = await loadHookModule({ aspectDir, projectRoot, filename: "check.mjs" });
-  const exportCheck = validateCheckModuleExport(mod, {
-    codePrefix: "STRUCTURE",
-    runnerLabel: `aspect '${aspectId}'`
-  });
-  if (!exportCheck.ok) {
-    throw new StructureRunnerError(exportCheck.code, exportCheck.message);
-  }
-  const checkFn = mod.check;
-  const { ctx, recorder, ownFiles, astInputSet } = await buildUnitCtx({
-    aspectId,
-    nodePath,
-    graph,
-    projectRoot,
-    astCache,
-    touchedFiles,
-    subjectScope
-  });
-  let raw;
   try {
-    raw = checkFn(ctx);
-  } catch (err) {
-    if (err instanceof UndeclaredFsReadError) {
-      return {
-        violations: [{
-          message: `Aspect tried to read undeclared path '${err.path}'. Add a relation in yg-node.yaml to the node owning this path.`,
-          kind: "structure-aspect-undeclared-fs-read",
-          file: `.yggdrasil/aspects/${aspectId}/check.mjs`
-        }],
-        touchedFiles: [],
-        succeeded: false,
-        observations: recorder.snapshot(),
-        observationsTainted: recorder.tainted
-      };
+    let rangesFor2 = function(filePath) {
+      const existing = rangesByFile.get(filePath);
+      if (existing !== void 0) return existing;
+      const cached = astCache.get(filePath);
+      let ranges;
+      if (cached) {
+        ranges = collectSuppressions(cached.ast, filePath, cached.content.split("\n").length, cached.content);
+      } else {
+        const content = contentByPath.get(filePath);
+        ranges = content !== void 0 ? collectSuppressions(void 0, filePath, content.split("\n").length, content) : null;
+      }
+      rangesByFile.set(filePath, ranges);
+      return ranges;
+    };
+    var rangesFor = rangesFor2;
+    const mod = await loadHookModule({ aspectDir, projectRoot, filename: "check.mjs" });
+    const exportCheck = validateCheckModuleExport(mod, {
+      codePrefix: "STRUCTURE",
+      runnerLabel: `aspect '${aspectId}'`
+    });
+    if (!exportCheck.ok) {
+      throw new StructureRunnerError(exportCheck.code, exportCheck.message);
     }
-    if (err instanceof UndeclaredGraphReadError) {
-      return {
-        violations: [{
-          message: `Aspect tried to read undeclared graph node '${err.nodePath}'. Add a relation in yg-node.yaml.`,
-          kind: "structure-aspect-undeclared-graph-read",
-          file: `.yggdrasil/aspects/${aspectId}/check.mjs`
-        }],
-        touchedFiles: [],
-        succeeded: false,
-        observations: recorder.snapshot(),
-        observationsTainted: recorder.tainted
-      };
+    const checkFn = mod.check;
+    const { ctx, recorder, ownFiles, astInputSet } = await buildUnitCtx({
+      aspectId,
+      nodePath,
+      graph,
+      projectRoot,
+      astCache,
+      touchedFiles,
+      subjectScope
+    });
+    let raw;
+    try {
+      raw = checkFn(ctx);
+    } catch (err) {
+      if (err instanceof UndeclaredFsReadError) {
+        return {
+          violations: [{
+            message: `Aspect tried to read undeclared path '${err.path}'. Add a relation in yg-node.yaml to the node owning this path.`,
+            kind: "structure-aspect-undeclared-fs-read",
+            file: `.yggdrasil/aspects/${aspectId}/check.mjs`
+          }],
+          touchedFiles: [],
+          succeeded: false,
+          observations: recorder.snapshot(),
+          observationsTainted: recorder.tainted
+        };
+      }
+      if (err instanceof UndeclaredGraphReadError) {
+        return {
+          violations: [{
+            message: `Aspect tried to read undeclared graph node '${err.nodePath}'. Add a relation in yg-node.yaml.`,
+            kind: "structure-aspect-undeclared-graph-read",
+            file: `.yggdrasil/aspects/${aspectId}/check.mjs`
+          }],
+          touchedFiles: [],
+          succeeded: false,
+          observations: recorder.snapshot(),
+          observationsTainted: recorder.tainted
+        };
+      }
+      if (err instanceof ParseAstNotPrewarmedError) {
+        return {
+          violations: [{
+            message: `Aspect called ctx.parseAst on '${err.filePath}', which was not pre-warmed by the dispatcher. Add a declared relation to the node owning this file, or use ctx.parseYaml/Json/Toml if AST is not required.`,
+            kind: "structure-aspect-parseast-not-prewarmed",
+            file: `.yggdrasil/model/${nodePath}/yg-node.yaml`
+          }],
+          touchedFiles: [],
+          succeeded: false,
+          observations: recorder.snapshot(),
+          observationsTainted: recorder.tainted
+        };
+      }
+      throw new StructureRunnerError("STRUCTURE_CHECK_THROWN", {
+        what: `check.mjs threw an exception while running (aspect '${aspectId}').`,
+        why: `${err.message}
+${err.stack ?? ""}`,
+        next: `Fix the bug in check.mjs, then re-run: yg check --approve`
+      });
     }
-    if (err instanceof ParseAstNotPrewarmedError) {
-      return {
-        violations: [{
-          message: `Aspect called ctx.parseAst on '${err.filePath}', which was not pre-warmed by the dispatcher. Add a declared relation to the node owning this file, or use ctx.parseYaml/Json/Toml if AST is not required.`,
-          kind: "structure-aspect-parseast-not-prewarmed",
-          file: `.yggdrasil/model/${nodePath}/yg-node.yaml`
-        }],
-        touchedFiles: [],
-        succeeded: false,
-        observations: recorder.snapshot(),
-        observationsTainted: recorder.tainted
-      };
+    if (raw !== null && typeof raw === "object" && typeof raw.then === "function") {
+      throw new StructureRunnerError("STRUCTURE_CHECK_ASYNC", {
+        what: `check.mjs returned a Promise; only synchronous returns are supported.`,
+        why: `The runner does not await check's return value.`,
+        next: `Refactor check to be synchronous.`
+      });
     }
-    throw new StructureRunnerError("STRUCTURE_CHECK_THROWN", {
-      what: `check.mjs threw an exception while running (aspect '${aspectId}').`,
-      why: `${err.message}
-${err.stack ?? ""}`,
-      next: `Fix the bug in check.mjs, then re-run: yg check --approve`
-    });
-  }
-  if (raw !== null && typeof raw === "object" && typeof raw.then === "function") {
-    throw new StructureRunnerError("STRUCTURE_CHECK_ASYNC", {
-      what: `check.mjs returned a Promise; only synchronous returns are supported.`,
-      why: `The runner does not await check's return value.`,
-      next: `Refactor check to be synchronous.`
-    });
-  }
-  if (!Array.isArray(raw)) {
-    throw new StructureRunnerError("STRUCTURE_CHECK_RETURN_SHAPE", {
-      what: `check.mjs returned ${typeof raw}, expected Violation[].`,
-      why: `The runner reports violations from the array returned by check.`,
-      next: `Return [] or Violation[] from check.`
-    });
-  }
-  const contextFiles = new Set(ownFiles.map((f) => f.path));
-  for (const t of touchedFiles) contextFiles.add(t);
-  const violations = [];
-  for (const v of raw) {
-    if (typeof v !== "object" || v === null || typeof v.message !== "string") {
+    if (!Array.isArray(raw)) {
       throw new StructureRunnerError("STRUCTURE_CHECK_RETURN_SHAPE", {
-        what: `Violation entry must be an object with a string 'message' field.`,
-        why: `The runner renders each violation from its message and optional file/line.`,
-        next: `Return objects shaped { message: string, file?: string, line?: number } from check.`
+        what: `check.mjs returned ${typeof raw}, expected Violation[].`,
+        why: `The runner reports violations from the array returned by check.`,
+        next: `Return [] or Violation[] from check.`
       });
     }
-    const vv = v;
-    if (typeof vv.file === "string" && !contextFiles.has(normalizeMappingPath(vv.file))) {
-      throw new StructureRunnerError("STRUCTURE_CHECK_FILE_NOT_IN_CONTEXT", {
-        what: `Violation references file '${vv.file}' not in ctx (own mapping or touched via ctx.fs/ctx.graph).`,
-        why: `Author cannot synthesize violations against files they were not given.`,
-        next: `Return only violations for files in ctx, or declare a relation to the node owning '${vv.file}'.`
-      });
+    const contextFiles = new Set(ownFiles.map((f) => f.path));
+    for (const t of touchedFiles) contextFiles.add(t);
+    const violations = [];
+    for (const v of raw) {
+      if (typeof v !== "object" || v === null || typeof v.message !== "string") {
+        throw new StructureRunnerError("STRUCTURE_CHECK_RETURN_SHAPE", {
+          what: `Violation entry must be an object with a string 'message' field.`,
+          why: `The runner renders each violation from its message and optional file/line.`,
+          next: `Return objects shaped { message: string, file?: string, line?: number } from check.`
+        });
+      }
+      const vv = v;
+      if (typeof vv.file === "string" && !contextFiles.has(normalizeMappingPath(vv.file))) {
+        throw new StructureRunnerError("STRUCTURE_CHECK_FILE_NOT_IN_CONTEXT", {
+          what: `Violation references file '${vv.file}' not in ctx (own mapping or touched via ctx.fs/ctx.graph).`,
+          why: `Author cannot synthesize violations against files they were not given.`,
+          next: `Return only violations for files in ctx, or declare a relation to the node owning '${vv.file}'.`
+        });
+      }
+      violations.push(vv);
     }
-    violations.push(vv);
-  }
-  const contentByPath = /* @__PURE__ */ new Map();
-  for (const f of [...ownFiles, ...astInputSet]) {
-    contentByPath.set(normalizeMappingPath(f.path), f.content);
-  }
-  const rangesByFile = /* @__PURE__ */ new Map();
-  function rangesFor(filePath) {
-    const existing = rangesByFile.get(filePath);
-    if (existing !== void 0) return existing;
-    const cached = astCache.get(filePath);
-    let ranges;
-    if (cached) {
-      ranges = collectSuppressions(cached.ast, filePath, cached.content.split("\n").length, cached.content);
-    } else {
-      const content = contentByPath.get(filePath);
-      ranges = content !== void 0 ? collectSuppressions(void 0, filePath, content.split("\n").length, content) : null;
+    const contentByPath = /* @__PURE__ */ new Map();
+    for (const f of [...ownFiles, ...astInputSet]) {
+      contentByPath.set(normalizeMappingPath(f.path), f.content);
     }
-    rangesByFile.set(filePath, ranges);
-    return ranges;
-  }
-  const visible = violations.filter((v) => {
-    if (typeof v.file !== "string" || typeof v.line !== "number") return true;
-    const ranges = rangesFor(normalizeMappingPath(v.file));
-    if (!ranges) return true;
-    return !isLineSuppressed(ranges, aspectId, v.line);
-  });
-  return {
-    violations: visible,
-    touchedFiles,
-    succeeded: true,
-    observations: recorder.snapshot(),
-    observationsTainted: recorder.tainted
-  };
+    const rangesByFile = /* @__PURE__ */ new Map();
+    const visible = violations.filter((v) => {
+      if (typeof v.file !== "string" || typeof v.line !== "number") return true;
+      const ranges = rangesFor2(normalizeMappingPath(v.file));
+      if (!ranges) return true;
+      return !isLineSuppressed(ranges, aspectId, v.line);
+    });
+    return {
+      violations: visible,
+      touchedFiles,
+      succeeded: true,
+      observations: recorder.snapshot(),
+      observationsTainted: recorder.tainted
+    };
+  } finally {
+    if (ownCache) destroyParseCache(astCache);
+  }
 }
 
 // src/structure/suppress-ranges.ts
@@ -1581,12 +1607,12 @@ async function resolveSuppressedRangesForPrompt(subjects, aspectId) {
   for (const subject of subjects) {
     const content = subject.bytes.toString("utf8");
     const hasGrammar = getLanguageForExtension(extname5(subject.path).toLowerCase()) !== null;
-    let tree;
-    if (hasGrammar) {
-      tree = await parseFile(subject.path, content);
-    }
     const totalLines = content.split("\n").length;
-    const all = collectSuppressions(tree, subject.path, totalLines, content);
+    const all = hasGrammar ? await withParsedFile(
+      subject.path,
+      content,
+      (tree) => collectSuppressions(tree, subject.path, totalLines, content)
+    ) : collectSuppressions(void 0, subject.path, totalLines, content);
     const ranges = formatSuppressedRangesForAspect(all, aspectId);
     if (ranges.length > 0) {
       byFile.push({ path: subject.path, ranges });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrisdudek/yg",
-  "version": "5.2.4",
+  "version": "5.2.6",
   "description": "Architecture rules your AI coding agent can't ignore. It gets the rules for a file before it edits, and every change is checked — by a free local script or an LLM reviewer — before it moves on. Works with Claude Code, Cursor, Copilot, Codex, Cline.",
   "type": "module",
   "bin": {