@ixo/editor 6.33.0 → 6.35.0

package/dist/EvalEngineFlowDetail-PUFRNO4U.js

@@ -0,0 +1,4291 @@
+import {
+  formatCapCoins,
+  parseEvalEngineInputs
+} from "./chunk-NJAII6CO.js";
+import {
+  billingNote,
+  ownerPaysLine,
+  usdLabel,
+  useEnginePricing
+} from "./chunk-ILSFU3WD.js";
+import {
+  CollapsibleSection
+} from "./chunk-CGFAICUE.js";
+import {
+  getCollectionDisplayName
+} from "./chunk-EKBQ7K4N.js";
+import {
+  UserSearch
+} from "./chunk-GR4SIU32.js";
+import {
+  BaseAlert,
+  BaseMultiSelect
+} from "./chunk-7ZLW7H37.js";
+import {
+  icon
+} from "./chunk-YN4CEKCF.js";
+import {
+  BaseNumberInput
+} from "./chunk-76YX5R4L.js";
+import {
+  BasePrimaryButton
+} from "./chunk-K74XQ4Q5.js";
+import {
+  BaseSelect
+} from "./chunk-4NAFQF6V.js";
+import "./chunk-NZ7AXA7B.js";
+import "./chunk-XVA7QRVH.js";
+import {
+  FORM_SEGMENT,
+  SCHEMA_UNKNOWN_KEY_PREFIX,
+  buildRubricEnvelope,
+  extractRubricFieldCatalog,
+  operatorsForKind,
+  parseEvalRubricInputs,
+  parsePublishedRubric,
+  serializeEvalRubricInputs,
+  validateRubric,
+  validateRubricShape
+} from "./chunk-NIXT2SBH.js";
+import {
+  resolveReferences
+} from "./chunk-JVROGQ7Q.js";
+import "./chunk-HT6L7A5M.js";
+import {
+  BaseTextArea
+} from "./chunk-ZDNW6VQG.js";
+import {
+  actionAlertStyles
+} from "./chunk-6GKJR52N.js";
+import {
+  BaseTextInput
+} from "./chunk-WO7V6ZNC.js";
+import {
+  useBlocknoteHandlers
+} from "./chunk-4DGCCXD6.js";
+import "./chunk-7W7UUUIE.js";
+import {
+  matrixUserIdToDid
+} from "./chunk-TS2LNBF2.js";
+
+// src/mantine/blocks/action/actionTypes/evalEngine/EvalEngineFlowDetail.tsx
+import React14, { useCallback as useCallback2, useEffect as useEffect6, useMemo as useMemo7, useRef as useRef5, useState as useState9 } from "react";
+import { ActionIcon as ActionIcon6, Alert as Alert6, Badge as Badge2, Box as Box5, Button as Button8, Group as Group13, Loader as Loader3, Paper as Paper10, Stack as Stack12, Text as Text12 } from "@mantine/core";
+import { IconAlertCircle, IconAlertTriangle as IconAlertTriangle5, IconArrowRight, IconCheck as IconCheck2, IconInfoCircle, IconTrash as IconTrash4 } from "@tabler/icons-react";
+
+// src/mantine/blocks/action/actionTypes/evalRubric/AdvancedPanel.tsx
+import React from "react";
+import { Button, Code, CopyButton, Group, ScrollArea, Stack } from "@mantine/core";
+var AdvancedPanel = ({ body }) => /* @__PURE__ */ React.createElement(CollapsibleSection, { title: "Your rules, as the machine reads them" }, /* @__PURE__ */ React.createElement(MachineView, { body }));
+var MachineView = ({ body }) => {
+  const text = JSON.stringify(buildRubricEnvelope(body), null, 2);
+  return /* @__PURE__ */ React.createElement(Stack, { gap: "xs" }, /* @__PURE__ */ React.createElement(Group, { justify: "flex-end" }, /* @__PURE__ */ React.createElement(CopyButton, { value: text }, ({ copied, copy }) => /* @__PURE__ */ React.createElement(Button, { size: "compact-xs", variant: "subtle", onClick: copy }, copied ? "Copied" : "Copy"))), /* @__PURE__ */ React.createElement(ScrollArea.Autosize, { mah: 280 }, /* @__PURE__ */ React.createElement(Code, { block: true, style: { fontSize: 11 } }, text)));
+};
+
+// src/mantine/blocks/action/actionTypes/evalRubric/ApprovalPolicy.tsx
+import React3, { useEffect, useRef, useState } from "react";
+import { Box, Button as Button2, Checkbox, Group as Group2, Paper, SegmentedControl, Stack as Stack2, Text } from "@mantine/core";
+import { IconPin } from "@tabler/icons-react";
+
+// src/mantine/blocks/action/actionTypes/evalRubric/phrases.ts
+import { IconBan, IconUserSearch } from "@tabler/icons-react";
+
+// src/mantine/blocks/action/actionTypes/evalRubric/ruleModel.ts
+function indexCatalog(catalog) {
+  const index = /* @__PURE__ */ new Map();
+  const add = (field) => {
+    index.set(field.path, field);
+    field.columns?.forEach(add);
+  };
+  for (const field of catalog?.fields ?? []) add(field);
+  return index;
+}
+function rootPath(path, cards) {
+  if (cards) {
+    for (let prefix = path; ; ) {
+      if (cards.has(prefix)) return prefix;
+      const cut = Math.max(prefix.lastIndexOf("."), prefix.lastIndexOf("["));
+      if (cut <= 0) break;
+      prefix = prefix.slice(0, cut);
+    }
+  }
+  return FIELD_ROOT.exec(path)?.[0] ?? path;
+}
+var FIELD_ROOT = new RegExp(`^\\$${FORM_SEGMENT}`);
+function targetableFields(field) {
+  return [field, ...field.columns ?? []];
+}
+var EXT_REF = /^ext\.([A-Za-z0-9_-]+)\.(valid|score|reason)$/;
+function extFieldKind(fieldName) {
+  return fieldName === "score" ? "number" : fieldName === "valid" ? "boolean" : "text";
+}
+function extRefField(ref, sources) {
+  const match = EXT_REF.exec(ref);
+  if (!match) return void 0;
+  const source = sources?.find((entry) => entry.name === match[1]);
+  if (!source) return void 0;
+  const fieldName = match[2];
+  if (fieldName === "valid" && source.expect !== "boolean") return void 0;
+  if (fieldName === "score" && source.expect !== "score") return void 0;
+  const noun = fieldName === "valid" ? "passed?" : fieldName;
+  return { path: ref, kind: extFieldKind(fieldName), title: `${source.name} check \u2014 ${noun}`, isRequired: false };
+}
+function extRefQuestion(ref, body) {
+  const name = EXT_REF.exec(ref)?.[1];
+  const source = name ? body?.sources?.find((entry) => entry.name === name) : void 0;
+  if (!source) return void 0;
+  return Object.values(source.send).find((value) => typeof value === "string" && value.startsWith("$"));
+}
+var AI_REF = /^ai\.([A-Za-z0-9_-]+)\.(valid|reason)$/;
+function aiRefField(ref, aiChecks) {
+  const match = AI_REF.exec(ref);
+  if (!match) return void 0;
+  const check = aiChecks?.find((entry) => entry.name === match[1]);
+  if (!check) return void 0;
+  const fieldName = match[2];
+  return { path: ref, kind: fieldName === "valid" ? "boolean" : "text", title: `${check.name} AI check \u2014 ${fieldName === "valid" ? "passed?" : "reason"}`, isRequired: false };
+}
+function aiRefQuestion(ref, body) {
+  const name = AI_REF.exec(ref)?.[1];
+  const check = name ? body?.aiChecks?.find((entry) => entry.name === name) : void 0;
+  if (!check) return void 0;
+  return Object.values(check.send).find((value) => typeof value === "string" && value.startsWith("$"));
+}
+var AI_VALID_REF = /^ai\.([A-Za-z0-9_-]+)\.valid$/;
+function aiMemberName(member) {
+  return member.op === "isTrue" ? AI_VALID_REF.exec(member.field)?.[1] : void 0;
+}
+function aiSendFields(check) {
+  const values = Object.values(check.send ?? {});
+  if (values.length === 0) return void 0;
+  return values.every((value) => typeof value === "string" && value.startsWith("$")) ? values : void 0;
+}
+var DERIVED_VALUE_REF = /^~([A-Za-z0-9_-]+)$/;
+var DERIVED_EXPR_REFS = /~([A-Za-z0-9_-]+)/g;
+function pruneDanglingSources(body) {
+  const sources = body.sources ?? [];
+  const aiChecks = body.aiChecks ?? [];
+  const derived = body.derived ?? [];
+  if (sources.length === 0 && aiChecks.length === 0 && derived.length === 0) return body;
+  const used = /* @__PURE__ */ new Set();
+  const usedAi = /* @__PURE__ */ new Set();
+  const usedDerived = /* @__PURE__ */ new Set();
+  const note = (value) => {
+    if (typeof value === "string") {
+      const name = EXT_REF.exec(value)?.[1];
+      if (name) used.add(name);
+      const aiName = AI_REF.exec(value)?.[1];
+      if (aiName) usedAi.add(aiName);
+      const derivedName = DERIVED_VALUE_REF.exec(value)?.[1];
+      if (derivedName) usedDerived.add(derivedName);
+    } else if (Array.isArray(value)) {
+      value.forEach(note);
+    }
+  };
+  const walkCondition = (cond) => {
+    if (!cond || typeof cond !== "object") return;
+    if ("forEach" in cond) {
+      walkCondition(cond.every);
+      walkCondition(cond.some);
+      return;
+    }
+    if ("all" in cond) {
+      cond.all.forEach(walkCondition);
+      return;
+    }
+    if ("any" in cond) {
+      cond.any.forEach(walkCondition);
+      return;
+    }
+    if ("not" in cond) {
+      walkCondition(cond.not);
+      return;
+    }
+    if ("atLeast" in cond) {
+      cond.of.forEach(walkCondition);
+      return;
+    }
+    if ("field" in cond) {
+      note(cond.field);
+      note(cond.value);
+    }
+  };
+  const walkScore = (score) => {
+    if (!score) return;
+    switch (score["@type"]) {
+      case "BooleanScore":
+        walkCondition(score.when);
+        break;
+      case "BandsScore":
+        note(score.value);
+        (score.bands ?? []).forEach((band) => "op" in band && note(band.value));
+        break;
+      case "LinearScore":
+        note(score.value);
+        note(score.zeroAt);
+        note(score.fullAt);
+        break;
+      case "MapScore":
+        note(score.value);
+        break;
+      case "LevelsScore":
+        (score.levels ?? []).forEach((level) => "when" in level && walkCondition(level.when));
+        break;
+      case "DeductionsScore":
+        (score.deduct ?? []).forEach((deduction) => walkCondition(deduction.when));
+        break;
+      default:
+        break;
+    }
+  };
+  for (const gate of body.gates ?? []) {
+    walkCondition(gate.when);
+    walkCondition(gate.appliesWhen);
+  }
+  for (const criterion of body.scoring?.criteria ?? []) {
+    walkCondition(criterion.appliesWhen);
+    walkScore(criterion.score);
+  }
+  note(body.settlement?.onPartial?.prorateBy);
+  const kept = sources.filter((source) => used.has(source.name));
+  const keptAi = aiChecks.filter((check) => usedAi.has(check.name));
+  for (const source of kept) Object.values(source.send ?? {}).forEach(note);
+  for (const check of keptAi) Object.values(check.send ?? {}).forEach(note);
+  let keptDerived = derived;
+  for (; ; ) {
+    const live = new Set(usedDerived);
+    for (const entry of keptDerived) {
+      for (const match of entry.expr.matchAll(DERIVED_EXPR_REFS)) live.add(match[1]);
+    }
+    const next = keptDerived.filter((entry) => live.has(entry.name));
+    if (next.length === keptDerived.length) break;
+    keptDerived = next;
+  }
+  if (kept.length === sources.length && keptAi.length === aiChecks.length && keptDerived.length === derived.length) return body;
+  return {
+    ...body,
+    sources: kept.length > 0 ? kept : void 0,
+    aiChecks: keptAi.length > 0 ? keptAi : void 0,
+    derived: keptDerived.length > 0 ? keptDerived : void 0
+  };
+}
+function toCondition(rule) {
+  const inner = {
+    "@type": "Condition",
+    field: rule.field,
+    op: rule.op,
+    ...rule.value !== void 0 ? { value: rule.value } : {},
+    ...rule.tolerance !== void 0 ? { tolerance: rule.tolerance } : {}
+  };
+  const rowIndex = rule.field.indexOf("[*]");
+  if (rowIndex < 0) return inner;
+  return { "@type": "Condition", forEach: rule.field.slice(0, rowIndex), every: { ...inner, field: rule.field.slice(rowIndex + 3) } };
+}
+function toSimpleRule(cond) {
+  if (!cond) return void 0;
+  if ("forEach" in cond && typeof cond.forEach === "string") {
+    const every = cond.every;
+    if (!every || !("field" in every) || typeof every.field !== "string" || !every.field.startsWith(".")) return void 0;
+    return { field: `${cond.forEach}[*]${every.field}`, op: every.op, value: every.value, tolerance: every.tolerance };
+  }
+  if ("field" in cond && typeof cond.field === "string") return { field: cond.field, op: cond.op, value: cond.value, tolerance: cond.tolerance };
+  return void 0;
+}
+function groupShapeOf(when, aiChecks) {
+  if (!when || typeof when !== "object") return void 0;
+  if ("not" in when) return { editable: false };
+  if ("any" in when || "atLeast" in when || "of" in when) return { editable: false };
+  if (!("all" in when)) return void 0;
+  const raw = when.all;
+  if (!Array.isArray(raw) || raw.length === 0) return { editable: false };
+  const members = [];
+  for (const member of raw) {
+    const simple = toSimpleRule(member);
+    if (!simple) return { editable: false };
+    const aiName = aiMemberName(simple);
+    if (aiName && aiChecks !== void 0) {
+      const check = aiChecks.find((entry) => entry.name === aiName);
+      if (!check || !aiSendFields(check)) return { editable: false };
+    }
+    members.push(simple);
+  }
+  return { editable: true, members };
+}
+function policyMemberRenderable(cond) {
+  if (!cond || typeof cond !== "object") return false;
+  if (toSimpleRule(cond)) return true;
+  if ("all" in cond && Array.isArray(cond.all) && cond.all.length > 0) return cond.all.every((member) => toSimpleRule(member) !== void 0);
+  return false;
+}
+function policyShapeOf(body) {
+  const gates = body?.gates ?? [];
+  const candidates = [];
+  gates.forEach((gate2, index2) => {
+    const when2 = gate2.when;
+    if (when2 && typeof when2 === "object" && ("any" in when2 || "atLeast" in when2 || "of" in when2)) candidates.push(index2);
+  });
+  if (candidates.length === 0) return { kind: "none" };
+  if (candidates.length > 1) return { kind: "foreign" };
+  const index = candidates[0];
+  const gate = gates[index];
+  const when = gate.when;
+  const members = Array.isArray(when.any) ? when.any : Array.isArray(when.of) ? when.of : void 0;
+  if (!members || members.length === 0) return { kind: "foreign" };
+  if (!members.every(policyMemberRenderable)) return { kind: "foreign" };
+  if (gate.appliesWhen && !toSimpleRule(gate.appliesWhen)) return { kind: "foreign" };
+  if (Array.isArray(when.any)) return { kind: "policy", index, gate, tab: "any", members };
+  const n = when.atLeast;
+  if (!Number.isInteger(n) || n < 1 || n > members.length) return { kind: "foreign" };
+  return { kind: "policy", index, gate, tab: "atLeast", nRest: n, members };
+}
+function valueKey(value) {
+  return JSON.stringify(value) ?? "undefined";
+}
+function listLinkedRules(body) {
+  const gates = body?.gates ?? [];
+  const aiChecksByName = new Map((body?.aiChecks ?? []).map((check) => [check.name, check]));
+  const byKey = /* @__PURE__ */ new Map();
+  const push = (key, candidate) => {
+    const bucket = byKey.get(key);
+    if (bucket) bucket.push(candidate);
+    else byKey.set(key, [candidate]);
+  };
+  gates.forEach((gate, index) => {
+    if (groupShapeOf(gate.when)) return;
+    const when = toSimpleRule(gate.when);
+    const guard = toSimpleRule(gate.appliesWhen);
+    if (!when || !guard) return;
+    if (guard.op !== "in" && guard.op !== "notIn") return;
+    if (!Array.isArray(guard.value) || guard.value.length === 0) return;
+    if (guard.op === "in" && guard.value.length !== 1) return;
+    if (guard.field.includes("[*]")) return;
+    const aiName = aiMemberName(when);
+    if (aiName) {
+      const check = aiChecksByName.get(aiName);
+      if (!check) return;
+      const sendFields = aiSendFields(check);
+      if (!sendFields) return;
+      if (check.instructions.length !== 1 || typeof check.instructions[0] !== "string") return;
+      if (guard.field === sendFields[0]) return;
+      push(JSON.stringify(["ai", guard.field, sendFields]), { index, gate, when, guard, ai: { name: aiName, instructions: check.instructions[0], sendFields } });
+      return;
+    }
+    if (guard.field === when.field) return;
+    push(JSON.stringify([when.field, when.op, guard.field]), { index, gate, when, guard });
+  });
+  const out = [];
+  for (const bucket of byKey.values()) {
+    const named = bucket.filter((entry) => entry.guard.op === "in");
+    const others = bucket.filter((entry) => entry.guard.op === "notIn");
+    if (named.length < 1 || others.length !== 1) continue;
+    const elseEntry = others[0];
+    const unionKeys = named.map((entry) => valueKey(entry.guard.value[0]));
+    if (new Set(unionKeys).size !== unionKeys.length) continue;
+    const elseKeys = elseEntry.guard.value.map(valueKey);
+    if (elseKeys.length !== unionKeys.length) continue;
+    if ([...unionKeys].sort().join("\0") !== [...elseKeys].sort().join("\0")) continue;
+    const onFail = bucket[0].gate.onFail ?? "reject";
+    const gateClass = bucket[0].gate.class;
+    if (!bucket.every((entry) => (entry.gate.onFail ?? "reject") === onFail && entry.gate.class === gateClass)) continue;
+    const ai = bucket[0].ai;
+    if (ai && new Set(bucket.map((entry) => entry.ai?.name)).size !== bucket.length) continue;
+    const caseExtras = (entry) => entry.ai ? { aiName: entry.ai.name, instructions: entry.ai.instructions } : {};
+    out.push({
+      checkedField: ai ? ai.sendFields[0] : bucket[0].when.field,
+      op: bucket[0].when.op,
+      guardField: bucket[0].guard.field,
+      cases: named.map((entry) => ({
+        code: entry.gate.code,
+        index: entry.index,
+        gate: entry.gate,
+        guardValue: entry.guard.value[0],
+        when: entry.when,
+        ...caseExtras(entry)
+      })),
+      elseCase: { code: elseEntry.gate.code, index: elseEntry.index, gate: elseEntry.gate, when: elseEntry.when, ...caseExtras(elseEntry) },
+      onFail,
+      gateClass,
+      indices: bucket.map((entry) => entry.index).sort((a, b) => a - b),
+      ...ai ? { ai: { alsoSend: ai.sendFields.slice(1) } } : {}
+    });
+  }
+  return out.sort((a, b) => a.indices[0] - b.indices[0]);
+}
+function removeGatesAt(body, indices) {
+  const drop = new Set(indices);
+  return { ...body, gates: (body.gates ?? []).filter((_, i) => !drop.has(i)) };
+}
+var SCORE_SUBJECT = /^ext\.([A-Za-z0-9_-]+)\.score$/;
+function scoreGateOf(gate) {
+  const simple = toSimpleRule(gate.when);
+  if (!simple || simple.op !== ">=") return void 0;
+  const name = SCORE_SUBJECT.exec(simple.field)?.[1];
+  if (!name) return void 0;
+  const value = simple.value;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 1e4) return void 0;
+  return { name, value };
+}
+function scoreBandsByHold(gates, skip, claimedFloors) {
+  const bySource = /* @__PURE__ */ new Map();
+  gates.forEach((gate, index) => {
+    if (skip.has(index)) return;
+    const score = scoreGateOf(gate);
+    if (!score) return;
+    const entry = bySource.get(score.name) ?? { holds: [], floors: [] };
+    ((gate.onFail ?? "reject") === "review" ? entry.holds : entry.floors).push(index);
+    bySource.set(score.name, entry);
+  });
+  const out = /* @__PURE__ */ new Map();
+  for (const { holds, floors } of bySource.values()) {
+    if (holds.length !== 1) continue;
+    const hold = holds[0];
+    const approveAt = scoreGateOf(gates[hold]).value;
+    const lone = { approveAt, rejectBelow: 0, indices: [hold] };
+    if (floors.length === 0) {
+      out.set(hold, lone);
+      continue;
+    }
+    if (floors.length > 1) continue;
+    const floorIndex = floors[0];
+    const floorGate = gates[floorIndex];
+    const rejectBelow = scoreGateOf(floorGate).value;
+    const sameGuard = JSON.stringify(gates[hold].appliesWhen ?? null) === JSON.stringify(floorGate.appliesWhen ?? null);
+    if (floorIndex > hold || rejectBelow >= approveAt || !sameGuard) {
+      out.set(hold, lone);
+      continue;
+    }
+    claimedFloors.add(floorIndex);
+    out.set(hold, { approveAt, rejectBelow, floor: { index: floorIndex, code: floorGate.code, gate: floorGate }, indices: [floorIndex, hold] });
+  }
+  return out;
+}
+function primaryFieldOf(cond) {
+  if (!cond || typeof cond !== "object") return "";
+  if ("forEach" in cond && typeof cond.forEach === "string") return cond.forEach;
+  if ("field" in cond && typeof cond.field === "string") return cond.field;
+  const members = "not" in cond ? [cond.not] : "all" in cond && Array.isArray(cond.all) ? cond.all : "any" in cond && Array.isArray(cond.any) ? cond.any : "of" in cond && Array.isArray(cond.of) ? cond.of : [];
+  for (const member of members) {
+    const found = primaryFieldOf(member);
+    if (found) return found;
+  }
+  return "";
+}
+function manualScoreField(score) {
+  return score?.["@type"] === "ManualScore" ? score.field : "";
+}
+var FIELD_IN_EXPR = new RegExp(`\\$${FORM_SEGMENT}(?:\\.${FORM_SEGMENT}|\\[\\*\\])*`);
+function resolveRef(ref, body) {
+  if (ref.startsWith("ext.")) return extRefQuestion(ref, body) ?? ref;
+  if (ref.startsWith("ai.")) return aiRefQuestion(ref, body) ?? ref;
+  if (!ref.startsWith("~")) return ref;
+  const derived = body.derived?.find((entry) => entry.name === ref.slice(1));
+  return derived && FIELD_IN_EXPR.exec(derived.expr)?.[0] || ref;
+}
+function listRules(body) {
+  if (!body) return [];
+  const claimed = /* @__PURE__ */ new Set();
+  for (const linked of listLinkedRules(body)) for (const index of linked.indices) claimed.add(index);
+  const policy = policyShapeOf(body);
+  if (policy.kind === "policy") claimed.add(policy.index);
+  const bandsByHold = scoreBandsByHold(body.gates ?? [], claimed, claimed);
+  const rules = [];
+  (body.gates ?? []).forEach((gate, index) => {
+    if (claimed.has(index)) return;
+    const shape = groupShapeOf(gate.when, body.aiChecks ?? []);
+    const grown = shape && shape.editable && gate.appliesWhen && !toSimpleRule(gate.appliesWhen) ? { editable: false } : shape;
+    const bands = bandsByHold.get(index);
+    rules.push({
+      consequence: "reject",
+      code: gate.code,
+      index,
+      fieldPath: resolveRef(primaryFieldOf(gate.when), body),
+      gate,
+      ...grown ? { grown } : {},
+      ...bands ? { bands } : {}
+    });
+  });
+  (body.scoring?.criteria ?? []).forEach((criterion, index) => {
+    if (criterion.score?.["@type"] !== "ManualScore") return;
+    const fieldPath = resolveRef(manualScoreField(criterion.score), body);
+    const task = (body.review?.tasks ?? []).find((t) => t.id === criterion.score.reviewTask);
+    rules.push({ consequence: "human", code: criterion.code, index, fieldPath, criterion, task });
+  });
+  return rules;
+}
+function rulesByCard(body, cards) {
+  const byCard = /* @__PURE__ */ new Map();
+  for (const rule of listRules(body)) {
+    const key = rule.fieldPath ? rootPath(rule.fieldPath, cards) : "";
+    const bucket = byCard.get(key);
+    if (bucket) bucket.push(rule);
+    else byCard.set(key, [rule]);
+  }
+  return byCard;
+}
+var CODE_SEQUENCE = /^[A-Z0-9]+-(\d+)-/;
+function usedCodes(body) {
+  if (!body) return [];
+  const codes = [];
+  for (const gate of body.gates ?? []) codes.push(gate.code);
+  for (const criterion of body.scoring?.criteria ?? []) {
+    codes.push(criterion.code);
+    if (criterion.score?.["@type"] === "DeductionsScore") for (const deduction of criterion.score.deduct ?? []) codes.push(deduction.code);
+  }
+  for (const task of body.review?.tasks ?? []) codes.push(task.id);
+  for (const derived of body.derived ?? []) codes.push(derived.name);
+  return codes;
+}
+function codeToken(fieldPath) {
+  const token = fieldPath.replace(/^\$/, "").replace(/\[\*\]/g, "").replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").toUpperCase();
+  return token.slice(0, 24) || "ANSWER";
+}
+function nextCode(body, prefix, fieldPath, alsoUsed = []) {
+  const reserved = [...usedCodes(body), ...alsoUsed];
+  const taken = new Set(reserved);
+  const highest = reserved.reduce((max, code) => {
+    const seq = CODE_SEQUENCE.exec(code)?.[1];
+    return seq ? Math.max(max, Number(seq)) : max;
+  }, 100);
+  const token = codeToken(fieldPath);
+  for (let seq = highest + 1; ; seq++) {
+    const code = `${prefix}-${seq}-${token}`;
+    if (!taken.has(code)) return code;
+  }
+}
+var APPROVAL_METHOD = "all_pass";
+var APPROVE_AT = 8500;
+function emptyRubric(protocolDid, proof, title, resource = "#vct") {
+  return {
+    "@type": "Rubric",
+    title,
+    claimSchema: { "@type": "ClaimSchemaBinding", protocol: protocolDid, resource, proof },
+    gates: [],
+    scoring: { "@type": "Scoring", method: APPROVAL_METHOD, approveAt: APPROVE_AT, criteria: [] },
+    settlement: { "@type": "Settlement", onApprove: { pay: "approval" } }
+  };
+}
+function bindForm(current, protocol, resource, proof, title) {
+  if (current) {
+    return {
+      ...current,
+      claimSchema: { ...current.claimSchema, protocol, resource, proof },
+      // Re-pin the approval rule. A document written before the method picker
+      // was removed still says `weighted_average`, which would make the screen
+      // ("when all N checks pass") lie about what the engine will actually do.
+      ...current.scoring ? { scoring: { ...current.scoring, method: APPROVAL_METHOD } } : {}
+    };
+  }
+  return emptyRubric(protocol, proof, title, resource);
+}
+function putGate(body, gate, at) {
+  const gates = [...body.gates ?? []];
+  if (at === void 0) gates.push(gate);
+  else gates[at] = gate;
+  return { ...body, gates };
+}
+function putCriterion(body, criterion, at) {
+  const scoring = body.scoring ?? { "@type": "Scoring", method: APPROVAL_METHOD, approveAt: APPROVE_AT, criteria: [] };
+  const criteria = [...scoring.criteria ?? []];
+  if (at === void 0) criteria.push(criterion);
+  else criteria[at] = criterion;
+  return { ...body, scoring: { ...scoring, criteria } };
+}
+function putReviewTask(body, task) {
+  const review = body.review ?? {
+    "@type": "HumanReview",
+    assignTo: { role: "reviewer" },
+    slaHours: 48,
+    onTimeout: "reject",
+    tasks: []
+  };
+  const tasks = [...review.tasks ?? []];
+  const at = tasks.findIndex((t) => t.id === task.id);
+  if (at < 0) tasks.push(task);
+  else tasks[at] = task;
+  return { ...body, review: { ...review, tasks } };
+}
+function removeRule(body, rule) {
+  if (rule.consequence === "reject") {
+    const drop = new Set(rule.bands?.indices ?? [rule.index]);
+    return { ...body, gates: (body.gates ?? []).filter((_, i) => !drop.has(i)) };
+  }
+  const scoring = body.scoring;
+  const next = { ...body, ...scoring ? { scoring: { ...scoring, criteria: (scoring.criteria ?? []).filter((_, i) => i !== rule.index) } } : {} };
+  if (!rule.task) return next;
+  const tasks = (next.review?.tasks ?? []).filter((t) => t.id !== rule.task?.id);
+  if (tasks.length === 0) {
+    const { review: _dropped, ...withoutReview } = next;
+    return withoutReview;
+  }
+  return { ...next, review: { ...next.review, tasks } };
+}
+function ruleForDiagnosticPath(body, path) {
+  if (!body || !path) return void 0;
+  const rules = listRules(body);
+  const gate = /^\/gates\/(\d+)/.exec(path);
+  if (gate) {
+    const index = Number(gate[1]);
+    return rules.find((r) => r.consequence === "reject" && (r.index === index || r.bands?.indices.includes(index) === true));
+  }
+  const criterion = /^\/scoring\/criteria\/(\d+)/.exec(path);
+  if (criterion) return rules.find((r) => r.consequence !== "reject" && r.index === Number(criterion[1]));
+  const task = /^\/review\/tasks\/(\d+)/.exec(path);
+  if (task) {
+    const forCriterion = body.review?.tasks?.[Number(task[1])]?.forCriterion;
+    return rules.find((r) => r.code === forCriterion);
+  }
+  return void 0;
+}
+function cardForDiagnosticPath(body, path, cards) {
+  const rule = ruleForDiagnosticPath(body, path);
+  if (rule?.fieldPath) return rootPath(rule.fieldPath, cards);
+  const gate = /^\/gates\/(\d+)/.exec(path);
+  if (gate && body) {
+    const index = Number(gate[1]);
+    const linked = listLinkedRules(body).find((entry) => entry.indices.includes(index));
+    if (linked) return rootPath(linked.checkedField, cards);
+  }
+  return void 0;
+}
+var PASSED = 1e4;
+var FAILED = 0;
+
+// src/mantine/blocks/action/actionTypes/evalRubric/phrases.ts
+var CONSEQUENCES = [
+  { value: "reject", Icon: IconBan, color: "var(--mantine-color-red-6)", label: "Reject the claim", hint: "The claim is turned down straight away." },
+  { value: "human", Icon: IconUserSearch, color: "var(--mantine-color-grape-6)", label: "A person checks", hint: "Someone looks at it and answers a question." }
+];
+function consequenceIcon(consequence, size = 18) {
+  const found = CONSEQUENCES.find((c) => c.value === consequence);
+  return found ? icon(found.Icon, size, found.color) : null;
+}
+var KIND_LABEL = {
+  text: "writing",
+  number: "number",
+  date: "date",
+  choice: "choice",
+  multichoice: "tick list",
+  boolean: "yes / no",
+  file: "file",
+  signature: "signature",
+  keyed_choice: "grid",
+  cells: "table",
+  rows: "table",
+  keyed_text: "group of answers",
+  geo: "place"
+};
+var OPERATOR_PHRASE = {
+  present: { label: "must be filled in" },
+  empty: { label: "must be empty" },
+  "==": { label: "must be exactly" },
+  "!=": { label: "must not be" },
+  ">": { label: "must be more than" },
+  ">=": { label: "must be at least" },
+  "<": { label: "must be less than" },
+  "<=": { label: "must be at most" },
+  between: { label: "must be between" },
+  approx: { label: "must be about" },
+  in: { label: "must be one of" },
+  notIn: { label: "must not be one of" },
+  matches: { label: "must look like" },
+  startsWith: { label: "must start with" },
+  endsWith: { label: "must end with" },
+  lengthBetween: { label: "must be between", suffix: "characters long" },
+  contains: { label: "must include" },
+  containsAll: { label: "must include all of" },
+  containsAny: { label: "must include any of" },
+  subsetOf: { label: "may only include" },
+  countBetween: { label: "must have between", suffix: "entries" },
+  isTrue: { label: "must be ticked" },
+  isFalse: { label: "must be left unticked" },
+  before: { label: "must be before" },
+  after: { label: "must be after" },
+  withinWindow: { label: "must be during the collection period" },
+  withinDays: { label: "must be within the last", suffix: "days" },
+  notInFuture: { label: "cannot be in the future" },
+  mediaTypeIn: { label: "must be" },
+  maxSizeMB: { label: "must be smaller than", suffix: "MB" },
+  withinBoundary: { label: "must be inside the project area" },
+  withinRadius: { label: "must be near" }
+};
+function takesNoValue(op) {
+  return op === "present" || op === "empty" || op === "isTrue" || op === "isFalse" || op === "withinWindow" || op === "notInFuture" || op === "withinBoundary";
+}
+var CTX_LABEL = {
+  "ctx.now": "the moment it is judged",
+  "ctx.collection.startDate": "the day the collection opened",
+  "ctx.collection.endDate": "the day the collection closes",
+  "ctx.claim.submitter": "the person who sent the claim",
+  "ctx.claim.submitterAddress": "the wallet address of the person who sent the claim",
+  "ctx.claim.submissionDate": "the day the claim was sent",
+  "ctx.submitter.priorClaimCount": "how many claims this person sent before",
+  "ctx.submitter.priorApprovedCount": "how many of their claims were approved",
+  "ctx.collection.projectBoundary": "the project area"
+};
+var MEDIA_TYPES = [
+  { value: "application/pdf", label: "a PDF" },
+  { value: "image/*", label: "a picture" },
+  { value: "video/*", label: "a video" },
+  { value: "audio/*", label: "a sound recording" },
+  { value: "text/csv", label: "a spreadsheet (CSV)" }
+];
+var DIAGNOSTIC_TEXT = {
+  RUB_SCHEMA: "This rule has a setting the rules service will not accept \u2014 open it and check its options.",
+  RUB_FIELD_NOT_IN_SCHEMA: "This rule is about a question that is not on the form.",
+  RUB_FIELD_PATH: "This rule points at something the form does not have.",
+  RUB_OPERATOR_TYPE_MISMATCH: "This check does not work on this kind of answer.",
+  RUB_VALUE_TYPE: "The value here does not suit the check \u2014 fix it and the rule will work.",
+  RUB_UNKNOWN_REF: "This rule uses a value that no longer exists.",
+  RUB_EXPR_SYNTAX: "This calculated value could not be worked out.",
+  RUB_EXPR_UNKNOWN_FUNC: "This calculated value uses a way of counting we do not support.",
+  RUB_REGEX_UNSAFE: "This pattern is too complicated to be safe \u2014 please simplify it.",
+  RUB_THRESHOLD_ORDER: "The approve, part-pay and person-checks scores are in the wrong order.",
+  RUB_WEIGHT_INVALID: "How much this question counts must be between one and five stars.",
+  RUB_QUORUM_INVALID: "You are asking for more checks to pass than there are checks to pass.",
+  RUB_DUPLICATE_CODE: "Two rules are using the same name.",
+  RUB_REVIEW_TASK_UNMAPPED: "A person is meant to check this, but there is no question to ask them.",
+  RUB_REVIEW_ANSWER_UNMAPPED: "One of the answers a person can give does not decide anything yet.",
+  RUB_UNREACHABLE_BAND: "A step below can never be reached, because an earlier one always wins.",
+  RUB_WEIGHT_IGNORED: "The stars on your scored rules are being ignored \u2014 the way this rubric adds up scores does not use them.",
+  RUB_NO_RULES: "No rules yet \u2014 as it stands, every claim would be approved and paid without any checking. Add at least one rule before publishing.",
+  RUB_SCHEMA_DRIFT: "The form changed: this rule is about a question that was removed or altered.",
+  RUB_UNIQUE_KEY_DERIVED: "Calculated values cannot be part of the unique key \u2014 pick answers from the form instead.",
+  RUB_EXT_SOURCE_UNKNOWN: "This rule uses an external check that is not set up \u2014 add it under External checks, or fix the name.",
+  RUB_EXT_FIELD_INVALID: "This rule reads the wrong kind of answer from an external check \u2014 a yes/no check has no score, and a score has no yes/no.",
+  RUB_AI_CHECK_UNKNOWN: "This rule uses an AI check that is not set up \u2014 re-open the rule and pick \u201CAI checks it\u201D again.",
+  RUB_AI_FIELD_INVALID: "This rule reads the wrong kind of answer from an AI check \u2014 it gives a yes/no and a reason, nothing else."
+};
+function problemText(problem) {
+  return DIAGNOSTIC_TEXT[problem.code] ?? problem.message;
+}
+function schemaProblemText(path, hasCard) {
+  if (hasCard) return DIAGNOSTIC_TEXT.RUB_SCHEMA;
+  if (path === "/claimSchema/proof") return "This form has no fingerprint yet \u2014 reopen the collection so its form is pinned to these rules before publishing.";
+  if (path.startsWith("/claimSchema")) return "The form link needs refreshing \u2014 reopen the collection to reconnect these rules to its questions.";
+  if (path.startsWith("/review/assignTo")) return "This review\u2019s assigned person uses an old setting \u2014 re-pick the reviewer.";
+  if (path.startsWith("/review")) return "The \u201Ca person checks\u201D settings have something the rules service will not accept \u2014 re-open that rule and re-pick its options.";
+  if (path.startsWith("/scoring")) return "The approval scoring has a setting the rules service will not accept \u2014 check the approve score and how the rules add up.";
+  if (path.startsWith("/settlement")) return "The payout settings have a value the rules service will not accept.";
+  if (path.startsWith("/derived")) return "One of your calculated values has a setting the rules service will not accept.";
+  if (path.startsWith("/sources")) return "One of your external checks has a setting that isn\u2019t valid \u2014 check its web address, its audience, and that it sends at least one value.";
+  if (path.startsWith("/aiChecks")) return "One of your AI checks has a setting that isn\u2019t valid \u2014 re-open its rule and make sure it has at least one written rule to check.";
+  if (path.startsWith("/unique")) return "The \u201Cmust be unique\u201D rule has a setting the rules service will not accept \u2014 re-pick its answers and thresholds.";
+  if (path.startsWith("/frequency")) return "The \u201Chow often\u201D limit has a setting the rules service will not accept \u2014 re-pick its number and period.";
+  return "These rules are missing something the rules service needs \u2014 add at least one reject rule or scored question.";
+}
+var EXT_REF2 = /^ext\.([A-Za-z0-9_-]+)\.(valid|score|reason)$/;
+function describeExtRef(ref, quoted) {
+  const match = EXT_REF2.exec(ref);
+  if (!match) return ref;
+  const [, name, fieldName] = match;
+  const label = quoted ? `the \u201C${name}\u201D check` : `${name} check`;
+  if (fieldName === "score") return `${label} score`;
+  if (fieldName === "reason") return `${label} reason`;
+  return label;
+}
+var AI_REF2 = /^ai\.([A-Za-z0-9_-]+)\.(valid|reason)$/;
+function describeAiRef(ref) {
+  const match = AI_REF2.exec(ref);
+  if (!match) return ref;
+  const [, name, fieldName] = match;
+  const label = `${name.replace(/_ai(_\d+)?$/, "")} AI check`;
+  return fieldName === "reason" ? `${label} reason` : label;
+}
+function fieldTitle(path, ctx) {
+  if (path.startsWith("ai.")) return describeAiRef(path);
+  if (path.startsWith("ext.")) return describeExtRef(path, false);
+  if (path.startsWith("~")) return "a calculated value";
+  const field = ctx.fields.get(path);
+  if (field) return field.title;
+  const rowPath = path.replace("[*]", "");
+  return ctx.fields.get(rowPath)?.title ?? path.replace(/^\$/, "");
+}
+function choiceText(value, field) {
+  const match = field?.choices?.find((choice) => choice.value === value);
+  return match ? match.text : String(value);
+}
+function valueText(value, field, ctx) {
+  if (value === void 0 || value === null) return "\u2026";
+  if (Array.isArray(value)) return value.map((entry) => valueText(entry, field, ctx)).join(", ") || "\u2026";
+  if (typeof value === "object" && "@value" in value) return String(value["@value"]);
+  if (typeof value === "object") return JSON.stringify(value);
+  if (typeof value === "string") {
+    if (value.startsWith("$")) return `the answer to \u201C${fieldTitle(value, ctx)}\u201D`;
+    if (value.startsWith("ext.")) return describeExtRef(value, true);
+    if (value in CTX_LABEL) return CTX_LABEL[value];
+    if (value.startsWith("~")) return fieldTitle(value, ctx);
+  }
+  return choiceText(value, field);
+}
+function describeValue(op, value, field, ctx) {
+  if (takesNoValue(op)) return "";
+  if (op === "mediaTypeIn") {
+    const globs = Array.isArray(value) ? value : [];
+    return globs.map((glob) => MEDIA_TYPES.find((m) => m.value === glob)?.label ?? String(glob)).join(" or ") || "\u2026";
+  }
+  if (op === "between" || op === "lengthBetween" || op === "countBetween") {
+    const pair = Array.isArray(value) ? value : [];
+    return `${valueText(pair[0], field, ctx)} and ${valueText(pair[1], field, ctx)}`;
+  }
+  if (op === "withinRadius") {
+    const spec = value ?? {};
+    return `${valueText(spec.center, field, ctx)}, within ${String(spec.meters ?? "\u2026")} m`;
+  }
+  return valueText(value, field, ctx);
+}
+function describeCondition(cond, ctx, rowOf) {
+  if (!cond) return "nothing to check";
+  if ("forEach" in cond && typeof cond.forEach === "string") {
+    const inner = cond.every ?? cond.some;
+    const lead = cond.every ? "every row" : "at least one row";
+    return `${lead} of \u201C${fieldTitle(cond.forEach, ctx)}\u201D: ${describeCondition(inner, ctx, cond.forEach)}`;
+  }
+  if ("all" in cond && Array.isArray(cond.all)) return cond.all.map((member) => describeCondition(member, ctx, rowOf)).join(", and ");
+  if ("any" in cond && Array.isArray(cond.any)) return cond.any.map((member) => describeCondition(member, ctx, rowOf)).join(", or ");
+  if ("not" in cond) return `it is not the case that ${describeCondition(cond.not, ctx, rowOf)}`;
+  if ("atLeast" in cond && Array.isArray(cond.of)) return `at least ${cond.atLeast} of: ${cond.of.map((member) => describeCondition(member, ctx, rowOf)).join("; ")}`;
+  if (!("field" in cond)) return "nothing to check";
+  const path = cond.field.startsWith(".") && rowOf ? `${rowOf}[*]${cond.field}` : cond.field;
+  const field = ctx.fields.get(path);
+  const phrase = OPERATOR_PHRASE[cond.op];
+  if (!phrase) return `\u201C${fieldTitle(path, ctx)}\u201D has a check we no longer recognise`;
+  const value = describeValue(cond.op, cond.value, field, ctx);
+  const tolerance = cond.op === "approx" && typeof cond.tolerance === "number" ? `(give or take ${cond.tolerance})` : "";
+  return [`\u201C${fieldTitle(path, ctx)}\u201D`, phrase.label, value, phrase.suffix, tolerance].filter(Boolean).join(" ");
+}
+function describeReviewTask(rule, ctx) {
+  const task = rule.task;
+  if (!task) return `a person checks \u201C${fieldTitle(rule.fieldPath, ctx)}\u201D \u2014 but there is no question to ask them yet`;
+  const outcomes = Object.entries(task.map ?? {}).map(([answer, verdict]) => `${answerLabel(answer)} \u2192 ${VERDICT_LABEL[verdict]}`);
+  const score = rule.criterion.score;
+  const missing = score?.["@type"] === "ManualScore" ? ` If nothing was attached, nobody is asked and the check ${score.whenMissing === FAILED ? "fails" : "passes"}.` : "";
+  return `A person answers: \u201C${task.prompt}\u201D  ${outcomes.join(" \xB7 ")}${missing}`;
+}
+var VERDICT_LABEL = {
+  approve: "approve",
+  partial: "part-approve",
+  reject: "reject"
+};
+function answerLabel(answer) {
+  if (answer === "true") return "Yes";
+  if (answer === "false") return "No";
+  return answer;
+}
+function appliesWhenLead(cond, ctx) {
+  return cond ? `If ${describeCondition(cond, ctx)} \u2014 ` : "";
+}
+function describeRule(rule, ctx) {
+  switch (rule.consequence) {
+    case "reject": {
+      if (rule.bands) {
+        return `${appliesWhenLead(rule.gate.appliesWhen, ctx)}${describeScoreBands(rule.fieldPath, rule.bands, ctx)}`;
+      }
+      if (rule.grown?.editable) {
+        return describeGrown({ members: rule.grown.members, onFail: rule.gate.onFail, reason: rule.gate.reason, appliesWhen: rule.gate.appliesWhen }, ctx);
+      }
+      const check = describeCondition(rule.gate.when, ctx);
+      const outcome = rule.gate.onFail === "review" ? "else a person checks it" : `else reject: \u201C${rule.gate.reason}\u201D`;
+      return `${appliesWhenLead(rule.gate.appliesWhen, ctx)}${check} \u2014 ${outcome}`;
+    }
+    case "human":
+      return `${appliesWhenLead(rule.criterion.appliesWhen, ctx)}${describeReviewTask(rule, ctx)}`;
+    default:
+      return "";
+  }
+}
+var EXT_ANSWER_TYPE_LABEL = "What does it answer?";
+var EXT_ANSWERS_BOOLEAN_LABEL = "Yes or no";
+var EXT_ANSWERS_SCORE_LABEL = "A score out of 100";
+var SCORE_HOLD_REASON = "The check\u2019s score is in the middle band \u2014 a person decides";
+var SCORE_FLOOR_REASON = "The check\u2019s score is too low";
+var SCORE_MESSAGE_LABEL = "What should the claimant be told when the score is too low?";
+function describeScoreBands(fieldPath, bands, ctx) {
+  const question = `\u201C${fieldTitle(fieldPath, ctx)}\u201D`;
+  const approveAt = Math.round(bands.approveAt / 100);
+  const rejectBelow = Math.round(bands.rejectBelow / 100);
+  if (rejectBelow <= 0) {
+    return `The outside service scores ${question} out of 100 \u2014 below ${approveAt} a person checks it; at ${approveAt} or more it passes`;
+  }
+  return `The outside service scores ${question} out of 100 \u2014 below ${rejectBelow} the claim is turned down; from ${rejectBelow} to ${approveAt - 1} a person checks it; at ${approveAt} or more it passes`;
+}
+var GROW_RULE_LABEL = "Add another check to this rule";
+var GROWN_CHECKS_LABEL = "The checks";
+var LINKED_ADD_LABEL = "Depends on another answer";
+var AI_CHECK_LANE_LABEL = "AI checks it";
+var GROUP_AI_MEMBER_LEAD = "The AI checks";
+var LINKED_AI_ROW_LEAD = "the AI checks:";
+var LINKED_AI_ELSE_LEAD = "For anyone else, the AI checks:";
+var LINKED_AI_PLACEHOLDER = "e.g. The invoice must show a salary of 3000";
+var LINKED_MISSING_AI_TEXT = "Every case needs what the AI should check, written in plain words.";
+var AI_SEES_LABEL = "What can the AI see?";
+var AI_SEES_PLACEHOLDER = "Add other answers the AI should see";
+function aiSeesHint(questionTitle) {
+  return `The answer it checks \u2014 \u201C${questionTitle}\u201D \u2014 is always sent. Add any other answers the AI should read; photos and files are sent as the files themselves.`;
+}
+var AI_SETTING_HINT = "Needs \u201CAI checks\u201D switched on for this collection in the Evaluation Engine block \u2014 without it these rules can\u2019t run and claims wait for a person.";
+var GROUP_OUTSIDE_BUILDER_TEXT = "This rule was written outside the builder. It is applied exactly as written \u2014 the advanced view below shows it in full.";
+var LINKED_DUPLICATE_CASE_TEXT = "Two of your cases are about the same value \u2014 every case must be different.";
+var LINKED_MISSING_CASE_TEXT = "Every case needs a value to check against.";
+function describeGrown(rule, ctx) {
+  const lead = rule.members.map((member) => describeGroupMember(member, ctx)).join(", and ");
+  const outcome = rule.onFail === "review" ? "otherwise a person checks it" : `otherwise reject: \u201C${rule.reason}\u201D`;
+  return `${appliesWhenLead(rule.appliesWhen, ctx)}${lead} \u2014 ${outcome}`;
+}
+function linkedCaseText(guardField, guardValue, ctx) {
+  return `when \u201C${fieldTitle(guardField, ctx)}\u201D is \u201C${describeValue("==", guardValue, ctx.fields.get(guardField), ctx)}\u201D`;
+}
+function linkedElseText() {
+  return "for anyone else";
+}
+function linkedSentenceOf(entry) {
+  return {
+    checkedField: entry.checkedField,
+    op: entry.op,
+    guardField: entry.guardField,
+    cases: entry.cases.map((c) => ({ guardValue: c.guardValue, value: c.when.value, instructions: c.instructions })),
+    elseValue: entry.elseCase.when.value,
+    ...entry.ai ? { ai: true, elseInstructions: entry.elseCase.instructions } : {}
+  };
+}
+function describeLinked(linked, ctx) {
+  const guard = ctx.fields.get(linked.guardField);
+  if (linked.ai) {
+    const rules = (instructions) => `\u201C${(instructions ?? "").trim() || "\u2026"}\u201D`;
+    const parts2 = linked.cases.map((entry, at) => {
+      const guardText = `\u201C${describeValue("==", entry.guardValue, guard, ctx)}\u201D`;
+      return at === 0 ? `If \u201C${fieldTitle(linked.guardField, ctx)}\u201D is ${guardText}, the AI checks \u201C${fieldTitle(linked.checkedField, ctx)}\u201D: ${rules(entry.instructions)}.` : `If it is ${guardText}: ${rules(entry.instructions)}.`;
+    });
+    parts2.push(`For anyone else: ${rules(linked.elseInstructions)}.`);
+    return parts2.join(" ");
+  }
+  const phrase = OPERATOR_PHRASE[linked.op];
+  const checked = ctx.fields.get(linked.checkedField);
+  const check = (value) => [phrase.label, describeValue(linked.op, value, checked, ctx), phrase.suffix].filter(Boolean).join(" ");
+  const parts = linked.cases.map((entry, at) => {
+    const guardText = `\u201C${describeValue("==", entry.guardValue, guard, ctx)}\u201D`;
+    return at === 0 ? `If \u201C${fieldTitle(linked.guardField, ctx)}\u201D is ${guardText}, \u201C${fieldTitle(linked.checkedField, ctx)}\u201D ${check(entry.value)}.` : `If it is ${guardText}, it ${check(entry.value)}.`;
+  });
+  parts.push(`For anyone else it ${check(linked.elseValue)}.`);
+  return parts.join(" ");
+}
+function describeGroupMember(member, ctx) {
+  const name = aiMemberName(member);
+  const check = name ? ctx.aiChecks?.find((entry) => entry.name === name) : void 0;
+  if (check) {
+    const anchor = Object.values(check.send).find((value) => typeof value === "string" && value.startsWith("$"));
+    const rules = check.instructions.filter((rule) => rule.trim().length > 0).join("; ");
+    return anchor ? `the AI checks \u201C${fieldTitle(anchor, ctx)}\u201D: \u201C${rules}\u201D` : `the AI checks it: \u201C${rules}\u201D`;
+  }
+  return describeCondition(toCondition(member), ctx);
+}
+var POLICY_TAB_LABEL = {
+  all: "All of them",
+  any: "Any of them",
+  atLeast: "At least\u2026"
+};
+var POLICY_PIN_LABEL = "Must always pass";
+var POLICY_DEFAULT_REASON = "Not enough of the checks passed";
+var POLICY_EMPTY_TALLY_TEXT = "Tick the rules that should count \u2014 until then, every check must still pass.";
+var POLICY_NO_RULES_TEXT = "No rules yet \u2014 add a rule to a question above, then choose how many must pass.";
+var POLICY_OUTSIDE_BUILDER_TEXT = "The approval rule was written outside the builder. It is applied exactly as written \u2014 the advanced view below shows it in full.";
+function policyStepperText(selectedCount) {
+  return `of the ${plural(selectedCount, "selected rule")} must pass`;
+}
+function listOf(parts) {
+  if (parts.length <= 1) return parts[0] ?? "";
+  return `${parts.slice(0, -1).join(", ")} and ${parts[parts.length - 1]}`;
+}
+function describePolicyMember(member, ctx) {
+  const simple = toSimpleRule(member);
+  if (simple) return describeGroupMember(simple, ctx);
+  if ("all" in member && Array.isArray(member.all)) {
+    const parts = member.all.map((inner) => {
+      const innerSimple = toSimpleRule(inner);
+      return innerSimple ? describeGroupMember(innerSimple, ctx) : describeCondition(inner, ctx);
+    });
+    return parts.join(", and ");
+  }
+  return describeCondition(member, ctx);
+}
+function describePolicy(input) {
+  const { tab, pinned, restCount, n, reason } = input;
+  const outcome = `\u2014 otherwise reject: \u201C${reason}\u201D`;
+  const rules = plural(restCount, "rule");
+  if (pinned.length === 0) {
+    return tab === "any" ? `Any one of the ${rules} must pass ${outcome}` : `At least ${n} of the ${rules} must pass ${outcome}`;
+  }
+  const names = listOf(pinned.map((title) => `\u201C${title}\u201D`));
+  const beyond = pinned.length === 1 ? "Beyond that" : "Beyond those";
+  const rest = tab === "any" ? `any one of the other ${rules} must also pass` : `at least ${n - pinned.length} of the other ${rules} must also pass`;
+  return `${names} must always pass. ${beyond}, ${rest} ${outcome}`;
+}
+var UNIQUE_TITLE = "This claim must be unique";
+var UNIQUE_EXPLAINER = "Claims already in this collection are compared with each new one \u2014 exact copies, re-saved files and near-identical wording are caught. A claim that was rejected never blocks a fixed resubmission.";
+var UNIQUE_BY_LABEL = "Unique by\u2026";
+var UNIQUE_BY_PLACEHOLDER = "Pick the answers that identify a claim";
+var UNIQUE_BY_HINT = "Two claims matching on ALL of these count as the same claim. Leave empty to compare whole claims.";
+var UNIQUE_FILE_BADGE = "matched by file fingerprint";
+var UNIQUE_GRANULARITY_OPTIONS = [
+  { value: "exact", label: "exactly" },
+  { value: "day", label: "on the same day" },
+  { value: "month", label: "in the same month" },
+  { value: "year", label: "in the same year" }
+];
+function uniqueGranularityLead(title) {
+  return `Dates in \u201C${title}\u201D match`;
+}
+var UNIQUE_AI_LABEL = "Use AI to catch reworded duplicates";
+var UNIQUE_AI_ON_HINT = "Similar-looking claims are checked by AI; matches go to human review.";
+var UNIQUE_AI_OFF_WARNING = "Without AI checking, similar-looking claims pass with only a recorded score.";
+var UNIQUE_PRICING_NOTE = "Duplicate screening \u2014 fingerprints, similarity and AI checks \u2014 is included in this collection\u2019s per-claim price.";
+var UNIQUE_REJECT_LABEL = "Auto-reject at";
+var UNIQUE_REVIEW_LABEL = "Send to review at";
+var FREQUENCY_TITLE = "Limit how often each person can claim";
+var FREQUENCY_EXPLAINER = "Counts how many claims each person has already sent this calendar period \u2014 however different their content. A claim that was rejected never uses up a turn, so a fixed resubmission always fits.";
+var FREQUENCY_MAX_LEAD = "At most";
+function frequencyMaxNoun(max) {
+  return max === 1 ? "claim" : "claims";
+}
+var FREQUENCY_PERIOD_ARIA = "The period the limit counts over";
+var FREQUENCY_PERIOD_OPTIONS = [
+  { value: "day", label: "per day" },
+  { value: "week", label: "per week" },
+  { value: "month", label: "per month" },
+  { value: "year", label: "per year" }
+];
+var FREQUENCY_BREACH_LABEL = "When someone goes over the limit";
+var FREQUENCY_BREACH_OPTIONS = [
+  { value: "review", label: "A person checks" },
+  { value: "reject", label: "Reject the claim" }
+];
+var FREQUENCY_BREACH_REVIEW_HINT = "A claim over the limit is sent to a person to look at \u2014 nothing is turned down automatically.";
+function plural(count, noun) {
+  return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+function describeTally(rules, extra) {
+  const parts = [
+    plural(rules.filter((r) => r.consequence === "reject").length + (extra?.policyMembers ?? 0), "reject rule"),
+    plural(rules.filter((r) => r.consequence === "human").length, "human check")
+  ];
+  if (extra?.linked) parts.push(plural(extra.linked, "linked rule"));
+  return parts.join(" \xB7 ");
+}
+function describeApproval(checkCount) {
+  if (checkCount === 0) return "When every check passes. No checks yet \u2014 add a rule to a question above.";
+  if (checkCount === 1) return "When the one check passes.";
+  return `When all ${checkCount} checks pass.`;
+}
+
+// src/mantine/blocks/action/actionTypes/evalRubric/policyModel.ts
+function clampPolicyN(n, pinnedSelected, selectedCount) {
+  const min = pinnedSelected + 1;
+  const max = Math.max(selectedCount, min);
+  return Math.min(Math.max(Math.round(n) || min, min), max);
+}
+function foldableRule(rule) {
+  if (rule.gate.appliesWhen) return false;
+  if ((rule.gate.onFail ?? "reject") !== "reject") return false;
+  if (rule.grown && !rule.grown.editable) return false;
+  return policyMemberRenderable(rule.gate.when);
+}
+function derivePolicy(body) {
+  const shape = policyShapeOf(body);
+  if (shape.kind === "foreign") return { base: body, foreign: true, tab: "all", rows: [], n: 1, reason: "" };
+  const rejects = listRules(body).filter((rule) => rule.consequence === "reject");
+  if (shape.kind === "none") {
+    const rows = rejects.map((rule) => {
+      const locked = !foldableRule(rule);
+      return { key: rule.code, rule, locked, selected: true, pinned: locked };
+    });
+    const pinned = rows.filter((row) => row.pinned).length;
+    return { base: body, foreign: false, tab: "all", rows, n: pinned + 1, reason: "" };
+  }
+  const memberRows = shape.members.map((member, at) => ({ key: `member-${at}`, member, locked: false, selected: true, pinned: false }));
+  const gateRows = rejects.map((rule) => ({ key: rule.code, rule, locked: !foldableRule(rule), selected: true, pinned: true }));
+  return {
+    base: body,
+    foreign: false,
+    tab: shape.tab,
+    rows: [...memberRows, ...gateRows],
+    n: (shape.nRest ?? 1) + gateRows.length,
+    reason: shape.gate.reason,
+    gate: shape.gate,
+    gateAt: shape.index
+  };
+}
+function compilePolicy(state) {
+  if (state.foreign) return state.base;
+  const baseGates = state.base.gates ?? [];
+  const folded = state.tab === "all" ? [] : state.rows.filter((row) => row.selected && !row.pinned && !row.locked);
+  const members = folded.map((row) => row.rule ? row.rule.gate.when : row.member);
+  const foldedIndexes = new Set(folded.flatMap((row) => row.rule ? [row.rule.index] : []));
+  const pinnedSelected = state.rows.filter((row) => row.selected && row.pinned).length;
+  const nRest = Math.min(Math.max(state.n - pinnedSelected, 1), Math.max(members.length, 1));
+  const reason = state.reason.trim() || POLICY_DEFAULT_REASON;
+  const minted = [];
+  const extractedGates = state.rows.filter((row) => row.member && !folded.includes(row)).map((row) => {
+    const code = nextCode(state.base, "RULE", primaryFieldOf(row.member), minted);
+    minted.push(code);
+    return { "@type": "Gate", code, reason: state.gate?.reason ?? reason, when: row.member, onFail: "reject", class: state.gate?.class ?? "insufficient_evidence" };
+  });
+  let policyGate;
+  if (state.tab !== "all" && members.length > 0) {
+    const when = state.tab === "any" ? { "@type": "Condition", any: members } : { "@type": "Condition", atLeast: nRest, of: members };
+    const old = state.gate;
+    policyGate = old && old.reason === reason && JSON.stringify(old.when) === JSON.stringify(when) ? old : {
+      "@type": "Gate",
+      code: old?.code ?? nextCode(state.base, "RULE", "approval", minted),
+      reason,
+      ...old?.appliesWhen ? { appliesWhen: old.appliesWhen } : {},
+      when,
+      onFail: old?.onFail ?? "reject",
+      class: old?.class ?? "insufficient_evidence"
+    };
+  }
+  const gates = [];
+  baseGates.forEach((gate, at) => {
+    if (at === state.gateAt) {
+      if (policyGate) gates.push(policyGate);
+      return;
+    }
+    if (foldedIndexes.has(at)) return;
+    gates.push(gate);
+  });
+  gates.push(...extractedGates);
+  if (policyGate && state.gateAt === void 0) gates.push(policyGate);
+  return { ...state.base, gates };
+}
+
+// src/mantine/blocks/action/actionTypes/evalRubric/rubricStyles.tsx
+import React2 from "react";
+var ACCENT = "var(--mantine-color-accent-5)";
+var ACCENT_SOFT = `color-mix(in srgb, ${ACCENT} 10%, transparent)`;
+var INK = "var(--mantine-color-text)";
+var SLATE = "var(--mantine-color-dimmed)";
+var HAIRLINE = "var(--mantine-color-neutralColor-4)";
+var SURFACE = "var(--mantine-color-body)";
+var PANEL_GROUND = "var(--mantine-color-neutralColor-1)";
+var SHADOW_TINT = "color-mix(in srgb, var(--mantine-color-black) 5%, transparent)";
+var cardStyle = {
+  background: SURFACE,
+  border: `1px solid ${HAIRLINE}`,
+  borderRadius: 12,
+  boxShadow: `0 1px 2px ${SHADOW_TINT}, 0 8px 28px ${SHADOW_TINT}`
+};
+var panelStyle = {
+  background: PANEL_GROUND,
+  border: `1px solid ${HAIRLINE}`,
+  borderRadius: 10
+};
+var microLabelStyle = {
+  fontSize: 11.5,
+  fontWeight: 600,
+  letterSpacing: "0.07em",
+  textTransform: "uppercase",
+  color: SLATE
+};
+var leadWordStyle = { fontSize: 14, fontWeight: 600, color: INK };
+var chipInput = {
+  wrapper: { "--input-bd": HAIRLINE, "--input-bg": SURFACE },
+  input: {
+    borderRadius: 8,
+    boxShadow: `0 1px 1px ${SHADOW_TINT}`,
+    fontSize: 14,
+    fontWeight: 500,
+    paddingInline: 12
+  }
+};
+function chipInputStyles(hasError) {
+  return hasError ? { input: chipInput.input } : chipInput;
+}
+var segmentedPill = {
+  root: {
+    background: SURFACE,
+    border: `1px solid ${HAIRLINE}`,
+    borderRadius: 999,
+    padding: 3,
+    "--sc-radius": "999px",
+    "--sc-color": ACCENT,
+    "--sc-label-color": "var(--mantine-color-white)"
+  },
+  label: { fontSize: 13.5, fontWeight: 500 }
+};
+var chipButton = {
+  root: {
+    fontWeight: 500,
+    boxShadow: `0 1px 1px ${SHADOW_TINT}`,
+    "--button-radius": "8px",
+    "--button-bd": `1px solid ${HAIRLINE}`,
+    "--button-bg": SURFACE,
+    "--button-color": INK,
+    "--button-hover": ACCENT_SOFT,
+    "--button-hover-color": INK
+  }
+};
+var quietButton = {
+  root: {
+    fontWeight: 500,
+    "--button-radius": "8px",
+    "--button-bg": "transparent",
+    "--button-color": SLATE,
+    "--button-hover": ACCENT_SOFT,
+    "--button-hover-color": INK
+  }
+};
+function consequencePillStyle(color) {
+  return {
+    display: "inline-flex",
+    alignItems: "center",
+    justifyContent: "center",
+    padding: 4,
+    borderRadius: 8,
+    color,
+    background: `color-mix(in srgb, ${color} 10%, transparent)`
+  };
+}
+var QUOTED = /(“[^”]*”)/g;
+var RuleSentence = ({ text }) => /* @__PURE__ */ React2.createElement(
+  "div",
+  {
+    style: {
+      borderLeft: `3px solid ${ACCENT}`,
+      background: ACCENT_SOFT,
+      borderRadius: "0 8px 8px 0",
+      padding: "8px 12px",
+      fontSize: 14,
+      fontStyle: "italic",
+      lineHeight: 1.55,
+      color: INK
+    }
+  },
+  text.split(QUOTED).map(
+    (part, at) => part.startsWith("\u201C") ? (
+      // Index keys are safe: the segments are a pure projection of `text`.
+      /* @__PURE__ */ React2.createElement("span", { key: `${part}${at}`, style: { fontStyle: "normal", fontWeight: 600 } }, part)
+    ) : /* @__PURE__ */ React2.createElement(React2.Fragment, { key: `${part}${at}` }, part)
+  )
+);
+
+// src/mantine/blocks/action/actionTypes/evalRubric/ApprovalPolicy.tsx
+var TABS = ["all", "any", "atLeast"];
+function rowTitle(row, ctx) {
+  return fieldTitle(row.rule ? row.rule.fieldPath : primaryFieldOf(row.member), ctx);
+}
+function rowSentence(row, ctx) {
+  if (row.rule) return describeRule(row.rule, ctx);
+  return row.member ? describePolicyMember(row.member, ctx) : "";
+}
+function pinChipStyles(active) {
+  return { root: { ...quietButton.root, ...active ? { "--button-bg": ACCENT_SOFT, "--button-color": INK } : {} } };
+}
+var ApprovalPolicy = ({ body, index, checkCount, onChange, disabled }) => {
+  const [state, setState] = useState(() => derivePolicy(body));
+  const lastWrittenRef = useRef(null);
+  const bodyJson = JSON.stringify(body);
+  useEffect(() => {
+    if (bodyJson === lastWrittenRef.current) return;
+    setState(derivePolicy(body));
+  }, [bodyJson]);
+  const commit = (next) => {
+    setState(next);
+    const compiled = compilePolicy(next);
+    const json = JSON.stringify(compiled);
+    lastWrittenRef.current = json;
+    if (json !== bodyJson) onChange(compiled);
+  };
+  const selectedCount = state.rows.filter((row) => row.selected).length;
+  const pinnedSelected = state.rows.filter((row) => row.selected && row.pinned).length;
+  const restCount = state.rows.filter((row) => row.selected && !row.pinned && !row.locked).length;
+  const patchRow = (key, patch) => {
+    const rows = state.rows.map((row) => row.key === key ? { ...row, ...patch } : row);
+    const pinned = rows.filter((row) => row.selected && row.pinned).length;
+    const selected = rows.filter((row) => row.selected).length;
+    commit({ ...state, rows, n: clampPolicyN(state.n, pinned, selected) });
+  };
+  const pickTab = (tab) => commit({ ...state, tab, n: clampPolicyN(state.n, pinnedSelected, selectedCount) });
+  const setN = (n) => commit({ ...state, n: clampPolicyN(n, pinnedSelected, selectedCount) });
+  const setReason = (reason) => commit({ ...state, reason });
+  const ctx = { fields: index, aiChecks: body.aiChecks };
+  const pinnedTitles = state.rows.filter((row) => row.selected && row.pinned).map((row) => rowTitle(row, ctx));
+  const sentence = state.tab === "all" ? describeApproval(checkCount) : restCount === 0 ? "" : describePolicy({ tab: state.tab, pinned: pinnedTitles, restCount, n: state.n, reason: state.reason.trim() || POLICY_DEFAULT_REASON });
+  return /* @__PURE__ */ React3.createElement(Paper, { p: 18, style: cardStyle }, /* @__PURE__ */ React3.createElement(Stack2, { gap: "sm" }, /* @__PURE__ */ React3.createElement(Group2, { gap: "sm", justify: "space-between", align: "center", wrap: "wrap" }, /* @__PURE__ */ React3.createElement(Text, { size: "sm", fw: 600 }, "When is a claim approved?"), /* @__PURE__ */ React3.createElement(
+    SegmentedControl,
+    {
+      styles: segmentedPill,
+      value: state.foreign ? "" : state.tab,
+      onChange: (tab) => pickTab(tab),
+      disabled: disabled || state.foreign,
+      data: TABS.map((tab) => ({ value: tab, label: POLICY_TAB_LABEL[tab] }))
+    }
+  )), state.foreign ? (
+    // Hand-authored territory the tabs cannot edit — applied as written,
+    // shown read-only; the stray gates stay deletable on their cards.
+    /* @__PURE__ */ React3.createElement(Text, { size: "xs", c: "dimmed" }, POLICY_OUTSIDE_BUILDER_TEXT)
+  ) : state.tab === "all" ? /* @__PURE__ */ React3.createElement(RuleSentence, { text: sentence }) : /* @__PURE__ */ React3.createElement(Stack2, { gap: "xs" }, state.rows.length === 0 ? /* @__PURE__ */ React3.createElement(Text, { size: "xs", c: "dimmed" }, POLICY_NO_RULES_TEXT) : state.rows.map((row) => /* @__PURE__ */ React3.createElement(Group2, { key: row.key, gap: "sm", align: "flex-start", wrap: "nowrap" }, /* @__PURE__ */ React3.createElement(
+    Checkbox,
+    {
+      size: "xs",
+      mt: 8,
+      checked: row.selected,
+      disabled: disabled || row.locked,
+      onChange: (event) => patchRow(row.key, { selected: event.currentTarget.checked }),
+      "aria-label": `Count the rule on ${rowTitle(row, ctx)} towards approval`
+    }
+  ), /* @__PURE__ */ React3.createElement(Box, { style: { flex: 1 } }, row.rule?.grown && !row.rule.grown.editable ? /* @__PURE__ */ React3.createElement(Text, { size: "xs", c: "dimmed" }, GROUP_OUTSIDE_BUILDER_TEXT) : /* @__PURE__ */ React3.createElement(RuleSentence, { text: rowSentence(row, ctx) })), row.selected && /* @__PURE__ */ React3.createElement(
+    Button2,
+    {
+      size: "compact-xs",
+      variant: "subtle",
+      styles: pinChipStyles(row.pinned),
+      leftSection: icon(IconPin, 12, row.pinned ? ACCENT : void 0),
+      onClick: () => patchRow(row.key, { pinned: !row.pinned }),
+      disabled: disabled || row.locked
+    },
+    POLICY_PIN_LABEL
+  ))), state.tab === "atLeast" && state.rows.length > 0 && /* @__PURE__ */ React3.createElement(Group2, { gap: 8, align: "center", wrap: "nowrap" }, /* @__PURE__ */ React3.createElement(
+    BaseNumberInput,
+    {
+      w: 80,
+      styles: chipInput,
+      min: pinnedSelected + 1,
+      max: Math.max(selectedCount, pinnedSelected + 1),
+      value: state.n,
+      onChange: (next) => setN(typeof next === "number" ? next : pinnedSelected + 1),
+      disabled
+    }
+  ), /* @__PURE__ */ React3.createElement(Text, { size: "sm", c: "dimmed" }, policyStepperText(selectedCount))), state.rows.length > 0 && /* @__PURE__ */ React3.createElement(
+    BaseTextInput,
+    {
+      label: "What should the claimant be told?",
+      styles: chipInput,
+      placeholder: POLICY_DEFAULT_REASON,
+      description: "They will read this when too few of the rules pass.",
+      value: state.reason,
+      onChange: (event) => setReason(event.currentTarget.value),
+      disabled
+    }
+  ), sentence ? /* @__PURE__ */ React3.createElement(RuleSentence, { text: sentence }) : state.rows.length > 0 && /* @__PURE__ */ React3.createElement(Text, { size: "xs", c: "dimmed" }, POLICY_EMPTY_TALLY_TEXT))));
+};
+
+// src/mantine/blocks/action/actionTypes/evalRubric/LinkedRuleEditor.tsx
+import React5, { useMemo as useMemo2, useState as useState2 } from "react";
+import { ActionIcon, Alert, Button as Button3, Group as Group4, Modal, Paper as Paper2, ScrollArea as ScrollArea2, Stack as Stack4, Text as Text3 } from "@mantine/core";
+import { IconAlertTriangle, IconPlus, IconRobot, IconTrash } from "@tabler/icons-react";
+
+// src/mantine/blocks/action/actionTypes/evalRubric/ValueInput.tsx
+import React4, { useMemo } from "react";
+import { Group as Group3, SegmentedControl as SegmentedControl2, Stack as Stack3, TagsInput, Text as Text2 } from "@mantine/core";
+import { DateTimePicker } from "@mantine/dates";
+var CTX_DATES = ["ctx.now", "ctx.collection.startDate", "ctx.collection.endDate", "ctx.claim.submissionDate"];
+var ValueInput = ({ op, field, index, value, tolerance, onChange, disabled }) => {
+  const kind = field?.kind ?? "text";
+  const setValue = (next) => onChange({ value: next });
+  const refOptions = useMemo(() => {
+    const needed = comparableKind(op, kind);
+    const options = [...index.values()].filter((entry) => entry.kind === needed && entry.path !== field?.path && !entry.path.includes("[*]")).map((entry) => ({ value: entry.path, label: entry.title }));
+    if (needed === "date") options.push(...CTX_DATES.map((token) => ({ value: token, label: CTX_LABEL[token] })));
+    return options;
+  }, [index, op, kind, field?.path]);
+  if (takesNoValue(op)) return null;
+  switch (op) {
+    case "between":
+      return /* @__PURE__ */ React4.createElement(PairInput, { kind: kind === "date" ? "date" : "number", value, onChange: setValue, disabled, labels: ["from", "to"] });
+    case "lengthBetween":
+      return /* @__PURE__ */ React4.createElement(PairInput, { kind: "number", value, onChange: setValue, disabled, labels: ["at least", "at most"] });
+    case "countBetween":
+      return /* @__PURE__ */ React4.createElement(PairInput, { kind: "number", value, onChange: setValue, disabled, labels: ["at least", "at most"] });
+    case "withinDays":
+    case "maxSizeMB":
+      return /* @__PURE__ */ React4.createElement(BaseNumberInput, { w: 140, styles: chipInput, min: 0, value: typeof value === "number" ? value : "", onChange: (next) => setValue(toNumber(next)), disabled });
+    case "approx":
+      return /* @__PURE__ */ React4.createElement(Group3, { gap: "xs", wrap: "nowrap" }, /* @__PURE__ */ React4.createElement(LiteralOrRef, { kind: "number", field, index, refOptions, value, onChange: setValue, disabled }), /* @__PURE__ */ React4.createElement(Text2, { size: "xs", c: "dimmed", fw: 500 }, "give or take"), /* @__PURE__ */ React4.createElement(
+        BaseNumberInput,
+        {
+          w: 100,
+          styles: chipInput,
+          min: 0,
+          value: typeof tolerance === "number" ? tolerance : "",
+          onChange: (next) => onChange({ tolerance: toNumber(next) ?? 0 }),
+          disabled
+        }
+      ));
+    case "in":
+    case "notIn":
+    case "containsAll":
+    case "containsAny":
+    case "subsetOf":
+      return /* @__PURE__ */ React4.createElement(ListInput, { field, value, onChange: setValue, disabled });
+    case "contains":
+      return /* @__PURE__ */ React4.createElement(LiteralOrRef, { kind: kind === "multichoice" ? "choice" : kind, field, index, refOptions: [], value, onChange: setValue, disabled });
+    case "mediaTypeIn":
+      return /* @__PURE__ */ React4.createElement(
+        BaseMultiSelect,
+        {
+          w: 280,
+          styles: chipInput,
+          placeholder: "Pick the file types you accept",
+          data: MEDIA_TYPES.map((type) => ({ value: type.value, label: type.label })),
+          value: Array.isArray(value) ? value.map(String) : [],
+          onChange: (next) => setValue(next),
+          disabled
+        }
+      );
+    case "matches":
+      return /* @__PURE__ */ React4.createElement(
+        BaseTextInput,
+        {
+          w: 260,
+          styles: chipInput,
+          placeholder: "e.g. ^INV-[0-9]{6}$",
+          description: "A simple pattern the answer has to match.",
+          value: typeof value === "string" ? value : "",
+          onChange: (event) => setValue(event.currentTarget.value),
+          disabled
+        }
+      );
+    case "withinRadius": {
+      const spec = value ?? {};
+      return /* @__PURE__ */ React4.createElement(Group3, { gap: "xs", wrap: "nowrap" }, /* @__PURE__ */ React4.createElement(
+        BaseSelect,
+        {
+          w: 200,
+          styles: chipInput,
+          placeholder: "Near which answer?",
+          data: refOptions,
+          value: typeof spec.center === "string" ? spec.center : null,
+          onChange: (next) => setValue({ ...spec, center: next || void 0 }),
+          disabled
+        }
+      ), /* @__PURE__ */ React4.createElement(
+        BaseNumberInput,
+        {
+          w: 120,
+          styles: chipInput,
+          min: 1,
+          suffix: " m",
+          value: typeof spec.meters === "number" ? spec.meters : "",
+          onChange: (next) => setValue({ ...spec, meters: toNumber(next) }),
+          disabled
+        }
+      ));
+    }
+    case "startsWith":
+    case "endsWith":
+      return /* @__PURE__ */ React4.createElement(BaseTextInput, { w: 220, styles: chipInput, value: typeof value === "string" ? value : "", onChange: (event) => setValue(event.currentTarget.value), disabled });
+    default:
+      return /* @__PURE__ */ React4.createElement(LiteralOrRef, { kind: comparableKind(op, kind), field, index, refOptions, value, onChange: setValue, disabled });
+  }
+};
+function comparableKind(op, kind) {
+  if (op === "before" || op === "after") return "date";
+  if (op === ">" || op === ">=" || op === "<" || op === "<=" || op === "approx") return kind === "date" ? "date" : "number";
+  if (op === "withinRadius") return "geo";
+  return kind;
+}
+var LiteralOrRef = ({ kind, field, refOptions, value, onChange, disabled }) => {
+  const isRef = typeof value === "string" && (value.startsWith("$") || value.startsWith("ctx.") || value.startsWith("ext."));
+  const mode = isRef ? "ref" : "literal";
+  return /* @__PURE__ */ React4.createElement(Stack3, { gap: 6 }, refOptions.length > 0 && /* @__PURE__ */ React4.createElement(
+    SegmentedControl2,
+    {
+      size: "xs",
+      styles: segmentedPill,
+      value: mode,
+      onChange: (next) => onChange(next === "ref" ? refOptions[0]?.value : void 0),
+      data: [
+        { value: "literal", label: "A value" },
+        { value: "ref", label: "Another answer" }
+      ],
+      disabled
+    }
+  ), mode === "ref" ? /* @__PURE__ */ React4.createElement(
+    BaseSelect,
+    {
+      w: 240,
+      styles: chipInput,
+      placeholder: "Which answer?",
+      data: refOptions,
+      value: typeof value === "string" ? value : null,
+      onChange: (next) => onChange(next || void 0),
+      disabled,
+      searchable: true
+    }
+  ) : /* @__PURE__ */ React4.createElement(LiteralInput, { kind, field, value, onChange, disabled }));
+};
+var LiteralInput = ({
+  kind,
+  field,
+  value,
+  onChange,
+  disabled
+}) => {
+  switch (kind) {
+    case "number":
+      return /* @__PURE__ */ React4.createElement(
+        BaseNumberInput,
+        {
+          w: 160,
+          styles: chipInput,
+          placeholder: "0",
+          value: typeof value === "number" ? value : "",
+          onChange: (next) => onChange(toNumber(next)),
+          disabled
+        }
+      );
+    case "date":
+      return /* @__PURE__ */ React4.createElement(
+        DateTimePicker,
+        {
+          w: 240,
+          styles: chipInput,
+          placeholder: "Pick a date",
+          valueFormat: "DD MMM YYYY, HH:mm",
+          clearable: true,
+          value: isoToDate(value),
+          onChange: (next) => onChange(dateToIso(next)),
+          disabled
+        }
+      );
+    case "boolean":
+      return /* @__PURE__ */ React4.createElement(
+        BaseSelect,
+        {
+          w: 140,
+          styles: chipInput,
+          data: [
+            { value: "true", label: "Yes" },
+            { value: "false", label: "No" }
+          ],
+          value: typeof value === "boolean" ? String(value) : null,
+          onChange: (next) => onChange(next === null ? void 0 : next === "true"),
+          disabled
+        }
+      );
+    case "choice":
+    case "multichoice":
+      if (field?.choices?.length) {
+        return /* @__PURE__ */ React4.createElement(
+          BaseSelect,
+          {
+            w: 240,
+            styles: chipInput,
+            placeholder: "Pick an option",
+            data: field.choices.map((choice) => ({ value: choice.value, label: choice.text })),
+            value: typeof value === "string" ? value : null,
+            onChange: (next) => onChange(next ?? void 0),
+            disabled,
+            searchable: true
+          }
+        );
+      }
+      return /* @__PURE__ */ React4.createElement(BaseTextInput, { w: 240, styles: chipInput, value: typeof value === "string" ? value : "", onChange: (event) => onChange(event.currentTarget.value), disabled });
+    default:
+      return /* @__PURE__ */ React4.createElement(
+        BaseTextInput,
+        {
+          w: 240,
+          styles: chipInput,
+          placeholder: "Type the value",
+          value: typeof value === "string" ? value : "",
+          onChange: (event) => onChange(event.currentTarget.value),
+          disabled
+        }
+      );
+  }
+};
+var ListInput = ({ field, value, onChange, disabled }) => {
+  const current = Array.isArray(value) ? value.map(String) : [];
+  if (field?.choices?.length) {
+    return /* @__PURE__ */ React4.createElement(
+      BaseMultiSelect,
+      {
+        w: 300,
+        styles: chipInput,
+        placeholder: "Pick the options you allow",
+        data: field.choices.map((choice) => ({ value: choice.value, label: choice.text })),
+        value: current,
+        onChange: (next) => onChange(next),
+        disabled,
+        searchable: true
+      }
+    );
+  }
+  const numeric = field?.kind === "number";
+  return /* @__PURE__ */ React4.createElement(
+    TagsInput,
+    {
+      w: 300,
+      styles: chipInput,
+      placeholder: "Type a value, press Enter",
+      value: current,
+      onChange: (next) => onChange(numeric ? next.map(Number).filter((entry) => !Number.isNaN(entry)) : next),
+      disabled
+    }
+  );
+};
+var PairInput = ({
+  kind,
+  value,
+  onChange,
+  disabled,
+  labels
+}) => {
+  const pair = Array.isArray(value) ? value : [void 0, void 0];
+  const setAt = (at, next) => {
+    const updated = [pair[0], pair[1]];
+    updated[at] = next;
+    onChange(updated);
+  };
+  return /* @__PURE__ */ React4.createElement(Group3, { gap: "xs", wrap: "nowrap", align: "flex-end" }, [0, 1].map((at) => /* @__PURE__ */ React4.createElement(Stack3, { key: at, gap: 2 }, /* @__PURE__ */ React4.createElement(Text2, { size: "xs", c: "dimmed", fw: 500 }, labels[at]), kind === "date" ? /* @__PURE__ */ React4.createElement(
+    DateTimePicker,
+    {
+      w: 190,
+      styles: chipInput,
+      valueFormat: "DD MMM YYYY, HH:mm",
+      clearable: true,
+      value: isoToDate(pair[at]),
+      onChange: (next) => setAt(at, dateToIso(next)),
+      disabled
+    }
+  ) : /* @__PURE__ */ React4.createElement(
+    BaseNumberInput,
+    {
+      w: 110,
+      styles: chipInput,
+      value: typeof pair[at] === "number" ? pair[at] : "",
+      onChange: (next) => setAt(at, toNumber(next)),
+      disabled
+    }
+  ))));
+};
+function isoToDate(value) {
+  if (typeof value !== "string" || !value) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function dateToIso(value) {
+  if (!value) return void 0;
+  try {
+    return value.toISOString();
+  } catch {
+    return void 0;
+  }
+}
+function toNumber(value) {
+  if (value === "" || value === null || value === void 0) return void 0;
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+
+// src/mantine/blocks/action/actionTypes/evalRubric/ruleDraft.ts
+var SCORE_BANDS_DEFAULT = { rejectBelow: 30, approveAt: 80 };
+function clampBands(bands) {
+  const approveAt = Math.min(100, Math.max(1, Math.round(bands.approveAt)));
+  const rejectBelow = Math.min(approveAt - 1, Math.max(0, Math.round(bands.rejectBelow)));
+  return { rejectBelow, approveAt };
+}
+function extSubjectRef(ext) {
+  return `ext.${ext.name}.${ext.expect === "score" ? "score" : "valid"}`;
+}
+function sendKey(fieldPath) {
+  return fieldPath.replace(/^\$/, "").replace(/\[\*\]/g, "").replace(/[^A-Za-z0-9_-]+/g, "_").replace(/_{2,}/g, "_").replace(/^[_-]+|[_-]+$/g, "") || "answer";
+}
+function autoExtName(sendField, sources) {
+  const base = `${sendKey(sendField)}_check`;
+  const taken = new Set((sources ?? []).map((source) => source.name));
+  if (!taken.has(base)) return base;
+  for (let n = 2; ; n++) {
+    const name = `${base}_${n}`;
+    if (!taken.has(name)) return name;
+  }
+}
+function extSourceFromDraft(ext) {
+  return { "@type": "ExternalSource", name: ext.name, endpoint: ext.endpoint, audience: ext.audience, send: { [sendKey(ext.sendField)]: ext.sendField }, expect: ext.expect };
+}
+function upsertExtSource(body, ext) {
+  const source = extSourceFromDraft(ext);
+  const sources = [...body.sources ?? []];
+  const at = sources.findIndex((entry) => entry.name === source.name);
+  if (at < 0) sources.push(source);
+  else sources[at] = source;
+  return { ...body, sources };
+}
+function withExtSubject(draft, ext) {
+  const ref = extSubjectRef(ext);
+  if (ext.expect === "score") {
+    const bands = clampBands(ext.bands ?? SCORE_BANDS_DEFAULT);
+    return {
+      ...draft,
+      ext: { ...ext, bands },
+      ai: void 0,
+      field: ref,
+      consequence: "reject",
+      reject: { ...draft.reject, when: { field: ref, op: ">=", value: bands.approveAt * 100 }, onFail: "review", verdictClass: "requires_human_review" }
+    };
+  }
+  if (draft.ext && draft.field === ref) return { ...draft, ext };
+  return {
+    ...draft,
+    ext,
+    field: ref,
+    consequence: "reject",
+    // Fresh lane entry, a rename, or a score flipped back to yes/no — the fixed
+    // check with the lane's default ending, never a leftover score ending.
+    reject: { ...draft.reject, when: { field: ref, op: "isTrue" }, onFail: "reject", verdictClass: "refuted" }
+  };
+}
+function aiSubjectRef(ai) {
+  return `ai.${ai.name}.valid`;
+}
+function autoAiName(sendField, aiChecks, alsoTaken = []) {
+  const base = `${sendKey(sendField)}_ai`;
+  const taken = /* @__PURE__ */ new Set([...(aiChecks ?? []).map((check) => check.name), ...alsoTaken]);
+  if (!taken.has(base)) return base;
+  for (let n = 2; ; n++) {
+    const name = `${base}_${n}`;
+    if (!taken.has(name)) return name;
+  }
+}
+function aiSendOf(sendField, alsoSend) {
+  const send = {};
+  const sent = /* @__PURE__ */ new Set();
+  for (const field of [sendField, ...alsoSend ?? []]) {
+    if (!field || sent.has(field)) continue;
+    sent.add(field);
+    const base = sendKey(field);
+    let key = base;
+    for (let n = 2; key in send; n++) key = `${base}_${n}`;
+    send[key] = field;
+  }
+  return send;
+}
+function aiCheckFromDraft(ai) {
+  return {
+    "@type": "AiCheck",
+    name: ai.name,
+    send: aiSendOf(ai.sendField, ai.alsoSend),
+    instructions: ai.instructions.map((rule) => rule.trim()).filter((rule) => rule.length > 0),
+    expect: "boolean"
+  };
+}
+function putAiCheckNode(body, check) {
+  const aiChecks = [...body.aiChecks ?? []];
+  const at = aiChecks.findIndex((entry) => entry.name === check.name);
+  if (at < 0) aiChecks.push(check);
+  else aiChecks[at] = check;
+  return { ...body, aiChecks };
+}
+function upsertAiCheck(body, ai) {
+  return putAiCheckNode(body, aiCheckFromDraft(ai));
+}
+function aiDraftFromCheck(check) {
+  const sendFields = aiSendFields(check);
+  if (!sendFields) return void 0;
+  return {
+    name: check.name,
+    instructions: check.instructions,
+    sendField: sendFields[0],
+    ...sendFields.length > 1 ? { alsoSend: sendFields.slice(1) } : {}
+  };
+}
+function withAiSubject(draft, ai) {
+  const ref = aiSubjectRef(ai);
+  if (draft.ai && draft.field === ref) return { ...draft, ai };
+  return {
+    ...draft,
+    ai,
+    ext: void 0,
+    field: ref,
+    consequence: "reject",
+    reject: { ...draft.reject, when: { field: ref, op: "isTrue" } }
+  };
+}
+var AI_SUBJECT_REF = /^ai\.([A-Za-z0-9_-]+)\.(valid|reason)$/;
+var EXT_SUBJECT_REF = /^ext\.([A-Za-z0-9_-]+)\.(valid|score|reason)$/;
+function checkRefOfRule(rule, pattern) {
+  if (rule.consequence !== "reject") return void 0;
+  const candidate = toSimpleRule(rule.gate.when)?.field;
+  return candidate && pattern.test(candidate) ? candidate : void 0;
+}
+function newDraft(body, field, op = "present") {
+  return {
+    code: nextCode(body, "RULE", field),
+    field,
+    consequence: "reject",
+    reject: { when: { field, op }, reason: "", onFail: "reject", verdictClass: "refuted" },
+    human: {
+      whenMissing: FAILED,
+      taskId: nextCode(body, "ASK", field),
+      prompt: "",
+      show: [field],
+      answer: { type: "boolean" },
+      map: { true: "approve", false: "reject" },
+      // The shared reviewer routing, as it stands — so saving without touching
+      // the picker writes back exactly what was there.
+      assigneeDid: body?.review?.assignTo?.assigneeDid,
+      channelRoomId: body?.review?.route?.matrixRoom
+    }
+  };
+}
+function draftFromRule(rule, body) {
+  if (rule.consequence === "reject" && rule.grown?.editable) {
+    const base = plainDraftFromRule(rule, body);
+    return {
+      ...base,
+      grown: {
+        members: rule.grown.members.map((member) => {
+          const name2 = aiMemberName(member);
+          const check = name2 ? body?.aiChecks?.find((entry) => entry.name === name2) : void 0;
+          const ai = check ? aiDraftFromCheck(check) : void 0;
+          return ai ? { kind: "ai", ai } : { kind: "check", rule: member };
+        }),
+        verdictClass: gateClassOf(rule.gate.class)
+      }
+    };
+  }
+  const draft = plainDraftFromRule(rule, body);
+  const aiRef = checkRefOfRule(rule, AI_SUBJECT_REF);
+  const aiName = aiRef ? AI_SUBJECT_REF.exec(aiRef)?.[1] : void 0;
+  const aiCheck = aiName ? body?.aiChecks?.find((entry) => entry.name === aiName) : void 0;
+  if (aiRef && aiCheck) {
+    const sendField2 = Object.values(aiCheck.send).find((value) => typeof value === "string" && value.startsWith("$"));
+    const when = draft.reject.when.field === aiRef ? draft.reject.when : { field: aiRef, op: "isTrue" };
+    return {
+      ...draft,
+      field: aiRef,
+      consequence: "reject",
+      reject: { ...draft.reject, when },
+      // Every sent answer loads back — anchor first, the rest into the picker.
+      // A hand-authored send the pickers can't represent falls back to the
+      // anchor-only read it always had.
+      ai: aiDraftFromCheck(aiCheck) ?? { name: aiCheck.name, instructions: aiCheck.instructions, sendField: sendField2 ?? rule.fieldPath }
+    };
+  }
+  const extRef = checkRefOfRule(rule, EXT_SUBJECT_REF);
+  const name = extRef ? EXT_SUBJECT_REF.exec(extRef)?.[1] : void 0;
+  const source = name ? body?.sources?.find((entry) => entry.name === name) : void 0;
+  if (!extRef || !source) return draft;
+  const sendField = Object.values(source.send).find((value) => typeof value === "string" && value.startsWith("$"));
+  if (source.expect === "score") {
+    const bands = rule.consequence === "reject" ? rule.bands : void 0;
+    if (!bands) return draft;
+    return {
+      ...draft,
+      field: extRef,
+      consequence: "reject",
+      reject: {
+        ...draft.reject,
+        when: { field: extRef, op: ">=", value: bands.approveAt },
+        onFail: "review",
+        // The author's message lives on the FLOOR gate — the hold gate's
+        // reason is generated and never shown as theirs.
+        reason: bands.floor?.gate.reason ?? ""
+      },
+      ext: {
+        name: source.name,
+        endpoint: source.endpoint,
+        audience: source.audience,
+        expect: "score",
+        sendField: sendField ?? rule.fieldPath,
+        // Document bps → the author's 0–100 scale (hand-authored odd values
+        // snap to whole points on the next save).
+        bands: { rejectBelow: Math.round(bands.rejectBelow / 100), approveAt: Math.round(bands.approveAt / 100) },
+        ...bands.floor ? { floorCode: bands.floor.code } : {}
+      }
+    };
+  }
+  return {
+    ...draft,
+    field: extRef,
+    ext: { name: source.name, endpoint: source.endpoint, audience: source.audience, expect: "boolean", sendField: sendField ?? rule.fieldPath }
+  };
+}
+function plainDraftFromRule(rule, body) {
+  const base = newDraft(body, rule.fieldPath);
+  base.at = rule.index;
+  base.code = rule.code;
+  switch (rule.consequence) {
+    case "reject":
+      return {
+        ...base,
+        consequence: "reject",
+        appliesWhen: toSimpleRule(rule.gate.appliesWhen),
+        reject: {
+          when: toSimpleRule(rule.gate.when) ?? base.reject.when,
+          reason: rule.gate.reason,
+          onFail: rule.gate.onFail ?? "reject",
+          verdictClass: gateClassOf(rule.gate.class)
+        }
+      };
+    case "human": {
+      const manual = rule.criterion.score;
+      return {
+        ...base,
+        consequence: "human",
+        appliesWhen: toSimpleRule(rule.criterion.appliesWhen),
+        human: {
+          ...base.human,
+          // carries the shared reviewer (assigneeDid)
+          // Anything that isn't a clean pass reads as a fail — the control only
+          // offers the two, so a legacy in-between value settles on one.
+          whenMissing: manual.whenMissing === PASSED ? PASSED : FAILED,
+          taskId: rule.task?.id ?? base.human.taskId,
+          prompt: rule.task?.prompt ?? "",
+          show: rule.task?.show ?? [rule.fieldPath],
+          answer: rule.task?.answer ?? base.human.answer,
+          map: rule.task?.map ?? base.human.map
+        }
+      };
+    }
+    default:
+      return base;
+  }
+}
+function applyDraft(body, draft, editing, fieldTitle2) {
+  const withSource = draft.ext ? upsertExtSource(body, draft.ext) : draft.ai ? upsertAiCheck(body, draft.ai) : body;
+  const moved = editing !== void 0 && editing.consequence !== draft.consequence;
+  const target = moved ? removeRule(withSource, editing) : withSource;
+  const at = moved ? void 0 : draft.at;
+  const appliesWhen = draft.appliesWhen ? { appliesWhen: toCondition(draft.appliesWhen) } : {};
+  switch (draft.consequence) {
+    case "reject": {
+      const ownedBands = !moved && editing?.consequence === "reject" && editing.bands ? editing.bands.indices : void 0;
+      const base = ownedBands ? removeGatesAt(target, ownedBands) : target;
+      const putRejectGates = (b, add) => {
+        if (ownedBands) {
+          const gates2 = [...b.gates ?? []];
+          gates2.splice(Math.min(...ownedBands), 0, ...add);
+          return { ...b, gates: gates2 };
+        }
+        if (add.length === 1) return putGate(b, add[0], at);
+        const gates = [...b.gates ?? []];
+        if (at === void 0) gates.push(...add);
+        else gates.splice(at, 1, ...add);
+        return { ...b, gates };
+      };
+      if (draft.ext?.expect === "score") {
+        const bands = clampBands(draft.ext.bands ?? SCORE_BANDS_DEFAULT);
+        const ref = extSubjectRef(draft.ext);
+        const hold = {
+          "@type": "Gate",
+          code: draft.code,
+          reason: SCORE_HOLD_REASON,
+          ...appliesWhen,
+          when: { "@type": "Condition", field: ref, op: ">=", value: bands.approveAt * 100 },
+          onFail: "review",
+          class: "requires_human_review"
+        };
+        if (bands.rejectBelow <= 0) return putRejectGates(base, [hold]);
+        const floor = {
+          "@type": "Gate",
+          code: draft.ext.floorCode ?? nextCode(base, "RULE", draft.ext.sendField, [draft.code]),
+          reason: draft.reject.reason.trim() || SCORE_FLOOR_REASON,
+          ...appliesWhen,
+          when: { "@type": "Condition", field: ref, op: ">=", value: bands.rejectBelow * 100 },
+          onFail: "reject",
+          class: "refuted"
+        };
+        return putRejectGates(base, [floor, hold]);
+      }
+      const grown = draft.grown;
+      if (grown && grown.members.length >= 2) {
+        const withMemberChecks = grown.members.reduce((acc, member) => member.kind === "ai" ? upsertAiCheck(acc, member.ai) : acc, base);
+        return putRejectGates(withMemberChecks, [
+          {
+            "@type": "Gate",
+            code: draft.code,
+            reason: draft.reject.reason.trim() || "This claim does not meet the rules",
+            ...appliesWhen,
+            when: grownWhen(grown),
+            onFail: draft.reject.onFail,
+            class: grown.verdictClass ?? "refuted"
+          }
+        ]);
+      }
+      return putRejectGates(base, [
+        {
+          "@type": "Gate",
+          code: draft.code,
+          reason: draft.reject.reason.trim() || "This claim does not meet the rules",
+          ...appliesWhen,
+          when: toCondition(draft.reject.when),
+          onFail: draft.reject.onFail,
+          class: draft.reject.verdictClass
+        }
+      ]);
+    }
+    case "human": {
+      const task = {
+        "@type": "ReviewTask",
+        id: draft.human.taskId,
+        forCriterion: draft.code,
+        prompt: draft.human.prompt.trim() || "Does this look right?",
+        show: draft.human.show,
+        answer: draft.human.answer,
+        map: draft.human.map
+      };
+      const withCriterion = putCriterion(
+        target,
+        {
+          "@type": "Criterion",
+          code: draft.code,
+          reason: reasonFor(draft, fieldTitle2),
+          // `weight` is REQUIRED by the format and read by `weighted_average`
+          // alone — inert under `all_pass`, which is the only method v1 writes.
+          // A constant keeps it out of the author's way without breaking shape.
+          weight: 1,
+          ...appliesWhen,
+          score: { "@type": "ManualScore", field: draft.field, whenMissing: draft.human.whenMissing, reviewTask: task.id }
+        },
+        at
+      );
+      const withTask = putReviewTask(withCriterion, task);
+      const { route: _route, ...review } = withTask.review;
+      const assignTo = { role: review.assignTo?.role || "reviewer", ...draft.human.assigneeDid ? { assigneeDid: draft.human.assigneeDid } : {} };
+      return {
+        ...withTask,
+        review: { ...review, assignTo, ...draft.human.channelRoomId ? { route: { matrixRoom: draft.human.channelRoomId } } : {} }
+      };
+    }
+    default:
+      return body;
+  }
+}
+function reasonFor(draft, fieldTitle2) {
+  const question = fieldTitle2?.trim() || (draft.ext ? `the ${draft.ext.name} check` : draft.ai ? "the AI check" : plainField(draft.field));
+  return `A person checked ${question}`;
+}
+function plainField(field) {
+  return field.replace(/^\$/, "").replace(/\[\*\]/g, "").split(".").map((seg) => seg.includes(":") ? seg.split(":").pop() || seg : seg).join(" ");
+}
+function gateClassOf(value) {
+  return value ?? "refuted";
+}
+function growDraft(draft, seedField) {
+  if (draft.grown || draft.ext || draft.consequence !== "reject") return draft;
+  const first = draft.ai ? { kind: "ai", ai: draft.ai } : { kind: "check", rule: draft.reject.when };
+  return { ...draft, ai: void 0, grown: { members: [first, { kind: "check", rule: { field: seedField, op: "present" } }] } };
+}
+function addGrownMember(draft, seedField) {
+  if (!draft.grown) return draft;
+  return { ...draft, grown: { ...draft.grown, members: [...draft.grown.members, { kind: "check", rule: { field: seedField, op: "present" } }] } };
+}
+function removeGrownMember(draft, at) {
+  const grown = draft.grown;
+  if (!grown) return draft;
+  const members = grown.members.filter((_, i) => i !== at);
+  if (members.length >= 2) return { ...draft, grown: { ...grown, members } };
+  const [last] = members;
+  const base = { ...draft, grown: void 0 };
+  if (!last) return base;
+  if (last.kind === "ai") return withAiSubject(base, last.ai);
+  const show = last.rule.field.startsWith("$") && !base.human.show.includes(last.rule.field) ? [last.rule.field] : base.human.show;
+  return { ...base, ai: void 0, field: last.rule.field, reject: { ...base.reject, when: last.rule }, human: { ...base.human, show } };
+}
+function memberCondition(member) {
+  return member.kind === "ai" ? { "@type": "Condition", field: aiSubjectRef(member.ai), op: "isTrue" } : toCondition(member.rule);
+}
+function grownWhen(grown) {
+  return { "@type": "Condition", all: grown.members.map(memberCondition) };
+}
+function newLinkedDraft(checkedField, op, guardField) {
+  return { checkedField, op, guardField, reason: "", cases: [{}], elseCase: {}, onFail: "reject", verdictClass: "refuted" };
+}
+function linkedReason(prefix, caseText) {
+  return `${prefix} \u2014 ${caseText}`;
+}
+function draftFromLinked(linked, fields) {
+  const first = linked.cases[0].gate.reason;
+  const suffix = ` \u2014 ${linkedCaseText(linked.guardField, linked.cases[0].guardValue, { fields })}`;
+  const reason = first.endsWith(suffix) ? first.slice(0, -suffix.length) : first;
+  return {
+    checkedField: linked.checkedField,
+    // An AI table's gates carry no value check, so `op` holds nothing to keep —
+    // '==' is the neutral seat the editor re-legalises if the author switches
+    // the table back to values.
+    op: linked.ai ? "==" : linked.op,
+    guardField: linked.guardField,
+    reason,
+    cases: linked.cases.map((entry) => ({
+      guardValue: entry.guardValue,
+      value: entry.when.value,
+      tolerance: entry.when.tolerance,
+      ...linked.ai ? { instructions: entry.instructions, aiName: entry.aiName } : {},
+      code: entry.code
+    })),
+    elseCase: {
+      value: linked.elseCase.when.value,
+      tolerance: linked.elseCase.when.tolerance,
+      ...linked.ai ? { instructions: linked.elseCase.instructions, aiName: linked.elseCase.aiName } : {},
+      code: linked.elseCase.code
+    },
+    onFail: linked.onFail,
+    verdictClass: linked.gateClass,
+    editing: linked.indices,
+    ...linked.ai ? { aiMode: true, ...linked.ai.alsoSend.length > 0 ? { alsoSend: linked.ai.alsoSend } : {} } : {}
+  };
+}
+function applyLinkedDraft(body, draft, fields) {
+  const at = draft.editing?.length ? Math.min(...draft.editing) : void 0;
+  const base = draft.editing?.length ? removeGatesAt(body, draft.editing) : body;
+  const prefix = draft.reason.trim() || "This claim does not meet the rules";
+  const minted = [];
+  const codeOf = (row) => {
+    const code = row.code ?? nextCode(base, "RULE", draft.checkedField, minted);
+    minted.push(code);
+    return code;
+  };
+  const inGuard = (row) => ({ "@type": "Condition", field: draft.guardField, op: "in", value: [row.guardValue] });
+  const elseGuard = { "@type": "Condition", field: draft.guardField, op: "notIn", value: draft.cases.map((row) => row.guardValue) };
+  if (draft.aiMode) {
+    const mintedNames = [];
+    const nameOf = (row) => {
+      const name = row.aiName ?? autoAiName(draft.checkedField, base.aiChecks, mintedNames);
+      mintedNames.push(name);
+      return name;
+    };
+    const send = aiSendOf(draft.checkedField, draft.alsoSend);
+    const rows = [
+      ...draft.cases.map((row) => ({ row, appliesWhen: inGuard(row), caseText: linkedCaseText(draft.guardField, row.guardValue, { fields }) })),
+      { row: draft.elseCase, appliesWhen: elseGuard, caseText: linkedElseText() }
+    ];
+    const checks = [];
+    const aiGates = rows.map(({ row, appliesWhen, caseText }) => {
+      const name = nameOf(row);
+      checks.push({
+        "@type": "AiCheck",
+        name,
+        send,
+        instructions: [(row.instructions ?? "").trim()].filter((rule) => rule.length > 0),
+        expect: "boolean"
+      });
+      return {
+        "@type": "Gate",
+        code: codeOf(row),
+        reason: linkedReason(prefix, caseText),
+        appliesWhen,
+        when: { "@type": "Condition", field: `ai.${name}.valid`, op: "isTrue" },
+        onFail: draft.onFail,
+        class: draft.verdictClass
+      };
+    });
+    const withChecks = checks.reduce(putAiCheckNode, base);
+    const gates2 = [...withChecks.gates ?? []];
+    gates2.splice(at ?? gates2.length, 0, ...aiGates);
+    return { ...withChecks, gates: gates2 };
+  }
+  const whenOf = (row) => toCondition({ field: draft.checkedField, op: draft.op, value: row.value, tolerance: row.tolerance });
+  const caseGates = draft.cases.map((row) => ({
+    "@type": "Gate",
+    code: codeOf(row),
+    reason: linkedReason(prefix, linkedCaseText(draft.guardField, row.guardValue, { fields })),
+    appliesWhen: inGuard(row),
+    when: whenOf(row),
+    onFail: draft.onFail,
+    class: draft.verdictClass
+  }));
+  const elseGate = {
+    "@type": "Gate",
+    code: codeOf(draft.elseCase),
+    reason: linkedReason(prefix, linkedElseText()),
+    appliesWhen: elseGuard,
+    when: whenOf(draft.elseCase),
+    onFail: draft.onFail,
+    class: draft.verdictClass
+  };
+  const gates = [...base.gates ?? []];
+  gates.splice(at ?? gates.length, 0, ...caseGates, elseGate);
+  return { ...base, gates };
+}
+
+// src/mantine/blocks/action/actionTypes/evalRubric/LinkedRuleEditor.tsx
+var AI_MODE = "__ai-check__";
+var GUARD_KINDS = /* @__PURE__ */ new Set(["text", "number", "choice"]);
+function legalOps(index, path) {
+  return operatorsForKind(index.get(path)?.kind ?? "text").filter((op) => !takesNoValue(op));
+}
+var LinkedRuleEditor = ({ opened, onClose, body, catalog, index, initialChecked, editing, onSave }) => {
+  const [draft, setDraft] = useState2(() => {
+    if (editing) return draftFromLinked(editing, index);
+    const guard = [...index.values()].find((entry) => GUARD_KINDS.has(entry.kind) && entry.path !== initialChecked && !entry.path.includes("[*]"));
+    return newLinkedDraft(initialChecked, legalOps(index, initialChecked)[0] ?? "==", guard?.path ?? "");
+  });
+  const checkedField = index.get(draft.checkedField);
+  const guardField = index.get(draft.guardField);
+  const ctx = useMemo2(() => ({ fields: index }), [index]);
+  const checkedOptions = useMemo2(
+    () => [...index.values()].filter((entry) => entry.path !== draft.guardField).map((entry) => ({ value: entry.path, label: entry.title })),
+    [index, draft.guardField]
+  );
+  const guardOptions = useMemo2(
+    () => [...index.values()].filter((entry) => GUARD_KINDS.has(entry.kind) && entry.path !== draft.checkedField && !entry.path.includes("[*]")).map((entry) => ({ value: entry.path, label: entry.title })),
+    [index, draft.checkedField]
+  );
+  const opOptions = useMemo2(
+    () => [
+      ...legalOps(index, draft.checkedField).map((op) => {
+        const phrase = OPERATOR_PHRASE[op];
+        return { value: op, label: phrase.suffix ? `${phrase.label} \u2026 ${phrase.suffix}` : phrase.label };
+      }),
+      // The AI lane, entered from the check box like everywhere else (§A.15).
+      { value: AI_MODE, label: AI_CHECK_LANE_LABEL }
+    ],
+    [index, draft.checkedField]
+  );
+  const pickChecked = (path) => {
+    if (!path) return;
+    setDraft((current) => {
+      const legal = legalOps(index, path);
+      const op = legal.includes(current.op) ? current.op : legal[0];
+      return {
+        ...current,
+        checkedField: path,
+        op,
+        cases: current.cases.map((row) => ({ ...row, value: void 0, tolerance: void 0 })),
+        elseCase: { ...current.elseCase, value: void 0, tolerance: void 0 }
+      };
+    });
+  };
+  const pickOp = (op) => {
+    if (!op) return;
+    if (op === AI_MODE) {
+      setDraft((current) => ({ ...current, aiMode: true }));
+      return;
+    }
+    setDraft((current) => {
+      if (current.aiMode && op === current.op) return { ...current, aiMode: false };
+      return {
+        ...current,
+        aiMode: false,
+        op,
+        cases: current.cases.map((row) => ({ ...row, value: void 0, tolerance: void 0 })),
+        elseCase: { ...current.elseCase, value: void 0, tolerance: void 0 }
+      };
+    });
+  };
+  const pickGuard = (path) => {
+    if (!path) return;
+    setDraft((current) => ({ ...current, guardField: path, cases: current.cases.map((row) => ({ ...row, guardValue: void 0 })) }));
+  };
+  const setCase = (at, patch) => setDraft((current) => ({ ...current, cases: current.cases.map((row, i) => i === at ? { ...row, ...patch } : row) }));
+  const addCase = () => setDraft((current) => ({ ...current, cases: [...current.cases, {}] }));
+  const removeCase = (at) => setDraft((current) => current.cases.length <= 1 ? current : { ...current, cases: current.cases.filter((_, i) => i !== at) });
+  const preview = useMemo2(() => {
+    const base = editing ? removeGatesAt(body, editing.indices) : body;
+    const applied = applyLinkedDraft(base, { ...draft, editing: void 0 }, index);
+    const first = base.gates?.length ?? 0;
+    const count = draft.cases.length + 1;
+    const problems = validateRubric(applied, catalog).filter((diagnostic) => {
+      if (diagnostic.severity !== "error") return false;
+      const at = /^\/gates\/(\d+)/.exec(diagnostic.path);
+      return !!at && Number(at[1]) >= first && Number(at[1]) < first + count;
+    }).map(problemText);
+    const missingCase = draft.cases.some((row) => row.guardValue === void 0 || row.guardValue === "");
+    if (missingCase) problems.push(LINKED_MISSING_CASE_TEXT);
+    const keys = draft.cases.map((row) => JSON.stringify(row.guardValue ?? null));
+    if (new Set(keys).size !== keys.length) problems.push(LINKED_DUPLICATE_CASE_TEXT);
+    if (draft.aiMode && [...draft.cases, draft.elseCase].some((row) => !(row.instructions ?? "").trim())) problems.push(LINKED_MISSING_AI_TEXT);
+    const sentence = describeLinked(
+      {
+        checkedField: draft.checkedField,
+        op: draft.op,
+        guardField: draft.guardField,
+        cases: draft.cases,
+        elseValue: draft.elseCase.value,
+        ...draft.aiMode ? { ai: true, elseInstructions: draft.elseCase.instructions } : {}
+      },
+      ctx
+    );
+    return { sentence, problems: [...new Set(problems)] };
+  }, [body, catalog, ctx, draft, editing, index]);
+  const missingReason = !draft.reason.trim();
+  const canSave = preview.problems.length === 0 && !missingReason && !!draft.guardField;
+  const opLabel = OPERATOR_PHRASE[draft.op]?.label ?? "";
+  const opSuffix = OPERATOR_PHRASE[draft.op]?.suffix;
+  return /* @__PURE__ */ React5.createElement(
+    Modal,
+    {
+      opened,
+      onClose,
+      title: editing ? "Change this rule" : `\u201C${fieldTitle(draft.checkedField, ctx)}\u201D depends on another answer`,
+      size: "xl",
+      radius: 14,
+      styles: { title: { fontWeight: 600 } },
+      scrollAreaComponent: ScrollArea2.Autosize
+    },
+    /* @__PURE__ */ React5.createElement(Stack4, { gap: "md" }, /* @__PURE__ */ React5.createElement(Group4, { gap: 8, align: "center", wrap: "wrap" }, /* @__PURE__ */ React5.createElement(BaseSelect, { w: 230, styles: chipInput, data: checkedOptions, value: draft.checkedField, onChange: pickChecked, searchable: checkedOptions.length > 6 }), /* @__PURE__ */ React5.createElement(
+      BaseSelect,
+      {
+        w: 210,
+        styles: chipInput,
+        data: opOptions,
+        value: draft.aiMode ? AI_MODE : draft.op,
+        onChange: pickOp,
+        searchable: opOptions.length > 8,
+        renderOption: ({ option }) => /* @__PURE__ */ React5.createElement(Group4, { gap: 8, wrap: "nowrap" }, option.value === AI_MODE && icon(IconRobot, 16), /* @__PURE__ */ React5.createElement(Text3, { size: "sm" }, option.label))
+      }
+    ), /* @__PURE__ */ React5.createElement(Text3, { style: leadWordStyle }, "\u2026 depending on"), /* @__PURE__ */ React5.createElement(
+      BaseSelect,
+      {
+        w: 230,
+        styles: chipInput,
+        data: guardOptions,
+        value: draft.guardField || null,
+        onChange: pickGuard,
+        searchable: guardOptions.length > 6,
+        placeholder: "Which answer?"
+      }
+    )), /* @__PURE__ */ React5.createElement(Paper2, { p: "md", style: panelStyle }, /* @__PURE__ */ React5.createElement(Stack4, { gap: 8 }, /* @__PURE__ */ React5.createElement(Text3, { style: microLabelStyle }, "The cases"), draft.cases.map((row, at) => /* @__PURE__ */ React5.createElement(Group4, { key: at, gap: 8, align: "flex-start", wrap: "wrap" }, /* @__PURE__ */ React5.createElement(Text3, { mt: 6, style: leadWordStyle }, "If it is"), /* @__PURE__ */ React5.createElement(LiteralInput, { kind: guardField?.kind ?? "text", field: guardField, value: row.guardValue, onChange: (next) => setCase(at, { guardValue: next }) }), draft.aiMode ? /* @__PURE__ */ React5.createElement(React5.Fragment, null, /* @__PURE__ */ React5.createElement(Text3, { mt: 6, style: leadWordStyle }, LINKED_AI_ROW_LEAD), /* @__PURE__ */ React5.createElement(
+      BaseTextInput,
+      {
+        style: { flex: 1, minWidth: 260 },
+        styles: chipInput,
+        placeholder: LINKED_AI_PLACEHOLDER,
+        value: row.instructions ?? "",
+        onChange: (event) => setCase(at, { instructions: event.currentTarget.value })
+      }
+    )) : /* @__PURE__ */ React5.createElement(React5.Fragment, null, /* @__PURE__ */ React5.createElement(Text3, { mt: 6, style: leadWordStyle }, "it ", opLabel), /* @__PURE__ */ React5.createElement(ValueInput, { op: draft.op, field: checkedField, index, value: row.value, tolerance: row.tolerance, onChange: (patch) => setCase(at, patch) }), opSuffix && /* @__PURE__ */ React5.createElement(Text3, { mt: 6, size: "sm", c: "dimmed" }, opSuffix)), /* @__PURE__ */ React5.createElement(ActionIcon, { mt: 4, variant: "subtle", color: "red", onClick: () => removeCase(at), disabled: draft.cases.length <= 1, "aria-label": "Remove this case" }, /* @__PURE__ */ React5.createElement(IconTrash, { size: 16 })))), /* @__PURE__ */ React5.createElement(Group4, { gap: 8, align: "flex-start", wrap: "wrap" }, draft.aiMode ? /* @__PURE__ */ React5.createElement(React5.Fragment, null, /* @__PURE__ */ React5.createElement(Text3, { mt: 6, style: leadWordStyle }, LINKED_AI_ELSE_LEAD), /* @__PURE__ */ React5.createElement(
+      BaseTextInput,
+      {
+        style: { flex: 1, minWidth: 260 },
+        styles: chipInput,
+        placeholder: LINKED_AI_PLACEHOLDER,
+        value: draft.elseCase.instructions ?? "",
+        onChange: (event) => setDraft((current) => ({ ...current, elseCase: { ...current.elseCase, instructions: event.currentTarget.value } }))
+      }
+    )) : /* @__PURE__ */ React5.createElement(React5.Fragment, null, /* @__PURE__ */ React5.createElement(Text3, { mt: 6, style: leadWordStyle }, "For anyone else, it ", opLabel), /* @__PURE__ */ React5.createElement(
+      ValueInput,
+      {
+        op: draft.op,
+        field: checkedField,
+        index,
+        value: draft.elseCase.value,
+        tolerance: draft.elseCase.tolerance,
+        onChange: (patch) => setDraft((current) => ({ ...current, elseCase: { ...current.elseCase, ...patch } }))
+      }
+    ), opSuffix && /* @__PURE__ */ React5.createElement(Text3, { mt: 6, size: "sm", c: "dimmed" }, opSuffix))), /* @__PURE__ */ React5.createElement(Button3, { variant: "subtle", size: "compact-sm", styles: quietButton, style: { alignSelf: "flex-start" }, leftSection: /* @__PURE__ */ React5.createElement(IconPlus, { size: 14 }), onClick: addCase }, "Add another case"))), draft.aiMode && /* @__PURE__ */ React5.createElement(Paper2, { p: "md", style: panelStyle }, /* @__PURE__ */ React5.createElement(Stack4, { gap: "xs" }, /* @__PURE__ */ React5.createElement(Group4, { gap: 6, wrap: "nowrap" }, icon(IconRobot, 16), /* @__PURE__ */ React5.createElement(Text3, { size: "sm", fw: 600 }, AI_SEES_LABEL)), /* @__PURE__ */ React5.createElement(Text3, { size: "xs", c: "dimmed" }, aiSeesHint(fieldTitle(draft.checkedField, ctx))), /* @__PURE__ */ React5.createElement(Text3, { size: "xs", c: "dimmed" }, AI_SETTING_HINT), /* @__PURE__ */ React5.createElement(
+      BaseMultiSelect,
+      {
+        styles: chipInput,
+        placeholder: AI_SEES_PLACEHOLDER,
+        data: [...index.values()].filter((entry) => entry.path !== draft.checkedField).map((entry) => ({ value: entry.path, label: entry.title })),
+        value: (draft.alsoSend ?? []).filter((path) => path !== draft.checkedField),
+        onChange: (alsoSend) => setDraft((current) => ({ ...current, alsoSend: alsoSend.length > 0 ? alsoSend : void 0 })),
+        searchable: true
+      }
+    ))), /* @__PURE__ */ React5.createElement(
+      BaseTextInput,
+      {
+        label: "What should the claimant be told?",
+        styles: chipInputStyles(missingReason),
+        placeholder: "e.g. The amount does not match our records",
+        description: "One message for the whole table \u2014 each case adds which answer it was checked against.",
+        error: missingReason ? "Please write the message." : void 0,
+        value: draft.reason,
+        onChange: (event) => setDraft((current) => ({ ...current, reason: event.currentTarget.value }))
+      }
+    ), preview.problems.length > 0 && /* @__PURE__ */ React5.createElement(Alert, { color: "red", icon: /* @__PURE__ */ React5.createElement(IconAlertTriangle, { size: 16 }), styles: actionAlertStyles }, /* @__PURE__ */ React5.createElement(Stack4, { gap: 2 }, preview.problems.map((problem) => /* @__PURE__ */ React5.createElement(Text3, { key: problem, size: "xs" }, problem)))), /* @__PURE__ */ React5.createElement(Stack4, { gap: 6 }, /* @__PURE__ */ React5.createElement(Text3, { style: microLabelStyle }, "This rule reads:"), /* @__PURE__ */ React5.createElement(RuleSentence, { text: preview.sentence })), /* @__PURE__ */ React5.createElement(Group4, { justify: "flex-end", gap: "xs" }, /* @__PURE__ */ React5.createElement(Button3, { variant: "default", onClick: onClose }, "Cancel"), /* @__PURE__ */ React5.createElement(BasePrimaryButton, { disabled: !canSave, onClick: () => onSave(draft) }, editing ? "Save the change" : "Add this rule")))
+  );
+};
+
+// src/mantine/blocks/action/actionTypes/evalRubric/RuleCard.tsx
+import React6 from "react";
+import { ActionIcon as ActionIcon2, Alert as Alert2, Box as Box2, Button as Button4, Group as Group5, Paper as Paper3, Stack as Stack5, Text as Text4 } from "@mantine/core";
+import { IconAlertTriangle as IconAlertTriangle2, IconLink, IconPencil, IconPlus as IconPlus2, IconTrash as IconTrash2 } from "@tabler/icons-react";
+var RuleCard = ({
+  field,
+  rules,
+  linked,
+  problems,
+  index,
+  aiChecks,
+  onAdd,
+  onEdit,
+  onDelete,
+  onAddLinked,
+  onEditLinked,
+  onDeleteLinked,
+  disabled
+}) => {
+  const errors = problems.filter((problem) => problem.severity === "error");
+  const warnings = problems.filter((problem) => problem.severity === "warning");
+  const ctx = { fields: index, aiChecks };
+  return /* @__PURE__ */ React6.createElement(Paper3, { p: 18, style: { ...cardStyle, ...errors.length > 0 ? { borderColor: "var(--mantine-color-red-6)" } : {} } }, /* @__PURE__ */ React6.createElement(Stack5, { gap: "sm" }, /* @__PURE__ */ React6.createElement(Group5, { gap: "xs", justify: "space-between", wrap: "nowrap" }, /* @__PURE__ */ React6.createElement(Group5, { gap: 8, wrap: "nowrap" }, /* @__PURE__ */ React6.createElement(Text4, { size: "sm", c: "dimmed" }, "\u25CF"), /* @__PURE__ */ React6.createElement(Text4, { size: "sm", fw: 600 }, field.title), field.isRequired && /* @__PURE__ */ React6.createElement(Text4, { size: "xs", c: "dimmed" }, "(always asked)")), /* @__PURE__ */ React6.createElement(Text4, { style: microLabelStyle }, KIND_LABEL[field.kind])), rules.length === 0 && (linked ?? []).length === 0 ? /* @__PURE__ */ React6.createElement(Text4, { size: "xs", c: "dimmed", pl: 20 }, "No rules yet \u2014 this answer won't be checked.") : rules.map((rule) => {
+    const grownShape = rule.consequence === "reject" ? rule.grown : void 0;
+    return /* @__PURE__ */ React6.createElement(Group5, { key: rule.code, gap: "sm", align: "flex-start", wrap: "nowrap", pl: 20 }, /* @__PURE__ */ React6.createElement(Box2, { mt: 2, style: consequencePillStyle(CONSEQUENCES.find((entry) => entry.value === rule.consequence)?.color ?? SLATE) }, consequenceIcon(rule.consequence, 15)), /* @__PURE__ */ React6.createElement(Box2, { style: { flex: 1 } }, grownShape && !grownShape.editable ? (
+      // A compound the builder cannot represent — quiet, honest,
+      // and deletable; never rewritten (§B.5 doctrine).
+      /* @__PURE__ */ React6.createElement(Text4, { size: "xs", c: "dimmed" }, GROUP_OUTSIDE_BUILDER_TEXT)
+    ) : /* @__PURE__ */ React6.createElement(RuleSentence, { text: describeRule(rule, ctx) })), (!grownShape || grownShape.editable) && /* @__PURE__ */ React6.createElement(ActionIcon2, { variant: "subtle", onClick: () => onEdit(rule), disabled, "aria-label": `Change the rule on ${field.title}` }, /* @__PURE__ */ React6.createElement(IconPencil, { size: 16 })), /* @__PURE__ */ React6.createElement(ActionIcon2, { variant: "subtle", color: "red", onClick: () => onDelete(rule), disabled, "aria-label": `Delete the rule on ${field.title}` }, /* @__PURE__ */ React6.createElement(IconTrash2, { size: 16 })));
+  }), (linked ?? []).map((entry) => /* @__PURE__ */ React6.createElement(Group5, { key: entry.elseCase.code, gap: "sm", align: "flex-start", wrap: "nowrap", pl: 20 }, /* @__PURE__ */ React6.createElement(Box2, { mt: 2, style: consequencePillStyle(entry.onFail === "review" ? "var(--mantine-color-grape-6)" : "var(--mantine-color-red-6)") }, consequenceIcon(entry.onFail === "review" ? "human" : "reject", 15)), /* @__PURE__ */ React6.createElement(Box2, { style: { flex: 1 } }, /* @__PURE__ */ React6.createElement(RuleSentence, { text: describeLinked(linkedSentenceOf(entry), ctx) })), /* @__PURE__ */ React6.createElement(ActionIcon2, { variant: "subtle", onClick: () => onEditLinked?.(entry), disabled: disabled || !onEditLinked, "aria-label": `Change the linked rule on ${field.title}` }, /* @__PURE__ */ React6.createElement(IconPencil, { size: 16 })), /* @__PURE__ */ React6.createElement(
+    ActionIcon2,
+    {
+      variant: "subtle",
+      color: "red",
+      onClick: () => onDeleteLinked?.(entry),
+      disabled: disabled || !onDeleteLinked,
+      "aria-label": `Delete the linked rule on ${field.title}`
+    },
+    /* @__PURE__ */ React6.createElement(IconTrash2, { size: 16 })
+  ))), errors.length > 0 && /* @__PURE__ */ React6.createElement(Alert2, { color: "red", icon: /* @__PURE__ */ React6.createElement(IconAlertTriangle2, { size: 16 }), styles: actionAlertStyles, p: "xs" }, /* @__PURE__ */ React6.createElement(Stack5, { gap: 2 }, unique(errors).map((problem) => /* @__PURE__ */ React6.createElement(Text4, { key: problem, size: "xs" }, problem)))), warnings.length > 0 && /* @__PURE__ */ React6.createElement(Alert2, { color: "yellow", styles: actionAlertStyles, p: "xs" }, /* @__PURE__ */ React6.createElement(Stack5, { gap: 2 }, unique(warnings).map((problem) => /* @__PURE__ */ React6.createElement(Text4, { key: problem, size: "xs" }, problem)))), /* @__PURE__ */ React6.createElement(Group5, { pl: 20, gap: "xs" }, /* @__PURE__ */ React6.createElement(Button4, { size: "compact-xs", variant: "subtle", styles: quietButton, leftSection: /* @__PURE__ */ React6.createElement(IconPlus2, { size: 14 }), onClick: onAdd, disabled }, "Add a rule"), onAddLinked && /* @__PURE__ */ React6.createElement(Button4, { size: "compact-xs", variant: "subtle", styles: quietButton, leftSection: /* @__PURE__ */ React6.createElement(IconLink, { size: 14 }), onClick: onAddLinked, disabled }, LINKED_ADD_LABEL))));
+};
+function unique(problems) {
+  return [...new Set(problems.map(problemText))];
+}
+
+// src/mantine/blocks/action/actionTypes/evalRubric/RuleEditor.tsx
+import React11, { useMemo as useMemo4, useState as useState5 } from "react";
+import { ActionIcon as ActionIcon5, Alert as Alert4, Box as Box4, Button as Button7, Divider as Divider2, Group as Group10, Modal as Modal2, Paper as Paper7, ScrollArea as ScrollArea3, Stack as Stack9, Text as Text9 } from "@mantine/core";
+import { IconAlertTriangle as IconAlertTriangle4, IconPlus as IconPlus4, IconRobot as IconRobot3, IconTrash as IconTrash3, IconWand, IconWorld as IconWorld2, IconX as IconX3 } from "@tabler/icons-react";
+
+// src/mantine/blocks/action/actionTypes/evalRubric/AiCheckInline.tsx
+import React7 from "react";
+import { ActionIcon as ActionIcon3, Button as Button5, Group as Group6, Paper as Paper4, Stack as Stack6, Text as Text5 } from "@mantine/core";
+import { IconPlus as IconPlus3, IconRobot as IconRobot2, IconX } from "@tabler/icons-react";
+var AiCheckInline = ({ ai, questionTitle, onChange, disabled, index }) => {
+  const setRule = (at, text) => onChange({ ...ai, instructions: ai.instructions.map((rule, i) => i === at ? text : rule) });
+  const removeRule2 = (at) => onChange({ ...ai, instructions: ai.instructions.filter((_, i) => i !== at) });
+  const addRule = () => onChange({ ...ai, instructions: [...ai.instructions, ""] });
+  return /* @__PURE__ */ React7.createElement(Paper4, { p: "md", style: panelStyle }, /* @__PURE__ */ React7.createElement(Stack6, { gap: "xs" }, /* @__PURE__ */ React7.createElement(Group6, { gap: 6, wrap: "nowrap" }, icon(IconRobot2, 16), /* @__PURE__ */ React7.createElement(Text5, { size: "sm", fw: 600 }, "What should the AI check?")), /* @__PURE__ */ React7.createElement(Text5, { size: "xs", c: "dimmed" }, "While a claim is judged, the AI reads \u201C", questionTitle, "\u201D and passes it only when every rule below holds."), /* @__PURE__ */ React7.createElement(Text5, { size: "xs", c: "dimmed" }, AI_SETTING_HINT), /* @__PURE__ */ React7.createElement(Stack6, { gap: 6 }, ai.instructions.map((rule, at) => (
+    // Index keys are safe here: rows are edited in place and only ever
+    // removed by index — there is no identity to preserve across reorders.
+    /* @__PURE__ */ React7.createElement(Group6, { key: at, gap: "xs", wrap: "nowrap" }, /* @__PURE__ */ React7.createElement(
+      BaseTextInput,
+      {
+        style: { flex: 1 },
+        styles: chipInput,
+        placeholder: "e.g. Looks like a real batch code, not a placeholder",
+        value: rule,
+        onChange: (event) => setRule(at, event.currentTarget.value),
+        disabled
+      }
+    ), /* @__PURE__ */ React7.createElement(ActionIcon3, { variant: "subtle", color: "red", onClick: () => removeRule2(at), disabled: disabled || ai.instructions.length <= 1, "aria-label": "Remove this rule" }, /* @__PURE__ */ React7.createElement(IconX, { size: 16 })))
+  )), /* @__PURE__ */ React7.createElement(Button5, { size: "xs", variant: "subtle", styles: quietButton, leftSection: /* @__PURE__ */ React7.createElement(IconPlus3, { size: 14 }), onClick: addRule, disabled, style: { alignSelf: "flex-start" } }, "Add a rule")), index && /* @__PURE__ */ React7.createElement(
+    BaseMultiSelect,
+    {
+      label: AI_SEES_LABEL,
+      styles: chipInput,
+      placeholder: AI_SEES_PLACEHOLDER,
+      description: aiSeesHint(questionTitle),
+      data: [...index.values()].filter((entry) => entry.path !== ai.sendField).map((entry) => ({ value: entry.path, label: entry.title })),
+      value: (ai.alsoSend ?? []).filter((path) => path !== ai.sendField),
+      onChange: (alsoSend) => onChange({ ...ai, alsoSend: alsoSend.length > 0 ? alsoSend : void 0 }),
+      searchable: true,
+      disabled
+    }
+  )));
+};
+
+// src/mantine/blocks/action/actionTypes/evalRubric/ConditionRow.tsx
+import React8, { useMemo as useMemo3 } from "react";
+import { Group as Group7, Text as Text6 } from "@mantine/core";
+var ConditionRow = ({
+  index,
+  options,
+  sources,
+  aiChecks,
+  rule,
+  onChange,
+  lead = "If",
+  showField = true,
+  disabled,
+  extraOperators,
+  onPickExtra
+}) => {
+  const field = index.get(rule.field) ?? extRefField(rule.field, sources) ?? aiRefField(rule.field, aiChecks);
+  const kind = field?.kind ?? "text";
+  const operatorOptions = useMemo3(
+    () => [
+      ...operatorsForKind(kind).map((op) => {
+        const phrase = OPERATOR_PHRASE[op];
+        return { value: op, label: phrase.suffix ? `${phrase.label} \u2026 ${phrase.suffix}` : phrase.label };
+      }),
+      ...extraOperators ?? []
+    ],
+    [kind, extraOperators]
+  );
+  const pickField = (path) => {
+    if (!path) return;
+    const nextKind = (index.get(path) ?? extRefField(path, sources) ?? aiRefField(path, aiChecks))?.kind ?? "text";
+    const legal = operatorsForKind(nextKind);
+    const op = legal.includes(rule.op) ? rule.op : legal[0];
+    const kept = op === rule.op;
+    onChange({ field: path, op, value: kept ? rule.value : void 0, tolerance: kept ? rule.tolerance : void 0 });
+  };
+  const pickOperator = (op) => {
+    if (!op) return;
+    if (extraOperators?.some((entry) => entry.value === op)) {
+      onPickExtra?.(op);
+      return;
+    }
+    onChange({ field: rule.field, op, value: void 0, tolerance: void 0 });
+  };
+  return /* @__PURE__ */ React8.createElement(Group7, { gap: 8, align: "flex-start", wrap: "wrap" }, /* @__PURE__ */ React8.createElement(Text6, { mt: 6, style: leadWordStyle }, lead), showField && /* @__PURE__ */ React8.createElement(BaseSelect, { w: 220, styles: chipInput, data: options, value: rule.field, onChange: pickField, disabled: disabled || options.length <= 1, searchable: options.length > 6 }), /* @__PURE__ */ React8.createElement(
+    BaseSelect,
+    {
+      w: 230,
+      styles: chipInput,
+      data: operatorOptions,
+      value: rule.op,
+      onChange: pickOperator,
+      disabled,
+      searchable: operatorOptions.length > 8,
+      renderOption: ({ option }) => {
+        const Icon = extraOperators?.find((entry) => entry.value === option.value)?.Icon;
+        return /* @__PURE__ */ React8.createElement(Group7, { gap: 8, wrap: "nowrap" }, Icon && icon(Icon, 16), /* @__PURE__ */ React8.createElement(Text6, { size: "sm" }, option.label));
+      }
+    }
+  ), /* @__PURE__ */ React8.createElement(
+    ValueInput,
+    {
+      op: rule.op,
+      field,
+      index,
+      value: rule.value,
+      tolerance: rule.tolerance,
+      onChange: (patch) => onChange({ ...rule, ...patch }),
+      disabled
+    }
+  ));
+};
+
+// src/mantine/blocks/action/actionTypes/evalRubric/ExternalCheckInline.tsx
+import React9, { useState as useState3 } from "react";
+import { Alert as Alert3, Box as Box3, Button as Button6, Code as Code2, Divider, Group as Group8, Loader, Paper as Paper5, SegmentedControl as SegmentedControl3, Stack as Stack7, Text as Text7 } from "@mantine/core";
+import { IconAlertTriangle as IconAlertTriangle3, IconCheck, IconWorld } from "@tabler/icons-react";
+var ExternalCheckInline = ({ ext, questionTitle, onChange, disabled }) => {
+  const handlers = useBlocknoteHandlers();
+  const canTest = typeof handlers.testExternalSource === "function";
+  const [sample, setSample] = useState3("");
+  const [result, setResult] = useState3(null);
+  const [testing, setTesting] = useState3(false);
+  const [detecting, setDetecting] = useState3(false);
+  const [detectError, setDetectError] = useState3(null);
+  const [manual, setManual] = useState3(false);
+  const detect = async (endpoint) => {
+    if (!endpoint.trim()) return;
+    if (typeof handlers.resolveSourceDid !== "function") {
+      setManual(true);
+      setDetectError("Couldn\u2019t detect who this service is automatically \u2014 enter its did:web address.");
+      return;
+    }
+    setDetecting(true);
+    setDetectError(null);
+    try {
+      const outcome = await handlers.resolveSourceDid({ endpoint: endpoint.trim() });
+      if (outcome.resolved && outcome.did) {
+        onChange({ ...ext, audience: outcome.did });
+        setManual(false);
+      } else {
+        setDetectError(outcome.error || "Couldn\u2019t detect who this service is \u2014 enter its did:web address.");
+        setManual(true);
+      }
+    } catch (error) {
+      setDetectError(error instanceof Error ? error.message : String(error));
+      setManual(true);
+    } finally {
+      setDetecting(false);
+    }
+  };
+  const runTest = async () => {
+    if (!handlers.testExternalSource) return;
+    const source = extSourceFromDraft(ext);
+    setTesting(true);
+    setResult(null);
+    try {
+      setResult(await handlers.testExternalSource({ source, sampleValues: { [Object.keys(source.send)[0]]: sample } }));
+    } catch (error) {
+      setResult({
+        ok: false,
+        reachable: false,
+        httpStatus: null,
+        contractOk: false,
+        expect: ext.expect,
+        value: null,
+        reason: null,
+        error: readableError(error),
+        sent: {},
+        audience: ext.audience,
+        elapsedMs: 0
+      });
+    } finally {
+      setTesting(false);
+    }
+  };
+  const ready = /^https?:\/\//.test(ext.endpoint) && /^did:web:/.test(ext.audience);
+  return /* @__PURE__ */ React9.createElement(Paper5, { p: "md", style: panelStyle }, /* @__PURE__ */ React9.createElement(Stack7, { gap: "xs" }, /* @__PURE__ */ React9.createElement(Group8, { gap: 6, wrap: "nowrap" }, icon(IconWorld, 16), /* @__PURE__ */ React9.createElement(Text7, { size: "sm", fw: 600 }, "The outside service")), /* @__PURE__ */ React9.createElement(Text7, { size: "xs", c: "dimmed" }, "While a claim is judged, the engine sends \u201C", questionTitle, "\u201D to this service and uses its answer in the rule."), /* @__PURE__ */ React9.createElement(Stack7, { gap: 4 }, /* @__PURE__ */ React9.createElement(
+    BaseTextInput,
+    {
+      label: "Web address",
+      styles: chipInput,
+      placeholder: "https://\u2026",
+      value: ext.endpoint,
+      onChange: (event) => onChange({ ...ext, endpoint: event.currentTarget.value }),
+      onBlur: (event) => detect(event.currentTarget.value),
+      disabled
+    }
+  ), detecting && /* @__PURE__ */ React9.createElement(Group8, { gap: 6, wrap: "nowrap" }, /* @__PURE__ */ React9.createElement(Loader, { size: 12 }), /* @__PURE__ */ React9.createElement(Text7, { size: "xs", c: "dimmed" }, "Finding who this service is\u2026")), !detecting && ext.audience && !manual && /* @__PURE__ */ React9.createElement(Group8, { gap: 6, wrap: "nowrap" }, icon(IconCheck, 14, "var(--mantine-color-green-6)"), /* @__PURE__ */ React9.createElement(Text7, { size: "xs", c: "dimmed", style: { wordBreak: "break-all" } }, "detected ", ext.audience), /* @__PURE__ */ React9.createElement(Button6, { size: "compact-xs", variant: "subtle", styles: quietButton, onClick: () => setManual(true), disabled }, "change")), !detecting && (manual || detectError) && /* @__PURE__ */ React9.createElement(Stack7, { gap: 2 }, detectError && /* @__PURE__ */ React9.createElement(Text7, { size: "xs", c: "red" }, detectError), /* @__PURE__ */ React9.createElement(
+    BaseTextInput,
+    {
+      label: "Who it is (did:web)",
+      styles: chipInput,
+      placeholder: "did:web:example.com",
+      value: ext.audience,
+      onChange: (event) => onChange({ ...ext, audience: event.currentTarget.value }),
+      disabled
+    }
+  ))), /* @__PURE__ */ React9.createElement(Divider, { label: EXT_ANSWER_TYPE_LABEL, labelPosition: "left", color: HAIRLINE, styles: { label: microLabelStyle } }), /* @__PURE__ */ React9.createElement(
+    SegmentedControl3,
+    {
+      styles: segmentedPill,
+      value: ext.expect,
+      onChange: (expect) => onChange(expect === "score" ? { ...ext, expect: "score", bands: ext.bands ?? { ...SCORE_BANDS_DEFAULT } } : { ...ext, expect: "boolean" }),
+      disabled,
+      data: [
+        { value: "boolean", label: EXT_ANSWERS_BOOLEAN_LABEL },
+        { value: "score", label: EXT_ANSWERS_SCORE_LABEL }
+      ],
+      style: { alignSelf: "flex-start" }
+    }
+  ), ext.expect === "score" && /* @__PURE__ */ React9.createElement(ScoreBandsEditor, { ext, onChange, disabled }), /* @__PURE__ */ React9.createElement(Divider, { label: "Try it", labelPosition: "left", color: HAIRLINE, styles: { label: microLabelStyle } }), /* @__PURE__ */ React9.createElement(Group8, { gap: "xs", align: "flex-end", wrap: "wrap" }, /* @__PURE__ */ React9.createElement(
+    BaseTextInput,
+    {
+      w: 260,
+      styles: chipInput,
+      label: `Sample ${questionTitle}`,
+      placeholder: "a value to try",
+      value: sample,
+      onChange: (event) => setSample(event.currentTarget.value),
+      disabled
+    }
+  ), /* @__PURE__ */ React9.createElement(
+    Button6,
+    {
+      size: "xs",
+      variant: "light",
+      styles: chipButton,
+      leftSection: testing ? /* @__PURE__ */ React9.createElement(Loader, { size: 12 }) : icon(IconWorld, 14),
+      onClick: runTest,
+      disabled: disabled || !canTest || !ready || testing
+    },
+    "Test this check"
+  ), !canTest ? /* @__PURE__ */ React9.createElement(Text7, { size: "xs", c: "dimmed" }, "Testing isn\u2019t available here.") : !ready && /* @__PURE__ */ React9.createElement(Text7, { size: "xs", c: "dimmed" }, "Enter the web address first.")), result && /* @__PURE__ */ React9.createElement(TestResult, { result, ext })));
+};
+var ScoreBandsEditor = ({ ext, onChange, disabled }) => {
+  const bands = clampBands(ext.bands ?? SCORE_BANDS_DEFAULT);
+  const commit = (next) => onChange({ ...ext, bands: clampBands(next) });
+  const zone = (background, width, label) => /* @__PURE__ */ React9.createElement(
+    Box3,
+    {
+      style: {
+        width: `${width}%`,
+        background,
+        overflow: "hidden",
+        whiteSpace: "nowrap",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        fontSize: 10,
+        fontWeight: 700,
+        color: "var(--mantine-color-white)",
+        opacity: 0.85
+      }
+    },
+    width >= 14 ? label : ""
+  );
+  return /* @__PURE__ */ React9.createElement(Stack7, { gap: 8 }, /* @__PURE__ */ React9.createElement(Group8, { gap: 8, align: "center", wrap: "wrap" }, /* @__PURE__ */ React9.createElement(Text7, { size: "sm" }, "Below"), /* @__PURE__ */ React9.createElement(
+    BaseNumberInput,
+    {
+      w: 72,
+      styles: chipInput,
+      min: 0,
+      max: 99,
+      allowDecimal: false,
+      value: bands.rejectBelow,
+      onChange: (next) => commit({ ...bands, rejectBelow: typeof next === "number" ? next : 0 }),
+      disabled,
+      "aria-label": "Reject below this score"
+    }
+  ), /* @__PURE__ */ React9.createElement(Text7, { size: "sm" }, "the claim is turned down \xB7 at"), /* @__PURE__ */ React9.createElement(
+    BaseNumberInput,
+    {
+      w: 72,
+      styles: chipInput,
+      min: 1,
+      max: 100,
+      allowDecimal: false,
+      value: bands.approveAt,
+      onChange: (next) => commit({ ...bands, approveAt: typeof next === "number" ? next : 100 }),
+      disabled,
+      "aria-label": "Passes at this score"
+    }
+  ), /* @__PURE__ */ React9.createElement(Text7, { size: "sm" }, "or more it passes")), /* @__PURE__ */ React9.createElement(Box3, { style: { display: "flex", height: 22, borderRadius: 6, overflow: "hidden", border: `1px solid ${HAIRLINE}` }, "aria-hidden": true }, zone("var(--mantine-color-red-8)", bands.rejectBelow, "turned down"), zone("var(--mantine-color-yellow-8)", bands.approveAt - bands.rejectBelow, "a person decides"), zone("var(--mantine-color-green-8)", 100 - bands.approveAt, "passes")), /* @__PURE__ */ React9.createElement(Text7, { size: "xs", c: "dimmed" }, "In between \u2014 from ", bands.rejectBelow, " to ", bands.approveAt - 1, " \u2014 the claim waits for a person to decide."));
+};
+var TestResult = ({ result, ext }) => {
+  const title = (() => {
+    if (!result.ok) return "Did not pass";
+    if (result.expect === "score" && typeof result.value === "number") {
+      const score = Math.round(result.value / 100);
+      const bands = clampBands(ext.bands ?? SCORE_BANDS_DEFAULT);
+      const outcome = score >= bands.approveAt ? "it would pass" : score >= bands.rejectBelow ? "a person would decide" : "the claim would be turned down";
+      return `Scored ${score} / 100 \u2014 ${outcome}`;
+    }
+    return `Passed \u2014 ${result.value ? "yes" : "no"}`;
+  })();
+  return /* @__PURE__ */ React9.createElement(Alert3, { color: result.ok ? "green" : "red", icon: result.ok ? /* @__PURE__ */ React9.createElement(IconCheck, { size: 16 }) : /* @__PURE__ */ React9.createElement(IconAlertTriangle3, { size: 16 }), title }, /* @__PURE__ */ React9.createElement(Stack7, { gap: 4 }, !result.ok && /* @__PURE__ */ React9.createElement(Text7, { size: "xs" }, [result.error, result.httpStatus != null ? `HTTP ${result.httpStatus}` : null].filter(Boolean).join(" \xB7 ") || "The check could not be completed."), result.reason && /* @__PURE__ */ React9.createElement(Text7, { size: "xs", c: "dimmed" }, result.reason), /* @__PURE__ */ React9.createElement(Text7, { size: "xs", c: "dimmed" }, "Sent: ", /* @__PURE__ */ React9.createElement(Code2, { style: { fontSize: 11 } }, JSON.stringify(result.sent)))));
+};
+function readableError(error) {
+  return appErrorMessage(error) ?? (error instanceof Error ? error.message : String(error));
+}
+function appErrorMessage(error) {
+  if (!error || typeof error !== "object") return null;
+  const source = error;
+  for (const candidate of [source.response?.data, source.data, source]) {
+    const envelope = candidate && typeof candidate === "object" ? candidate.error : void 0;
+    if (envelope && typeof envelope === "object" && typeof envelope.message === "string") {
+      const { message, details } = envelope;
+      const detail = typeof details === "string" ? details : Array.isArray(details) ? details.map((d) => typeof d === "string" ? d : JSON.stringify(d)).join("; ") : details ? JSON.stringify(details) : "";
+      return detail ? `${message} \u2014 ${detail}` : message;
+    }
+  }
+  return null;
+}
+
+// src/mantine/blocks/action/actionTypes/evalRubric/ReviewTaskEditor.tsx
+import React10, { useEffect as useEffect2, useState as useState4 } from "react";
+import { ActionIcon as ActionIcon4, Group as Group9, Loader as Loader2, Paper as Paper6, SegmentedControl as SegmentedControl4, Stack as Stack8, TagsInput as TagsInput2, Text as Text8 } from "@mantine/core";
+import { IconBan as IconBan2, IconCircleCheck, IconMessages, IconPercentage, IconUser, IconX as IconX2 } from "@tabler/icons-react";
+var VERDICT_OPTIONS = [
+  { value: "approve", label: "Approve the claim", Icon: IconCircleCheck, color: "var(--mantine-color-green-6)" },
+  { value: "partial", label: "Part-approve it", Icon: IconPercentage, color: "var(--mantine-color-blue-6)" },
+  { value: "reject", label: "Reject the claim", Icon: IconBan2, color: "var(--mantine-color-red-6)" }
+];
+var ReviewTaskEditor = ({ fieldOptions, draft, onChange }) => {
+  const answers = possibleAnswers(draft.answer);
+  const pickShape = (type) => {
+    if (type === "boolean") {
+      onChange({ ...draft, answer: { type: "boolean" }, map: { true: "approve", false: "reject" } });
+    } else if (type === "enum") {
+      const options = draft.answer.type === "enum" ? draft.answer.options : [];
+      onChange({ ...draft, answer: { type: "enum", options }, map: mapFor(options, draft.map) });
+    }
+  };
+  const setOptions = (options) => onChange({ ...draft, answer: { type: "enum", options }, map: mapFor(options, draft.map) });
+  return /* @__PURE__ */ React10.createElement(Stack8, { gap: "sm" }, /* @__PURE__ */ React10.createElement(
+    BaseTextArea,
+    {
+      label: "What should the person be asked?",
+      styles: chipInput,
+      placeholder: "e.g. Does the delivery photo clearly show the goods at the outlet?",
+      description: "Ask one plain question they can answer by looking.",
+      minRows: 2,
+      autosize: true,
+      value: draft.prompt,
+      onChange: (event) => onChange({ ...draft, prompt: event.currentTarget.value })
+    }
+  ), /* @__PURE__ */ React10.createElement(
+    BaseMultiSelect,
+    {
+      label: "What should they see?",
+      styles: chipInput,
+      placeholder: "Pick the answers to show them",
+      description: "They will only see what you pick here.",
+      data: fieldOptions,
+      value: draft.show,
+      onChange: (show) => onChange({ ...draft, show }),
+      searchable: true
+    }
+  ), /* @__PURE__ */ React10.createElement(
+    BaseSelect,
+    {
+      label: "How do they answer?",
+      w: 240,
+      styles: chipInput,
+      data: [
+        { value: "boolean", label: "Yes or No" },
+        { value: "enum", label: "Pick one from a list" }
+      ],
+      value: draft.answer.type,
+      onChange: pickShape
+    }
+  ), draft.answer.type === "enum" && /* @__PURE__ */ React10.createElement(TagsInput2, { label: "The answers they can pick", styles: chipInput, placeholder: "Type an answer, press Enter", value: draft.answer.options, onChange: setOptions }), /* @__PURE__ */ React10.createElement(Stack8, { gap: 6 }, /* @__PURE__ */ React10.createElement(Text8, { style: microLabelStyle }, "What does each answer do?"), answers.length === 0 ? /* @__PURE__ */ React10.createElement(Text8, { size: "xs", c: "dimmed" }, "Add at least one answer above.") : answers.map((answer) => /* @__PURE__ */ React10.createElement(Group9, { key: answer, gap: "xs", align: "center" }, /* @__PURE__ */ React10.createElement(Text8, { size: "sm", fw: 500, style: { width: 160 } }, answerLabel(answer)), /* @__PURE__ */ React10.createElement(Text8, { size: "xs", c: "dimmed" }, "\u2192"), /* @__PURE__ */ React10.createElement(
+    BaseSelect,
+    {
+      w: 200,
+      styles: chipInput,
+      data: VERDICT_OPTIONS.map(({ value, label }) => ({ value, label })),
+      renderOption: ({ option }) => {
+        const verdict = VERDICT_OPTIONS.find((entry) => entry.value === option.value);
+        return /* @__PURE__ */ React10.createElement(Group9, { gap: 8, wrap: "nowrap" }, verdict && icon(verdict.Icon, 16, verdict.color), /* @__PURE__ */ React10.createElement(Text8, { size: "sm" }, option.label));
+      },
+      value: draft.map[answer] ?? null,
+      onChange: (verdict) => verdict && onChange({ ...draft, map: { ...draft.map, [answer]: verdict } })
+    }
+  )))), /* @__PURE__ */ React10.createElement(Stack8, { gap: 6 }, /* @__PURE__ */ React10.createElement(Text8, { style: microLabelStyle }, "If nothing was attached"), /* @__PURE__ */ React10.createElement(
+    SegmentedControl4,
+    {
+      w: 280,
+      styles: segmentedPill,
+      data: [
+        { value: String(FAILED), label: "The check fails" },
+        { value: String(PASSED), label: "The check passes" }
+      ],
+      value: draft.whenMissing === PASSED ? String(PASSED) : String(FAILED),
+      onChange: (value) => onChange({ ...draft, whenMissing: Number(value) })
+    }
+  ), /* @__PURE__ */ React10.createElement(Text8, { size: "xs", c: "dimmed", maw: 320 }, "Nobody is asked when there is nothing to look at \u2014 the claim is decided this way instead.")), /* @__PURE__ */ React10.createElement(Text8, { size: "xs", c: "dimmed" }, "When there IS something to look at, the claim waits for the person's answer \u2014 it cannot be approved before then."), /* @__PURE__ */ React10.createElement(ReviewerPicker, { draft, onChange }));
+};
+var ROOM_SHAPE = /^[!#][^\s:]+:.+$/;
+var ReviewerPicker = ({ draft, onChange }) => {
+  const [mode, setMode] = useState4(draft.assigneeDid && !draft.channelRoomId ? "person" : "channel");
+  const [pickedName, setPickedName] = useState4(null);
+  const pickPerson = (did, displayName) => {
+    setPickedName(did ? displayName ?? null : null);
+    onChange({ ...draft, assigneeDid: did ? matrixUserIdToDid(did) : void 0, channelRoomId: void 0 });
+  };
+  const pickChannel = (roomId) => onChange({ ...draft, channelRoomId: roomId || void 0, assigneeDid: void 0 });
+  return /* @__PURE__ */ React10.createElement(Stack8, { gap: 6 }, /* @__PURE__ */ React10.createElement(Text8, { style: microLabelStyle }, "Who checks it?"), /* @__PURE__ */ React10.createElement(
+    SegmentedControl4,
+    {
+      w: 320,
+      size: "xs",
+      styles: segmentedPill,
+      value: mode,
+      onChange: (value) => setMode(value),
+      data: [
+        {
+          value: "channel",
+          label: /* @__PURE__ */ React10.createElement(Group9, { gap: 6, wrap: "nowrap", justify: "center" }, icon(IconMessages, 14), /* @__PURE__ */ React10.createElement("span", null, "A channel"))
+        },
+        {
+          value: "person",
+          label: /* @__PURE__ */ React10.createElement(Group9, { gap: 6, wrap: "nowrap", justify: "center" }, icon(IconUser, 14), /* @__PURE__ */ React10.createElement("span", null, "A person"))
+        }
+      ]
+    }
+  ), mode === "channel" ? /* @__PURE__ */ React10.createElement(Stack8, { gap: 6 }, /* @__PURE__ */ React10.createElement(Text8, { size: "xs", c: "dimmed" }, "Anyone in the channel can pick the review up. Leave it empty and anyone with the reviewer role can."), draft.channelRoomId ? /* @__PURE__ */ React10.createElement(React10.Fragment, null, /* @__PURE__ */ React10.createElement(PickedValue, { title: "Review channel", value: draft.channelRoomId, onClear: () => pickChannel(void 0), clearLabel: "Remove this channel" }), /* @__PURE__ */ React10.createElement(EngineChannelAccess, { roomId: draft.channelRoomId })) : /* @__PURE__ */ React10.createElement(ChannelSearch, { onPick: pickChannel })) : /* @__PURE__ */ React10.createElement(Stack8, { gap: 6 }, /* @__PURE__ */ React10.createElement(Text8, { size: "xs", c: "dimmed" }, "Name the person who reviews these claims. Leave it open and anyone with the reviewer role can pick it up."), draft.assigneeDid ? /* @__PURE__ */ React10.createElement(PickedValue, { title: pickedName ?? "Assigned reviewer", value: draft.assigneeDid, onClear: () => pickPerson(void 0), clearLabel: "Remove this reviewer" }) : /* @__PURE__ */ React10.createElement(UserSearch, { onPick: (user) => pickPerson(user.did, user.displayName), placeholder: "Search for the person who checks" })));
+};
+var EngineChannelAccess = ({ roomId }) => {
+  const handlers = useBlocknoteHandlers();
+  const invite = handlers.inviteEvalEngineToChannel;
+  const [state, setState] = useState4("working");
+  useEffect2(() => {
+    if (typeof invite !== "function") return;
+    let alive = true;
+    setState("working");
+    invite({ roomId }).then((result) => alive && setState(result?.status === "not-configured" ? "unavailable" : "ready")).catch((error) => {
+      console.warn("[eval.rubric] could not invite the eval engine to the review channel:", error);
+      if (alive) setState("failed");
+    });
+    return () => {
+      alive = false;
+    };
+  }, [roomId, invite]);
+  if (typeof invite !== "function" || state === "unavailable") return null;
+  if (state === "working") {
+    return /* @__PURE__ */ React10.createElement(Group9, { gap: 6, wrap: "nowrap" }, /* @__PURE__ */ React10.createElement(Loader2, { size: 12 }), /* @__PURE__ */ React10.createElement(Text8, { size: "xs", c: "dimmed" }, "Giving the eval engine access to this channel\u2026"));
+  }
+  if (state === "failed") {
+    return /* @__PURE__ */ React10.createElement(Text8, { size: "xs", c: "red" }, "Couldn\u2019t give the eval engine access to this channel. Open the channel and invite it yourself, or pick another one.");
+  }
+  return /* @__PURE__ */ React10.createElement(Group9, { gap: 6, wrap: "nowrap" }, icon(IconCircleCheck, 14, "var(--mantine-color-green-6)"), /* @__PURE__ */ React10.createElement(Text8, { size: "xs", c: "dimmed" }, "The eval engine can post review requests here."));
+};
+var PickedValue = ({ title, value, onClear, clearLabel }) => /* @__PURE__ */ React10.createElement(Paper6, { p: "xs", style: panelStyle }, /* @__PURE__ */ React10.createElement(Group9, { gap: "xs", justify: "space-between", wrap: "nowrap" }, /* @__PURE__ */ React10.createElement(Stack8, { gap: 0 }, /* @__PURE__ */ React10.createElement(Text8, { size: "sm", fw: 500 }, title), /* @__PURE__ */ React10.createElement(Text8, { size: "xs", c: "dimmed", style: { wordBreak: "break-all" } }, value)), /* @__PURE__ */ React10.createElement(ActionIcon4, { variant: "subtle", color: "red", onClick: onClear, "aria-label": clearLabel }, /* @__PURE__ */ React10.createElement(IconX2, { size: 16 }))));
+var ChannelSearch = ({ onPick }) => {
+  const handlers = useBlocknoteHandlers();
+  const canList = typeof handlers.listDomainChannels === "function" || typeof handlers.sourceDomainSpaces === "function";
+  const [options, setOptions] = useState4([]);
+  const [loading, setLoading] = useState4(canList);
+  const [loadError, setLoadError] = useState4(null);
+  const [pasted, setPasted] = useState4("");
+  useEffect2(() => {
+    if (!canList) return;
+    let alive = true;
+    const load = async () => {
+      if (typeof handlers.listDomainChannels === "function") {
+        const rooms = await handlers.listDomainChannels();
+        return rooms.map((room) => ({ value: room.roomId, label: room.name || room.roomId }));
+      }
+      const tree = await handlers.sourceDomainSpaces();
+      const label = (room) => room.roomAlias || room.roomId;
+      const groups = [
+        { group: "This entity", items: (tree.rooms ?? []).map((room) => ({ value: room.roomId, label: label(room) })) },
+        ...Object.entries(tree.subspaces ?? {}).map(([name, subspace]) => ({
+          group: name,
+          items: (subspace?.rooms ?? []).map((room) => ({ value: room.roomId, label: label(room) }))
+        }))
+      ];
+      return groups.filter((entry) => entry.items.length > 0);
+    };
+    load().then((loaded) => alive && setOptions(loaded)).catch((error) => {
+      console.warn("[eval.rubric] channel listing failed:", error);
+      if (alive) setLoadError(error instanceof Error ? error.message : String(error));
+    }).finally(() => alive && setLoading(false));
+    return () => {
+      alive = false;
+    };
+  }, []);
+  const pastedValid = ROOM_SHAPE.test(pasted.trim());
+  const empty = !loading && options.length === 0;
+  return /* @__PURE__ */ React10.createElement(Stack8, { gap: 6 }, canList && !empty && /* @__PURE__ */ React10.createElement(
+    BaseSelect,
+    {
+      w: 320,
+      styles: chipInput,
+      placeholder: loading ? "Finding this domain\u2019s channels\u2026" : "Pick one of this domain\u2019s channels",
+      data: options,
+      value: null,
+      onChange: (roomId) => roomId && onPick(roomId),
+      searchable: true,
+      disabled: loading,
+      rightSection: loading ? /* @__PURE__ */ React10.createElement(Loader2, { size: 12 }) : void 0
+    }
+  ), (empty || !canList) && /* @__PURE__ */ React10.createElement(Text8, { size: "xs", c: loadError ? "red" : "dimmed" }, loadError ? `Couldn\u2019t list this domain\u2019s channels (${loadError}) \u2014 paste the channel id instead.` : canList ? "No channels found in this domain space \u2014 paste the channel id instead." : "Channels can\u2019t be listed here \u2014 paste the channel id instead."), /* @__PURE__ */ React10.createElement(
+    BaseTextInput,
+    {
+      w: 320,
+      styles: chipInputStyles(Boolean(pasted.trim() && !pastedValid)),
+      placeholder: "\u2026or paste a channel id (!room:server)",
+      value: pasted,
+      error: pasted.trim() && !pastedValid ? "A channel id starts with ! or # and contains :server" : void 0,
+      onChange: (event) => setPasted(event.currentTarget.value),
+      onKeyDown: (event) => {
+        if (event.key === "Enter" && pastedValid) onPick(pasted.trim());
+      },
+      onBlur: () => {
+        if (pastedValid) onPick(pasted.trim());
+      }
+    }
+  ));
+};
+function possibleAnswers(answer) {
+  if (answer.type === "boolean") return ["true", "false"];
+  if (answer.type === "enum") return answer.options;
+  return [];
+}
+function mapFor(options, existing) {
+  return Object.fromEntries(options.map((option) => [option, existing[option] ?? "reject"]));
+}
+
+// src/mantine/blocks/action/actionTypes/evalRubric/templates.ts
+var mustBeFilledIn = {
+  id: "present",
+  label: "Must be filled in",
+  build: (field, body) => reject(newDraft(body, field.path, "present"), `${field.title} is missing`, "insufficient_evidence")
+};
+var mustBeAttached = {
+  id: "attached",
+  label: "Must be attached",
+  build: (field, body) => reject(newDraft(body, field.path, "present"), `${field.title} is missing`, "insufficient_evidence")
+};
+var mustBeDuringPeriod = {
+  id: "withinWindow",
+  label: "Must be during the collection period",
+  build: (field, body) => reject(newDraft(body, field.path, "withinWindow"), `${field.title} is outside the collection period`, "refuted")
+};
+var cannotBeInFuture = {
+  id: "notInFuture",
+  label: "Cannot be in the future",
+  build: (field, body) => reject(newDraft(body, field.path, "notInFuture"), `${field.title} is in the future`, "refuted")
+};
+var mustBeOneOf = {
+  id: "in",
+  label: "Must be one of\u2026",
+  build: (field, body) => {
+    if (!field.choices || field.choices.length === 0) return void 0;
+    const draft = newDraft(body, field.path, "in");
+    draft.reject.when = { field: field.path, op: "in", value: field.choices.map((choice) => choice.value) };
+    return reject(draft, `${field.title} is not allowed`, "out_of_authority");
+  }
+};
+var mustBeAtLeast = {
+  id: "atLeast",
+  label: "Must be at least\u2026",
+  build: (field, body) => {
+    const draft = newDraft(body, field.path, ">=");
+    draft.reject.when = { field: field.path, op: ">=", value: 1 };
+    return reject(draft, `${field.title} is too low`, "refuted");
+  }
+};
+var mustBeAPdf = {
+  id: "pdf",
+  label: "Must be a PDF",
+  build: (field, body) => {
+    const draft = newDraft(body, field.path, "mediaTypeIn");
+    draft.reject.when = { field: field.path, op: "mediaTypeIn", value: ["application/pdf"] };
+    return reject(draft, `${field.title} must be a PDF`, "invalid_evidence");
+  }
+};
+var aPersonChecks = {
+  id: "human",
+  label: "A person checks it",
+  build: (field, body) => {
+    const draft = newDraft(body, field.path);
+    draft.consequence = "human";
+    draft.human = { ...draft.human, prompt: `Does \u201C${field.title}\u201D show what it should?`, show: [field.path] };
+    return draft;
+  }
+};
+var mustBeTicked = {
+  id: "isTrue",
+  label: "Must be ticked",
+  build: (field, body) => reject(newDraft(body, field.path, "isTrue"), `${field.title} was not confirmed`, "refuted")
+};
+var everyRowMust = {
+  id: "everyRow",
+  label: "Every row must be filled in",
+  build: (field, body) => {
+    const column = field.columns?.find((inner) => inner.kind === "number") ?? field.columns?.[0];
+    if (!column) return void 0;
+    return reject(newDraft(body, column.path, "present"), `Every row of ${field.title} must be complete`, "insufficient_evidence");
+  }
+};
+var mustHaveEntries = {
+  id: "countBetween",
+  label: "Must have at least one entry",
+  build: (field, body) => {
+    const draft = newDraft(body, field.path, "countBetween");
+    draft.reject.when = { field: field.path, op: "countBetween", value: [1, 100] };
+    return reject(draft, `${field.title} is empty`, "insufficient_evidence");
+  }
+};
+var mustBeInProjectArea = {
+  id: "withinBoundary",
+  label: "Must be inside the project area",
+  build: (field, body) => {
+    const draft = newDraft(body, field.path, "withinBoundary");
+    draft.reject.when = { field: field.path, op: "withinBoundary", value: "ctx.collection.projectBoundary" };
+    return reject(draft, `${field.title} is outside the project area`, "out_of_authority");
+  }
+};
+var TEMPLATES = {
+  text: [mustBeFilledIn],
+  number: [mustBeAtLeast],
+  date: [mustBeDuringPeriod, cannotBeInFuture],
+  choice: [mustBeOneOf],
+  multichoice: [mustBeFilledIn, mustHaveEntries],
+  boolean: [mustBeTicked],
+  file: [mustBeAttached, mustBeAPdf, aPersonChecks],
+  signature: [mustBeAttached, aPersonChecks],
+  geo: [mustBeInProjectArea],
+  rows: [everyRowMust, mustHaveEntries],
+  cells: [mustBeFilledIn],
+  keyed_choice: [mustBeFilledIn],
+  keyed_text: [mustBeFilledIn]
+};
+function templatesForField(field, body) {
+  const templates = [];
+  for (const def of TEMPLATES[field.kind] ?? []) {
+    const draft = def.build(field, body);
+    if (draft) templates.push({ id: def.id, label: def.label, draft });
+  }
+  return templates;
+}
+function reject(draft, reason, verdictClass) {
+  draft.consequence = "reject";
+  draft.reject = { ...draft.reject, reason, verdictClass };
+  return draft;
+}
+
+// src/mantine/blocks/action/actionTypes/evalRubric/RuleEditor.tsx
+var EXT_SUBJECT = "__external-check__";
+var AI_CHECK = "__ai-check__";
+var RuleEditor = ({ opened, onClose, body, catalog, index, field, editing, onSave }) => {
+  const [draft, setDraft] = useState5(() => editing ? draftFromRule(editing, body) : newDraft(body, field.path));
+  const [showTemplates, setShowTemplates] = useState5(!editing);
+  const ext = draft.ext;
+  const ai = draft.ai;
+  const grown = draft.grown;
+  const draftBody = useMemo4(() => {
+    const withLane = ext ? upsertExtSource(body, ext) : ai ? upsertAiCheck(body, ai) : body;
+    return grown ? grown.members.reduce((acc, member) => member.kind === "ai" ? upsertAiCheck(acc, member.ai) : acc, withLane) : withLane;
+  }, [body, ext, ai, grown]);
+  const fieldOptions = useMemo4(() => targetableFields(field).map((entry) => ({ value: entry.path, label: entry.title })), [field]);
+  const subjectOptions = useMemo4(
+    () => [
+      ...fieldOptions,
+      { value: EXT_SUBJECT, label: "An outside service checks this answer" },
+      ...ai ? [{ value: AI_CHECK, label: `The AI checks \u201C${index.get(ai.sendField)?.title ?? field.title}\u201D` }] : []
+    ],
+    [fieldOptions, ai, index, field.title]
+  );
+  const showOptions = useMemo4(() => [...index.values()].map((entry) => ({ value: entry.path, label: entry.title })), [index]);
+  const templates = useMemo4(() => templatesForField(field, body), [field, body]);
+  const consequences = useMemo4(() => ai || ext ? CONSEQUENCES.filter((entry) => entry.value === "reject") : CONSEQUENCES, [ext, ai]);
+  const preview = useMemo4(() => {
+    const applied = applyDraft(
+      editing ? removeRule(body, editing) : body,
+      { ...draft, at: void 0 },
+      void 0,
+      index.get(draft.ext?.sendField ?? draft.ai?.sendField ?? draft.field)?.title
+    );
+    const rule = listRules(applied).find((entry) => entry.code === draft.code);
+    const problems = validateRubric(applied, catalog).filter((diagnostic) => diagnostic.severity === "error" && ruleForDiagnosticPath(applied, diagnostic.path)?.code === draft.code).map(problemText);
+    return { sentence: rule ? describeRule(rule, { fields: index, aiChecks: applied.aiChecks }) : "", problems: [...new Set(problems)] };
+  }, [body, catalog, draft, editing, index]);
+  const pickTemplate = (next) => {
+    setDraft({ ...next, at: draft.at, code: draft.code });
+    setShowTemplates(false);
+  };
+  const pickSubject = (path) => {
+    if (!path || path === AI_CHECK || path.startsWith("~")) return;
+    if (path === EXT_SUBJECT) {
+      setDraft((current) => {
+        if (current.ext) return current;
+        const sendField = current.field.startsWith("$") ? current.field : field.path;
+        return withExtSubject({ ...current, ai: void 0 }, { name: autoExtName(sendField, body.sources), endpoint: "", audience: "", expect: "boolean", sendField });
+      });
+      return;
+    }
+    setDraft((current) => {
+      const legal = operatorsForKind(index.get(path)?.kind ?? "text");
+      const keepWhen = !current.ext && !current.ai && legal.includes(current.reject.when.op);
+      return {
+        ...current,
+        ext: void 0,
+        ai: void 0,
+        field: path,
+        reject: { ...current.reject, when: keepWhen ? { ...current.reject.when, field: path } : { field: path, op: legal[0] } },
+        human: { ...current.human, show: current.human.show.includes(path) ? current.human.show : [path] }
+      };
+    });
+  };
+  const enterAiCheck = () => {
+    setDraft((current) => {
+      if (current.ai) return current;
+      const sendField = current.field.startsWith("$") ? current.field : field.path;
+      return withAiSubject(current, { name: autoAiName(sendField, body.aiChecks), instructions: [""], sendField });
+    });
+  };
+  const setExt = (next) => setDraft((current) => withExtSubject(current, next));
+  const setAi = (next) => setDraft((current) => withAiSubject(current, next));
+  const setRejectRule = (rule) => {
+    if (rule.field === EXT_SUBJECT) {
+      pickSubject(EXT_SUBJECT);
+      return;
+    }
+    setDraft((current) => ({ ...current, field: rule.field, reject: { ...current.reject, when: rule } }));
+  };
+  const setConsequence = (consequence) => setDraft((current) => {
+    if (consequence !== "reject") return { ...current, consequence };
+    if (current.ext?.expect === "score") return { ...current, consequence };
+    if (current.ext || current.ai) return { ...current, consequence, reject: { ...current.reject, when: { field: current.field, op: "isTrue" } } };
+    const legal = operatorsForKind(index.get(current.field)?.kind ?? "text");
+    const when = legal.includes(current.reject.when.op) ? current.reject.when : { field: current.field, op: legal[0] };
+    return { ...current, consequence, reject: { ...current.reject, when } };
+  });
+  const setOnFail = (onFail) => setDraft((current) => ({ ...current, reject: { ...current.reject, onFail } }));
+  const grow = () => setDraft((current) => growDraft(current, field.path));
+  const addCheck = () => setDraft((current) => addGrownMember(current, field.path));
+  const removeCheck = (at) => setDraft((current) => removeGrownMember(current, at));
+  const setMemberRule = (at, rule) => setDraft(
+    (current) => current.grown ? { ...current, grown: { ...current.grown, members: current.grown.members.map((member, i) => i === at ? { kind: "check", rule } : member) } } : current
+  );
+  const setMemberAi = (at, memberAi) => setDraft(
+    (current) => current.grown ? { ...current, grown: { ...current.grown, members: current.grown.members.map((member, i) => i === at ? { kind: "ai", ai: memberAi } : member) } } : current
+  );
+  const toAiMember = (at) => setDraft((current) => {
+    const state = current.grown;
+    const member = state?.members[at];
+    if (!state || !member || member.kind === "ai") return current;
+    const sendField = member.rule.field.startsWith("$") ? member.rule.field : field.path;
+    const taken = state.members.flatMap((entry) => entry.kind === "ai" ? [entry.ai.name] : []);
+    const memberAi = { name: autoAiName(sendField, body.aiChecks, taken), instructions: [""], sendField };
+    return { ...current, grown: { ...state, members: state.members.map((entry, i) => i === at ? { kind: "ai", ai: memberAi } : entry) } };
+  });
+  const memberOptionsFor = (rule) => showOptions.some((option) => option.value === rule.field) ? showOptions : [...showOptions, { value: rule.field, label: fieldTitle(rule.field, { fields: index }) }];
+  const scoreExt = ext?.expect === "score";
+  const scoreFloorOn = scoreExt && (ext?.bands?.rejectBelow ?? 0) > 0;
+  const holdsForReview = draft.reject.onFail === "review";
+  const showOnFail = draft.consequence === "reject" && !scoreExt && (!!ai || !!grown || holdsForReview);
+  const needsMessage = draft.consequence === "reject" && (scoreExt ? scoreFloorOn : !holdsForReview);
+  const missingMessage = needsMessage && !draft.reject.reason.trim();
+  const extIncomplete = !!ext && !(/^https?:\/\//.test(ext.endpoint) && /^did:web:/.test(ext.audience));
+  const aiIncomplete = !!ai && ai.instructions.every((rule) => !rule.trim()) || !!grown?.members.some((member) => member.kind === "ai" && member.ai.instructions.every((rule) => !rule.trim()));
+  const canSave = preview.problems.length === 0 && !missingMessage && !extIncomplete && !aiIncomplete;
+  return /* @__PURE__ */ React11.createElement(
+    Modal2,
+    {
+      opened,
+      onClose,
+      title: editing ? "Change this rule" : `Add a rule to \u201C${field.title}\u201D`,
+      size: "xl",
+      radius: 14,
+      styles: { title: { fontWeight: 600 } },
+      scrollAreaComponent: ScrollArea3.Autosize
+    },
+    showTemplates ? /* @__PURE__ */ React11.createElement(Stack9, { gap: "sm" }, /* @__PURE__ */ React11.createElement(Text9, { size: "sm", c: "dimmed" }, "Pick one \u2014 you can change it afterwards."), templates.map((template) => /* @__PURE__ */ React11.createElement(Button7, { key: template.id, variant: "default", justify: "flex-start", size: "md", styles: chipButton, onClick: () => pickTemplate(template.draft) }, template.label)), templates.length === 0 && /* @__PURE__ */ React11.createElement(Text9, { size: "sm", c: "dimmed" }, "There are no quick rules for this kind of answer \u2014 build your own below."), /* @__PURE__ */ React11.createElement(Divider2, { label: "or", labelPosition: "center", color: HAIRLINE }), /* @__PURE__ */ React11.createElement(Button7, { variant: "subtle", styles: quietButton, leftSection: /* @__PURE__ */ React11.createElement(IconWand, { size: 16 }), onClick: () => setShowTemplates(false) }, "Custom rule")) : /* @__PURE__ */ React11.createElement(Stack9, { gap: "md" }, grown ? (
+      /* The checks box (owner 2026-08-03, v3): every check a sentence row
+         (or the inline AI lane). ALL of them must pass — no knob; any/
+         at-least belong to the rulebook's approval policy. Compiles to
+         ONE gate whose `when` is `{all: […]}`. */
+      /* @__PURE__ */ React11.createElement(Paper7, { p: "md", style: panelStyle }, /* @__PURE__ */ React11.createElement(Stack9, { gap: 8 }, /* @__PURE__ */ React11.createElement(Text9, { style: microLabelStyle }, GROWN_CHECKS_LABEL), grown.members.map((member, at) => /* @__PURE__ */ React11.createElement(Group10, { key: `${at}-${grown.members.length}`, gap: "xs", align: "flex-start", wrap: "nowrap" }, /* @__PURE__ */ React11.createElement(Box4, { style: { flex: 1 } }, member.kind === "check" ? /* @__PURE__ */ React11.createElement(
+        ConditionRow,
+        {
+          index,
+          options: memberOptionsFor(member.rule),
+          sources: draftBody.sources,
+          aiChecks: draftBody.aiChecks,
+          rule: member.rule,
+          onChange: (next) => setMemberRule(at, next),
+          lead: "",
+          extraOperators: [{ value: AI_CHECK, label: AI_CHECK_LANE_LABEL, Icon: IconRobot3 }],
+          onPickExtra: () => toAiMember(at)
+        }
+      ) : (
+        // The AI member: the question the AI looks at, then the
+        // same inline instructions (+ "what can the AI see")
+        // every AI lane has. No operator, no value — the check
+        // IS the sentence.
+        /* @__PURE__ */ React11.createElement(Stack9, { gap: 8 }, /* @__PURE__ */ React11.createElement(Group10, { gap: 8, align: "center", wrap: "wrap" }, /* @__PURE__ */ React11.createElement(Text9, { style: leadWordStyle }, GROUP_AI_MEMBER_LEAD), /* @__PURE__ */ React11.createElement(
+          BaseSelect,
+          {
+            w: 230,
+            styles: chipInput,
+            data: showOptions,
+            value: member.ai.sendField,
+            onChange: (path) => path && setMemberAi(at, { ...member.ai, sendField: path }),
+            searchable: showOptions.length > 6
+          }
+        )), /* @__PURE__ */ React11.createElement(
+          AiCheckInline,
+          {
+            ai: member.ai,
+            questionTitle: fieldTitle(member.ai.sendField, { fields: index }),
+            index,
+            onChange: (next) => setMemberAi(at, next)
+          }
+        ))
+      )), /* @__PURE__ */ React11.createElement(ActionIcon5, { variant: "subtle", color: "red", onClick: () => removeCheck(at), "aria-label": "Remove this check" }, /* @__PURE__ */ React11.createElement(IconTrash3, { size: 16 })))), /* @__PURE__ */ React11.createElement(Button7, { variant: "subtle", size: "compact-sm", styles: quietButton, style: { alignSelf: "flex-start" }, leftSection: /* @__PURE__ */ React11.createElement(IconPlus4, { size: 14 }), onClick: addCheck }, GROW_RULE_LABEL)))
+    ) : draft.consequence === "reject" && !ext && !ai ? /* @__PURE__ */ React11.createElement(
+      ConditionRow,
+      {
+        index,
+        options: subjectOptions,
+        rule: draft.reject.when,
+        onChange: setRejectRule,
+        lead: "If",
+        extraOperators: [{ value: AI_CHECK, label: AI_CHECK_LANE_LABEL, Icon: IconRobot3 }],
+        onPickExtra: enterAiCheck
+      }
+    ) : /* @__PURE__ */ React11.createElement(
+      BaseSelect,
+      {
+        label: "Which answer is this rule about?",
+        w: 300,
+        styles: chipInput,
+        data: subjectOptions,
+        value: ext ? EXT_SUBJECT : ai ? AI_CHECK : draft.field,
+        onChange: pickSubject,
+        searchable: subjectOptions.length > 6,
+        renderOption: ({ option }) => {
+          const OptionIcon = option.value === AI_CHECK ? IconRobot3 : option.value === EXT_SUBJECT ? IconWorld2 : void 0;
+          return /* @__PURE__ */ React11.createElement(Group10, { gap: 8, wrap: "nowrap" }, OptionIcon && icon(OptionIcon, 16), /* @__PURE__ */ React11.createElement(Text9, { size: "sm" }, option.label));
+        }
+      }
+    ), ext && /* @__PURE__ */ React11.createElement(ExternalCheckInline, { ext, questionTitle: index.get(ext.sendField)?.title ?? field.title, onChange: setExt }), ai && /* @__PURE__ */ React11.createElement(AiCheckInline, { ai, questionTitle: index.get(ai.sendField)?.title ?? field.title, index, onChange: setAi }), !ai && !grown && /* @__PURE__ */ React11.createElement(Stack9, { gap: 6 }, /* @__PURE__ */ React11.createElement(Text9, { style: leadWordStyle }, "Then\u2026"), /* @__PURE__ */ React11.createElement(Group10, { gap: "sm", align: "stretch", grow: true }, consequences.map((consequence) => /* @__PURE__ */ React11.createElement(
+      ConsequenceCard,
+      {
+        key: consequence.value,
+        active: draft.consequence === consequence.value,
+        tint: consequence.color,
+        iconNode: consequenceIcon(consequence.value, 22),
+        title: consequence.label,
+        description: consequence.hint,
+        onClick: () => setConsequence(consequence.value)
+      }
+    )))), /* @__PURE__ */ React11.createElement(Paper7, { p: "md", style: panelStyle }, draft.consequence === "reject" && /* @__PURE__ */ React11.createElement(Stack9, { gap: "xs" }, ext && !scoreExt && /* @__PURE__ */ React11.createElement(Text9, { size: "xs", c: "dimmed" }, "The outside service must confirm this answer \u2014 when it doesn\u2019t, the claim is rejected with your message."), scoreExt && /* @__PURE__ */ React11.createElement(Text9, { size: "xs", c: "dimmed" }, scoreFloorOn ? "The bands above decide: too low is turned down with your message, the middle waits for a person, high enough passes." : "The bands above decide: below the passing score the claim waits for a person \u2014 nothing is turned down automatically."), ai && /* @__PURE__ */ React11.createElement(Text9, { size: "xs", c: "dimmed" }, "The AI reads this answer against your rules and gives a yes or a no. When it says no\u2026"), showOnFail && /* @__PURE__ */ React11.createElement(Group10, { gap: "sm", align: "stretch", grow: true }, /* @__PURE__ */ React11.createElement(
+      ConsequenceCard,
+      {
+        active: !holdsForReview,
+        tint: "var(--mantine-color-red-6)",
+        iconNode: consequenceIcon("reject", 22),
+        title: "Reject the claim",
+        description: "The claim is turned down straight away, with your message.",
+        onClick: () => setOnFail("reject")
+      }
+    ), /* @__PURE__ */ React11.createElement(
+      ConsequenceCard,
+      {
+        active: holdsForReview,
+        tint: "var(--mantine-color-grape-6)",
+        iconNode: consequenceIcon("human", 22),
+        title: "A person checks it",
+        description: "The claim is held for a reviewer instead of being turned down.",
+        onClick: () => setOnFail("review")
+      }
+    )), needsMessage && /* @__PURE__ */ React11.createElement(
+      BaseTextInput,
+      {
+        label: scoreExt ? SCORE_MESSAGE_LABEL : "What should the claimant be told?",
+        styles: chipInputStyles(missingMessage),
+        placeholder: "e.g. Delivery date outside the collection period",
+        description: "They will read this, so say plainly what went wrong.",
+        error: missingMessage ? "Please write the message." : void 0,
+        value: draft.reject.reason,
+        onChange: (event) => setDraft({ ...draft, reject: { ...draft.reject, reason: event.currentTarget.value } })
+      }
+    )), draft.consequence === "human" && /* @__PURE__ */ React11.createElement(ReviewTaskEditor, { fieldOptions: showOptions, draft: draft.human, onChange: (human) => setDraft((current) => ({ ...current, human })) })), draft.appliesWhen ? /* @__PURE__ */ React11.createElement(Paper7, { p: "sm", style: panelStyle }, /* @__PURE__ */ React11.createElement(Group10, { gap: "xs", align: "flex-start", wrap: "nowrap" }, /* @__PURE__ */ React11.createElement(Box4, { style: { flex: 1 } }, /* @__PURE__ */ React11.createElement(
+      ConditionRow,
+      {
+        index,
+        options: showOptions,
+        sources: draftBody.sources,
+        aiChecks: draftBody.aiChecks,
+        rule: draft.appliesWhen,
+        onChange: (rule) => setDraft((current) => ({ ...current, appliesWhen: rule })),
+        lead: "Only check this if"
+      }
+    )), /* @__PURE__ */ React11.createElement(ActionIcon5, { variant: "subtle", color: "red", onClick: () => setDraft((current) => ({ ...current, appliesWhen: void 0 })), "aria-label": "Always check this rule" }, /* @__PURE__ */ React11.createElement(IconX3, { size: 16 })))) : /* @__PURE__ */ React11.createElement(
+      Button7,
+      {
+        variant: "subtle",
+        size: "compact-sm",
+        styles: quietButton,
+        style: { alignSelf: "flex-start" },
+        leftSection: /* @__PURE__ */ React11.createElement(IconPlus4, { size: 14 }),
+        onClick: () => setDraft((current) => ({ ...current, appliesWhen: { field: field.path, op: "present" } }))
+      },
+      "Only check this if\u2026"
+    ), draft.consequence === "reject" && !grown && !ext && /* @__PURE__ */ React11.createElement(Button7, { variant: "subtle", size: "compact-sm", styles: quietButton, style: { alignSelf: "flex-start" }, leftSection: /* @__PURE__ */ React11.createElement(IconPlus4, { size: 14 }), onClick: grow }, GROW_RULE_LABEL), preview.problems.length > 0 && /* @__PURE__ */ React11.createElement(Alert4, { color: "red", icon: /* @__PURE__ */ React11.createElement(IconAlertTriangle4, { size: 16 }), styles: actionAlertStyles }, /* @__PURE__ */ React11.createElement(Stack9, { gap: 2 }, preview.problems.map((problem) => /* @__PURE__ */ React11.createElement(Text9, { key: problem, size: "xs" }, problem)))), /* @__PURE__ */ React11.createElement(Stack9, { gap: 6 }, /* @__PURE__ */ React11.createElement(Text9, { style: microLabelStyle }, "This rule reads:"), /* @__PURE__ */ React11.createElement(RuleSentence, { text: preview.sentence })), /* @__PURE__ */ React11.createElement(Group10, { justify: "space-between" }, !editing ? /* @__PURE__ */ React11.createElement(Button7, { variant: "subtle", styles: quietButton, onClick: () => setShowTemplates(true) }, "Back to the quick rules") : /* @__PURE__ */ React11.createElement("span", null), /* @__PURE__ */ React11.createElement(Group10, { gap: "xs" }, /* @__PURE__ */ React11.createElement(Button7, { variant: "default", onClick: onClose }, "Cancel"), /* @__PURE__ */ React11.createElement(BasePrimaryButton, { disabled: !canSave, onClick: () => onSave(draft) }, editing ? "Save the change" : "Add this rule"))))
+  );
+};
+var ConsequenceCard = ({
+  active,
+  tint,
+  iconNode,
+  title,
+  description,
+  onClick
+}) => /* @__PURE__ */ React11.createElement(
+  Paper7,
+  {
+    p: "sm",
+    onClick,
+    role: "button",
+    tabIndex: 0,
+    onKeyDown: (event) => {
+      if (event.key === "Enter" || event.key === " ") {
+        event.preventDefault();
+        onClick();
+      }
+    },
+    style: {
+      flex: 1,
+      cursor: "pointer",
+      borderRadius: 10,
+      border: `1px solid ${active ? `color-mix(in srgb, ${tint} 55%, transparent)` : HAIRLINE}`,
+      background: active ? `color-mix(in srgb, ${tint} 10%, transparent)` : void 0,
+      transition: "border-color 120ms ease, background 120ms ease"
+    }
+  },
+  /* @__PURE__ */ React11.createElement(Stack9, { gap: 4 }, /* @__PURE__ */ React11.createElement(Group10, { gap: 6, align: "center", wrap: "nowrap" }, iconNode, /* @__PURE__ */ React11.createElement(Text9, { fw: 600, style: { fontSize: 13.5, color: active ? tint : void 0 } }, title)), /* @__PURE__ */ React11.createElement(Text9, { size: "xs", c: "dimmed" }, description))
+);
+
+// src/mantine/blocks/action/actionTypes/evalRubric/FrequencyRule.tsx
+import React12, { useEffect as useEffect3, useRef as useRef2, useState as useState6 } from "react";
+import { Group as Group11, Paper as Paper8, SegmentedControl as SegmentedControl5, Stack as Stack10, Switch, Text as Text10 } from "@mantine/core";
+
+// src/mantine/blocks/action/actionTypes/evalRubric/frequencyModel.ts
+var DEFAULT_ID = "claim-limit";
+var DEFAULT_MAX = 1;
+var DEFAULT_PER = "month";
+function deriveFrequency(body) {
+  const frequency = body.frequency;
+  return {
+    on: !!frequency,
+    max: frequency?.max ?? DEFAULT_MAX,
+    per: frequency?.per ?? DEFAULT_PER,
+    onBreach: frequency?.onBreach ?? "review"
+  };
+}
+function compileFrequency(body, state) {
+  if (!state.on) {
+    if (body.frequency === void 0) return body;
+    const { frequency: _off, ...rest } = body;
+    return rest;
+  }
+  const prior = body.frequency;
+  const onBreach = state.onBreach === (prior?.onBreach ?? "review") ? prior?.onBreach : state.onBreach === "review" ? void 0 : "reject";
+  return {
+    ...body,
+    frequency: {
+      "@type": "Frequency",
+      id: prior?.id ?? DEFAULT_ID,
+      ...prior?.label !== void 0 ? { label: prior.label } : {},
+      max: state.max,
+      per: state.per,
+      ...onBreach !== void 0 ? { onBreach } : {}
+    }
+  };
+}
+
+// src/mantine/blocks/action/actionTypes/evalRubric/FrequencyRule.tsx
+var FrequencyRule = ({ body, onChange, disabled }) => {
+  const [state, setState] = useState6(() => deriveFrequency(body));
+  const lastWrittenRef = useRef2(null);
+  const bodyJson = JSON.stringify(body);
+  useEffect3(() => {
+    if (bodyJson === lastWrittenRef.current) return;
+    setState(deriveFrequency(body));
+  }, [bodyJson]);
+  const commit = (next) => {
+    setState(next);
+    const compiled = compileFrequency(body, next);
+    const json = JSON.stringify(compiled);
+    lastWrittenRef.current = json;
+    if (json !== bodyJson) onChange(compiled);
+  };
+  return /* @__PURE__ */ React12.createElement(Paper8, { p: 18, style: cardStyle }, /* @__PURE__ */ React12.createElement(Stack10, { gap: "sm" }, /* @__PURE__ */ React12.createElement(Group11, { gap: "sm", justify: "space-between", align: "center", wrap: "wrap" }, /* @__PURE__ */ React12.createElement(Text10, { size: "sm", fw: 600 }, FREQUENCY_TITLE), /* @__PURE__ */ React12.createElement(Switch, { size: "sm", checked: state.on, onChange: (event) => commit({ ...state, on: event.currentTarget.checked }), disabled, "aria-label": FREQUENCY_TITLE })), state.on && /* @__PURE__ */ React12.createElement(Stack10, { gap: "sm" }, /* @__PURE__ */ React12.createElement(Text10, { size: "xs", c: "dimmed" }, FREQUENCY_EXPLAINER), /* @__PURE__ */ React12.createElement(Group11, { gap: 8, align: "center", wrap: "nowrap" }, /* @__PURE__ */ React12.createElement(Text10, { size: "sm", fw: 500 }, FREQUENCY_MAX_LEAD), /* @__PURE__ */ React12.createElement(
+    BaseNumberInput,
+    {
+      w: 80,
+      styles: chipInput,
+      min: 1,
+      allowDecimal: false,
+      value: state.max,
+      onChange: (next) => commit({ ...state, max: typeof next === "number" && next >= 1 ? Math.round(next) : 1 }),
+      disabled,
+      "aria-label": FREQUENCY_MAX_LEAD
+    }
+  ), /* @__PURE__ */ React12.createElement(Text10, { size: "sm", fw: 500 }, frequencyMaxNoun(state.max)), /* @__PURE__ */ React12.createElement(
+    BaseSelect,
+    {
+      w: 130,
+      styles: chipInput,
+      data: FREQUENCY_PERIOD_OPTIONS,
+      value: state.per,
+      onChange: (per) => commit({ ...state, per: per ?? state.per }),
+      disabled,
+      "aria-label": FREQUENCY_PERIOD_ARIA
+    }
+  )), /* @__PURE__ */ React12.createElement(Stack10, { gap: 6 }, /* @__PURE__ */ React12.createElement(Text10, { size: "sm", fw: 500 }, FREQUENCY_BREACH_LABEL), /* @__PURE__ */ React12.createElement(
+    SegmentedControl5,
+    {
+      styles: segmentedPill,
+      value: state.onBreach,
+      onChange: (onBreach) => commit({ ...state, onBreach }),
+      disabled,
+      data: FREQUENCY_BREACH_OPTIONS
+    }
+  ), state.onBreach === "review" && /* @__PURE__ */ React12.createElement(Text10, { size: "xs", c: "dimmed" }, FREQUENCY_BREACH_REVIEW_HINT)))));
+};
+
+// src/mantine/blocks/action/actionTypes/evalRubric/UniqueRule.tsx
+import React13, { useEffect as useEffect4, useMemo as useMemo5, useRef as useRef3, useState as useState7 } from "react";
+import { Alert as Alert5, Badge, Group as Group12, Paper as Paper9, Slider, Stack as Stack11, Switch as Switch2, Text as Text11 } from "@mantine/core";
+
+// src/mantine/blocks/action/actionTypes/evalRubric/uniqueModel.ts
+var DEFAULT_COUNT_PRIOR = ["approved", "pending_review", "queued"];
+var DEFAULT_REJECT_AT_PCT = 90;
+var DEFAULT_REVIEW_AT_PCT = 50;
+var DEFAULT_ID2 = "no-duplicates";
+var refOf = (entry) => typeof entry === "string" ? entry : entry.ref;
+var clampPct = (pct) => Math.min(Math.max(Math.round(pct) || 0, 0), 100);
+function withRejectAt(state, pct) {
+  const rejectAtPct = clampPct(pct);
+  return { ...state, rejectAtPct, reviewAtPct: Math.min(state.reviewAtPct, rejectAtPct) };
+}
+function withReviewAt(state, pct) {
+  const reviewAtPct = clampPct(pct);
+  return { ...state, reviewAtPct, rejectAtPct: Math.max(state.rejectAtPct, reviewAtPct) };
+}
+function withGranularity(state, ref, granularity) {
+  const { [ref]: _prior, ...rest } = state.granularity;
+  return { ...state, granularity: granularity ? { ...rest, [ref]: granularity } : rest };
+}
+function deriveUnique(body) {
+  const unique2 = body.unique;
+  const granularity = {};
+  for (const entry of unique2?.by ?? []) {
+    if (typeof entry !== "string" && entry.granularity) granularity[entry.ref] = entry.granularity;
+  }
+  return {
+    on: !!unique2,
+    by: (unique2?.by ?? []).map(refOf),
+    granularity,
+    // Absent bytes mean the engine's default — ON. Only an explicit `enabled: false` reads back
+    // as off, so a newly-enabled rule (no block yet) starts with the judge on, like the engine.
+    ai: unique2?.ai?.enabled !== false,
+    rejectAtPct: unique2?.thresholds ? Math.round(unique2.thresholds.rejectAtBps / 100) : DEFAULT_REJECT_AT_PCT,
+    reviewAtPct: unique2?.thresholds ? Math.round(unique2.thresholds.reviewAtBps / 100) : DEFAULT_REVIEW_AT_PCT
+  };
+}
+function compileUnique(body, state) {
+  if (!state.on) {
+    if (body.unique === void 0) return body;
+    const { unique: _off, ...rest } = body;
+    return rest;
+  }
+  const prior = body.unique;
+  const priorByRef = new Map((prior?.by ?? []).map((entry) => [refOf(entry), entry]));
+  const by = state.by.map((ref) => {
+    const authored = priorByRef.get(ref);
+    const authoredGranularity = authored !== void 0 && typeof authored !== "string" ? authored.granularity : void 0;
+    const picked = state.granularity[ref];
+    if (picked === authoredGranularity && authored !== void 0) return authored;
+    return picked ? { ref, granularity: picked } : ref;
+  });
+  const priorPairs = prior?.ai?.maxPairs;
+  const ai = state.ai === (prior?.ai?.enabled !== false) ? prior?.ai : state.ai ? priorPairs !== void 0 ? { enabled: true, maxPairs: priorPairs } : void 0 : { enabled: false, ...priorPairs !== void 0 ? { maxPairs: priorPairs } : {} };
+  return {
+    ...body,
+    unique: {
+      "@type": "Unique",
+      id: prior?.id ?? DEFAULT_ID2,
+      ...prior?.label !== void 0 ? { label: prior.label } : {},
+      ...by.length > 0 ? { by } : {},
+      countPrior: prior?.countPrior ?? DEFAULT_COUNT_PRIOR,
+      attachments: prior?.attachments ?? true,
+      ...ai !== void 0 ? { ai } : {},
+      thresholds: { rejectAtBps: state.rejectAtPct * 100, reviewAtBps: state.reviewAtPct * 100 }
+    }
+  };
+}
+
+// src/mantine/blocks/action/actionTypes/evalRubric/UniqueRule.tsx
+var CONTAINER_KINDS = /* @__PURE__ */ new Set(["keyed_choice", "cells", "rows", "keyed_text"]);
+var UniqueRule = ({ body, catalog, onChange, disabled }) => {
+  const [state, setState] = useState7(() => deriveUnique(body));
+  const lastWrittenRef = useRef3(null);
+  const bodyJson = JSON.stringify(body);
+  useEffect4(() => {
+    if (bodyJson === lastWrittenRef.current) return;
+    setState(deriveUnique(body));
+  }, [bodyJson]);
+  const commit = (next) => {
+    setState(next);
+    const compiled = compileUnique(body, next);
+    const json = JSON.stringify(compiled);
+    lastWrittenRef.current = json;
+    if (json !== bodyJson) onChange(compiled);
+  };
+  const keyFields = useMemo5(() => catalog.fields.filter((field) => !CONTAINER_KINDS.has(field.kind)), [catalog]);
+  const fieldByPath = useMemo5(() => new Map(keyFields.map((field) => [field.path, field])), [keyFields]);
+  const options = useMemo5(
+    () => [...keyFields.map((field) => ({ value: field.path, label: field.title })), ...state.by.filter((ref) => !fieldByPath.has(ref)).map((ref) => ({ value: ref, label: ref }))],
+    [keyFields, fieldByPath, state.by]
+  );
+  const pickedFileTitles = state.by.filter((ref) => fieldByPath.get(ref)?.kind === "file").map((ref) => fieldByPath.get(ref).title);
+  const pickedDateRefs = state.by.filter((ref) => fieldByPath.get(ref)?.kind === "date");
+  return /* @__PURE__ */ React13.createElement(Paper9, { p: 18, style: cardStyle }, /* @__PURE__ */ React13.createElement(Stack11, { gap: "sm" }, /* @__PURE__ */ React13.createElement(Group12, { gap: "sm", justify: "space-between", align: "center", wrap: "wrap" }, /* @__PURE__ */ React13.createElement(Text11, { size: "sm", fw: 600 }, UNIQUE_TITLE), /* @__PURE__ */ React13.createElement(Switch2, { size: "sm", checked: state.on, onChange: (event) => commit({ ...state, on: event.currentTarget.checked }), disabled, "aria-label": UNIQUE_TITLE })), state.on && /* @__PURE__ */ React13.createElement(Stack11, { gap: "sm" }, /* @__PURE__ */ React13.createElement(Text11, { size: "xs", c: "dimmed" }, UNIQUE_EXPLAINER), /* @__PURE__ */ React13.createElement(
+    BaseMultiSelect,
+    {
+      label: UNIQUE_BY_LABEL,
+      description: UNIQUE_BY_HINT,
+      placeholder: state.by.length === 0 ? UNIQUE_BY_PLACEHOLDER : void 0,
+      data: options,
+      value: state.by,
+      onChange: (by) => commit({ ...state, by }),
+      renderOption: ({ option }) => /* @__PURE__ */ React13.createElement(Group12, { gap: "xs", wrap: "nowrap", justify: "space-between", style: { flex: 1 } }, /* @__PURE__ */ React13.createElement(Text11, { size: "sm" }, option.label), fieldByPath.get(option.value)?.kind === "file" && /* @__PURE__ */ React13.createElement(Badge, { size: "xs", variant: "light", color: "neutralColor" }, UNIQUE_FILE_BADGE)),
+      styles: chipInput,
+      searchable: true,
+      disabled
+    }
+  ), pickedFileTitles.length > 0 && /* @__PURE__ */ React13.createElement(Text11, { size: "xs", c: "dimmed" }, pickedFileTitles.map((title) => `\u201C${title}\u201D`).join(", "), " \u2014 ", UNIQUE_FILE_BADGE, ": a re-saved or recompressed copy still matches."), pickedDateRefs.map((ref) => /* @__PURE__ */ React13.createElement(Group12, { key: ref, gap: 8, align: "center", wrap: "nowrap" }, /* @__PURE__ */ React13.createElement(Text11, { size: "xs", c: "dimmed" }, uniqueGranularityLead(fieldByPath.get(ref).title)), /* @__PURE__ */ React13.createElement(
+    BaseSelect,
+    {
+      w: 180,
+      styles: chipInput,
+      data: UNIQUE_GRANULARITY_OPTIONS,
+      value: state.granularity[ref] ?? "exact",
+      onChange: (value) => commit(withGranularity(state, ref, value && value !== "exact" ? value : void 0)),
+      disabled,
+      "aria-label": uniqueGranularityLead(fieldByPath.get(ref).title)
+    }
+  ))), /* @__PURE__ */ React13.createElement(
+    Switch2,
+    {
+      size: "sm",
+      label: UNIQUE_AI_LABEL,
+      description: state.ai ? UNIQUE_AI_ON_HINT : void 0,
+      checked: state.ai,
+      onChange: (event) => commit({ ...state, ai: event.currentTarget.checked }),
+      styles: { label: { fontWeight: 500 } },
+      disabled
+    }
+  ), !state.ai && /* @__PURE__ */ React13.createElement(Alert5, { color: "yellow", styles: actionAlertStyles, p: "xs" }, /* @__PURE__ */ React13.createElement(Text11, { size: "xs" }, UNIQUE_AI_OFF_WARNING)), /* @__PURE__ */ React13.createElement(Text11, { size: "xs", c: "dimmed" }, UNIQUE_PRICING_NOTE), /* @__PURE__ */ React13.createElement(Stack11, { gap: 4 }, /* @__PURE__ */ React13.createElement(Group12, { justify: "space-between" }, /* @__PURE__ */ React13.createElement(Text11, { size: "sm", fw: 500 }, UNIQUE_REJECT_LABEL), /* @__PURE__ */ React13.createElement(Text11, { size: "sm", c: "dimmed", ff: "monospace" }, "\u2265 ", state.rejectAtPct, "%")), /* @__PURE__ */ React13.createElement(
+    Slider,
+    {
+      min: 0,
+      max: 100,
+      step: 1,
+      value: state.rejectAtPct,
+      onChange: (pct) => setState(withRejectAt(state, pct)),
+      onChangeEnd: (pct) => commit(withRejectAt(state, pct)),
+      label: (pct) => `\u2265 ${pct}%`,
+      color: "accent.5",
+      disabled
+    }
+  )), /* @__PURE__ */ React13.createElement(Stack11, { gap: 4 }, /* @__PURE__ */ React13.createElement(Group12, { justify: "space-between" }, /* @__PURE__ */ React13.createElement(Text11, { size: "sm", fw: 500 }, UNIQUE_REVIEW_LABEL), /* @__PURE__ */ React13.createElement(Text11, { size: "sm", c: "dimmed", ff: "monospace" }, "\u2265 ", state.reviewAtPct, "%")), /* @__PURE__ */ React13.createElement(
+    Slider,
+    {
+      min: 0,
+      max: 100,
+      step: 1,
+      value: state.reviewAtPct,
+      onChange: (pct) => setState(withReviewAt(state, pct)),
+      onChangeEnd: (pct) => commit(withReviewAt(state, pct)),
+      label: (pct) => `\u2265 ${pct}%`,
+      color: "accent.5",
+      disabled
+    }
+  )))));
+};
+
+// src/mantine/blocks/action/actionTypes/evalRubric/useRubricDraft.ts
+import { useCallback, useEffect as useEffect5, useMemo as useMemo6, useRef as useRef4, useState as useState8 } from "react";
+function protocolDidOf(collection) {
+  const protocol = collection?.protocol;
+  const did = typeof protocol === "string" ? protocol : protocol?.id;
+  return String(did ?? "").trim();
+}
+function resourceFragment(resourceId) {
+  const raw = String(resourceId ?? "");
+  const hash = raw.indexOf("#");
+  return hash >= 0 ? raw.slice(hash) : "#vct";
+}
+var ENGINE_CHECK_DEBOUNCE_MS = 600;
+var RULES_UNCHECKED_MESSAGE = "Couldn\u2019t reach the rules service to check your rules \u2014 try again.";
+function useRubricDraft(inputs, onInputsChange, opts) {
+  const handlers = useBlocknoteHandlers();
+  const handlersRef = useRef4(handlers);
+  useEffect5(() => {
+    handlersRef.current = handlers;
+  }, [handlers]);
+  const mountedRef = useRef4(true);
+  useEffect5(
+    () => () => {
+      mountedRef.current = false;
+    },
+    []
+  );
+  const [local, setLocal] = useState8(() => parseEvalRubricInputs(inputs));
+  const localRef = useRef4(local);
+  const lastWrittenRef = useRef4(null);
+  useEffect5(() => {
+    if (inputs === lastWrittenRef.current) return;
+    const parsed = parseEvalRubricInputs(inputs);
+    localRef.current = parsed;
+    setLocal(parsed);
+  }, [inputs]);
+  const update = useCallback(
+    (patch) => {
+      const next = { ...localRef.current, ...patch };
+      localRef.current = next;
+      setLocal(next);
+      const json = serializeEvalRubricInputs(next);
+      lastWrittenRef.current = json;
+      onInputsChange(json);
+    },
+    [onInputsChange]
+  );
+  const setRubric = useCallback((next) => update({ rubric: next }), [update]);
+  const [collections, setCollections] = useState8([]);
+  const [loadingCollections, setLoadingCollections] = useState8(false);
+  const [collectionsError, setCollectionsError] = useState8(null);
+  const fetchCollections = useCallback(async () => {
+    const deedDid = localRef.current.deedDid.trim();
+    if (!deedDid) {
+      setCollectionsError("Please enter a DID first");
+      return;
+    }
+    update({ deedDid });
+    setLoadingCollections(true);
+    setCollectionsError(null);
+    try {
+      const response = await handlers.getClaimCollections(deedDid);
+      const fetched = response?.collections || [];
+      setCollections(fetched);
+      if (fetched.length === 0) setCollectionsError("No claim collections found for this DID");
+      if (localRef.current.collectionId && !fetched.some((collection) => collection.id === localRef.current.collectionId)) {
+        update({ collectionId: "" });
+      }
+    } catch (error) {
+      setCollections([]);
+      setCollectionsError(error instanceof Error ? error.message : "Failed to fetch claim collections");
+    } finally {
+      setLoadingCollections(false);
+    }
+  }, [handlers, update]);
+  const [formLoading, setFormLoading] = useState8(false);
+  const [formError, setFormError] = useState8(null);
+  const fetchGenRef = useRef4(0);
+  const [prefilledFromChain, setPrefilledFromChain] = useState8(false);
+  const loadForm = useCallback(
+    async (deedDid, collectionId, collection) => {
+      if (!deedDid || !collectionId) return;
+      const generation = ++fetchGenRef.current;
+      setFormLoading(true);
+      setFormError(null);
+      try {
+        const result = await handlers.getDeedSurveyTemplate(deedDid, collectionId);
+        if (generation !== fetchGenRef.current) return;
+        const surveyTemplate = result?.surveyTemplate;
+        if (!surveyTemplate) {
+          setFormError("This collection has no claim form yet. Add the form first \u2014 the rules are written against its questions.");
+          update({ claimSchemaSnapshot: null });
+          return;
+        }
+        const catalog = extractRubricFieldCatalog(surveyTemplate, result?.proof ?? "");
+        if (catalog.fields.length === 0) {
+          setFormError("None of this form\u2019s questions can be checked automatically. Rules need questions with answers \u2014 text, numbers, dates, choices, files.");
+        }
+        const title = collection ? getCollectionDisplayName(collection) : "";
+        const resource = resourceFragment(result?.resourceId);
+        const current = localRef.current.rubric;
+        const protocol = protocolDidOf(collection) || current?.claimSchema.protocol || "";
+        if (!protocol) {
+          setFormError("This collection isn't linked to a protocol yet \u2014 the rules can't attach. Link a protocol to the collection, then reopen.");
+          update({ claimSchemaSnapshot: catalog });
+          return;
+        }
+        let base = current;
+        if (!base && typeof handlers.getDeedRubric === "function") {
+          const published = await handlers.getDeedRubric(deedDid).catch((error) => {
+            console.warn("[eval.rubric] step prefill \u2014 could not read the published rules", error);
+            return null;
+          });
+          if (generation !== fetchGenRef.current) return;
+          const candidate = parsePublishedRubric(published?.rubric);
+          const boundTo = String(candidate?.claimSchema?.protocol || "");
+          const fetched = candidate && boundTo === protocol ? candidate : null;
+          base = localRef.current.rubric ?? fetched;
+          setPrefilledFromChain(!localRef.current.rubric && !!fetched);
+          console.info(
+            "[eval.rubric] step prefill \u2014",
+            fetched ? `opened on the rules already published for protocol ${protocol}` : candidate ? `skipped: the published rules are bound to protocol ${boundTo}, not ${protocol}` : "no rules published yet; starting fresh"
+          );
+        }
+        update({
+          claimSchemaSnapshot: catalog,
+          // Keep the rules the author already wrote (or the published ones just
+          // read); re-pin them to the form that is actually loaded. `bindForm`
+          // NEVER replaces an existing rubric with a blank one — only fills the
+          // binding — so reopening cannot wipe work.
+          rubric: bindForm(base, protocol, resource, catalog.proof, title)
+        });
+      } catch (error) {
+        if (generation !== fetchGenRef.current) return;
+        setFormError(error instanceof Error ? error.message : "Failed to load the claim form");
+      } finally {
+        if (generation === fetchGenRef.current) setFormLoading(false);
+      }
+    },
+    [handlers, update]
+  );
+  const pickCollection = useCallback(
+    (collectionId) => {
+      const collection = collections.find((entry) => entry.id === collectionId);
+      update({ collectionId });
+      void loadForm(localRef.current.deedDid.trim(), collectionId, collection);
+    },
+    [collections, loadForm, update]
+  );
+  const reloadForm = useCallback(() => {
+    const collection = collections.find((entry) => entry.id === localRef.current.collectionId);
+    void loadForm(localRef.current.deedDid.trim(), localRef.current.collectionId, collection);
+  }, [collections, loadForm]);
+  useEffect5(() => {
+    if (local.deedDid.trim() && local.collectionId && collections.length === 0 && !loadingCollections) void fetchCollections();
+  }, [local.deedDid, local.collectionId]);
+  useEffect5(() => {
+    if (!local.deedDid.trim() || !local.collectionId || local.claimSchemaSnapshot || formLoading) return;
+    const collection = collections.find((entry) => entry.id === local.collectionId);
+    if (!collection && !localRef.current.rubric?.claimSchema.protocol) return;
+    void loadForm(local.deedDid.trim(), local.collectionId, collection);
+  }, [local.deedDid, local.collectionId, local.claimSchemaSnapshot, collections]);
+  const [driftChecking, setDriftChecking] = useState8(false);
+  const [driftProblems, setDriftProblems] = useState8(null);
+  const [driftError, setDriftError] = useState8(null);
+  const checkFormDrift = useCallback(async () => {
+    const { deedDid, collectionId, rubric, claimSchemaSnapshot } = localRef.current;
+    const entity = deedDid.trim();
+    if (!entity || !collectionId || !rubric || !claimSchemaSnapshot) return;
+    setDriftChecking(true);
+    setDriftError(null);
+    try {
+      const result = await handlersRef.current.getDeedSurveyTemplate(entity, collectionId);
+      if (!mountedRef.current) return;
+      const surveyTemplate = result?.surveyTemplate;
+      if (!surveyTemplate) {
+        setDriftProblems(null);
+        setDriftError("This collection has no claim form any more, so these rules have nothing to judge.");
+        return;
+      }
+      const live = extractRubricFieldCatalog(surveyTemplate, result?.proof ?? claimSchemaSnapshot.proof);
+      setDriftProblems(validateRubric(rubric, live, claimSchemaSnapshot).filter((d) => d.code === "RUB_SCHEMA_DRIFT"));
+    } catch (error) {
+      if (!mountedRef.current) return;
+      setDriftProblems(null);
+      setDriftError(error instanceof Error ? error.message : "Could not check these rules against the claim form");
+    } finally {
+      if (mountedRef.current) setDriftChecking(false);
+    }
+  }, []);
+  const [shapeProblems, setShapeProblems] = useState8([]);
+  const [checking, setChecking] = useState8(() => !!local.rubric && !!local.claimSchemaSnapshot);
+  const [checkError, setCheckError] = useState8(null);
+  useEffect5(() => {
+    let mounted = true;
+    const body = local.rubric;
+    if (!body || !local.claimSchemaSnapshot) {
+      setShapeProblems([]);
+      setChecking(false);
+      setCheckError(null);
+      return;
+    }
+    setChecking(true);
+    const timer = setTimeout(() => {
+      void (async () => {
+        const host = handlersRef.current;
+        try {
+          const engineUrl = local.evalEngineUrl.trim() || void 0;
+          if (host.previewRubric && local.collectionId) {
+            const ask = (interactive) => host.previewRubric?.({
+              collectionId: local.collectionId,
+              rubric: body,
+              evalEngineUrl: engineUrl,
+              interactive,
+              ...opts?.settings ? { settings: opts.settings } : {}
+            }).catch((error) => {
+              console.warn("[eval.rubric] engine check failed; using the local shape gate", error);
+              return null;
+            }) ?? Promise.resolve(null);
+            let preview = await ask(false);
+            if (!mounted) return;
+            if (!preview) {
+              console.info("[eval.rubric] no cached signer \u2014 asking for the pin once so rules can be checked");
+              preview = await ask(true);
+              if (!mounted) return;
+            }
+            if (preview) {
+              setShapeProblems(preview.problems);
+              setCheckError(null);
+              return;
+            }
+            console.info("[eval.rubric] engine check unavailable; using the local shape gate");
+          } else if (!host.previewRubric) {
+            console.info("[eval.rubric] host has no previewRubric handler; using the local shape gate");
+          }
+          const shape = await validateRubricShape(body, host.getRubricSchema, engineUrl);
+          if (!mounted) return;
+          if (shape.ok) {
+            setShapeProblems(shape.problems);
+            setCheckError(null);
+          } else {
+            console.warn("[eval.rubric] the rules could not be checked at all", shape.reason);
+            setShapeProblems([]);
+            setCheckError(RULES_UNCHECKED_MESSAGE);
+          }
+        } catch (error) {
+          console.warn("[eval.rubric] the rules check threw", error);
+          if (mounted) {
+            setShapeProblems([]);
+            setCheckError(RULES_UNCHECKED_MESSAGE);
+          }
+        } finally {
+          if (mounted) setChecking(false);
+        }
+      })();
+    }, ENGINE_CHECK_DEBOUNCE_MS);
+    return () => {
+      mounted = false;
+      clearTimeout(timer);
+    };
+  }, [local.rubric, local.claimSchemaSnapshot, local.collectionId, local.evalEngineUrl, opts?.settings]);
+  const index = useMemo6(() => indexCatalog(local.claimSchemaSnapshot), [local.claimSchemaSnapshot]);
+  const rules = useMemo6(() => listRules(local.rubric), [local.rubric]);
+  const linked = useMemo6(() => listLinkedRules(local.rubric), [local.rubric]);
+  const diagnostics = useMemo6(
+    () => local.rubric && local.claimSchemaSnapshot ? [...validateRubric(local.rubric, local.claimSchemaSnapshot), ...shapeProblems] : [],
+    [local.rubric, local.claimSchemaSnapshot, shapeProblems]
+  );
+  const errors = useMemo6(() => diagnostics.filter((diagnostic) => diagnostic.severity === "error"), [diagnostics]);
+  return {
+    local,
+    update,
+    setRubric,
+    collections,
+    loadingCollections,
+    collectionsError,
+    fetchCollections,
+    pickCollection,
+    formLoading,
+    formError,
+    reloadForm,
+    prefilledFromChain,
+    checking,
+    checkError,
+    checkFormDrift,
+    driftChecking,
+    driftProblems,
+    driftError,
+    index,
+    diagnostics,
+    errors,
+    rules,
+    linked
+  };
+}
+
+// src/mantine/blocks/action/actionTypes/evalEngine/EvalEngineFlowDetail.tsx
+var LOG = "[eval.engine]";
+function truncate(value) {
+  if (!value) return "";
+  return value.length <= 16 ? value : `${value.slice(0, 10)}\u2026${value.slice(-4)}`;
+}
+function failureMessageOf(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string" && error) return error;
+  if (error && typeof error === "object" && "message" in error && error.message) {
+    return String(error.message);
+  }
+  try {
+    const serialized = JSON.stringify(error);
+    if (serialized && serialized !== "{}" && serialized !== "null" && serialized !== "undefined") return serialized;
+  } catch {
+  }
+  return "Failed to enable the Evaluation Engine";
+}
+var EvalEngineFlowDetail = ({
+  inputs,
+  editor,
+  block,
+  runtime,
+  updateRuntime,
+  isDisabled,
+  provideSigningHandler,
+  unlockSigning,
+  registerRuntimeInputs,
+  executeAction,
+  activePendingInvocation,
+  onPendingInvocationCompleted
+}) => {
+  const handlers = useBlocknoteHandlers();
+  const handlersRef = useRef5(handlers);
+  useEffect6(() => {
+    handlersRef.current = handlers;
+  }, [handlers]);
+  const parsed = useMemo7(() => parseEvalEngineInputs(inputs), [inputs]);
+  const editorDocument = editor?.document || [];
+  const resolveOpts = useMemo7(() => ({ yRuntime: editor?._yRuntime }), [editor?._yRuntime]);
+  const templateDeedDid = useMemo7(() => resolveReferences(parsed.deedDid || "", editorDocument, resolveOpts).trim(), [parsed.deedDid, editorDocument, resolveOpts]);
+  const templateCollectionId = useMemo7(() => resolveReferences(parsed.collectionId || "", editorDocument, resolveOpts).trim(), [parsed.collectionId, editorDocument, resolveOpts]);
+  const pendingPayload = useMemo7(() => {
+    if (!activePendingInvocation) return void 0;
+    return {
+      ...activePendingInvocation.payload || {},
+      ...activePendingInvocation.refSnapshots || {}
+    };
+  }, [activePendingInvocation]);
+  const deedDid = useMemo7(() => String(pendingPayload?.entity || "").trim() || templateDeedDid, [pendingPayload, templateDeedDid]);
+  const collectionId = useMemo7(() => String(pendingPayload?.collectionId || "").trim() || templateCollectionId, [pendingPayload, templateCollectionId]);
+  const [adminAddress, setAdminAddress] = useState9("");
+  useEffect6(() => {
+    let mounted = true;
+    if (!deedDid) {
+      setAdminAddress("");
+      return;
+    }
+    (async () => {
+      try {
+        const addr = await handlersRef.current.getAdminAccountAddress(deedDid);
+        if (mounted) setAdminAddress(String(addr || "").trim());
+      } catch {
+        if (mounted) setAdminAddress("");
+      }
+    })();
+    return () => {
+      mounted = false;
+    };
+  }, [deedDid]);
+  const writeInputs = useCallback2(
+    (rubricSubsetJson) => {
+      const blockId = String(block?.id || "");
+      if (!editor || !blockId) return;
+      const current = (editor.document || []).find((candidate) => candidate?.id === blockId) || block;
+      let subset = {};
+      try {
+        subset = JSON.parse(rubricSubsetJson);
+      } catch {
+        return;
+      }
+      let full = {};
+      try {
+        full = JSON.parse(String(current?.props?.inputs || "{}"));
+      } catch {
+      }
+      const changed = Object.keys(subset).some((key) => {
+        const before = full[key];
+        const after = subset[key];
+        if (before === after) return false;
+        if ((before ?? "") === "" && (after ?? "") === "") return false;
+        return JSON.stringify(before ?? null) !== JSON.stringify(after ?? null);
+      });
+      if (!changed) return;
+      editor.updateBlock(blockId, { props: { inputs: JSON.stringify({ ...full, ...subset }) } });
+    },
+    [editor, block]
+  );
+  const intendedSettings = useMemo7(
+    () => ({ allowAiChecks: parsed.allowAiChecks, allowImageChecks: parsed.allowImageChecks, allowChainEvaluation: parsed.allowChainEvaluation }),
+    [parsed.allowAiChecks, parsed.allowImageChecks, parsed.allowChainEvaluation]
+  );
+  const draft = useRubricDraft(inputs, writeInputs, { settings: intendedSettings });
+  const draftLocalRef = useRef5(draft.local);
+  draftLocalRef.current = draft.local;
+  useEffect6(() => {
+    if (!pendingPayload) return;
+    if (!collectionId && !deedDid) return;
+    if (draft.local.collectionId === collectionId && draft.local.deedDid === deedDid) return;
+    console.log(`${LOG} listener mode \u2014 pinning the event's collection into the block`, { collectionId });
+    draft.update({ collectionId, deedDid });
+  }, [pendingPayload, collectionId, deedDid]);
+  const { card, live } = useEnginePricing({ collectionId, evalEngineUrl: parsed.evalEngineUrl });
+  const payLine = ownerPaysLine(live);
+  const output = runtime.output || void 0;
+  const registrationId = String(output?.registrationId || "").trim();
+  const rubricId = String(output?.rubricId || "").trim();
+  const resourceTxHash = String(output?.resourceTxHash || "").trim();
+  const isRunning = runtime.state === "running";
+  const isFailed = runtime.state === "failed";
+  const errorMessage = runtime.error?.message || null;
+  const isCompletedWithProof = runtime.state === "completed" && !!registrationId && !!rubricId && !!resourceTxHash;
+  const isStale = runtime.state === "completed" && !isCompletedWithProof;
+  const catalog = draft.local.claimSchemaSnapshot;
+  const body = draft.local.rubric;
+  const allDiagnostics = useMemo7(() => draft.driftProblems ? [...draft.diagnostics, ...draft.driftProblems] : draft.diagnostics, [draft.diagnostics, draft.driftProblems]);
+  const allErrors = useMemo7(() => allDiagnostics.filter((diagnostic) => diagnostic.severity === "error"), [allDiagnostics]);
+  const configMissing = !collectionId || !deedDid;
+  const adminMissing = !configMissing && !adminAddress && parsed.allowChainEvaluation;
+  const emailMissing = !configMissing && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(parsed.notifyEmail || "").trim());
+  const policyMemberCount = useMemo7(() => {
+    const shape = policyShapeOf(body ?? null);
+    return shape.kind === "policy" ? shape.members.length : 0;
+  }, [body]);
+  const checkCount = draft.rules.length + draft.linked.length + policyMemberCount;
+  const rulesMissing = !body || checkCount === 0;
+  const formBroken = !configMissing && !draft.formLoading && (!!draft.formError || !catalog);
+  const rulesUnchecked = !configMissing && !rulesMissing && (draft.checking || !!draft.checkError);
+  const driftUnchecked = !configMissing && !rulesMissing && (draft.driftChecking || !!draft.driftError || draft.driftProblems === null);
+  const blocked = configMissing || adminMissing || emailMissing || draft.formLoading || formBroken || rulesMissing || rulesUnchecked || driftUnchecked || allErrors.length > 0;
+  const driftCheckedRef = useRef5(false);
+  useEffect6(() => {
+    if (driftCheckedRef.current) return;
+    if (configMissing || isCompletedWithProof) return;
+    if (draft.formLoading || !catalog || !body) return;
+    driftCheckedRef.current = true;
+    console.log(`${LOG} checking the rules against the claim form as it is NOW`);
+    void draft.checkFormDrift();
+  }, [configMissing, isCompletedWithProof, catalog, body, draft.formLoading, draft.checkFormDrift]);
+  useEffect6(() => {
+    if (!registerRuntimeInputs) return;
+    registerRuntimeInputs({ collectionId, deedDid, adminAddress: adminAddress || void 0 });
+  }, [registerRuntimeInputs, collectionId, deedDid, adminAddress]);
+  useEffect6(() => {
+    unlockSigning?.(!isDisabled && !isRunning && !isCompletedWithProof && !blocked);
+  }, [unlockSigning, isDisabled, isRunning, isCompletedWithProof, blocked]);
+  const execute = useCallback2(async () => {
+    if (isDisabled || isRunning || isCompletedWithProof) return;
+    if (!executeAction) {
+      updateRuntime({ state: "failed", error: { message: "Shared action executor is unavailable", at: Date.now() } });
+      return;
+    }
+    if (configMissing) {
+      updateRuntime({ state: "failed", error: { message: "No collection configured. Set one in template mode or wire a Claim Collection trigger.", at: Date.now() } });
+      return;
+    }
+    if (blocked) {
+      updateRuntime({ state: "failed", error: { message: "Finish the rules and fix the problems above before signing.", at: Date.now() } });
+      return;
+    }
+    const runtimeInputs = {
+      collectionId,
+      deedDid,
+      adminAddress: adminAddress || void 0,
+      // The rules ride ALONG WITH the run, not only in the block's saved blob.
+      // Runtime inputs are merged LAST over `block.props.inputs`
+      // (`actionExecutor.ts`'s `buildActionRunInputs`), and the block object that
+      // blob is read from is the caller's own copy — `findBlock` returns it as
+      // given, without re-resolving the id against `editor.document`, so it can
+      // be one write behind the edit that was just made. The blob itself is
+      // written correctly (`runInputs.test.tsx` pins that); this is what
+      // guarantees the run is judged on the SAME rules the signing gate armed
+      // on. Read through the ref so the freshest edit wins over whatever this
+      // callback closed over; `blocked` above already refuses to run without
+      // rules, so past the gate these are never absent.
+      rubric: draftLocalRef.current.rubric ?? void 0,
+      claimSchemaSnapshot: draftLocalRef.current.claimSchemaSnapshot ?? void 0
+    };
+    const pendingInvocationId = activePendingInvocation?.id;
+    console.log(`${LOG} execute \u2192`, { collectionId, rules: draft.rules.length, listener: !!pendingInvocationId });
+    try {
+      const outcome = await executeAction(pendingInvocationId ? { runtimeInputs, pendingInvocationId } : { runtimeInputs });
+      if (!outcome.success) throw new Error(outcome.error || "Enabling the Evaluation Engine failed");
+      const payload = outcome.output;
+      if (!String(payload?.registrationId || "").trim() || !String(payload?.rubricId || "").trim() || !String(payload?.resourceTxHash || "").trim()) {
+        throw new Error("The run reported success without full proof (enrolment, published rules, and the transaction that anchors them). Check the [eval.engine] handler logs.");
+      }
+      console.log(`${LOG} execute success`, { registrationId: payload.registrationId, rubricId: payload.rubricId });
+      if (pendingInvocationId) onPendingInvocationCompleted?.(pendingInvocationId);
+    } catch (error) {
+      console.error(`${LOG} execute failed`, error);
+      updateRuntime({ state: "failed", error: { message: failureMessageOf(error), at: Date.now() } });
+    }
+  }, [
+    isDisabled,
+    isRunning,
+    isCompletedWithProof,
+    executeAction,
+    configMissing,
+    blocked,
+    collectionId,
+    deedDid,
+    adminAddress,
+    draft.rules.length,
+    activePendingInvocation,
+    updateRuntime,
+    onPendingInvocationCompleted
+  ]);
+  useEffect6(() => {
+    if (!provideSigningHandler) return;
+    provideSigningHandler(execute);
+  }, [provideSigningHandler, execute]);
+  const handleReset = useCallback2(() => {
+    updateRuntime({ state: "idle", error: void 0, output: {} });
+  }, [updateRuntime]);
+  const [editorState, setEditorState] = useState9(null);
+  const [linkedEditorState, setLinkedEditorState] = useState9(null);
+  const cardPaths = useMemo7(() => new Set((catalog?.fields ?? []).map((field) => field.path)), [catalog]);
+  const byCard = useMemo7(() => rulesByCard(body, cardPaths), [body, cardPaths]);
+  const linkedByCard = useMemo7(() => {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const entry of draft.linked) {
+      const key = rootPath(entry.checkedField, cardPaths);
+      const bucket = grouped.get(key);
+      if (bucket) bucket.push(entry);
+      else grouped.set(key, [entry]);
+    }
+    return grouped;
+  }, [draft.linked, cardPaths]);
+  const guardPaths = useMemo7(
+    () => [...draft.index.values()].filter((entry) => (entry.kind === "text" || entry.kind === "number" || entry.kind === "choice") && !entry.path.includes("[*]")).map((entry) => entry.path),
+    [draft.index]
+  );
+  const problemsByCard = useMemo7(() => {
+    const grouped = /* @__PURE__ */ new Map();
+    const loose = [];
+    for (const diagnostic of allDiagnostics) {
+      const cardPath = cardForDiagnosticPath(body, diagnostic.path, cardPaths);
+      if (!cardPath) {
+        loose.push(diagnostic);
+        continue;
+      }
+      const bucket = grouped.get(cardPath);
+      if (bucket) bucket.push(diagnostic);
+      else grouped.set(cardPath, [diagnostic]);
+    }
+    return { grouped, loose };
+  }, [body, allDiagnostics, cardPaths]);
+  const orphanRules = useMemo7(() => draft.rules.filter((rule) => !rule.fieldPath || !cardPaths.has(rootPath(rule.fieldPath, cardPaths))), [draft.rules, cardPaths]);
+  const orphanLinked = useMemo7(() => draft.linked.filter((entry) => !cardPaths.has(rootPath(entry.checkedField, cardPaths))), [draft.linked, cardPaths]);
+  const cardRefs = useRef5(/* @__PURE__ */ new Map());
+  const scrollToCard = useCallback2((cardPath) => {
+    cardRefs.current.get(cardPath)?.scrollIntoView({ behavior: "smooth", block: "center" });
+  }, []);
+  const problemList = useMemo7(() => {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const diagnostic of allErrors) {
+      const cardPath = cardForDiagnosticPath(body, diagnostic.path, cardPaths);
+      const text = diagnostic.code === "RUB_SCHEMA" && diagnostic.message.startsWith(SCHEMA_UNKNOWN_KEY_PREFIX) ? diagnostic.message : diagnostic.code === "RUB_SCHEMA" ? schemaProblemText(diagnostic.path, !!cardPath) : problemText(diagnostic);
+      const target = cardPath && cardPaths.has(cardPath) ? cardPath : void 0;
+      const key = `${text}@@${target ?? ""}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push({ text, card: target });
+    }
+    return out;
+  }, [allErrors, body, cardPaths]);
+  const saveRule = (rule) => {
+    if (!body) return;
+    const subjectTitle = draft.index.get(rule.ext?.sendField ?? rule.ai?.sendField ?? rule.field)?.title;
+    draft.setRubric(pruneDanglingSources(applyDraft(body, rule, editorState?.editing, subjectTitle)));
+    setEditorState(null);
+  };
+  const deleteRule = (rule) => {
+    if (!body) return;
+    draft.setRubric(pruneDanglingSources(removeRule(body, rule)));
+  };
+  const saveLinked = (linkedDraft) => {
+    if (!body) return;
+    draft.setRubric(pruneDanglingSources(applyLinkedDraft(body, linkedDraft, draft.index)));
+    setLinkedEditorState(null);
+  };
+  const deleteLinked = (entry) => {
+    if (!body) return;
+    draft.setRubric(pruneDanglingSources(removeGatesAt(body, entry.indices)));
+  };
+  const editingLocked = isDisabled || isRunning;
+  const title = block?.props?.title || "Evaluation Engine";
+  const description = block?.props?.description || "";
+  return /* @__PURE__ */ React14.createElement(Stack12, { gap: "md" }, /* @__PURE__ */ React14.createElement(Stack12, { gap: 2 }, /* @__PURE__ */ React14.createElement(Text12, { fw: 600 }, title), description && /* @__PURE__ */ React14.createElement(Text12, { size: "sm", c: "dimmed" }, description)), configMissing && /* @__PURE__ */ React14.createElement(Alert6, { color: "yellow", styles: actionAlertStyles }, "Configure the DID and claim collection in template mode (or wire a Claim Collection trigger) before running this action."), !configMissing && !isCompletedWithProof && /* @__PURE__ */ React14.createElement(React14.Fragment, null, draft.formLoading && /* @__PURE__ */ React14.createElement(Group13, { gap: "xs" }, /* @__PURE__ */ React14.createElement(Loader3, { size: "xs" }), /* @__PURE__ */ React14.createElement(Text12, { size: "sm", c: "dimmed" }, "Loading the claim form\u2026")), draft.prefilledFromChain && /* @__PURE__ */ React14.createElement(Alert6, { color: "neutralColor", variant: "light", icon: /* @__PURE__ */ React14.createElement(IconInfoCircle, { size: 16 }), styles: actionAlertStyles }, /* @__PURE__ */ React14.createElement(Text12, { size: "xs" }, "These are the rules already published for this claim form, loaded from chain. Edit them and sign to replace what is live.")), draft.collectionsError && /* @__PURE__ */ React14.createElement(Alert6, { color: "red", icon: /* @__PURE__ */ React14.createElement(IconAlertCircle, { size: 16 }), styles: actionAlertStyles }, /* @__PURE__ */ React14.createElement(Text12, { size: "sm" }, draft.collectionsError)), !draft.formLoading && draft.formError && /* @__PURE__ */ React14.createElement(BaseAlert, { errMsg: draft.formError, onRetry: draft.reloadForm }), !draft.formLoading && !draft.formError && catalog && body && /* @__PURE__ */ React14.createElement(React14.Fragment, null, /* @__PURE__ */ React14.createElement(Group13, { justify: "space-between", align: "center" }, /* @__PURE__ */ React14.createElement(Text12, { size: "sm", fw: 600 }, body.title ? `Form: \u201C${body.title}\u201D` : "The claim form", " \xB7 ", catalog.fields.length, " question", catalog.fields.length === 1 ? "" : "s")), /* @__PURE__ */ React14.createElement(Stack12, { gap: 14 }, catalog.fields.map((field) => /* @__PURE__ */ React14.createElement(
+    "div",
+    {
+      key: field.path,
+      ref: (el) => {
+        if (el) cardRefs.current.set(field.path, el);
+        else cardRefs.current.delete(field.path);
+      }
+    },
+    /* @__PURE__ */ React14.createElement(
+      RuleCard,
+      {
+        field,
+        rules: byCard.get(field.path) ?? [],
+        linked: linkedByCard.get(field.path) ?? [],
+        problems: problemsByCard.grouped.get(field.path) ?? [],
+        index: draft.index,
+        aiChecks: body.aiChecks,
+        onAdd: () => setEditorState({ field }),
+        onEdit: (rule) => setEditorState({ field, editing: rule }),
+        onDelete: deleteRule,
+        onAddLinked: guardPaths.some((path) => path !== field.path) ? () => setLinkedEditorState({ checkedField: field.path }) : void 0,
+        onEditLinked: (entry) => setLinkedEditorState({ checkedField: entry.checkedField, editing: entry }),
+        onDeleteLinked: deleteLinked,
+        disabled: editingLocked
+      }
+    )
+  ))), (orphanRules.length > 0 || orphanLinked.length > 0) && /* @__PURE__ */ React14.createElement(Paper10, { p: 18, style: { ...cardStyle, borderColor: "var(--mantine-color-red-6)" } }, /* @__PURE__ */ React14.createElement(Stack12, { gap: "sm" }, /* @__PURE__ */ React14.createElement(Text12, { size: "sm", fw: 600 }, "Rules with no question"), /* @__PURE__ */ React14.createElement(Text12, { size: "xs", c: "dimmed" }, "These are about answers the form no longer asks for. Delete them, or put the questions back on the form."), orphanRules.map((rule) => /* @__PURE__ */ React14.createElement(Group13, { key: rule.code, gap: "sm", align: "flex-start", wrap: "nowrap" }, /* @__PURE__ */ React14.createElement(Box5, { mt: 2, style: consequencePillStyle(CONSEQUENCES.find((entry) => entry.value === rule.consequence)?.color ?? SLATE) }, consequenceIcon(rule.consequence, 15)), /* @__PURE__ */ React14.createElement(Box5, { style: { flex: 1 } }, /* @__PURE__ */ React14.createElement(RuleSentence, { text: describeRule(rule, { fields: draft.index, aiChecks: body.aiChecks }) })), /* @__PURE__ */ React14.createElement(ActionIcon6, { variant: "subtle", color: "red", onClick: () => deleteRule(rule), disabled: editingLocked, "aria-label": "Delete this rule" }, /* @__PURE__ */ React14.createElement(IconTrash4, { size: 16 })))), orphanLinked.map((entry) => /* @__PURE__ */ React14.createElement(Group13, { key: entry.elseCase.code, gap: "sm", align: "flex-start", wrap: "nowrap" }, /* @__PURE__ */ React14.createElement(Box5, { mt: 2, style: consequencePillStyle(entry.onFail === "review" ? "var(--mantine-color-grape-6)" : "var(--mantine-color-red-6)") }, consequenceIcon(entry.onFail === "review" ? "human" : "reject", 15)), /* @__PURE__ */ React14.createElement(Box5, { style: { flex: 1 } }, /* @__PURE__ */ React14.createElement(RuleSentence, { text: describeLinked(linkedSentenceOf(entry), { fields: draft.index }) })), /* @__PURE__ */ React14.createElement(ActionIcon6, { variant: "subtle", color: "red", onClick: () => deleteLinked(entry), disabled: editingLocked, "aria-label": "Delete this rule" }, /* @__PURE__ */ React14.createElement(IconTrash4, { size: 16 })))))), allErrors.filter((problem) => problem.code === "RUB_AI_CHECKS_DISABLED").map((problem) => /* @__PURE__ */ React14.createElement(Alert6, { key: problem.code, color: "red", icon: /* @__PURE__ */ React14.createElement(IconAlertTriangle5, { size: 16 }), title: "AI checks are turned off for this collection", styles: actionAlertStyles }, /* @__PURE__ */ React14.createElement(Text12, { size: "xs" }, problem.message))), /* @__PURE__ */ React14.createElement(ApprovalPolicy, { body, index: draft.index, checkCount, onChange: draft.setRubric, disabled: editingLocked }), /* @__PURE__ */ React14.createElement(UniqueRule, { body, catalog, onChange: draft.setRubric, disabled: editingLocked }), /* @__PURE__ */ React14.createElement(FrequencyRule, { body, onChange: draft.setRubric, disabled: editingLocked }), problemsByCard.loose.filter((problem) => problem.severity === "warning" && problem.code !== "RUB_WEIGHT_IGNORED").map((problem) => /* @__PURE__ */ React14.createElement(Alert6, { key: `${problem.code}${problem.path}`, color: "yellow", icon: /* @__PURE__ */ React14.createElement(IconInfoCircle, { size: 16 }), styles: actionAlertStyles }, /* @__PURE__ */ React14.createElement(Text12, { size: "xs" }, problemText(problem)))), /* @__PURE__ */ React14.createElement(Paper10, { p: "md", style: cardStyle }, /* @__PURE__ */ React14.createElement(Stack12, { gap: "xs" }, /* @__PURE__ */ React14.createElement(Group13, { justify: "space-between" }, /* @__PURE__ */ React14.createElement(Group13, { gap: "xs" }, allErrors.length === 0 ? /* @__PURE__ */ React14.createElement(IconCheck2, { size: 16, color: "var(--mantine-color-green-6)" }) : /* @__PURE__ */ React14.createElement(IconAlertTriangle5, { size: 16, color: "var(--mantine-color-red-6)" }), /* @__PURE__ */ React14.createElement(Text12, { size: "sm" }, describeTally(draft.rules, { linked: draft.linked.length, policyMembers: policyMemberCount }))), /* @__PURE__ */ React14.createElement(Text12, { size: "sm", fw: 600, c: allErrors.length > 0 ? "red" : "dimmed" }, allErrors.length > 0 ? `${allErrors.length} problem${allErrors.length === 1 ? "" : "s"} left to fix` : "Ready to sign")), problemList.length > 0 && /* @__PURE__ */ React14.createElement(Stack12, { gap: 6 }, problemList.map((problem, at) => /* @__PURE__ */ React14.createElement(Group13, { key: `${problem.text}${at}`, gap: "xs", wrap: "nowrap", align: "flex-start" }, /* @__PURE__ */ React14.createElement(Box5, { mt: 3, style: { flexShrink: 0 } }, /* @__PURE__ */ React14.createElement(IconAlertTriangle5, { size: 14, color: "var(--mantine-color-red-6)" })), /* @__PURE__ */ React14.createElement(Text12, { size: "xs", style: { flex: 1 } }, problem.text), problem.card && /* @__PURE__ */ React14.createElement(Button8, { size: "compact-xs", variant: "subtle", styles: quietButton, rightSection: /* @__PURE__ */ React14.createElement(IconArrowRight, { size: 12 }), onClick: () => scrollToCard(problem.card) }, "Take me there")))))), /* @__PURE__ */ React14.createElement(AdvancedPanel, { body }), editorState && /* @__PURE__ */ React14.createElement(
+    RuleEditor,
+    {
+      opened: true,
+      onClose: () => setEditorState(null),
+      body,
+      catalog,
+      index: draft.index,
+      field: editorState.field,
+      editing: editorState.editing,
+      onSave: saveRule
+    }
+  ), linkedEditorState && /* @__PURE__ */ React14.createElement(
+    LinkedRuleEditor,
+    {
+      opened: true,
+      onClose: () => setLinkedEditorState(null),
+      body,
+      catalog,
+      index: draft.index,
+      initialChecked: linkedEditorState.checkedField,
+      editing: linkedEditorState.editing,
+      onSave: saveLinked
+    }
+  ))), !configMissing && !isCompletedWithProof && !rulesMissing && (draft.checking || draft.driftChecking) && /* @__PURE__ */ React14.createElement(Group13, { gap: "xs" }, /* @__PURE__ */ React14.createElement(Loader3, { size: "xs" }), /* @__PURE__ */ React14.createElement(Text12, { size: "sm", c: "dimmed" }, draft.driftChecking ? "Checking your rules against the claim form\u2026" : "Checking your rules\u2026")), !configMissing && !isCompletedWithProof && !rulesMissing && !draft.checking && !draft.driftChecking && (draft.checkError || draft.driftError) && /* @__PURE__ */ React14.createElement(Alert6, { color: "red", icon: /* @__PURE__ */ React14.createElement(IconAlertCircle, { size: 16 }), styles: actionAlertStyles }, /* @__PURE__ */ React14.createElement(Stack12, { gap: "xs" }, draft.driftError && /* @__PURE__ */ React14.createElement(Text12, { size: "sm" }, draft.driftError), draft.checkError && /* @__PURE__ */ React14.createElement(Text12, { size: "sm" }, draft.checkError), /* @__PURE__ */ React14.createElement(Text12, { size: "xs", c: "dimmed" }, "Your rules can't be signed off until they have been checked \u2014 enrolling is not something that can be taken back."))), !configMissing && !isCompletedWithProof && /* @__PURE__ */ React14.createElement(Alert6, { color: "neutralColor", variant: "light", icon: /* @__PURE__ */ React14.createElement(IconInfoCircle, { size: 16 }), styles: actionAlertStyles }, /* @__PURE__ */ React14.createElement(Stack12, { gap: 6 }, /* @__PURE__ */ React14.createElement(Text12, { size: "xs" }, "Slide to sign to turn the Evaluation Engine on for this collection. One signature does both: it authorizes the engine to read this collection's claims on your behalf, and publishes the rules above so every new claim is judged by them."), /* @__PURE__ */ React14.createElement(Stack12, { gap: 2 }, /* @__PURE__ */ React14.createElement(Text12, { size: "xs" }, "Checking a claim \u2014 ", usdLabel(card.baseUsd), " / claim"), parsed.allowAiChecks && /* @__PURE__ */ React14.createElement(Text12, { size: "xs" }, "AI checks \u2014 ", usdLabel(card.aiRuleUsd), " per AI rule / claim"), parsed.allowAiChecks && parsed.allowImageChecks && /* @__PURE__ */ React14.createElement(Text12, { size: "xs" }, "Fake-photo detection \u2014 ", usdLabel(card.photoUsd), " / photo"), payLine && /* @__PURE__ */ React14.createElement(Text12, { size: "xs", fw: 500 }, payLine), /* @__PURE__ */ React14.createElement(Text12, { size: "xs" }, parsed.allowChainEvaluation ? "Decisions are submitted on chain \u2014 this releases payment" : "Decisions are recorded only \u2014 nothing is submitted on chain"), parsed.allowChainEvaluation && /* @__PURE__ */ React14.createElement(Text12, { size: "xs" }, "Engine may approve payouts up to ", formatCapCoins(parsed.evaluateMaxAmount, "no custom amount"), " / claim"), /* @__PURE__ */ React14.createElement(Text12, { size: "xs" }, describeTally(draft.rules, { policyMembers: policyMemberCount })), /* @__PURE__ */ React14.createElement(Text12, { size: "xs", c: "dimmed" }, billingNote(card, live))), /* @__PURE__ */ React14.createElement(Group13, { gap: "xs" }, /* @__PURE__ */ React14.createElement(Badge2, { size: "xs", variant: "light", color: "neutralColor" }, "Collection ", truncate(collectionId))))), !configMissing && !isCompletedWithProof && rulesMissing && !draft.formLoading && !draft.formError && /* @__PURE__ */ React14.createElement(Text12, { size: "xs", c: "dimmed" }, "Add at least one rule before signing \u2014 until then this engine would have nothing to judge by, and every claim would wait for a person."), emailMissing && !isCompletedWithProof && /* @__PURE__ */ React14.createElement(Text12, { size: "xs", c: "dimmed" }, "Add a billing email in template mode before signing \u2014 failed payments and paused evaluations are announced there."), adminMissing && !isCompletedWithProof && /* @__PURE__ */ React14.createElement(Text12, { size: "xs", c: "dimmed" }, "Waiting for the entity's admin account\u2026 (it signs the grant that lets the engine submit decisions on chain)"), isStale && /* @__PURE__ */ React14.createElement(Alert6, { icon: /* @__PURE__ */ React14.createElement(IconAlertCircle, { size: 16 }), color: "yellow", title: "Inconsistent State", styles: actionAlertStyles }, /* @__PURE__ */ React14.createElement(Stack12, { gap: "xs" }, /* @__PURE__ */ React14.createElement(Text12, { size: "sm" }, "This block was marked completed but did not record all of the enrolment, the published rules, and the transaction that anchors them. Reset and re-run."), /* @__PURE__ */ React14.createElement(Button8, { variant: "outline", size: "xs", onClick: handleReset }, "Reset"))), isFailed && /* @__PURE__ */ React14.createElement(Alert6, { icon: /* @__PURE__ */ React14.createElement(IconAlertCircle, { size: 16 }), color: "red", title: "The Evaluation Engine was not enabled", styles: actionAlertStyles }, /* @__PURE__ */ React14.createElement(Stack12, { gap: "xs" }, errorMessage && /* @__PURE__ */ React14.createElement(Text12, { size: "sm" }, errorMessage), /* @__PURE__ */ React14.createElement(Button8, { variant: "outline", size: "xs", onClick: handleReset }, "Reset"))), isCompletedWithProof && /* @__PURE__ */ React14.createElement(Alert6, { icon: /* @__PURE__ */ React14.createElement(IconCheck2, { size: 16 }), color: "green", styles: actionAlertStyles }, "Evaluation Engine enabled \u2014 this collection is enrolled and your rules are published (rules ", truncate(rubricId), "). Every new claim is judged by them."), isDisabled && /* @__PURE__ */ React14.createElement(Text12, { size: "xs", c: "dimmed" }, "This block is currently disabled."));
+};
+var EvalEngineFlowDetail_default = EvalEngineFlowDetail;
+export {
+  EvalEngineFlowDetail,
+  EvalEngineFlowDetail_default as default
+};
+//# sourceMappingURL=EvalEngineFlowDetail-PUFRNO4U.js.map