@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.2

package/dist/chunk-GQ4N4WKF.js

@@ -0,0 +1,1142 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  parseRecord
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/sdk/dist/parse-cache.js
+import { createHash } from "node:crypto";
+var DEFAULT_PARSE_CACHE_LIMITS = {
+  maxChars: 8e6,
+  maxEntries: 2e4,
+  maxNativeChars: 1e6,
+  maxNativeEntries: 2e3,
+  maxTextChars: 16e6
+};
+function refuse() {
+  throw new TypeError("a parsed value is shared by every reader and can't be changed; copy it");
+}
+function deepFreeze(value) {
+  const stack = [value];
+  const seen = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const v = stack.pop();
+    if (v === null || typeof v !== "object" || seen.has(v))
+      continue;
+    seen.add(v);
+    if (ArrayBuffer.isView(v) || v instanceof ArrayBuffer)
+      continue;
+    if (v instanceof Map) {
+      for (const [k, x] of v)
+        stack.push(k, x);
+      for (const m of ["set", "delete", "clear"])
+        Object.defineProperty(v, m, { value: refuse });
+    } else if (v instanceof Set) {
+      for (const x of v)
+        stack.push(x);
+      for (const m of ["add", "delete", "clear"])
+        Object.defineProperty(v, m, { value: refuse });
+    }
+    for (const k of Object.keys(v))
+      stack.push(v[k]);
+    Object.freeze(v);
+  }
+  return value;
+}
+var hash = (text) => createHash("sha1").update(text).digest("base64");
+function createParseCache(limits = {}) {
+  const l = { ...DEFAULT_PARSE_CACHE_LIMITS, ...limits };
+  const values = { map: /* @__PURE__ */ new Map(), chars: 0, maxChars: l.maxChars, maxEntries: l.maxEntries };
+  const native = {
+    map: /* @__PURE__ */ new Map(),
+    chars: 0,
+    maxChars: l.maxNativeChars,
+    maxEntries: l.maxNativeEntries
+  };
+  const texts = /* @__PURE__ */ new Map();
+  const reading = /* @__PURE__ */ new Map();
+  let textChars = 0;
+  let disposed = false;
+  const st = { hits: 0, misses: 0, evictions: 0, textHits: 0, textReads: 0 };
+  const byKind = {};
+  const count = (kind, hit) => {
+    const k = byKind[kind] ??= { hits: 0, misses: 0 };
+    if (hit) {
+      k.hits++;
+      st.hits++;
+    } else {
+      k.misses++;
+      st.misses++;
+    }
+  };
+  const free = (e) => {
+    if (e.done && e.dispose)
+      e.dispose(e.value);
+  };
+  const remove = (e) => {
+    if (e.pool.map.get(e.key) !== e)
+      return;
+    e.pool.map.delete(e.key);
+    e.pool.chars -= e.weight;
+    e.gone = true;
+    if (e.pins === 0)
+      free(e);
+  };
+  const trim = (pool) => {
+    if (pool.chars <= pool.maxChars && pool.map.size <= pool.maxEntries)
+      return;
+    for (const e of [...pool.map.values()]) {
+      if (pool.chars <= pool.maxChars && pool.map.size <= pool.maxEntries)
+        break;
+      if (e.pins > 0 || !e.done)
+        continue;
+      remove(e);
+      st.evictions++;
+    }
+  };
+  const touch = (e) => {
+    e.pool.map.delete(e.key);
+    e.pool.map.set(e.key, e);
+  };
+  const entry = (kind, path, text, o) => {
+    const pool = o.pool === "native" ? native : values;
+    const key = `${kind}\0${path}\0${text.length}\0${hash(text)}`;
+    const found = pool.map.get(key);
+    if (found && found.text === text) {
+      touch(found);
+      count(kind, true);
+      return { e: found, hit: true };
+    }
+    if (found)
+      remove(found);
+    count(kind, false);
+    const e = {
+      key,
+      text,
+      weight: o.weight ?? text.length,
+      pool,
+      done: false,
+      pins: 0,
+      gone: false,
+      ...o.dispose ? { dispose: o.dispose } : {}
+    };
+    if (!disposed && pool.maxChars > 0 && pool.maxEntries > 0 && e.weight <= pool.maxChars) {
+      pool.map.set(key, e);
+      pool.chars += e.weight;
+    } else
+      e.gone = true;
+    return { e, hit: false };
+  };
+  const settle = (e, value, freeze) => {
+    e.value = freeze ? deepFreeze(value) : value;
+    e.done = true;
+    delete e.pending;
+  };
+  const fail = (e) => {
+    if (e.pool.map.get(e.key) === e) {
+      e.pool.map.delete(e.key);
+      e.pool.chars -= e.weight;
+    }
+    e.gone = true;
+  };
+  const valueOf = async (e, hit, parse, o) => {
+    if (hit)
+      return e.done ? e.value : await e.pending;
+    const p = (async () => parse(e.text))();
+    e.pending = p;
+    try {
+      const v = await p;
+      settle(e, v, o.freeze !== false);
+      return e.value;
+    } catch (err) {
+      fail(e);
+      throw err;
+    }
+  };
+  return {
+    get(kind, path, text, parse, o = {}) {
+      const { e, hit } = entry(kind, path, text, o);
+      if (hit && e.done)
+        return e.value;
+      if (hit)
+        throw new Error(`${kind} of ${path} is being parsed asynchronously; use getAsync`);
+      let v;
+      try {
+        v = parse(text);
+      } catch (err) {
+        fail(e);
+        throw err;
+      }
+      settle(e, v, o.freeze !== false);
+      trim(e.pool);
+      return e.value;
+    },
+    async getAsync(kind, path, text, parse, o = {}) {
+      const { e, hit } = entry(kind, path, text, o);
+      const v = await valueOf(e, hit, parse, o);
+      trim(e.pool);
+      return v;
+    },
+    async use(kind, path, text, parse, use, o = {}) {
+      const { e, hit } = entry(kind, path, text, o);
+      e.pins++;
+      try {
+        const v = await valueOf(e, hit, parse, o);
+        return await use(v);
+      } finally {
+        e.pins--;
+        if (e.pins === 0 && e.gone)
+          free(e);
+        else
+          trim(e.pool);
+      }
+    },
+    async text(path, read) {
+      const t = texts.get(path);
+      if (t !== void 0) {
+        st.textHits++;
+        texts.delete(path);
+        texts.set(path, t);
+        return t;
+      }
+      const inFlight = reading.get(path);
+      if (inFlight) {
+        st.textHits++;
+        return inFlight;
+      }
+      st.textReads++;
+      const p = read();
+      reading.set(path, p);
+      let text;
+      try {
+        text = await p;
+      } finally {
+        reading.delete(path);
+      }
+      if (disposed || l.maxTextChars <= 0 || text.length > l.maxTextChars)
+        return text;
+      texts.set(path, text);
+      textChars += text.length;
+      for (const [p2, x] of texts) {
+        if (textChars <= l.maxTextChars)
+          break;
+        texts.delete(p2);
+        textChars -= x.length;
+      }
+      return text;
+    },
+    stats() {
+      return {
+        ...st,
+        entries: values.map.size,
+        chars: values.chars,
+        nativeEntries: native.map.size,
+        nativeChars: native.chars,
+        texts: texts.size,
+        byKind: structuredClone(byKind)
+      };
+    },
+    dispose() {
+      disposed = true;
+      for (const pool of [values, native])
+        for (const e of [...pool.map.values()])
+          remove(e);
+      texts.clear();
+      textChars = 0;
+    }
+  };
+}
+function withParseCache(repo, cache) {
+  const wrapped = Object.create(repo);
+  Object.defineProperties(wrapped, {
+    parseCache: { value: cache, enumerable: true },
+    readText: { value: (path) => cache.text(path, () => repo.readText(path)) }
+  });
+  return wrapped;
+}
+
+// packages/sdk/dist/plugin.js
+function defineExtractor(extractor) {
+  if (!/^[a-z][a-z0-9-]*$/.test(extractor.id)) {
+    throw new Error(`extractor id "${extractor.id}" must be a lowercase slug`);
+  }
+  if (!/^\d+\.\d+\.\d+(-[0-9a-z.-]+)?$/i.test(extractor.version)) {
+    throw new Error(`extractor version "${extractor.version}" must be semver`);
+  }
+  if (extractor.claims.length === 0) {
+    throw new Error(`extractor "${extractor.id}" must claim at least one file glob`);
+  }
+  return extractor;
+}
+async function runExtractor(extractor, repo, options = {}) {
+  const out = { records: [], rejected: [], warnings: [] };
+  const ctx = {
+    dialects: options.dialects ?? [],
+    scannedAt: options.scannedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    warn: (message, path) => out.warnings.push(path ? { message, path } : { message })
+  };
+  const own = repo.parseCache ? void 0 : createParseCache();
+  const r = own ? withParseCache(repo, own) : repo;
+  try {
+    for await (const emitted of extractor.scan(r, ctx)) {
+      const result = parseRecord(emitted);
+      if (result.ok)
+        out.records.push(result.record);
+      else
+        out.rejected.push({ record: emitted, issues: result.issues });
+    }
+  } finally {
+    own?.dispose();
+  }
+  return out;
+}
+function memoryRepo(name, commit, files) {
+  const paths = Object.keys(files).sort();
+  return {
+    name,
+    commit,
+    async *listFiles(globs) {
+      const matchers = globs.map(globToRegExp);
+      for (const p of paths)
+        if (matchers.some((m) => m.test(p)))
+          yield p;
+    },
+    async readText(path) {
+      const text = files[path];
+      if (text === void 0)
+        throw new Error(`no such file: ${path}`);
+      return text;
+    }
+  };
+}
+function globToRegExp(glob) {
+  let re = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        const slash = glob[i + 2] === "/";
+        re += slash ? "(?:.*/)?" : ".*";
+        i += slash ? 2 : 1;
+      } else
+        re += "[^/]*";
+    } else if (c === "?")
+      re += "[^/]";
+    else
+      re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(`^${re}$`);
+}
+
+// packages/sdk/dist/fs-repo.js
+import { lstat, readdir, readFile, realpath, stat } from "node:fs/promises";
+import { join, relative, resolve, sep } from "node:path";
+var DEFAULT_IGNORES = [
+  ".git",
+  "node_modules",
+  "target",
+  "build",
+  "dist",
+  "out",
+  ".gradle",
+  ".idea",
+  ".vscode",
+  "__pycache__",
+  ".venv"
+];
+function tooLargeMessage(bytes, maxBytes) {
+  const mb = maxBytes / 1024 / 1024;
+  return `left out: ${bytes} bytes is over the ${Number.isInteger(mb) ? `${mb} MB` : `${maxBytes} bytes`} a file may be`;
+}
+var RepoReadError = class extends Error {
+  path;
+  constructor(message, path) {
+    super(message);
+    this.path = path;
+    this.name = "RepoReadError";
+  }
+};
+function fsRepo(name, dir, commit, options = {}) {
+  const root = resolve(dir);
+  const ignore = new Set(options.ignore ?? DEFAULT_IGNORES);
+  const maxBytes = options.maxFileBytes ?? 5 * 1024 * 1024;
+  let cache;
+  const sizes = /* @__PURE__ */ new Map();
+  const skipped = /* @__PURE__ */ new Map();
+  async function walk(abs, out) {
+    const entries = await readdir(abs, { withFileTypes: true });
+    for (const e of entries) {
+      if (e.isSymbolicLink())
+        continue;
+      const full = join(abs, e.name);
+      if (e.isDirectory()) {
+        if (!ignore.has(e.name))
+          await walk(full, out);
+      } else if (e.isFile()) {
+        out.push(relative(root, full).split(sep).join("/"));
+      }
+    }
+  }
+  async function allFiles() {
+    if (!cache) {
+      const out = [];
+      await walk(root, out);
+      cache = out.sort();
+    }
+    return cache;
+  }
+  async function safePath(path) {
+    if (path.startsWith("/") || /^[A-Za-z]:/.test(path) || path.includes("\\") || path.split("/").includes("..")) {
+      throw new RepoReadError(`path must be repo-relative with forward slashes: ${path}`, path);
+    }
+    const abs = join(root, ...path.split("/"));
+    const info = await lstat(abs).catch(() => void 0);
+    if (!info || !info.isFile())
+      throw new RepoReadError(`no such file: ${path}`, path);
+    if (info.isSymbolicLink())
+      throw new RepoReadError(`symbolic links are not read: ${path}`, path);
+    const real = await realpath(abs);
+    const realRoot = await realpath(root);
+    if (real !== realRoot && !real.startsWith(realRoot + sep)) {
+      throw new RepoReadError(`path leaves the repo: ${path}`, path);
+    }
+    if (info.size > maxBytes)
+      throw new RepoReadError(`file is larger than ${maxBytes} bytes: ${path}`, path);
+    return abs;
+  }
+  return {
+    name,
+    commit,
+    async *listFiles(globs) {
+      const matchers = globs.map(globToRegExp);
+      for (const p of await allFiles()) {
+        if (!matchers.some((m) => m.test(p)))
+          continue;
+        if (!sizes.has(p))
+          sizes.set(p, (await stat(join(root, ...p.split("/"))).catch(() => void 0))?.size ?? 0);
+        const bytes = sizes.get(p);
+        if (bytes > maxBytes) {
+          skipped.set(p, bytes);
+          continue;
+        }
+        yield p;
+      }
+    },
+    maxFileBytes: maxBytes,
+    skippedFiles() {
+      return [...skipped].sort(([a], [b]) => a < b ? -1 : 1).map(([path, bytes]) => ({ path, bytes }));
+    },
+    async readText(path) {
+      const text = await readFile(await safePath(path), "utf8");
+      return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+    }
+  };
+}
+
+// packages/sdk/dist/cache.js
+import { createHash as createHash2 } from "node:crypto";
+import { mkdir, readdir as readdir2, readFile as readFile2, rename, rm, writeFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var sha256 = (s) => createHash2("sha256").update(s).digest("hex");
+function cacheKeyHash(key) {
+  return sha256(JSON.stringify([
+    key.repo,
+    key.commit,
+    key.extractor,
+    key.version,
+    [...key.dialects].sort(),
+    key.config ?? ""
+  ]));
+}
+function configHash(parts) {
+  const sorted = Object.keys(parts).sort().map((k) => [k, parts[k]]);
+  return sha256(JSON.stringify(sorted)).slice(0, 16);
+}
+function memoryScanCache() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    async get(key) {
+      const v = map.get(cacheKeyHash(key));
+      return v ? JSON.parse(v) : void 0;
+    },
+    async put(key, value) {
+      map.set(cacheKeyHash(key), JSON.stringify(value));
+    },
+    size: () => map.size
+  };
+}
+var SAFE = /^[A-Za-z0-9._@-]+$/;
+function fsScanCache(dir) {
+  const fileFor = (key) => {
+    for (const part of [key.repo, key.commit, key.extractor, key.version]) {
+      if (!SAFE.test(part))
+        throw new Error(`unsafe cache key part: ${part}`);
+    }
+    const h = cacheKeyHash(key);
+    return {
+      h,
+      path: join2(dir, key.repo, key.commit, `${key.extractor}@${key.version}.${h.slice(0, 16)}.json`)
+    };
+  };
+  return {
+    async get(key) {
+      const { h, path } = fileFor(key);
+      let file;
+      try {
+        file = JSON.parse(await readFile2(path, "utf8"));
+      } catch {
+        return void 0;
+      }
+      if (file.format !== 1 || file.keyHash !== h)
+        return void 0;
+      if (sha256(JSON.stringify(file.value)) !== file.checksum)
+        return void 0;
+      const records = [];
+      for (const r of file.value.records) {
+        const parsed = parseRecord(r);
+        if (!parsed.ok)
+          return void 0;
+        records.push(parsed.record);
+      }
+      return { ...file.value, records };
+    },
+    async put(key, value) {
+      const { h, path } = fileFor(key);
+      const file = {
+        format: 1,
+        key,
+        keyHash: h,
+        checksum: sha256(JSON.stringify(value)),
+        value
+      };
+      await mkdir(join2(path, ".."), { recursive: true });
+      const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+      await writeFile(tmp, JSON.stringify(file), "utf8");
+      await rename(tmp, path);
+    },
+    async prune(repo, keepCommits) {
+      if (!SAFE.test(repo))
+        throw new Error(`unsafe repo name: ${repo}`);
+      const keep = new Set(keepCommits);
+      let removed = 0;
+      let commits;
+      try {
+        commits = await readdir2(join2(dir, repo));
+      } catch {
+        return 0;
+      }
+      for (const c of commits) {
+        if (!keep.has(c)) {
+          await rm(join2(dir, repo, c), { recursive: true, force: true });
+          removed++;
+        }
+      }
+      return removed;
+    }
+  };
+}
+
+// packages/sdk/dist/runner.js
+var EVIDENCE_FROM_REPO = /* @__PURE__ */ new Set([
+  "code",
+  "config",
+  "spec",
+  "gateway",
+  "event-config",
+  "infrastructure",
+  "pipeline",
+  "migration"
+]);
+function stampEvidence(record, repo, extractor, scannedAt) {
+  if (record === null || typeof record !== "object")
+    return record;
+  const r = record;
+  if (!Array.isArray(r.evidence))
+    return record;
+  return {
+    ...r,
+    evidence: r.evidence.map((e) => {
+      if (e === null || typeof e !== "object")
+        return e;
+      const ev = { ...e };
+      if (typeof ev.source !== "string" || !EVIDENCE_FROM_REPO.has(ev.source))
+        return ev;
+      ev.repo ??= repo.name;
+      if (ev.repo === repo.name) {
+        ev.commit ??= repo.commit;
+        ev.scannedAt ??= scannedAt;
+      }
+      ev.extractor ??= extractor;
+      return ev;
+    })
+  };
+}
+async function hasClaimedFiles(repo, claims) {
+  for await (const _ of repo.listFiles(claims))
+    return true;
+  return false;
+}
+function compareRecords(a, b) {
+  const ka = `${a.r.kind}\0${a.r.id}\0${a.x}`;
+  const kb = `${b.r.kind}\0${b.r.id}\0${b.x}`;
+  return ka < kb ? -1 : ka > kb ? 1 : 0;
+}
+async function scanRepo(options) {
+  const own = options.repo.parseCache ? void 0 : createParseCache();
+  try {
+    return await scanWith(own ? { ...options, repo: withParseCache(options.repo, own) } : options);
+  } finally {
+    own?.dispose();
+  }
+}
+async function scanWith(options) {
+  const { repo } = options;
+  const dialects = [...options.dialects ?? []].sort();
+  const scannedAt = options.scannedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const useCache = options.cache !== void 0 && !options.dirty;
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const x of options.extractors) {
+    if (seenIds.has(x.id))
+      throw new Error(`extractor ${x.id} is registered twice`);
+    seenIds.add(x.id);
+  }
+  const out = {
+    repo: repo.name,
+    commit: repo.commit,
+    scannedAt,
+    records: [],
+    runs: [],
+    warnings: [],
+    rejected: []
+  };
+  const collected = [];
+  for (const extractor of [...options.extractors].sort((a, b) => a.id.localeCompare(b.id))) {
+    const tag = `${extractor.id}@${extractor.version}`;
+    const started = Date.now();
+    const run = {
+      extractor: extractor.id,
+      version: extractor.version,
+      status: "ran",
+      records: 0,
+      rejected: 0,
+      warnings: 0,
+      durationMs: 0
+    };
+    const key = {
+      repo: repo.name,
+      commit: repo.commit,
+      extractor: extractor.id,
+      version: extractor.version,
+      dialects,
+      config: [
+        options.configFor?.(extractor) ?? "",
+        JSON.stringify(options.repoInfo ?? {}),
+        // A changed framework model means a different reading of the same code.
+        options.frameworks?.length ? JSON.stringify(options.frameworks) : ""
+      ].join("|")
+    };
+    try {
+      const hit = useCache ? await options.cache.get(key) : void 0;
+      if (hit) {
+        run.status = "cached";
+        run.records = hit.records.length;
+        run.rejected = hit.rejected;
+        run.warnings = hit.warnings.length;
+        for (const r of hit.records)
+          collected.push({ r, x: extractor.id });
+        for (const w of hit.warnings)
+          out.warnings.push({ extractor: extractor.id, ...w });
+      } else if (!await hasClaimedFiles(repo, extractor.claims)) {
+        run.status = "skipped";
+      } else {
+        const records = [];
+        const warnings = [];
+        const ids = /* @__PURE__ */ new Set();
+        let rejected = 0;
+        const info = options.repoInfo ?? {};
+        const ctx = {
+          dialects,
+          ...info.component ? { component: info.component } : {},
+          ...info.system ? { system: info.system } : {},
+          ...info.repoType ? { repoType: info.repoType } : {},
+          ...info.modules?.length ? { modules: info.modules } : {},
+          ...options.frameworks?.length ? { frameworks: options.frameworks } : {},
+          scannedAt,
+          warn: (message, path) => warnings.push(path === void 0 ? { message } : { message, path })
+        };
+        const claimed = extractor.claims.map(globToRegExp);
+        const skippedNow = () => repo.skippedFiles?.().filter((f) => claimed.some((m) => m.test(f.path))) ?? [];
+        for await (const emitted of extractor.scan(repo, ctx)) {
+          const parsed = parseRecord(stampEvidence(emitted, repo, tag, scannedAt));
+          if (!parsed.ok) {
+            rejected++;
+            out.rejected.push({ extractor: extractor.id, record: emitted, issues: parsed.issues });
+            continue;
+          }
+          const id = `${parsed.record.kind}/${parsed.record.id}`;
+          if (ids.has(id)) {
+            warnings.push({ message: `emitted ${id} more than once; kept the first` });
+            continue;
+          }
+          ids.add(id);
+          records.push(parsed.record);
+        }
+        for (const f of skippedNow())
+          warnings.push({
+            message: tooLargeMessage(f.bytes, repo.maxFileBytes),
+            path: f.path
+          });
+        run.records = records.length;
+        run.rejected = rejected;
+        run.warnings = warnings.length;
+        for (const r of records)
+          collected.push({ r, x: extractor.id });
+        for (const w of warnings)
+          out.warnings.push({ extractor: extractor.id, ...w });
+        if (useCache)
+          await options.cache.put(key, { records, warnings, rejected });
+      }
+    } catch (err) {
+      run.status = "failed";
+      run.error = err instanceof Error ? err.message : String(err);
+      for (let i = collected.length - 1; i >= 0; i--)
+        if (collected[i].x === extractor.id)
+          collected.splice(i, 1);
+      for (let i = out.warnings.length - 1; i >= 0; i--)
+        if (out.warnings[i].extractor === extractor.id)
+          out.warnings.splice(i, 1);
+      for (let i = out.rejected.length - 1; i >= 0; i--)
+        if (out.rejected[i].extractor === extractor.id)
+          out.rejected.splice(i, 1);
+      run.rejected = 0;
+      run.warnings = 0;
+      run.records = 0;
+    }
+    run.durationMs = Date.now() - started;
+    out.runs.push(run);
+  }
+  out.records = collected.sort(compareRecords).map((c) => c.r);
+  return out;
+}
+
+// packages/sdk/dist/sandbox.js
+import { createHash as createHash3 } from "node:crypto";
+import { readFile as readFile3 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+import { Worker } from "node:worker_threads";
+var PLUGIN_EXTRACTOR_PREFIX = "plugin-";
+var MAX_RECORDS = 1e5;
+function pluginEntryHash(text) {
+  return createHash3("sha256").update(text.replace(/\r\n/g, "\n"), "utf8").digest("hex");
+}
+async function readPinnedEntry(dir, manifest) {
+  if (!manifest.sha256)
+    return { ok: false, message: "isn't pinned: run atticus plugin pin once it is reviewed" };
+  let source;
+  try {
+    source = await readFile3(join3(dir, ...manifest.entry.split("/")), "utf8");
+  } catch (e) {
+    return { ok: false, message: `can't read ${manifest.entry}: ${e.message}` };
+  }
+  if (pluginEntryHash(source) !== manifest.sha256)
+    return {
+      ok: false,
+      message: `${manifest.entry} changed after it was pinned: its sha256 isn't the one in plugin.yaml. Review the change, then run atticus plugin pin`
+    };
+  return { ok: true, source };
+}
+var PluginRunError = class extends Error {
+  reason;
+  constructor(message, reason) {
+    super(message);
+    this.reason = reason;
+    this.name = "PluginRunError";
+  }
+};
+function insideRepo(p) {
+  return p.length > 0 && !p.startsWith("/") && !/^[A-Za-z]:/.test(p) && !p.includes("\\") && !p.includes("\0") && !p.split("/").includes("..");
+}
+var HARDEN = String.raw`  "use strict";
+  const g = globalThis;
+  const send = host;
+  const blocked = (what) => {
+    send("violation", 0, String(what));
+    return new Error("blocked: " + what + " is not allowed in a scanner plugin");
+  };
+  // Code from strings: the constructors every function reaches, and eval.
+  const compileStub = function () { throw blocked("compile code from a string (eval or Function)"); };
+  for (const f of [function () {}, async function () {}, function* () {}, async function* () {}])
+    Object.defineProperty(Object.getPrototypeOf(f), "constructor", { value: compileStub });
+  Object.defineProperty(g, "Function", { value: compileStub });
+  Object.defineProperty(g, "eval", { value: compileStub });
+  // Node's way out of the sandbox, if it were there: reported when touched.
+  for (const name of ["require", "process", "module", "exports", "Buffer", "fetch", "XMLHttpRequest",
+    "WebSocket", "setTimeout", "setInterval", "setImmediate", "queueMicrotask", "WebAssembly",
+    "SharedArrayBuffer", "Atomics"]) {
+    Object.defineProperty(g, name, { get() { throw blocked("use " + name); }, configurable: false });
+  }
+  // The same commit must read the same (ADR 0074): no clock, no randomness.
+  Object.defineProperty(g, "Date", { get() { throw blocked("use Date (the scan's time is ctx.scannedAt)"); }, configurable: false });
+  Object.defineProperty(Math, "random", { value: function () { throw blocked("use Math.random"); } });
+  const noop = () => undefined;
+  Object.defineProperty(g, "console", { value: Object.freeze({ log: noop, info: noop, warn: noop, error: noop, debug: noop }) });
+  // Freeze what the plugin and this bootstrap share, so neither can be changed under the other.
+  const seen = new Set();
+  const freeze = (o) => {
+    if ((typeof o !== "object" && typeof o !== "function") || o === null || seen.has(o)) return;
+    seen.add(o);
+    Object.freeze(o);
+    for (const k of Reflect.ownKeys(o)) {
+      const d = Object.getOwnPropertyDescriptor(o, k);
+      if (d && "value" in d) freeze(d.value);
+    }
+    freeze(Object.getPrototypeOf(o));
+  };
+  for (const k of Reflect.ownKeys(g)) {
+    const d = Object.getOwnPropertyDescriptor(g, k);
+    if (d && "value" in d) freeze(d.value);
+  }
+  for (const f of [function () {}, async function () {}, function* () {}, async function* () {}])
+    freeze(Object.getPrototypeOf(f));
+  for (const f of [function* () {}, async function* () {}]) freeze(Object.getPrototypeOf(f()));
+  freeze(Object.getPrototypeOf([][Symbol.iterator]()));
+  freeze(Object.getPrototypeOf(new Map()[Symbol.iterator]()));
+  freeze(Object.getPrototypeOf(new Set()[Symbol.iterator]()));
+  freeze(Object.getPrototypeOf(""[Symbol.iterator]()));
+  freeze(Object.getPrototypeOf(/x/[Symbol.matchAll]("")));
+  Object.freeze(g);
+
+  const parse = JSON.parse;
+  const stringify = JSON.stringify;
+  const pending = new Map();
+  let next = 0;
+  const ask = (op, arg) =>
+    new Promise((resolve, reject) => {
+      const id = ++next;
+      pending.set(id, { resolve, reject });
+      send(op, id, arg);
+    });
+  function answer(id, ok, text) {
+    const p = pending.get(id);
+    if (!p) return;
+    pending.delete(id);
+    if (ok) p.resolve(parse(text));
+    else p.reject(new Error(text));
+  }
+`;
+var EXTRACTOR_DRIVER = String.raw`  async function drive(x, input) {
+    const data = parse(input);
+    if (!x || typeof x !== "object" || typeof x.scan !== "function")
+      throw new Error("the entry file's default export isn't an extractor (id, version, claims, scan)");
+    send("meta", 0, stringify({ id: String(x.id), version: String(x.version) }));
+    const repo = Object.freeze({
+      name: data.repo.name,
+      commit: data.repo.commit,
+      listFiles: async function* (globs) {
+        const list = await ask("list", stringify(Array.from(globs, (s) => String(s))));
+        for (const p of list) yield p;
+      },
+      readText: (path) => ask("read", String(path)),
+    });
+    const ctx = Object.freeze({
+      ...data.ctx,
+      warn: (message, path) =>
+        send("warn", 0, stringify(path === undefined ? { message: String(message) } : { message: String(message), path: String(path) })),
+    });
+    for await (const r of x.scan(repo, ctx)) send("record", 0, stringify(r));
+  }
+  function run(x, input) {
+    drive(x, input).then(
+      () => send("done", 0, ""),
+      (e) => send("error", 0, String(e && e.message !== undefined ? e.message : e)),
+    );
+  }
+`;
+var TRANSLATOR_DRIVER = String.raw`  function run(x, input) {
+    Promise.resolve()
+      .then(() => {
+        const data = parse(input);
+        if (!x || typeof x !== "object") throw new Error("the entry file has no default export");
+        send("meta", 0, stringify({ id: String(x.id), version: String(x.version) }));
+        if (typeof x[data.fn] !== "function")
+          throw new Error("the entry file's default export has no " + data.fn + " function");
+        return x[data.fn](data.arg);
+      })
+      .then(
+        (r) => send("result", 0, stringify(r === undefined ? null : r)),
+        (e) => send("error", 0, String(e && e.message !== undefined ? e.message : e)),
+      );
+  }
+`;
+var bootstrapWith = (driver) => `(function (host) {
+${HARDEN}${driver}  return Object.freeze({ answer, run });
+})`;
+var BOOTSTRAP = bootstrapWith(EXTRACTOR_DRIVER);
+var TRANSLATOR_BOOTSTRAP = bootstrapWith(TRANSLATOR_DRIVER);
+var WORKER = String.raw`"use strict";
+const vm = require("node:vm");
+const { parentPort, workerData } = require("node:worker_threads");
+const { source, identifier, input, bootstrap } = workerData;
+const post = (m) => parentPort.postMessage(m);
+const context = vm.createContext(
+  vm.constants && vm.constants.DONT_CONTEXTIFY !== undefined ? vm.constants.DONT_CONTEXTIFY : {},
+  { name: identifier, codeGeneration: { strings: false, wasm: false } },
+);
+// Errors thrown into plugin code are made in its context, never the worker's.
+const makeError = vm.runInContext("(m) => new Error(m)", context);
+let bridge;
+const host = (op, id, arg) => {
+  try {
+    if (typeof op !== "string" || typeof id !== "number" || typeof arg !== "string") return;
+    post({ t: op, id, arg });
+  } catch {
+    // Never throw a worker error into the plugin's context.
+  }
+};
+parentPort.on("message", (m) => {
+  if (m && m.t === "answer") bridge.answer(m.id, m.ok, m.text);
+});
+(async () => {
+  try {
+    bridge = vm.runInContext(bootstrap, context)(host);
+    const refuse = (spec) => {
+      post({ t: "violation", id: 0, arg: "import " + String(spec) });
+      throw makeError("blocked: import " + String(spec) + " is not allowed in a scanner plugin");
+    };
+    const mod = new vm.SourceTextModule(source, {
+      context,
+      identifier,
+      importModuleDynamically: (spec) => refuse(spec),
+    });
+    await mod.link((spec) => refuse(spec));
+    await mod.evaluate();
+    bridge.run(mod.namespace.default, input);
+  } catch (e) {
+    post({ t: "error", id: 0, arg: String(e && e.message !== undefined ? e.message : e) });
+  }
+})();
+`;
+function contextData(ctx) {
+  return {
+    dialects: [...ctx.dialects],
+    scannedAt: ctx.scannedAt,
+    ...ctx.component !== void 0 ? { component: ctx.component } : {},
+    ...ctx.system !== void 0 ? { system: ctx.system } : {},
+    ...ctx.repoType !== void 0 ? { repoType: ctx.repoType } : {},
+    ...ctx.modules ? { modules: ctx.modules } : {},
+    ...ctx.frameworks ? { frameworks: ctx.frameworks } : {}
+  };
+}
+function spawnSandbox(o) {
+  const memoryMb = o.limits.memoryMb;
+  return new Worker(WORKER, {
+    eval: true,
+    workerData: {
+      source: o.source,
+      identifier: `plugin:${o.id}/${o.entry ?? "index.js"}`,
+      input: o.input,
+      bootstrap: o.bootstrap
+    },
+    execArgv: ["--experimental-vm-modules", "--no-warnings"],
+    argv: [],
+    env: {},
+    stdout: true,
+    stderr: true,
+    stdin: false,
+    trackUnmanagedFds: true,
+    resourceLimits: {
+      maxOldGenerationSizeMb: memoryMb,
+      maxYoungGenerationSizeMb: Math.max(4, Math.min(16, Math.floor(memoryMb / 4))),
+      codeRangeSizeMb: 16,
+      stackSizeMb: 4
+    },
+    name: `atticus-plugin-${o.id}`
+  });
+}
+function runInWorker(p, repo, ctx) {
+  const records = [];
+  const emits = new Set(p.emits);
+  const memoryMb = p.limits.memoryMb;
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const worker = spawnSandbox({
+      ...p,
+      input: JSON.stringify({
+        repo: { name: repo.name, commit: repo.commit },
+        ctx: contextData(ctx)
+      }),
+      bootstrap: BOOTSTRAP
+    });
+    worker.stdout.resume();
+    worker.stderr.resume();
+    const finish = (err) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      void worker.terminate();
+      if (err)
+        reject(err);
+      else
+        resolve2(records);
+    };
+    const timer = setTimeout(() => finish(new PluginRunError(`stopped after ${p.limits.timeoutMs} ms, its time limit`, "timeout")), p.limits.timeoutMs);
+    const outside = (what, path) => finish(new PluginRunError(`blocked: tried to ${what} ${JSON.stringify(path)}, which is outside the repo`, "blocked"));
+    const answer = (id, ok, text) => {
+      if (!settled)
+        worker.postMessage({ t: "answer", id, ok, text });
+    };
+    worker.on("message", (m) => {
+      if (settled)
+        return;
+      void (async () => {
+        switch (m.t) {
+          case "list": {
+            const globs = JSON.parse(m.arg);
+            const bad = globs.find((g) => typeof g !== "string" || !insideRepo(g));
+            if (bad !== void 0)
+              return outside("list", String(bad));
+            try {
+              const out = [];
+              for await (const f of repo.listFiles(globs))
+                out.push(f);
+              answer(m.id, true, JSON.stringify(out));
+            } catch (e) {
+              answer(m.id, false, e.message);
+            }
+            return;
+          }
+          case "read": {
+            if (!insideRepo(m.arg))
+              return outside("read", m.arg);
+            try {
+              answer(m.id, true, JSON.stringify(await repo.readText(m.arg)));
+            } catch (e) {
+              answer(m.id, false, e.message);
+            }
+            return;
+          }
+          case "meta": {
+            const meta = JSON.parse(m.arg);
+            if (meta.id !== p.id || meta.version !== p.version)
+              finish(new PluginRunError(`the entry file exports ${meta.id} ${meta.version}, but its manifest says ${p.id} ${p.version}`, "invalid"));
+            return;
+          }
+          case "record": {
+            const r = JSON.parse(m.arg);
+            if (!emits.has(String(r?.kind)))
+              return finish(new PluginRunError(`emitted a ${String(r?.kind)} record; its manifest allows ${[...emits].join(", ")}`, "invalid"));
+            if (records.length >= MAX_RECORDS)
+              return finish(new PluginRunError(`emitted more than ${MAX_RECORDS} records`, "invalid"));
+            records.push(r);
+            return;
+          }
+          case "warn": {
+            const w = JSON.parse(m.arg);
+            ctx.warn(w.message, w.path);
+            return;
+          }
+          case "violation":
+            return finish(new PluginRunError(`blocked: tried to ${m.arg}`, "blocked"));
+          case "error":
+            return finish(new PluginRunError(`failed: ${m.arg}`, "failed"));
+          case "done":
+            return finish();
+        }
+      })().catch((e) => finish(new PluginRunError(`failed: ${e.message}`, "failed")));
+    });
+    worker.on("error", (e) => finish(e.code === "ERR_WORKER_OUT_OF_MEMORY" ? new PluginRunError(`stopped: it used more than its ${memoryMb} MB memory limit`, "memory") : new PluginRunError(`failed: ${e.message}`, "failed")));
+    worker.on("exit", (code) => finish(new PluginRunError(`stopped before it finished (exit code ${code})`, "failed")));
+  });
+}
+var MAX_RESULT_CHARS = 32 * 1024 * 1024;
+function runTranslator(p, fn, arg) {
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const worker = spawnSandbox({
+      ...p,
+      input: JSON.stringify({ fn, arg: arg ?? null }),
+      bootstrap: TRANSLATOR_BOOTSTRAP
+    });
+    worker.stdout.resume();
+    worker.stderr.resume();
+    const finish = (err, value) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      void worker.terminate();
+      if (err)
+        reject(err);
+      else
+        resolve2(value);
+    };
+    const timer = setTimeout(() => finish(new PluginRunError(`stopped after ${p.limits.timeoutMs} ms, its time limit`, "timeout")), p.limits.timeoutMs);
+    worker.on("message", (m) => {
+      if (settled)
+        return;
+      switch (m.t) {
+        case "meta": {
+          const meta = JSON.parse(m.arg);
+          if (meta.id !== p.id || meta.version !== p.version)
+            finish(new PluginRunError(`the entry file exports ${meta.id} ${meta.version}, but its manifest says ${p.id} ${p.version}`, "invalid"));
+          return;
+        }
+        case "result":
+          if (m.arg.length > MAX_RESULT_CHARS)
+            return finish(new PluginRunError("gave back more than 32 MB", "invalid"));
+          return finish(void 0, JSON.parse(m.arg));
+        case "violation":
+          return finish(new PluginRunError(`blocked: tried to ${m.arg}`, "blocked"));
+        case "error":
+          return finish(new PluginRunError(`failed: ${m.arg}`, "failed"));
+        default:
+          return finish(new PluginRunError(`blocked: tried to ${m.t}`, "blocked"));
+      }
+    });
+    worker.on("error", (e) => finish(e.code === "ERR_WORKER_OUT_OF_MEMORY" ? new PluginRunError(`stopped: it used more than its ${p.limits.memoryMb} MB memory limit`, "memory") : new PluginRunError(`failed: ${e.message}`, "failed")));
+    worker.on("exit", (code) => finish(new PluginRunError(`stopped before it finished (exit code ${code})`, "failed")));
+  });
+}
+function sandboxedExtractor(p) {
+  return {
+    id: `${PLUGIN_EXTRACTOR_PREFIX}${p.id}`,
+    version: p.version,
+    // What the plugin reads is up to it, through the handle: the run is never skipped.
+    claims: ["**/*"],
+    async *scan(repo, ctx) {
+      for (const r of await runInWorker(p, repo, ctx))
+        yield r;
+    }
+  };
+}
+
+export {
+  DEFAULT_PARSE_CACHE_LIMITS,
+  deepFreeze,
+  createParseCache,
+  withParseCache,
+  defineExtractor,
+  runExtractor,
+  memoryRepo,
+  globToRegExp,
+  DEFAULT_IGNORES,
+  tooLargeMessage,
+  RepoReadError,
+  fsRepo,
+  cacheKeyHash,
+  configHash,
+  memoryScanCache,
+  fsScanCache,
+  stampEvidence,
+  scanRepo,
+  PLUGIN_EXTRACTOR_PREFIX,
+  pluginEntryHash,
+  readPinnedEntry,
+  PluginRunError,
+  runTranslator,
+  sandboxedExtractor
+};