@maycombhq/atticus 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/chunk-GS76RXQE.js

@@ -0,0 +1,226 @@
+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 {
+  forgetCatalogs,
+  readCatalog
+} from "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
+import "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import {
+  loadRepos
+} from "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import {
+  FACTS_COMPANIONS,
+  ManifestEditError,
+  RecordId,
+  catalogDirOf,
+  factsDirOf,
+  factsRelOf,
+  listQuestions,
+  mapRelOf,
+  orgPackDirOf,
+  parseRecord,
+  recordPath,
+  renameManifestRepo,
+  require_dist,
+  serializeRecord,
+  specRelOf,
+  writeQuestion
+} from "./chunk-PAINMSID.js";
+import {
+  LockHeldError,
+  acquireLock,
+  writeFileAtomic
+} from "./chunk-ODMBPDDV.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/repo-rename.js
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync } from "node:fs";
+import { readFile, rm } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+var posix = (p) => p.split(sep).join("/");
+function renamed(v, from, to) {
+  let changed = false;
+  const walk = (x) => {
+    if (Array.isArray(x))
+      return x.map(walk);
+    if (x && typeof x === "object") {
+      const out = {};
+      for (const [k, y] of Object.entries(x)) {
+        if (k === "repo" && y === from) {
+          out[k] = to;
+          changed = true;
+        } else
+          out[k] = walk(y);
+      }
+      return out;
+    }
+    return x;
+  };
+  return { value: walk(v), changed };
+}
+function renamedText(text, from, to) {
+  const esc = from.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return text.replace(new RegExp(`(?<![A-Za-z0-9._-])${esc}(?![A-Za-z0-9._-])`, "g"), to);
+}
+function rewriteFactsFile(name, text, from, to) {
+  if (name.endsWith(".jsonl"))
+    return text.split(/\r?\n/).map((line) => {
+      if (!line.trim())
+        return line;
+      try {
+        const r = renamed(JSON.parse(line), from, to);
+        return r.changed ? JSON.stringify(r.value) : line;
+      } catch {
+        return line;
+      }
+    }).join("\n");
+  try {
+    const r = renamed((0, import_yaml.parse)(text), from, to);
+    return r.changed ? (0, import_yaml.stringify)(r.value) : text;
+  } catch {
+    return text;
+  }
+}
+async function repoRename(root, from, to, io) {
+  if (!from || !to) {
+    io.err("Usage: atticus repo rename <old id> <new id>");
+    return 2;
+  }
+  if (!RecordId.safeParse(to).success) {
+    io.err(`${to} isn't a repo id: ids are lowercase slugs (a-z, 0-9, '.', '_' and '-').`);
+    return 2;
+  }
+  const listed = await loadRepos(root).catch(() => []);
+  if (!listed.some((r) => r.id === from)) {
+    io.err(`There is no repo ${from} in any manifest (atticus repos list shows the ids).`);
+    return 2;
+  }
+  if (listed.some((r) => r.id === to)) {
+    io.err(`${to} is already listed; repo ids are unique across every profile.`);
+    return 2;
+  }
+  const factsDir = factsDirOf(root);
+  const fRel = factsRelOf(root);
+  const moves = [];
+  for (const suffix of [".jsonl", ...FACTS_COMPANIONS]) {
+    const src = join(factsDir, `${from}${suffix}`);
+    if (!existsSync(src))
+      continue;
+    moves.push({
+      src,
+      dst: join(factsDir, `${to}${suffix}`),
+      rel: `${fRel}/${from}${suffix}`,
+      relTo: `${fRel}/${to}${suffix}`,
+      name: suffix
+    });
+  }
+  const scanDir = join(orgPackDirOf(root), "scan");
+  const scanSrc = join(scanDir, `${from}.yaml`);
+  if (existsSync(scanSrc)) {
+    const rel = posix(relative(root, scanDir));
+    moves.push({
+      src: scanSrc,
+      dst: join(scanDir, `${to}.yaml`),
+      rel: `${rel}/${from}.yaml`,
+      relTo: `${rel}/${to}.yaml`,
+      name: ".yaml"
+    });
+  }
+  const taken = moves.filter((m) => existsSync(m.dst));
+  if (taken.length) {
+    for (const m of taken)
+      io.err(`${m.relTo} is already there: move or remove it first, so ${m.rel} doesn't overwrite it. Nothing was changed.`);
+    return 1;
+  }
+  let lock;
+  try {
+    lock = await acquireLock(root, "scan", `atticus repo rename ${from} ${to}`);
+  } catch (e) {
+    if (e instanceof LockHeldError) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  try {
+    const said = [];
+    let manifest;
+    try {
+      manifest = await renameManifestRepo(root, from, to);
+    } catch (e) {
+      if (e instanceof ManifestEditError) {
+        io.err(e.message);
+        return e.code === "not-found" ? 2 : 1;
+      }
+      throw e;
+    }
+    said.push(`${manifest.rel}: the entry's id`);
+    for (const m of moves) {
+      const text = await readFile(m.src, "utf8");
+      await writeFileAtomic(m.dst, rewriteFactsFile(m.name, text, from, to));
+      await rm(m.src, { force: true });
+      said.push(`${m.rel} \u2192 ${m.relTo}`);
+    }
+    const qs = (await listQuestions(root)).questions.filter((q) => q.repo === from);
+    for (const q of qs) {
+      const next = {
+        ...q,
+        repo: to,
+        rerun: renamedText(q.rerun, from, to),
+        askedBy: { ...q.askedBy, command: renamedText(q.askedBy.command, from, to) },
+        ...q.scope.level === "repo" && q.scope.id === from ? { scope: { ...q.scope, id: to } } : {}
+      };
+      await writeQuestion(root, next);
+    }
+    if (qs.length)
+      said.push(`${qs.length} question${qs.length === 1 ? "" : "s"} (repo ${to})`);
+    let records = 0;
+    for (const sub of ["generated", "curated"]) {
+      const dir = join(catalogDirOf(root), sub);
+      const cat = await readCatalog(dir, { cacheRoot: root });
+      for (const r of cat.records) {
+        const n = renamed(r, from, to);
+        if (!n.changed)
+          continue;
+        const p = parseRecord(n.value);
+        if (!p.ok) {
+          io.err(`${r.kind} ${r.id} names ${from} but wouldn't be valid renamed (${p.issues.map((i) => i.message).join("; ")}); left as it is.`);
+          continue;
+        }
+        await writeFileAtomic(join(dir, ...recordPath(p.record).split("/")), serializeRecord(p.record));
+        records++;
+      }
+    }
+    forgetCatalogs();
+    if (records)
+      said.push(`${records} catalog record${records === 1 ? "" : "s"} (repo ${to})`);
+    io.out(`Renamed ${from} to ${to}:`);
+    for (const l of said)
+      io.out(`  ${l}`);
+    const left = [
+      existsSync(join(root, ...specRelOf(root, from).split("/"))) ? specRelOf(root, from) : "",
+      existsSync(join(root, ...`${mapRelOf(root)}/${from}`.split("/"))) ? `${mapRelOf(root)}/${from}` : ""
+    ].filter(Boolean);
+    if (left.length)
+      io.out(`Left as they are: ${left.join(" and ")}. atticus verify ${to} --write writes them under ${to}; remove the old ones in the same pull request.`);
+    io.out(`Review the change and commit it in a pull request: Atticus commits and pushes nothing. A clone under the old id is cloned again under ${to} by atticus workspace sync.`);
+    return 0;
+  } finally {
+    await lock.release();
+  }
+}
+export {
+  repoRename
+};

package/dist/{chunk-YYQN46FY.js → chunk-GSGIZ2OO.js}

@@ -3,40 +3,40 @@ 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-GLUX4EEP.js";
+import "./chunk-K6JB6XTX.js";
 import {
   loadCatalog
-} from "./chunk-FITWGOJ2.js";
+} from "./chunk-5QUOPNLN.js";
 import {
   repoFor
-} from "./chunk-O3WI5KWW.js";
+} from "./chunk-TGVVUKTG.js";
 import {
   recordFact,
   verifyScan
-} from "./chunk-KEM4SDDP.js";
-import "./chunk-ZVM6AKKM.js";
+} from "./chunk-P2VBXX7N.js";
+import "./chunk-ZOSD4FXV.js";
 import {
   stepJudges
-} from "./chunk-CKSITVS4.js";
-import "./chunk-L6SGQIR3.js";
-import "./chunk-3HI6Z55Y.js";
-import "./chunk-XY3P7JW7.js";
-import "./chunk-4AK7IBVP.js";
-import "./chunk-7JUKDRSZ.js";
+} from "./chunk-BEPCKDCP.js";
+import "./chunk-HWD4JPU7.js";
+import "./chunk-5WERBKLE.js";
+import "./chunk-K332XW7K.js";
+import "./chunk-HSZMPH5T.js";
+import "./chunk-D2WSW4GU.js";
+import "./chunk-4KNOJC6J.js";
 import {
   checkScanSettings
-} from "./chunk-27NKUS3X.js";
-import "./chunk-L24C55VN.js";
-import "./chunk-PAMPPUR6.js";
-import "./chunk-23W7VWKR.js";
-import "./chunk-7EKXJZ2Y.js";
-import "./chunk-MC3H7736.js";
-import "./chunk-T6AIP7H5.js";
-import "./chunk-EFHQ3TWP.js";
+} from "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
+import "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
 import {
   fsRepo
-} from "./chunk-GQ4N4WKF.js";
-import "./chunk-CNUKCS2T.js";
+} from "./chunk-7AB6OWTV.js";
 import {
   SCAN_VERIFY_SCHEMA_VERSION,
   ScanSettings,
@@ -50,8 +50,8 @@ import {
   raiseQuestions,
   require_dist,
   reusedLine
-} from "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/chunk-GUYL7RMK.js

@@ -0,0 +1,60 @@
+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 {
+  READS_AS_RULE,
+  dataBlock,
+  draftPrompt,
+  missedOf,
+  rulesAddCommand,
+  rulesDraftCommand,
+  rulesImportCommand,
+  rulesListCommand,
+  rulesNotesCommand,
+  rulesSetCommand,
+  rulesTryCommand,
+  scopeFile,
+  tryDiff
+} from "./chunk-JRVNXLZP.js";
+import "./chunk-LIJJCBQI.js";
+import "./chunk-26Z7OGQW.js";
+import "./chunk-OKUB6RJA.js";
+import "./chunk-THN26IEF.js";
+import "./chunk-L4CESDPB.js";
+import "./chunk-455SYIIE.js";
+import "./chunk-3J5I7ZOU.js";
+import "./chunk-GIFMBCTW.js";
+import "./chunk-MD7KUEJ3.js";
+import "./chunk-Q46QDDMF.js";
+import "./chunk-TGVVUKTG.js";
+import "./chunk-3AQ2R5NL.js";
+import "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
+import "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import "./chunk-VUVGX5L2.js";
+import "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
+import "./chunk-TV45EUGM.js";
+export {
+  READS_AS_RULE,
+  dataBlock,
+  draftPrompt,
+  missedOf,
+  rulesAddCommand,
+  rulesDraftCommand,
+  rulesImportCommand,
+  rulesListCommand,
+  rulesNotesCommand,
+  rulesSetCommand,
+  rulesTryCommand,
+  scopeFile,
+  tryDiff
+};

package/dist/chunk-GX74YWR7.js

@@ -0,0 +1,321 @@
+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 {
+  headCommitOf
+} from "./chunk-G6IQYM25.js";
+import {
+  denyHashesAt
+} from "./chunk-LPV6T362.js";
+import {
+  intakeContext
+} from "./chunk-TQ4TG57V.js";
+import {
+  componentRenames,
+  estateFacts,
+  estateJoinOf,
+  hostAliases,
+  joinReposOf,
+  outsideProfileSystems
+} from "./chunk-4SLBCEPD.js";
+import {
+  sameCommit
+} from "./chunk-JYMIB5XY.js";
+import {
+  openApiContractSpecs,
+  readContractSpecs,
+  readRepoSpecs,
+  readVendorSpec
+} from "./chunk-CPK7QSBG.js";
+import {
+  VERSION
+} from "./chunk-VUVGX5L2.js";
+import {
+  createGit
+} from "./chunk-XOL3GFW2.js";
+import {
+  SpecsFile,
+  catalogDirOf,
+  checkContracts,
+  factsDirOf,
+  factsRelOf,
+  inputsDirOf,
+  joinConventions,
+  joinVendorOperations,
+  newFindings,
+  orgPackDirOf,
+  questionsDirOf,
+  require_dist
+} from "./chunk-PAINMSID.js";
+import {
+  writeFileAtomic
+} from "./chunk-ODMBPDDV.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, estate.pairs, estate.aiTargets);
+  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,
+  stampOf,
+  estateJoinOnFile,
+  contractCheckOf
+};