@iowarp/clio-coder 0.3.2 → 0.3.4

package/dist/verifiers-4UUM6TEE.js

@@ -0,0 +1,1214 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  discoverDeclaredChecksAtRoot,
+  verifyTool
+} from "./chunk-PCZJO5TI.js";
+import "./chunk-NILBFAPG.js";
+import {
+  PROJECT_VERIFIER_CATALOG_CAPS,
+  PROJECT_VERIFIER_CATALOG_RELATIVE_PATH,
+  PROJECT_VERIFIER_CATALOG_VERSION,
+  compareCodepoints,
+  loadProjectVerifierCatalog,
+  parseProjectVerifierCatalogText
+} from "./chunk-FYYLNIL5.js";
+import {
+  isVerificationScriptName
+} from "./chunk-UL3WSD3F.js";
+import "./chunk-VG7TBQIY.js";
+import "./chunk-OQE5J4C6.js";
+import "./chunk-ECH6PKUQ.js";
+import "./chunk-6XLNIQDB.js";
+import "./chunk-5B2AEOW5.js";
+import "./chunk-CGKSTWHD.js";
+import {
+  printError,
+  printOk
+} from "./chunk-ED4KHGC3.js";
+import "./chunk-5TSRNF4G.js";
+import {
+  SAFE_EXEC_DEFAULT_TIMEOUT_MS,
+  resolveSafeCwd
+} from "./chunk-VEZEGCGW.js";
+import "./chunk-FQ4SKYE4.js";
+import "./chunk-FCSXB6T2.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import "./chunk-YXLYO42X.js";
+import "./chunk-BNAZZHFG.js";
+import "./chunk-6EJMN2Y3.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/verifiers.ts
+init_esm_shims();
+
+// src/tools/verify/authoring.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { randomUUID } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import path from "node:path";
+var DECLARED_FILE_CAP_BYTES = 1024 * 1024;
+var VALIDATION_CONTRACT_PATHS = [
+  ".clio-coder/validation.yaml",
+  ".clio-coder/validation.yml",
+  "validation.yaml",
+  "validation.yml"
+];
+function manualEntryInstruction() {
+  return 'No unambiguous declared command was found. Add one explicitly with `clio-coder verifiers add --id <id> --description <text> --command \'["executable","arg"]\'`; `--command` is an exact JSON argv array. Review the preview, then rerun with `--yes`.';
+}
+function cloneCheck(check) {
+  return {
+    ...check,
+    command: [...check.command],
+    tags: [...check.tags],
+    provenance: { ...check.provenance }
+  };
+}
+function relativePath(workspaceRoot, filePath) {
+  const relative = path.relative(workspaceRoot, filePath);
+  return relative.length === 0 ? "." : relative.split(path.sep).join("/");
+}
+function regularFileText(filePath, workspaceRoot) {
+  if (!existsSync(filePath)) return null;
+  try {
+    const realRoot = realpathSync(workspaceRoot);
+    const realFilePath = realpathSync(filePath);
+    resolveSafeCwd(realFilePath, realRoot);
+    const stats = statSync(realFilePath);
+    if (!stats.isFile()) return new Error("path is not a regular file");
+    if (stats.size > DECLARED_FILE_CAP_BYTES) {
+      return new Error(`file exceeds the ${DECLARED_FILE_CAP_BYTES}-byte discovery cap`);
+    }
+    return readFileSync(realFilePath, "utf8");
+  } catch (error) {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+}
+function slug(value, fallback) {
+  const normalized = value.toLowerCase().replace(/[^a-z0-9._:-]+/gu, "-").replace(/^[^a-z0-9]+/u, "").replace(/[-.:]+$/u, "");
+  return normalized.length > 0 ? normalized : fallback;
+}
+function boundedId(base, suffix = "") {
+  const cap = PROJECT_VERIFIER_CATALOG_CAPS.idBytes - Buffer.byteLength(suffix, "utf8");
+  let result = "";
+  for (const character of base) {
+    if (Buffer.byteLength(result + character, "utf8") > cap) break;
+    result += character;
+  }
+  result = result.replace(/[-.:]+$/u, "");
+  return `${result.length > 0 ? result : "check"}${suffix}`;
+}
+function deterministicVerifierId(preferredId, occupied) {
+  const base = boundedId(slug(preferredId, "check"));
+  if (!occupied.has(base) && base !== "frontend") return base;
+  for (let index = 2; index <= PROJECT_VERIFIER_CATALOG_CAPS.checks + 2; index += 1) {
+    const suffix = `-${index}`;
+    const candidate = boundedId(base, suffix);
+    if (!occupied.has(candidate) && candidate !== "frontend") return candidate;
+  }
+  throw new Error(`cannot allocate a deterministic ID for '${preferredId}' within the catalog cap`);
+}
+function rawProposalSort(left, right) {
+  return compareCodepoints(left.provenance.path, right.provenance.path) || compareCodepoints(left.provenance.detail, right.provenance.detail) || compareCodepoints(left.preferredId, right.preferredId) || compareCodepoints(JSON.stringify(left.command), JSON.stringify(right.command));
+}
+function checkIdentity(check) {
+  return JSON.stringify([check.cwd, check.command]);
+}
+function sourceProvenance(workspaceRoot, check) {
+  if (check.source.kind === "package.json") {
+    return {
+      kind: "package-script",
+      path: relativePath(workspaceRoot, check.source.path),
+      detail: `package.json script '${check.id}'`,
+      authority: "project-declared"
+    };
+  }
+  return {
+    kind: "project-catalog",
+    path: PROJECT_VERIFIER_CATALOG_RELATIVE_PATH,
+    detail: `existing catalog check '${check.id}'`,
+    authority: "project-declared"
+  };
+}
+function projectedCheck(workspaceRoot, check) {
+  return {
+    id: check.id,
+    description: check.description,
+    command: [...check.command],
+    cwd: check.cwd,
+    timeoutMs: check.timeoutMs,
+    tags: [...check.tags],
+    provenance: sourceProvenance(workspaceRoot, check),
+    state: check.source.kind === "package.json" ? "active" : "existing",
+    ...check.source.kind === "package.json" ? {} : { catalogId: check.id }
+  };
+}
+function cargoProposals(workspaceRoot, diagnostics) {
+  const relative = "Cargo.toml";
+  const text = regularFileText(path.join(workspaceRoot, relative), workspaceRoot);
+  if (text === null) return [];
+  if (text instanceof Error) {
+    diagnostics.push(`${relative}: ${text.message}; Cargo discovery skipped.`);
+    return [];
+  }
+  const workspace = /^\s*\[workspace(?:\]|\.)/mu.test(text);
+  const packageManifest = /^\s*\[package\]/mu.test(text);
+  if (!workspace && !packageManifest) {
+    diagnostics.push(`${relative}: no [package] or [workspace] declaration was found; Cargo discovery skipped.`);
+    return [];
+  }
+  return [
+    {
+      preferredId: "cargo-test",
+      description: workspace ? "Run the Cargo workspace tests" : "Run the Cargo package tests",
+      command: workspace ? ["cargo", "test", "--workspace"] : ["cargo", "test"],
+      cwd: ".",
+      timeoutMs: SAFE_EXEC_DEFAULT_TIMEOUT_MS,
+      tags: ["rust", "test"],
+      provenance: {
+        kind: "cargo",
+        path: relative,
+        detail: workspace ? "Cargo [workspace] manifest" : "Cargo package manifest",
+        authority: "toolchain-defined"
+      }
+    }
+  ];
+}
+function cmakeProposals(workspaceRoot, diagnostics) {
+  const relative = "CMakePresets.json";
+  const text = regularFileText(path.join(workspaceRoot, relative), workspaceRoot);
+  if (text === null) return [];
+  if (text instanceof Error) {
+    diagnostics.push(`${relative}: ${text.message}; CMake preset discovery skipped.`);
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    diagnostics.push(`${relative}: invalid JSON (${error instanceof Error ? error.message : String(error)}).`);
+    return [];
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    diagnostics.push(`${relative}: root is not an object; CMake preset discovery skipped.`);
+    return [];
+  }
+  const record = parsed;
+  const proposals = [];
+  for (const [field, executable, args, label, tag] of [
+    ["testPresets", "ctest", ["--preset"], "test", "test"],
+    ["buildPresets", "cmake", ["--build", "--preset"], "build", "build"]
+  ]) {
+    const presets = record[field];
+    if (!Array.isArray(presets)) continue;
+    for (const preset of presets) {
+      if (preset === null || typeof preset !== "object" || Array.isArray(preset)) continue;
+      const value = preset;
+      if (value.hidden === true || typeof value.name !== "string" || value.name.length === 0) continue;
+      const name = value.name;
+      proposals.push({
+        preferredId: `cmake-${label}-${slug(name, "preset")}`,
+        description: `Run CMake ${label} preset '${name}'`,
+        command: [executable, ...args, name],
+        cwd: ".",
+        timeoutMs: SAFE_EXEC_DEFAULT_TIMEOUT_MS,
+        tags: ["cmake", tag],
+        provenance: {
+          kind: "cmake-preset",
+          path: relative,
+          detail: `${field} entry '${name}'`,
+          authority: "toolchain-defined"
+        }
+      });
+    }
+  }
+  if (proposals.length === 0) diagnostics.push(`${relative}: no visible buildPresets or testPresets were declared.`);
+  return proposals;
+}
+function tomlSections(text) {
+  const sections = /* @__PURE__ */ new Map();
+  let active = "";
+  for (const line of text.split(/\r?\n/u)) {
+    const header = /^\s*\[([^\]]+)\]\s*(?:#.*)?$/u.exec(line);
+    if (header?.[1] !== void 0) {
+      active = header[1].trim();
+      if (!sections.has(active)) sections.set(active, []);
+      continue;
+    }
+    if (active.length > 0) sections.get(active)?.push(line);
+  }
+  return sections;
+}
+function declaredScriptName(line) {
+  const match = /^\s*(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_.:-]+))\s*=\s*(?:"[^"]+"|'[^']+')\s*(?:#.*)?$/u.exec(line);
+  return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+}
+function pythonProposals(workspaceRoot, diagnostics) {
+  const proposals = [];
+  const pyprojectPath = "pyproject.toml";
+  const pyproject = regularFileText(path.join(workspaceRoot, pyprojectPath), workspaceRoot);
+  if (pyproject instanceof Error) diagnostics.push(`${pyprojectPath}: ${pyproject.message}; Python discovery skipped.`);
+  if (typeof pyproject === "string") {
+    const sections = tomlSections(pyproject);
+    for (const [section, module, id, description, tags2] of [
+      ["tool.pytest.ini_options", "pytest", "python-pytest", "Run the declared pytest suite", ["python", "test"]],
+      ["tool.tox", "tox", "python-tox", "Run the declared tox environments", ["python", "test"]],
+      ["tool.nox", "nox", "python-nox", "Run the declared nox sessions", ["python", "test"]]
+    ]) {
+      if (!sections.has(section)) continue;
+      proposals.push({
+        preferredId: id,
+        description,
+        command: ["python", "-m", module],
+        cwd: ".",
+        timeoutMs: SAFE_EXEC_DEFAULT_TIMEOUT_MS,
+        tags: [...tags2],
+        provenance: {
+          kind: "python-runner",
+          path: pyprojectPath,
+          detail: `[${section}]`,
+          authority: "toolchain-defined"
+        }
+      });
+    }
+    for (const section of ["project.scripts", "tool.poetry.scripts"]) {
+      for (const line of sections.get(section) ?? []) {
+        const name = declaredScriptName(line);
+        if (name === null || !isVerificationScriptName(name)) continue;
+        proposals.push({
+          preferredId: `python-${slug(name, "check")}`,
+          description: `Run declared Python entry point '${name}'`,
+          command: [name],
+          cwd: ".",
+          timeoutMs: SAFE_EXEC_DEFAULT_TIMEOUT_MS,
+          tags: [slug(name.split(/[:.-]/u)[0] ?? "python", "python"), "python"],
+          provenance: {
+            kind: "python-runner",
+            path: pyprojectPath,
+            detail: `[${section}] entry '${name}'`,
+            authority: "project-declared"
+          }
+        });
+      }
+    }
+  }
+  for (const [relative, marker, module, id, description] of [
+    ["pytest.ini", null, "pytest", "python-pytest", "Run the declared pytest suite"],
+    ["tox.ini", null, "tox", "python-tox", "Run the declared tox environments"],
+    ["noxfile.py", null, "nox", "python-nox", "Run the declared nox sessions"],
+    ["setup.cfg", /^\s*\[tool:pytest\]/mu, "pytest", "python-pytest", "Run the declared pytest suite"]
+  ]) {
+    const text = regularFileText(path.join(workspaceRoot, relative), workspaceRoot);
+    if (text === null) continue;
+    if (text instanceof Error) {
+      diagnostics.push(`${relative}: ${text.message}; Python discovery skipped.`);
+      continue;
+    }
+    if (marker !== null && !marker.test(text)) continue;
+    proposals.push({
+      preferredId: id,
+      description,
+      command: ["python", "-m", module],
+      cwd: ".",
+      timeoutMs: SAFE_EXEC_DEFAULT_TIMEOUT_MS,
+      tags: ["python", "test"],
+      provenance: {
+        kind: "python-runner",
+        path: relative,
+        detail: `${module} configuration file`,
+        authority: "toolchain-defined"
+      }
+    });
+  }
+  return proposals;
+}
+function goProposals(workspaceRoot, diagnostics) {
+  const relative = "go.mod";
+  const text = regularFileText(path.join(workspaceRoot, relative), workspaceRoot);
+  if (text === null) return [];
+  if (text instanceof Error) {
+    diagnostics.push(`${relative}: ${text.message}; Go discovery skipped.`);
+    return [];
+  }
+  if (!/^\s*module\s+\S+/mu.test(text)) {
+    diagnostics.push(`${relative}: no module directive was found; Go discovery skipped.`);
+    return [];
+  }
+  return [
+    {
+      preferredId: "go-test",
+      description: "Run all Go module tests",
+      command: ["go", "test", "./..."],
+      cwd: ".",
+      timeoutMs: SAFE_EXEC_DEFAULT_TIMEOUT_MS,
+      tags: ["go", "test"],
+      provenance: {
+        kind: "go-module",
+        path: relative,
+        detail: "Go module directive",
+        authority: "toolchain-defined"
+      }
+    }
+  ];
+}
+function shellLikeArgv(command) {
+  const argv = [];
+  let token = "";
+  let quote = null;
+  let tokenStarted = false;
+  for (let index = 0; index < command.length; index += 1) {
+    const character = command[index] ?? "";
+    if (quote === "single") {
+      if (character === "'") quote = null;
+      else token += character;
+      tokenStarted = true;
+      continue;
+    }
+    if (quote === "double") {
+      if (character === '"') {
+        quote = null;
+        continue;
+      }
+      if (character === "\\") {
+        const next = command[index + 1];
+        if (next === void 0) return new Error("trailing escape");
+        token += next;
+        index += 1;
+      } else if (character === "$" || character === "`") {
+        return new Error(`shell expansion '${character}' is ambiguous`);
+      } else {
+        token += character;
+      }
+      tokenStarted = true;
+      continue;
+    }
+    if (/\s/u.test(character)) {
+      if (tokenStarted) {
+        argv.push(token);
+        token = "";
+        tokenStarted = false;
+      }
+      continue;
+    }
+    if (character === "'") {
+      quote = "single";
+      tokenStarted = true;
+      continue;
+    }
+    if (character === '"') {
+      quote = "double";
+      tokenStarted = true;
+      continue;
+    }
+    if (character === "\\") {
+      const next = command[index + 1];
+      if (next === void 0) return new Error("trailing escape");
+      token += next;
+      tokenStarted = true;
+      index += 1;
+      continue;
+    }
+    if ("|&;<>()`$\n\r".includes(character)) {
+      return new Error(`shell operator or expansion '${character}' is ambiguous`);
+    }
+    token += character;
+    tokenStarted = true;
+  }
+  if (quote !== null) return new Error(`unterminated ${quote}-quoted argument`);
+  if (tokenStarted) argv.push(token);
+  if (argv.length === 0) return new Error("empty command");
+  if ((argv[0] ?? "").includes("=")) return new Error("environment assignments are not argv executables");
+  return argv;
+}
+function validatorArgv(value) {
+  if (typeof value === "string") return shellLikeArgv(value);
+  if (!Array.isArray(value) || value.length === 0 || value.some((entry) => typeof entry !== "string" || entry.length === 0)) {
+    return new Error("validator must be a command string or a non-empty argv string array");
+  }
+  return [...value];
+}
+function validationPreferredId(argv) {
+  const executable = path.basename(argv[0] ?? "check").replace(/\.[^.]+$/u, "");
+  const script = argv.find((entry, index) => index > 0 && /\.(?:py|js|mjs|sh)$/u.test(entry));
+  const subject = script === void 0 ? executable : path.basename(script).replace(/\.[^.]+$/u, "");
+  return `validation-${slug(subject, "check")}`;
+}
+function validationContractProposals(workspaceRoot, diagnostics) {
+  const proposals = [];
+  for (const relative of VALIDATION_CONTRACT_PATHS) {
+    const text = regularFileText(path.join(workspaceRoot, relative), workspaceRoot);
+    if (text === null) continue;
+    if (text instanceof Error) {
+      diagnostics.push(`${relative}: ${text.message}; validation command discovery skipped.`);
+      continue;
+    }
+    const document = (0, import_yaml.parseDocument)(text, { prettyErrors: false, strict: true, uniqueKeys: true });
+    if (document.errors.length > 0) {
+      diagnostics.push(`${relative}: invalid YAML; validation command discovery skipped.`);
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = document.toJS({ maxAliasCount: 0 });
+    } catch (error) {
+      diagnostics.push(`${relative}: invalid YAML (${error instanceof Error ? error.message : String(error)}).`);
+      continue;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+    const validators = parsed.validators;
+    if (!Array.isArray(validators)) continue;
+    for (const [index, validator] of validators.entries()) {
+      const record = validator !== null && typeof validator === "object" && !Array.isArray(validator) ? validator : null;
+      if (record !== null) {
+        const typedFields = [
+          ["id", (value) => typeof value === "string"],
+          ["description", (value) => typeof value === "string"],
+          ["cwd", (value) => typeof value === "string"],
+          ["timeoutMs", (value) => typeof value === "number"],
+          ["tags", (value) => Array.isArray(value) && value.every((tag) => typeof tag === "string")]
+        ];
+        const invalidField = typedFields.find(([field, valid]) => Object.hasOwn(record, field) && !valid(record[field]));
+        if (invalidField !== void 0) {
+          diagnostics.push(
+            `${relative}: validators[${index}].${String(invalidField[0])} has an ambiguous type; use manual argv entry.`
+          );
+          continue;
+        }
+      }
+      const commandValue = record === null ? validator : record.command;
+      const argv = validatorArgv(commandValue);
+      if (argv instanceof Error) {
+        diagnostics.push(`${relative}: validators[${index}] is ambiguous (${argv.message}); use manual argv entry.`);
+        continue;
+      }
+      const declaredId = typeof record?.id === "string" ? record.id : validationPreferredId(argv);
+      const description = typeof record?.description === "string" ? record.description : `Run validation contract command ${JSON.stringify(argv)}`;
+      const cwd = typeof record?.cwd === "string" ? record.cwd : ".";
+      const timeoutMs = typeof record?.timeoutMs === "number" ? record.timeoutMs : SAFE_EXEC_DEFAULT_TIMEOUT_MS;
+      const tags2 = Array.isArray(record?.tags) ? record.tags.filter((tag) => typeof tag === "string") : [];
+      proposals.push({
+        preferredId: declaredId,
+        description,
+        command: argv,
+        cwd,
+        timeoutMs,
+        tags: tags2.length > 0 ? tags2 : ["scientific", "validation"],
+        provenance: {
+          kind: "validation-contract",
+          path: relative,
+          detail: `validators[${index}]`,
+          authority: "project-declared"
+        }
+      });
+    }
+  }
+  if (existsSync(path.join(workspaceRoot, "VALIDATION.md"))) {
+    diagnostics.push(
+      "VALIDATION.md is advisory prose; enter an exact argv vector manually instead of inferring a command."
+    );
+  }
+  return proposals;
+}
+function deduplicatedRawProposals(proposals, diagnostics) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const proposal of proposals.sort(rawProposalSort)) {
+    const identity = checkIdentity(proposal);
+    const prior = seen.get(identity);
+    if (prior !== void 0) {
+      diagnostics.push(
+        `${proposal.provenance.path} (${proposal.provenance.detail}) repeats ${prior.provenance.path} (${prior.provenance.detail}); one proposal was kept.`
+      );
+      continue;
+    }
+    seen.set(identity, proposal);
+  }
+  return [...seen.values()];
+}
+function discoverVerifierAuthoring(workspaceRoot = process.cwd()) {
+  const manualEntry = manualEntryInstruction();
+  const productionDiscovery = discoverDeclaredChecksAtRoot(workspaceRoot, void 0);
+  if (!productionDiscovery.ok) {
+    return {
+      ok: false,
+      reason: `Cannot author over the existing verifier authority: ${productionDiscovery.reason}`,
+      manualEntry
+    };
+  }
+  const activeChecks = [];
+  const existingChecks = [];
+  for (const source of productionDiscovery.sources) {
+    for (const check of source.checks) {
+      const projected = projectedCheck(workspaceRoot, check);
+      if (projected.state === "active") activeChecks.push(projected);
+      else existingChecks.push(projected);
+    }
+  }
+  activeChecks.sort((left, right) => compareCodepoints(left.id, right.id));
+  existingChecks.sort((left, right) => compareCodepoints(left.id, right.id));
+  const diagnostics = [];
+  const raw = deduplicatedRawProposals(
+    [
+      ...cargoProposals(workspaceRoot, diagnostics),
+      ...cmakeProposals(workspaceRoot, diagnostics),
+      ...pythonProposals(workspaceRoot, diagnostics),
+      ...goProposals(workspaceRoot, diagnostics),
+      ...validationContractProposals(workspaceRoot, diagnostics)
+    ],
+    diagnostics
+  );
+  const occupied = new Set([...activeChecks, ...existingChecks].map((check) => check.id));
+  const represented = new Map(existingChecks.map((check) => [checkIdentity(check), check.id]));
+  const proposals = [];
+  for (const proposal of raw) {
+    const priorId = represented.get(checkIdentity(proposal));
+    if (priorId !== void 0) {
+      diagnostics.push(
+        `${proposal.provenance.path} (${proposal.provenance.detail}) is already represented by catalog check '${priorId}'.`
+      );
+      continue;
+    }
+    const normalizedId = boundedId(slug(proposal.preferredId, "check"));
+    const id = deterministicVerifierId(proposal.preferredId, occupied);
+    if (normalizedId !== proposal.preferredId) {
+      diagnostics.push(`Proposed ID '${proposal.preferredId}' was normalized to '${normalizedId}'.`);
+    }
+    if (id !== normalizedId) {
+      diagnostics.push(`Proposed ID '${normalizedId}' collides with declared authority; using '${id}'.`);
+    }
+    occupied.add(id);
+    represented.set(checkIdentity(proposal), id);
+    proposals.push({
+      id,
+      description: proposal.description,
+      command: [...proposal.command],
+      cwd: proposal.cwd,
+      timeoutMs: proposal.timeoutMs,
+      tags: [...proposal.tags],
+      provenance: { ...proposal.provenance },
+      state: "proposed"
+    });
+  }
+  proposals.sort((left, right) => compareCodepoints(left.id, right.id));
+  if (activeChecks.length === 0 && existingChecks.length === 0 && proposals.length === 0) {
+    diagnostics.push(
+      "No package verification script, supported toolchain declaration, or exact validation command was found."
+    );
+  }
+  const catalogPath = path.join(workspaceRoot, PROJECT_VERIFIER_CATALOG_RELATIVE_PATH);
+  const catalogText = regularFileText(catalogPath, workspaceRoot);
+  return {
+    ok: true,
+    workspaceRoot,
+    catalogPath,
+    activeChecks,
+    existingChecks,
+    proposals,
+    diagnostics,
+    manualEntry,
+    ...typeof catalogText === "string" ? { catalogText } : {}
+  };
+}
+function createVerifierDraft(discovery, options = {}) {
+  return {
+    workspaceRoot: discovery.workspaceRoot,
+    catalogPath: discovery.catalogPath,
+    activeChecks: discovery.activeChecks.map(cloneCheck),
+    checks: [...discovery.existingChecks, ...options.includeProposals === false ? [] : discovery.proposals].map(cloneCheck).sort((left, right) => compareCodepoints(left.id, right.id)),
+    diagnostics: [...discovery.diagnostics],
+    manualEntry: discovery.manualEntry,
+    ...discovery.catalogText === void 0 ? {} : { catalogText: discovery.catalogText }
+  };
+}
+function catalogEntry({ id, description, command, cwd, timeoutMs, tags: tags2 }) {
+  return { id, description, command: [...command], cwd, timeoutMs, tags: [...tags2] };
+}
+function serializeVerifierDraft(draft) {
+  const checks = [...draft.checks].sort((left, right) => compareCodepoints(left.id, right.id));
+  const document = draft.catalogText === void 0 ? null : (0, import_yaml.parseDocument)(draft.catalogText);
+  const sequence = document?.get("checks");
+  if (document === null || !(0, import_yaml.isSeq)(sequence)) {
+    return (0, import_yaml.stringify)({ version: PROJECT_VERIFIER_CATALOG_VERSION, checks: checks.map(catalogEntry) }, { lineWidth: 0 });
+  }
+  const nodes = /* @__PURE__ */ new Map();
+  for (const node of sequence.items) if ((0, import_yaml.isMap)(node)) nodes.set(node.get("id"), node);
+  const kept = /* @__PURE__ */ new Set();
+  const appended = [];
+  let changed = false;
+  for (const check of checks) {
+    const entry = catalogEntry(check);
+    const node = nodes.get(check.catalogId ?? check.id);
+    if (node === void 0) {
+      appended.push(document.createNode(entry));
+      continue;
+    }
+    kept.add(node);
+    const current = node.toJSON();
+    for (const [field, value] of Object.entries(entry)) {
+      if (JSON.stringify(current[field]) === JSON.stringify(value)) continue;
+      node.set(field, value);
+      changed = true;
+    }
+  }
+  if (!changed && appended.length === 0 && kept.size === sequence.items.length) return draft.catalogText;
+  sequence.items = [...sequence.items.filter((node) => (0, import_yaml.isMap)(node) && kept.has(node)), ...appended];
+  return document.toString({ lineWidth: 0 });
+}
+function validateVerifierDraft(draft) {
+  const text = serializeVerifierDraft(draft);
+  const parsed = parseProjectVerifierCatalogText(text, draft.workspaceRoot, draft.catalogPath);
+  if (!parsed.ok) return { ok: false, reason: parsed.reason, text };
+  const activeId = new Map(draft.activeChecks.map((check) => [check.id, check]));
+  for (const check of parsed.source?.checks ?? []) {
+    const collision = activeId.get(check.id);
+    if (collision !== void 0) {
+      return {
+        ok: false,
+        reason: `duplicate declared check id '${check.id}' from ${collision.provenance.kind} (${collision.provenance.path}) and project-catalog (${PROJECT_VERIFIER_CATALOG_RELATIVE_PATH})`,
+        text
+      };
+    }
+  }
+  const byId = new Map(draft.checks.map((check) => [check.id, check]));
+  const checks = (parsed.source?.checks ?? []).map((check) => {
+    const original = byId.get(check.id);
+    return {
+      id: check.id,
+      description: check.description,
+      command: [...check.command],
+      cwd: check.cwd,
+      timeoutMs: check.timeoutMs,
+      tags: [...check.tags],
+      provenance: original?.provenance ?? {
+        kind: "manual-entry",
+        path: PROJECT_VERIFIER_CATALOG_RELATIVE_PATH,
+        detail: `manual check '${check.id}'`,
+        authority: "project-declared"
+      },
+      state: original?.state ?? "manual",
+      ...original?.catalogId === void 0 ? {} : { catalogId: original.catalogId }
+    };
+  });
+  return { ok: true, text, checks };
+}
+function cloneDraft(draft) {
+  return {
+    ...draft,
+    activeChecks: draft.activeChecks.map(cloneCheck),
+    checks: draft.checks.map(cloneCheck),
+    diagnostics: [...draft.diagnostics]
+  };
+}
+function reviseVerifierDraft(draft, revisions) {
+  const next = cloneDraft(draft);
+  const diagnostics = [];
+  for (const revision of revisions) {
+    if (revision.kind === "add") {
+      if (next.checks.some((check2) => check2.id === revision.check.id)) {
+        return { ok: false, draft, reason: `Cannot add '${revision.check.id}': that ID already exists.` };
+      }
+      if (next.activeChecks.some((check2) => check2.id === revision.check.id)) {
+        return { ok: false, draft, reason: `Cannot add '${revision.check.id}': it collides with an active package check.` };
+      }
+      next.checks.push({
+        ...revision.check,
+        command: [...revision.check.command],
+        tags: [...revision.check.tags],
+        provenance: revision.provenance ?? {
+          kind: "manual-entry",
+          path: PROJECT_VERIFIER_CATALOG_RELATIVE_PATH,
+          detail: `manual check '${revision.check.id}'`,
+          authority: "project-declared"
+        },
+        state: "manual"
+      });
+      diagnostics.push(`Added check '${revision.check.id}'.`);
+      continue;
+    }
+    const index = next.checks.findIndex((check2) => check2.id === revision.id);
+    if (index === -1) return { ok: false, draft, reason: `Check '${revision.id}' does not exist.` };
+    const check = next.checks[index];
+    if (check === void 0) return { ok: false, draft, reason: `Check '${revision.id}' does not exist.` };
+    if (revision.kind === "remove") {
+      next.checks.splice(index, 1);
+      diagnostics.push(`Removed check '${revision.id}'; its command is no longer executable through the catalog.`);
+      continue;
+    }
+    if (revision.kind === "rename") {
+      if (next.checks.some((candidate, candidateIndex) => candidateIndex !== index && candidate.id === revision.newId)) {
+        return {
+          ok: false,
+          draft,
+          reason: `Cannot rename '${revision.id}' to '${revision.newId}': that ID already exists.`
+        };
+      }
+      if (next.activeChecks.some((candidate) => candidate.id === revision.newId)) {
+        return {
+          ok: false,
+          draft,
+          reason: `Cannot rename '${revision.id}' to '${revision.newId}': it collides with an active package check.`
+        };
+      }
+      check.id = revision.newId;
+      diagnostics.push(`Renamed check '${revision.id}' to '${revision.newId}'.`);
+      continue;
+    }
+    if (revision.changes.description !== void 0) check.description = revision.changes.description;
+    if (revision.changes.command !== void 0) check.command = [...revision.changes.command];
+    if (revision.changes.cwd !== void 0) check.cwd = revision.changes.cwd;
+    if (revision.changes.timeoutMs !== void 0) check.timeoutMs = revision.changes.timeoutMs;
+    if (revision.changes.tags !== void 0) check.tags = [...revision.changes.tags];
+    diagnostics.push(`Edited check '${revision.id}' without changing its deterministic ID.`);
+  }
+  next.checks.sort((left, right) => compareCodepoints(left.id, right.id));
+  const validation = validateVerifierDraft(next);
+  if (!validation.ok) return { ok: false, draft, reason: validation.reason };
+  next.checks = validation.checks;
+  next.diagnostics.push(...diagnostics);
+  return { ok: true, draft: next, diagnostics };
+}
+function authorityDescription(check) {
+  if (check.state === "active") {
+    return "active package-script authority; verify runs npm with the declared script name and may accept explicit extra argv";
+  }
+  return `exact catalog authority after confirmation; verify fixes argv, cwd, and timeout through safe-exec (proposal origin: ${check.provenance.authority})`;
+}
+function renderCheck(check, destinationPath) {
+  return [
+    `- ${check.id}`,
+    `  path: ${check.state === "active" ? check.provenance.path : destinationPath}`,
+    `  source: ${check.provenance.path} (${check.provenance.detail}; ${check.provenance.authority})`,
+    `  argv: ${JSON.stringify(check.command)}`,
+    `  cwd: ${check.cwd}`,
+    `  timeoutMs: ${check.timeoutMs}`,
+    `  tags: ${JSON.stringify(check.tags)}`,
+    `  effective execution authority: ${authorityDescription(check)}`
+  ];
+}
+function previewVerifierDraft(draft, options = {}) {
+  const validation = validateVerifierDraft(draft);
+  const lines = [
+    "Project verifier authority preview",
+    `Catalog path: ${draft.catalogPath}`,
+    `Schema validation: ${validation.ok ? "accepted by the production catalog parser" : `rejected (${validation.reason})`}`
+  ];
+  if (draft.activeChecks.length > 0) {
+    lines.push("", "Already executable package checks (not duplicated into the catalog):");
+    for (const check of draft.activeChecks) lines.push(...renderCheck(check, draft.catalogPath));
+  }
+  lines.push("", "Catalog checks after confirmation:");
+  if (draft.checks.length === 0) lines.push("(none)");
+  else for (const check of draft.checks) lines.push(...renderCheck(check, draft.catalogPath));
+  if (draft.diagnostics.length > 0) {
+    lines.push("", "Diagnostics:");
+    for (const diagnostic of draft.diagnostics) lines.push(`- ${diagnostic}`);
+  }
+  if (draft.checks.length === 0) {
+    lines.push(
+      "",
+      draft.activeChecks.length === 0 ? draft.manualEntry : "No catalog checks are proposed; the package checks above are already executable without a catalog entry."
+    );
+  }
+  if (options.confirmed !== true) {
+    lines.push("", "Preview only: no file has been written and no check has been executed.");
+  }
+  return lines.join("\n");
+}
+function writeValidatedDraft(draft, validation) {
+  const directory = path.dirname(draft.catalogPath);
+  mkdirSync(directory, { recursive: true });
+  const realRoot = realpathSync(draft.workspaceRoot);
+  const realDirectory = realpathSync(directory);
+  resolveSafeCwd(realDirectory, realRoot);
+  const realCatalogPath = path.join(realDirectory, path.basename(draft.catalogPath));
+  const temporaryPath = path.join(
+    realDirectory,
+    `.${path.basename(draft.catalogPath)}.${process.pid}.${randomUUID()}.tmp`
+  );
+  try {
+    writeFileSync(temporaryPath, validation.text, { encoding: "utf8", flag: "wx", mode: 420 });
+    renameSync(temporaryPath, realCatalogPath);
+  } catch (error) {
+    rmSync(temporaryPath, { force: true });
+    throw error;
+  }
+}
+async function runVerifierAuthoringWorkflow(options) {
+  const workspaceRoot = options.workspaceRoot ?? process.cwd();
+  const discovery = discoverVerifierAuthoring(workspaceRoot);
+  if (!discovery.ok) return { status: "invalid", reason: discovery.reason, wrote: false };
+  let draft = createVerifierDraft(
+    discovery,
+    options.includeProposals === void 0 ? {} : { includeProposals: options.includeProposals }
+  );
+  if (options.initialRevisions !== void 0 && options.initialRevisions.length > 0) {
+    const revised = reviseVerifierDraft(draft, options.initialRevisions);
+    if (!revised.ok) return { status: "invalid", reason: revised.reason, wrote: false };
+    draft = revised.draft;
+  }
+  for (let revision = 0; revision <= PROJECT_VERIFIER_CATALOG_CAPS.checks; revision += 1) {
+    const validation = validateVerifierDraft(draft);
+    const preview = previewVerifierDraft(draft, { confirmed: options.confirmed === true });
+    const decision = await options.decide({ draft: cloneDraft(draft), preview, validation, revision });
+    if (decision.kind === "reject") {
+      return { status: "rejected", wrote: false, preview, diagnostics: [...draft.diagnostics] };
+    }
+    if (decision.kind === "revise") {
+      const revised = reviseVerifierDraft(draft, decision.revisions);
+      if (!revised.ok) {
+        draft.diagnostics.push(`Revision rejected: ${revised.reason}`);
+        continue;
+      }
+      draft = revised.draft;
+      continue;
+    }
+    if (!validation.ok) return { status: "invalid", reason: validation.reason, wrote: false, preview };
+    const authorizedPreview = previewVerifierDraft(draft, { confirmed: true });
+    try {
+      writeValidatedDraft(draft, validation);
+    } catch (error) {
+      return {
+        status: "invalid",
+        reason: `Could not write ${draft.catalogPath}: ${error instanceof Error ? error.message : String(error)}`,
+        wrote: false,
+        preview: authorizedPreview
+      };
+    }
+    const loaded = discoverDeclaredChecksAtRoot(workspaceRoot, void 0);
+    if (!loaded.ok) {
+      return {
+        status: "invalid",
+        reason: `Catalog was written but production discovery rejected it: ${loaded.reason}`,
+        wrote: true,
+        path: draft.catalogPath,
+        preview: authorizedPreview
+      };
+    }
+    const dryRuns = [];
+    const runCheck = options.runCheck ?? ((id) => verifyTool.run({ check: id }));
+    for (const id of decision.dryRunCheckIds ?? []) {
+      dryRuns.push({ id, result: await runCheck(id) });
+    }
+    return {
+      status: "written",
+      wrote: true,
+      path: draft.catalogPath,
+      preview: authorizedPreview,
+      diagnostics: [...draft.diagnostics],
+      dryRuns
+    };
+  }
+  return {
+    status: "invalid",
+    reason: `Revision limit of ${PROJECT_VERIFIER_CATALOG_CAPS.checks} exceeded without an operator decision.`,
+    wrote: false
+  };
+}
+
+// src/cli/verifiers.ts
+var HELP = `Project verifier authoring
+
+Usage:
+  clio-coder verifiers discover
+  clio-coder verifiers author [--exclude <id>] [--rename <old>=<new>] [--dry-run <id>] [--yes]
+  clio-coder verifiers validate
+  clio-coder verifiers dry-run <id>
+  clio-coder verifiers add --id <id> --description <text> --command <json-argv> [fields] [--yes]
+  clio-coder verifiers edit <id> [--description <text>] [--command <json-argv>] [fields] [--yes]
+  clio-coder verifiers rename <old> <new> [--yes]
+  clio-coder verifiers remove <id> [--yes]
+
+Fields:
+  --cwd <path>            repository-relative working directory (default .)
+  --timeout-ms <number>   bounded timeout in milliseconds (default 120000)
+  --tags <a,b>            comma-separated catalog tags
+
+Discovery and every preview are read-only. Mutating commands write only with
+--yes after printing the exact argv, cwd, timeout, tags, source provenance, and
+effective execution authority. dry-run invokes the production verify path.
+`;
+var VALUE_OPTIONS = /* @__PURE__ */ new Set([
+  "--id",
+  "--description",
+  "--command",
+  "--cwd",
+  "--timeout-ms",
+  "--tags",
+  "--exclude",
+  "--rename",
+  "--dry-run"
+]);
+function parseAuthoringArgs(argv) {
+  const positional = [];
+  const values = /* @__PURE__ */ new Map();
+  let yes = false;
+  let help = false;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--yes") {
+      yes = true;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      help = true;
+      continue;
+    }
+    if (arg?.startsWith("--") === true) {
+      if (!VALUE_OPTIONS.has(arg)) return { yes, help, positional, values, error: `unknown option: ${arg}` };
+      const value = argv[index + 1];
+      if (value === void 0 || value.startsWith("--")) {
+        return { yes, help, positional, values, error: `${arg} requires a value` };
+      }
+      const prior = values.get(arg) ?? [];
+      prior.push(value);
+      values.set(arg, prior);
+      index += 1;
+      continue;
+    }
+    if (arg !== void 0) positional.push(arg);
+  }
+  return { yes, help, positional, values };
+}
+function oneValue(parsed, option) {
+  return parsed.values.get(option)?.at(-1);
+}
+function parseCommand(value) {
+  if (value === void 0) return new Error("--command is required and must be a JSON argv array");
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    return new Error(`--command must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!Array.isArray(parsed) || parsed.length === 0 || parsed.some((entry) => typeof entry !== "string")) {
+    return new Error("--command must be a non-empty JSON string array");
+  }
+  return parsed;
+}
+function parseTimeout(value) {
+  if (value === void 0) return SAFE_EXEC_DEFAULT_TIMEOUT_MS;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) return new Error("--timeout-ms must be a positive integer");
+  return parsed;
+}
+function tags(value) {
+  return value === void 0 ? [] : value.split(",").map((tag) => tag.trim()).filter((tag) => tag.length > 0);
+}
+function requiredValue(parsed, option) {
+  const value = oneValue(parsed, option);
+  return value === void 0 || value.length === 0 ? new Error(`${option} is required`) : value;
+}
+function authorRevisions(parsed) {
+  const revisions = [];
+  for (const id of parsed.values.get("--exclude") ?? []) revisions.push({ kind: "remove", id });
+  for (const rename of parsed.values.get("--rename") ?? []) {
+    const separator = rename.indexOf("=");
+    if (separator <= 0 || separator === rename.length - 1) {
+      return new Error("--rename must use <old>=<new>");
+    }
+    revisions.push({ kind: "rename", id: rename.slice(0, separator), newId: rename.slice(separator + 1) });
+  }
+  return revisions;
+}
+function addRevision(parsed) {
+  const id = requiredValue(parsed, "--id");
+  if (id instanceof Error) return id;
+  const description = requiredValue(parsed, "--description");
+  if (description instanceof Error) return description;
+  const command = parseCommand(oneValue(parsed, "--command"));
+  if (command instanceof Error) return command;
+  const timeoutMs = parseTimeout(oneValue(parsed, "--timeout-ms"));
+  if (timeoutMs instanceof Error) return timeoutMs;
+  return {
+    kind: "add",
+    check: {
+      id,
+      description,
+      command,
+      cwd: oneValue(parsed, "--cwd") ?? ".",
+      timeoutMs,
+      tags: tags(oneValue(parsed, "--tags"))
+    }
+  };
+}
+function editRevision(parsed) {
+  const id = parsed.positional[1];
+  if (id === void 0) return new Error("edit requires a check ID");
+  const changes = {};
+  const description = oneValue(parsed, "--description");
+  if (description !== void 0) changes.description = description;
+  const commandValue = oneValue(parsed, "--command");
+  if (commandValue !== void 0) {
+    const command = parseCommand(commandValue);
+    if (command instanceof Error) return command;
+    changes.command = command;
+  }
+  const cwd = oneValue(parsed, "--cwd");
+  if (cwd !== void 0) changes.cwd = cwd;
+  const timeoutValue = oneValue(parsed, "--timeout-ms");
+  if (timeoutValue !== void 0) {
+    const timeoutMs = parseTimeout(timeoutValue);
+    if (timeoutMs instanceof Error) return timeoutMs;
+    changes.timeoutMs = timeoutMs;
+  }
+  const tagValue = oneValue(parsed, "--tags");
+  if (tagValue !== void 0) changes.tags = tags(tagValue);
+  if (Object.keys(changes).length === 0) return new Error("edit requires at least one changed field");
+  return { kind: "edit", id, changes };
+}
+function mutationRevision(parsed) {
+  const command = parsed.positional[0];
+  if (command === "add") return addRevision(parsed);
+  if (command === "edit") return editRevision(parsed);
+  if (command === "rename") {
+    const id = parsed.positional[1];
+    const newId = parsed.positional[2];
+    if (id === void 0 || newId === void 0) return new Error("rename requires <old> and <new> IDs");
+    return { kind: "rename", id, newId };
+  }
+  if (command === "remove") {
+    const id = parsed.positional[1];
+    if (id === void 0) return new Error("remove requires a check ID");
+    return { kind: "remove", id };
+  }
+  return new Error(`unknown verifiers command: ${command ?? "(none)"}`);
+}
+function printDryRun(id, result) {
+  if (result.kind === "error") {
+    printError(`dry-run '${id}' failed: ${result.message}`);
+    return 1;
+  }
+  process.stdout.write(`Dry run '${id}':
+${result.output}${result.output.endsWith("\n") ? "" : "\n"}`);
+  return 0;
+}
+async function executeWorkflow(parsed, options) {
+  let printedPreview = false;
+  const dryRunCheckIds = parsed.values.get("--dry-run") ?? [];
+  const result = await runVerifierAuthoringWorkflow({
+    includeProposals: options.includeProposals,
+    initialRevisions: options.revisions,
+    confirmed: parsed.yes,
+    decide(context) {
+      process.stdout.write(`${context.preview}
+`);
+      printedPreview = true;
+      if (!parsed.yes || context.draft.checks.length === 0 && options.revisions.length === 0) {
+        return { kind: "reject" };
+      }
+      return { kind: "confirm", dryRunCheckIds };
+    }
+  });
+  if (result.status === "invalid") {
+    if (!printedPreview && result.preview !== void 0) process.stdout.write(`${result.preview}
+`);
+    printError(result.reason);
+    if (result.wrote && result.path !== void 0) {
+      process.stderr.write(`  ${result.path} was written; repair or remove it before running a check.
+`);
+    }
+    return 1;
+  }
+  if (result.status === "rejected") {
+    if (!parsed.yes) {
+      process.stdout.write("Review complete. Nothing changed; rerun the same command with --yes to write this preview.\n");
+    } else {
+      process.stdout.write(
+        "Nothing changed because the preview contains no catalog checks. Package checks remain active; unsupported commands can be added with `clio-coder verifiers add`.\n"
+      );
+    }
+    return 0;
+  }
+  printOk(`wrote ${result.path}; production parser accepted the catalog`);
+  let code = 0;
+  for (const dryRun of result.dryRuns) code = Math.max(code, printDryRun(dryRun.id, dryRun.result));
+  return code;
+}
+async function discoverCommand() {
+  const discovery = discoverVerifierAuthoring();
+  if (!discovery.ok) {
+    printError(discovery.reason);
+    process.stderr.write(`${discovery.manualEntry}
+`);
+    return 1;
+  }
+  process.stdout.write(`${previewVerifierDraft(createVerifierDraft(discovery))}
+`);
+  return 0;
+}
+function validateCommand() {
+  const loaded = loadProjectVerifierCatalog(process.cwd());
+  if (!loaded.ok) {
+    printError(`production catalog parser rejected ${loaded.reason}`);
+    return 1;
+  }
+  if (loaded.source === null) {
+    process.stdout.write(`No ${PROJECT_VERIFIER_CATALOG_RELATIVE_PATH} exists. Run \`clio-coder verifiers author\`.
+`);
+    return 0;
+  }
+  printOk(
+    `production catalog parser accepted ${PROJECT_VERIFIER_CATALOG_RELATIVE_PATH} (${loaded.source.checks.length} check${loaded.source.checks.length === 1 ? "" : "s"})`
+  );
+  return 0;
+}
+async function runVerifiersCommand(argv) {
+  const parsed = parseAuthoringArgs(argv);
+  if (parsed.error !== void 0) {
+    printError(parsed.error);
+    process.stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.help || parsed.positional.length === 0) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  const command = parsed.positional[0];
+  if (command === "discover") return discoverCommand();
+  if (command === "validate") return validateCommand();
+  if (command === "dry-run") {
+    const id = parsed.positional[1];
+    if (id === void 0) {
+      printError("dry-run requires a check ID");
+      return 2;
+    }
+    return printDryRun(id, await verifyTool.run({ check: id }));
+  }
+  if (command === "author") {
+    const revisions = authorRevisions(parsed);
+    if (revisions instanceof Error) {
+      printError(revisions.message);
+      return 2;
+    }
+    return executeWorkflow(parsed, { includeProposals: true, revisions });
+  }
+  if (["add", "edit", "rename", "remove"].includes(command ?? "")) {
+    const revision = mutationRevision(parsed);
+    if (revision instanceof Error) {
+      printError(revision.message);
+      return 2;
+    }
+    return executeWorkflow(parsed, { includeProposals: false, revisions: [revision] });
+  }
+  printError(`unknown verifiers command: ${command}`);
+  process.stderr.write(HELP);
+  return 2;
+}
+export {
+  runVerifiersCommand
+};
+//# sourceMappingURL=verifiers-4UUM6TEE.js.map