@maycombhq/atticus 2.0.0-beta.10 → 2.0.0-beta.12

package/dist/{chunk-VKMTFIWS.js → chunk-AYVLEB55.js}

@@ -3,35 +3,35 @@ 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 "./chunk-XIWYUQZQ.js";
+import "./chunk-X64BFQ3R.js";
 import {
   loadCatalog
-} from "./chunk-P3TKKBAH.js";
+} from "./chunk-ZPT4QX3J.js";
 import {
   repoFor
-} from "./chunk-XKS6THI5.js";
+} from "./chunk-7VNEDDCC.js";
 import {
   askHosts
-} from "./chunk-LRS573EX.js";
-import "./chunk-Y5PZHS4K.js";
+} from "./chunk-GKPOCUQR.js";
+import "./chunk-INCECZ2E.js";
 import {
   estateFlow,
   estateStepKey,
   fieldLineage,
   joinEstate
-} from "./chunk-AY2IUF4K.js";
-import "./chunk-6JLPXDWN.js";
-import "./chunk-4GZXS6S2.js";
-import "./chunk-R4TBNKKC.js";
-import "./chunk-NIXVDQVO.js";
-import "./chunk-UR7RMZ3R.js";
-import "./chunk-JF2NSTFO.js";
-import "./chunk-N4QZJJVB.js";
-import "./chunk-PGKHJYOB.js";
+} from "./chunk-22GLUHGE.js";
+import "./chunk-QR65C3DV.js";
+import "./chunk-MLAACAES.js";
+import "./chunk-HY2VVVFZ.js";
+import "./chunk-PJRMMWU4.js";
+import "./chunk-34NWVIBC.js";
+import "./chunk-TEHH47TG.js";
+import "./chunk-77UOXZVM.js";
+import "./chunk-RA64IK43.js";
 import {
   fsRepo
-} from "./chunk-MKRBG5EF.js";
-import "./chunk-5XDNUJ4P.js";
+} from "./chunk-MRLCNXXR.js";
+import "./chunk-CQD26SMZ.js";
 import {
   listQuestions,
   loadOrgPack,
@@ -45,8 +45,8 @@ import {
   specsRelOf,
   templateRef,
   writeEstateJoins
-} from "./chunk-577AJVRS.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-U25OX22K.js";
+import "./chunk-MMB2OHUY.js";
 import "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/estate-commands.js

package/dist/chunk-B6X5PJSA.js

@@ -0,0 +1,320 @@
+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 {
+  intakeContext
+} from "./chunk-6S27MUQQ.js";
+import {
+  headCommitOf
+} from "./chunk-EU7VTBAI.js";
+import {
+  denyHashesAt
+} from "./chunk-NCONDPHH.js";
+import {
+  componentRenames,
+  estateFacts,
+  estateJoinOf,
+  hostAliases,
+  joinReposOf,
+  outsideProfileSystems
+} from "./chunk-22GLUHGE.js";
+import {
+  sameCommit
+} from "./chunk-MLAACAES.js";
+import {
+  openApiContractSpecs,
+  readContractSpecs,
+  readRepoSpecs,
+  readVendorSpec
+} from "./chunk-HY2VVVFZ.js";
+import {
+  VERSION
+} from "./chunk-TWHZU36X.js";
+import {
+  createGit
+} from "./chunk-RA64IK43.js";
+import {
+  SpecsFile,
+  catalogDirOf,
+  checkContracts,
+  factsDirOf,
+  factsRelOf,
+  inputsDirOf,
+  joinConventions,
+  joinVendorOperations,
+  newFindings,
+  orgPackDirOf,
+  questionsDirOf,
+  require_dist
+} from "./chunk-U25OX22K.js";
+import {
+  writeFileAtomic
+} from "./chunk-MMB2OHUY.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/contract-check-files.js
+var import_yaml = __toESM(require_dist(), 1);
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { readdir, readFile, rm, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+var SPEC_CLASSES = /* @__PURE__ */ new Set(["openapi", "swagger", "asyncapi", "protobuf", "avro"]);
+async function specsCommitOf(facts, dir, git = createGit()) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const f of facts)
+    counts.set(f.commit, (counts.get(f.commit) ?? 0) + 1);
+  if (!counts.size)
+    return void 0;
+  const head = await headCommitOf(dir);
+  const atHead = head ? [...counts.keys()].find((c) => sameCommit(c, head)) : void 0;
+  if (atHead)
+    return atHead;
+  const most = Math.max(...counts.values());
+  const top = [...counts].filter(([, n]) => n === most).map(([c]) => c).sort();
+  if (top.length === 1)
+    return top[0];
+  const newest = await git(["rev-list", "--no-walk", ...top], dir).then((r) => r.stdout.split("\n")[0]?.trim(), () => void 0);
+  return top.find((c) => !!newest && sameCommit(c, newest)) ?? top[0];
+}
+async function commitTree(dir, commit, git) {
+  const listed = await git(["ls-tree", "-r", "-l", "-z", "--full-tree", commit], dir).then((r) => r.stdout, () => void 0);
+  if (listed === void 0)
+    return void 0;
+  const files = listed.split("\0").filter(Boolean).flatMap((line) => {
+    const tab = line.indexOf("	");
+    const [mode, type, , size] = line.slice(0, tab).trim().split(/\s+/);
+    if (tab < 0 || type !== "blob" || mode === "120000")
+      return [];
+    return [{ path: line.slice(tab + 1), size: Number(size) || 0 }];
+  });
+  return {
+    files: async () => files,
+    read: (p) => git(["cat-file", "blob", `${commit}:${p}`], dir).then((r) => r.stdout, () => void 0)
+  };
+}
+async function specTreeOf(repo, dir, commit, git, note) {
+  const as = commit ? { commit } : {};
+  if (!existsSync(join(dir, ".git")))
+    return as;
+  if (commit) {
+    const tree2 = await commitTree(dir, commit, git);
+    if (tree2)
+      return { tree: tree2, commit };
+    note?.(`${repo}: the facts' commit ${commit.slice(0, 12)} isn't in the clone, so its specs are read at the clone's HEAD; fetch it, or read the repo again.`);
+  }
+  const tree = await commitTree(dir, "HEAD", git);
+  if (!tree) {
+    note?.(`${repo}: git can't list the clone's files, so its specs are read from the folder.`);
+    return as;
+  }
+  const head = await headCommitOf(dir);
+  return { tree, ...head ? { commit: head } : as };
+}
+async function writeRepoSpecs(root, repo, dir, facts, onRefused, git = createGit()) {
+  const { tree, commit } = await specTreeOf(repo, dir, await specsCommitOf(facts, dir, git), git, onRefused);
+  const deny = await denyHashesAt(root);
+  const file = await readRepoSpecs(dir, {
+    repo,
+    ...commit ? { commit } : {},
+    ...tree ? { tree } : {},
+    facts,
+    ...deny.size ? { denyHashes: deny } : {},
+    ...onRefused ? { onRefused } : {}
+  });
+  const path = join(factsDirOf(root), `${repo}.specs.yaml`);
+  if (file.specs.length)
+    await writeFileAtomic(path, (0, import_yaml.stringify)(file, { lineWidth: 0 }));
+  else
+    await rm(path, { force: true });
+  return file;
+}
+async function loadRepoSpecs(root) {
+  const files = [];
+  const problems = [];
+  const rel = factsRelOf(root);
+  for (const n of (await readdir(factsDirOf(root)).catch(() => [])).sort()) {
+    if (!n.endsWith(".specs.yaml"))
+      continue;
+    let v;
+    try {
+      v = (0, import_yaml.parse)(await readFile(join(factsDirOf(root), n), "utf8"));
+    } catch (e) {
+      problems.push(`${rel}/${n} isn't YAML (${e.message}); it is left out.`);
+      continue;
+    }
+    const p = SpecsFile.safeParse(v);
+    if (p.success)
+      files.push(p.data);
+    else
+      problems.push(`${rel}/${n} isn't a specs file; it is left out.`);
+  }
+  return { files, problems };
+}
+async function intakenSpec(root, doc, system) {
+  const body = await readFile(join(inputsDirOf(root), ...doc.path.split("/").slice(1)), "utf8").catch(() => void 0);
+  if (body === void 0)
+    return void 0;
+  const vendor = readVendorSpec(doc.path, body, system);
+  const specs = vendor ? openApiContractSpecs(vendor) : readContractSpecs(doc.path, body);
+  if (!specs.length)
+    return void 0;
+  return {
+    path: doc.path,
+    ...doc.title ? { title: doc.title } : {},
+    ...doc.version ? { version: doc.version } : {},
+    specs,
+    operations: (vendor?.operations ?? []).map((o) => ({
+      id: o.id,
+      method: o.method,
+      path: o.path,
+      fullPath: o.fullPath,
+      cite: o.cite
+    })),
+    hosts: vendor?.hosts ?? []
+  };
+}
+async function stampOf(root) {
+  const out = [];
+  const walk = async (dir, rel) => {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => void 0);
+    if (!entries)
+      return;
+    await Promise.all(entries.map(async (e) => {
+      const p = join(dir, e.name);
+      if (e.isDirectory())
+        return walk(p, `${rel}/${e.name}`);
+      const s = await stat(p).catch(() => void 0);
+      if (s)
+        out.push(`${rel}/${e.name}\0${s.size}\0${s.mtimeMs}`);
+    }));
+  };
+  const dirs = [
+    factsDirOf(root),
+    inputsDirOf(root),
+    orgPackDirOf(root),
+    questionsDirOf(root),
+    join(catalogDirOf(root), "curated")
+  ];
+  await Promise.all(dirs.map((d, i) => walk(d, String(i))));
+  return out.sort().join("\n");
+}
+var kept = /* @__PURE__ */ new Map();
+var cacheFileOf = (root, name) => join(resolve(root), ".atticus", "cache", `${name}.json`);
+var stampKey = (stamp) => createHash("sha256").update(VERSION).update("\0").update(stamp).digest("hex");
+async function readCached(root, name, stamp) {
+  try {
+    const c = JSON.parse(await readFile(cacheFileOf(root, name), "utf8"));
+    return c.key === stampKey(stamp) ? c.value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function writeCached(root, name, stamp, value) {
+  await writeFileAtomic(cacheFileOf(root, name), JSON.stringify({ key: stampKey(stamp), value })).catch(() => void 0);
+}
+var breathe = () => new Promise((r) => setImmediate(r));
+async function estateJoinOnFile(root, op, estate, stamp) {
+  const at = stamp ?? await stampOf(root);
+  const hit = await readCached(root, "estate-join", at);
+  if (hit)
+    return hit;
+  await breathe();
+  const join2 = estateJoinOf(op, estate.repos, estate.targets);
+  await writeCached(root, "estate-join", at, join2);
+  return join2;
+}
+async function contractCheckOf(root) {
+  const key = resolve(root);
+  const stamp = await stampOf(root);
+  const hit = kept.get(key);
+  if (hit && hit.stamp === stamp)
+    return hit.value;
+  const value = (async () => {
+    const disk = await readCached(root, "contract-check", stamp);
+    if (disk)
+      return { ...disk, newBySystem: new Map(disk.newBySystem) };
+    const v = await workOutContractCheck(root, stamp);
+    await writeCached(root, "contract-check", stamp, {
+      ...v,
+      newBySystem: [...v.newBySystem]
+    });
+    return v;
+  })();
+  kept.set(key, { stamp, value });
+  value.catch(() => {
+    if (kept.get(key)?.value === value)
+      kept.delete(key);
+  });
+  return value;
+}
+async function workOutContractCheck(root, stamp) {
+  const quiet = { out: () => void 0, err: () => void 0 };
+  const { op, inputs } = await intakeContext(root, quiet);
+  const estate = await estateFacts(root, op, "");
+  const join2 = await estateJoinOnFile(root, op, estate, stamp);
+  const { files, problems } = await loadRepoSpecs(root);
+  const systems = outsideProfileSystems(op);
+  const outside = [];
+  for (const s of systems) {
+    const docs = inputs.documents.filter((d) => d.id && SPEC_CLASSES.has(d.classification) && d.systems[0] === s.id);
+    const newestDoc = docs.find((d) => !d.supersededBy);
+    const previousDoc = newestDoc ? docs.find((d) => d.supersededBy === newestDoc.id) : void 0;
+    const newest = newestDoc ? await intakenSpec(root, newestDoc, s.id) : void 0;
+    const previous = previousDoc ? await intakenSpec(root, previousDoc, s.id) : void 0;
+    outside.push({
+      system: s.id,
+      name: s.name,
+      ...newest ? { newest } : {},
+      ...previous ? { previous } : {}
+    });
+  }
+  const repos = joinReposOf(op, estate.repos, componentRenames(estate.repos, op));
+  const run = (pick) => {
+    const specs = [];
+    const vendors = [];
+    for (const o of outside) {
+      const s = pick(o);
+      if (!s)
+        continue;
+      const sys = systems.find((x) => x.id === o.system);
+      specs.push({ system: o.system, name: o.name, specs: s.specs });
+      if (s.operations.length)
+        vendors.push({
+          system: o.system,
+          boundary: "internal",
+          names: [sys.name, ...sys.aliases],
+          hosts: [.../* @__PURE__ */ new Set([...s.hosts, ...hostAliases(sys.aliases)])],
+          operations: s.operations
+        });
+    }
+    const matched = vendors.length ? joinVendorOperations({ repos, vendors, targets: estate.targets, ...joinConventions(op) }) : { matches: [] };
+    return checkContracts({
+      repos: estate.repos,
+      join: join2,
+      specs: files,
+      outside: specs,
+      vendorMatches: matched.matches
+    });
+  };
+  await breathe();
+  const result = run((o) => o.newest);
+  const newBySystem = /* @__PURE__ */ new Map();
+  if (outside.some((o) => o.previous)) {
+    await breathe();
+    const before = run((o) => o.previous ?? o.newest);
+    for (const o of outside)
+      if (o.previous)
+        newBySystem.set(o.system, newFindings(result.findings.filter((f) => f.system === o.system), before.findings.filter((f) => f.system === o.system)));
+  }
+  return { result, notes: [...estate.notes, ...problems], outside, newBySystem };
+}
+
+export {
+  writeRepoSpecs,
+  estateJoinOnFile,
+  contractCheckOf
+};

package/dist/{chunk-JMSEEBN4.js → chunk-BRCDEGNE.js}

@@ -10,7 +10,7 @@ function draftCheckTool(root, request) {
   if (!request.selfCheck || !/^(feature|architecture|stories|small)-answer\.yaml$/.test(request.outputPath))
     return void 0;
   let box;
-  const planner = () => box ??= import("./chunk-UF7TAFJM.js").then((p) => p.draftCheckBox(root, request));
+  const planner = () => box ??= import("./chunk-3RP34PYV.js").then((p) => p.draftCheckBox(root, request));
   return {
     definitions: [
       {

package/dist/{chunk-67J3VZBA.js → chunk-BSVTNNUK.js}

@@ -5,26 +5,26 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   loadCatalog
-} from "./chunk-P3TKKBAH.js";
+} from "./chunk-ZPT4QX3J.js";
 import {
   TARGET_DIR,
   mergeDelta,
   readDeltas
-} from "./chunk-KC5DROFC.js";
+} from "./chunk-DWYPYVPJ.js";
 import {
   changeStore
-} from "./chunk-XQ3YIV5R.js";
+} from "./chunk-U5T4A2QV.js";
 import {
   changeView,
   toDrawio,
   toMermaid
-} from "./chunk-4GZXS6S2.js";
+} from "./chunk-MLAACAES.js";
 import {
   changesDirOf,
   changesRelOf,
   readRepoSpec,
   specRepos
-} from "./chunk-577AJVRS.js";
+} from "./chunk-U25OX22K.js";
 
 // packages/cli/dist/change-map.js
 import { stat } from "node:fs/promises";

package/dist/{chunk-3GTZ2OON.js → chunk-BTOGAUWX.js}

@@ -4,8 +4,11 @@ var require = __atticusCreateRequire(import.meta.url);
 var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
-  recordReadProgress
-} from "./chunk-HE4ZQXZM.js";
+  recordTopUpVerified
+} from "./chunk-QY7RGTUP.js";
+import {
+  notesAt
+} from "./chunk-ZS47PQ3O.js";
 import {
   carryOf,
   checkoutOf,
@@ -16,22 +19,23 @@ import {
   raiseReadQuestions,
   readCorrections,
   readReviewed,
+  recordReadProgress,
   reviewedProblemsOf,
   slipNoteLines,
   writeVerifyFiles
-} from "./chunk-B3O52AUQ.js";
+} from "./chunk-P76AW3PA.js";
 import {
   dirSource,
   frameworkFacts,
   frameworksToLearn,
   repairFormSlips,
   verifyFacts
-} from "./chunk-4GZXS6S2.js";
+} from "./chunk-MLAACAES.js";
 import {
   NoRoomError,
   roomGuard,
   streamFacts
-} from "./chunk-7F2RUWPU.js";
+} from "./chunk-ARLH2ZMD.js";
 import {
   factsDirOf,
   factsRelOf,
@@ -39,7 +43,7 @@ import {
   loadOrgPack,
   orgPackDirOf,
   stackHelpersOff
-} from "./chunk-577AJVRS.js";
+} from "./chunk-U25OX22K.js";
 
 // packages/cli/dist/verify-commands.js
 import { existsSync } from "node:fs";
@@ -88,8 +92,10 @@ async function verifyAllCommand(root, o, io) {
   io.out(`Verified ${repos.length === 1 ? "1 repo" : `${repos.length} repos`}: ${passed} passed${failed.length ? `, ${failed.length} with something to fix (${failed.join(", ")})` : ""}.`);
   return failed.length ? 1 : 0;
 }
-async function verifyInputsOf(root, repo) {
+async function verifyInputsOf(root, repo, dir) {
   return {
+    // ADR 0163: the org notes the read was handed, so a term's note is one of them.
+    notes: (await notesAt(root, repo, dir)).notes,
     corrections: await readCorrections(root, repo),
     reviewed: await readReviewed(root, repo),
     estate: await estateComponentsOf(root),
@@ -137,7 +143,7 @@ async function verifyCommand(root, repo, o, io) {
   const commit = o.commit ?? await headOf(dir);
   const source = dirSource(dir);
   const { carry, missing } = await carryOf(dir, parsed.facts, commit, o.git);
-  const inputs = await verifyInputsOf(root, repo);
+  const inputs = await verifyInputsOf(root, repo, dir);
   const { corrections, reviewed, estate, conventions } = inputs;
   for (const b of corrections.bad.slice(0, SHOWN))
     io.err(`${rel}/${repo}.corrections.jsonl line ${b.line} isn't a correction: ${b.message}`);
@@ -159,7 +165,8 @@ async function verifyCommand(root, repo, o, io) {
       room,
       // J1 (ADR 0143): an exposure read here names a component the manifest lists.
       ...estate ? { estate } : {},
-      conventions
+      conventions,
+      notes: inputs.notes
     });
   } catch (e) {
     if (!(e instanceof NoRoomError))
@@ -204,11 +211,13 @@ async function verifyCommand(root, repo, o, io) {
       now: o.now().toISOString().replace(/\.\d{3}Z$/, "Z")
     } : {}
   });
+  if (!failed)
+    await recordTopUpVerified(root, repo, { commit });
   const rejectedNote = `Nothing written to the catalog: ${report.rejected.length} facts were rejected. Fix them and run atticus verify ${repo} --write again.`;
   if (o.json) {
     let written2;
     if (o.write && !failed) {
-      const { writeFactsIntoCatalog: writeFactsIntoCatalog2 } = await import("./chunk-KM2FBM3T.js");
+      const { writeFactsIntoCatalog: writeFactsIntoCatalog2 } = await import("./chunk-PVW2N63M.js");
       written2 = await writeFactsIntoCatalog2(root, repo, report.accepted, { dir, command: `atticus verify ${repo} --write` }, { ...io, out: () => void 0 });
       if (!written2)
         return 1;
@@ -348,7 +357,7 @@ async function verifyCommand(root, repo, o, io) {
     io.out(`When the read is complete: atticus verify ${repo} --write puts the facts in the catalog, the flows in specs/${repo}/, and renders the map.`);
     return 0;
   }
-  const { writeFactsIntoCatalog } = await import("./chunk-KM2FBM3T.js");
+  const { writeFactsIntoCatalog } = await import("./chunk-PVW2N63M.js");
   const written = await writeFactsIntoCatalog(root, repo, report.accepted, { dir, command: `atticus verify ${repo} --write`, verbose: o.verbose === true }, io);
   return written ? 0 : 1;
 }

package/dist/{chunk-4SVJNVEE.js → chunk-BXBCMGIQ.js}

@@ -64,6 +64,8 @@ function aliasArgv(argv, positions) {
     out.splice(first, 2, "estate", "measure");
   else if (word === "join" && second === "shared")
     out.splice(first, 2, "estate", "shared");
+  else if (word === "join" && second === "contracts")
+    out.splice(first, 2, "estate", "contracts");
   else if (word === "join")
     out.splice(first, 1, "estate", "join");
   else if (word === "stories")

package/dist/chunk-BXP2Q4TD.js

@@ -0,0 +1,48 @@
+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 {
+  MIN_GIT,
+  MIN_NODE,
+  doctorChecks,
+  doctorCommand,
+  stepModelChoices,
+  stepModelLine
+} from "./chunk-SSL6JMPA.js";
+import "./chunk-3G4YI4ZU.js";
+import "./chunk-4G56W6H7.js";
+import "./chunk-DDZZXVQ5.js";
+import "./chunk-GHSVJNVL.js";
+import "./chunk-DWYPYVPJ.js";
+import "./chunk-ISXNWUG7.js";
+import "./chunk-GMDOXWIS.js";
+import "./chunk-U5T4A2QV.js";
+import "./chunk-JQG4VO47.js";
+import "./chunk-DW4BM73R.js";
+import "./chunk-22GLUHGE.js";
+import "./chunk-QR65C3DV.js";
+import "./chunk-MLAACAES.js";
+import "./chunk-HY2VVVFZ.js";
+import "./chunk-PJRMMWU4.js";
+import "./chunk-34NWVIBC.js";
+import "./chunk-77UOXZVM.js";
+import {
+  versionAtLeast
+} from "./chunk-TWHZU36X.js";
+import "./chunk-RA64IK43.js";
+import "./chunk-MRLCNXXR.js";
+import "./chunk-CQD26SMZ.js";
+import "./chunk-U25OX22K.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+export {
+  MIN_GIT,
+  MIN_NODE,
+  doctorChecks,
+  doctorCommand,
+  stepModelChoices,
+  stepModelLine,
+  versionAtLeast
+};

package/dist/{chunk-XPEEICAO.js → chunk-BZRWJUB4.js}

@@ -153,23 +153,23 @@ import {
   writeProposals,
   writeQuarantineItems,
   wroteIn
-} from "./chunk-47QE246J.js";
+} from "./chunk-GMDOXWIS.js";
 import {
   BUILT_IN_GATES
-} from "./chunk-XQ3YIV5R.js";
-import "./chunk-MGVYVW7Q.js";
-import "./chunk-NGPU2ARF.js";
-import "./chunk-AY2IUF4K.js";
-import "./chunk-6JLPXDWN.js";
-import "./chunk-4GZXS6S2.js";
-import "./chunk-R4TBNKKC.js";
-import "./chunk-NIXVDQVO.js";
-import "./chunk-UR7RMZ3R.js";
-import "./chunk-PGKHJYOB.js";
-import "./chunk-MKRBG5EF.js";
-import "./chunk-5XDNUJ4P.js";
-import "./chunk-577AJVRS.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-U5T4A2QV.js";
+import "./chunk-JQG4VO47.js";
+import "./chunk-DW4BM73R.js";
+import "./chunk-22GLUHGE.js";
+import "./chunk-QR65C3DV.js";
+import "./chunk-MLAACAES.js";
+import "./chunk-HY2VVVFZ.js";
+import "./chunk-PJRMMWU4.js";
+import "./chunk-34NWVIBC.js";
+import "./chunk-RA64IK43.js";
+import "./chunk-MRLCNXXR.js";
+import "./chunk-CQD26SMZ.js";
+import "./chunk-U25OX22K.js";
+import "./chunk-MMB2OHUY.js";
 import "./chunk-TV45EUGM.js";
 export {
   ANSWERS_TEXT,

package/dist/{chunk-MH5OCRUM.js → chunk-CH6LUQLD.js}

@@ -8,11 +8,11 @@ import {
   changesDirOf,
   orgPackDirOf,
   require_dist
-} from "./chunk-577AJVRS.js";
+} from "./chunk-U25OX22K.js";
 import {
   ensureLocalIgnore,
   redactText
-} from "./chunk-D3PO4DOZ.js";
+} from "./chunk-MMB2OHUY.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/{chunk-T6USVBEJ.js → chunk-CIIRPLI6.js}

@@ -45,16 +45,16 @@ import {
   utf8,
   visioIngestor,
   xlsxIngestor
-} from "./chunk-NIXVDQVO.js";
-import "./chunk-UR7RMZ3R.js";
-import "./chunk-MKRBG5EF.js";
+} from "./chunk-PJRMMWU4.js";
+import "./chunk-34NWVIBC.js";
+import "./chunk-MRLCNXXR.js";
 import {
   ZIP_LIMITS,
   ZipError,
   peekZip,
   readZip
-} from "./chunk-577AJVRS.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-U25OX22K.js";
+import "./chunk-MMB2OHUY.js";
 import "./chunk-TV45EUGM.js";
 export {
   DEFAULT_LEGEND,