@chrisdudek/yg 4.2.0 → 5.0.0-alpha.2

package/dist/structure.js

@@ -0,0 +1,1261 @@
+// src/structure/runner.ts
+import * as fs4 from "fs";
+import * as path8 from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+
+// src/ast/loader-hook.ts
+import { register } from "module";
+import { pathToFileURL } from "url";
+import path from "path";
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var registered = false;
+function ensureLoaderRegistered() {
+  if (registered) return;
+  let implPath = path.resolve(__dirname, "./loader-hook-impl.js");
+  if (!existsSync(implPath)) {
+    const pkgRoot = path.resolve(__dirname, "../../");
+    implPath = path.resolve(pkgRoot, "dist/loader-hook-impl.js");
+  }
+  register(pathToFileURL(implPath));
+  registered = true;
+}
+
+// src/structure/ctx-fs.ts
+import * as fs from "fs";
+import * as path2 from "path";
+
+// src/utils/mapping-path.ts
+function normalizeMappingPath(p) {
+  return p.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+}
+
+// src/utils/posix.ts
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+function toPosixPath(p) {
+  return p.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+
+// src/structure/ctx-fs.ts
+var UndeclaredFsReadError = class extends Error {
+  constructor(path9) {
+    super(`structure-aspect-undeclared-fs-read: ${path9}`);
+    this.path = path9;
+    this.name = "UndeclaredFsReadError";
+  }
+};
+function isAllowed(p, set) {
+  if (p === "") return false;
+  if (set.has(p)) return true;
+  for (const a of set) {
+    if (a === p) return true;
+    if (a.startsWith(p + "/")) return true;
+    if (p.startsWith(a + "/")) return true;
+  }
+  return false;
+}
+function assertRealpathContained(abs, projectRoot, rel) {
+  let realRoot;
+  try {
+    realRoot = fs.realpathSync(projectRoot);
+  } catch {
+    realRoot = projectRoot;
+  }
+  let probe = abs;
+  while (!fs.existsSync(probe)) {
+    const parent = path2.dirname(probe);
+    if (parent === probe) return;
+    probe = parent;
+  }
+  let realProbe;
+  try {
+    realProbe = fs.realpathSync(probe);
+  } catch {
+    return;
+  }
+  const relReal = toPosix(path2.relative(realRoot, realProbe));
+  if (relReal === ".." || relReal.startsWith("../") || path2.isAbsolute(relReal)) {
+    throw new UndeclaredFsReadError(rel);
+  }
+}
+function resolveAllowedReadPath(raw, allowedSet, projectRoot) {
+  const abs = path2.resolve(projectRoot, normalizeMappingPath(raw));
+  const rel = toPosix(path2.relative(projectRoot, abs));
+  if (rel === "" || rel.startsWith("..") || path2.isAbsolute(rel)) {
+    throw new UndeclaredFsReadError(normalizeMappingPath(raw));
+  }
+  if (!isAllowed(rel, allowedSet)) throw new UndeclaredFsReadError(rel);
+  assertRealpathContained(abs, projectRoot, rel);
+  return rel;
+}
+function createCtxFs(params) {
+  const { allowedSet, projectRoot, touchedFiles } = params;
+  function assertAllowed(raw) {
+    const p = resolveAllowedReadPath(raw, allowedSet, projectRoot);
+    touchedFiles.push(p);
+    return p;
+  }
+  return {
+    exists(raw) {
+      const p = assertAllowed(raw);
+      const abs = path2.resolve(projectRoot, p);
+      try {
+        const stat2 = fs.statSync(abs);
+        return stat2.isDirectory() ? "dir" : stat2.isFile() ? "file" : false;
+      } catch {
+        return false;
+      }
+    },
+    read(raw) {
+      const p = assertAllowed(raw);
+      const abs = path2.resolve(projectRoot, p);
+      return fs.readFileSync(abs, "utf8");
+    },
+    list(raw) {
+      const p = assertAllowed(raw);
+      const abs = path2.resolve(projectRoot, p);
+      const entries = fs.readdirSync(abs, { withFileTypes: true });
+      return entries.map((e) => ({
+        name: e.name,
+        kind: e.isDirectory() ? "dir" : "file"
+      }));
+    }
+  };
+}
+
+// src/structure/ctx-graph.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+
+// src/structure/expand-mapping-sync.ts
+function isPathInMapping(candidate, mapping) {
+  const c = normalizeMappingPath(candidate);
+  if (c === "") return false;
+  for (const raw of mapping) {
+    const n = normalizeMappingPath(raw);
+    if (n === "") continue;
+    if (c === n) return true;
+    if (c.startsWith(n + "/")) return true;
+  }
+  return false;
+}
+
+// src/structure/ctx-graph.ts
+var UndeclaredGraphReadError = class extends Error {
+  constructor(nodePath) {
+    super(`structure-aspect-undeclared-graph-read: ${nodePath}`);
+    this.nodePath = nodePath;
+    this.name = "UndeclaredGraphReadError";
+  }
+};
+function computeAllowedNodePaths(currentPath, graph) {
+  const allowed = /* @__PURE__ */ new Set([currentPath]);
+  const current = graph.nodes.get(currentPath);
+  if (!current) return allowed;
+  for (const rel of current.meta.relations ?? []) {
+    allowed.add(rel.target);
+    const target = graph.nodes.get(rel.target);
+    if (!target) continue;
+    const relStack = [...target.children];
+    while (relStack.length > 0) {
+      const n = relStack.pop();
+      allowed.add(n.path);
+      relStack.push(...n.children);
+    }
+  }
+  let cursor = current.parent;
+  while (cursor) {
+    allowed.add(cursor.path);
+    cursor = cursor.parent;
+  }
+  const stack = [...current.children];
+  while (stack.length) {
+    const n = stack.pop();
+    allowed.add(n.path);
+    stack.push(...n.children);
+  }
+  return allowed;
+}
+function createCtxGraph(params) {
+  const { currentNodePath, graph, projectRoot, touchedFiles } = params;
+  const allowed = computeAllowedNodePaths(currentNodePath, graph);
+  function assertAllowed(id) {
+    if (!allowed.has(id)) throw new UndeclaredGraphReadError(id);
+  }
+  function toPublicNode(m) {
+    const files = [];
+    for (const raw of m.meta.mapping ?? []) {
+      const p = normalizeMappingPath(raw);
+      if (!p) continue;
+      const abs = path3.resolve(projectRoot, p);
+      try {
+        const stat2 = fs2.statSync(abs);
+        if (stat2.isFile()) {
+          const content = fs2.readFileSync(abs, "utf8");
+          files.push({ path: p, content });
+          touchedFiles.push(p);
+        }
+      } catch {
+      }
+    }
+    return {
+      id: m.path,
+      type: m.meta.type,
+      mapping: m.meta.mapping ?? [],
+      files,
+      ports: m.meta.ports ?? {}
+    };
+  }
+  return {
+    node(id) {
+      assertAllowed(id);
+      const m = graph.nodes.get(id);
+      return m ? toPublicNode(m) : void 0;
+    },
+    nodesByType(type) {
+      const out = [];
+      for (const id of allowed) {
+        const m = graph.nodes.get(id);
+        if (m && m.meta.type === type) out.push(toPublicNode(m));
+      }
+      return out;
+    },
+    relationsFrom(node) {
+      assertAllowed(node.id);
+      const m = graph.nodes.get(node.id);
+      return m?.meta.relations ?? [];
+    },
+    relationsTo(node) {
+      const out = [];
+      for (const id of allowed) {
+        const m = graph.nodes.get(id);
+        if (!m) continue;
+        for (const rel of m.meta.relations ?? []) {
+          if (rel.target === node.id) out.push(rel);
+        }
+      }
+      return out;
+    },
+    children(node) {
+      assertAllowed(node.id);
+      const m = graph.nodes.get(node.id);
+      return m ? m.children.map(toPublicNode) : [];
+    },
+    flowParticipants(flowName) {
+      const flow = graph.flows.find((f) => f.name === flowName || f.path === flowName);
+      if (!flow) return [];
+      const participates = flow.nodes.some((n) => {
+        if (n === currentNodePath) return true;
+        let cursor = graph.nodes.get(currentNodePath)?.parent;
+        while (cursor) {
+          if (cursor.path === n) return true;
+          cursor = cursor.parent;
+        }
+        return false;
+      });
+      if (!participates) throw new UndeclaredGraphReadError(`flow:${flowName}`);
+      const out = [];
+      for (const nodeId of flow.nodes) {
+        const m = graph.nodes.get(nodeId);
+        if (m) out.push(toPublicNode(m));
+      }
+      return out;
+    }
+  };
+}
+
+// src/structure/ctx-parsers.ts
+import * as fs3 from "fs";
+import * as path5 from "path";
+import { extname } from "path";
+import { parse as parseYaml } from "yaml";
+import { parse as parseTomlSmol } from "smol-toml";
+
+// src/ast/parser.ts
+import { Parser, Language } from "web-tree-sitter";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { existsSync as existsSync3 } from "fs";
+import { createRequire } from "module";
+
+// src/core/graph/language-registry.ts
+var LANGUAGES = {
+  typescript: {
+    id: "typescript",
+    extensions: [".ts"],
+    wasmFile: "tree-sitter-typescript.wasm",
+    wasmPackage: "tree-sitter-typescript",
+    grammarRepo: "https://github.com/tree-sitter/tree-sitter-typescript",
+    grammarCommit: "",
+    treeSitterCliVersion: "",
+    externalScanner: false,
+    commentTypes: ["comment"],
+    commentDelimiters: ["//", "/*"]
+  },
+  tsx: {
+    id: "tsx",
+    extensions: [".tsx"],
+    wasmFile: "tree-sitter-tsx.wasm",
+    wasmPackage: "tree-sitter-typescript",
+    grammarRepo: "https://github.com/tree-sitter/tree-sitter-typescript",
+    grammarCommit: "",
+    treeSitterCliVersion: "",
+    externalScanner: false,
+    commentTypes: ["comment"],
+    commentDelimiters: ["//", "/*"]
+  },
+  javascript: {
+    id: "javascript",
+    extensions: [".js", ".mjs", ".cjs", ".jsx"],
+    wasmFile: "tree-sitter-javascript.wasm",
+    wasmPackage: "tree-sitter-javascript",
+    grammarRepo: "https://github.com/tree-sitter/tree-sitter-javascript",
+    grammarCommit: "",
+    treeSitterCliVersion: "",
+    externalScanner: false,
+    commentTypes: ["comment"],
+    commentDelimiters: ["//", "/*"]
+  },
+  python: {
+    id: "python",
+    extensions: [".py"],
+    wasmFile: "tree-sitter-python.wasm",
+    wasmPackage: "tree-sitter-python",
+    grammarRepo: "https://github.com/tree-sitter/tree-sitter-python",
+    grammarCommit: "",
+    treeSitterCliVersion: "",
+    externalScanner: false,
+    commentTypes: ["comment"],
+    commentDelimiters: ["#"]
+  },
+  go: {
+    id: "go",
+    extensions: [".go"],
+    wasmFile: "tree-sitter-go.wasm",
+    wasmPackage: "tree-sitter-go",
+    grammarRepo: "https://github.com/tree-sitter/tree-sitter-go",
+    grammarCommit: "",
+    treeSitterCliVersion: "",
+    externalScanner: false,
+    commentTypes: ["comment"],
+    commentDelimiters: ["//", "/*"]
+  },
+  rust: {
+    id: "rust",
+    extensions: [".rs"],
+    wasmFile: "tree-sitter-rust.wasm",
+    wasmPackage: "tree-sitter-rust",
+    grammarRepo: "https://github.com/tree-sitter/tree-sitter-rust",
+    grammarCommit: "",
+    treeSitterCliVersion: "",
+    externalScanner: false,
+    commentTypes: ["line_comment", "block_comment"],
+    commentDelimiters: ["//", "/*"]
+  },
+  java: {
+    id: "java",
+    extensions: [".java"],
+    wasmFile: "tree-sitter-java.wasm",
+    wasmPackage: "tree-sitter-java",
+    grammarRepo: "https://github.com/tree-sitter/tree-sitter-java",
+    grammarCommit: "",
+    treeSitterCliVersion: "",
+    externalScanner: false,
+    commentTypes: ["line_comment", "block_comment"],
+    commentDelimiters: ["//", "/*"]
+  },
+  csharp: {
+    id: "csharp",
+    extensions: [".cs"],
+    wasmFile: "tree-sitter-c_sharp.wasm",
+    wasmPackage: "tree-sitter-c-sharp",
+    grammarRepo: "https://github.com/tree-sitter/tree-sitter-c-sharp",
+    grammarCommit: "",
+    treeSitterCliVersion: "",
+    externalScanner: false,
+    commentTypes: ["comment"],
+    commentDelimiters: ["//", "/*"]
+  },
+  c: {
+    id: "c",
+    extensions: [".c", ".h"],
+    wasmFile: "tree-sitter-c.wasm",
+    wasmPackage: "tree-sitter-c",
+    grammarRepo: "https://github.com/tree-sitter/tree-sitter-c",
+    grammarCommit: "",
+    treeSitterCliVersion: "",
+    externalScanner: false,
+    commentTypes: ["comment"],
+    commentDelimiters: ["//", "/*"]
+  },
+  cpp: {
+    id: "cpp",
+    extensions: [".cpp", ".cc", ".cxx", ".hpp", ".hh", ".hxx"],
+    wasmFile: "tree-sitter-cpp.wasm",
+    wasmPackage: "tree-sitter-cpp",
+    grammarRepo: "https://github.com/tree-sitter/tree-sitter-cpp",
+    grammarCommit: "",
+    treeSitterCliVersion: "",
+    externalScanner: false,
+    commentTypes: ["comment"],
+    commentDelimiters: ["//", "/*"]
+  },
+  php: {
+    id: "php",
+    extensions: [".php"],
+    wasmFile: "tree-sitter-php_only.wasm",
+    wasmPackage: "tree-sitter-php",
+    grammarRepo: "https://github.com/tree-sitter/tree-sitter-php",
+    grammarCommit: "",
+    treeSitterCliVersion: "",
+    externalScanner: false,
+    commentTypes: ["comment"],
+    commentDelimiters: ["//", "#", "/*"]
+  },
+  ruby: {
+    id: "ruby",
+    extensions: [".rb"],
+    wasmFile: "tree-sitter-ruby.wasm",
+    wasmPackage: "tree-sitter-ruby",
+    grammarRepo: "https://github.com/tree-sitter/tree-sitter-ruby",
+    grammarCommit: "",
+    treeSitterCliVersion: "",
+    externalScanner: false,
+    commentTypes: ["comment"],
+    commentDelimiters: ["#"]
+  },
+  json: {
+    id: "json",
+    extensions: [".json"],
+    wasmFile: "tree-sitter-json.wasm",
+    wasmPackage: "tree-sitter-json",
+    grammarRepo: "https://github.com/tree-sitter/tree-sitter-json",
+    grammarCommit: "",
+    treeSitterCliVersion: "",
+    externalScanner: false,
+    commentTypes: [],
+    commentDelimiters: []
+  },
+  kotlin: {
+    id: "kotlin",
+    extensions: [".kt", ".kts"],
+    wasmFile: "tree-sitter-kotlin.wasm",
+    wasmPackage: "@tree-sitter-grammars/tree-sitter-kotlin",
+    grammarRepo: "https://github.com/tree-sitter-grammars/tree-sitter-kotlin",
+    grammarCommit: "",
+    treeSitterCliVersion: "",
+    externalScanner: false,
+    commentTypes: ["line_comment", "block_comment"],
+    commentDelimiters: ["//", "/*"]
+  },
+  yaml: {
+    id: "yaml",
+    extensions: [".yaml", ".yml"],
+    wasmFile: "tree-sitter-yaml.wasm",
+    wasmPackage: "@tree-sitter-grammars/tree-sitter-yaml",
+    grammarRepo: "https://github.com/tree-sitter-grammars/tree-sitter-yaml",
+    grammarCommit: "",
+    treeSitterCliVersion: "",
+    externalScanner: false,
+    commentTypes: ["comment"],
+    commentDelimiters: ["#"]
+  },
+  toml: {
+    id: "toml",
+    extensions: [".toml"],
+    wasmFile: "tree-sitter-toml.wasm",
+    wasmPackage: "@tree-sitter-grammars/tree-sitter-toml",
+    grammarRepo: "https://github.com/tree-sitter-grammars/tree-sitter-toml",
+    grammarCommit: "",
+    treeSitterCliVersion: "",
+    externalScanner: false,
+    commentTypes: ["comment"],
+    commentDelimiters: ["#"]
+  }
+};
+var EXTENSION_TO_LANGUAGE = Object.fromEntries(
+  Object.values(LANGUAGES).flatMap((def) => def.extensions.map((ext) => [ext, def.id]))
+);
+function getLanguageForExtension(ext, overrides) {
+  if (overrides && ext in overrides) return overrides[ext];
+  return EXTENSION_TO_LANGUAGE[ext] ?? null;
+}
+function getGrammarForExtension(ext) {
+  const lang = getLanguageForExtension(ext.toLowerCase());
+  if (lang === null) return null;
+  const def = LANGUAGES[lang];
+  if (!def) return null;
+  return { wasmFile: def.wasmFile, wasmPackage: def.wasmPackage };
+}
+
+// src/ast/parser.ts
+var _require = createRequire(import.meta.url);
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path4.dirname(__filename2);
+var GRAMMAR_DIRS = [
+  path4.resolve(__dirname2, "grammars"),
+  path4.resolve(__dirname2, "..", "grammars")
+];
+var initialized = false;
+var langCache = /* @__PURE__ */ new Map();
+async function init() {
+  if (initialized) return;
+  await Parser.init();
+  initialized = true;
+}
+function resolveWasm(filename, pkg) {
+  for (const dir of GRAMMAR_DIRS) {
+    const p = path4.join(dir, filename);
+    if (existsSync3(p)) return p;
+  }
+  try {
+    const pkgDir = path4.dirname(_require.resolve(`${pkg}/package.json`));
+    for (const candidate of [path4.join(pkgDir, filename), path4.join(pkgDir, "bindings/node", filename)]) {
+      if (existsSync3(candidate)) return candidate;
+    }
+  } catch {
+  }
+  throw new Error(`Could not find WASM grammar ${filename} in dist/grammars/ or in the ${pkg} package.`);
+}
+async function getParser(extension) {
+  await init();
+  const info = getGrammarForExtension(extension);
+  if (!info) {
+    throw new Error(`no parser for extension '${extension}'`);
+  }
+  const cacheKey = info.wasmFile;
+  let lang = langCache.get(cacheKey);
+  if (!lang) {
+    const wasmPath = resolveWasm(info.wasmFile, info.wasmPackage);
+    lang = await Language.load(wasmPath);
+    langCache.set(cacheKey, lang);
+  }
+  const parser = new Parser();
+  parser.setLanguage(lang);
+  return parser;
+}
+async function parseFile(filePath, content) {
+  const ext = path4.extname(filePath);
+  const parser = await getParser(ext);
+  const tree = parser.parse(content);
+  if (tree === null) {
+    throw new Error(`tree-sitter failed to parse file: ${filePath}`);
+  }
+  return tree;
+}
+
+// src/structure/ctx-parsers.ts
+var ParseAstNotPrewarmedError = class extends Error {
+  constructor(filePath) {
+    super(
+      `structure-aspect-parseast-not-prewarmed: ${filePath}. The dispatcher did not prewarm this file. Either (i) add a declared relation to the node owning this file, or (ii) use ctx.parseYaml/Json/Toml if AST is not required.`
+    );
+    this.filePath = filePath;
+    this.name = "ParseAstNotPrewarmedError";
+  }
+};
+function createCtxParsers(params) {
+  const { allowedSet, projectRoot, touchedFiles, astCache } = params;
+  function asFile(input) {
+    if (typeof input !== "string") {
+      touchedFiles.push(input.path);
+      return input;
+    }
+    const p = resolveAllowedReadPath(input, allowedSet, projectRoot);
+    const abs = path5.resolve(projectRoot, p);
+    const content = fs3.readFileSync(abs, "utf8");
+    touchedFiles.push(p);
+    return { path: p, content };
+  }
+  return {
+    parseAst(file, language) {
+      void language;
+      const f = asFile(file);
+      const cached = astCache.get(f.path);
+      if (cached && cached.content === f.content) return cached.ast;
+      throw new ParseAstNotPrewarmedError(f.path);
+    },
+    parseYaml(file) {
+      return parseYaml(asFile(file).content);
+    },
+    parseJson(file) {
+      return JSON.parse(asFile(file).content);
+    },
+    parseToml(file) {
+      return parseTomlSmol(asFile(file).content);
+    }
+  };
+}
+async function prewarmupAstCache(params) {
+  const { astCache, files } = params;
+  for (const f of files) {
+    if (!isAstLanguageExtension(f.path)) continue;
+    const existing = astCache.get(f.path);
+    if (existing && existing.content === f.content) continue;
+    const tree = await parseFile(f.path, f.content);
+    astCache.set(f.path, { content: f.content, ast: tree });
+  }
+}
+function isAstLanguageExtension(p) {
+  return getLanguageForExtension(extname(p).toLowerCase()) !== null;
+}
+function enrichFilesWithAst(files, astCache) {
+  return files.map((f) => {
+    const language = getLanguageForExtension(extname(f.path)) ?? void 0;
+    const cached = astCache.get(f.path);
+    const ast = cached && cached.content === f.content ? cached.ast : void 0;
+    return { ...f, ast, language };
+  });
+}
+
+// src/structure/allowed-reads.ts
+function collectAllowedReadsForAspect(nodePath, graph) {
+  const allowed = /* @__PURE__ */ new Set();
+  const node = graph.nodes.get(nodePath);
+  if (!node) return allowed;
+  const addMapping = (n) => {
+    const mapping = n.meta.mapping ?? [];
+    for (const raw of mapping) {
+      const p = normalizeMappingPath(raw);
+      if (p) allowed.add(p);
+    }
+  };
+  const childPaths = /* @__PURE__ */ new Set();
+  for (const child of node.children) {
+    for (const raw of child.meta.mapping ?? []) {
+      const p = normalizeMappingPath(raw);
+      if (p) childPaths.add(p);
+    }
+  }
+  for (const raw of node.meta.mapping ?? []) {
+    const p = normalizeMappingPath(raw);
+    if (p && !childPaths.has(p)) allowed.add(p);
+  }
+  for (const rel of node.meta.relations ?? []) {
+    const target = graph.nodes.get(rel.target);
+    if (!target) continue;
+    addMapping(target);
+    const relStack = [...target.children];
+    while (relStack.length > 0) {
+      const n = relStack.pop();
+      addMapping(n);
+      relStack.push(...n.children);
+    }
+  }
+  let cursor = node.parent;
+  while (cursor) {
+    addMapping(cursor);
+    cursor = cursor.parent;
+  }
+  const parentDirs = /* @__PURE__ */ new Set();
+  for (const raw of node.meta.mapping ?? []) {
+    const p = normalizeMappingPath(raw);
+    if (p) {
+      const lastSlash = p.lastIndexOf("/");
+      if (lastSlash > 0) {
+        parentDirs.add(p.substring(0, lastSlash));
+      }
+    }
+  }
+  const siblingCarveOut = /* @__PURE__ */ new Set();
+  for (const cp of childPaths) {
+    const lastSlash = cp.lastIndexOf("/");
+    if (lastSlash > 0) {
+      const cpDir = cp.substring(0, lastSlash);
+      if (parentDirs.has(cpDir)) {
+        siblingCarveOut.add(cp);
+      }
+    }
+  }
+  const stack = [...node.children];
+  while (stack.length > 0) {
+    const n = stack.pop();
+    for (const raw of n.meta.mapping ?? []) {
+      const p = normalizeMappingPath(raw);
+      if (p && !siblingCarveOut.has(p)) allowed.add(p);
+    }
+    stack.push(...n.children);
+  }
+  return allowed;
+}
+
+// src/io/hash.ts
+import { readFile as readFile2, readdir as readdir2, stat } from "fs/promises";
+import path7 from "path";
+import { createHash } from "crypto";
+import { createRequire as createRequire3 } from "module";
+
+// src/io/repo-scanner.ts
+import { readFile, readdir } from "fs/promises";
+import { join, relative as relative2, sep } from "path";
+import { createRequire as createRequire2 } from "module";
+
+// src/utils/debug-log.ts
+import path6 from "path";
+
+// src/io/repo-scanner.ts
+var require2 = createRequire2(import.meta.url);
+var ignoreFactory = require2("ignore");
+
+// src/io/hash.ts
+var require3 = createRequire3(import.meta.url);
+var ignoreFactory2 = require3("ignore");
+async function loadRootGitignoreStack2(projectRoot) {
+  if (!projectRoot) return [];
+  try {
+    const content = await readFile2(path7.join(projectRoot, ".gitignore"), "utf-8");
+    const matcher = ignoreFactory2();
+    matcher.add(content);
+    return [{ basePath: projectRoot, matcher }];
+  } catch {
+    return [];
+  }
+}
+function isIgnoredByStack2(candidatePath, stack) {
+  for (const { basePath, matcher } of stack) {
+    const relativePath = toPosix(path7.relative(basePath, candidatePath));
+    if (relativePath === "" || relativePath.startsWith("..")) continue;
+    if (matcher.ignores(relativePath) || matcher.ignores(relativePath + "/")) return true;
+  }
+  return false;
+}
+function hashString(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+var EMPTY_IDENTITY = { ownSubset: hashString(""), ports: {}, aspects: {} };
+async function collectDirectoryFilePaths(directoryPath, rootDirectoryPath, options) {
+  let stack = options.gitignoreStack ?? [];
+  try {
+    const localContent = await readFile2(path7.join(directoryPath, ".gitignore"), "utf-8");
+    const localMatcher = ignoreFactory2();
+    localMatcher.add(localContent);
+    stack = [...stack, { basePath: directoryPath, matcher: localMatcher }];
+  } catch {
+  }
+  const entries = await readdir2(directoryPath, { withFileTypes: true });
+  const dirs = [];
+  const files = [];
+  for (const entry of entries) {
+    const absoluteChildPath = path7.join(directoryPath, entry.name);
+    if (isIgnoredByStack2(absoluteChildPath, stack)) continue;
+    if (entry.isDirectory()) dirs.push(absoluteChildPath);
+    else if (entry.isFile()) files.push(absoluteChildPath);
+  }
+  const [dirResults, fileStats] = await Promise.all([
+    Promise.all(dirs.map((d) => collectDirectoryFilePaths(d, rootDirectoryPath, {
+      projectRoot: options.projectRoot,
+      gitignoreStack: stack
+    }))),
+    Promise.all(files.map(async (f) => {
+      const fileStat = await stat(f);
+      return {
+        relPath: toPosixPath(path7.relative(rootDirectoryPath, f)),
+        absPath: f,
+        mtimeMs: fileStat.mtimeMs
+      };
+    }))
+  ]);
+  const result = [];
+  for (const nested of dirResults) result.push(...nested);
+  result.push(...fileStats);
+  return result;
+}
+async function expandMappingPaths(projectRoot, mappingPaths) {
+  const gitignoreStack = await loadRootGitignoreStack2(projectRoot);
+  const result = [];
+  for (const mp of mappingPaths) {
+    const absPath = path7.join(projectRoot, mp);
+    try {
+      const st = await stat(absPath);
+      if (st.isDirectory()) {
+        const dirEntries = await collectDirectoryFilePaths(absPath, absPath, {
+          projectRoot,
+          gitignoreStack
+        });
+        for (const entry of dirEntries) {
+          result.push(toPosixPath(path7.join(mp, entry.relPath)));
+        }
+      } else {
+        result.push(toPosixPath(mp));
+      }
+    } catch {
+      continue;
+    }
+  }
+  return result;
+}
+
+// src/ast/suppress.ts
+import { extname as extname3 } from "path";
+
+// src/ast/find-comments.ts
+import { extname as extname2 } from "path";
+function findComments(target) {
+  const hasAst = "ast" in target;
+  const hasRootNode = "rootNode" in target;
+  if (hasAst && hasRootNode) {
+    throw new Error("AST_FINDCOMMENTS_AMBIGUOUS_TARGET: pass either ast or rootNode, not both");
+  }
+  let language = "language" in target ? target.language : void 0;
+  if (language === void 0 && "path" in target) {
+    language = getLanguageForExtension(extname2(target.path)) ?? void 0;
+  }
+  if (language === void 0) {
+    throw new Error(
+      "AST_FINDCOMMENTS_NO_LANGUAGE: pass a SourceFile whose path has a known extension, or an explicit { language }"
+    );
+  }
+  const def = LANGUAGES[language];
+  if (def === void 0) {
+    throw new Error(`AST_FINDCOMMENTS_UNKNOWN_LANGUAGE: '${language}' not in registry`);
+  }
+  const root = hasAst ? target.ast.rootNode : target.rootNode;
+  const out = [];
+  for (const type of def.commentTypes) {
+    out.push(...root.descendantsOfType(type));
+  }
+  return out;
+}
+
+// src/ast/suppress.ts
+var SuppressMarkerError = class extends Error {
+  constructor(message, file, line) {
+    super(message);
+    this.file = file;
+    this.line = line;
+    this.name = "SuppressMarkerError";
+  }
+  code = "SUPPRESS_MARKER_MISSING_REASON";
+};
+var RE_SINGLE = /\byg-suppress\(\s*([^)]+?)\s*\)\s*(.+)?$/;
+var RE_DISABLE = /\byg-suppress-disable\(\s*([^)]+?)\s*\)\s*(.+)?$/;
+var RE_ENABLE = /\byg-suppress-enable\(\s*([^)]+?)\s*\)/;
+function commentBody(text) {
+  if (text.startsWith("//")) return text.slice(2).trim();
+  if (text.startsWith("/*")) return text.replace(/^\/\*+/, "").replace(/\*+\/$/, "").trim();
+  return text.trim();
+}
+function splitAspectList(raw) {
+  return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function makeMarker(kind, match, line, file) {
+  const aspectIds = splitAspectList(match[1]);
+  const reason = (match[2] ?? "").trim();
+  if (reason === "") {
+    throw new SuppressMarkerError(
+      `yg-suppress${kind === "disable" ? "-disable" : ""}(${match[1]}) missing reason at ${file}:${line}`,
+      file,
+      line
+    );
+  }
+  return { kind, aspectIds, reason, line };
+}
+function parseMarker(commentText, line, file) {
+  const body = commentBody(commentText);
+  let m = body.match(RE_DISABLE);
+  if (m) return makeMarker("disable", m, line, file);
+  m = body.match(RE_ENABLE);
+  if (m) {
+    return { kind: "enable", aspectIds: splitAspectList(m[1]), reason: "", line };
+  }
+  m = body.match(RE_SINGLE);
+  if (m) return makeMarker("single", m, line, file);
+  return null;
+}
+function collectSuppressions(tree, file, totalLines) {
+  if (getLanguageForExtension(extname3(file)) === null) {
+    return [];
+  }
+  const comments = findComments({ path: file, ast: tree });
+  const markers = [];
+  for (const c of comments) {
+    const m = parseMarker(c.text, c.startPosition.row + 1, file);
+    if (m) markers.push(m);
+  }
+  markers.sort((a, b) => a.line - b.line);
+  const ranges = [];
+  const openSpecific = /* @__PURE__ */ new Map();
+  let openWildcard = null;
+  for (const m of markers) {
+    if (m.kind === "single") {
+      const isWildcard = m.aspectIds.includes("*");
+      ranges.push({ aspectIds: new Set(m.aspectIds), startLine: m.line + 1, endLine: m.line + 1, isWildcard });
+    } else if (m.kind === "disable") {
+      for (const id of m.aspectIds) {
+        if (id === "*") {
+          if (openWildcard === null) openWildcard = m.line + 1;
+        } else {
+          if (!openSpecific.has(id)) openSpecific.set(id, m.line + 1);
+        }
+      }
+    } else {
+      for (const id of m.aspectIds) {
+        if (id === "*") {
+          if (openWildcard !== null) {
+            ranges.push({ aspectIds: /* @__PURE__ */ new Set(["*"]), startLine: openWildcard, endLine: m.line - 1, isWildcard: true });
+            openWildcard = null;
+          }
+        } else {
+          const start = openSpecific.get(id);
+          if (start !== void 0) {
+            ranges.push({ aspectIds: /* @__PURE__ */ new Set([id]), startLine: start, endLine: m.line - 1, isWildcard: false });
+            openSpecific.delete(id);
+          }
+        }
+      }
+    }
+  }
+  if (openWildcard !== null) ranges.push({ aspectIds: /* @__PURE__ */ new Set(["*"]), startLine: openWildcard, endLine: totalLines, isWildcard: true });
+  for (const [id, start] of openSpecific) {
+    ranges.push({ aspectIds: /* @__PURE__ */ new Set([id]), startLine: start, endLine: totalLines, isWildcard: false });
+  }
+  return ranges;
+}
+function isLineSuppressed(ranges, aspectId, line) {
+  return ranges.some((r) => {
+    if (line < r.startLine || line > r.endLine) return false;
+    return r.isWildcard || r.aspectIds.has(aspectId);
+  });
+}
+
+// src/utils/validate-check-module.ts
+function validateCheckModuleExport(mod, opts) {
+  const { codePrefix, runnerLabel } = opts;
+  if (mod.check === void 0) {
+    const defaultExport = mod.default;
+    if (typeof defaultExport === "function" && defaultExport.name === "check") {
+      return {
+        ok: false,
+        code: `${codePrefix}_CHECK_DEFAULT_EXPORT`,
+        message: {
+          what: `check.mjs exports 'check' as default, but a NAMED export is required (${runnerLabel}).`,
+          why: `The runner imports the named export. A default export is invisible to it.`,
+          next: `Change 'export default function check(...)' to 'export function check(...)'.`
+        }
+      };
+    }
+    return {
+      ok: false,
+      code: `${codePrefix}_CHECK_NOT_EXPORTED`,
+      message: {
+        what: `check.mjs does not export a function named 'check' (${runnerLabel}).`,
+        why: `The runner expects 'export function check(ctx) { ... }'.`,
+        next: `Add a named export 'check' in check.mjs.`
+      }
+    };
+  }
+  if (typeof mod.check !== "function") {
+    return {
+      ok: false,
+      code: `${codePrefix}_CHECK_NOT_FUNCTION`,
+      message: {
+        what: `'check' is exported but is not a function (got ${typeof mod.check}).`,
+        why: `The runner calls check(ctx).`,
+        next: `Re-export check as a function.`
+      }
+    };
+  }
+  const checkFn = mod.check;
+  if (checkFn.length !== 1) {
+    return {
+      ok: false,
+      code: `${codePrefix}_CHECK_WRONG_ARITY`,
+      message: {
+        what: `'check' must accept exactly 1 parameter (ctx); declared arity is ${checkFn.length}.`,
+        why: `The runner invokes check(ctx).`,
+        next: `Change the signature to function check(ctx).`
+      }
+    };
+  }
+  return { ok: true };
+}
+
+// src/structure/runner.ts
+var StructureRunnerError = class extends Error {
+  constructor(code, data) {
+    super(`${code}: ${data.what}
+${data.why}
+${data.next}`);
+    this.code = code;
+    this.messageData = data;
+    this.name = "StructureRunnerError";
+  }
+  messageData;
+};
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".gif",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".webp",
+  ".bmp",
+  ".ico",
+  ".svgz",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".zip",
+  ".gz",
+  ".tgz",
+  ".tar",
+  ".bz2",
+  ".7z",
+  ".pdf",
+  ".mp4",
+  ".mov",
+  ".webm",
+  ".mp3",
+  ".wav",
+  ".wasm",
+  ".bin"
+]);
+async function buildOwnFiles(node, projectRoot, touchedFiles) {
+  const childMappingEntries = [];
+  for (const child of node.children) {
+    for (const raw of child.meta.mapping ?? []) {
+      const p = normalizeMappingPath(raw);
+      if (p) childMappingEntries.push(p);
+    }
+  }
+  const rawMapping = (node.meta.mapping ?? []).map(normalizeMappingPath).filter((p) => p !== "");
+  const expanded = await expandMappingPaths(projectRoot, rawMapping);
+  const result = [];
+  for (const p of expanded) {
+    if (childMappingEntries.length > 0 && isPathInMapping(p, childMappingEntries)) continue;
+    if (BINARY_EXTENSIONS.has(path8.extname(p).toLowerCase())) continue;
+    const abs = path8.resolve(projectRoot, p);
+    let content;
+    try {
+      content = fs4.readFileSync(abs, "utf8");
+    } catch {
+      continue;
+    }
+    result.push({ path: p, content });
+    touchedFiles.push(p);
+  }
+  return result;
+}
+async function enumerateMappedFilesAsync(mappingPaths, projectRoot) {
+  const normalized = mappingPaths.map(normalizeMappingPath).filter((p) => p !== "");
+  return expandMappingPaths(projectRoot, normalized);
+}
+async function runStructureAspect(params) {
+  ensureLoaderRegistered();
+  const { aspectDir, aspectId, nodePath, graph, projectRoot } = params;
+  const astCache = params.parseCache ?? /* @__PURE__ */ new Map();
+  const touchedFiles = [];
+  const node = graph.nodes.get(nodePath);
+  if (!node) {
+    throw new StructureRunnerError("STRUCTURE_NODE_MISSING", {
+      what: `Node '${nodePath}' not in graph.`,
+      why: `The runner resolves the node by path to load its mapped files and aspects.`,
+      next: `Pass an existing node path, or add the node to the graph.`
+    });
+  }
+  const aspectDirAbs = path8.isAbsolute(aspectDir) ? aspectDir : path8.resolve(projectRoot, aspectDir);
+  const checkPath = path8.join(aspectDirAbs, "check.mjs");
+  let mod;
+  try {
+    mod = await import(pathToFileURL2(checkPath).href);
+  } catch (err) {
+    throw new StructureRunnerError("STRUCTURE_LOADER_RESOLVE_FAILED", {
+      what: `Failed to load check.mjs at ${checkPath}: ${err.message}`,
+      why: `The runner dynamically imports the aspect's check.mjs before invoking it.`,
+      next: `Ensure check.mjs exists at the aspect directory and has no unresolved imports.`
+    });
+  }
+  const exportCheck = validateCheckModuleExport(mod, {
+    codePrefix: "STRUCTURE",
+    runnerLabel: `aspect '${aspectId}'`
+  });
+  if (!exportCheck.ok) {
+    throw new StructureRunnerError(exportCheck.code, exportCheck.message);
+  }
+  const checkFn = mod.check;
+  const allowedSet = collectAllowedReadsForAspect(nodePath, graph);
+  const ctxFs = createCtxFs({ allowedSet, projectRoot, touchedFiles });
+  const ctxGraph = createCtxGraph({ currentNodePath: nodePath, graph, projectRoot, touchedFiles });
+  const parsers = createCtxParsers({ allowedSet, projectRoot, touchedFiles, astCache });
+  const ownFiles = await buildOwnFiles(node, projectRoot, touchedFiles);
+  await prewarmupAstCache({ astCache, projectRoot, files: ownFiles });
+  const ownFilesEnriched = enrichFilesWithAst(ownFiles, astCache);
+  const ctx = {
+    node: {
+      id: node.path,
+      type: node.meta.type,
+      mapping: node.meta.mapping ?? [],
+      files: ownFilesEnriched,
+      ports: node.meta.ports ?? {}
+    },
+    files: ownFilesEnriched,
+    fs: ctxFs,
+    graph: ctxGraph,
+    parseAst: parsers.parseAst,
+    parseYaml: parsers.parseYaml,
+    parseJson: parsers.parseJson,
+    parseToml: parsers.parseToml
+  };
+  const astInputSet = [...ownFiles];
+  for (const rel of node.meta.relations ?? []) {
+    const target = graph.nodes.get(rel.target);
+    if (!target) continue;
+    for (const p of await enumerateMappedFilesAsync(target.meta.mapping ?? [], projectRoot)) {
+      const abs = path8.resolve(projectRoot, p);
+      try {
+        const content = fs4.readFileSync(abs, "utf8");
+        astInputSet.push({ path: p, content });
+      } catch {
+      }
+    }
+  }
+  await prewarmupAstCache({ astCache, projectRoot, files: astInputSet });
+  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
+      };
+    }
+    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
+      };
+    }
+    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
+      };
+    }
+    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 and re-run yg 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") {
+      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);
+  }
+  const rangesByFile = /* @__PURE__ */ new Map();
+  function rangesFor(filePath) {
+    const existing = rangesByFile.get(filePath);
+    if (existing !== void 0) return existing;
+    const cached = astCache.get(filePath);
+    const ranges = cached ? collectSuppressions(cached.ast, filePath, cached.content.split("\n").length) : null;
+    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 };
+}
+
+// src/ast/walk.ts
+function walk(node, visitor) {
+  const result = visitor(node);
+  if (result === false) return;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child !== null) walk(child, visitor);
+  }
+}
+function closest(node, types) {
+  const typeSet = typeof types === "string" ? /* @__PURE__ */ new Set([types]) : new Set(types);
+  let cur = node.parent;
+  while (cur !== null) {
+    if (typeSet.has(cur.type)) return cur;
+    cur = cur.parent;
+  }
+  return null;
+}
+
+// src/ast/report.ts
+function report(file, node, message) {
+  return {
+    file: file.path,
+    line: node.startPosition.row + 1,
+    column: node.startPosition.column,
+    message
+  };
+}
+
+// src/ast/file-path.ts
+import { minimatch } from "minimatch";
+function inFile(file, pattern) {
+  if ("glob" in pattern) return minimatch(file.path, pattern.glob);
+  if ("regex" in pattern) return pattern.regex.test(file.path);
+  if ("contains" in pattern) return file.path.includes(pattern.contains);
+  return false;
+}
+export {
+  StructureRunnerError,
+  closest,
+  findComments,
+  inFile,
+  report,
+  runStructureAspect,
+  walk
+};
+//# sourceMappingURL=structure.js.map