@ixo/editor 6.33.0 → 6.34.0

package/dist/chunk-NIXT2SBH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/lib/actionRegistry/actions/evalRegister/description.ts","../src/core/lib/actionRegistry/actions/evalRubric/schemaGate.ts","../src/core/lib/actionRegistry/actions/evalRubric/types.ts","../src/core/lib/actionRegistry/actions/evalRubric/pathGrammar.ts","../src/core/lib/actionRegistry/actions/evalRubric/fieldCatalog.ts","../src/core/lib/actionRegistry/actions/evalRubric/expression.ts","../src/core/lib/actionRegistry/actions/evalRubric/validate.ts"],"sourcesContent":["/**\n * The three plain-language questions the owner answers about their collection, and the ONE\n * opaque `description` string they compose into for the engine's register call\n * (`POST /v1/collections/register`).\n *\n * Why it exists: the engine's duplicate-claim judge is shown two claim submissions and asked\n * \"is this the same real-world event, sent twice?\" — with no idea what the collection collects.\n * On a repetitive-task collection (daily waste sorting, where the same worker legitimately\n * submits again tomorrow) it reads honest work as a duplicate. This string is the missing\n * context. The ENGINE never parses it: it stores one opaque string, caps it at 1000 characters,\n * and hands it to the judge — so all the structure lives here, in the owner's words.\n *\n * ABSENT and EMPTY are different to the engine, exactly like `displayName`/`notifyEmail`:\n * omitting the field means \"no opinion\" and leaves any stored description alone, while an\n * explicit `''` ERASES it. So this returns `undefined` — never `''` — when nothing was answered,\n * and `runEvalRegister` only puts the key on the payload when it is defined.\n *\n * The 1000-char ceiling is enforced by capping the INPUTS (300 + a canned sentence + 100 ≈ 500\n * worst case), never by truncating the output — an owner's words are not silently mangled.\n */\n\n/** Q2 — \"Can the same person do this again tomorrow?\" */\nexport type RepeatSubmissions = 'normal' | 'sometimes' | 'once';\n\n/**\n * The one choice, its owner-facing label, and the sentence the judge reads. Keeping all three\n * in one table is what stops the UI wording and the composed sentence drifting apart.\n */\nexport const REPEAT_SUBMISSIONS_OPTIONS: { value: RepeatSubmissions; label: string; sentence: string }[] = [\n  { value: 'normal', label: \"Yes, that's normal\", sentence: 'Repeat submissions from the same person are expected and normal here.' },\n  { value: 'sometimes', label: 'Sometimes', sentence: 'Repeat submissions from the same person happen but are not the norm.' },\n  { value: 'once', label: 'No, only once ever', sentence: 'Each claim should be a distinct one-off; repeat submissions are unusual here.' },\n];\n\n/** Q3 — \"When the same person does it again, what is different?\" */\nexport type DifferentWhen = 'date' | 'amount' | 'place' | 'kind' | 'photos';\n\n/**\n * The tick list: `label` is what the owner ticks, `phrase` is how the line reads. This array's\n * ORDER is the order the composed line lists them in — never the order they were ticked.\n */\nexport const DIFFERENT_WHEN_OPTIONS: { value: DifferentWhen; label: string; phrase: string }[] = [\n  { value: 'date', label: 'The date', phrase: 'the date' },\n  { value: 'amount', label: 'The amount or weight', phrase: 'the amount or weight' },\n  { value: 'place', label: 'The place', phrase: 'the place' },\n  { value: 'kind', label: 'The type or kind', phrase: 'the type or kind' },\n  { value: 'photos', label: 'The photos', phrase: 'the photos' },\n];\n\n/** Per-answer caps. The UI enforces the same numbers, so the 1000-char total is unreachable by construction. */\nexport const WHAT_IS_COLLECTED_MAX = 300;\nexport const DIFFERENT_WHEN_OTHER_MAX = 100;\n\n/** The owner's raw answers, stored as-is on the block — the composed string is one-way. */\nexport interface CollectionDescriptionAnswers {\n  /** Q1 — \"What do people do to make a claim here?\" */\n  whatIsCollected?: string;\n  /** Q2 — required once anything else is answered (enforced in the config UI, never a hard run gate). */\n  repeatSubmissions?: RepeatSubmissions;\n  /** Q3 — the ticked options. */\n  differentWhen?: DifferentWhen[];\n  /** Q3 — the free-text \"Other\", appended last, in the owner's own words. */\n  differentWhenOther?: string;\n}\n\n/** Keep only the options this version knows, in the table's order — a hand-edited blob cannot inject a phrase. */\nexport function normalizeDifferentWhen(value: unknown): DifferentWhen[] {\n  if (!Array.isArray(value)) return [];\n  return DIFFERENT_WHEN_OPTIONS.filter((option) => value.includes(option.value)).map((option) => option.value);\n}\n\n/** `undefined` unless the blob carries one of the three known choices. */\nexport function normalizeRepeatSubmissions(value: unknown): RepeatSubmissions | undefined {\n  return REPEAT_SUBMISSIONS_OPTIONS.find((option) => option.value === value)?.value;\n}\n\n/**\n * Three lines, newline-separated, and ONLY the ones that have an answer — never a line with an\n * empty value, never the literal \"undefined\". Nothing answered at all returns `undefined`, which\n * is what keeps a re-register from erasing a description the owner set earlier.\n */\nexport function composeCollectionDescription(answers: CollectionDescriptionAnswers): string | undefined {\n  const lines: string[] = [];\n\n  const whatIsCollected = String(answers.whatIsCollected || '')\n    .trim()\n    .slice(0, WHAT_IS_COLLECTED_MAX);\n  if (whatIsCollected) lines.push(`What is collected: ${whatIsCollected}`);\n\n  const repeat = REPEAT_SUBMISSIONS_OPTIONS.find((option) => option.value === answers.repeatSubmissions);\n  if (repeat) lines.push(`Repeat submissions: ${repeat.sentence}`);\n\n  // Ticked options first, in table order; the owner's \"Other\" wording last and verbatim.\n  const ticked = normalizeDifferentWhen(answers.differentWhen);\n  const differences = DIFFERENT_WHEN_OPTIONS.filter((option) => ticked.includes(option.value)).map((option) => option.phrase);\n  const other = String(answers.differentWhenOther || '')\n    .trim()\n    .slice(0, DIFFERENT_WHEN_OTHER_MAX);\n  if (other) differences.push(other);\n  if (differences.length) lines.push(`Two claims are different when: any of these differ — ${differences.join(', ')}.`);\n\n  return lines.length ? lines.join('\\n') : undefined;\n}\n","// The `.js` extension is required so the bundled ESM resolves under Node (ajv is\n// plain CJS with no `exports` map — the extensionless subpath is unresolvable).\nimport Ajv2020 from 'ajv/dist/2020.js';\nimport type { ErrorObject, ValidateFunction } from 'ajv/dist/2020.js';\nimport { buildRubricEnvelope, type RubricBody } from './types';\nimport type { RubricDiagnostic } from './validate';\n\n/**\n * The Ajv backstop — rubric-spec §A.12. The editor's own binder (`validate.ts`)\n * is deliberately looser than the engine's schema; this closes the gap so the\n * editor can never publish a SHAPE the engine will then reject.\n *\n * The engine serves the one true JSON Schema (draft 2020-12) at\n * `GET /v1/rubric-schema`, and that schema is ENVELOPE-level\n * (`{@context, type, rubric}`) — so we validate the built ENVELOPE, which is the\n * exact structure that gets uploaded (§A.2/§B.2 step 3), not just the body.\n *\n * Fail closed: if the schema cannot be fetched or compiled, the caller must NOT\n * proceed as if the rubric were valid — `validateRubricShape` returns\n * `{ ok: false }` and the publish path blocks with a plain-language \"try again\".\n *\n * The compiled validator is cached for the session (the schema rarely changes\n * and the engine sets an ETag, so a re-fetch is cheap). A failed fetch is never\n * cached, so a later retry re-fetches.\n */\n\n/** How the host hands us the served schema — a public GET of `/v1/rubric-schema`. */\nexport type RubricSchemaFetcher = (evalEngineUrl?: string) => Promise<object>;\n\nexport type RubricShapeResult =\n  /** Schema fetched + compiled; `problems` lists shape violations (translated, never raw Ajv text). */\n  | { ok: true; problems: RubricDiagnostic[] }\n  /** Schema could not be fetched or compiled — fail closed; do not treat the rubric as valid. */\n  | { ok: false; reason: string };\n\nlet compiledValidator: ValidateFunction | null = null;\n\n/** Test seam: drop the cached validator so a fresh fetch + compile runs. */\nexport function resetRubricSchemaCache(): void {\n  compiledValidator = null;\n}\n\nasync function getValidator(fetchSchema: RubricSchemaFetcher, evalEngineUrl?: string): Promise<ValidateFunction> {\n  if (compiledValidator) return compiledValidator;\n  const schema = await fetchSchema(evalEngineUrl);\n  if (!schema || typeof schema !== 'object') throw new Error('the rules service returned no schema');\n  // draft-2020-12 is the target the engine generates at, so the matching Ajv\n  // dialect is required. The schema uses no `format` keywords, so ajv-formats is\n  // not needed. `strict:false` keeps a future benign keyword from throwing.\n  const validate = new Ajv2020({ allErrors: true, strict: false }).compile(schema);\n  compiledValidator = validate;\n  return validate;\n}\n\n/**\n * Validate a rubric body's SHAPE against the engine's served schema. Returns the\n * translated problems (never raw Ajv error text — §B.5 rule 1), or `{ ok:false }`\n * when the schema is unreachable/uncompilable (fail closed).\n *\n * Self-heal: when the ONLY failures are unknown keys (`additionalProperties`),\n * the likely culprit is not the rubric but the session-cached validator — a\n * schema compiled before the engine learned a newer vocabulary (e.g. `sources`).\n * The cache is dropped, the schema refetched ONCE (the engine serves it\n * `no-cache`, so the refetch gets fresh bytes), and the rubric revalidated — a\n * stale schema fixes itself instead of telling the author their rules are wrong.\n */\nexport async function validateRubricShape(body: RubricBody, fetchSchema: RubricSchemaFetcher | undefined, evalEngineUrl?: string): Promise<RubricShapeResult> {\n  if (typeof fetchSchema !== 'function') return { ok: false, reason: 'The rules service is not available to check these rules.' };\n  let validate: ValidateFunction;\n  try {\n    validate = await getValidator(fetchSchema, evalEngineUrl);\n  } catch (error) {\n    return { ok: false, reason: error instanceof Error ? error.message : String(error) };\n  }\n  if (validate(buildRubricEnvelope(body))) return { ok: true, problems: [] };\n  let errors = validate.errors ?? [];\n  if (errors.length > 0 && errors.every((error) => error.keyword === 'additionalProperties')) {\n    resetRubricSchemaCache();\n    try {\n      validate = await getValidator(fetchSchema, evalEngineUrl);\n    } catch (error) {\n      return { ok: false, reason: error instanceof Error ? error.message : String(error) };\n    }\n    if (validate(buildRubricEnvelope(body))) return { ok: true, problems: [] };\n    errors = validate.errors ?? [];\n  }\n  return { ok: true, problems: translateAjvErrors(errors) };\n}\n\n// The words the author reads come from the RUB_SCHEMA entry in phrases'\n// DIAGNOSTIC_TEXT (keyed by `code`), never from `message` — so raw Ajv text can\n// never reach the screen (§B.5 rule 1). `message` carries a plain-language\n// summary for logs and the run() throw only. The ONE exception is an\n// unknown-key diagnostic, which composes its own display words (below): the\n// section fallbacks would misdiagnose a stale rules service as a rubric problem.\nexport const SCHEMA_PROBLEM_MESSAGE = 'This rule has a setting the rules service will not accept.';\n\n/**\n * The display prefix of an unknown-key diagnostic — the marker the summary bar\n * matches to show these words verbatim instead of the section fallback (which\n * would blame the rubric for a key the service is too old to know).\n */\nexport const SCHEMA_UNKNOWN_KEY_PREFIX = 'The rules service doesn’t recognise';\n\nfunction unknownKeyMessage(key: string): string {\n  return `${SCHEMA_UNKNOWN_KEY_PREFIX} '${key}' — the rules service may be out of date; refresh and try again.`;\n}\n\n/**\n * Collapse Ajv's errors — a discriminated union blows up into one error per\n * branch — into ONE `RUB_SCHEMA` diagnostic per offending SECTION. The served\n * schema is envelope-level, so every instancePath begins `/rubric`; strip it,\n * then reduce to the stable key the UI maps by (`sectionPath`).\n *\n * The `path` is load-bearing downstream: the summary reads it (via\n * `schemaProblemText`) to say WHAT is actually wrong in plain words instead of\n * blaming the form link for everything (§A.11) — a binding error names the\n * binding, an unknown reviewer setting names the reviewer, and so on. An\n * `additionalProperties` failure additionally NAMES the rejected key in its\n * message (deduped per key), so a vocabulary mismatch reads as what it is.\n */\nfunction translateAjvErrors(errors: ErrorObject[]): RubricDiagnostic[] {\n  const seen = new Set<string>();\n  const diagnostics: RubricDiagnostic[] = [];\n  for (const error of errors) {\n    const path = sectionPath(bodyPath(error.instancePath));\n    const unknownKey = error.keyword === 'additionalProperties' ? String((error.params as { additionalProperty?: unknown })?.additionalProperty ?? '') : '';\n    const dedupeKey = `${path}@@${unknownKey}`;\n    if (seen.has(dedupeKey)) continue;\n    seen.add(dedupeKey);\n    diagnostics.push({ code: 'RUB_SCHEMA', severity: 'error', message: unknownKey ? unknownKeyMessage(unknownKey) : SCHEMA_PROBLEM_MESSAGE, path });\n  }\n  return diagnostics;\n}\n\n/** `/rubric/gates/0/when/op` → `/gates/0/when/op`; the top-level `/rubric` → ''. */\nfunction bodyPath(instancePath: string): string {\n  if (instancePath === '/rubric') return '';\n  return instancePath.startsWith('/rubric/') ? instancePath.slice('/rubric'.length) : instancePath;\n}\n\nconst RULE_ROOT = /^(\\/gates\\/\\d+|\\/scoring\\/criteria\\/\\d+|\\/review\\/tasks\\/\\d+|\\/derived\\/\\d+)/;\n\n/**\n * The smallest stable key the UI maps a shape error by, two jobs in one:\n *  - a RULE-level path (`/gates/N`, `/scoring/criteria/N`, `/review/tasks/N`,\n *    `/derived/N`) collapses to that rule root, so a discriminated-union\n *    explosion becomes ONE diagnostic on ONE card;\n *  - every other error keeps the SECTION it lives in — the form binding\n *    (`/claimSchema/proof|protocol|resource`), the reviewer assignment\n *    (`/review/assignTo`), the scoring thresholds (`/scoring`), the settlement,\n *    the named values — so `schemaProblemText` can name it specifically rather\n *    than fall back to \"the form link needs refreshing\" for unrelated problems.\n */\nfunction sectionPath(path: string): string {\n  const rule = RULE_ROOT.exec(path);\n  if (rule) return rule[1];\n  if (path.startsWith('/claimSchema')) {\n    if (path.startsWith('/claimSchema/proof')) return '/claimSchema/proof';\n    if (path.startsWith('/claimSchema/protocol')) return '/claimSchema/protocol';\n    if (path.startsWith('/claimSchema/resource')) return '/claimSchema/resource';\n    return '/claimSchema';\n  }\n  if (path.startsWith('/review/assignTo')) return '/review/assignTo';\n  if (path.startsWith('/review')) return '/review';\n  if (path.startsWith('/scoring')) return '/scoring';\n  if (path.startsWith('/settlement')) return '/settlement';\n  if (path.startsWith('/derived')) return '/derived';\n  if (path.startsWith('/unique')) return '/unique';\n  if (path.startsWith('/frequency')) return '/frequency';\n  return '';\n}\n","/**\n * Types for the `qi/eval.rubric` block (\"Claim Approval Rules\") — rubric-spec\n * Part A. A rubric is a strict JSON-LD rulebook over a claim form's answers,\n * published as the `#rub` LinkedResource on the protocol entity. These types\n * model exactly the spec's vocabulary — closed unions, no extensions; unknown\n * keys are rejected by the engine-served JSON Schema (§A.11), not here.\n * See the module comment in `./evalRubric` for the publish flow.\n */\n\nimport { matrixUserIdToDid } from '../../../matrixDm';\n\n// ---------------------------------------------------------------------------\n// Closed enums (§A.3 kinds, §A.4 operators, §A.8 methods, §A.9 verdicts)\n// ---------------------------------------------------------------------------\n\n/** The complete v1 assertion vocabulary (§A.4). Legality per kind is enforced by `validateRubric`. */\nexport type RubricOperator =\n  | 'present'\n  | 'empty'\n  | '=='\n  | '!='\n  | '>'\n  | '>='\n  | '<'\n  | '<='\n  | 'between'\n  | 'approx'\n  | 'in'\n  | 'notIn'\n  | 'matches'\n  | 'startsWith'\n  | 'endsWith'\n  | 'lengthBetween'\n  | 'contains'\n  | 'containsAll'\n  | 'containsAny'\n  | 'subsetOf'\n  | 'countBetween'\n  | 'isTrue'\n  | 'isFalse'\n  | 'before'\n  | 'after'\n  | 'withinWindow'\n  | 'withinDays'\n  | 'notInFuture'\n  | 'mediaTypeIn'\n  | 'maxSizeMB'\n  | 'withinBoundary'\n  | 'withinRadius';\n\n/**\n * Field kind, derived from the SurveyJS question `type` AND `inputType`/`cellType`\n * (§A.3 table). The kind decides which operators and scoring nodes are legal.\n * Container kinds (`keyed_choice`/`cells`/`rows`/`keyed_text`) address the whole\n * question; their expanded leaf paths carry the scalar kinds rules compare with.\n */\nexport type RubricFieldKind = 'text' | 'number' | 'date' | 'choice' | 'multichoice' | 'boolean' | 'file' | 'signature' | 'keyed_choice' | 'cells' | 'rows' | 'keyed_text' | 'geo';\n\n/**\n * What a FAILING gate may declare (§A.6) — the only §A.9 class vocabulary the\n * DOCUMENT names. Narrower than §A.9's seven verdict classes on purpose:\n * `supported` and `partial` are approvals, and a must-pass check that failed\n * cannot mint one. The verdicts and actions an evaluation produces are the\n * engine's output, not part of the rubric, so they are not modelled here.\n */\nexport type RubricGateClass = 'refuted' | 'invalid_evidence' | 'out_of_authority' | 'insufficient_evidence' | 'requires_human_review';\n\n/**\n * Aggregation method over criterion scores (§A.8). `weight` is read by\n * `weighted_average` ONLY — it is inert under the other three, which combine\n * criteria by min/count (the builder warns: `RUB_WEIGHT_IGNORED`).\n *\n * An earlier draft had a fifth, `weighted_sum`; it is gone because it could\n * never say what it promised — its thresholds were compared absolutely, but\n * `approveAt` is bps (≤10000) while Σ(score×weight) reaches 50000, so every\n * threshold above 10000 was inexpressible. Additive schemes are\n * `weighted_average` with weights.\n */\nexport type RubricScoringMethod = 'weighted_average' | 'all_pass' | 'minimum' | 'quorum';\n\n/**\n * A numeric anchor (§A.8): a plain number, or a `~derived` ref that resolves to\n * one — so `fullAt: \"~target\"` moves when the calculation does. (`@constant`\n * refs are gone — format v1.1, §A.0: authors write the literal value inline.)\n * That the ref resolves to a number is the binder's job (`validateRubric`), as\n * with every other ref; the string arm is unavoidably wider than the `~name`\n * grammar TypeScript can express.\n */\nexport type RubricNumberOrRef = number | string;\n\n/** Context tokens (closed enum, §A.3) — resolved once per evaluation, frozen in the receipt. */\nexport const RUBRIC_CTX_TOKENS = [\n  'ctx.now',\n  'ctx.collection.startDate',\n  'ctx.collection.endDate',\n  'ctx.claim.submitter',\n  'ctx.claim.submitterAddress',\n  'ctx.claim.submissionDate',\n  'ctx.submitter.priorClaimCount',\n  'ctx.submitter.priorApprovedCount',\n  'ctx.collection.projectBoundary',\n] as const;\nexport type RubricCtxToken = (typeof RUBRIC_CTX_TOKENS)[number];\n\n// ---------------------------------------------------------------------------\n// Conditions (§A.5) — one recursive node: simple, row-quantified, compound\n// ---------------------------------------------------------------------------\n\n/**\n * A value in a rule. A plain JSON value is a literal; a string starting with\n * `$ ~` or `ctx.` is a ref (wrap a literal that collides in `{\"@value\": …}`);\n * some operators take structured values (`between` pairs, `withinRadius` specs).\n * Typed loosely — `validateRubric` owns the per-operator runtime checks.\n */\nexport type RubricConditionValue = unknown;\n\n/** Shape 1 — simple: field × operator × value. */\nexport interface RubricSimpleCondition {\n  '@type': 'Condition';\n  /** `$answer`, `~derived`, or (inside a forEach) a row-relative `.column` ref. */\n  field: string;\n  op: RubricOperator;\n  value?: RubricConditionValue;\n  /** `approx` only: the ± tolerance. */\n  tolerance?: number;\n}\n\n/**\n * Shape 2 — over repeating rows: exactly one of `every` / `some`.\n * `every` over zero rows is TRUE, `some` is FALSE (§A.5, declared).\n */\nexport interface RubricForEachCondition {\n  '@type': 'Condition';\n  /** A rows-kind field ref (`$lineItems`). */\n  forEach: string;\n  every?: RubricCondition;\n  some?: RubricCondition;\n}\n\n/**\n * Shapes 3–6 — compound: `all`/`any`/`not` RESTORED and `atLeast` added by\n * owner decision 2026-08-03 (the linked-rules design, eval-engine\n * `docs/superpowers/specs/2026-08-03-linked-rules-design.md`), superseding the\n * v1.1 §A.0 removal — the builder's rule groups now write these shapes. Each\n * member evaluates independently under the §A.5 null rule: a missing answer\n * makes its member false, never an error. Empty member lists and an `atLeast`\n * outside `1..of.length` are authoring errors (`validateRubric`), not runtime\n * cases.\n */\nexport interface RubricAllCondition {\n  '@type': 'Condition';\n  /** Every member must hold. */\n  all: RubricCondition[];\n}\n\nexport interface RubricAnyCondition {\n  '@type': 'Condition';\n  /** At least one member must hold. */\n  any: RubricCondition[];\n}\n\n/**\n * Format-only: the builder never renders a NOT toggle — negation lives in the\n * operator vocabulary (`!=`, `notIn`, `isFalse`, `empty`) where authors already\n * find it. Generators and hand-authored rubrics may use it freely.\n */\nexport interface RubricNotCondition {\n  '@type': 'Condition';\n  not: RubricCondition;\n}\n\n/** ≥ `atLeast` of `of` must hold. `atLeast: of.length` is legal — it is `all` spelled with a number. */\nexport interface RubricAtLeastCondition {\n  '@type': 'Condition';\n  atLeast: number;\n  of: RubricCondition[];\n}\n\nexport type RubricCondition = RubricSimpleCondition | RubricForEachCondition | RubricAllCondition | RubricAnyCondition | RubricNotCondition | RubricAtLeastCondition;\n\n// ---------------------------------------------------------------------------\n// Gates (§A.6), derived values (§A.7)\n// ---------------------------------------------------------------------------\n\n/** Must-pass check; gates run first, in document order, first failure terminal. */\nexport interface RubricGate {\n  '@type': 'Gate';\n  /** `^[A-Z0-9]+-[0-9]+-[A-Z0-9-]+$`; unique per rubric. */\n  code: string;\n  /** Display-only wording; lands in the rejection. */\n  reason: string;\n  /**\n   * Optional, exactly as a criterion has it (§A.6): the gate is SKIPPED —\n   * neither passed nor failed — unless this holds. This is how \"optional, but\n   * must be valid if present\" is written — the UI's \"Only check this if…\" row.\n   */\n  appliesWhen?: RubricCondition;\n  /** Condition that must be TRUE. */\n  when: RubricCondition;\n  /** Default `reject`; `review` routes borderline checks to a human instead. */\n  onFail?: 'reject' | 'review';\n  /**\n   * The class this gate's FAILURE declares; carried into the receipt (§A.6).\n   * REQUIRED: the builder always sets it (default `refuted`), and the engine's\n   * schema rejects a gate without one — a UI regression that dropped it must\n   * surface as an authoring error, never publish a class-less gate.\n   */\n  class: RubricGateClass;\n}\n\n/** Named pure computation over the claim, referenced as `~name` (§A.7). */\nexport interface RubricDerived {\n  '@type': 'Derived';\n  name: string;\n  /** Strictly grammared expression — see `expression.ts`. `~refs` must be defined earlier in the array. */\n  expr: string;\n}\n\n// ---------------------------------------------------------------------------\n// Scoring (§A.8) — criteria and the 7 score nodes\n// ---------------------------------------------------------------------------\n\n/** `need` of `of` criteria must clear their `min` (§A.8). `need ≤ of` is `RUB_QUORUM_INVALID`. */\nexport interface RubricQuorum {\n  need: number;\n  of: number;\n}\n\nexport interface RubricScoring {\n  '@type': 'Scoring';\n  method: RubricScoringMethod;\n  /** Bps, 0–10000. */\n  approveAt: number;\n  /** Optional; ≥ this & < approveAt ⇒ partial approve. */\n  partialFloor?: number;\n  /** ≥ this & < approveAt ⇒ human review; below ⇒ reject. */\n  reviewFloor?: number;\n  /**\n   * REQUIRED when `method: 'quorum'`, and refused under any other method — the\n   * two are meaningless apart, so they travel together (§A.8). That coupling is\n   * SHAPE: the engine's schema is a `oneOf` of two closed objects and reports a\n   * violation as `RUB_SCHEMA`. What a schema cannot say is `need ≤ of` (it\n   * can't compare two siblings), so that is ours: `RUB_QUORUM_INVALID`.\n   */\n  quorum?: RubricQuorum;\n  criteria: RubricCriterion[];\n}\n\nexport interface RubricCriterion {\n  '@type': 'Criterion';\n  code: string;\n  reason: string;\n  /**\n   * Integer 1..5 — the UI's star rating. Read by `weighted_average` ONLY;\n   * inert under `all_pass`/`minimum`/`quorum`, which combine criteria by\n   * min/count (`RUB_WEIGHT_IGNORED` warns). Stays REQUIRED regardless: a\n   * default would be an invisible input to the document's hash, and swapping\n   * the method back must not have silently lost the author's intent.\n   */\n  weight: number;\n  /** With `min`: below min ⇒ hard reject on its own, regardless of total. */\n  critical?: boolean;\n  min?: number;\n  /** Optional: criterion only counts when true. */\n  appliesWhen?: RubricCondition;\n  /** Optional provenance floor — weaker-sourced values score 0 and force review (§A.8 trust). */\n  requireSource?: 'server_verified' | 'attested';\n  /** Optional bps ceiling for weaker-sourced (client-typed) values. */\n  trustCap?: number;\n  /** Exactly one scoring node. */\n  score: RubricScoreNode;\n}\n\n/** 1) All-or-nothing on a condition. */\nexport interface RubricBooleanScore {\n  '@type': 'BooleanScore';\n  when: RubricCondition;\n  onTrue: number;\n  onFalse: number;\n}\n\n/** A band's step: a number, or a `~derived` ref standing in for one (§A.8). */\nexport type RubricBand = { op: '>' | '>=' | '<' | '<=' | '=='; value: RubricNumberOrRef; points: number } | { else: true; points: number };\n\n/** 2) Stepped thresholds, first match wins. */\nexport interface RubricBandsScore {\n  '@type': 'BandsScore';\n  /** What is being scored: `$field`, a row column, `~derived`, or a ctx token. */\n  value: string;\n  bands: RubricBand[];\n}\n\n/** 3) Proportional between two anchors (`zeroAt > fullAt` inverts, e.g. \"cheaper is better\"). */\nexport interface RubricLinearScore {\n  '@type': 'LinearScore';\n  /** What is being scored (see BandsScore.value). */\n  value: string;\n  /** Anchors take `~derived` refs: `fullAt: \"~target\"` moves when the calculation does (§A.8). */\n  zeroAt: RubricNumberOrRef;\n  fullAt: RubricNumberOrRef;\n  clamp?: boolean;\n}\n\nexport type RubricLevel = { name: string; when: RubricCondition; points: number } | { name: string; else: true; points: number };\n\n/** 4) Ordinal scale, every level backed by an objective condition. */\nexport interface RubricLevelsScore {\n  '@type': 'LevelsScore';\n  levels: RubricLevel[];\n}\n\n/** 5) Enum answer → points. */\nexport interface RubricMapScore {\n  '@type': 'MapScore';\n  value: string;\n  map: Record<string, number>;\n  default?: number;\n}\n\nexport interface RubricDeduction {\n  when: RubricCondition;\n  points: number;\n  code: string;\n}\n\n/** 6) Start full, subtract coded penalties (floor-clamped). */\nexport interface RubricDeductionsScore {\n  '@type': 'DeductionsScore';\n  start: number;\n  floor?: number;\n  deduct: RubricDeduction[];\n}\n\n/**\n * 7) A human scores it — but ONLY when `field` is present (§A.8).\n *\n * A missing field scores `whenMissing`, creates NO review task, and the verdict\n * follows deterministically from that score (typically a reject, since\n * `whenMissing` is typically 0). A machine can tell a photo is absent; it just\n * can't tell what's in one — so \"absent\" is a machine decision that asks\n * nobody, and \"what does this show?\" is the human's. That is what makes §A.9's\n * rule precise: a manual criterion is *pending* only when its field is present,\n * and only a pending one downgrades approve/partial to review.\n */\nexport interface RubricManualScore {\n  '@type': 'ManualScore';\n  /** The evidence field the reviewer judges. */\n  field: string;\n  /** Bps scored when the evidence is missing — no task, no human, deterministic verdict. */\n  whenMissing: number;\n  /** Must name an existing ReviewTask id. */\n  reviewTask: string;\n}\n\nexport type RubricScoreNode = RubricBooleanScore | RubricBandsScore | RubricLinearScore | RubricLevelsScore | RubricMapScore | RubricDeductionsScore | RubricManualScore;\n\n// ---------------------------------------------------------------------------\n// Human review + settlement (§A.9)\n// ---------------------------------------------------------------------------\n\n/**\n * Enumerable answers ONLY (§A.9). `map` has to turn the reviewer's answer into\n * approve/partial/reject deterministically, and \"every possible answer is\n * mapped\" (`RUB_REVIEW_ANSWER_UNMAPPED`) is only checkable when the answers can\n * be listed — which rules out free `number`/`text`, whose every value could\n * miss the map. Ask the yes/no or the pick-one the rubric actually needs, not a\n * value someone has to interpret afterwards.\n */\nexport type RubricReviewAnswerShape = { type: 'boolean' } | { type: 'enum'; options: string[] };\n\n/** Review is authored, not improvised — exactly what to ask, show, and do per answer. */\nexport interface RubricReviewTask {\n  '@type': 'ReviewTask';\n  id: string;\n  forCriterion: string;\n  prompt: string;\n  /** Exactly what evidence to display (field refs). */\n  show?: string[];\n  answer: RubricReviewAnswerShape;\n  /** Answer (stringified) → verdict contribution. Every possible answer must be mapped. */\n  map: Record<string, 'approve' | 'partial' | 'reject'>;\n}\n\nexport interface RubricHumanReview {\n  '@type': 'HumanReview';\n  /**\n   * Who reviews. `role` is the routing lane (default `reviewer`); `assigneeDid`\n   * optionally names ONE specific person by DID (picked in the builder's\n   * people-search, §A.9) so a review can be assigned to a known individual\n   * rather than a role. Optional + additive — the engine schema accepts either\n   * (`RubricEnvelope` in `eval-engine/src/lib/rubric/schema.ts`).\n   */\n  assignTo?: { role: string; assigneeDid?: string };\n  /**\n   * WHERE the review lands: a real Matrix room id (`!room:server`) or alias\n   * (`#alias:server`) — the channel whose members review. One-of with\n   * `assigneeDid` in the builder: a channel means anyone in that room reviews.\n   */\n  route?: { matrixRoom: string };\n  slaHours?: number;\n  /** Fail closed: unanswered ⇒ reject, never approve. */\n  onTimeout?: 'reject';\n  tasks: RubricReviewTask[];\n}\n\nexport interface RubricSettlement {\n  '@type': 'Settlement';\n  onApprove?: { pay: 'approval' };\n  /** `prorateBy`: `\"total\"` (amount × total/10000), a `~derived`/`$field` 0..1 fraction, or `\"none\"`. */\n  onPartial?: { pay: 'approval'; prorateBy?: string };\n}\n\n// ---------------------------------------------------------------------------\n// External sources (§A.14) — an HTTP check the engine makes during evaluation\n// ---------------------------------------------------------------------------\n\n/**\n * A §A.14 external check: a declared HTTP call the engine makes to a service it\n * names by `did:web:` (UCAN-authorized), whose answer a rule reads as\n * `ext.<name>.<field>` — `valid` (boolean sources), `score` (score sources), or\n * `reason` (both). Mirrors the engine's already-shipped Zod EXACTLY; unknown\n * keys are the engine schema's job (§A.11), not modelled here.\n *\n * `capability` is deliberately NOT rendered in the builder — the host mints it\n * from `audience` at resolve time — so the UI leaves it unset.\n */\nexport interface RubricExternalSource {\n  '@type': 'ExternalSource';\n  /** `^[A-Za-z0-9_-]+$` — the `<name>` in `ext.<name>.*`, unique per rubric. */\n  name: string;\n  /** `^https?:\\/\\/` — where the engine calls. */\n  endpoint: string;\n  /** `^did:web:` — the service's identity and the UCAN audience the engine addresses. */\n  audience: string;\n  /** UCAN capability the engine invokes with; the host mints it from `audience`. HIDDEN from the UI — left unset. */\n  capability?: { can: string; with: string };\n  /** Payload key → a ref (`$field`/`~derived`/`ctx.*`) OR a literal — what the engine sends. */\n  send: Record<string, string | number | boolean>;\n  /** The answer's shape: a yes/no (`ext.<name>.valid`) or a bps score 0..10000 (`ext.<name>.score`). */\n  expect: 'boolean' | 'score';\n  /** How trusted the answer is (§A.8 trust); resolved engine-side when omitted. */\n  provenance?: 'server_verified' | 'attested' | 'client_assisted';\n  /** What a failed call does: route to a human, or reject outright. */\n  onError?: 'review' | 'reject';\n  /** Per-call timeout in milliseconds. */\n  timeoutMs?: number;\n}\n\n// ---------------------------------------------------------------------------\n// AI checks (§A.15) — the engine's own AI agent judges the sent values\n// ---------------------------------------------------------------------------\n\n/**\n * A §A.15 AI check: the engine asks its AI agent whether the sent values\n * satisfy the authored `instructions`, and a rule reads the answer as\n * `ai.<name>.valid` / `ai.<name>.reason`. Same lifecycle as an external source\n * (declared → resolved+frozen before the decision), minus the plumbing: no\n * endpoint, no audience — the engine is the service. Mirrors the engine's Zod\n * EXACTLY.\n */\nexport interface RubricAiCheck {\n  '@type': 'AiCheck';\n  /** `^[A-Za-z0-9_-]+$` — the `<name>` in `ai.<name>.*`, unique per rubric. */\n  name: string;\n  /** Payload key → a ref (`$field`/`~derived`/`ctx.*`) OR a literal — what the AI sees. */\n  send: Record<string, string | number | boolean>;\n  /** The plain-language rules the answer is checked against — ALL must hold for `valid: true`. */\n  instructions: string[];\n  /** v1 is yes/no only. */\n  expect: 'boolean';\n  /** What a failed AI call does: route to a human, or reject outright. */\n  onError?: 'review' | 'reject';\n}\n\n// ---------------------------------------------------------------------------\n// Duplicate-claim detection (dup-detection spec §6) — one opt-in block per rubric\n// ---------------------------------------------------------------------------\n\n/**\n * One entry of the duplicate rule's identity key (`by`): a plain ref, or a ref\n * with a date granularity — dates in the key compare at that granularity. The\n * builder's picker emits plain refs only; the object arm is hand-authored and\n * round-trips untouched (`uniqueModel`).\n */\nexport type RubricUniqueBy = string | { ref: string; granularity?: 'day' | 'month' | 'year' };\n\n/**\n * The §6 duplicate rule: \"this claim must be unique\". Mirrors the engine's Zod\n * EXACTLY (eval-engine `src/lib/rubric/schema.ts`, `Unique`) in its INPUT mode —\n * `countPrior`/`attachments`/`thresholds` are engine-defaulted so they are\n * optional here, but the builder always writes them out so what the author sees\n * in the machine view is what runs. Thresholds are bps: score ≥ `rejectAtBps` ⇒\n * reject, ≥ `reviewAtBps` ⇒ review; `rejectAtBps ≥ reviewAtBps` is a Zod-refine\n * bound the served schema cannot state, so the sliders enforce it.\n */\nexport interface RubricUnique {\n  '@type': 'Unique';\n  id: string;\n  /** Display-only. */\n  label?: string;\n  /** Identity key — absent ⇒ similarity runs over the whole canonical body. */\n  by?: RubricUniqueBy[];\n  /** Which prior verdicts block — rejected priors never do (the honest-fix path, dup §6). */\n  countPrior?: ('approved' | 'pending_review' | 'queued')[];\n  /** The attachment lanes: CID exact match + pHash near match (dup §4 L2/L4). */\n  attachments?: boolean;\n  /** The gray-zone same-event AI judge (dup §7) — the engine defaults it ON (T18): absent means on, `enabled: false` is the opt-out. Bundled into the per-claim price, no separate line. */\n  ai?: { enabled?: boolean; maxPairs?: number };\n  thresholds?: { rejectAtBps: number; reviewAtBps: number };\n}\n\n/**\n * The §13 submission-rate limit: \"max X claims per calendar period per\n * submitter\". Composes with `unique` — same content vs. too much content,\n * however varied. Mirrors the engine's Zod EXACTLY (eval-engine\n * `src/lib/rubric/schema.ts`, `Frequency`) in its INPUT mode — `onBreach` is\n * engine-defaulted (`review`) so it is optional here, and the builder omits it\n * when it matches the default (minimal bytes, like `unique.ai`).\n */\nexport interface RubricFrequency {\n  '@type': 'Frequency';\n  id: string;\n  /** Display-only. */\n  label?: string;\n  /** The window budget — the count includes the claim being evaluated (§13.3). */\n  max: number;\n  /** Calendar periods, UTC; weeks are ISO weeks (§13.2 — the chain's clock picks the window). */\n  per: 'day' | 'week' | 'month' | 'year';\n  /** Breach consequence — absent ⇒ `review` (a person checks); `reject` is the owner's hardening. */\n  onBreach?: 'review' | 'reject';\n}\n\n// ---------------------------------------------------------------------------\n// Body, envelope (§A.2)\n// ---------------------------------------------------------------------------\n\n/** The form binding pin (§A.3): which `#vct` these rules were authored against. */\nexport interface RubricClaimSchemaBinding {\n  '@type': 'ClaimSchemaBinding';\n  /** Protocol entity DID carrying `#vct` (and, after publish, `#rub`). */\n  protocol: string;\n  /** `#vct`. */\n  resource: string;\n  /** The `#vct` LinkedResource proof at authoring time. */\n  proof: string;\n}\n\n/**\n * The `rubric` body under the envelope. Requires `@type`, `claimSchema`, and at\n * least one of `gates`/`scoring`.\n *\n * Deliberately NO `@id`: the rubric's id is the hash of the uploaded bytes\n * (§A.10), so the document cannot carry it — it would have to contain a hash of\n * itself. The id exists only after upload.\n *\n * Deliberately NO `fixtures` either: the id hashes the whole document, so\n * saving a test case would mint a new rubric and write to chain even though no\n * rule changed. Golden tests live in the engine (task 3), keyed by `rubricId`.\n */\nexport interface RubricBody {\n  '@type': 'Rubric';\n  title?: string;\n  description?: string;\n  claimSchema: RubricClaimSchemaBinding;\n  // `constants` is gone — format v1.1 (§A.0): literal values are written inline.\n  derived?: RubricDerived[];\n  /** External checks (§A.14) a rule may read as `ext.<name>.*`. */\n  sources?: RubricExternalSource[];\n  /** AI checks (§A.15) a rule may read as `ai.<name>.*`. */\n  aiChecks?: RubricAiCheck[];\n  /** Duplicate-claim detection (dup-detection spec §6) — opt-in, one block per rubric. */\n  unique?: RubricUnique;\n  /** Submission-rate limit (dup-detection spec §13) — opt-in, one block per rubric. */\n  frequency?: RubricFrequency;\n  gates?: RubricGate[];\n  scoring?: RubricScoring;\n  review?: RubricHumanReview;\n  settlement?: RubricSettlement;\n}\n\n/** The stored document mirrors the claim template's envelope exactly (§A.2); read back as `resolved.rubric ?? resolved`. */\nexport const RUBRIC_CONTEXT = {\n  ixo: 'https://w3id.org/ixo/ns/protocol/',\n  '@id': '@type',\n  type: '@type',\n  '@protected': true,\n} as const;\n\nexport const RUBRIC_ENVELOPE_TYPE = 'ixo:entity#rubric';\n\nexport interface RubricEnvelope {\n  '@context': typeof RUBRIC_CONTEXT;\n  type: typeof RUBRIC_ENVELOPE_TYPE;\n  rubric: RubricBody;\n}\n\nexport function buildRubricEnvelope(body: RubricBody): RubricEnvelope {\n  return { '@context': RUBRIC_CONTEXT, type: RUBRIC_ENVELOPE_TYPE, rubric: body };\n}\n\n/**\n * `buildRubricEnvelope` read backwards: the rubric BODY inside a `#rub`\n * document that was resolved off chain, or `null` when the document is not a\n * rubric at all. The designer opens on this so an author editing a collection\n * that ALREADY has rules published continues from them instead of a blank\n * sheet — publishing replaces `#rub` outright (delete + add in one\n * transaction, `publishEvalRubric` step 5), so a blank sheet is how a live\n * rulebook gets silently wiped.\n *\n * Both shapes are accepted — `resolved.rubric ?? resolved` (the read the\n * envelope comment above describes), since a host resolves LinkedResources\n * through several transports and not every stored document is wrapped. The\n * body then goes through the SAME `migrateRubric` pass as one parsed out of\n * `block.props.inputs`: a rubric published before a field rename must open\n * clean rather than trip the engine's strict-object schema on first validate.\n *\n * `claimSchema` is the discriminator — a document with no form binding cannot\n * be a rubric, and filling the designer from it would produce rules bound to\n * nothing. `@type` is normalized rather than demanded: an early document that\n * omits it is still a rubric, and refusing it would silently drop the author\n * back to the blank sheet this exists to prevent.\n */\nexport function parsePublishedRubric(raw: unknown): RubricBody | null {\n  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;\n  const wrapped = (raw as { rubric?: unknown }).rubric;\n  const candidate = wrapped && typeof wrapped === 'object' && !Array.isArray(wrapped) ? wrapped : raw;\n  const body = candidate as Partial<RubricBody>;\n  if (!body.claimSchema || typeof body.claimSchema !== 'object') return null;\n  return migrateRubric({ ...(body as RubricBody), '@type': 'Rubric' });\n}\n\n// ---------------------------------------------------------------------------\n// The field catalog (§B.4) — how the form becomes rule cards\n// ---------------------------------------------------------------------------\n\n/** A choice option: rules compare against `value`; the builder displays `text` (§A.3). */\nexport interface RubricChoice {\n  value: string;\n  text: string;\n}\n\n/**\n * One addressable field of the claim form. Container questions (matrix,\n * matrixdropdown, matrixdynamic, paneldynamic, multipletext) carry their\n * expanded addressable inner fields in `columns` — `$q.row.col` cells,\n * `$q[*].col` repeating columns, `$q.row` matrix rows, `$q.key` items —\n * so a rule can only ever point at a path that exists.\n */\nexport interface RubricField {\n  /** §A.3 grammar: `$name`, `$q.row.col`, `$q[*].col`, `$q.key`. */\n  path: string;\n  /** Derived from `type` AND `inputType` AND `cellType` (§A.3 table). */\n  kind: RubricFieldKind;\n  /** Question title (the card heading). */\n  title: string;\n  isRequired: boolean;\n  /** dropdown/radio/checkbox/tagbox/matrix cells: the pickable options. */\n  choices?: RubricChoice[];\n  /** matrix/matrixdropdown rows. */\n  rows?: RubricChoice[];\n  /** Container questions: the expanded addressable inner fields. */\n  columns?: RubricField[];\n}\n\n/** `proof` = the `#vct` binding pin at extraction time ('' when the caller has no resource proof). */\nexport type RubricFieldCatalog = { fields: RubricField[]; proof: string };\n\n// ---------------------------------------------------------------------------\n// Block inputs (§B.3) — what the config persists in block.props.inputs\n// ---------------------------------------------------------------------------\n\n/**\n * Template storage shape for `qi/eval.rubric`. Persisting the rubric inside\n * the block keeps the flow self-contained (diffable, previewable); chain +\n * Matrix become the published copy at execution.\n */\nexport interface EvalRubricActionInputs {\n  /** Entity (deed) DID, or a `${ref}` to an upstream block output. */\n  deedDid: string;\n  collectionId: string;\n  /** The rubric body (§A.2 `rubric`, minus `@id`) — envelope + `@id` are computed at publish. */\n  rubric: RubricBody | null;\n  /** The field catalog the rules were authored against (§B.4). */\n  claimSchemaSnapshot: RubricFieldCatalog | null;\n  /** Optional engine base-URL override for the best-effort pin. Blank = host default (mirrors eval.register). */\n  evalEngineUrl: string;\n}\n\nconst EMPTY_INPUTS: EvalRubricActionInputs = {\n  deedDid: '',\n  collectionId: '',\n  rubric: null,\n  claimSchemaSnapshot: null,\n  evalEngineUrl: '',\n};\n\n/**\n * Self-heal a rubric persisted before a field rename, so a stale document opens\n * CLEAN instead of tripping the engine's strict-object schema on every reopen.\n *\n * `assignTo.matrixUserId` → `assignTo.assigneeDid` (§A.9): the reviewer field was\n * renamed in both the engine schema and the editor. A rubric authored before the\n * rename still carries `matrixUserId`, and the served schema is a `strictObject`\n * — an unknown key is an error (`RUB_SCHEMA`) on EVERY validate, which persists\n * across close/reopen because it is baked into `block.props.inputs` and\n * re-validated each time. Moving the value forward ONCE here — at parse time,\n * before any validation — makes the old document valid again. `matrixUserIdToDid`\n * is idempotent on a DID, so a value already in `did:…` form crosses unchanged;\n * a stored Matrix user id is converted to the DID the field now expects.\n *\n * `route.matrixRoom: \"collection\"` → no `route` (§A.9): the early format used a\n * `\"collection\"` sentinel there, but no such channel exists — the engine now\n * demands a real Matrix room id/alias, so the retired sentinel is dropped and\n * the role lane routes until the author picks a channel.\n *\n * Idempotent: once migrated there is no `matrixUserId` key and no sentinel\n * `route`, so re-parsing is a no-op. Runs before `validateRubric`/\n * `validateRubricShape` ever see the body.\n */\nfunction migrateRubric(rubric: RubricBody): RubricBody {\n  const review = rubric.review;\n  if (!review) return rubric;\n  let next = review;\n  if (next.route?.matrixRoom === 'collection') {\n    const { route: _retired, ...withoutRoute } = next;\n    next = withoutRoute;\n  }\n  const assignTo = next.assignTo as Record<string, unknown> | undefined;\n  if (assignTo && 'matrixUserId' in assignTo) {\n    const { matrixUserId, assigneeDid, ...rest } = assignTo;\n    const nextDid = typeof assigneeDid === 'string' && assigneeDid ? assigneeDid : typeof matrixUserId === 'string' && matrixUserId ? matrixUserIdToDid(matrixUserId) : undefined;\n    next = { ...next, assignTo: { ...rest, ...(nextDid ? { assigneeDid: nextDid } : {}) } as RubricHumanReview['assignTo'] };\n  }\n  return next === review ? rubric : { ...rubric, review: next };\n}\n\nexport function parseEvalRubricInputs(raw: string | Record<string, any> | undefined): EvalRubricActionInputs {\n  try {\n    const parsed: any = typeof raw === 'string' ? JSON.parse(raw || '{}') : raw || {};\n    const rubric = parsed.rubric && typeof parsed.rubric === 'object' && !Array.isArray(parsed.rubric) ? migrateRubric(parsed.rubric as RubricBody) : null;\n    const snapshot =\n      parsed.claimSchemaSnapshot && typeof parsed.claimSchemaSnapshot === 'object' && Array.isArray(parsed.claimSchemaSnapshot.fields)\n        ? ({ fields: parsed.claimSchemaSnapshot.fields, proof: typeof parsed.claimSchemaSnapshot.proof === 'string' ? parsed.claimSchemaSnapshot.proof : '' } as RubricFieldCatalog)\n        : null;\n    return {\n      deedDid: typeof parsed.deedDid === 'string' ? parsed.deedDid : '',\n      collectionId: typeof parsed.collectionId === 'string' ? parsed.collectionId : '',\n      rubric,\n      claimSchemaSnapshot: snapshot,\n      evalEngineUrl: typeof parsed.evalEngineUrl === 'string' ? parsed.evalEngineUrl : '',\n    };\n  } catch {\n    return { ...EMPTY_INPUTS };\n  }\n}\n\nexport function serializeEvalRubricInputs(inputs: EvalRubricActionInputs): string {\n  return JSON.stringify(inputs);\n}\n\n/**\n * Full inputs passed to the action's `run()`. The merge of template\n * configuration and runtime inputs; `rubric`/`claimSchemaSnapshot` may arrive\n * as objects or JSON strings (DataInput refs serialize) — `run()` normalizes.\n */\nexport interface EvalRubricRunInputs {\n  deedDid?: string;\n  collectionId?: string;\n  rubric?: RubricBody | string;\n  claimSchemaSnapshot?: RubricFieldCatalog | string;\n  evalEngineUrl?: string;\n}\n\n/**\n * `run()` output. `rubricId` + `resourceTxHash` are the proof fields.\n *\n * There is no separate content hash: `rubricId` IS the hash of the published\n * bytes, and the same value is the LinkedResource `proof` on-chain (§A.10).\n */\nexport interface EvalRubricOutput {\n  rubricId: string;\n  resourceId: string;\n  protocolDid: string;\n  collectionId: string;\n  resourceUrl: string;\n  resourceTxHash: string;\n}\n\n// Re-export the host-injected service contract so the consumer app can import\n// the whole `eval.rubric` type surface from this one module.\nexport type { RubricService } from '../../types';\n","/**\n * §A.3 form path segment grammar — the ONE segment definition every rubric\n * regex in this package is built from. A segment may carry ONE JSON-LD\n * namespace prefix (`ixo:hiveId`, `schema:legalName`) — IXO claim forms name\n * their SurveyJS questions that way throughout, and claim answers store those\n * names verbatim. Colons appear nowhere else in the ref/expression grammar,\n * so the prefix is unambiguous.\n *\n * MUST stay identical to eval-engine's `src/lib/rubric/schema.ts`\n * FORM_SEGMENT — the engine parses what the editor authors, so any drift\n * between the two grammars is a published rubric the engine 400s on (or a\n * form field the editor refuses to offer that the engine would accept).\n *\n * Engine-internal names (`~derived`, `ext.*`, `ai.*`, send-map keys) are\n * deliberately NARROWER (`[A-Za-z0-9_-]+`, the engine's INTERNAL_NAME): they\n * are authored inside the rubric document itself and never carry a namespace\n * prefix. Do not build those from this constant.\n */\nexport const FORM_SEGMENT = '[A-Za-z0-9_-]+(?::[A-Za-z0-9_-]+)?';\n","import { FORM_SEGMENT } from './pathGrammar';\nimport type { RubricChoice, RubricField, RubricFieldCatalog, RubricFieldKind } from './types';\n\n/**\n * Extract the rubric field catalog from a SurveyJS template — rubric-spec §B.4.\n *\n * The richer sibling of `../claim/surveySchema.ts`'s `extractSurveyAnswerSchema`\n * (same traversal, richer output): the catalog is (a) the builder's card list,\n * (b) the operator filter, (c) the value pickers' choice source, and (d) the\n * binder input — the author can only ever click on things that exist.\n *\n * Differences that matter (§A.3, verified against the real devnet form):\n * - `inputType` refines the kind (`text` + `datetime-local` ⇒ date, + `number`\n *   ⇒ number) — the claim TYPE_MAP ignores it, the rubric binder must not.\n * - Choice questions keep `{value, text}` PAIRS: rules compare against values,\n *   the builder displays texts.\n * - Matrix cells carry their own `cellType` (a slider column ⇒ number cells).\n * - Container questions expand their addressable inner paths into `columns`:\n *   `$q.row.col` (matrixdropdown), `$q[*].col` (matrixdynamic/paneldynamic),\n *   `$q.row` (matrix), `$q.key` (multipletext).\n *\n * Question types outside the §A.3 table (and any name/row/column outside the\n * path grammar's segments — `[A-Za-z0-9_-]+` with one optional JSON-LD\n * `namespace:` prefix) are skipped — an unaddressable or unknown-kind field\n * must be unconstructible, not guessed at.\n */\n\n/** §A.3 path grammar segment — one optional JSON-LD namespace prefix (`ixo:hiveId`). */\nconst SEGMENT = new RegExp(`^${FORM_SEGMENT}$`);\n\n/**\n * A question NAME may be a whole dotted path, not just one segment — MIRROR of the engine's\n * `catalog.ts` (eval-engine, 2026-08-12). Cellnode-era collections (emerging-eco FuelPurchase)\n * store nested JSON-LD documents rather than flat form answers, so their `#vct` is a path\n * manifest: each question name IS the dotted path into `credentialSubject`\n * (`claim.product.quantity.amount`). The `$field` ref grammar (validate.ts FIELD_REF) already\n * accepts unlimited depth — this check was the only thing keeping such fields out of the picker.\n *\n * Each segment may carry one JSON-LD namespace prefix (`ixo:claim.schema:quantity`) — the\n * same FORM_SEGMENT grammar as everywhere else.\n *\n * `[*]` is deliberately NOT accepted here: a fan-out belongs to a container question, whose\n * columns are expanded below with the kind that comes off the column definition.\n */\nconst NAME_PATH = new RegExp(`^${FORM_SEGMENT}(?:\\\\.${FORM_SEGMENT})*$`);\n\ninterface SurveyElement {\n  name?: string;\n  title?: string;\n  type?: string;\n  inputType?: string;\n  cellType?: string;\n  isRequired?: boolean;\n  multiSelect?: boolean;\n  choices?: unknown[];\n  rows?: unknown[];\n  columns?: unknown[];\n  items?: unknown[];\n  elements?: SurveyElement[]; // panels nest\n  templateElements?: SurveyElement[]; // paneldynamic row shape\n}\n\n/** SurveyJS question type (+ inputType) → scalar field kind. Returns undefined for non-scalar/unknown types. */\nfunction scalarKind(type: string, inputType?: string): RubricFieldKind | undefined {\n  switch (type) {\n    case 'text':\n      if (inputType === 'number') return 'number';\n      if (inputType === 'date' || inputType === 'datetime-local') return 'date';\n      return 'text';\n    case 'comment':\n      return 'text';\n    case 'rating':\n    case 'slider':\n      return 'number';\n    case 'dropdown':\n    case 'radiogroup':\n      return 'choice';\n    case 'checkbox':\n    case 'tagbox':\n    case 'ranking':\n      return 'multichoice';\n    case 'boolean':\n      return 'boolean';\n    case 'file':\n      return 'file';\n    case 'signaturepad':\n      return 'signature';\n    case 'geopoint':\n      return 'geo';\n    default:\n      return undefined;\n  }\n}\n\n/** Normalize SurveyJS choices/rows (strings or `{value, text}` objects) into `{value, text}` pairs with grammar-safe values. */\nfunction normalizeChoices(raw: unknown[] | undefined): RubricChoice[] {\n  if (!Array.isArray(raw)) return [];\n  const out: RubricChoice[] = [];\n  for (const entry of raw) {\n    let value = '';\n    let text = '';\n    if (typeof entry === 'string' || typeof entry === 'number') {\n      value = String(entry);\n      text = String(entry);\n    } else if (entry && typeof entry === 'object') {\n      const obj = entry as { value?: unknown; text?: unknown };\n      if (obj.value === undefined || obj.value === null) continue;\n      value = String(obj.value);\n      text = obj.text === undefined || obj.text === null ? value : stripHtml(String(obj.text));\n    } else {\n      continue;\n    }\n    out.push({ value, text });\n  }\n  return out;\n}\n\n/** Row/item values become path segments — only grammar-safe ones are addressable. */\nfunction segmentChoices(raw: unknown[] | undefined): RubricChoice[] {\n  return normalizeChoices(raw).filter((choice) => SEGMENT.test(choice.value));\n}\n\n/** Inner-field descriptor from a matrix column / paneldynamic template element. */\nfunction innerField(el: SurveyElement, path: string, fallbackKind?: RubricFieldKind): RubricField | undefined {\n  // Matrix columns default to dropdown cells when no cellType is set (SurveyJS default).\n  const type = typeof el.cellType === 'string' && el.cellType ? el.cellType : typeof el.type === 'string' ? el.type : '';\n  const kind = scalarKind(type, el.inputType) ?? fallbackKind;\n  if (!kind) return undefined;\n  const choices = kind === 'choice' || kind === 'multichoice' ? normalizeChoices(el.choices) : undefined;\n  return {\n    path,\n    kind,\n    title: titleOf(el),\n    isRequired: el.isRequired === true,\n    ...(choices && choices.length > 0 ? { choices } : {}),\n  };\n}\n\nexport function extractRubricFieldCatalog(surveyTemplate: unknown, proof = ''): RubricFieldCatalog {\n  // The template may arrive as the JSON-LD envelope (§A.2 sibling convention):\n  // `{\"type\": \"ixo:entity#surveyTemplate\", \"question\": {<survey>}}` — unwrap\n  // `question ?? root`, the exact read the portal already does.\n  const root = ((surveyTemplate as { question?: unknown })?.question ?? surveyTemplate) as { pages?: Array<{ elements?: SurveyElement[] }>; elements?: SurveyElement[] } | null;\n  if (!root || typeof root !== 'object') return { fields: [], proof };\n\n  const fields: RubricField[] = [];\n  const seen = new Set<string>();\n\n  const walk = (elements: SurveyElement[] | undefined) => {\n    if (!Array.isArray(elements)) return;\n    for (const el of elements) {\n      if (!el || typeof el !== 'object') continue;\n      // Panels don't hold an answer themselves — descend into their children.\n      if (el.type === 'panel' && Array.isArray(el.elements)) {\n        walk(el.elements);\n        continue;\n      }\n      const name = typeof el.name === 'string' ? el.name.trim() : '';\n      const type = typeof el.type === 'string' ? el.type : '';\n      // html/expression are not submitter input; ungrammatical names are unaddressable.\n      if (!name || !NAME_PATH.test(name) || seen.has(name) || type === 'html' || type === 'expression') continue;\n      const field = extractQuestion(el, name, type);\n      if (!field) continue;\n      seen.add(name);\n      fields.push(field);\n    }\n  };\n\n  if (Array.isArray(root.pages) && root.pages.length > 0) {\n    for (const page of root.pages) walk(page.elements);\n  }\n  walk(root.elements);\n\n  return { fields, proof };\n}\n\nfunction extractQuestion(el: SurveyElement, name: string, type: string): RubricField | undefined {\n  const base = { path: `$${name}`, title: titleOf(el), isRequired: el.isRequired === true };\n\n  // imagepicker splits on multiSelect — the one type whose kind isn't static.\n  if (type === 'imagepicker') {\n    return { ...base, kind: el.multiSelect === true ? 'multichoice' : 'choice', choices: normalizeChoices(el.choices) };\n  }\n\n  const scalar = scalarKind(type, el.inputType);\n  if (scalar) {\n    const choices = scalar === 'choice' || scalar === 'multichoice' ? normalizeChoices(el.choices) : undefined;\n    return { ...base, kind: scalar, ...(choices && choices.length > 0 ? { choices } : {}) };\n  }\n\n  switch (type) {\n    case 'matrix': {\n      // Keyed choice: `{row: colValue}` — per-row `$q.row` checks against the matrix columns.\n      const rows = segmentChoices(el.rows);\n      const choices = normalizeChoices(el.columns);\n      const columns = rows.map(\n        (row): RubricField => ({ path: `$${name}.${row.value}`, kind: 'choice', title: `${base.title} — ${row.text}`, isRequired: base.isRequired, choices })\n      );\n      return { ...base, kind: 'keyed_choice', rows, choices, columns };\n    }\n    case 'matrixdropdown': {\n      // Cells: `{row: {col: value}}` — `$q.row.col`, kind from the column's cellType.\n      const rows = segmentChoices(el.rows);\n      const columns: RubricField[] = [];\n      for (const rawCol of Array.isArray(el.columns) ? el.columns : []) {\n        const col = rawCol as SurveyElement;\n        const colName = typeof col?.name === 'string' ? col.name.trim() : '';\n        if (!colName || !SEGMENT.test(colName)) continue;\n        for (const row of rows) {\n          const cell = innerField(col, `$${name}.${row.value}.${colName}`, 'choice');\n          if (cell) columns.push({ ...cell, title: `${base.title} — ${row.text} / ${titleOf(col) || colName}` });\n        }\n      }\n      return { ...base, kind: 'cells', rows, columns };\n    }\n    case 'matrixdynamic': {\n      // Rows: `[{col: value}]` — `$q[*].col`, kind from the column's cellType.\n      const columns: RubricField[] = [];\n      for (const rawCol of Array.isArray(el.columns) ? el.columns : []) {\n        const col = rawCol as SurveyElement;\n        const colName = typeof col?.name === 'string' ? col.name.trim() : '';\n        if (!colName || !SEGMENT.test(colName)) continue;\n        const inner = innerField(col, `$${name}[*].${colName}`, 'choice');\n        if (inner) columns.push(inner);\n      }\n      return { ...base, kind: 'rows', columns };\n    }\n    case 'paneldynamic': {\n      // Rows: `[{name: value}]` — `$q[*].name` from templateElements (panels within recurse).\n      const columns: RubricField[] = [];\n      const walkTemplate = (elements: SurveyElement[] | undefined) => {\n        if (!Array.isArray(elements)) return;\n        for (const child of elements) {\n          if (!child || typeof child !== 'object') continue;\n          if (child.type === 'panel' && Array.isArray(child.elements)) {\n            walkTemplate(child.elements);\n            continue;\n          }\n          const childName = typeof child.name === 'string' ? child.name.trim() : '';\n          const childType = typeof child.type === 'string' ? child.type : '';\n          if (!childName || !SEGMENT.test(childName) || childType === 'html' || childType === 'expression') continue;\n          const inner = innerField(child, `$${name}[*].${childName}`);\n          if (inner) columns.push(inner);\n        }\n      };\n      walkTemplate(el.templateElements);\n      return { ...base, kind: 'rows', columns };\n    }\n    case 'multipletext': {\n      // Keyed text: `{key: string}` — `$q.key`.\n      const columns: RubricField[] = [];\n      for (const rawItem of Array.isArray(el.items) ? el.items : []) {\n        const item = rawItem as SurveyElement;\n        const itemName = typeof item?.name === 'string' ? item.name.trim() : '';\n        if (!itemName || !SEGMENT.test(itemName)) continue;\n        columns.push({ path: `$${name}.${itemName}`, kind: 'text', title: titleOf(item) || humanize(itemName), isRequired: item.isRequired === true });\n      }\n      return { ...base, kind: 'keyed_text', columns };\n    }\n    default:\n      // Unknown widget — no kind, no legal operators, so no card. Skip.\n      return undefined;\n  }\n}\n\nfunction titleOf(el: SurveyElement): string {\n  const title = typeof el.title === 'string' ? stripHtml(el.title.trim()) : '';\n  return title || humanize(typeof el.name === 'string' ? el.name : '');\n}\n\nfunction humanize(name: string): string {\n  // Display only: drop JSON-LD namespace prefixes per segment (`ixo:hiveId` → \"HiveId\") — the\n  // catalog path keeps them. Mirror of the engine's `catalog.ts` humanize.\n  const bare = name\n    .split('.')\n    .map((seg) => (seg.includes(':') ? (seg.split(':').pop() as string) : seg))\n    .join('.');\n  return bare.replace(/[-_]+/g, ' ').replace(/\\b\\w/g, (c) => c.toUpperCase());\n}\n\nfunction stripHtml(s: string): string {\n  return s\n    .replace(/<[^>]*>/g, '')\n    .replace(/\\s+/g, ' ')\n    .trim();\n}\n","/**\n * The §A.7 derived-expression grammar — a small recursive-descent PARSER, and\n * nothing else. Its only consumer is `validate.ts`, which walks the AST to\n * raise RUB_EXPR_SYNTAX / RUB_EXPR_UNKNOWN_FUNC while the author is typing.\n * The grammar is closed:\n *\n *   expr   := term ((\"+\"|\"-\") term)*\n *   term   := factor ((\"*\"|\"/\") factor)*\n *   factor := number | string | ref | call | \"(\" expr \")\" | \"-\" factor\n *   call   := ident \"(\" (expr (\",\" expr)*)? \")\"\n *   ref    := fieldRef | \"~\"ident | ctxToken\n *\n * Format v1.1 (rubric-spec §A.0): the `@ident` production is GONE — constants\n * were removed from the format, so `@` is not a sigil and fails the parse.\n *\n * One pragmatic extension to the spec text: quoted string literals exist in the\n * token stream ONLY so `countWhere(selector, op, literal)` can carry its\n * operator — `validate.ts` rejects a string literal anywhere else, keeping the\n * authored surface exactly the spec's.\n *\n * DELIBERATELY NOT HERE: evaluation. Nothing in the editor computes a derived\n * value from real answers — the engine owns the decision order and every\n * operator's runtime semantics, and a second implementation here would drift\n * from it (which is the whole reason it lives in one place). The builder's\n * \"try it\" preview calls the engine's rubric-preview endpoint. This module\n * tells the author their expression is WELL-FORMED; only the engine ever says\n * what it computes.\n */\n\nimport { FORM_SEGMENT } from './pathGrammar';\n\nexport type ExprNode =\n  | { kind: 'num'; value: number }\n  | { kind: 'str'; value: string }\n  | { kind: 'bool'; value: boolean }\n  | { kind: 'ref'; ref: string }\n  | { kind: 'call'; name: string; args: ExprNode[] }\n  | { kind: 'neg'; operand: ExprNode }\n  | { kind: 'bin'; op: '+' | '-' | '*' | '/'; left: ExprNode; right: ExprNode };\n\n/** The closed function library (§A.7): name → allowed arity range. */\nexport const EXPR_FUNCTIONS: Record<string, { minArgs: number; maxArgs: number }> = {\n  min: { minArgs: 2, maxArgs: Infinity },\n  max: { minArgs: 2, maxArgs: Infinity },\n  clamp: { minArgs: 3, maxArgs: 3 },\n  abs: { minArgs: 1, maxArgs: 1 },\n  floor: { minArgs: 1, maxArgs: 1 },\n  ceil: { minArgs: 1, maxArgs: 1 },\n  round: { minArgs: 1, maxArgs: 1 },\n  sum: { minArgs: 1, maxArgs: 1 },\n  avg: { minArgs: 1, maxArgs: 1 },\n  count: { minArgs: 1, maxArgs: 1 },\n  countWhere: { minArgs: 3, maxArgs: 3 },\n  daysBetween: { minArgs: 2, maxArgs: 2 },\n  hoursBetween: { minArgs: 2, maxArgs: 2 },\n  yearsBetween: { minArgs: 2, maxArgs: 2 },\n  distanceMeters: { minArgs: 2, maxArgs: 2 },\n  length: { minArgs: 1, maxArgs: 1 },\n};\n\n/**\n * `countWhere`'s operator argument (§A.7). Ordering comparisons stay numeric —\n * `>` on a string has no defined meaning here — while equality is the only\n * thing a boolean or an enum answers, so `==`/`!=` also take a boolean or\n * string literal. `COUNT_WHERE_ORDERING_OPS` is the numeric-only subset.\n */\nexport const COUNT_WHERE_OPS = ['==', '!=', '>', '>=', '<', '<='] as const;\nexport const COUNT_WHERE_ORDERING_OPS = ['>', '>=', '<', '<='] as const;\n\nexport class ExpressionSyntaxError extends Error {\n  constructor(\n    message: string,\n    readonly position: number\n  ) {\n    super(`${message} (at offset ${position})`);\n    this.name = 'ExpressionSyntaxError';\n  }\n}\n\nconst IDENT = /[A-Za-z_][A-Za-z0-9_]*/y;\nconst NUMBER = /(?:\\d+\\.?\\d*|\\.\\d+)/y;\n// fieldRef := \"$\" segment (\".\" segment | \"[*]\")*  — §A.3 grammar; a segment may\n// carry one JSON-LD namespace prefix (`$ixo:hiveId`), per FORM_SEGMENT.\nconst FIELD_REF = new RegExp(`\\\\$${FORM_SEGMENT}(?:\\\\.${FORM_SEGMENT}|\\\\[\\\\*\\\\])*`, 'y');\nconst SIGIL_REF = /~[A-Za-z_][A-Za-z0-9_]*/y;\nconst CTX_REF = /ctx(?:\\.[A-Za-z][A-Za-z0-9]*)+/y;\n\n/** Parse an expression source string into its AST. Throws {@link ExpressionSyntaxError}. */\nexport function parseExpression(src: string): ExprNode {\n  let pos = 0;\n\n  const skipWs = () => {\n    while (pos < src.length && /\\s/.test(src[pos])) pos++;\n  };\n  const match = (re: RegExp): string | undefined => {\n    re.lastIndex = pos;\n    const m = re.exec(src);\n    if (!m) return undefined;\n    pos = re.lastIndex;\n    return m[0];\n  };\n  const fail = (message: string): never => {\n    throw new ExpressionSyntaxError(message, pos);\n  };\n\n  const parseExpr = (): ExprNode => {\n    let left = parseTerm();\n    for (;;) {\n      skipWs();\n      const ch = src[pos];\n      if (ch !== '+' && ch !== '-') return left;\n      pos++;\n      left = { kind: 'bin', op: ch, left, right: parseTerm() };\n    }\n  };\n\n  const parseTerm = (): ExprNode => {\n    let left = parseFactor();\n    for (;;) {\n      skipWs();\n      const ch = src[pos];\n      if (ch !== '*' && ch !== '/') return left;\n      pos++;\n      left = { kind: 'bin', op: ch, left, right: parseFactor() };\n    }\n  };\n\n  const parseFactor = (): ExprNode => {\n    skipWs();\n    const ch = src[pos];\n    if (ch === undefined) return fail('unexpected end of expression');\n\n    if (ch === '-') {\n      pos++;\n      return { kind: 'neg', operand: parseFactor() };\n    }\n    if (ch === '(') {\n      pos++;\n      const inner = parseExpr();\n      skipWs();\n      if (src[pos] !== ')') return fail(\"expected ')'\");\n      pos++;\n      return inner;\n    }\n    if (ch === \"'\" || ch === '\"') {\n      const quote = ch;\n      const start = ++pos;\n      while (pos < src.length && src[pos] !== quote) pos++;\n      if (pos >= src.length) return fail('unterminated string literal');\n      return { kind: 'str', value: src.slice(start, pos++) };\n    }\n    if (ch === '$') {\n      const ref = match(FIELD_REF);\n      if (!ref) return fail('malformed $field reference');\n      return { kind: 'ref', ref };\n    }\n    if (ch === '~') {\n      const ref = match(SIGIL_REF);\n      if (!ref) return fail('malformed ~-reference');\n      return { kind: 'ref', ref };\n    }\n\n    const numeric = match(NUMBER);\n    if (numeric) return { kind: 'num', value: Number(numeric) };\n\n    // `ctx.…` tokens win over bare idents; any other bare ident must be a call.\n    const ctxRef = match(CTX_REF);\n    if (ctxRef) return { kind: 'ref', ref: ctxRef };\n\n    const ident = match(IDENT);\n    if (ident) {\n      // `true`/`false` are literals, not calls — legal ONLY as countWhere's\n      // value argument, which `validate.ts` enforces (the grammar's `literal`\n      // production, §A.7). Parsed here so the fence can be a real diagnostic\n      // rather than a syntax error about a missing '('.\n      if (ident === 'true' || ident === 'false') return { kind: 'bool', value: ident === 'true' };\n      skipWs();\n      if (src[pos] !== '(') return fail(`'${ident}' is not a value — bare identifiers must be function calls`);\n      pos++;\n      const args: ExprNode[] = [];\n      skipWs();\n      if (src[pos] === ')') {\n        pos++;\n      } else {\n        for (;;) {\n          args.push(parseExpr());\n          skipWs();\n          if (src[pos] === ',') {\n            pos++;\n            continue;\n          }\n          if (src[pos] === ')') {\n            pos++;\n            break;\n          }\n          return fail(\"expected ',' or ')'\");\n        }\n      }\n      return { kind: 'call', name: ident, args };\n    }\n\n    return fail(`unexpected character '${ch}'`);\n  };\n\n  const root = parseExpr();\n  skipWs();\n  if (pos < src.length) fail(`unexpected trailing input '${src.slice(pos)}'`);\n  return root;\n}\n","import { COUNT_WHERE_OPS, COUNT_WHERE_ORDERING_OPS, EXPR_FUNCTIONS, ExpressionSyntaxError, parseExpression, type ExprNode } from './expression';\nimport { FORM_SEGMENT } from './pathGrammar';\nimport type {\n  RubricBand,\n  RubricBody,\n  RubricCondition,\n  RubricCriterion,\n  RubricCtxToken,\n  RubricExternalSource,\n  RubricField,\n  RubricFieldCatalog,\n  RubricFieldKind,\n  RubricNumberOrRef,\n  RubricOperator,\n  RubricScoreNode,\n  RubricSimpleCondition,\n} from './types';\nimport { RUBRIC_CTX_TOKENS } from './types';\n\n/**\n * The binder — rubric-spec §A.11. Validates a rubric body against the claim\n * form's field catalog: every ref must resolve, every operator must be legal\n * for its field's kind, every expression must parse inside the closed grammar.\n * Pure SHAPE (unknown keys, closed enums, bps ranges, required members, code\n * grammar, group exclusivity, gates-or-scoring) is the engine-served JSON\n * Schema's job — compiled with Ajv in `schemaGate.ts` and surfaced as\n * `RUB_SCHEMA` — and is not re-implemented here. What stays below is what a\n * JSON Schema cannot decide: the binder checks (does `$field` exist? is the\n * operator legal for its kind?), the expression grammar, and the two\n * sibling-comparison refines the engine also keeps out of its schema (threshold\n * order, `quorum.need ≤ of`).\n *\n * Diagnostics carry `{code, severity, message, path}` with `path` a\n * JSON-Pointer into the rubric BODY — stable codes, so tooling composes.\n *\n * Pass `authoringCatalog` when `catalog` is a FRESH read of the live form\n * (publish-time re-check, §B.2 step 2): a rule referencing a field that the\n * snapshot had but the live form no longer has (or has retyped) is reported\n * as `RUB_SCHEMA_DRIFT` — \"the form changed since authoring\" — instead of a\n * plain unresolved ref.\n */\n\nexport type RubricDiagnosticCode =\n  | 'RUB_SCHEMA'\n  | 'RUB_FIELD_NOT_IN_SCHEMA'\n  | 'RUB_FIELD_PATH'\n  | 'RUB_OPERATOR_TYPE_MISMATCH'\n  | 'RUB_VALUE_TYPE'\n  | 'RUB_UNKNOWN_REF'\n  | 'RUB_EXPR_SYNTAX'\n  | 'RUB_EXPR_UNKNOWN_FUNC'\n  | 'RUB_REGEX_UNSAFE'\n  | 'RUB_THRESHOLD_ORDER'\n  | 'RUB_WEIGHT_INVALID'\n  | 'RUB_QUORUM_INVALID'\n  | 'RUB_DUPLICATE_CODE'\n  | 'RUB_REVIEW_TASK_UNMAPPED'\n  | 'RUB_REVIEW_ANSWER_UNMAPPED'\n  | 'RUB_UNREACHABLE_BAND'\n  | 'RUB_WEIGHT_IGNORED'\n  | 'RUB_NO_RULES'\n  | 'RUB_SCHEMA_DRIFT'\n  | 'RUB_UNIQUE_KEY_DERIVED'\n  | 'RUB_EXT_SOURCE_UNKNOWN'\n  | 'RUB_EXT_FIELD_INVALID'\n  | 'RUB_AI_CHECK_UNKNOWN'\n  | 'RUB_AI_FIELD_INVALID';\n\nexport interface RubricDiagnostic {\n  code: RubricDiagnosticCode;\n  severity: 'error' | 'warning';\n  message: string;\n  /** JSON-Pointer into the rubric body ('' = the whole body). */\n  path: string;\n}\n\n/**\n * A problem from EITHER source: this validator (codes above) or the engine's pre-publish preview,\n * whose codes this union deliberately doesn't enumerate — the binder's `BIND_*` family and the\n * settings gate's `RUB_AI_CHECKS_DISABLED` are the engine's vocabulary, not the editor's, and\n * pinning them here would mean a lock-step release every time the engine adds one. Every\n * `RubricDiagnostic` is a `RubricProblem`; render both through `problemText` (phrases.ts), which\n * falls back to `message` for a code the editor has no words of its own for.\n */\nexport interface RubricProblem {\n  code: string;\n  severity: 'error' | 'warning';\n  message: string;\n  path: string;\n}\n\n/** §A.4 legality table: operator → field kinds it is legal for ('all' = every kind). */\nexport const RUBRIC_OPERATOR_KINDS: Record<RubricOperator, RubricFieldKind[] | 'all'> = {\n  present: 'all',\n  empty: 'all',\n  '==': ['text', 'number', 'date', 'choice', 'boolean'],\n  '!=': ['text', 'number', 'date', 'choice', 'boolean'],\n  '>': ['number', 'date'],\n  '>=': ['number', 'date'],\n  '<': ['number', 'date'],\n  '<=': ['number', 'date'],\n  between: ['number', 'date'],\n  approx: ['number'],\n  in: ['text', 'number', 'choice'],\n  notIn: ['text', 'number', 'choice'],\n  matches: ['text'],\n  startsWith: ['text'],\n  endsWith: ['text'],\n  lengthBetween: ['text'],\n  contains: ['multichoice'],\n  containsAll: ['multichoice'],\n  containsAny: ['multichoice'],\n  subsetOf: ['multichoice'],\n  countBetween: ['multichoice', 'rows'],\n  isTrue: ['boolean'],\n  isFalse: ['boolean'],\n  before: ['date'],\n  after: ['date'],\n  withinWindow: ['date'],\n  withinDays: ['date'],\n  notInFuture: ['date'],\n  mediaTypeIn: ['file', 'signature'],\n  maxSizeMB: ['file', 'signature'],\n  withinBoundary: ['geo'],\n  withinRadius: ['geo'],\n};\n\n/** The operator picker filter (§B.4): which operators the builder may offer for a field kind. */\nexport function operatorsForKind(kind: RubricFieldKind): RubricOperator[] {\n  return (Object.keys(RUBRIC_OPERATOR_KINDS) as RubricOperator[]).filter((op) => {\n    const kinds = RUBRIC_OPERATOR_KINDS[op];\n    return kinds === 'all' || kinds.includes(kind);\n  });\n}\n\n/**\n * The five classes a FAILING gate may declare (§A.6). `class` is required on\n * every gate and must be one of these — the engine's schema rejects anything\n * else, so a class-less or off-list gate is an authoring error, not a shape the\n * builder should ever be able to publish.\n */\nconst GATE_FAILURE_CLASSES = ['refuted', 'invalid_evidence', 'out_of_authority', 'insufficient_evidence', 'requires_human_review'] as const;\n\n/** What each context token resolves to, for value-type checking. */\nconst CTX_TOKEN_KIND: Record<RubricCtxToken, RubricFieldKind> = {\n  'ctx.now': 'date',\n  'ctx.collection.startDate': 'date',\n  'ctx.collection.endDate': 'date',\n  'ctx.claim.submitter': 'text',\n  'ctx.claim.submitterAddress': 'text',\n  'ctx.claim.submissionDate': 'date',\n  'ctx.submitter.priorClaimCount': 'number',\n  'ctx.submitter.priorApprovedCount': 'number',\n  'ctx.collection.projectBoundary': 'geo',\n};\n\n/** §A.3 field-ref grammar — each segment may carry one JSON-LD namespace prefix (`$ixo:hiveId`). */\nconst FIELD_REF = new RegExp(`^\\\\$${FORM_SEGMENT}(?:\\\\.${FORM_SEGMENT}|\\\\[\\\\*\\\\])*$`);\n/** Row-relative ref — only inside a forEach scope. Same FORM_SEGMENT grammar as columns. */\nconst ROW_REF = new RegExp(`^\\\\.${FORM_SEGMENT}$`);\n/** The root question of a `$field` ref — the WHOLE namespaced first segment (`$ixo:hiveId`). */\nconst FIELD_ROOT = new RegExp(`^\\\\$${FORM_SEGMENT}`);\nconst DERIVED_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;\n/** §A.14 external-check ref: `ext.<name>.<field>`, field ∈ { valid, score, reason }. */\nconst EXT_REF = /^ext\\.([A-Za-z0-9_-]+)\\.(valid|score|reason)$/;\n/** §A.15 AI-check ref: `ai.<name>.<field>`, field ∈ { valid, reason } (v1 is yes/no only). */\nconst AI_REF = /^ai\\.([A-Za-z0-9_-]+)\\.(valid|reason)$/;\n/** §A.14 source name grammar (the `<name>` in `ext.<name>.*` / `ai.<name>.*`). */\nconst SOURCE_NAME = /^[A-Za-z0-9_-]+$/;\n\nexport function validateRubric(body: RubricBody, catalog: RubricFieldCatalog, authoringCatalog?: RubricFieldCatalog): RubricDiagnostic[] {\n  const diags: RubricDiagnostic[] = [];\n  const error = (code: RubricDiagnosticCode, message: string, path: string) => diags.push({ code, severity: 'error', message, path });\n  const warn = (code: RubricDiagnosticCode, message: string, path: string) => diags.push({ code, severity: 'warning', message, path });\n\n  const fieldIndex = indexCatalog(catalog);\n  const snapshotIndex = authoringCatalog ? indexCatalog(authoringCatalog) : undefined;\n  const derivedNames = new Set((body.derived ?? []).map((d) => d.name));\n  const sourcesByName = new Map((body.sources ?? []).map((s) => [s.name, s]));\n  const aiChecksByName = new Map((body.aiChecks ?? []).map((c) => [c.name, c]));\n\n  // ---- refs ----------------------------------------------------------------\n\n  /** Resolve a `$field` ref against the catalog; emits the right diagnostic and returns its kind (or undefined). */\n  const checkFieldRef = (ref: string, path: string): RubricFieldKind | undefined => {\n    if (!FIELD_REF.test(ref)) {\n      error('RUB_FIELD_PATH', `malformed field path '${ref}'`, path);\n      return undefined;\n    }\n    const field = fieldIndex.get(ref);\n    if (field) {\n      const snapshotKind = snapshotIndex?.get(ref)?.kind;\n      if (snapshotKind && snapshotKind !== field.kind) {\n        error('RUB_SCHEMA_DRIFT', `'${ref}' changed from ${snapshotKind} to ${field.kind} since the rules were authored`, path);\n        return undefined;\n      }\n      return field.kind;\n    }\n    if (snapshotIndex?.has(ref)) {\n      error('RUB_SCHEMA_DRIFT', `'${ref}' no longer exists on the claim form (deleted or renamed since the rules were authored)`, path);\n      return undefined;\n    }\n    const rootName = FIELD_ROOT.exec(ref)?.[0] ?? ref;\n    if (ref !== rootName && fieldIndex.has(rootName)) {\n      error('RUB_FIELD_PATH', `'${ref}' does not address a row/column of ${rootName}`, path);\n    } else {\n      error('RUB_FIELD_NOT_IN_SCHEMA', `'${ref}' does not resolve to a question in the bound form`, path);\n    }\n    return undefined;\n  };\n\n  /**\n   * Resolve an `ext.<name>.<field>` ref (§A.14) against `sources[]`. Valid IFF a\n   * source named `<name>` exists AND `<field>` fits its `expect` (`valid`/`reason`\n   * for a boolean source, `score`/`reason` for a score one). Returns the ref's\n   * kind — a boolean `valid`, a number `score`, or a text `reason` — so the caller\n   * can type-check it exactly like any other ref.\n   */\n  const checkExtRef = (ref: string, path: string): RubricFieldKind | undefined => {\n    const match = EXT_REF.exec(ref);\n    if (!match) {\n      error('RUB_EXT_FIELD_INVALID', `'${ref}' is not a valid external-check reference — use ext.<name>.valid, .score or .reason`, path);\n      return undefined;\n    }\n    const [, name, fieldName] = match;\n    const source = sourcesByName.get(name);\n    if (!source) {\n      error('RUB_EXT_SOURCE_UNKNOWN', `no external check named '${name}' is defined`, path);\n      return undefined;\n    }\n    if (fieldName === 'valid' && source.expect !== 'boolean') {\n      error('RUB_EXT_FIELD_INVALID', `external check '${name}' returns a score, not a yes/no — read ext.${name}.score`, path);\n      return undefined;\n    }\n    if (fieldName === 'score' && source.expect !== 'score') {\n      error('RUB_EXT_FIELD_INVALID', `external check '${name}' returns a yes/no, not a score — read ext.${name}.valid`, path);\n      return undefined;\n    }\n    return fieldName === 'score' ? 'number' : fieldName === 'valid' ? 'boolean' : 'text';\n  };\n\n  /**\n   * Resolve an `ai.<name>.<field>` ref (§A.15) against `aiChecks[]` — the same\n   * contract as `checkExtRef`, minus the score shape (v1 AI checks are yes/no).\n   */\n  const checkAiRef = (ref: string, path: string): RubricFieldKind | undefined => {\n    const match = AI_REF.exec(ref);\n    if (!match) {\n      error('RUB_AI_FIELD_INVALID', `'${ref}' is not a valid AI-check reference — use ai.<name>.valid or ai.<name>.reason`, path);\n      return undefined;\n    }\n    const [, name, fieldName] = match;\n    if (!aiChecksByName.has(name)) {\n      error('RUB_AI_CHECK_UNKNOWN', `no AI check named '${name}' is defined`, path);\n      return undefined;\n    }\n    return fieldName === 'valid' ? 'boolean' : 'text';\n  };\n\n  /** A condition's `field` position: `$answer`, `~derived`, `ext.<name>.<field>`, `ai.<name>.<field>`, or (inside forEach) `.column`. */\n  const checkConditionField = (ref: unknown, path: string, forEachTarget?: string): RubricFieldKind | undefined => {\n    if (typeof ref !== 'string' || ref.length === 0) {\n      error('RUB_FIELD_PATH', 'condition field must be a reference string', path);\n      return undefined;\n    }\n    if (ref.startsWith('~')) {\n      if (!derivedNames.has(ref.slice(1))) {\n        error('RUB_UNKNOWN_REF', `derived value '${ref}' is not defined`, path);\n        return undefined;\n      }\n      return 'number'; // derived expressions compute numbers\n    }\n    if (ref.startsWith('ext.')) return checkExtRef(ref, path);\n    if (ref.startsWith('ai.')) return checkAiRef(ref, path);\n    if (ref.startsWith('.')) {\n      if (!forEachTarget) {\n        error('RUB_FIELD_PATH', `row-relative ref '${ref}' is only legal inside a forEach`, path);\n        return undefined;\n      }\n      if (!ROW_REF.test(ref)) {\n        error('RUB_FIELD_PATH', `malformed row-relative ref '${ref}'`, path);\n        return undefined;\n      }\n      return checkFieldRef(`${forEachTarget}[*]${ref}`, path);\n    }\n    if (ref.startsWith('$')) return checkFieldRef(ref, path);\n    error('RUB_FIELD_PATH', `'${ref}' is not a field reference ($answer, ~derived, or a row-relative .column)`, path);\n    return undefined;\n  };\n\n  // `@` is NOT a sigil any more (format v1.1, §A.0) — a string starting with it\n  // is an ordinary literal, like any other text.\n  const isRefString = (v: unknown): v is string =>\n    typeof v === 'string' && (v.startsWith('$') || v.startsWith('~') || v.startsWith('ctx.') || v.startsWith('ext.') || v.startsWith('ai.'));\n\n  /** Unwrap the `{\"@value\": …}` literal escape (§A.3). */\n  const unwrapLiteral = (v: unknown): { literal: unknown } | undefined => {\n    if (v !== null && typeof v === 'object' && !Array.isArray(v) && '@value' in (v as Record<string, unknown>)) {\n      return { literal: (v as Record<string, unknown>)['@value'] };\n    }\n    return isRefString(v) ? undefined : { literal: v };\n  };\n\n  /** Resolve a value-position ref; emits RUB_UNKNOWN_REF (bare-sigil strings included) and returns the ref's kind. */\n  const checkValueRef = (ref: string, path: string): RubricFieldKind | undefined => {\n    if (ref.startsWith('$')) {\n      if (FIELD_REF.test(ref) && (fieldIndex.has(ref) || snapshotIndex?.has(ref))) return checkFieldRef(ref, path);\n      error('RUB_UNKNOWN_REF', `'${ref}' does not resolve — wrap a literal that starts with a sigil in {\"@value\": …}`, path);\n      return undefined;\n    }\n    if (ref.startsWith('~')) {\n      if (!derivedNames.has(ref.slice(1))) {\n        error('RUB_UNKNOWN_REF', `derived value '${ref}' is not defined`, path);\n        return undefined;\n      }\n      return 'number';\n    }\n    if (ref.startsWith('ext.')) return checkExtRef(ref, path);\n    if (ref.startsWith('ai.')) return checkAiRef(ref, path);\n    if ((RUBRIC_CTX_TOKENS as readonly string[]).includes(ref)) return CTX_TOKEN_KIND[ref as RubricCtxToken];\n    error('RUB_UNKNOWN_REF', `unknown context token '${ref}'`, path);\n    return undefined;\n  };\n\n  // ---- per-operator value checks --------------------------------------------\n\n  const isDateString = (v: unknown): boolean => typeof v === 'string' && !Number.isNaN(Date.parse(v));\n\n  /** A literal must fit the field's kind (`==`, `in` elements, …). */\n  const literalFitsKind = (literal: unknown, kind: RubricFieldKind): boolean => {\n    switch (kind) {\n      case 'number':\n        return typeof literal === 'number';\n      case 'boolean':\n        return typeof literal === 'boolean';\n      case 'date':\n        return isDateString(literal);\n      default:\n        return typeof literal === 'string';\n    }\n  };\n\n  /** Comparison operand (`>`, `between` bounds, `approx`, `before`/`after`): literal of the kind, or a ref of the same kind. */\n  const checkComparable = (value: unknown, kind: 'number' | 'date', path: string) => {\n    if (isRefString(value)) {\n      const refKind = checkValueRef(value, path);\n      if (refKind && refKind !== kind) error('RUB_VALUE_TYPE', `'${value}' is a ${refKind}, expected a ${kind}`, path);\n      return;\n    }\n    const unwrapped = unwrapLiteral(value);\n    if (!unwrapped || !literalFitsKind(unwrapped.literal, kind)) {\n      error('RUB_VALUE_TYPE', `expected a ${kind} value`, path);\n    }\n  };\n\n  /** `[min, max]` pair for between/lengthBetween/countBetween. */\n  const checkPair = (value: unknown, path: string, check: (v: unknown, p: string) => void) => {\n    if (!Array.isArray(value) || value.length !== 2) {\n      error('RUB_VALUE_TYPE', 'expected a [min, max] pair', path);\n      return;\n    }\n    check(value[0], `${path}/0`);\n    check(value[1], `${path}/1`);\n  };\n\n  const checkInteger = (value: unknown, path: string) => {\n    if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) error('RUB_VALUE_TYPE', 'expected a non-negative integer', path);\n  };\n\n  const checkSimpleCondition = (cond: RubricSimpleCondition, path: string, forEachTarget?: string) => {\n    const kind = checkConditionField(cond.field, `${path}/field`, forEachTarget);\n    const legalKinds = RUBRIC_OPERATOR_KINDS[cond.op];\n    if (!legalKinds) {\n      error('RUB_OPERATOR_TYPE_MISMATCH', `unknown operator '${String(cond.op)}'`, `${path}/op`);\n      return;\n    }\n    if (kind === undefined) return; // field already diagnosed; value checks would only cascade\n    if (legalKinds !== 'all' && !legalKinds.includes(kind)) {\n      error('RUB_OPERATOR_TYPE_MISMATCH', `'${cond.op}' is not legal for a ${kind} field`, `${path}/op`);\n      return;\n    }\n\n    const value = cond.value;\n    const valuePath = `${path}/value`;\n\n    switch (cond.op) {\n      case 'present':\n      case 'empty':\n      case 'isTrue':\n      case 'isFalse':\n      case 'withinWindow':\n      case 'notInFuture':\n        if (value !== undefined) error('RUB_VALUE_TYPE', `'${cond.op}' takes no value`, valuePath);\n        break;\n      case '==':\n      case '!=': {\n        if (isRefString(value)) {\n          const refKind = checkValueRef(value, valuePath);\n          if (refKind && refKind !== kind) error('RUB_VALUE_TYPE', `'${value}' is a ${refKind}, expected a ${kind}`, valuePath);\n          break;\n        }\n        const unwrapped = unwrapLiteral(value);\n        if (!unwrapped || !literalFitsKind(unwrapped.literal, kind)) error('RUB_VALUE_TYPE', `expected a ${kind} value`, valuePath);\n        break;\n      }\n      case '>':\n      case '>=':\n      case '<':\n      case '<=':\n        checkComparable(value, kind === 'date' ? 'date' : 'number', valuePath);\n        break;\n      case 'between':\n        checkPair(value, valuePath, (v, p) => checkComparable(v, kind === 'date' ? 'date' : 'number', p));\n        break;\n      case 'approx':\n        checkComparable(value, 'number', valuePath);\n        if (typeof cond.tolerance !== 'number' || cond.tolerance < 0) error('RUB_VALUE_TYPE', \"'approx' needs a non-negative numeric tolerance\", `${path}/tolerance`);\n        break;\n      case 'in':\n      case 'notIn':\n      case 'containsAll':\n      case 'containsAny':\n      case 'subsetOf': {\n        // Inline arrays ONLY — the `@constant` list stand-in is gone (§A.0).\n        if (!Array.isArray(value)) {\n          error('RUB_VALUE_TYPE', 'expected a list of values', valuePath);\n          break;\n        }\n        // Membership lists hold the question's STORED values: strings for\n        // text/choice/multichoice, numbers for number fields (§A.3).\n        const elementKind: RubricFieldKind = kind === 'number' ? 'number' : 'text';\n        for (const [i, element] of value.entries()) {\n          if (isRefString(element)) checkValueRef(element, `${valuePath}/${i}`);\n          else if (!literalFitsKind(element, elementKind)) error('RUB_VALUE_TYPE', `list entry must be a ${elementKind === 'number' ? 'number' : 'string'}`, `${valuePath}/${i}`);\n        }\n        break;\n      }\n      case 'contains': {\n        if (isRefString(value)) checkValueRef(value, valuePath);\n        else {\n          const unwrapped = unwrapLiteral(value);\n          if (!unwrapped || (typeof unwrapped.literal !== 'string' && typeof unwrapped.literal !== 'number' && typeof unwrapped.literal !== 'boolean')) {\n            error('RUB_VALUE_TYPE', \"'contains' expects a single literal value\", valuePath);\n          }\n        }\n        break;\n      }\n      case 'matches': {\n        if (typeof value !== 'string' || value.length === 0) {\n          error('RUB_VALUE_TYPE', \"'matches' expects a regex pattern string\", valuePath);\n          break;\n        }\n        try {\n          new RegExp(value);\n        } catch {\n          error('RUB_VALUE_TYPE', `'${value}' is not a valid pattern`, valuePath);\n          break;\n        }\n        const unsafeReason = unsafeRegexReason(value);\n        if (unsafeReason) error('RUB_REGEX_UNSAFE', `pattern outside the safe subset: ${unsafeReason}`, valuePath);\n        break;\n      }\n      case 'startsWith':\n      case 'endsWith': {\n        // A plain string or its `{\"@value\": …}` escape — NEVER a ref (§A.4,\n        // pinned by the 2026-08-03 skew resolution: these two ops take the\n        // text itself, and the engine's kitchen-sink fixture uses the escape).\n        const unwrapped = unwrapLiteral(value);\n        if (!unwrapped || typeof unwrapped.literal !== 'string') error('RUB_VALUE_TYPE', `'${cond.op}' expects a string`, valuePath);\n        break;\n      }\n      case 'lengthBetween':\n      case 'countBetween':\n        checkPair(value, valuePath, checkInteger);\n        break;\n      case 'before':\n      case 'after':\n        checkComparable(value, 'date', valuePath);\n        break;\n      case 'withinDays':\n        checkInteger(value, valuePath);\n        break;\n      case 'mediaTypeIn':\n        if (!Array.isArray(value) || value.length === 0 || value.some((v) => typeof v !== 'string')) {\n          error('RUB_VALUE_TYPE', \"'mediaTypeIn' expects a list of MIME globs\", valuePath);\n        }\n        break;\n      case 'maxSizeMB':\n        if (typeof value !== 'number' || value <= 0) error('RUB_VALUE_TYPE', \"'maxSizeMB' expects a positive number\", valuePath);\n        break;\n      case 'withinBoundary':\n        // The `@constant` GeoJSON stand-in is gone (§A.0) — the project area is\n        // the only boundary the format names.\n        if (value !== 'ctx.collection.projectBoundary') {\n          error('RUB_VALUE_TYPE', \"'withinBoundary' expects ctx.collection.projectBoundary\", valuePath);\n        }\n        break;\n      case 'withinRadius': {\n        const spec = value as { center?: unknown; meters?: unknown } | undefined;\n        if (!spec || typeof spec !== 'object' || Array.isArray(spec)) {\n          error('RUB_VALUE_TYPE', \"'withinRadius' expects { center, meters }\", valuePath);\n          break;\n        }\n        if (typeof spec.meters !== 'number' || spec.meters <= 0) error('RUB_VALUE_TYPE', 'meters must be a positive number', `${valuePath}/meters`);\n        if (typeof spec.center === 'string') {\n          const centerKind = checkValueRef(spec.center, `${valuePath}/center`);\n          if (centerKind && centerKind !== 'geo') error('RUB_VALUE_TYPE', 'center must be a geo answer or {lat, lng}', `${valuePath}/center`);\n        } else {\n          const center = spec.center as { lat?: unknown; lng?: unknown } | undefined;\n          if (!center || typeof center.lat !== 'number' || typeof center.lng !== 'number') {\n            error('RUB_VALUE_TYPE', 'center must be a geo answer or {lat, lng}', `${valuePath}/center`);\n          }\n        }\n        break;\n      }\n    }\n  };\n\n  const checkCondition = (cond: RubricCondition | undefined, path: string, forEachTarget?: string) => {\n    if (!cond || typeof cond !== 'object') return; // shape is the JSON Schema's job\n    if ('forEach' in cond && cond.forEach !== undefined) {\n      const targetKind = typeof cond.forEach === 'string' && cond.forEach.startsWith('$') ? checkFieldRef(cond.forEach, `${path}/forEach`) : undefined;\n      if (typeof cond.forEach !== 'string' || !cond.forEach.startsWith('$')) {\n        error('RUB_FIELD_PATH', 'forEach must reference a repeating-rows question', `${path}/forEach`);\n      } else if (targetKind && targetKind !== 'rows') {\n        error('RUB_OPERATOR_TYPE_MISMATCH', `forEach needs a repeating-rows question, '${cond.forEach}' is a ${targetKind}`, `${path}/forEach`);\n      }\n      if (cond.every) checkCondition(cond.every, `${path}/every`, cond.forEach);\n      if (cond.some) checkCondition(cond.some, `${path}/some`, cond.forEach);\n      return;\n    }\n    // Compound shapes — `all`/`any`/`not` RESTORED and `atLeast` added (owner\n    // decision 2026-08-03, superseding the v1.1 §A.0 removal — the linked-rules\n    // design, Part 1). Every member validates like any condition, and the row\n    // scope threads through, so a compound inside a forEach still resolves\n    // row-relative refs. Empty member lists and an out-of-bounds `atLeast`\n    // mirror the engine binder's rejections — authoring errors, never runtime.\n    if ('all' in cond || 'any' in cond) {\n      const key = 'all' in cond ? ('all' as const) : ('any' as const);\n      const members = 'all' in cond ? cond.all : cond.any;\n      if (!Array.isArray(members) || members.length === 0) {\n        error('RUB_SCHEMA', `'${key}' needs at least one check inside it`, `${path}/${key}`);\n        return;\n      }\n      members.forEach((member, i) => checkCondition(member, `${path}/${key}/${i}`, forEachTarget));\n      return;\n    }\n    if ('not' in cond) {\n      checkCondition(cond.not, `${path}/not`, forEachTarget);\n      return;\n    }\n    if ('atLeast' in cond || 'of' in cond) {\n      const { atLeast: n, of: members } = cond as { atLeast?: unknown; of?: unknown };\n      if (!Array.isArray(members) || members.length === 0) {\n        error('RUB_SCHEMA', `'atLeast' needs a non-empty 'of' list of checks`, `${path}/of`);\n        return;\n      }\n      if (typeof n !== 'number' || !Number.isInteger(n) || n < 1) {\n        error('RUB_VALUE_TYPE', `'atLeast' must be a whole number, 1 or more — got ${String(n)}`, `${path}/atLeast`);\n      } else if (n > members.length) {\n        // The condition-level twin of `quorum.need ≤ of` — the same sibling\n        // comparison a JSON Schema cannot state (§A.8/§A.11).\n        error('RUB_QUORUM_INVALID', `atLeast ${n} of ${members.length} — atLeast cannot exceed the number of checks in 'of'`, `${path}/atLeast`);\n      }\n      members.forEach((member, i) => checkCondition(member, `${path}/of/${i}`, forEachTarget));\n      return;\n    }\n    if ('field' in cond) checkSimpleCondition(cond as RubricSimpleCondition, path, forEachTarget);\n  };\n\n  // ---- derived expressions (§A.7) -------------------------------------------\n\n  const checkExpression = (expr: string, path: string, earlierDerived: Set<string>) => {\n    let root: ExprNode;\n    try {\n      root = parseExpression(expr);\n    } catch (e) {\n      error('RUB_EXPR_SYNTAX', e instanceof ExpressionSyntaxError ? e.message : String(e), path);\n      return;\n    }\n\n    // `literal` (a string or true/false) is legal in EXACTLY two positions: the\n    // `op` and `value` arguments of a countWhere call (§A.7). An expr evaluates\n    // to a number and the grammar has no general string/boolean literals —\n    // `\"a\" + \"b\"` is nonsense here — so everywhere else this is a syntax error.\n    const checkNode = (node: ExprNode, allowLiteral: boolean) => {\n      switch (node.kind) {\n        case 'str':\n        case 'bool':\n          if (!allowLiteral) error('RUB_EXPR_SYNTAX', \"string and true/false literals are only legal as countWhere's operator or value\", path);\n          break;\n        case 'ref': {\n          const ref = node.ref;\n          if (ref.startsWith('$')) checkFieldRef(ref, path);\n          else if (ref.startsWith('~')) {\n            const name = ref.slice(1);\n            if (earlierDerived.has(name)) break;\n            if (derivedNames.has(name)) error('RUB_EXPR_SYNTAX', `'${ref}' must be defined earlier in the derived list (no cycles)`, path);\n            else error('RUB_UNKNOWN_REF', `derived value '${ref}' is not defined`, path);\n          } else if (!(RUBRIC_CTX_TOKENS as readonly string[]).includes(ref)) {\n            error('RUB_UNKNOWN_REF', `unknown context token '${ref}'`, path);\n          }\n          break;\n        }\n        case 'call': {\n          const signature = EXPR_FUNCTIONS[node.name];\n          if (!signature) {\n            error('RUB_EXPR_UNKNOWN_FUNC', `'${node.name}' is not in the function library`, path);\n            break;\n          }\n          if (node.args.length < signature.minArgs || node.args.length > signature.maxArgs) {\n            error('RUB_EXPR_SYNTAX', `'${node.name}' takes ${signature.minArgs === signature.maxArgs ? signature.minArgs : `${signature.minArgs}+`} argument(s)`, path);\n          }\n          if (node.name === 'sum' || node.name === 'avg' || node.name === 'count' || node.name === 'countWhere') {\n            const selector = node.args[0];\n            if (!selector || selector.kind !== 'ref' || !selector.ref.includes('[*]')) {\n              error('RUB_EXPR_SYNTAX', `'${node.name}' needs a $rows[*].column selector`, path);\n            }\n          }\n          if (node.name === 'countWhere') {\n            const op = node.args[1];\n            const value = node.args[2];\n            if (!op || op.kind !== 'str' || !(COUNT_WHERE_OPS as readonly string[]).includes(op.value)) {\n              error('RUB_EXPR_SYNTAX', `countWhere's operator must be one of ${COUNT_WHERE_OPS.join(' ')}`, path);\n            } else if (value) {\n              // Ordering comparisons stay numeric — `>` on a string has no\n              // defined meaning here. Equality is the only thing a boolean or\n              // an enum answers, so `==`/`!=` also take those (§A.7).\n              const ordering = (COUNT_WHERE_ORDERING_OPS as readonly string[]).includes(op.value);\n              if (ordering && value.kind !== 'num' && value.kind !== 'ref') {\n                error('RUB_EXPR_SYNTAX', `countWhere's '${op.value}' compares numbers — only == and != take a true/false or text value`, path);\n              }\n            }\n          }\n          // countWhere's op (1) and value (2) are the grammar's only literal positions.\n          node.args.forEach((arg, i) => checkNode(arg, node.name === 'countWhere' && (i === 1 || i === 2)));\n          break;\n        }\n        case 'bin':\n          checkNode(node.left, false);\n          checkNode(node.right, false);\n          break;\n        case 'neg':\n          checkNode(node.operand, false);\n          break;\n        default:\n          break;\n      }\n    };\n    checkNode(root, false);\n  };\n\n  // ---- walk the body ---------------------------------------------------------\n\n  // Duplicate codes: one namespace across gates, criteria, deductions, review\n  // tasks and derived names — a code is a stable identity, reuse breaks receipts.\n  const seenCodes = new Map<string, string>();\n  const checkDuplicate = (code: unknown, path: string) => {\n    if (typeof code !== 'string' || !code) return;\n    const first = seenCodes.get(code);\n    if (first) error('RUB_DUPLICATE_CODE', `'${code}' already used at ${first}`, path);\n    else seenCodes.set(code, path);\n  };\n\n  // Derived (order matters: ~refs may only look backward).\n  const earlier = new Set<string>();\n  (body.derived ?? []).forEach((derived, i) => {\n    if (typeof derived.name !== 'string' || !DERIVED_NAME.test(derived.name)) {\n      error('RUB_EXPR_SYNTAX', `'${String(derived.name)}' is not a valid derived name`, `/derived/${i}/name`);\n    }\n    checkDuplicate(derived.name, `/derived/${i}/name`);\n    if (typeof derived.expr === 'string') checkExpression(derived.expr, `/derived/${i}/expr`, earlier);\n    earlier.add(derived.name);\n  });\n\n  // Gates.\n  (body.gates ?? []).forEach((gate, i) => {\n    checkDuplicate(gate.code, `/gates/${i}/code`);\n    // `class` is required and closed (§A.6). The builder always sets it, so this\n    // only ever fires on a regression that dropped it or a hand-edited document\n    // — closing the gap where a class-less gate would sail past the binder and\n    // be rejected only later by the engine's schema.\n    const klass = (gate as { class?: unknown }).class;\n    if (typeof klass !== 'string' || !(GATE_FAILURE_CLASSES as readonly string[]).includes(klass)) {\n      error('RUB_SCHEMA', `reject rule '${gate.code}' is missing the outcome it declares (it must be one of ${GATE_FAILURE_CLASSES.join(', ')})`, `/gates/${i}/class`);\n    }\n    if (gate.appliesWhen) checkCondition(gate.appliesWhen, `/gates/${i}/appliesWhen`);\n    checkCondition(gate.when, `/gates/${i}/when`);\n  });\n\n  // Scoring.\n  const scoring = body.scoring;\n  const criteria = scoring?.criteria ?? [];\n  const reviewTaskIds = new Set((body.review?.tasks ?? []).map((t) => t.id));\n  if (scoring) {\n    const { approveAt, partialFloor, reviewFloor } = scoring;\n    if (typeof partialFloor === 'number' && approveAt <= partialFloor) {\n      error('RUB_THRESHOLD_ORDER', `approveAt (${approveAt}) must be greater than partialFloor (${partialFloor})`, '/scoring');\n    }\n    if (typeof reviewFloor === 'number' && approveAt <= reviewFloor) {\n      error('RUB_THRESHOLD_ORDER', `approveAt (${approveAt}) must be greater than reviewFloor (${reviewFloor})`, '/scoring');\n    }\n    if (typeof partialFloor === 'number' && typeof reviewFloor === 'number' && partialFloor < reviewFloor) {\n      error('RUB_THRESHOLD_ORDER', `partialFloor (${partialFloor}) must be at least reviewFloor (${reviewFloor})`, '/scoring');\n    }\n    // `need ≤ of` is the one quorum rule a JSON Schema cannot state (it can't\n    // compare two siblings), so it is ours (§A.8/§A.11). The method↔`quorum`\n    // COUPLING is shape — the engine's `oneOf` reports it as RUB_SCHEMA — so\n    // it is deliberately not re-checked here.\n    const quorum = scoring.quorum;\n    if (quorum && typeof quorum.need === 'number' && typeof quorum.of === 'number' && quorum.need > quorum.of) {\n      error('RUB_QUORUM_INVALID', `quorum needs ${quorum.need} of ${quorum.of} — need cannot exceed of`, '/scoring/quorum');\n    }\n\n    // `weight` is read by `weighted_average` alone; under the other three it is\n    // inert, so stars the author set do nothing. ONE warning on the method (the\n    // thing that would have to change), never one per criterion — and never a\n    // block: the key stays in the document so swapping the method back keeps\n    // the author's intent.\n    if (scoring.method !== 'weighted_average' && criteria.length > 0) {\n      warn('RUB_WEIGHT_IGNORED', `'${scoring.method}' combines rules by min/count and never reads weights — the stars set on your scored rules have no effect`, '/scoring/method');\n    }\n\n    criteria.forEach((criterion, i) => {\n      const path = `/scoring/criteria/${i}`;\n      checkDuplicate(criterion.code, `${path}/code`);\n      if (typeof criterion.weight !== 'number' || !Number.isInteger(criterion.weight) || criterion.weight < 1 || criterion.weight > 5) {\n        error('RUB_WEIGHT_INVALID', `weight must be an integer 1..5, got ${String(criterion.weight)}`, `${path}/weight`);\n      }\n      if (criterion.appliesWhen) checkCondition(criterion.appliesWhen, `${path}/appliesWhen`);\n      checkScoreNode(criterion, `${path}/score`);\n    });\n  }\n\n  function checkScoreNode(criterion: RubricCriterion, path: string) {\n    const score = criterion.score as RubricScoreNode | undefined;\n    if (!score || typeof score !== 'object') return; // shape is the JSON Schema's job\n    switch (score['@type']) {\n      case 'BooleanScore':\n        checkCondition(score.when, `${path}/when`);\n        break;\n      case 'BandsScore':\n        checkNumericValueRef(score.value, `${path}/value`, 'BandsScore');\n        (score.bands ?? []).forEach((band, i) => {\n          if ('op' in band) checkNumericAnchor(band.value, `${path}/bands/${i}/value`);\n        });\n        checkBandsReachable(score.bands, `${path}/bands`);\n        break;\n      case 'LinearScore':\n        checkNumericValueRef(score.value, `${path}/value`, 'LinearScore');\n        checkNumericAnchor(score.zeroAt, `${path}/zeroAt`);\n        checkNumericAnchor(score.fullAt, `${path}/fullAt`);\n        break;\n      case 'LevelsScore': {\n        let elseAt = -1;\n        (score.levels ?? []).forEach((level, i) => {\n          if (elseAt >= 0) warn('RUB_UNREACHABLE_BAND', `level shadowed by the catch-all level at index ${elseAt}`, `${path}/levels/${i}`);\n          if ('else' in level && level.else) elseAt = i;\n          else if ('when' in level) checkCondition(level.when, `${path}/levels/${i}/when`);\n        });\n        break;\n      }\n      case 'MapScore': {\n        if (typeof score.value === 'string' && score.value.startsWith('$')) checkFieldRef(score.value, `${path}/value`);\n        else if (typeof score.value === 'string' && score.value.startsWith('~')) checkValueRef(score.value, `${path}/value`);\n        else error('RUB_FIELD_PATH', 'MapScore.value must be a $answer or ~derived ref', `${path}/value`);\n        break;\n      }\n      case 'DeductionsScore':\n        (score.deduct ?? []).forEach((deduction, i) => {\n          checkDuplicate(deduction.code, `${path}/deduct/${i}/code`);\n          checkCondition(deduction.when, `${path}/deduct/${i}/when`);\n        });\n        break;\n      case 'ManualScore':\n        if (typeof score.field === 'string' && score.field.startsWith('$')) checkFieldRef(score.field, `${path}/field`);\n        else error('RUB_FIELD_PATH', 'ManualScore.field must be a $answer ref', `${path}/field`);\n        if (!reviewTaskIds.has(score.reviewTask)) {\n          error('RUB_REVIEW_TASK_UNMAPPED', `ManualScore names review task '${String(score.reviewTask)}' but no such task exists`, `${path}/reviewTask`);\n        }\n        break;\n      default:\n        break;\n    }\n  }\n\n  /**\n   * A numeric anchor (§A.8): a plain number, or a `~derived` ref that resolves\n   * to one — nothing else (format v1.1, §A.0: `@constant` anchors are gone).\n   * NOT a `$field` — an anchor is a fixed point of the scale, not another\n   * answer (the engine's `NumberOrRef` says the same).\n   */\n  function checkNumericAnchor(value: unknown, path: string) {\n    if (typeof value === 'number') return;\n    if (typeof value !== 'string' || !value.startsWith('~')) {\n      error('RUB_VALUE_TYPE', `'${String(value)}' is not a number — an anchor takes a number or a ~calculated value`, path);\n      return;\n    }\n    const kind = checkValueRef(value, path);\n    if (kind && kind !== 'number') error('RUB_VALUE_TYPE', `'${value}' is a ${kind}, expected a number`, path);\n  }\n\n  function checkNumericValueRef(value: unknown, path: string, node: string) {\n    if (typeof value !== 'string' || !(value.startsWith('$') || value.startsWith('~') || value.startsWith('ext.'))) {\n      error('RUB_FIELD_PATH', `${node}.value must be a $answer, ~derived, or ext.<name>.score ref`, path);\n      return;\n    }\n    const kind = value.startsWith('$') ? checkFieldRef(value, path) : checkValueRef(value, path);\n    if (kind && kind !== 'number') error('RUB_OPERATOR_TYPE_MISMATCH', `${node} needs a number, '${value}' is a ${kind}`, path);\n  }\n\n  function checkBandsReachable(bands: RubricBand[] | undefined, path: string) {\n    if (!Array.isArray(bands)) return;\n    let elseAt = -1;\n    bands.forEach((band, i) => {\n      if (elseAt >= 0) {\n        warn('RUB_UNREACHABLE_BAND', `band shadowed by the catch-all band at index ${elseAt}`, `${path}/${i}`);\n        return;\n      }\n      if ('else' in band && band.else) {\n        elseAt = i;\n        return;\n      }\n      for (let j = 0; j < i; j++) {\n        const earlierBand = bands[j];\n        if ('else' in earlierBand) continue;\n        if ('op' in band && bandCovers(earlierBand, band)) {\n          warn('RUB_UNREACHABLE_BAND', `band shadowed by the band at index ${j}`, `${path}/${i}`);\n          break;\n        }\n      }\n    });\n  }\n\n  // Review tasks.\n  (body.review?.tasks ?? []).forEach((task, i) => {\n    const path = `/review/tasks/${i}`;\n    checkDuplicate(task.id, `${path}/id`);\n    (task.show ?? []).forEach((ref, j) => {\n      if (typeof ref === 'string' && ref.startsWith('$')) checkFieldRef(ref, `${path}/show/${j}`);\n      else error('RUB_FIELD_PATH', 'show entries must be $answer refs', `${path}/show/${j}`);\n    });\n    const map = task.map ?? {};\n    for (const [answer, verdict] of Object.entries(map)) {\n      if (verdict !== 'approve' && verdict !== 'partial' && verdict !== 'reject') {\n        error('RUB_VALUE_TYPE', `answer '${answer}' maps to '${String(verdict)}' — must be approve | partial | reject`, `${path}/map/${answer}`);\n      }\n    }\n    // EVERY possible answer must be mapped — now fully enforceable, because\n    // answers are enumerable by construction (§A.9): `true`/`false` for a\n    // boolean, every `option` for an enum. Free number/text answers are gone\n    // precisely because this check could not be run against them.\n    const required = task.answer?.type === 'boolean' ? ['true', 'false'] : task.answer?.options ?? [];\n    for (const answer of required) {\n      if (!(answer in map)) error('RUB_REVIEW_ANSWER_UNMAPPED', `answer '${answer}' has no verdict mapping`, `${path}/map`);\n    }\n  });\n\n  // External sources (§A.14). The nodes themselves — unique names, a `did:web:`\n  // audience, an `http(s)://` endpoint, a non-empty payload — plus every ref a\n  // `send` value carries (a `$field`/`~derived`/`ctx.*` must resolve).\n  // These are shape checks the engine's schema also makes; catching them here\n  // names the offending source before publish instead of at the served-schema\n  // gate (mirrors the gate-class check above → `RUB_SCHEMA`).\n  const seenSourceNames = new Set<string>();\n  (body.sources ?? []).forEach((source: RubricExternalSource, i) => {\n    const path = `/sources/${i}`;\n    const name = source.name;\n    if (typeof name !== 'string' || !SOURCE_NAME.test(name)) {\n      error('RUB_SCHEMA', `external check name '${String(name)}' may use only letters, numbers, dashes and underscores`, `${path}/name`);\n    } else if (seenSourceNames.has(name)) {\n      error('RUB_SCHEMA', `two external checks are named '${name}' — a name must be unique so ext.${name}.* points at one`, `${path}/name`);\n    } else {\n      seenSourceNames.add(name);\n    }\n    if (typeof source.endpoint !== 'string' || !/^https?:\\/\\//.test(source.endpoint)) {\n      error('RUB_SCHEMA', `external check '${String(name)}' needs a web address starting with http:// or https://`, `${path}/endpoint`);\n    }\n    if (typeof source.audience !== 'string' || !/^did:web:/.test(source.audience)) {\n      error('RUB_SCHEMA', `external check '${String(name)}' needs an audience starting with did:web:`, `${path}/audience`);\n    }\n    const send = source.send;\n    if (!send || typeof send !== 'object' || Array.isArray(send) || Object.keys(send).length === 0) {\n      error('RUB_SCHEMA', `external check '${String(name)}' must send at least one value`, `${path}/send`);\n    } else {\n      for (const [key, value] of Object.entries(send)) {\n        // Send keys STAY `^[A-Za-z0-9_-]+$` (the engine's INTERNAL_NAME) even\n        // now that question names may carry a `namespace:` prefix — a\n        // namespaced ref is aliased to a legal key by the sendKey sanitizer,\n        // which is load-bearing here, not cosmetic. The engine 400s on a key\n        // with a colon or a space just as it does on a bad name.\n        if (!SOURCE_NAME.test(key)) {\n          error('RUB_SCHEMA', `external check '${String(name)}' has a send key '${key}' that may use only letters, numbers, dashes and underscores`, `${path}/send/${key}`);\n        }\n        // A send value is a ref (resolve it) or a literal (nothing to bind).\n        if (isRefString(value)) checkValueRef(value, `${path}/send/${key}`);\n      }\n    }\n  });\n\n  // AI checks (§A.15) — the same node discipline as sources: unique names, a\n  // non-empty payload with resolvable refs, and at least one non-empty rule to\n  // check against (an AI asked to check nothing is an authoring error).\n  const seenAiNames = new Set<string>();\n  (body.aiChecks ?? []).forEach((check, i) => {\n    const path = `/aiChecks/${i}`;\n    const name = check.name;\n    if (typeof name !== 'string' || !SOURCE_NAME.test(name)) {\n      error('RUB_SCHEMA', `AI check name '${String(name)}' may use only letters, numbers, dashes and underscores`, `${path}/name`);\n    } else if (seenAiNames.has(name)) {\n      error('RUB_SCHEMA', `two AI checks are named '${name}' — a name must be unique so ai.${name}.* points at one`, `${path}/name`);\n    } else {\n      seenAiNames.add(name);\n    }\n    const instructions = check.instructions;\n    if (!Array.isArray(instructions) || instructions.filter((rule) => typeof rule === 'string' && rule.trim().length > 0).length === 0) {\n      error('RUB_SCHEMA', `AI check '${String(name)}' has nothing to check — write at least one rule for the AI`, `${path}/instructions`);\n    }\n    const send = check.send;\n    if (!send || typeof send !== 'object' || Array.isArray(send) || Object.keys(send).length === 0) {\n      error('RUB_SCHEMA', `AI check '${String(name)}' must send at least one value`, `${path}/send`);\n    } else {\n      for (const [key, value] of Object.entries(send)) {\n        if (!SOURCE_NAME.test(key)) {\n          error('RUB_SCHEMA', `AI check '${String(name)}' has a send key '${key}' that may use only letters, numbers, dashes and underscores`, `${path}/send/${key}`);\n        }\n        if (isRefString(value)) checkValueRef(value, `${path}/send/${key}`);\n      }\n    }\n  });\n\n  // The duplicate rule (dup-detection spec §6): every `by` key entry — a plain\n  // ref or `{ref, granularity}` — must name an ANSWER field. The engine binds\n  // the key strictly through the field catalog (bind.ts `unique.by`, spec §10),\n  // so a `~derived` ref is BIND_FIELD there — the rubric becomes unusable for\n  // every claim. Rejecting it here, even when defined, is what keeps a rubric\n  // the editor calls clean publishable. `checkFieldRef` also gives the drift\n  // run its words: a key question deleted since authoring reads as \"the form\n  // changed\" (RUB_SCHEMA_DRIFT), not as a broken rule. The threshold order\n  // bound is the engine's Zod refine and the sliders'; a hand-authored\n  // violation is the engine preflight's to name.\n  (body.unique?.by ?? []).forEach((entry, i) => {\n    const ref = typeof entry === 'string' ? entry : entry?.ref;\n    const path = `/unique/by/${i}`;\n    if (typeof ref !== 'string' || ref.length === 0) {\n      error('RUB_FIELD_PATH', 'a unique-key entry must be a field reference', path);\n    } else if (ref.startsWith('~')) {\n      error('RUB_UNIQUE_KEY_DERIVED', `calculated value '${ref}' cannot be part of the unique key — pick answer fields`, path);\n    } else if (ref.startsWith('$')) {\n      checkFieldRef(ref, path);\n    } else {\n      error('RUB_FIELD_PATH', `'${ref}' is not an answer-field reference ($answer)`, path);\n    }\n  });\n\n  // Settlement.\n  const prorateBy = body.settlement?.onPartial?.prorateBy;\n  if (prorateBy !== undefined && prorateBy !== 'total' && prorateBy !== 'none') {\n    if (typeof prorateBy === 'string' && (prorateBy.startsWith('$') || prorateBy.startsWith('~'))) {\n      checkValueRef(prorateBy, '/settlement/onPartial/prorateBy');\n    } else {\n      error('RUB_VALUE_TYPE', \"prorateBy must be 'total', 'none', or a $answer/~derived fraction\", '/settlement/onPartial/prorateBy');\n    }\n  }\n\n  // Nothing to check at all? An ERROR, not a warning (owner decision, 2026-08-03): the engine\n  // treats an empty aggregate as a full score (evaluator rule S5), so a rules-less rubric\n  // silently APPROVES — and charges for — every claim. Blocking here blocks stage-1 preflight.\n  if ((body.gates ?? []).length === 0 && criteria.length === 0) {\n    error('RUB_NO_RULES', 'no rules at all — this rubric would approve (and charge for) every claim; add at least one rule', '');\n  }\n\n  return diags;\n}\n\n// ---------------------------------------------------------------------------\n// helpers\n// ---------------------------------------------------------------------------\n\nfunction indexCatalog(catalog: RubricFieldCatalog): Map<string, RubricField> {\n  const index = new Map<string, RubricField>();\n  const add = (field: RubricField) => {\n    index.set(field.path, field);\n    field.columns?.forEach(add);\n  };\n  for (const field of catalog.fields ?? []) add(field);\n  return index;\n}\n\ntype ComparisonBand = { op: '>' | '>=' | '<' | '<=' | '=='; value: RubricNumberOrRef };\n\n/**\n * True when every value the later band matches is already caught by the earlier\n * one. Only decidable between two literal steps: once a step is a `~derived`\n * ref (§A.8), its value isn't known until evaluation, so shadowing can't be\n * proven here and we stay silent rather than guess — this warning must never\n * cry wolf about a band that is actually reachable.\n */\nfunction bandCovers(earlier: RubricBand, later: ComparisonBand): boolean {\n  if (!('op' in earlier)) return false;\n  const [a, b] = [earlier.value, later.value];\n  if (typeof a !== 'number' || typeof b !== 'number') return false;\n  switch (earlier.op) {\n    case '>=':\n      return later.op === '>=' || later.op === '>' ? a <= b : later.op === '==' ? b >= a : false;\n    case '>':\n      return later.op === '>' ? a <= b : later.op === '>=' ? a < b : later.op === '==' ? b > a : false;\n    case '<=':\n      return later.op === '<=' || later.op === '<' ? a >= b : later.op === '==' ? b <= a : false;\n    case '<':\n      return later.op === '<' ? a >= b : later.op === '<=' ? a > b : later.op === '==' ? b < a : false;\n    case '==':\n      return later.op === '==' && a === b;\n    default:\n      return false;\n  }\n}\n\n/**\n * Conservative allowlist parse of the `matches` regex subset (§A.4/§A.11):\n * literals, escapes (no backreferences), character classes, `(?:…)`/capturing\n * groups, alternation, and quantifiers — with NO lookaround and none of the\n * catastrophic-backtracking shapes. Two shapes are rejected:\n *\n *  1. an unbounded quantifier over content that itself repeats unboundedly\n *     (`(a+)+`, `(a*)*`), and\n *  2. an unbounded quantifier over a group whose alternatives OVERLAP —\n *     `(a|a)*`, `(a|ab)+`, `(\\d|\\d)*` — the ambiguous-alternation shape that\n *     also backtracks catastrophically.\n *\n * Overlap is decided by a conservative first-character test: two alternatives\n * overlap unless both begin with a KNOWN, DIFFERENT literal character. A class,\n * an escape (`\\d`), `.`, a nested group, or an alternative that can start empty\n * all read as \"could match anything here\" and so conservatively overlap — false\n * positives (an over-cautious reject) are acceptable, a false negative is not.\n * Returns the reason, or null when safe.\n */\ntype RegexFirst = { wild: true } | { wild: false; char: string };\ntype RegexNode = { unbounded: boolean; ambiguous: boolean; first: RegexFirst };\n\nfunction firstOverlap(a: RegexFirst, b: RegexFirst): boolean {\n  if (a.wild || b.wild) return true;\n  return a.char === b.char;\n}\n\nfunction unsafeRegexReason(src: string): string | null {\n  let pos = 0;\n\n  const parseAlternation = (): RegexNode => {\n    let unbounded = false;\n    let ambiguous = false;\n    const firsts: RegexFirst[] = [];\n    let first: RegexFirst = { wild: true };\n    let atStart = true;\n    for (;;) {\n      const seq = parseSequence();\n      if (atStart) {\n        first = seq.first;\n        atStart = false;\n      }\n      unbounded = seq.unbounded || unbounded;\n      ambiguous = seq.ambiguous || ambiguous;\n      firsts.push(seq.first);\n      if (src[pos] === '|') {\n        pos++;\n        continue;\n      }\n      break;\n    }\n    // An alternation with two branches that could start on the same character\n    // is ambiguous — repeat it unboundedly and it backtracks catastrophically.\n    if (firsts.length > 1) {\n      for (let i = 0; i < firsts.length && !ambiguous; i++) {\n        for (let j = i + 1; j < firsts.length; j++) {\n          if (firstOverlap(firsts[i], firsts[j])) {\n            ambiguous = true;\n            break;\n          }\n        }\n      }\n    }\n    return { unbounded, ambiguous, first };\n  };\n\n  const parseSequence = (): RegexNode => {\n    let unbounded = false;\n    let ambiguous = false;\n    let first: RegexFirst = { wild: true };\n    let atStart = true;\n    while (pos < src.length && src[pos] !== '|' && src[pos] !== ')') {\n      const atom = parseAtom();\n      const quantifier = parseQuantifier();\n      if (atStart) {\n        // A first atom that can match nothing (`a?`, `a*`) leaves the sequence\n        // able to start on whatever follows — read the whole sequence as wild.\n        first = quantifier?.nullable ? { wild: true } : atom.first;\n        atStart = false;\n      }\n      if (quantifier?.unbounded) {\n        if (atom.unbounded) throw new Error('unbounded repetition nested inside unbounded repetition');\n        if (atom.ambiguous) throw new Error('a repeated group with overlapping choices can backtrack catastrophically');\n        unbounded = true;\n      }\n      unbounded = unbounded || atom.unbounded;\n      ambiguous = ambiguous || atom.ambiguous;\n    }\n    return { unbounded, ambiguous, first };\n  };\n\n  const parseAtom = (): RegexNode => {\n    const ch = src[pos];\n    if (ch === '(') {\n      pos++;\n      if (src[pos] === '?') {\n        if (src[pos + 1] === ':') pos += 2;\n        else throw new Error('lookaround and special groups are not allowed');\n      }\n      const inner = parseAlternation();\n      if (src[pos] !== ')') throw new Error('unbalanced group');\n      pos++;\n      // A group is opaque to an OUTER alternation's first-character test.\n      return { unbounded: inner.unbounded, ambiguous: inner.ambiguous, first: { wild: true } };\n    }\n    if (ch === '[') {\n      pos++;\n      if (src[pos] === '^') pos++;\n      if (src[pos] === ']') pos++; // leading ] is a literal\n      while (pos < src.length && src[pos] !== ']') {\n        if (src[pos] === '\\\\') pos++;\n        pos++;\n      }\n      if (src[pos] !== ']') throw new Error('unterminated character class');\n      pos++;\n      return { unbounded: false, ambiguous: false, first: { wild: true } };\n    }\n    if (ch === '\\\\') {\n      const next = src[pos + 1];\n      if (next === undefined) throw new Error('dangling escape');\n      if (/[1-9]/.test(next)) throw new Error('backreferences are not allowed');\n      if (next === 'k') throw new Error('named backreferences are not allowed');\n      pos += 2;\n      // A class escape (`\\d`) matches a set; treat every escape as wild rather\n      // than reason about which one — conservative, and cheap.\n      return { unbounded: false, ambiguous: false, first: { wild: true } };\n    }\n    if (ch === '*' || ch === '+' || ch === '?') throw new Error('quantifier without a target');\n    pos++; // any other literal (including . ^ $ and a literal brace)\n    // `.` matches anything; anchors carry no character. Only a plain literal has\n    // a known first character we can use to prove two alternatives disjoint.\n    const first: RegexFirst = ch === '.' || ch === '^' || ch === '$' ? { wild: true } : { wild: false, char: ch };\n    return { unbounded: false, ambiguous: false, first };\n  };\n\n  const parseQuantifier = (): { unbounded: boolean; nullable: boolean } | null => {\n    const ch = src[pos];\n    if (ch === '*') {\n      pos++;\n      if (src[pos] === '?') pos++; // lazy\n      return { unbounded: true, nullable: true };\n    }\n    if (ch === '+') {\n      pos++;\n      if (src[pos] === '?') pos++;\n      return { unbounded: true, nullable: false };\n    }\n    if (ch === '?') {\n      pos++;\n      if (src[pos] === '?') pos++;\n      return { unbounded: false, nullable: true };\n    }\n    if (ch === '{') {\n      const match = /^\\{(\\d+)(?:(,)(\\d+)?)?\\}/.exec(src.slice(pos));\n      if (!match) return null; // literal brace, not a quantifier\n      pos += match[0].length;\n      if (src[pos] === '?') pos++;\n      return { unbounded: match[2] === ',' && match[3] === undefined, nullable: Number(match[1]) === 0 };\n    }\n    return null;\n  };\n\n  try {\n    parseAlternation();\n    if (pos < src.length) throw new Error('unbalanced group');\n    return null;\n  } catch (e) {\n    return e instanceof Error ? e.message : String(e);\n  }\n}\n"],"mappings":"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","names":["FIELD_REF"]}

package/dist/chunk-NJAII6CO.js

@@ -0,0 +1,148 @@
+import {
+  DECIMALS,
+  IXO_DENOM,
+  USDC_DENOM
+} from "./chunk-YN4CEKCF.js";
+import {
+  DIFFERENT_WHEN_OTHER_MAX,
+  WHAT_IS_COLLECTED_MAX,
+  normalizeDifferentWhen,
+  normalizeRepeatSubmissions,
+  parseEvalRubricInputs
+} from "./chunk-NIXT2SBH.js";
+
+// src/mantine/blocks/action/actionTypes/evalRegister/types.ts
+function coinArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((coin) => typeof coin?.denom === "string" && !!coin.denom && Number(coin?.amount) > 0).map((coin) => ({ denom: coin.denom, amount: String(coin.amount) }));
+}
+function optionalString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+var DEFAULT_ENGINE_SETTINGS = {
+  allowAiChecks: true,
+  allowImageChecks: true,
+  allowChainEvaluation: true,
+  // The one setting that defaults OFF: turning it on lets a zero-payout approval land irreversibly
+  // on chain, so it has to be a thing the owner chose, never a thing a default chose for them.
+  allowZeroPayoutApprovals: false
+};
+function parseEvalRegisterActionInputs(json) {
+  try {
+    const parsed = typeof json === "string" ? json ? JSON.parse(json) : {} : json || {};
+    const allowAiChecks = parsed?.allowAiChecks !== false;
+    return {
+      deedDid: typeof parsed?.deedDid === "string" ? parsed.deedDid : "",
+      collectionId: typeof parsed?.collectionId === "string" ? parsed.collectionId : "",
+      displayName: optionalString(parsed?.displayName),
+      notifyEmail: optionalString(parsed?.notifyEmail),
+      whatIsCollected: optionalString(parsed?.whatIsCollected),
+      // Unknown choices are dropped, not carried: only this version's options can ever reach
+      // the composed sentence.
+      repeatSubmissions: normalizeRepeatSubmissions(parsed?.repeatSubmissions),
+      differentWhen: normalizeDifferentWhen(parsed?.differentWhen),
+      differentWhenOther: optionalString(parsed?.differentWhenOther),
+      allowAiChecks,
+      // Image detection lives inside the AI lane — never true without it.
+      allowImageChecks: allowAiChecks && parsed?.allowImageChecks !== false,
+      allowChainEvaluation: parsed?.allowChainEvaluation !== false,
+      // `=== true` here, deliberately unlike the three above: absent must read OFF, because absent
+      // means "never configured" and no owner has consented to a zero payout landing on chain.
+      allowZeroPayoutApprovals: parsed?.allowZeroPayoutApprovals === true,
+      evaluateMaxAmount: coinArray(parsed?.evaluateMaxAmount),
+      oracleDid: optionalString(parsed?.oracleDid),
+      evalEngineUrl: optionalString(parsed?.evalEngineUrl),
+      ucanStoreUrl: optionalString(parsed?.ucanStoreUrl),
+      rubricId: optionalString(parsed?.rubricId)
+    };
+  } catch {
+    return {
+      deedDid: "",
+      collectionId: "",
+      ...DEFAULT_ENGINE_SETTINGS,
+      evaluateMaxAmount: []
+    };
+  }
+}
+function serializeEvalRegisterActionInputs(inputs) {
+  const blob = {
+    deedDid: inputs.deedDid,
+    collectionId: inputs.collectionId,
+    allowAiChecks: inputs.allowAiChecks === true,
+    allowImageChecks: inputs.allowAiChecks === true && inputs.allowImageChecks === true,
+    allowChainEvaluation: inputs.allowChainEvaluation === true,
+    allowZeroPayoutApprovals: inputs.allowZeroPayoutApprovals === true
+  };
+  const evaluateMaxAmount = coinArray(inputs.evaluateMaxAmount);
+  if (evaluateMaxAmount.length) blob.evaluateMaxAmount = evaluateMaxAmount;
+  if (inputs.displayName?.trim()) blob.displayName = inputs.displayName.trim().slice(0, 120);
+  if (inputs.notifyEmail?.trim()) blob.notifyEmail = inputs.notifyEmail.trim();
+  if (inputs.whatIsCollected?.trim()) blob.whatIsCollected = inputs.whatIsCollected.trim().slice(0, WHAT_IS_COLLECTED_MAX);
+  const repeatSubmissions = normalizeRepeatSubmissions(inputs.repeatSubmissions);
+  if (repeatSubmissions) blob.repeatSubmissions = repeatSubmissions;
+  const differentWhen = normalizeDifferentWhen(inputs.differentWhen);
+  if (differentWhen.length) blob.differentWhen = differentWhen;
+  if (inputs.differentWhenOther?.trim()) blob.differentWhenOther = inputs.differentWhenOther.trim().slice(0, DIFFERENT_WHEN_OTHER_MAX);
+  if (inputs.oracleDid?.trim()) blob.oracleDid = inputs.oracleDid.trim();
+  if (inputs.evalEngineUrl?.trim()) blob.evalEngineUrl = inputs.evalEngineUrl.trim();
+  if (inputs.ucanStoreUrl?.trim()) blob.ucanStoreUrl = inputs.ucanStoreUrl.trim();
+  if (inputs.rubricId?.trim()) blob.rubricId = inputs.rubricId.trim();
+  return JSON.stringify(blob);
+}
+
+// src/mantine/blocks/action/actionTypes/evalEngine/types.ts
+function parseEvalEngineInputs(json) {
+  const { rubricId: _producedByRun, ...register } = parseEvalRegisterActionInputs(json);
+  const { rubric, claimSchemaSnapshot } = parseEvalRubricInputs(json);
+  return { ...register, rubric, claimSchemaSnapshot };
+}
+function serializeEvalEngineInputs(inputs) {
+  const { rubric, claimSchemaSnapshot, ...register } = inputs;
+  const blob = JSON.parse(serializeEvalRegisterActionInputs({ ...register, rubricId: void 0 }));
+  return JSON.stringify({ ...blob, rubric, claimSchemaSnapshot });
+}
+
+// src/mantine/blocks/action/actionTypes/evalRegister/grantCaps.ts
+var EMPTY_GRANT_CAP = { ixo: "", usdc: "" };
+function toBaseUnits(displayAmount) {
+  const trimmed = String(displayAmount ?? "").trim();
+  const n = Number(trimmed);
+  if (!Number.isFinite(n) || n <= 0) return "0";
+  const [intPart = "", fracRaw = ""] = trimmed.split(".");
+  const frac = fracRaw.slice(0, DECIMALS).padEnd(DECIMALS, "0");
+  return `${intPart}${frac}`.replace(/^0+/, "") || "0";
+}
+function fromBaseUnits(baseAmount) {
+  const n = Number(baseAmount);
+  if (!Number.isFinite(n)) return String(baseAmount ?? "");
+  return String(n / 10 ** DECIMALS);
+}
+function buildCapCoins(values) {
+  return [
+    { denom: IXO_DENOM, amount: values.ixo },
+    { denom: USDC_DENOM, amount: values.usdc }
+  ].filter((coin) => Number(coin.amount) > 0).map((coin) => ({ denom: coin.denom, amount: toBaseUnits(coin.amount) }));
+}
+function capValuesFromCoins(coins) {
+  if (!Array.isArray(coins)) return EMPTY_GRANT_CAP;
+  const find = (denom) => coins.find((c) => c?.denom === denom)?.amount;
+  const ixo = find(IXO_DENOM);
+  const usdc = find(USDC_DENOM);
+  return {
+    ixo: ixo ? fromBaseUnits(ixo) : "",
+    usdc: usdc ? fromBaseUnits(usdc) : ""
+  };
+}
+function formatCapCoins(coins, emptyLabel) {
+  if (!Array.isArray(coins) || coins.length === 0) return emptyLabel;
+  return coins.map((coin) => `${fromBaseUnits(coin.amount)} ${coin.denom === IXO_DENOM ? "IXO" : coin.denom === USDC_DENOM ? "USDC" : coin.denom}`).join(" \xB7 ");
+}
+
+export {
+  parseEvalEngineInputs,
+  serializeEvalEngineInputs,
+  buildCapCoins,
+  capValuesFromCoins,
+  formatCapCoins
+};
+//# sourceMappingURL=chunk-NJAII6CO.js.map