@pome-sh/checks 0.1.0

package/dist/chunk-4WXX5VPA.js

@@ -0,0 +1,238 @@
+import { createHash } from 'node:crypto';
+
+// ../sdk/dist/check-discrimination.js
+function isRealPass(outcome) {
+  return outcome.passed === true && (outcome.status === void 0 || outcome.status === "passed");
+}
+function isRealFail(outcome) {
+  return outcome.passed === false && (outcome.status === void 0 || outcome.status === "failed");
+}
+var describeOutcome = (outcome) => `passed=${outcome.passed} status=${outcome.status ?? "-"} reason=${JSON.stringify(outcome.reason)}`;
+function reasonOnEmptyWorld(def, args) {
+  try {
+    return def.evaluate(args, { seed: {}, final: {}, tape: [] }).reason;
+  } catch {
+    return null;
+  }
+}
+function probeDiscrimination(def, args) {
+  const worlds = def.discriminatingWorlds(args);
+  if (worlds === null)
+    return { kind: "declined" };
+  const passing = def.evaluate(args, worlds.passing);
+  if (!isRealPass(passing)) {
+    return {
+      kind: "broken",
+      arm: "passing",
+      detail: `passing world did not pass \u2014 ${describeOutcome(passing)}`
+    };
+  }
+  const failing = def.evaluate(args, worlds.failing);
+  if (!isRealFail(failing)) {
+    return {
+      kind: "broken",
+      arm: "failing",
+      detail: `failing world did not fail \u2014 ${describeOutcome(failing)}`
+    };
+  }
+  const degenerate = reasonOnEmptyWorld(def, args);
+  if (degenerate !== null && failing.reason === degenerate) {
+    return {
+      kind: "broken",
+      arm: "degenerate",
+      detail: `the failing world's reason is the one an EMPTY world produces (${JSON.stringify(failing.reason)}), so it fails through its selector rather than its assertion`
+    };
+  }
+  return { kind: "discriminates" };
+}
+
+// ../sdk/dist/check-state-path.js
+function escapeSegment(segment) {
+  return segment.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function unescapeSegment(segment) {
+  return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function statePath(...segments) {
+  return segments.map((segment) => `/${escapeSegment(String(segment))}`).join("");
+}
+function childStatePath(base, ...segments) {
+  return `${base}${statePath(...segments)}`;
+}
+function resolveStatePath(tree, pointer) {
+  if (pointer === "")
+    return { value: tree };
+  if (!pointer.startsWith("/"))
+    return null;
+  let cursor = tree;
+  for (const raw of pointer.slice(1).split("/")) {
+    const segment = unescapeSegment(raw);
+    if (Array.isArray(cursor)) {
+      if (!/^(?:0|[1-9][0-9]*)$/.test(segment))
+        return null;
+      const index = Number(segment);
+      if (index >= cursor.length)
+        return null;
+      cursor = cursor[index];
+      continue;
+    }
+    if (cursor === null || typeof cursor !== "object")
+      return null;
+    const record = cursor;
+    if (!Object.prototype.hasOwnProperty.call(record, segment))
+      return null;
+    cursor = record[segment];
+  }
+  return { value: cursor };
+}
+function probeArm(def, args, arm, world) {
+  const outcome = def.evaluate(args, world);
+  const paths = outcome.evidenceStatePaths;
+  if (paths === void 0)
+    return { kind: "uncited", arm };
+  if (!Array.isArray(paths) || paths.length === 0) {
+    return {
+      kind: "malformed",
+      arm,
+      detail: `evidenceStatePaths must be omitted when empty, not sent as ${JSON.stringify(paths)}`
+    };
+  }
+  for (const pointer of paths) {
+    if (typeof pointer !== "string" || pointer === "") {
+      return {
+        kind: "malformed",
+        arm,
+        detail: `${JSON.stringify(pointer)} is not a pointer \u2014 the whole-document pointer "" is not a citation`
+      };
+    }
+    if (resolveStatePath(world.final, pointer) === null) {
+      return { kind: "unresolvable", arm, pointer };
+    }
+  }
+  return { kind: "cites" };
+}
+function probeStateCitation(def, args) {
+  const worlds = def.discriminatingWorlds(args);
+  if (worlds === null)
+    return { kind: "declined" };
+  const passing = probeArm(def, args, "passing", worlds.passing);
+  if (passing.kind !== "cites")
+    return passing;
+  return probeArm(def, args, "failing", worlds.failing);
+}
+var VACUITY_SENTINEL = "pome-vacuity-never";
+var VACUITY_SENTINEL_SNAKE = "pome_vacuity_never";
+var VACUITY_SENTINEL_NUMBER = 987654321;
+var repoRef = {
+  name: "repo",
+  pattern: "[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+",
+  example: "acme/api",
+  render: (value) => value,
+  parse: (raw) => raw
+};
+function oneOf(name, values, example) {
+  if (values.length === 0)
+    throw new Error(`param type ${name}: oneOf needs at least one value`);
+  return {
+    name,
+    pattern: `(?:${values.map(escapeLiteral).join("|")})`,
+    example: example ?? values[0],
+    render: (value) => value,
+    parse: (raw) => raw
+  };
+}
+function captureGroupCount(source) {
+  return new RegExp(`${source}|`).exec("").length - 1;
+}
+var SLOT_RE = /\{([a-z][a-z0-9_]*)\}/g;
+function templateSlots(template) {
+  const literals = [];
+  const params = [];
+  let cursor = 0;
+  for (const match of template.matchAll(SLOT_RE)) {
+    literals.push(template.slice(cursor, match.index));
+    params.push(match[1]);
+    cursor = match.index + match[0].length;
+  }
+  literals.push(template.slice(cursor));
+  return { literals, params };
+}
+function escapeLiteral(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function defineCheck(def) {
+  const { params } = templateSlots(def.template);
+  const seen = /* @__PURE__ */ new Set();
+  for (const param of params) {
+    if (seen.has(param)) {
+      throw new Error(`check ${def.id}: duplicate template slot {${param}}`);
+    }
+    seen.add(param);
+    if (!def.params[param]) {
+      throw new Error(`check ${def.id}: template slot {${param}} has no declared param type`);
+    }
+  }
+  for (const declared of Object.keys(def.params)) {
+    if (!seen.has(declared)) {
+      throw new Error(`check ${def.id}: declared param \`${declared}\` is not used by the template`);
+    }
+  }
+  for (const [name, type] of Object.entries(def.params)) {
+    const paramType = type;
+    if (!new RegExp(`^${paramType.pattern}$`).test(paramType.example)) {
+      throw new Error(`check ${def.id}: param \`${name}\` example ${JSON.stringify(paramType.example)} does not match its own pattern /${paramType.pattern}/`);
+    }
+    const groups = captureGroupCount(paramType.pattern);
+    if (groups > 0) {
+      throw new Error(`check ${def.id}: param \`${name}\` pattern /${paramType.pattern}/ opens ${groups} capture group(s). Slot patterns must be group-free \u2014 use (?:\u2026) \u2014 or every slot after this one binds the wrong value.`);
+    }
+  }
+  return def;
+}
+function renderCheck(def, args) {
+  const { literals, params } = templateSlots(def.template);
+  let rendered = literals[0];
+  params.forEach((param, index) => {
+    const type = def.params[param];
+    rendered += type.render(args[param]) + literals[index + 1];
+  });
+  return rendered;
+}
+function buildPattern(template, slotSource) {
+  const { literals, params } = templateSlots(template);
+  let source = `^${escapeLiteral(literals[0])}`;
+  params.forEach((_param, index) => {
+    source += `(${slotSource(index)})${escapeLiteral(literals[index + 1])}`;
+  });
+  return new RegExp(`${source}$`);
+}
+function checkPattern(def) {
+  const { params } = templateSlots(def.template);
+  return buildPattern(def.template, (index) => def.params[params[index]].pattern);
+}
+function checksDigest(defs) {
+  const rows = defs.map((def) => ({
+    id: def.id,
+    substrate: def.substrate,
+    // The compiled source, not the template: this also catches a change in
+    // `buildPattern` itself, which comparing templates would miss.
+    pattern: checkPattern(def).source
+  })).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  return `sha256:${createHash("sha256").update(JSON.stringify(rows), "utf8").digest("hex")}`;
+}
+function checkNearMissPattern(def) {
+  return buildPattern(def.template, () => ".+?");
+}
+function parseCheck(def, text) {
+  const matched = text.trim().match(checkPattern(def));
+  if (!matched)
+    return null;
+  const { params } = templateSlots(def.template);
+  const args = {};
+  params.forEach((param, index) => {
+    args[param] = def.params[param].parse(matched[index + 1]);
+  });
+  return args;
+}
+
+export { VACUITY_SENTINEL, VACUITY_SENTINEL_NUMBER, VACUITY_SENTINEL_SNAKE, checkNearMissPattern, checkPattern, checksDigest, childStatePath, defineCheck, oneOf, parseCheck, probeDiscrimination, probeStateCitation, renderCheck, repoRef, resolveStatePath, statePath, templateSlots };