@maycombhq/atticus 2.0.0-beta.26 → 2.0.0-beta.27.1

package/dist/{chunk-EECFUQP3.js → chunk-XKWPEY4B.js}

@@ -5,27 +5,41 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   askHosts
-} from "./chunk-E5NHFHGC.js";
+} from "./chunk-FVT6LUOC.js";
 import {
   driftAfterScan
-} from "./chunk-DPH4BS3F.js";
+} from "./chunk-L3KSU4QU.js";
 import {
+  buildPlanOf,
+  pageChanged,
+  refusalPlanOf
+} from "./chunk-3XNE6XXF.js";
+import {
+  buildAndWrite,
+  buildLines,
   diffCatalogs,
   diffIsEmpty,
   readCatalog,
   scanEstate,
-  writeCatalog
-} from "./chunk-2HDNOUJU.js";
+  writeRefusedReport
+} from "./chunk-6H62UHY5.js";
+import {
+  readersSlotPath,
+  serializeReadersSlot,
+  sourcesRelOf,
+  writeReadersSlots
+} from "./chunk-4NPWOUI2.js";
 import {
   loadRepos
-} from "./chunk-XIJBQM45.js";
+} from "./chunk-X5B7KYPD.js";
 import {
-  catalogDirOf
-} from "./chunk-6ZDAEUKB.js";
+  catalogDirOf,
+  throwIfCancelled
+} from "./chunk-WJWSB65O.js";
 import {
   LockHeldError,
   acquireLock
-} from "./chunk-MEMEO7YO.js";
+} from "./chunk-SMFFUFMN.js";
 
 // packages/cli/dist/scan-commands.js
 import { join } from "node:path";
@@ -40,7 +54,6 @@ function diffLines(d) {
   ];
   return lines;
 }
-var FACTS_PATH = "Scan every repo (atticus scan, after atticus workspace sync), or put one repo's read in the catalog from its facts: atticus verify <repo> --write.";
 function unreadMessage(u) {
   switch (u.why) {
     case "not-cloned":
@@ -53,36 +66,96 @@ function unreadMessage(u) {
       return "left out by --repos";
   }
 }
-var fromCode = (r) => r.evidence.some((e) => !!e.repo);
-function scanRefusal(scan, before) {
+function scanRefusal(scan) {
+  if (scan.observations.some((o) => o.full))
+    return void 0;
   const unread = scan.unread;
-  if (unread.length) {
-    const asked = unread.filter((u) => u.why === "not-asked");
-    const lines = unread.filter((u) => u.why !== "not-asked").map((u) => `${u.repo}: ${unreadMessage(u)}`);
-    if (asked.length)
-      lines.push(`${asked.map((u) => u.repo).join(", ")}: left out by --repos; a scan of only some repos would replace the catalog with them alone, so it isn't written`);
+  const lines = unread.map((u) => `${u.repo}: ${unreadMessage(u)}`);
+  for (const o of scan.observations)
+    if (!o.full && !unread.some((u) => u.repo === o.repo))
+      lines.push(`${o.repo}: ${keptWhy({ reason: o.why, ...o.detail ? { detail: o.detail } : {} })}`);
+  return {
+    reasons: ["nothing-read"],
+    repos: unread.map((u) => ({
+      repo: u.repo,
+      why: u.why,
+      message: unreadMessage(u),
+      ...u.runs ? { runs: u.runs } : {}
+    })),
+    message: [
+      "Nothing written: the scan read no repo in full, so every slot and catalog/generated are as they were:",
+      ...lines.map((l) => `  ${l}`),
+      "Clone the repos (atticus workspace sync) or fix what stopped their read, then scan again."
+    ].join("\n")
+  };
+}
+function scanSources(scan, slots) {
+  return scan.observations.map((o) => {
+    const s = slots.find((x) => x.repo === o.repo);
+    const built = scan.build?.sources.find((x) => x.repo === o.repo);
     return {
-      repos: unread.map((u) => ({
-        repo: u.repo,
-        why: u.why,
-        message: unreadMessage(u),
-        ...u.runs ? { runs: u.runs } : {}
-      })),
-      message: [
-        `Nothing written: catalog/generated is as it was. A scan replaces the whole catalog, so it writes only when it has read every repo in full, and it didn't read ${unread.length === 1 ? "this one" : `these ${unread.length}`}:`,
-        ...lines.map((l) => `  ${l}`),
-        FACTS_PATH
-      ].join("\n")
+      repo: o.repo,
+      source: built?.source ?? "none",
+      ...built?.commit ? { sourceCommit: built.commit } : {},
+      slot: s?.slot ?? "none",
+      ...s?.commit ? { commit: s.commit } : {},
+      ...s?.reason ? { reason: s.reason } : {},
+      ...s?.detail ? { detail: s.detail } : {},
+      ...o.factsStale ? { factsStale: o.factsStale } : {}
     };
+  });
+}
+var short = (c) => /^[0-9a-f]{8,}$/.test(c) ? c.slice(0, 7) : c;
+function keptWhy(s) {
+  switch (s.reason) {
+    case "not-cloned":
+      return "it isn't cloned here";
+    case "unreadable":
+      return "its clone can't be read";
+    case "not-asked":
+      return "--repos left it out";
+    case "run-failed":
+      return `a run failed (${s.detail ?? "a reader"})`;
+    case "plugin-refused":
+      return `a plugin that applies to it isn't used (${s.detail ?? "a plugin"})`;
+    case "readers-off":
+      return "the readers are switched off (ATTICUS_HELPERS_OFF=readers)";
+    case "dirty":
+      return "its clone has changes not committed (commit or stash them, then scan again)";
+    case "refused":
+      return "the scan wrote nothing";
+    case "dry-run":
+      return "a dry run writes nothing";
+    default:
+      return "it wasn't read in full";
   }
-  const had = before.filter(fromCode).length;
-  if (had > 0 && !scan.records.some(fromCode))
-    return {
-      repos: [],
-      empty: { before: had },
-      message: `Nothing written: the scan found no records in any repo's code, and catalog/generated has ${had}, so it is left as it was. Check that the manifests list the repos to read (an archived repo or a prototype isn't read), then scan again.`
-    };
-  return void 0;
+}
+function sourceLines(rel, sources, wrote) {
+  const out = [];
+  if (wrote) {
+    const n = (k) => sources.filter((s) => s.slot === k).length;
+    out.push(`${rel}/readers: ${n("written")} written, ${n("unchanged")} unchanged`);
+    for (const s of sources)
+      if (s.reason && s.reason !== "refused" && s.reason !== "dry-run")
+        out.push(s.slot === "kept-last-good" ? `${s.repo}: its readers slot keeps its last good read${s.commit ? ` (commit ${short(s.commit)})` : ""}: ${keptWhy(s)}.` : `${s.repo}: no readers slot written: ${keptWhy(s)}.`);
+  }
+  for (const s of sources) {
+    const f = s.factsStale;
+    if (!f)
+      continue;
+    const at = `${rel}/facts/${s.repo}.jsonl`;
+    if (f.unusable)
+      out.push(`${s.repo}: its facts snapshot (${at}) ${f.unusable}, so it isn't used; write it again: ${f.command}`);
+    else if (f.notComparable)
+      out.push(`${s.repo}: its facts snapshot (${at}) is of commit ${short(f.commit)}, which can't be compared with ${short(f.head)} here; the snapshot stays as it is; refresh it: ${f.command}`);
+    else {
+      const shown = f.files.slice(0, 5).map((x) => `${x.path} ${x.how}${x.to ? ` to ${x.to}` : ""}: ${x.facts.slice(0, 5).join(", ")}${x.facts.length > 5 ? ` and ${x.facts.length - 5} more` : ""}`);
+      if (f.files.length > 5)
+        shown.push(`${f.files.length - 5} more files`);
+      out.push(`${s.repo}: its facts snapshot (${at}, commit ${short(f.commit)}) is stale at ${short(f.head)}: ${f.facts} ${f.facts === 1 ? "fact cites" : "facts cite"} files changed since (${shown.join("; ")}). The snapshot stays as it is; refresh it: ${f.command}`);
+    }
+  }
+  return out;
 }
 function saidByRefusal(p, refused) {
   const r = refused?.repos.find((x) => x.repo === p.repo);
@@ -122,6 +195,8 @@ function scanSummaryLines(report) {
   const w = Array.isArray(report.warnings) ? report.warnings.length : 0;
   if (w)
     out.push(`${n(w, "warning")}: atticus scan --warnings lists ${w === 1 ? "it" : "them"}`);
+  if (Array.isArray(report.sources))
+    out.push(...sourceLines(typeof report.sourcesDir === "string" ? report.sourcesDir : "catalog/sources", report.sources, report.written === true));
   if (typeof refusal?.message === "string")
     out.push(...refusal.message.split("\n"));
   return out;
@@ -160,11 +235,14 @@ async function scanCommand(root, o, io) {
   }
   try {
     if (o.ref) {
-      const { scanBranch } = await import("./chunk-7IWMRZRI.js");
+      const { scanBranch } = await import("./chunk-ZQZRNVNS.js");
       return await scanBranch(root, o.ref, {
         ...o.repos ? { repos: o.repos } : {},
         ...o.full ? { full: true } : {},
-        ...o.json ? { json: true } : {}
+        ...o.json ? { json: true } : {},
+        ...o.allowRemovals !== void 0 ? { allowRemovals: o.allowRemovals } : {},
+        ...o.discardEdits !== void 0 ? { discardEdits: o.discardEdits } : {},
+        ...o.plan !== void 0 ? { plan: o.plan } : {}
       }, io);
     }
     return await scanLocked(root, o, io);
@@ -174,16 +252,60 @@ async function scanCommand(root, o, io) {
 }
 async function scanLocked(root, o, io) {
   const out = join(catalogDirOf(root), "generated");
-  const before = await readCatalog(out, { cacheRoot: root });
+  const before = await readCatalog(out, { cacheRoot: root, fresh: true });
   const started = Date.now();
   const scan = await scanEstate({
     root,
     ...o.repos ? { repos: o.repos } : {},
     ...o.full ? { cache: null } : {}
   });
-  const refused = scanRefusal(scan, before.records);
+  throwIfCancelled();
+  const command = `atticus scan${o.repos?.length ? ` --repos ${o.repos.join(",")}` : ""}`;
+  const unreadAll = scanRefusal(scan);
+  if (unreadAll && !o.dryRun)
+    await writeRefusedReport(root, command, {
+      reasons: ["nothing-read"],
+      message: unreadAll.message,
+      unread: unreadAll.repos.map((r) => ({ repo: r.repo, why: r.message }))
+    });
+  const slotWrites = scan.observations.flatMap((x) => x.full ? [{ path: readersSlotPath(root, x.repo), text: serializeReadersSlot(x.slot) }] : []);
+  const planned = await writeReadersSlots(root, scan.observations, { hold: "dry-run" });
+  const built = unreadAll ? void 0 : await buildAndWrite(root, {
+    command,
+    build: scan.build,
+    slots: slotWrites,
+    ...o.dryRun ? { check: true } : {},
+    ...o.allowRemovals !== void 0 ? { allowRemovals: o.allowRemovals } : {},
+    ...o.discardEdits !== void 0 ? { discardEdits: o.discardEdits } : {},
+    // The app's confirm: the list worked out again under the lock (the review of beta.27).
+    ...o.plan !== void 0 && !o.dryRun ? { expect: (listed) => buildPlanOf(listed) === o.plan } : {}
+  });
+  const guardRefused = built && !o.dryRun ? built.guard.refused : void 0;
+  const changed = built?.changed ? pageChanged("what the build would remove or discard") : void 0;
+  const refused = unreadAll ?? (changed && !guardRefused ? { reasons: [], repos: [], message: changed } : void 0) ?? (guardRefused ? {
+    reasons: guardRefused.reasons,
+    repos: [],
+    message: changed ? `${changed}
+${guardRefused.message}` : guardRefused.message,
+    ...guardRefused.removals ? { removals: guardRefused.removals } : {},
+    ...guardRefused.unexplained ? { unexplained: guardRefused.unexplained } : {},
+    ...guardRefused.allowRemovals !== void 0 ? { allowRemovals: guardRefused.allowRemovals } : {},
+    ...guardRefused.edits ? { edits: guardRefused.edits } : {},
+    ...guardRefused.discardEdits !== void 0 ? { discardEdits: guardRefused.discardEdits } : {},
+    plan: refusalPlanOf(guardRefused)
+  } : void 0);
+  const w = built?.write;
   const diff = refused ? { added: [], removed: [], changed: [], evidenceOnly: [] } : diffCatalogs(before.records, scan.records);
-  const write = o.dryRun || refused ? void 0 : await writeCatalog(out, scan.records);
+  const slots = planned.map((x) => {
+    if (x.reason !== "dry-run")
+      return x;
+    const obs = scan.observations.find((y) => y.repo === x.repo);
+    if (w && obs?.full)
+      return { repo: x.repo, slot: "written", commit: obs.slot.commit };
+    return { ...x, reason: o.dryRun ? "dry-run" : "refused" };
+  });
+  const sources = scanSources(scan, slots);
+  const write = w ? { written: w.written, unchanged: w.unchanged, removed: w.removed } : void 0;
   const drift = write && !o.noDrift ? await driftAfterScan(root) : [];
   const hosts = write ? await askHosts(root, scan.records, {
     command: "atticus scan",
@@ -194,8 +316,8 @@ async function scanLocked(root, o, io) {
     ...scan.problems
   ];
   const seen = /* @__PURE__ */ new Set();
-  const warnings = scan.repos.flatMap((r) => r.warnings.map((w) => ({ repo: r.repo, ...w })).filter((w) => {
-    const k = `${w.repo}\0${w.path ?? ""}\0${w.message}`;
+  const warnings = scan.repos.flatMap((r) => r.warnings.map((w2) => ({ repo: r.repo, ...w2 })).filter((w2) => {
+    const k = `${w2.repo}\0${w2.path ?? ""}\0${w2.message}`;
     if (seen.has(k))
       return false;
     seen.add(k);
@@ -212,6 +334,17 @@ async function scanLocked(root, o, io) {
       notes: scan.notes,
       written: write !== void 0,
       files: write ?? null,
+      sources,
+      sourcesDir: sourcesRelOf(root),
+      removed: (w?.removals ?? []).map((x) => ({
+        kind: x.kind,
+        id: x.id,
+        repos: x.repos,
+        explainedBy: x.explainedBy,
+        reasons: x.reasons
+      })),
+      retired: scan.build.retired,
+      ...w?.undo !== void 0 ? { undo: w.undo } : {},
       drift,
       questions: [...hosts.raised, ...hosts.open].map((q) => q.id),
       ...refused ? { refused } : {}
@@ -241,10 +374,13 @@ async function scanLocked(root, o, io) {
     if (!refused)
       for (const l of diffLines(diff))
         io.out(l);
-    if (write)
-      io.out(`catalog/generated: ${write.written} written, ${write.unchanged} unchanged, ${write.removed} removed`);
+    if (built && w)
+      for (const l of buildLines(root, built))
+        io.out(l);
     else if (!refused)
       io.out("Dry run: nothing written.");
+    for (const l of sourceLines(sourcesRelOf(root), sources, write !== void 0))
+      io.out(l);
     for (const d of drift)
       io.out(driftLine(d));
     for (const l of hosts.lines)
@@ -252,8 +388,8 @@ async function scanLocked(root, o, io) {
     for (const n of scan.notes)
       io.out(`note: ${n}`);
     if (o.warnings)
-      for (const w of warnings)
-        io.out(`warning: ${w.repo}: ${w.path ? `${w.path}: ` : ""}${w.message}`);
+      for (const w2 of warnings)
+        io.out(`warning: ${w2.repo}: ${w2.path ? `${w2.path}: ` : ""}${w2.message}`);
     else if (warnings.length)
       io.out(`${warnings.length} warning${warnings.length === 1 ? "" : "s"}: atticus scan --warnings lists ${warnings.length === 1 ? "it" : "them"}`);
     for (const p of problems.filter((x) => !saidByRefusal(x, refused)))
@@ -280,6 +416,8 @@ async function catalogDiff(a, b, json, io) {
 export {
   diffLines,
   scanRefusal,
+  scanSources,
+  sourceLines,
   scanSummaryLines,
   scanCommand,
   catalogDiff

package/dist/{chunk-GAJBMPWC.js → chunk-XRNMQZFC.js}

@@ -10,19 +10,23 @@ import {
   scoreRepo,
   scoreSpecs,
   scoreVerifier
-} from "./chunk-EQMNMG6X.js";
+} from "./chunk-MA73J3E6.js";
 import {
   readCatalog
-} from "./chunk-2HDNOUJU.js";
+} from "./chunk-6H62UHY5.js";
+import {
+  dirSource,
+  verifyFacts
+} from "./chunk-YIGSUTW2.js";
 import {
   ScanVerifyProposal,
   parseFacts,
   readEstateJoins,
   readRepoSpec
-} from "./chunk-6ZDAEUKB.js";
+} from "./chunk-WJWSB65O.js";
 import {
   external_exports
-} from "./chunk-LZFKJ2BR.js";
+} from "./chunk-A3LVMCA5.js";
 import {
   require_dist
 } from "./chunk-BQGDB6ZL.js";
@@ -117,7 +121,7 @@ var pct = (x) => `${Math.round(x * 100)}%`;
 async function benchRun(o, io) {
   try {
     const { dir, cache, repos } = await load(o);
-    const { main } = await import("./chunk-TYN5SG5H.js");
+    const { main } = await import("./chunk-DGNTEKF6.js");
     const quiet = { out: () => {
     }, err: () => {
     } };
@@ -270,8 +274,22 @@ async function benchFactsCommand(o, io) {
       const parsed = parseFacts(await readFile(file, "utf8"));
       if (!parsed.ok)
         throw new BenchError(`${file} does not read as facts: ${parsed.issues.slice(0, 5).map((i) => `${i.line !== void 0 ? `line ${i.line}: ` : ""}${i.message}`).join("; ")}${parsed.issues.length > 5 ? ` (and ${parsed.issues.length - 5} more)` : ""}`);
+      const clone = join(cache, r.id);
+      let facts = parsed.facts;
+      let verify = { verified: false, why: "no-clone" };
+      const head = existsSync(clone) ? await cloneCommit(clone) : void 0;
+      if (existsSync(clone) && head !== r.commit)
+        verify = { verified: false, why: "off-pin", head: head ?? "none" };
+      else if (existsSync(clone)) {
+        const v = await verifyFacts({ facts, source: dirSource(clone) });
+        const codes = {};
+        for (const x of v.rejected)
+          codes[x.code] = (codes[x.code] ?? 0) + 1;
+        facts = v.accepted;
+        verify = { verified: true, kept: v.accepted.length, rejected: v.rejected.length, codes };
+      }
       try {
-        scores.push(scoreFacts(ref, parsed.facts));
+        scores.push({ ...scoreFacts(ref, facts), verify });
       } catch (e) {
         throw new BenchError(`${r.id}: ${e.message}`);
       }
@@ -311,6 +329,7 @@ async function benchFactsCommand(o, io) {
     io.out("REPO                       FACTS  FOUND  MISSED  WRONG  PRECISION  RECALL");
     for (const s of scores) {
       io.out(row(s.repo, s.total, s.facts.total));
+      io.out(s.verify.verified ? `  verified against the clone: ${s.verify.kept} kept, ${s.verify.rejected} rejected${s.verify.rejected ? ` (${Object.entries(s.verify.codes).map(([c, n]) => `${n} ${c}`).join(", ")})` : ""}; only the kept are scored` : s.verify.why === "off-pin" ? `  not verified: the clone at ${join(cache, s.repo)} is ${s.verify.head === "none" ? "no git checkout" : `at ${s.verify.head.slice(0, 12)}`}, not the pinned ${(repos.find((r) => r.id === s.repo)?.commit ?? "").slice(0, 12)} (atticus bench fetch); every fact is scored` : `  not verified: no clone at ${join(cache, s.repo)} (atticus bench fetch); every fact is scored`);
       for (const [k, v] of Object.entries(s.kinds))
         io.out(row(`  ${k}`, { found: v.found, missed: v.missed.length, wrong: v.wrong.length }));
     }
@@ -437,7 +456,7 @@ function printSpecScores(scores, none, passes, cache, io) {
 async function benchSurvey(o, io) {
   try {
     const { cache, repos } = await load(o);
-    const { main } = await import("./chunk-TYN5SG5H.js");
+    const { main } = await import("./chunk-DGNTEKF6.js");
     const quiet = { out: () => {
     }, err: () => {
     } };
@@ -485,7 +504,7 @@ $1- ${mode}`), "utf8");
 async function benchVerify(o, io, deps = {}) {
   try {
     const { cache, repos } = await load(o);
-    const { main } = await import("./chunk-TYN5SG5H.js");
+    const { main } = await import("./chunk-DGNTEKF6.js");
     const quiet = { out: () => {
     }, err: () => {
     } };
@@ -512,7 +531,7 @@ async function benchVerify(o, io, deps = {}) {
       const capture = { out: (l) => lines.push(l), err: (l) => lines.push(l) };
       let code;
       if (deps.runtime) {
-        const { scanVerify } = await import("./chunk-IYEET4VM.js");
+        const { scanVerify } = await import("./chunk-NNRQZUVW.js");
         code = await scanVerify(path, path, {}, { runtime: deps.runtime, ...deps.now ? { now: deps.now } : {} }, capture);
       } else
         code = await main(["scan", "verify", path, "--root", path, ...o.mode ? ["--mode", o.mode] : []], capture);

package/dist/{chunk-BIAQ6NQS.js → chunk-XRTECHVH.js}

@@ -7,20 +7,20 @@ import {
   readRound,
   reviewedGates,
   roundsOf
-} from "./chunk-VIQHZA53.js";
+} from "./chunk-LP6BFBE5.js";
 import {
   changeStore,
   liveHandoff
-} from "./chunk-WH3ZFLXT.js";
+} from "./chunk-YBAJ5SAR.js";
 import {
   createAdapters
-} from "./chunk-6U65YB54.js";
+} from "./chunk-I57IH5X6.js";
 import {
   orgPackDirOf
-} from "./chunk-6ZDAEUKB.js";
+} from "./chunk-WJWSB65O.js";
 import {
   loadOrgPack
-} from "./chunk-LZFKJ2BR.js";
+} from "./chunk-A3LVMCA5.js";
 
 // packages/cli/dist/digest-commands.js
 var norm = (s) => s.toLowerCase().replace(/^@/, "");
@@ -70,8 +70,8 @@ async function buildDigest(root, user) {
   }
   if (!lines.length)
     lines.push("Nothing waits on you.");
-  const { readMe } = await import("./chunk-IFQJ3YQE.js");
-  const { watchLine } = await import("./chunk-IERXBWQU.js");
+  const { readMe } = await import("./chunk-WNPGLGCJ.js");
+  const { watchLine } = await import("./chunk-DNKYWTVZ.js");
   const watching = [];
   for (const c of (await readMe(root)).watch)
     watching.push(await watchLine(root, c));

package/dist/{chunk-I2EWY3MG.js → chunk-XZY4GTCX.js}

@@ -10,12 +10,12 @@ import {
   globToRegExp,
   memoryRepo,
   scanRepo
-} from "./chunk-UFIQ5FWY.js";
+} from "./chunk-3M3MDBOG.js";
 import {
   MESH_KEY,
   readTarGz,
   readZip
-} from "./chunk-6ZDAEUKB.js";
+} from "./chunk-WJWSB65O.js";
 import {
   Dialect,
   FrameworkModel,
@@ -28,7 +28,7 @@ import {
   normalizePath,
   renderExpr,
   renderTemplate
-} from "./chunk-LZFKJ2BR.js";
+} from "./chunk-A3LVMCA5.js";
 import {
   require_dist
 } from "./chunk-BQGDB6ZL.js";
@@ -1965,8 +1965,8 @@ function grammarFile(lang, here = __atticus_import_meta_url) {
   if (lang === "groovy")
     return fileURLToPath(new URL("../../grammars/tree-sitter-groovy.wasm", here));
   const name2 = `tree-sitter-${lang}.wasm`;
-  const shipped = fileURLToPath(new URL(`../../../../vendor/tree-sitter-wasms/out/${name2}`, here));
-  return existsSync(shipped) ? shipped : require2.resolve(`tree-sitter-wasms/out/${name2}`);
+  const shipped2 = fileURLToPath(new URL(`../../../../vendor/tree-sitter-wasms/out/${name2}`, here));
+  return existsSync(shipped2) ? shipped2 : require2.resolve(`tree-sitter-wasms/out/${name2}`);
 }
 async function parseSyntax(lang, text2) {
   const l = await language(lang);
@@ -15323,11 +15323,16 @@ function listShippedDialects() {
   return names.filter((n) => /\.ya?ml$/.test(n)).sort().map((n) => join5(SHIPPED_DIALECTS_DIR, n));
 }
 async function loadShippedDialects() {
-  const out2 = [];
-  for (const p of listShippedDialects())
-    out2.push(Dialect.parse((0, import_yaml13.parse)(await readFile(p, "utf8"))));
-  return out2;
+  shipped ??= (async () => {
+    const out2 = [];
+    for (const p of listShippedDialects())
+      out2.push(Dialect.parse((0, import_yaml13.parse)(await readFile(p, "utf8"))));
+    return out2;
+  })();
+  shipped.catch(() => shipped = void 0);
+  return structuredClone(await shipped);
 }
+var shipped;
 
 // packages/extractors/dist/data/index.js
 var DATA_EXTRACTORS = [

package/dist/{chunk-V3M4VFUB.js → chunk-Y6S7VCYN.js}

@@ -18,12 +18,12 @@ import {
   readHistory,
   recordingOf,
   setLocalRecording
-} from "./chunk-GNFZ227W.js";
-import "./chunk-BSZII65X.js";
-import "./chunk-6ZDAEUKB.js";
-import "./chunk-MEMEO7YO.js";
-import "./chunk-LZFKJ2BR.js";
-import "./chunk-CTJHEG6A.js";
+} from "./chunk-XIIT4PVT.js";
+import "./chunk-SFCFL7Y5.js";
+import "./chunk-WJWSB65O.js";
+import "./chunk-SMFFUFMN.js";
+import "./chunk-A3LVMCA5.js";
+import "./chunk-NWMFVPEP.js";
 import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {

package/dist/{chunk-MY3LDBMR.js → chunk-YAPVAYZN.js}

@@ -9,14 +9,14 @@ import {
   planBatches,
   reachableModels,
   readingRank
-} from "./chunk-RK5P2DWD.js";
+} from "./chunk-YIGSUTW2.js";
 import {
   neutralise,
   wrapData
-} from "./chunk-ZDA72732.js";
+} from "./chunk-2MRYL45Z.js";
 import {
   estimateTokens
-} from "./chunk-6ZDAEUKB.js";
+} from "./chunk-WJWSB65O.js";
 
 // packages/cli/dist/map-reach.js
 var CLIENT_ONLY_WHY = "reached only from an outbound client; --models reachable reads them";