@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-RBES4TCZ.js

@@ -0,0 +1,302 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  describeYaziProfile,
+  inspectCurrentYaziProfile,
+  resetYaziProfile
+} from "./chunk-O2QJDRWP.js";
+import {
+  formatColumns,
+  printError,
+  printOk
+} from "./chunk-ATB3Q7YO.js";
+import {
+  installTool,
+  installedToolVersions,
+  removeTool
+} from "./chunk-5GZICIYO.js";
+import {
+  describeFloorRejection,
+  describeResolution,
+  installRemedy,
+  toolStatus,
+  toolStatuses
+} from "./chunk-XCUDZQLX.js";
+import {
+  PINNED_TOOLS,
+  findPinnedTool
+} from "./chunk-K2BLQC5E.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/tools.ts
+init_esm_shims();
+var HELP = `clio-coder tools <command>
+
+Manage the external terminal programs Clio can drive. Every one of them is
+optional: Clio works without them and only uses one when it is present. Each is
+pinned to an exact upstream version and checksum, and a copy already on PATH
+wins over Clio's own as long as it clears the pinned minimum.
+
+Commands:
+  clio-coder tools list [--json]           the pinned table and where each resolves
+  clio-coder tools status <id> [--json] [--reset-profile]  one tool in detail
+  clio-coder tools install <id> [--force] [--json]  download, verify, and vendor a tool
+  clio-coder tools remove <id>|--all [--json]  delete every vendored version of a tool
+
+Downloads happen only here. Nothing on a startup path fetches anything.
+
+An install keeps one version directory per tool: once the pinned version is in
+place, versions it superseded are pruned, along with any staging directory left
+by an install that was killed. Removal touches nothing outside <data>/tools/<id>
+and needs no confirmation, since every byte under it is re-downloadable from the
+checksum-pinned registry. "remove --all" sweeps every tool in the table.
+`;
+async function runToolsCommand(argv = []) {
+  let parsed;
+  try {
+    parsed = parse(argv);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.help || parsed.command === void 0) {
+    process.stdout.write(HELP);
+    return parsed.help ? 0 : 2;
+  }
+  if (parsed.all && parsed.command !== "remove") {
+    printError("--all is only valid with `tools remove`");
+    return 2;
+  }
+  switch (parsed.command) {
+    case "list":
+      if (parsed.resetProfile) return invalidResetProfile();
+      return listTools(parsed.json);
+    case "status":
+      return statusTool(parsed.positional[0], parsed.json, parsed.resetProfile);
+    case "install":
+      if (parsed.resetProfile) return invalidResetProfile();
+      return installOne(parsed.positional[0], parsed.force, parsed.json);
+    case "remove":
+      if (parsed.resetProfile) return invalidResetProfile();
+      return parsed.all ? removeAll(parsed.positional[0], parsed.json) : removeOne(parsed.positional[0], parsed.json);
+    default:
+      printError(`unknown tools command: ${parsed.command}`);
+      process.stderr.write(HELP);
+      return 2;
+  }
+}
+function parse(argv) {
+  const out = { positional: [], json: false, force: false, all: false, resetProfile: false, help: false };
+  for (const arg of argv) {
+    if (!out.command && !arg.startsWith("-")) {
+      out.command = arg;
+      continue;
+    }
+    switch (arg) {
+      case "--json":
+        out.json = true;
+        break;
+      case "--force":
+      case "-f":
+        out.force = true;
+        break;
+      case "--all":
+        out.all = true;
+        break;
+      case "--reset-profile":
+        out.resetProfile = true;
+        break;
+      case "--help":
+      case "-h":
+        out.help = true;
+        break;
+      default:
+        if (arg.startsWith("-")) throw new Error(`unknown flag: ${arg}`);
+        out.positional.push(arg);
+    }
+  }
+  return out;
+}
+function listTools(json) {
+  const statuses = toolStatuses();
+  if (json) {
+    process.stdout.write(`${JSON.stringify(statuses.map(jsonShape), null, 2)}
+`);
+    return 0;
+  }
+  const rows = statuses.map((status) => [
+    status.id,
+    status.version,
+    status.license,
+    status.resolution.source,
+    describeResolution(status)
+  ]);
+  process.stdout.write(formatColumns([["TOOL", "PIN", "LICENSE", "SOURCE", "RESOLVED"], ...rows]));
+  return 0;
+}
+function invalidResetProfile() {
+  printError("--reset-profile is only valid with `tools status yazi`");
+  return 2;
+}
+function unknownTool(id) {
+  printError(`unknown tool: ${id} (known: ${PINNED_TOOLS.map((row) => row.id).join(", ")})`);
+  return 2;
+}
+function statusTool(id, json, resetProfile) {
+  if (id === void 0) {
+    printError("usage: clio-coder tools status <id>");
+    return 2;
+  }
+  const entry = findPinnedTool(id);
+  if (entry === null) {
+    return unknownTool(id);
+  }
+  if (resetProfile && id !== "yazi") return invalidResetProfile();
+  if (resetProfile) resetYaziProfile();
+  const status = toolStatus(entry);
+  const profile = id === "yazi" ? inspectCurrentYaziProfile() : null;
+  if (json) {
+    process.stdout.write(
+      `${JSON.stringify({ ...jsonShape(status), ...profile ? { profile, profileReset: resetProfile } : {} }, null, 2)}
+`
+    );
+    return 0;
+  }
+  const rejection = describeFloorRejection(status);
+  const installedVersions = installedToolVersions(entry.id);
+  const lines = [
+    `${entry.id} ${entry.version} (${entry.license})`,
+    `  ${entry.summary}`,
+    `  homepage    ${entry.homepage}`,
+    `  binaries    ${entry.binaries.join(", ")}`,
+    `  PATH floor  ${entry.minimumVersion}`,
+    `  platform    ${status.platform ?? `${process.platform}-${process.arch}`}${status.supported ? "" : " (no pinned asset)"}`,
+    `  vendor dir  ${status.installDir}${status.installed ? "" : " (not installed)"}`,
+    `  vendored    ${installedVersions.length === 0 ? "nothing" : installedVersions.join(", ")}`,
+    `  resolves to ${describeResolution(status)}`,
+    // Spelled out on its own line as well as inside the resolution sentence,
+    // because a rejected PATH copy is the one thing an operator reads this
+    // command to understand and the sentence above may be about something else.
+    ...rejection === null ? [] : [
+      `  floor       rejected: ${rejection}`,
+      ...status.resolution.source === "none" && status.supported ? [`  remedy      ${installRemedy(entry.id)}`] : []
+    ],
+    ...profile ? [
+      `  profile     ${describeYaziProfile(profile)}`,
+      ...resetProfile ? ["  profile reset; next open regenerates it"] : []
+    ] : []
+  ];
+  process.stdout.write(`${lines.join("\n")}
+`);
+  return 0;
+}
+async function installOne(id, force, json) {
+  if (id === void 0) {
+    printError("usage: clio-coder tools install <id>");
+    return 2;
+  }
+  if (findPinnedTool(id) === null) {
+    return unknownTool(id);
+  }
+  const result = await installTool(id, {
+    force,
+    ...json ? {} : { onProgress: (message) => process.stderr.write(`  ${message}
+`) }
+  });
+  if (json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    return result.ok ? 0 : 1;
+  }
+  if (!result.ok) {
+    printError(result.message);
+    return 1;
+  }
+  printOk(result.message);
+  for (const path of result.documents) process.stdout.write(`  license  ${path}
+`);
+  for (const version of result.pruned) process.stdout.write(`  pruned   ${id} ${version}
+`);
+  return 0;
+}
+function removeOne(id, json) {
+  if (id === void 0) {
+    printError("usage: clio-coder tools remove <id>");
+    return 2;
+  }
+  if (findPinnedTool(id) === null) return unknownTool(id);
+  const result = removeTool(id);
+  if (json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    return result.ok ? 0 : 1;
+  }
+  if (!result.ok) {
+    printError(result.message);
+    return 1;
+  }
+  printOk(result.message);
+  if (result.removed.length > 0) {
+    process.stdout.write(`  reinstall with \`${installRemedy(id)}\`
+`);
+  }
+  return 0;
+}
+function removeAll(id, json) {
+  if (id !== void 0) {
+    printError("`tools remove --all` takes no tool id; drop the id or drop --all");
+    return 2;
+  }
+  const results = PINNED_TOOLS.map((entry) => removeTool(entry.id));
+  if (json) {
+    process.stdout.write(`${JSON.stringify(results, null, 2)}
+`);
+    return results.every((result) => result.ok) ? 0 : 1;
+  }
+  for (const result of results) {
+    if (!result.ok) printError(result.message);
+    else if (result.removed.length > 0 || result.staleStaging.length > 0) printOk(result.message);
+  }
+  const touched = results.filter((result) => result.ok && result.removed.length > 0);
+  const untouched = results.filter((result) => result.ok && result.removed.length === 0);
+  if (touched.length > 0) {
+    process.stdout.write(`  reinstall with \`clio-coder tools install <id>\`
+`);
+  }
+  if (untouched.length > 0) {
+    process.stdout.write(`  ${untouched.length} of ${results.length} had nothing vendored
+`);
+  }
+  return results.every((result) => result.ok) ? 0 : 1;
+}
+function jsonShape(status) {
+  return {
+    id: status.id,
+    version: status.version,
+    license: status.license,
+    platform: status.platform,
+    supported: status.supported,
+    installed: status.installed,
+    installDir: status.installDir,
+    source: status.resolution.source,
+    binaryPath: status.resolution.binaryPath,
+    foundVersion: status.resolution.version,
+    minimumVersion: status.resolution.entry?.minimumVersion ?? null,
+    pathCandidate: status.resolution.pathCandidate,
+    // A script deciding whether to warn about a floor rejection should not have
+    // to parse `detail` for it, so the rejection and the command that answers
+    // it are their own fields. `remedy` is null exactly where installing would
+    // change nothing: already vendored, or no asset for this platform.
+    floorRejection: describeFloorRejection(status),
+    remedy: status.resolution.source === "none" && status.supported ? installRemedy(status.id) : null,
+    installedVersions: installedToolVersions(status.id),
+    detail: describeResolution(status)
+  };
+}
+
+export {
+  runToolsCommand
+};
+//# sourceMappingURL=chunk-RBES4TCZ.js.map

package/dist/chunk-RFCKPS2V.js

@@ -0,0 +1,26 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/extensions/operator-commands.ts
+init_esm_shims();
+function extensionInvocation(id, command) {
+  return `ext:${id}:${command}`;
+}
+function isExtensionCommandToken(token) {
+  return /^ext:[^\s/]+$/u.test(token);
+}
+function resolveExtensionCommands(rows, promptNames) {
+  const prompts = new Set(promptNames.map((name) => name.toLowerCase()));
+  return rows.map(
+    (row) => prompts.has(row.invocation.toLowerCase()) ? { ...row, available: false, reason: "invocation belongs to an existing prompt template" } : row
+  );
+}
+
+export {
+  extensionInvocation,
+  isExtensionCommandToken,
+  resolveExtensionCommands
+};
+//# sourceMappingURL=chunk-RFCKPS2V.js.map

package/dist/chunk-RFULVPBX.js

@@ -0,0 +1,318 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  compareCodepoints
+} from "./chunk-B6UM3OZC.js";
+import {
+  byteLength
+} from "./chunk-MYI32N4R.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  resolveSafeCwd
+} from "./chunk-GJ24ODAX.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/safety/validation-contract.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+var VALIDATION_CONTRACT_VERSION = 1;
+var VALIDATION_CONTRACT_YAML_PATHS = [
+  ".clio-coder/validation.yaml",
+  ".clio-coder/validation.yml",
+  "validation.yaml",
+  "validation.yml"
+];
+var VALIDATION_CONTRACT_MARKDOWN_PATH = "VALIDATION.md";
+var VALIDATION_CONTRACT_CAPS = Object.freeze({
+  fileBytes: 256 * 1024,
+  textBytes: 4096,
+  notesBytes: 16 * 1024,
+  artifacts: 256,
+  validators: 128,
+  modules: 64,
+  mapEntries: 256,
+  mapKeyBytes: 256
+});
+var RUNTIME_KINDS = ["local", "slurm", "mpi", "other"];
+var ROOT_FIELDS = /* @__PURE__ */ new Set(["version", "task", "runtime", "artifacts", "validators", "notes"]);
+var RUNTIME_FIELDS = /* @__PURE__ */ new Set(["kind", "nodes", "ranks", "walltime", "modules"]);
+var ARTIFACT_FIELDS = /* @__PURE__ */ new Set([
+  "path",
+  "format",
+  "expected_dimensions",
+  "expected_attributes",
+  "numerical_tolerances",
+  "preserve"
+]);
+var TOLERANCE_FIELDS = /* @__PURE__ */ new Set(["relative", "absolute", "ulp"]);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function unknownFields(record, allowed) {
+  return Object.keys(record).filter((key) => !allowed.has(key)).sort(compareCodepoints);
+}
+function boundedText(value, location, cap) {
+  if (typeof value !== "string" || value.length === 0) return new Error(`${location} must be a non-empty string`);
+  if (value.includes("\0")) return new Error(`${location} must not contain a NUL byte`);
+  if (byteLength(value) > cap) return new Error(`${location} exceeds the ${cap}-byte cap`);
+  return value;
+}
+function positiveInteger(value, location) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    return new Error(`${location} must be a positive integer`);
+  }
+  return value;
+}
+function nonNegativeNumber(value, location) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return new Error(`${location} must be a finite non-negative number`);
+  }
+  return value;
+}
+function boundedStringList(value, location, cap) {
+  if (!Array.isArray(value)) return new Error(`${location} must be an array of strings`);
+  if (value.length > cap) return new Error(`${location} exceeds the ${cap}-entry cap`);
+  const items = [];
+  for (const [index, entry] of value.entries()) {
+    const text = boundedText(entry, `${location}[${index}]`, VALIDATION_CONTRACT_CAPS.textBytes);
+    if (text instanceof Error) return text;
+    items.push(text);
+  }
+  return items;
+}
+function boundedMap(value, location, validateEntry) {
+  if (!isRecord(value)) return new Error(`${location} must be a map`);
+  const keys = Object.keys(value);
+  if (keys.length > VALIDATION_CONTRACT_CAPS.mapEntries) {
+    return new Error(`${location} exceeds the ${VALIDATION_CONTRACT_CAPS.mapEntries}-entry cap`);
+  }
+  const out = {};
+  for (const key of keys.sort(compareCodepoints)) {
+    const entryLocation = `${location}.${key}`;
+    if (key.length === 0) return new Error(`${location} has an empty key`);
+    if (byteLength(key) > VALIDATION_CONTRACT_CAPS.mapKeyBytes) {
+      return new Error(`${entryLocation} key exceeds the ${VALIDATION_CONTRACT_CAPS.mapKeyBytes}-byte cap`);
+    }
+    const entry = validateEntry(value[key], entryLocation);
+    if (entry instanceof Error) return entry;
+    out[key] = entry;
+  }
+  return out;
+}
+function validateRuntime(value, location) {
+  if (!isRecord(value)) return new Error(`${location} must be an object with a kind field`);
+  const unknown = unknownFields(value, RUNTIME_FIELDS);
+  if (unknown.length > 0) return new Error(`${location} has unknown field(s): ${unknown.join(", ")}`);
+  if (!Object.hasOwn(value, "kind")) return new Error(`${location}.kind is required`);
+  const kind = value.kind;
+  if (typeof kind !== "string" || !RUNTIME_KINDS.includes(kind)) {
+    return new Error(`${location}.kind must be one of ${RUNTIME_KINDS.join(", ")}`);
+  }
+  const runtime = { kind };
+  if (Object.hasOwn(value, "nodes")) {
+    const nodes = positiveInteger(value.nodes, `${location}.nodes`);
+    if (nodes instanceof Error) return nodes;
+    runtime.nodes = nodes;
+  }
+  if (Object.hasOwn(value, "ranks")) {
+    const ranks = positiveInteger(value.ranks, `${location}.ranks`);
+    if (ranks instanceof Error) return ranks;
+    runtime.ranks = ranks;
+  }
+  if (Object.hasOwn(value, "walltime")) {
+    const walltime = boundedText(value.walltime, `${location}.walltime`, VALIDATION_CONTRACT_CAPS.textBytes);
+    if (walltime instanceof Error) return walltime;
+    runtime.walltime = walltime;
+  }
+  if (Object.hasOwn(value, "modules")) {
+    const modules = boundedStringList(value.modules, `${location}.modules`, VALIDATION_CONTRACT_CAPS.modules);
+    if (modules instanceof Error) return modules;
+    runtime.modules = modules;
+  }
+  return runtime;
+}
+function validateTolerances(value, location) {
+  if (!isRecord(value)) return new Error(`${location} must be an object`);
+  const unknown = unknownFields(value, TOLERANCE_FIELDS);
+  if (unknown.length > 0) return new Error(`${location} has unknown field(s): ${unknown.join(", ")}`);
+  const tolerances = {};
+  if (Object.hasOwn(value, "relative")) {
+    const relative = nonNegativeNumber(value.relative, `${location}.relative`);
+    if (relative instanceof Error) return relative;
+    tolerances.relative = relative;
+  }
+  if (Object.hasOwn(value, "absolute")) {
+    const absolute = nonNegativeNumber(value.absolute, `${location}.absolute`);
+    if (absolute instanceof Error) return absolute;
+    tolerances.absolute = absolute;
+  }
+  if (Object.hasOwn(value, "ulp")) {
+    const ulp = value.ulp;
+    if (typeof ulp !== "number" || !Number.isInteger(ulp) || ulp < 0) {
+      return new Error(`${location}.ulp must be a non-negative integer`);
+    }
+    tolerances.ulp = ulp;
+  }
+  return tolerances;
+}
+function validateArtifact(value, location) {
+  if (!isRecord(value)) return new Error(`${location} must be an object with a path field`);
+  const unknown = unknownFields(value, ARTIFACT_FIELDS);
+  if (unknown.length > 0) return new Error(`${location} has unknown field(s): ${unknown.join(", ")}`);
+  if (!Object.hasOwn(value, "path")) return new Error(`${location}.path is required`);
+  const artifactPath = boundedText(value.path, `${location}.path`, VALIDATION_CONTRACT_CAPS.textBytes);
+  if (artifactPath instanceof Error) return artifactPath;
+  const artifact = { path: artifactPath };
+  if (Object.hasOwn(value, "format")) {
+    const format = boundedText(value.format, `${location}.format`, VALIDATION_CONTRACT_CAPS.textBytes);
+    if (format instanceof Error) return format;
+    artifact.format = format;
+  }
+  if (Object.hasOwn(value, "expected_dimensions")) {
+    const dimensions = boundedMap(
+      value.expected_dimensions,
+      `${location}.expected_dimensions`,
+      (entry, entryLocation) => typeof entry === "number" && Number.isInteger(entry) && entry >= 0 ? entry : new Error(`${entryLocation} must be a non-negative integer`)
+    );
+    if (dimensions instanceof Error) return dimensions;
+    artifact.expected_dimensions = dimensions;
+  }
+  if (Object.hasOwn(value, "expected_attributes")) {
+    const attributes = boundedMap(
+      value.expected_attributes,
+      `${location}.expected_attributes`,
+      (entry, entryLocation) => typeof entry === "string" ? boundedText(entry, entryLocation, VALIDATION_CONTRACT_CAPS.textBytes) : new Error(`${entryLocation} must be a string`)
+    );
+    if (attributes instanceof Error) return attributes;
+    artifact.expected_attributes = attributes;
+  }
+  if (Object.hasOwn(value, "numerical_tolerances")) {
+    const tolerances = validateTolerances(value.numerical_tolerances, `${location}.numerical_tolerances`);
+    if (tolerances instanceof Error) return tolerances;
+    artifact.numerical_tolerances = tolerances;
+  }
+  if (Object.hasOwn(value, "preserve")) {
+    if (typeof value.preserve !== "boolean") return new Error(`${location}.preserve must be a boolean`);
+    artifact.preserve = value.preserve;
+  }
+  return artifact;
+}
+function parseValidationContractText(text, contractPath) {
+  const invalid = (reason) => ({ ok: false, path: contractPath, reason });
+  const document = (0, import_yaml.parseDocument)(text, { prettyErrors: false, strict: true, uniqueKeys: true });
+  if (document.errors.length > 0) {
+    return invalid(`invalid YAML: ${document.errors.map((error) => error.message).join("; ")}`);
+  }
+  let parsed;
+  try {
+    parsed = document.toJS({ maxAliasCount: 0 });
+  } catch (error) {
+    return invalid(`invalid YAML: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isRecord(parsed)) return invalid("root must be an object with a version field");
+  const rootUnknown = unknownFields(parsed, ROOT_FIELDS);
+  if (rootUnknown.length > 0) return invalid(`root has unknown field(s): ${rootUnknown.join(", ")}`);
+  if (!Object.hasOwn(parsed, "version")) return invalid("root.version is required");
+  if (parsed.version !== VALIDATION_CONTRACT_VERSION) {
+    return invalid(
+      `unsupported version ${JSON.stringify(parsed.version)}; supported version is ${VALIDATION_CONTRACT_VERSION}`
+    );
+  }
+  const contract = { version: VALIDATION_CONTRACT_VERSION };
+  if (Object.hasOwn(parsed, "task")) {
+    const task = boundedText(parsed.task, "root.task", VALIDATION_CONTRACT_CAPS.textBytes);
+    if (task instanceof Error) return invalid(task.message);
+    contract.task = task;
+  }
+  if (Object.hasOwn(parsed, "runtime")) {
+    const runtime = validateRuntime(parsed.runtime, "root.runtime");
+    if (runtime instanceof Error) return invalid(runtime.message);
+    contract.runtime = runtime;
+  }
+  if (Object.hasOwn(parsed, "artifacts")) {
+    if (!Array.isArray(parsed.artifacts)) return invalid("root.artifacts must be an array");
+    if (parsed.artifacts.length > VALIDATION_CONTRACT_CAPS.artifacts) {
+      return invalid(`root.artifacts exceeds the ${VALIDATION_CONTRACT_CAPS.artifacts}-entry cap`);
+    }
+    const artifacts = [];
+    for (const [index, value] of parsed.artifacts.entries()) {
+      const artifact = validateArtifact(value, `artifacts[${index}]`);
+      if (artifact instanceof Error) return invalid(artifact.message);
+      artifacts.push(artifact);
+    }
+    contract.artifacts = artifacts;
+  }
+  if (Object.hasOwn(parsed, "validators")) {
+    const validators = boundedStringList(parsed.validators, "root.validators", VALIDATION_CONTRACT_CAPS.validators);
+    if (validators instanceof Error) return invalid(validators.message);
+    contract.validators = validators;
+  }
+  if (Object.hasOwn(parsed, "notes")) {
+    const notes = boundedText(parsed.notes, "root.notes", VALIDATION_CONTRACT_CAPS.notesBytes);
+    if (notes instanceof Error) return invalid(notes.message);
+    contract.notes = notes;
+  }
+  return { ok: true, contract, path: contractPath };
+}
+function readContractText(absolutePath, workspaceRoot) {
+  let realPath;
+  try {
+    const realRoot = realpathSync(workspaceRoot);
+    realPath = realpathSync(absolutePath);
+    resolveSafeCwd(realPath, realRoot);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return new Error(`contract file must resolve inside the workspace root (${message})`);
+  }
+  try {
+    const stats = statSync(realPath);
+    if (!stats.isFile()) return new Error("contract path must be a regular file");
+    if (stats.size > VALIDATION_CONTRACT_CAPS.fileBytes) {
+      return new Error(`file exceeds the ${VALIDATION_CONTRACT_CAPS.fileBytes}-byte cap`);
+    }
+    return readFileSync(realPath, "utf8");
+  } catch (error) {
+    return new Error(`cannot read contract (${error instanceof Error ? error.message : String(error)})`);
+  }
+}
+function loadValidationContract(workspaceRoot) {
+  let contractPath = null;
+  try {
+    contractPath = VALIDATION_CONTRACT_YAML_PATHS.find((relative) => existsSync(path.join(workspaceRoot, relative))) ?? null;
+    if (contractPath === null) {
+      if (existsSync(path.join(workspaceRoot, VALIDATION_CONTRACT_MARKDOWN_PATH))) {
+        return { ok: true, contract: null, path: VALIDATION_CONTRACT_MARKDOWN_PATH, advisory: true };
+      }
+      return { ok: true, contract: null };
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      path: contractPath ?? VALIDATION_CONTRACT_YAML_PATHS[0] ?? "validation.yaml",
+      reason: `cannot inspect workspace root (${error instanceof Error ? error.message : String(error)})`
+    };
+  }
+  const text = readContractText(path.join(workspaceRoot, contractPath), workspaceRoot);
+  if (text instanceof Error) return { ok: false, path: contractPath, reason: text.message };
+  return parseValidationContractText(text, contractPath);
+}
+function describeValidationContract(result) {
+  if (!result.ok) return `${result.path}: ${result.reason}`;
+  if (result.contract === null) {
+    return "advisory" in result ? `${result.path} is advisory prose and does not raise rigor; add a version-1 validation.yaml to raise the default to high` : null;
+  }
+  return null;
+}
+
+export {
+  VALIDATION_CONTRACT_MARKDOWN_PATH,
+  loadValidationContract,
+  describeValidationContract
+};
+//# sourceMappingURL=chunk-RFULVPBX.js.map