@felspar/sdk 0.4.0 → 0.4.1

package/dist/chunks/{chunk-MIPPJBXB.js → chunk-PYLLH47S.js}

@@ -51,26 +51,26 @@ function append(token, state, bytes = utf8Bytes(token)) {
   state.parts.push(state.buffer);
   state.buffer = "";
 }
-function quoted(value) {
-  if (value.length > canonicalJsonLimits.maxBytes) {
+function quoted(value2) {
+  if (value2.length > canonicalJsonLimits.maxBytes) {
     throw new RangeError("Canonical JSON string exceeds the byte limit");
   }
-  if (/[\uD800-\uDFFF]/u.test(value)) {
+  if (/[\uD800-\uDFFF]/u.test(value2)) {
     throw new TypeError("Canonical JSON requires valid Unicode strings");
   }
-  return JSON.stringify(value);
+  return JSON.stringify(value2);
 }
-function appendQuoted(value, state) {
-  let entry2 = state.strings.get(value);
-  if (!entry2) {
-    const token = quoted(value);
-    entry2 = { token, bytes: utf8Bytes(token) };
-    if (state.strings.size < 256 && state.stringBytes + entry2.bytes <= 65536) {
-      state.strings.set(value, entry2);
-      state.stringBytes += entry2.bytes;
+function appendQuoted(value2, state) {
+  let entry3 = state.strings.get(value2);
+  if (!entry3) {
+    const token = quoted(value2);
+    entry3 = { token, bytes: utf8Bytes(token) };
+    if (state.strings.size < 256 && state.stringBytes + entry3.bytes <= 65536) {
+      state.strings.set(value2, entry3);
+      state.stringBytes += entry3.bytes;
     }
   }
-  append(entry2.token, state, entry2.bytes);
+  append(entry3.token, state, entry3.bytes);
 }
 function dataValue(input, key3) {
   const descriptor = Object.getOwnPropertyDescriptor(input, key3);
@@ -131,13 +131,13 @@ function writeObject(input, state, depth) {
   }
   append("}", state);
 }
-function writeSealed(entry2, state, depth) {
-  state.nodes += entry2.nodes - 1;
-  if (depth + entry2.height > canonicalJsonLimits.maxDepth || state.nodes > canonicalJsonLimits.maxNodes) {
+function writeSealed(entry3, state, depth) {
+  state.nodes += entry3.nodes - 1;
+  if (depth + entry3.height > canonicalJsonLimits.maxDepth || state.nodes > canonicalJsonLimits.maxNodes) {
     throw new RangeError("Canonical JSON exceeds the depth or node limit");
   }
-  state.height = Math.max(state.height, depth + entry2.height);
-  append(entry2.json, state, entry2.bytes);
+  state.height = Math.max(state.height, depth + entry3.height);
+  append(entry3.json, state, entry3.bytes);
 }
 function writeContainer(input, state, depth) {
   const sealed = sealedEntries.get(input);
@@ -266,12 +266,12 @@ function sealValue(input, depth, state) {
     throw new RangeError("Canonical JSON exceeds the depth, node or byte limit");
   }
   Object.freeze(input);
-  const entry2 = { json, bytes, nodes, height };
+  const entry3 = { json, bytes, nodes, height };
   sealedContainers.add(input);
   if (bytes >= sealedEntryMinimumBytes) {
-    sealedEntries.set(input, entry2);
+    sealedEntries.set(input, entry3);
   }
-  return entry2;
+  return entry3;
 }
 function sealCanonicalJson(input) {
   sealValue(input, 0, { ancestors: /* @__PURE__ */ new Set() });
@@ -316,8 +316,8 @@ async function sha256(text8) {
   const hash = new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(text8)));
   return `sha256:${Array.from(hash, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
 }
-function reference(digest28) {
-  return { [draftContentPartReferenceKey]: digest28 };
+function reference(digest29) {
+  return { [draftContentPartReferenceKey]: digest29 };
 }
 var referenceBytes = utf8(canonicalizeJson(reference(`sha256:${"0".repeat(64)}`)));
 var logicalLimit = "Content parts exceed the logical byte, node or depth limit";
@@ -326,12 +326,12 @@ function admit(logical, depth) {
     throw new RangeError(logicalLimit);
   }
 }
-function scalar(value) {
-  if (value === void 0 || typeof value === "function" || typeof value === "symbol") {
+function scalar(value2) {
+  if (value2 === void 0 || typeof value2 === "function" || typeof value2 === "symbol") {
     throw new TypeError("Content parts require JSON values");
   }
-  const bytes = utf8(JSON.stringify(value));
-  return { value, tokenBytes: bytes, logical: { bytes, nodes: 1, height: 0 } };
+  const bytes = utf8(JSON.stringify(value2));
+  return { value: value2, tokenBytes: bytes, logical: { bytes, nodes: 1, height: 0 } };
 }
 function combine(keys, children) {
   let tokenBytes = 2 + Math.max(children.length - 1, 0);
@@ -350,8 +350,8 @@ function combine(keys, children) {
 }
 var hydratedValues = /* @__PURE__ */ new WeakSet();
 var knownSplits = /* @__PURE__ */ new WeakMap();
-function isImmutable(value) {
-  return hydratedValues.has(value) || isCanonicalJsonSealed(value);
+function isImmutable(value2) {
+  return hydratedValues.has(value2) || isCanonicalJsonSealed(value2);
 }
 function entriesOf(input) {
   const isArray = Array.isArray(input);
@@ -397,7 +397,7 @@ function measure(input, state, depth) {
       throw new RangeError(logicalLimit);
     }
     const entries2 = entriesOf(input);
-    const children = entries2.map(([, value]) => measure(value, state, depth + 1));
+    const children = entries2.map(([, value2]) => measure(value2, state, depth + 1));
     const keys = Array.isArray(input) ? null : entries2.map(([key3]) => key3);
     const { tokenBytes: tokenBytes2, logical } = combine(keys, children);
     const isPart = tokenBytes2 >= contentPartsLimits.minPartBytes;
@@ -419,19 +419,19 @@ function storedForm(input, state) {
   if (known) {
     return known.value;
   }
-  const digest28 = state.digests.get(input);
-  if (digest28 !== void 0) {
-    return reference(digest28);
+  const digest29 = state.digests.get(input);
+  if (digest29 !== void 0) {
+    return reference(digest29);
   }
   const node = state.measured.get(input);
   if (!node) {
     throw new Error("Content parts lost a measured container");
   }
-  return rebuild(input, node.entries, node.entries.map(([, value]) => storedForm(value, state)));
+  return rebuild(input, node.entries, node.entries.map(([, value2]) => storedForm(value2, state)));
 }
-function remember(node, value, tokenBytes) {
+function remember(node, value2, tokenBytes) {
   if (isImmutable(node.input)) {
-    knownSplits.set(node.input, { value, tokenBytes, logical: node.logical });
+    knownSplits.set(node.input, { value: value2, tokenBytes, logical: node.logical });
   }
 }
 function isCanonicalDocumentSized(logical) {
@@ -446,7 +446,7 @@ function freezeMeasured(state) {
     hydratedValues.add(node.input);
   }
 }
-async function splitRoot(value, isCollecting, isFreezing = false) {
+async function splitRoot(value2, isCollecting, isFreezing = false) {
   const state = {
     isCollecting,
     measured: /* @__PURE__ */ new Map(),
@@ -454,26 +454,26 @@ async function splitRoot(value, isCollecting, isFreezing = false) {
     digests: /* @__PURE__ */ new Map(),
     parts: /* @__PURE__ */ new Map()
   };
-  const root = measure(value, state, 0);
+  const root = measure(value2, state, 0);
   if (isFreezing) {
     freezeMeasured(state);
   }
   for (const node of state.order) {
     const token = canonicalizeJson(storedForm(node.input, state));
-    const digest29 = await sha256(token);
-    state.digests.set(node.input, digest29);
-    state.parts.set(digest29, token);
-    remember(node, reference(digest29), referenceBytes);
-  }
-  const stored = storedForm(value, state);
-  if (value !== null && typeof value === "object") {
-    const node = state.measured.get(value);
+    const digest30 = await sha256(token);
+    state.digests.set(node.input, digest30);
+    state.parts.set(digest30, token);
+    remember(node, reference(digest30), referenceBytes);
+  }
+  const stored = storedForm(value2, state);
+  if (value2 !== null && typeof value2 === "object") {
+    const node = state.measured.get(value2);
     if (node && !node.isPart) {
       remember(node, stored, node.tokenBytes);
     }
   }
-  const digest28 = await sha256(canonicalizeJson(stored));
-  return { state, root: { ...root, value: stored }, digest: digest28 };
+  const digest29 = await sha256(canonicalizeJson(stored));
+  return { state, root: { ...root, value: stored }, digest: digest29 };
 }
 function byDigest(left, right) {
   return left < right ? -1 : 1;
@@ -483,8 +483,8 @@ function admitStored(parts, bytes) {
     throw new RangeError("Content parts exceed the stored part or byte limit");
   }
 }
-async function packContentParts(value) {
-  const { state, root, digest: digest28 } = await splitRoot(value, true);
+async function packContentParts(value2) {
+  const { state, root, digest: digest29 } = await splitRoot(value2, true);
   const parts = [];
   for (const part of state.parts.keys()) {
     parts.push(part);
@@ -495,7 +495,7 @@ async function packContentParts(value) {
   const storedBytes = utf8(text8);
   admitStored(parts.length, storedBytes);
   return {
-    digest: digest28,
+    digest: digest29,
     text: text8,
     parts: parts.length,
     storedBytes,
@@ -524,12 +524,12 @@ import { z as z5 } from "zod";
 
 // ../schemas/src/draft-calendar-date.ts
 import { z as z2 } from "zod";
-var CalendarDateSchema = z2.string().regex(/^(?!0000)\d{4}-\d{2}-\d{2}$/u).refine((value) => {
-  const instant2 = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
-  return Number.isFinite(instant2.getTime()) && instant2.toISOString().slice(0, 10) === value;
+var CalendarDateSchema = z2.string().regex(/^(?!0000)\d{4}-\d{2}-\d{2}$/u).refine((value2) => {
+  const instant2 = /* @__PURE__ */ new Date(`${value2}T00:00:00.000Z`);
+  return Number.isFinite(instant2.getTime()) && instant2.toISOString().slice(0, 10) === value2;
 }, "Expected a real Gregorian calendar date in years 0001\u20139999");
-function calendarDay(value) {
-  return Date.parse(`${value}T00:00:00.000Z`) / 864e5;
+function calendarDay(value2) {
+  return Date.parse(`${value2}T00:00:00.000Z`) / 864e5;
 }
 
 // ../schemas/src/draft-evidence-scope.ts
@@ -537,8 +537,8 @@ import { z as z3 } from "zod";
 var identifier = z3.string().min(1).max(256).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/@-]*$/u);
 var draftSourceIdLimit = 2048;
 var draftSourceIdPattern = /^[a-zA-Z0-9](?:[a-zA-Z0-9\-._~:/?#[\]@!$&'()*+,;=]|%[0-9a-fA-F]{2})*$/u;
-function isDraftSourceId(value) {
-  return value.length <= draftSourceIdLimit && draftSourceIdPattern.test(value);
+function isDraftSourceId(value2) {
+  return value2.length <= draftSourceIdLimit && draftSourceIdPattern.test(value2);
 }
 var sourceId = z3.string().min(1).max(draftSourceIdLimit).regex(draftSourceIdPattern);
 var reference2 = z3.strictObject({
@@ -630,8 +630,8 @@ var businessCalendar = z5.strictObject({
     });
   }
   if (calendar.holidays.some((day) => {
-    const value = calendarDay(day);
-    return value < calendarDay(calendar.validFrom) || value > calendarDay(calendar.validThrough);
+    const value2 = calendarDay(day);
+    return value2 < calendarDay(calendar.validFrom) || value2 > calendarDay(calendar.validThrough);
   })) {
     context3.addIssue({ code: "custom", message: "Holiday outside declared calendar coverage" });
   }
@@ -691,20 +691,20 @@ function unique(values, context3, path3) {
 function checkAuthority(authority, context3) {
   unique(authority.definition.allowedValues, context3, ["definition", "allowedValues"]);
   unique(authority.allowedOutcomes, context3, ["allowedOutcomes"]);
-  unique(authority.rules.map((entry2) => entry2.id), context3, ["rules"]);
+  unique(authority.rules.map((entry3) => entry3.id), context3, ["rules"]);
   const values = new Set(authority.definition.allowedValues);
   const outcomes = new Set(authority.allowedOutcomes);
-  for (const [index, entry2] of authority.rules.entries()) {
+  for (const [index, entry3] of authority.rules.entries()) {
     const at = ["rules", index];
-    requireBinding(entry2.when.key === authority.definition.key, context3, {
+    requireBinding(entry3.when.key === authority.definition.key, context3, {
       path: [...at, "when", "key"],
       message: unknownDefinition
     });
-    requireBinding(values.has(entry2.when.equals), context3, {
+    requireBinding(values.has(entry3.when.equals), context3, {
       path: [...at, "when", "equals"],
       message: "Unknown definition value"
     });
-    requireBinding(outcomes.has(entry2.outcome), context3, {
+    requireBinding(outcomes.has(entry3.outcome), context3, {
       path: [...at, "outcome"],
       message: "Unknown outcome"
     });
@@ -769,15 +769,15 @@ var admission = z8.strictObject({
   trustDomain: identifier5,
   status: z8.enum(["approved", "revoked"])
 });
-function draftEvidenceReferenceKey(value) {
-  return JSON.stringify([draftPassageKey(value), value.contentDigest]);
+function draftEvidenceReferenceKey(value2) {
+  return JSON.stringify([draftPassageKey(value2), value2.contentDigest]);
 }
-function draftAdmissionKey(value) {
+function draftAdmissionKey(value2) {
   return JSON.stringify([
-    draftEvidenceReferenceKey(value.reference),
-    value.purpose,
-    value.sensitivity,
-    value.trustDomain
+    draftEvidenceReferenceKey(value2.reference),
+    value2.purpose,
+    value2.sensitivity,
+    value2.trustDomain
   ]);
 }
 function requireCoverage({ expected: expected2, actual, path: path3 }, context3) {
@@ -909,9 +909,9 @@ import { z as z12 } from "zod";
 
 // ../schemas/src/draft-decision-date.ts
 import { z as z11 } from "zod";
-function isTimeZone(value) {
+function isTimeZone(value2) {
   try {
-    const format = new Intl.DateTimeFormat("en-US", { timeZone: value });
+    const format = new Intl.DateTimeFormat("en-US", { timeZone: value2 });
     const options = format.resolvedOptions();
     return options.timeZone.length > 0;
   } catch {
@@ -992,22 +992,22 @@ function interval(clause, definition3) {
   if (!bounds) {
     return null;
   }
-  const { minimum, maximum, operator, value } = bounds;
+  const { minimum, maximum, operator, value: value2 } = bounds;
   return {
-    low: operator === "lt" || operator === "lte" ? minimum : Math.max(minimum, value),
-    high: operator === "gt" || operator === "gte" ? maximum : Math.min(maximum, value),
-    lowClosed: operator !== "gt" || minimum > value,
-    highClosed: operator !== "lt" || maximum < value
+    low: operator === "lt" || operator === "lte" ? minimum : Math.max(minimum, value2),
+    high: operator === "gt" || operator === "gte" ? maximum : Math.min(maximum, value2),
+    lowClosed: operator !== "gt" || minimum > value2,
+    highClosed: operator !== "lt" || maximum < value2
   };
 }
-function nextNumber(value) {
-  if (value === 0) {
+function nextNumber(value2) {
+  if (value2 === 0) {
     return Number.MIN_VALUE;
   }
   const view = new DataView(new ArrayBuffer(8));
-  view.setFloat64(0, value);
+  view.setFloat64(0, value2);
   const bits = view.getBigUint64(0);
-  view.setBigUint64(0, value > 0 ? bits + 1n : bits - 1n);
+  view.setBigUint64(0, value2 > 0 ? bits + 1n : bits - 1n);
   return view.getFloat64(0);
 }
 function isNonempty(range2, isInteger) {
@@ -1046,7 +1046,7 @@ function isConditionSupported(clause, definition3, definitions) {
     return clause.key !== clause.compareFact.key && areCompatibleFacts(definition3, definitions?.get(clause.compareFact.key));
   }
   if ("allowedValues" in definition3) {
-    return "oneOf" in clause ? clause.oneOf.every((value) => definition3.allowedValues.includes(value)) : "equals" in clause && typeof clause.equals === "string" && definition3.allowedValues.includes(clause.equals);
+    return "oneOf" in clause ? clause.oneOf.every((value2) => definition3.allowedValues.includes(value2)) : "equals" in clause && typeof clause.equals === "string" && definition3.allowedValues.includes(clause.equals);
   }
   if (definition3.valueRule.type === "boolean") {
     return "equals" in clause && typeof clause.equals === "boolean";
@@ -1066,7 +1066,7 @@ function relativeConditionsOverlap(left, right) {
     const { operator: b, ...rightOffset } = right.relativeDate;
     if (JSON.stringify(leftOffset) === JSON.stringify(rightOffset)) {
       const signs = { eq: [0], lt: [-1], lte: [-1, 0], gt: [1], gte: [0, 1] };
-      return signs[a].some((value) => signs[b].includes(value));
+      return signs[a].some((value2) => signs[b].includes(value2));
     }
   }
   return null;
@@ -1127,12 +1127,12 @@ function areConditionsOverlapping(left, right, definition3) {
   }
   if ("compareFact" in left && "compareFact" in right && left.compareFact.key === right.compareFact.key) {
     const signs = { eq: [0], lt: [-1], lte: [-1, 0], gt: [1], gte: [0, 1] };
-    return signs[left.compareFact.operator].some((value) => signs[right.compareFact.operator].includes(value));
+    return signs[left.compareFact.operator].some((value2) => signs[right.compareFact.operator].includes(value2));
   }
   const leftValues = optionsOf(left);
   const rightValues = optionsOf(right);
   if (leftValues && rightValues) {
-    return leftValues.some((value) => rightValues.includes(value));
+    return leftValues.some((value2) => rightValues.includes(value2));
   }
   const a = interval(left, definition3);
   const b = interval(right, definition3);
@@ -1286,7 +1286,7 @@ function isGuardImplied(guard, clause) {
   const allowed = choiceValues(guard);
   const values = choiceValues(clause);
   const isSameKey = clause.key === guard.key;
-  return isSameKey && values.length > 0 && values.every((value) => allowed.includes(value));
+  return isSameKey && values.length > 0 && values.every((value2) => allowed.includes(value2));
 }
 function isPolicyValid(proposal, context3) {
   const clauses2 = [
@@ -1534,7 +1534,7 @@ function inspectScoredPolicy(proposal, context3) {
   }
   inspectScoringReferences(scoring, proposal.requirements, context3);
   const ids3 = new Set(rules2.map((rule3) => rule3.id));
-  if (gates.some((id13) => !ids3.has(id13))) {
+  if (gates.some((id14) => !ids3.has(id14))) {
     fail("Unknown mandatory gate rule");
   }
   if (rules2.every((rule3) => gates.includes(rule3.id))) {
@@ -1547,7 +1547,7 @@ function inspectScoredPolicy(proposal, context3) {
     if (isGate ? hasRange || rule3.when.length === 0 : !hasRange) {
       fail("Mandatory gates require fact predicates only; other rules require score ranges");
     }
-    if (rule3.overrides.some((id13) => gates.includes(id13) !== isGate)) {
+    if (rule3.overrides.some((id14) => gates.includes(id14) !== isGate)) {
       fail("Explicit overrides cannot cross mandatory-gate and score-band classes");
     }
     const range2 = rule3.scoreRange;
@@ -1569,6 +1569,7 @@ function areScoredRulesDisjoint(proposal, left, right) {
 
 // ../schemas/src/draft-required-decision.ts
 var typedResolutionPolicy = "strict-required-types/direct-overrides/v2";
+var valueAgreementOutcomeRegions = "outcome-regions";
 var identifier8 = DraftEvidenceScopeSchema.shape.entityId;
 var duplicateIdentity = "Duplicate identity";
 var uniqueIds = z15.array(identifier8).max(64).refine(hasUniqueValues, duplicateIdentity);
@@ -1611,7 +1612,8 @@ var shape = z15.strictObject({
   }),
   scope: z15.strictObject({
     entityId: identifier8,
-    evaluationTime: DraftObservationChecksSchema.shape.evaluationTime
+    evaluationTime: DraftObservationChecksSchema.shape.evaluationTime,
+    valueAgreement: z15.literal(valueAgreementOutcomeRegions).optional()
   }),
   evidence: z15.array(DraftEvidenceValidationSchema).max(64)
 });
@@ -1631,23 +1633,44 @@ function draftRulePriority(ranked) {
 function hasDraftRulePrecedence(winner, other) {
   return winner.overrides.includes(other.id) || draftRulePriority(winner) > draftRulePriority(other);
 }
+function overlappingRulePairs(proposal) {
+  const { rules: rules2, requirements: requirements3 } = proposal;
+  const definitions = new Map(requirements3.map((item) => [item.definition.key, item.definition]));
+  const pairs = [];
+  for (const [index, item] of rules2.entries()) {
+    const later = rules2.slice(index + 1);
+    for (const [offset, other] of later.entries()) {
+      if (item.outcome !== other.outcome && !areScoredRulesDisjoint(proposal, item, other) && hasOverlap(item, other, definitions)) {
+        pairs.push([index, index + offset + 1]);
+      }
+    }
+  }
+  return pairs;
+}
+function contradictoryRulePairs(proposal) {
+  const { rules: rules2 } = proposal;
+  return overlappingRulePairs(proposal).filter(([left, right]) => {
+    const [item, other] = [rules2[left], rules2[right]];
+    return item !== void 0 && other !== void 0 && !hasDraftRulePrecedence(item, other) && !hasDraftRulePrecedence(other, item);
+  });
+}
 function hasCycle(rules2) {
   const graph = new Map(rules2.map((item) => [item.id, item.overrides]));
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
-  const hasPathCycle = (id13) => {
-    if (visiting.has(id13)) {
+  const hasPathCycle = (id14) => {
+    if (visiting.has(id14)) {
       return true;
     }
-    if (visited.has(id13)) {
+    if (visited.has(id14)) {
       return false;
     }
-    visiting.add(id13);
-    if ((graph.get(id13) ?? []).some(hasPathCycle)) {
+    visiting.add(id14);
+    if ((graph.get(id14) ?? []).some(hasPathCycle)) {
       return true;
     }
-    visiting.delete(id13);
-    visited.add(id13);
+    visiting.delete(id14);
+    visited.add(id14);
     return false;
   };
   return rules2.some((item) => hasPathCycle(item.id));
@@ -1656,7 +1679,7 @@ function inspectRules(proposal, context3) {
   const { rules: rules2, requirements: requirements3, allowedOutcomes } = proposal;
   const definitions = new Map(requirements3.map((item) => [item.definition.key, item.definition]));
   const ids3 = new Set(rules2.map((item) => item.id));
-  const byId = new Map(rules2.map((entry2) => [entry2.id, entry2]));
+  const byId = new Map(rules2.map((entry3) => [entry3.id, entry3]));
   for (const [index, item] of rules2.entries()) {
     const fail = (message) => {
       context3.addIssue({
@@ -1676,22 +1699,22 @@ function inspectRules(proposal, context3) {
         fail("Undeclared condition key or value");
       }
     }
-    if (item.overrides.some((id13) => id13 === item.id || !ids3.has(id13))) {
+    if (item.overrides.some((id14) => id14 === item.id || !ids3.has(id14))) {
       fail("Unknown or self override");
     }
-    if (item.overrides.some((id13) => {
-      const target = byId.get(id13);
-      return target !== void 0 && draftRulePriority(target) > draftRulePriority(item);
+    if (item.overrides.some((id14) => {
+      const target2 = byId.get(id14);
+      return target2 !== void 0 && draftRulePriority(target2) > draftRulePriority(item);
     })) {
       fail("Override points to a higher priority tier");
     }
-    const laterRules = rules2.slice(index + 1);
-    for (const other of laterRules) {
-      const isContradictory = item.outcome !== other.outcome && !areScoredRulesDisjoint(proposal, item, other) && hasOverlap(item, other, definitions);
-      if (isContradictory && !hasDraftRulePrecedence(item, other) && !hasDraftRulePrecedence(other, item)) {
-        fail("Overlapping contradictory rules require a direct override");
-      }
-    }
+  }
+  for (const [index] of contradictoryRulePairs(proposal)) {
+    context3.addIssue({
+      code: "custom",
+      path: ["rules", index],
+      message: "Overlapping contradictory rules require a direct override"
+    });
   }
   if (hasCycle(rules2)) {
     context3.addIssue({ code: "custom", path: ["rules"], message: "Override cycle" });
@@ -1817,26 +1840,26 @@ function unique2(values, context3, path3) {
 }
 function checkObservations(candidate2, context3) {
   const { authority, observations } = candidate2;
-  unique2(observations.map((entry2) => entry2.id), context3, ["observations"]);
-  for (const [index, entry2] of observations.entries()) {
+  unique2(observations.map((entry3) => entry3.id), context3, ["observations"]);
+  for (const [index, entry3] of observations.entries()) {
     const at = ["observations", index];
-    requireBinding2(entry2.key === authority.definition.key, context3, {
+    requireBinding2(entry3.key === authority.definition.key, context3, {
       path: [...at, "key"],
       message: unknownDefinition2
     });
-    requireBinding2(authority.definition.allowedValues.includes(entry2.value), context3, {
+    requireBinding2(authority.definition.allowedValues.includes(entry3.value), context3, {
       path: [...at, "value"],
       message: "Unknown definition value"
     });
-    requireBinding2(entry2.definitionDigest === authority.definition.contentDigest, context3, {
+    requireBinding2(entry3.definitionDigest === authority.definition.contentDigest, context3, {
       path: [...at, "definitionDigest"],
       message: "Definition fingerprint mismatch"
     });
-    requireBinding2(entry2.evidence.entityId === candidate2.entityId, context3, {
+    requireBinding2(entry3.evidence.entityId === candidate2.entityId, context3, {
       path: [...at, "evidence", "entityId"],
       message: "Evidence belongs to a different entity"
     });
-    requireBinding2(Date.parse(entry2.observedAt) <= Date.parse(candidate2.evaluatedAt), context3, {
+    requireBinding2(Date.parse(entry3.observedAt) <= Date.parse(candidate2.evaluatedAt), context3, {
       path: [...at, "observedAt"],
       message: "Observation is later than evaluation"
     });
@@ -1852,9 +1875,9 @@ function checkExpected(candidate2, context3) {
     return;
   }
   unique2(result.observationIds, context3, ["expected", "observationIds"]);
-  const observationIds = new Set(candidate2.observations.map((entry2) => entry2.id));
-  for (const [index, id13] of result.observationIds.entries()) {
-    requireBinding2(observationIds.has(id13), context3, {
+  const observationIds = new Set(candidate2.observations.map((entry3) => entry3.id));
+  for (const [index, id14] of result.observationIds.entries()) {
+    requireBinding2(observationIds.has(id14), context3, {
       path: ["expected", "observationIds", index],
       message: "Unknown observation"
     });
@@ -1866,7 +1889,7 @@ function checkExpected(candidate2, context3) {
     path: ["expected", "outcome"],
     message: "Unknown outcome"
   });
-  requireBinding2(candidate2.authority.rules.some((entry2) => entry2.id === result.ruleId), context3, { path: ["expected", "ruleId"], message: "Unknown rule" });
+  requireBinding2(candidate2.authority.rules.some((entry3) => entry3.id === result.ruleId), context3, { path: ["expected", "ruleId"], message: "Unknown rule" });
 }
 var DraftDecisionCaseSchema = shape2.superRefine((candidate2, context3) => {
   checkObservations(candidate2, context3);
@@ -1994,10 +2017,10 @@ var expectation = z19.strictObject({
   status: z19.enum(["ready", "blocked", "review_required", "stale", "conflict", "gap"]),
   outcome: identifier11.nullable(),
   selectedRuleIds: z19.array(identifier11).max(256).refine(hasUniqueValues, "Duplicate rule identity")
-}).superRefine((value, context3) => {
-  const hasOutcome = value.outcome !== null;
-  const hasRules = value.selectedRuleIds.length > 0;
-  const isReady = value.status === "ready";
+}).superRefine((value2, context3) => {
+  const hasOutcome = value2.outcome !== null;
+  const hasRules = value2.selectedRuleIds.length > 0;
+  const isReady = value2.status === "ready";
   if (isReady ? !hasOutcome || !hasRules : hasOutcome || hasRules) {
     context3.addIssue({
       code: "custom",
@@ -2014,9 +2037,22 @@ var DraftEvidenceFixtureSchema = z19.strictObject({
   ...fixtureIdentity,
   evidence: DraftRequiredDecisionSchema.shape.evidence
 });
+var fixtureFact = z19.strictObject({
+  key: identifier11,
+  value: DraftEvidenceValueSchema,
+  held: z19.enum(["stale", "review"]).optional(),
+  conflictsWith: DraftEvidenceValueSchema.optional()
+}).superRefine((fact, context3) => {
+  if (fact.held !== void 0 && fact.conflictsWith !== void 0) {
+    context3.addIssue({ code: "custom", message: "A fact is stale, flagged or conflicting" });
+  }
+  if (fact.conflictsWith === fact.value) {
+    context3.addIssue({ code: "custom", message: "Conflicting values must differ" });
+  }
+});
 var DraftFactFixtureSchema = z19.strictObject({
   ...fixtureIdentity,
-  facts: z19.array(z19.strictObject({ key: identifier11, value: DraftEvidenceValueSchema })).max(64).refine((facts) => hasUniqueValues(facts.map((fact) => fact.key)), "Duplicate fact key")
+  facts: z19.array(fixtureFact).max(64).refine((facts) => hasUniqueValues(facts.map((fact) => fact.key)), "Duplicate fact key")
 });
 var DraftAnyCompilationFixtureSchema = z19.union([
   DraftEvidenceFixtureSchema,
@@ -2148,40 +2184,40 @@ function boundedDraftInput(limits2) {
     let nodes = 0;
     let text8 = 0;
     const budgetError = new Error("Draft input budget exceeded or non-data input");
-    function copy(value, depth) {
+    function copy(value2, depth) {
       nodes += 1;
       if (nodes > limits2.nodes || depth > maxDepth) {
         throw budgetError;
       }
-      if (typeof value === "string") {
-        text8 += value.length;
-        if (value.length > limits2.stringLength || text8 > limits2.totalText) {
+      if (typeof value2 === "string") {
+        text8 += value2.length;
+        if (value2.length > limits2.stringLength || text8 > limits2.totalText) {
           throw budgetError;
         }
-        return value;
+        return value2;
       }
-      if (value === null || typeof value !== "object") {
-        return value;
+      if (value2 === null || typeof value2 !== "object") {
+        return value2;
       }
-      const isArray = Array.isArray(value);
-      const prototype = Object.getPrototypeOf(value);
+      const isArray = Array.isArray(value2);
+      const prototype = Object.getPrototypeOf(value2);
       if (prototype !== null && prototype !== (isArray ? Array.prototype : Object.prototype)) {
         throw budgetError;
       }
-      if (isArray && value.length > limits2.arrayLength) {
+      if (isArray && value2.length > limits2.arrayLength) {
         throw budgetError;
       }
-      const output = isArray ? Array.from({ length: value.length }) : {};
+      const output = isArray ? Array.from({ length: value2.length }) : {};
       let properties = 0;
-      for (const key3 in value) {
-        if (!Object.hasOwn(value, key3)) {
+      for (const key3 in value2) {
+        if (!Object.hasOwn(value2, key3)) {
           continue;
         }
         properties += 1;
         if (properties > (isArray ? limits2.arrayLength : 32)) {
           throw budgetError;
         }
-        const descriptor = Object.getOwnPropertyDescriptor(value, key3);
+        const descriptor = Object.getOwnPropertyDescriptor(value2, key3);
         if (!descriptor || !("value" in descriptor)) {
           throw budgetError;
         }
@@ -2206,7 +2242,7 @@ function boundedDraftInput(limits2) {
     }
   });
 }
-var isUnicodeText = (value) => !/[\uD800-\uDFFF]/u.test(value);
+var isUnicodeText = (value2) => !/[\uD800-\uDFFF]/u.test(value2);
 var isSplitCharacter = (text8, offset) => offset > 0 && offset < text8.length && /[\uDC00-\uDFFF]/u.test(text8.charAt(offset));
 var sourceText = DraftSourceReferenceSchema.omit({ contentDigest: true }).extend({
   text: z21.string().min(1).max(1048576).refine(isUnicodeText, "Lone Unicode surrogate"),
@@ -2571,22 +2607,22 @@ var DraftPrimitiveMappingSchema = z26.strictObject({
   caseId: id,
   rows: z26.array(row).min(requiredAuthorityPrimitives.length).max(authorityPrimitives.length)
 }).superRefine((mapping, context3) => {
-  if (!coversAuthorityPrimitives(mapping.rows.map((entry2) => entry2.primitive))) {
+  if (!coversAuthorityPrimitives(mapping.rows.map((entry3) => entry3.primitive))) {
     context3.addIssue({ code: "custom", path: ["rows"], message: "Every category is explicit" });
   }
   const seen = /* @__PURE__ */ new Set();
-  for (const [index, entry2] of mapping.rows.entries()) {
+  for (const [index, entry3] of mapping.rows.entries()) {
     const path3 = ["rows", index];
-    if (seen.has(entry2.primitive)) {
+    if (seen.has(entry3.primitive)) {
       context3.addIssue({ code: "custom", path: path3, message: "Duplicate primitive" });
     }
-    seen.add(entry2.primitive);
-    if (entry2.status !== "mapped") {
+    seen.add(entry3.primitive);
+    if (entry3.status !== "mapped") {
       continue;
     }
     const references = /* @__PURE__ */ new Set();
-    for (const [at, ref] of entry2.references.entries()) {
-      if (!kinds[entry2.primitive].includes(ref.kind)) {
+    for (const [at, ref] of entry3.references.entries()) {
+      if (!kinds[entry3.primitive].includes(ref.kind)) {
         context3.addIssue({
           code: "custom",
           path: [...path3, "references", at],
@@ -2606,7 +2642,7 @@ var DraftPrimitiveMappingSchema = z26.strictObject({
   }
 });
 function readObservation(input, ref) {
-  const index = input.observations.findIndex((entry2) => entry2.id === ref.observationId);
+  const index = input.observations.findIndex((entry3) => entry3.id === ref.observationId);
   const observation2 = input.observations[index];
   if (!observation2) {
     return void 0;
@@ -2642,7 +2678,7 @@ function readReference(input, ref) {
       return { path: "expected", value: input.expected };
     }
     case "rule": {
-      const index = authority.rules.findIndex((entry2) => entry2.id === ref.ruleId);
+      const index = authority.rules.findIndex((entry3) => entry3.id === ref.ruleId);
       const rule3 = authority.rules[index];
       return rule3 ? {
         path: `authority.rules.${index}`,
@@ -2671,18 +2707,18 @@ var DraftMappedCaseSchema = z26.strictObject({
       message: "Mapping belongs to a different case"
     });
   }
-  for (const [index, entry2] of mapping.rows.entries()) {
-    if (entry2.status !== "mapped") {
+  for (const [index, entry3] of mapping.rows.entries()) {
+    if (entry3.status !== "mapped") {
       continue;
     }
-    if (entry2.primitive === "gaps" && input.expected.state === "ready") {
+    if (entry3.primitive === "gaps" && input.expected.state === "ready") {
       context3.addIssue({
         code: "custom",
         path: ["mapping", "rows", index],
         message: "Ready expectation cannot demonstrate an unresolved gap or conflict"
       });
     }
-    for (const [at, ref] of entry2.references.entries()) {
+    for (const [at, ref] of entry3.references.entries()) {
       if (!readReference(input, ref)) {
         context3.addIssue({
           code: "custom",
@@ -2849,6 +2885,8 @@ var PackDraftBoundSchema = z29.union([
   z29.number(),
   CalendarDateSchema,
   z29.strictObject({ question: draftIdentifier, days: dayOffset }),
+  z29.strictObject({ question: draftIdentifier, businessDays: dayOffset }),
+  z29.strictObject({ question: draftIdentifier }),
   z29.strictObject({ decisionDate: dayOffset })
 ]);
 var PackDraftComparisonSchema = z29.strictObject({
@@ -2858,10 +2896,10 @@ var PackDraftComparisonSchema = z29.strictObject({
   gte: PackDraftBoundSchema.optional(),
   eq: PackDraftBoundSchema.optional(),
   quote: draftQuote
-}).superRefine((value, context3) => {
-  const lower = Number(value.gt !== void 0) + Number(value.gte !== void 0);
-  const upper = Number(value.lt !== void 0) + Number(value.lte !== void 0);
-  const hasEquality = value.eq !== void 0;
+}).superRefine((value2, context3) => {
+  const lower = Number(value2.gt !== void 0) + Number(value2.gte !== void 0);
+  const upper = Number(value2.lt !== void 0) + Number(value2.lte !== void 0);
+  const hasEquality = value2.eq !== void 0;
   if (lower + upper + Number(hasEquality) === 0) {
     context3.addIssue({ code: "custom", message: "Give a bound: lt, lte, gt, gte or eq" });
   } else if (lower > 1 || upper > 1) {
@@ -2876,6 +2914,9 @@ var PackDraftConditionSchema = z29.union([
   PackDraftComparisonSchema
 ]);
 var PackDraftConditionsSchema = z29.record(draftIdentifier, PackDraftConditionSchema);
+function isComparison(condition) {
+  return typeof condition === "object" && !Array.isArray(condition);
+}
 var questionTypes = ["number", "date"];
 var typedQuestionFields = {
   type: z29.enum(questionTypes).optional(),
@@ -2885,6 +2926,66 @@ var typedQuestionFields = {
   minimum: z29.number().optional(),
   maximum: z29.number().optional()
 };
+function unitKindOf(unit) {
+  if (unit === "percent") {
+    return "percent";
+  }
+  return isKnownCurrency(unit) ? "currency" : "count";
+}
+function fieldIssue(question3, field) {
+  return { path: [field], message: `A ${question3.type ?? "choice"} question has no ${field}` };
+}
+function fieldIssues(question3, allowed) {
+  const fields = ["answers", "unit", "unitWords", "integer", "minimum", "maximum"];
+  const present = fields.filter((field) => question3[field] !== void 0);
+  return present.filter((field) => !allowed.includes(field)).map((field) => fieldIssue(question3, field));
+}
+function numberIssues(question3) {
+  const issues = [];
+  const { unit } = question3;
+  if (unit === void 0) {
+    return [
+      {
+        path: ["unit"],
+        message: 'Give the unit: a currency code such as "USD", "percent", or a count noun'
+      }
+    ];
+  }
+  const kind = unitKindOf(unit);
+  if (kind === "count" && !/^[a-z][a-z0-9_-]*$/u.test(unit)) {
+    issues.push({
+      path: ["unit"],
+      message: 'Use a currency code such as "USD", "percent", or a lowercase count noun'
+    });
+  }
+  if (kind === "count" && question3.unitWords === void 0) {
+    issues.push({
+      path: ["unitWords"],
+      message: 'A count needs the words that name its unit next to its number, such as "claims"'
+    });
+  }
+  if (kind !== "count" && question3.unitWords !== void 0) {
+    issues.push({ path: ["unitWords"], message: "Only a count has unit words" });
+  }
+  const { minimum, maximum } = question3;
+  if (minimum !== void 0 && maximum !== void 0 && minimum > maximum) {
+    issues.push({ path: ["maximum"], message: "maximum is below minimum" });
+  }
+  return issues;
+}
+function questionIssues(question3) {
+  if (question3.type === "number") {
+    return [
+      ...fieldIssues(question3, ["unit", "unitWords", "integer", "minimum", "maximum"]),
+      ...numberIssues(question3)
+    ];
+  }
+  if (question3.type === "date") {
+    return fieldIssues(question3, []);
+  }
+  const missing = question3.answers === void 0 ? [{ path: ["answers"], message: "A choice question needs answers" }] : [];
+  return [...fieldIssues(question3, ["answers"]), ...missing];
+}
 var declaredDateOrders = [
   "month-first",
   "day-first"
@@ -2894,7 +2995,51 @@ var packConventionFields = {
   dateOrder: z29.enum(declaredDateOrders).optional(),
   timeZone: z29.string().min(1).max(64).regex(/^[A-Za-z][A-Za-z0-9_+/-]*$/u, "Use an IANA time zone name, such as Europe/Paris").refine(isTimeZone, "Unknown IANA time zone").optional()
 };
-var caseFactSchema = z29.union([draftValue, z29.number()]);
+var plainFact = z29.union([draftValue, z29.number()]);
+var heldFactSchema = z29.union([
+  z29.strictObject({ missing: z29.literal(true) }),
+  z29.strictObject({ stale: plainFact }),
+  z29.strictObject({ review: plainFact }),
+  z29.strictObject({ conflict: z29.tuple([plainFact, plainFact]) }).refine((fact) => fact.conflict[0] !== fact.conflict[1], "Conflicting readings must differ")
+]);
+var caseFactSchema = z29.union([plainFact, heldFactSchema]);
+var heldStates = ["missing", "stale", "conflict", "review"];
+var weekdayNames = [
+  "sunday",
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday"
+];
+var calendarYear = z29.number().int().min(1900).max(2200);
+var PackDraftBusinessDaysSchema = z29.strictObject({
+  workingDays: z29.array(z29.enum(weekdayNames)).min(1).max(7).refine(hasUniqueValues, "Duplicate working day"),
+  quote: draftQuote,
+  years: z29.strictObject({ from: calendarYear, through: calendarYear }),
+  holidays: z29.array(z29.strictObject({ date: CalendarDateSchema, quote: draftQuote })).max(400).refine((rows) => hasUniqueValues(rows.map((row2) => row2.date)), "Duplicate holiday").optional()
+}).superRefine((calendar, context3) => {
+  const { from, through } = calendar.years;
+  if (through < from || through - from > 99) {
+    context3.addIssue({
+      code: "custom",
+      path: ["years"],
+      message: "years.through must be on or after years.from, within 100 years"
+    });
+  }
+  const holidays = calendar.holidays ?? [];
+  for (const [index, holiday] of holidays.entries()) {
+    const year = Number(holiday.date.slice(0, 4));
+    if (year < from || year > through) {
+      context3.addIssue({
+        code: "custom",
+        path: ["holidays", index, "date"],
+        message: "This holiday is outside the calendar's years"
+      });
+    }
+  }
+});
 var caseDecisionDate = CalendarDateSchema.optional();
 
 // ../schemas/src/draft-pack-subjects.ts
@@ -3017,7 +3162,7 @@ var group = z31.strictObject({
   min: z31.number().int().min(0).max(64),
   max: z31.number().int().min(0).max(64),
   candidates: z31.array(candidate).max(64)
-}).refine((value) => value.min <= value.max, "Group minimum exceeds maximum");
+}).refine((value2) => value2.min <= value2.max, "Group minimum exceeds maximum");
 function areSubjectsValid(subjects, isIsolated) {
   const types = new Set(subjects.types.map((row2) => row2.id));
   const job = subjects.types.find((row2) => row2.id === subjects.job);
@@ -3038,13 +3183,13 @@ function areSubjectsValid(subjects, isIsolated) {
 function areEscalationsValid(escalations, context3) {
   const { isIsolated, outcomes } = context3;
   const ids3 = new Set(escalations.routes.map((row2) => row2.id));
-  const named = [escalations.unresolved, escalations.attemptLimit].filter((id13) => id13 !== null);
+  const named = [escalations.unresolved, escalations.attemptLimit].filter((id14) => id14 !== null);
   return [
     ids3.size === escalations.routes.length,
     escalations.routes.every((row2) => isIsolated(row2.entryId, "routing_jobs")),
     hasUniqueValues(escalations.outcomes.map((row2) => row2.outcome)),
     escalations.outcomes.every((row2) => ids3.has(row2.escalation) && outcomes.has(row2.outcome)),
-    named.every((id13) => ids3.has(id13))
+    named.every((id14) => ids3.has(id14))
   ].every(Boolean);
 }
 function isGuideValid(guide, isIsolated) {
@@ -3060,10 +3205,10 @@ function subjectPlanIssues(plan) {
   const issues = [];
   const candidates = plan.groups.flatMap((item) => item.candidates);
   const isIsolated = (entryId, primitive) => {
-    const entry2 = plan.entries.find((row2) => row2.id === entryId);
+    const entry3 = plan.entries.find((row2) => row2.id === entryId);
     return [
-      entry2?.primitive === primitive,
-      entry2?.dependencies.length === 0,
+      entry3?.primitive === primitive,
+      entry3?.dependencies.length === 0,
       !plan.requiredIds.includes(entryId),
       candidates.every((row2) => row2.entryId !== entryId),
       plan.entries.every((row2) => !row2.dependencies.includes(entryId))
@@ -3102,7 +3247,7 @@ var DraftContextSelectionPlanSchema = z31.strictObject({
   attempts: z31.strictObject({
     max: z31.number().int().min(1).max(10),
     withProgress: z31.number().int().min(1).max(10)
-  }).refine((value) => value.withProgress >= value.max, "withProgress below max").optional(),
+  }).refine((value2) => value2.withProgress >= value2.max, "withProgress below max").optional(),
   entries: base2.entries,
   requiredIds: base2.requiredIds,
   budget: base2.budget,
@@ -3134,19 +3279,19 @@ var DraftContextSelectionPlanSchema = z31.strictObject({
   if (candidateIds.length > 64 || !hasUniqueIds(candidateIds) || !hasUniqueIds(plan.groups.map((item) => item.id)) || !hasUniqueIds(plan.entries.map((item) => item.id))) {
     context3.addIssue({ code: "custom", message: "Duplicate identities or too many candidates" });
   }
-  if (plan.requiredIds.some((id13) => candidateIds.includes(id13))) {
+  if (plan.requiredIds.some((id14) => candidateIds.includes(id14))) {
     context3.addIssue({ code: "custom", message: "Global required root cannot be a candidate" });
   }
   const guidanceId = plan.unresolvedGuidanceEntryId;
   if (guidanceId === void 0) {
     return;
   }
-  const entry2 = plan.entries.find((row2) => row2.id === guidanceId);
+  const entry3 = plan.entries.find((row2) => row2.id === guidanceId);
   if ([
-    !entry2,
-    entry2?.primitive !== "gaps",
-    entry2?.dependencies.length,
-    entry2?.conflictsWith.length,
+    !entry3,
+    entry3?.primitive !== "gaps",
+    entry3?.dependencies.length,
+    entry3?.conflictsWith.length,
     plan.requiredIds.includes(guidanceId),
     candidateIds.includes(guidanceId),
     plan.entries.some((row2) => row2.dependencies.includes(guidanceId))
@@ -3669,7 +3814,7 @@ var DraftApplicationTargetSchema = DraftApplicationScopeSchema.extend({
   action,
   resourceId: identifier18,
   jobId: identifier18.nullable()
-}).refine((target) => target.action === "execute_job" === (target.jobId !== null), "Only job execution carries a job ID");
+}).refine((target2) => target2.action === "execute_job" === (target2.jobId !== null), "Only job execution carries a job ID");
 var DraftApplicationActorSchema = z43.strictObject({
   principalId: identifier18,
   organizationId: identifier18,
@@ -3725,7 +3870,7 @@ var DraftApplicationReleaseSchema = z43.strictObject({
 });
 
 // ../schemas/src/draft-hosted-application.ts
-import { z as z53 } from "zod";
+import { z as z57 } from "zod";
 
 // ../schemas/src/draft-source-instant.ts
 var localPattern = /^(\d{4})-(\d{2})-(\d{2})[Tt](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?([^.\d].*)$/u;
@@ -3765,11 +3910,11 @@ function utcOf(local, offset) {
   const utc = date.toISOString();
   return utcYear.test(utc) ? utc.slice(0, 19) : null;
 }
-function normalizedSourceInstant(value) {
-  if (value.length > sourceInstantMaxLength) {
+function normalizedSourceInstant(value2) {
+  if (value2.length > sourceInstantMaxLength) {
     return null;
   }
-  const match = localPattern.exec(value);
+  const match = localPattern.exec(value2);
   if (match === null) {
     return null;
   }
@@ -3838,7 +3983,7 @@ var DraftOutputContractSchema = z44.strictObject({
   }
   const encoder2 = new TextEncoder();
   for (const section of contract.sections) {
-    if (section.check === "exact" && section.alternatives.some((value) => encoder2.encode(value).byteLength > section.maxBytes)) {
+    if (section.check === "exact" && section.alternatives.some((value2) => encoder2.encode(value2).byteLength > section.maxBytes)) {
       context3.addIssue({ code: "custom", message: "Exact alternative exceeds section budget" });
     }
   }
@@ -3985,8 +4130,10 @@ var ArtifactSemanticRequestSchema = z46.strictObject({
   calibration: recipe.calibration,
   requestDigest: digest20
 });
+var artifactInjectionScreen = z46.literal("paragraph-injection/v1");
 var ArtifactSemanticResponseSchema = z46.strictObject({
   schema: z46.literal("felspar.artifact-question-response.draft/v1"),
+  screen: artifactInjectionScreen.optional(),
   preparationDigest: digest20,
   evaluator: recipe.evaluator,
   calibrationDigest: digest20,
@@ -4007,6 +4154,7 @@ var ArtifactSemanticJudgmentSchema = z46.strictObject({
 });
 var ArtifactSemanticRecordSchema = z46.strictObject({
   state: z46.enum(["ready", "skipped", "over_budget", "not_evaluated"]),
+  screen: artifactInjectionScreen.optional(),
   preparationDigest: digest20,
   evaluator: ArtifactSemanticRecipeSchema.shape.evaluator,
   calibrationDigest: digest20,
@@ -4029,13 +4177,13 @@ var ArtifactSemanticRecordSchema = z46.strictObject({
 });
 var caseNotStated = "not_stated";
 var abstain = "cannot_determine";
-function isMatchOf(question2, check) {
-  if (check?.kind !== "case_answer" || question2.aggregation !== "match") {
-    return check?.kind === "semantic_question" && question2.aggregation !== "match";
+function isMatchOf(question3, check) {
+  if (check?.kind !== "case_answer" || question3.aggregation !== "match") {
+    return check?.kind === "semantic_question" && question3.aggregation !== "match";
   }
-  const offered = new Set(question2.options.map((option2) => option2.value));
+  const offered = new Set(question3.options.map((option2) => option2.value));
   const expected2 = [...(check.answers ?? []).map((row2) => row2.value), caseNotStated, abstain];
-  return offered.size === question2.options.length && offered.size === expected2.length && expected2.every((value) => offered.has(value));
+  return offered.size === question3.options.length && offered.size === expected2.length && expected2.every((value2) => offered.has(value2));
 }
 function isAsking(check) {
   const isAsker = check.kind === "semantic_question" || check.kind === "case_answer";
@@ -4045,22 +4193,22 @@ function inspectSemantic(manifest2, issue) {
   const askers = manifest2.checks.filter(isAsking);
   const asked = askers.map((check) => check.questionId ?? "");
   const questions = manifest2.semantic?.questions ?? [];
-  for (const question2 of questions) {
-    const asker = askers.find((check) => check.questionId === question2.id);
-    if (!isMatchOf(question2, asker)) {
+  for (const question3 of questions) {
+    const asker = askers.find((check) => check.questionId === question3.id);
+    if (!isMatchOf(question3, asker)) {
       issue("A semantic question's aggregation differs from the check that asks it");
     }
   }
   const distinctAsked = new Set(asked);
-  if (distinctAsked.size !== asked.length || asked.length !== questions.length || questions.some((question2) => !distinctAsked.has(question2.id))) {
+  if (distinctAsked.size !== asked.length || asked.length !== questions.length || questions.some((question3) => !distinctAsked.has(question3.id))) {
     issue("Every released semantic question is asked by exactly one check");
   }
-  for (const question2 of questions) {
-    if (question2.aggregation === "match") {
+  for (const question3 of questions) {
+    if (question3.aggregation === "match") {
       continue;
     }
-    const effects = new Set(question2.options.map((option2) => option2.effect));
-    const needed = question2.aggregation === "prohibit" ? "violated" : "satisfied";
+    const effects = new Set(question3.options.map((option2) => option2.effect));
+    const needed = question3.aggregation === "prohibit" ? "violated" : "satisfied";
     if (!effects.has(needed)) {
       issue("A semantic question needs an option that can decide its aggregation");
     }
@@ -4080,8 +4228,8 @@ var artifactLintLimits = {
   maxLiteralUnits: 512,
   maxOccurrencesPerCheck: 16
 };
-function isWellFormedText(value) {
-  return !/\p{Cs}/u.test(value);
+function isWellFormedText(value2) {
+  return !/\p{Cs}/u.test(value2);
 }
 var literal = z47.string().min(1).max(artifactLintLimits.maxLiteralUnits).regex(/\S/u).refine(isWellFormedText);
 var passage = z47.strictObject({
@@ -4157,7 +4305,7 @@ var ArtifactCheckSchema = z47.discriminatedUnion("kind", [
 ]);
 var sectionDeclaration = z47.strictObject({
   id: id4,
-  heading: z47.string().min(1).max(256).regex(/\S/u).refine((value) => !/[\n\r]/u.test(value) && isWellFormedText(value)).nullable(),
+  heading: z47.string().min(1).max(256).regex(/\S/u).refine((value2) => !/[\n\r]/u.test(value2) && isWellFormedText(value2)).nullable(),
   maxUnits: z47.number().int().min(1).max(artifactLintLimits.maxSectionUnits)
 });
 function caseAnswerIssues(checks) {
@@ -4291,16 +4439,16 @@ function unique3(values, context3, path3) {
     context3.addIssue({ code: "custom", path: path3, message: "Duplicate obligation identity or target" });
   }
 }
-function isApprovalTargetValid(item, target, useRef) {
+function isApprovalTargetValid(item, target2, useRef) {
   switch (item.phase) {
     case "before_decision": {
-      return target.kind === "decision";
+      return target2.kind === "decision";
     }
     case "before_generation": {
-      return target.kind === "artifact";
+      return target2.kind === "artifact";
     }
     case "before_use": {
-      return target.kind === "artifact" || target.kind === "use" && useRef !== null;
+      return target2.kind === "artifact" || target2.kind === "use" && useRef !== null;
     }
     default: {
       return false;
@@ -4308,11 +4456,11 @@ function isApprovalTargetValid(item, target, useRef) {
   }
 }
 function inspectApproval(item, binding, context3) {
-  unique3(item.appliesTo.map((target) => JSON.stringify(target)), context3, ["approvals", item.id]);
-  const artifacts = new Set(binding.selected.artifacts.map((entry2) => entry2.id));
-  for (const target of item.appliesTo) {
-    const isKnown = target.kind !== "artifact" || artifacts.has(target.id);
-    const isValid = isApprovalTargetValid(item, target, binding.scope.useRef);
+  unique3(item.appliesTo.map((target2) => JSON.stringify(target2)), context3, ["approvals", item.id]);
+  const artifacts = new Set(binding.selected.artifacts.map((entry3) => entry3.id));
+  for (const target2 of item.appliesTo) {
+    const isKnown = target2.kind !== "artifact" || artifacts.has(target2.id);
+    const isValid = isApprovalTargetValid(item, target2, binding.scope.useRef);
     if (!isKnown || !isValid) {
       context3.addIssue({
         code: "custom",
@@ -4322,18 +4470,18 @@ function inspectApproval(item, binding, context3) {
     }
   }
 }
-function inspectManifest(value, context3) {
+function inspectManifest(value2, context3) {
   if (context3.issues.length > 0) {
     return;
   }
-  unique3(value.contracts.map((entry2) => entry2.id), context3, ["contracts"]);
-  unique3(value.outcomes.map((entry2) => entry2.outcomeId), context3, ["outcomes"]);
-  const contracts = new Map(value.contracts.map((entry2) => [entry2.id, entry2.contentDigest]));
-  for (const selected of value.outcomes) {
-    unique3(selected.artifacts.map((entry2) => entry2.id), context3, ["outcomes", selected.outcomeId, "artifacts"]);
-    unique3(selected.approvals.map((entry2) => entry2.id), context3, ["outcomes", selected.outcomeId, "approvals"]);
-    for (const entry2 of selected.artifacts) {
-      if (contracts.get(entry2.contract.id) !== entry2.contract.digest) {
+  unique3(value2.contracts.map((entry3) => entry3.id), context3, ["contracts"]);
+  unique3(value2.outcomes.map((entry3) => entry3.outcomeId), context3, ["outcomes"]);
+  const contracts = new Map(value2.contracts.map((entry3) => [entry3.id, entry3.contentDigest]));
+  for (const selected of value2.outcomes) {
+    unique3(selected.artifacts.map((entry3) => entry3.id), context3, ["outcomes", selected.outcomeId, "artifacts"]);
+    unique3(selected.approvals.map((entry3) => entry3.id), context3, ["outcomes", selected.outcomeId, "approvals"]);
+    for (const entry3 of selected.artifacts) {
+      if (contracts.get(entry3.contract.id) !== entry3.contract.digest) {
         context3.addIssue({
           code: "custom",
           message: "Dangling or mismatched specification reference"
@@ -4341,11 +4489,11 @@ function inspectManifest(value, context3) {
       }
     }
     for (const item of selected.approvals) {
-      inspectApproval(item, { selected, scope: value.scope }, context3);
+      inspectApproval(item, { selected, scope: value2.scope }, context3);
     }
   }
   const encoder2 = new TextEncoder();
-  if (encoder2.encode(JSON.stringify(value)).length > jobObligationsLimits.maxManifestBytes) {
+  if (encoder2.encode(JSON.stringify(value2)).length > jobObligationsLimits.maxManifestBytes) {
     context3.addIssue({ code: "custom", message: "Obligations manifest byte limit exceeded" });
   }
 }
@@ -4358,15 +4506,15 @@ var HostedOutputChecksSchema = z49.strictObject({
   schema: z49.literal("felspar.output-checks.draft/v0"),
   obligations: DraftJobObligationsSchema,
   manifests: z49.array(ArtifactCheckManifestSchema).min(1).max(hostedOutputCheckLimits.maxOutputs)
-}).superRefine((value, context3) => {
+}).superRefine((value2, context3) => {
   if (context3.issues.length > 0) {
     return;
   }
   const issue = (message) => {
     context3.addIssue({ code: "custom", message });
   };
-  const { obligations, manifests } = value;
-  const contracts = new Map(obligations.contracts.map((entry2) => [entry2.id, entry2]));
+  const { obligations, manifests } = value2;
+  const contracts = new Map(obligations.contracts.map((entry3) => [entry3.id, entry3]));
   const checked = new Set(manifests.map((manifest2) => manifest2.contract.id));
   if (checked.size !== manifests.length) {
     issue("One manifest per output contract");
@@ -4377,14 +4525,14 @@ var HostedOutputChecksSchema = z49.strictObject({
       issue("A manifest differs from its job or contract");
     }
   }
-  const required = obligations.outcomes.flatMap((entry2) => entry2.artifacts.map((artifact2) => artifact2.contract.id));
+  const required = obligations.outcomes.flatMap((entry3) => entry3.artifacts.map((artifact2) => artifact2.contract.id));
   if (required.some((contractId) => !checked.has(contractId)) || checked.size > contracts.size) {
     issue("Every required output needs exactly one manifest");
   }
 });
 
 // ../schemas/src/draft-pack-revision.ts
-import { z as z52 } from "zod";
+import { z as z55 } from "zod";
 
 // ../schemas/src/draft-pack-draft-outputs.ts
 import { z as z50 } from "zod";
@@ -4445,10 +4593,10 @@ var PackDraftScoreSchema = z51.strictObject({
   gte: points.optional(),
   eq: points.optional(),
   quote: draftQuote
-}).superRefine((value, context3) => {
-  const lower = Number(value.gt !== void 0) + Number(value.gte !== void 0);
-  const upper = Number(value.lt !== void 0) + Number(value.lte !== void 0);
-  const hasEquality = value.eq !== void 0;
+}).superRefine((value2, context3) => {
+  const lower = Number(value2.gt !== void 0) + Number(value2.gte !== void 0);
+  const upper = Number(value2.lt !== void 0) + Number(value2.lte !== void 0);
+  const hasEquality = value2.eq !== void 0;
   if (lower + upper + Number(hasEquality) === 0) {
     context3.addIssue({ code: "custom", message: "Give a bound: lt, lte, gt, gte or eq" });
   } else if (lower > 1 || upper > 1) {
@@ -4479,148 +4627,651 @@ var packDraftScoreExpectation = {
   points: z51.record(draftIdentifier, z51.number().min(0).nullable()).optional()
 };
 
+// ../schemas/src/draft-pack-draft.ts
+import { z as z54 } from "zod";
+
+// ../schemas/src/draft-pack-draft-coverage.ts
+import { z as z52 } from "zod";
+var coverageDispositions = ["represented", "needs_review", "unsupported"];
+var coverageTargetKinds = [
+  "question",
+  "rule",
+  "outcome",
+  "escalation",
+  "subject"
+];
+var coverageFields = [
+  "purpose",
+  "useWhen",
+  "notFor",
+  "owner",
+  "evidenceKinds",
+  "maxEvidenceAgeDays",
+  "manualFacts",
+  "businessDays",
+  "whenUnresolved",
+  "attempts",
+  "scoring",
+  "outputChecks",
+  "subject"
+];
+var target = z52.union([
+  ...coverageTargetKinds.map((kind) => z52.strictObject({ [kind]: draftIdentifier })),
+  z52.strictObject({ field: z52.enum(coverageFields) })
+]);
+var entry2 = z52.strictObject({
+  quote: draftQuote,
+  categories: z52.array(z52.enum(authorityPrimitives)).min(1).max(authorityPrimitives.length).refine(hasUniqueValues, "Duplicate category"),
+  disposition: z52.enum(coverageDispositions),
+  carriedBy: z52.array(target).min(1).max(16).optional(),
+  why: z52.string().min(1).max(600).optional()
+}).superRefine((row2, context3) => {
+  const isRepresented = row2.disposition === "represented";
+  if (isRepresented && row2.carriedBy === void 0) {
+    context3.addIssue({
+      code: "custom",
+      path: ["carriedBy"],
+      message: "Name what carries a represented passage: a question, rule, outcome, escalation or subject"
+    });
+  }
+  if (!isRepresented && row2.why === void 0) {
+    context3.addIssue({
+      code: "custom",
+      path: ["why"],
+      message: "Say why it is open or left out, for the owner"
+    });
+  }
+  if (!isRepresented && row2.carriedBy !== void 0) {
+    context3.addIssue({
+      code: "custom",
+      path: ["carriedBy"],
+      message: "Only a represented passage is carried by the pack"
+    });
+  }
+});
+var PackDraftCoverageSchema = z52.array(entry2).min(1).max(128);
+
+// ../schemas/src/draft-pack-draft-readings.ts
+import { z as z53 } from "zod";
+var readingCheckLimits = {
+  maxPerAnswer: 8,
+  maxPerCheck: 96,
+  maxKept: 200,
+  maxCharacters: 2e3,
+  maxLabelCharacters: 120
+};
+var PackDraftReadingTestSchema = z53.strictObject({
+  id: draftIdentifier,
+  question: draftIdentifier,
+  text: z53.string().trim().min(1).max(readingCheckLimits.maxCharacters),
+  expect: draftValue
+});
+var PackDraftReadingTestsSchema = z53.array(PackDraftReadingTestSchema).min(1).max(readingCheckLimits.maxKept).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate reading test");
+function readingTestIssue(row2, questions, path3) {
+  const question3 = questions.find((item) => item.key === row2.question);
+  if (question3 === void 0 || question3.type !== void 0 || question3.derive !== void 0) {
+    return {
+      path: [...path3, "question"],
+      message: `"${row2.question}" is not a choice question Felspar reads from text`
+    };
+  }
+  const answers2 = question3.answers ?? [];
+  return answers2.every((answer) => answer.value !== row2.expect) ? {
+    path: [...path3, "expect"],
+    message: `"${row2.expect}" is not one of the answers of "${row2.question}"`
+  } : null;
+}
+function readingTestIssues(tests, questions) {
+  const issues = [];
+  const perAnswer = /* @__PURE__ */ new Map();
+  const rows = tests ?? [];
+  for (const [index, row2] of rows.entries()) {
+    const path3 = ["readingTests", index];
+    const issue = readingTestIssue(row2, questions, path3);
+    const at = JSON.stringify([row2.question, row2.expect]);
+    const count2 = (perAnswer.get(at) ?? 0) + 1;
+    perAnswer.set(at, count2);
+    if (issue !== null) {
+      issues.push(issue);
+    } else if (count2 > readingCheckLimits.maxPerAnswer) {
+      issues.push({
+        path: path3,
+        message: `At most ${readingCheckLimits.maxPerAnswer} reading tests per answer`
+      });
+    }
+  }
+  return issues;
+}
+var variant = z53.strictObject({
+  id: draftIdentifier.optional(),
+  question: draftIdentifier,
+  text: z53.string().trim().min(1).max(readingCheckLimits.maxCharacters),
+  expect: draftValue.optional(),
+  label: z53.string().trim().min(1).max(readingCheckLimits.maxLabelCharacters).optional()
+});
+var ReadingCheckRequestSchema = z53.strictObject({
+  sourceObjectId: z53.string().min(1).max(200),
+  draft: z53.unknown(),
+  variants: z53.array(variant).max(readingCheckLimits.maxPerCheck).optional(),
+  includeTests: z53.boolean().default(true)
+});
+var readingResults = ["as_expected", "different", "held", "read", "not_read"];
+var readingReasons = [
+  "below_bar",
+  "cannot_tell",
+  "tie",
+  "looks_like_instructions",
+  "evaluation_off",
+  "limit_reached",
+  "not_answered"
+];
+var probability = z53.number().min(0).max(1);
+var ReadingOutcomeSchema = z53.strictObject({
+  id: z53.string().min(1).max(200),
+  origin: z53.enum(["test", "sent"]),
+  question: z53.string().min(1).max(200),
+  label: z53.string().optional(),
+  expect: z53.string().nullable(),
+  result: z53.enum(readingResults),
+  picked: z53.string().nullable(),
+  leaning: z53.string().nullable(),
+  confidence: probability.nullable(),
+  bar: probability,
+  reason: z53.enum(readingReasons).nullable()
+});
+var count = z53.number().int().min(0);
+var counts = z53.strictObject({
+  as_expected: count,
+  different: count,
+  held: count,
+  read: count,
+  not_read: count
+});
+var ReadingCheckSchema = z53.strictObject({
+  schema: z53.literal("felspar.reading-check/v0"),
+  authority: z53.literal("unapproved"),
+  jobId: z53.string(),
+  status: z53.enum(["clean", "misses", "incomplete"]),
+  counts,
+  questions: z53.array(z53.strictObject({ question: z53.string(), bar: probability, counts })),
+  readings: z53.array(ReadingOutcomeSchema)
+});
+
+// ../schemas/src/draft-pack-draft.ts
+var identifier22 = draftIdentifier;
+var quote2 = draftQuote;
+var value = draftValue;
+var conditions = PackDraftConditionsSchema;
+var ruleOrders = ["first-match", "unordered"];
+var packDraftVersions = [
+  "felspar.pack-draft/v0",
+  "felspar.pack-draft/v1",
+  "felspar.pack-draft/v2"
+];
+var answers = z54.array(z54.strictObject({
+  value,
+  meaning: quote2,
+  inclusions: z54.array(quote2).max(8).optional(),
+  exclusions: z54.array(quote2).max(8).optional(),
+  examples: z54.array(quote2).max(8).optional(),
+  edgeCases: z54.array(quote2).max(8).optional(),
+  noneOfThese: z54.literal(true).optional()
+})).min(2).max(64).refine((rows) => hasUniqueValues(rows.map((row2) => row2.value)), "Duplicate answer").refine((rows) => rows.filter((row2) => row2.noneOfThese === true).length <= 1, "Only one answer may be noneOfThese");
+var derive = z54.strictObject({
+  from: identifier22,
+  when: z54.record(value, z54.union([value, z54.array(value).min(2).max(64)])),
+  otherwise: value.optional()
+});
+var notDerived = [
+  "type",
+  "askOnlyWhen",
+  "whereToLook",
+  "about",
+  "evidence",
+  "minimumConfidence",
+  "highConsequence"
+];
+function computedIssue(field) {
+  return {
+    path: [field],
+    message: `A derived question is computed, never asked: it has no ${field}`
+  };
+}
+function deriveIssues(row2) {
+  const rule3 = row2.derive;
+  if (rule3 === void 0) {
+    return [];
+  }
+  const present = notDerived.filter((field) => row2[field] !== void 0);
+  const issues = present.map(computedIssue);
+  const values = new Set((row2.answers ?? []).map((answer) => answer.value));
+  const named = [
+    ...Object.keys(rule3.when),
+    ...rule3.otherwise === void 0 ? [] : [rule3.otherwise]
+  ];
+  const unknown = named.filter((item) => !values.has(item));
+  for (const answer of unknown) {
+    issues.push({ path: ["derive"], message: `"${answer}" is not one of this question's answers` });
+  }
+  if (rule3.otherwise !== void 0 && Object.hasOwn(rule3.when, rule3.otherwise)) {
+    issues.push({
+      path: ["derive", "otherwise"],
+      message: "otherwise names an answer already in when"
+    });
+  }
+  if ((row2.answers ?? []).some((answer) => answer.noneOfThese === true)) {
+    issues.push({ path: ["answers"], message: "A derived question has no noneOfThese answer" });
+  }
+  return issues;
+}
+var evidenceKinds = z54.array(identifier22).min(1).max(8).refine(hasUniqueValues, "Duplicate kind");
+var evidenceAge = z54.number().int().min(1).max(3650);
+var questionEvidence = z54.strictObject({
+  evidenceKinds: evidenceKinds.optional(),
+  maxEvidenceAgeDays: evidenceAge.optional(),
+  quote: quote2
+}).refine((row2) => row2.evidenceKinds !== void 0 || row2.maxEvidenceAgeDays !== void 0, "Give evidenceKinds, maxEvidenceAgeDays or both");
+var minimumConfidence = z54.number().min(0.5).max(0.99);
+var question2 = z54.strictObject({
+  key: identifier22,
+  meaning: quote2,
+  answers: answers.optional(),
+  ...typedQuestionFields,
+  askOnlyWhen: conditions.optional(),
+  whereToLook: z54.array(quote2).max(8).optional(),
+  about: identifier22.optional(),
+  derive: derive.optional(),
+  evidence: questionEvidence.optional(),
+  minimumConfidence: minimumConfidence.optional(),
+  highConsequence: z54.literal(true).optional()
+}).superRefine((row2, context3) => {
+  if (row2.type !== void 0 && row2.highConsequence !== void 0) {
+    context3.addIssue({
+      code: "custom",
+      path: ["highConsequence"],
+      message: "A number or date is read exactly, with no confidence bar to calibrate"
+    });
+  }
+  if (row2.type !== void 0 && row2.minimumConfidence !== void 0) {
+    context3.addIssue({
+      code: "custom",
+      path: ["minimumConfidence"],
+      message: "A number or date is read exactly, with no confidence bar"
+    });
+  }
+  for (const issue of questionIssues(row2)) {
+    context3.addIssue({ code: "custom", ...issue });
+  }
+  for (const issue of deriveIssues(row2)) {
+    context3.addIssue({ code: "custom", ...issue });
+  }
+});
+var shape3 = z54.strictObject({
+  schema: z54.enum(packDraftVersions),
+  job: identifier22,
+  purpose: quote2.optional(),
+  useWhen: z54.array(quote2).min(1).max(8).optional(),
+  notFor: z54.array(quote2).min(1).max(8).optional(),
+  owner: quote2.optional(),
+  evidenceKinds,
+  maxEvidenceAgeDays: evidenceAge,
+  manualFacts: z54.strictObject({ allowed: z54.literal(false), quote: quote2 }).optional(),
+  ...packConventionFields,
+  businessDays: PackDraftBusinessDaysSchema.optional(),
+  questions: z54.array(question2).min(1).max(64).refine((rows) => hasUniqueValues(rows.map((row2) => row2.key)), "Duplicate question"),
+  subjects: PackDraftSubjectsSchema.optional(),
+  subject: identifier22.optional(),
+  escalations: PackDraftEscalationsSchema.optional(),
+  outcomes: z54.array(z54.strictObject({
+    id: identifier22,
+    nextStep: quote2,
+    escalate: identifier22.optional()
+  })).min(1).max(64).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate outcome"),
+  whenUnresolved: z54.union([quote2, z54.strictObject({ quote: quote2, escalate: identifier22 })]),
+  attempts: z54.strictObject({
+    max: z54.number().int().min(1).max(10).optional(),
+    escalate: identifier22.optional()
+  }).optional(),
+  scoring: PackDraftScoringSchema.optional(),
+  ruleOrder: z54.enum(ruleOrders).optional(),
+  rules: z54.array(z54.strictObject({
+    id: identifier22,
+    meaning: quote2,
+    when: conditions.optional(),
+    score: PackDraftScoreSchema.optional(),
+    gate: z54.literal(true).optional(),
+    outcome: identifier22,
+    except: z54.array(identifier22).min(1).max(16).refine(hasUniqueValues, "Duplicate rule").optional()
+  })).min(1).max(256).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate rule"),
+  cases: z54.array(z54.strictObject({
+    id: identifier22,
+    why: z54.string().min(1).max(2e3),
+    facts: z54.record(identifier22, caseFactSchema),
+    decisionDate: caseDecisionDate,
+    subject: z54.strictObject({ id: SubjectIdSchema }).optional(),
+    expect: z54.union([
+      z54.strictObject({
+        outcome: identifier22,
+        rule: identifier22,
+        escalation: identifier22.optional(),
+        ...packDraftScoreExpectation
+      }),
+      z54.strictObject({ held: z54.enum(heldStates), ...packDraftScoreExpectation })
+    ])
+  })).min(1).max(200).refine((rows) => hasUniqueValues(rows.map((row2) => row2.id)), "Duplicate case"),
+  outputChecks: PackDraftOutputsSchema.optional(),
+  readingTests: PackDraftReadingTestsSchema.optional(),
+  coverage: PackDraftCoverageSchema.optional()
+});
+function comparisonPaths(when2, at) {
+  const entries2 = Object.entries(when2 ?? {});
+  return entries2.flatMap(([key3, condition]) => isComparison(condition) ? [[...at, key3]] : []);
+}
+function presentPaths(row2, fields, at) {
+  return fields.filter((field) => row2[field] !== void 0).map((field) => [...at, field]);
+}
+function casePaths(row2, at) {
+  const facts = Object.entries(row2.facts);
+  const isTyped = (fact) => typeof fact !== "string";
+  return [
+    ...presentPaths(row2, ["decisionDate"], at),
+    ...presentPaths(row2.expect, ["score", "points"], [...at, "expect"]),
+    ..."held" in row2.expect ? [[...at, "expect", "held"]] : [],
+    ...facts.flatMap(([key3, fact]) => isTyped(fact) ? [[...at, "facts", key3]] : [])
+  ];
+}
+function v1Paths(draft) {
+  const paths = presentPaths(draft, ["numberStyle", "dateOrder", "timeZone", "scoring", "businessDays", "ruleOrder"], []);
+  for (const [index, row2] of draft.questions.entries()) {
+    const at = ["questions", String(index)];
+    paths.push(...presentPaths(row2, ["type", "derive", "evidence", "minimumConfidence", "highConsequence"], at), ...comparisonPaths(row2.askOnlyWhen, [...at, "askOnlyWhen"]));
+  }
+  for (const [index, rule3] of draft.rules.entries()) {
+    const at = ["rules", String(index)];
+    paths.push(...presentPaths(rule3, ["score", "gate", "except"], at), ...comparisonPaths(rule3.when, [...at, "when"]));
+  }
+  for (const [index, row2] of draft.cases.entries()) {
+    paths.push(...casePaths(row2, ["cases", String(index)]));
+  }
+  return paths;
+}
+var PackDraftSchema = shape3.superRefine((draft, context3) => {
+  for (const issue of readingTestIssues(draft.readingTests, draft.questions)) {
+    context3.addIssue({ code: "custom", ...issue });
+  }
+  if (draft.schema === "felspar.pack-draft/v2" && draft.purpose === void 0) {
+    context3.addIssue({
+      code: "custom",
+      path: ["purpose"],
+      message: "Quote the job's purpose: why it exists and what it resolves"
+    });
+  }
+  if (draft.schema !== "felspar.pack-draft/v0") {
+    return;
+  }
+  for (const path3 of v1Paths(draft)) {
+    context3.addIssue({
+      code: "custom",
+      path: path3,
+      message: 'Number and date questions, derived questions, thresholds, conventions, scoring, business days, exceptions, rule order, per-question evidence and held cases need "schema": "felspar.pack-draft/v1"'
+    });
+  }
+});
+
 // ../schemas/src/draft-pack-revision.ts
-var KeptPackDraftSchema = z52.looseObject({
-  schema: z52.string().regex(/^felspar\.pack-draft\/v\d{1,3}$/u),
-  job: z52.string().min(1).max(200)
+var KeptPackDraftSchema = z55.looseObject({
+  schema: z55.string().regex(/^felspar\.pack-draft\/v\d{1,3}$/u),
+  job: z55.string().min(1).max(200)
 });
-var id6 = z52.string().min(1).max(200);
-var text7 = z52.string().min(1).max(262144);
-var texts = z52.array(z52.string()).max(8);
+var id6 = z55.string().min(1).max(200);
+var text7 = z55.string().min(1).max(262144);
+var texts = z55.array(z55.string()).max(8);
 var when = PackDraftConditionsSchema;
 var conventions = packConventionFields;
-var PackOutlineSchema = z52.strictObject({
-  schema: z52.literal("felspar.pack-outline/v0"),
+var PackOutlineSchema = z55.strictObject({
+  schema: z55.literal("felspar.pack-outline/v0"),
   job: id6,
   purpose: text7.nullable(),
   useWhen: texts,
   notFor: texts,
   owner: text7.nullable(),
-  evidenceKinds: z52.array(id6).max(8),
-  maxEvidenceAgeDays: z52.number().int().min(1).nullable(),
-  numberStyle: z52.enum(numberStyles).nullable(),
+  evidenceKinds: z55.array(id6).max(8),
+  maxEvidenceAgeDays: z55.number().int().min(1).nullable(),
+  numberStyle: z55.enum(numberStyles).nullable(),
   dateOrder: conventions.dateOrder.unwrap().nullable(),
-  timeZone: z52.string().min(1).max(64).nullable(),
+  timeZone: z55.string().min(1).max(64).nullable(),
+  businessDays: PackDraftBusinessDaysSchema.nullable(),
   subject: id6.nullable(),
-  subjects: z52.array(z52.strictObject({
+  subjects: z55.array(z55.strictObject({
     id: id6,
     definition: text7,
-    identifier: z52.string().nullable(),
-    example: z52.string().nullable(),
-    match: z52.string(),
-    relationships: z52.array(z52.strictObject({
+    identifier: z55.string().nullable(),
+    example: z55.string().nullable(),
+    match: z55.string(),
+    relationships: z55.array(z55.strictObject({
       name: id6,
       subject: id6,
-      cardinality: z52.enum(["one", "many"]),
-      required: z52.boolean(),
+      cardinality: z55.enum(["one", "many"]),
+      required: z55.boolean(),
       definition: text7
     })).max(16),
     identity: PackDraftIdentitySchema.nullable()
   })).max(16),
-  escalations: z52.array(z52.strictObject({ id: id6, quote: text7 })).max(16),
-  questions: z52.array(z52.strictObject({
+  escalations: z55.array(z55.strictObject({ id: id6, quote: text7 })).max(16),
+  questions: z55.array(z55.strictObject({
     key: id6,
-    type: z52.enum(["enum", "boolean", "number", "date"]),
+    type: z55.enum(["enum", "boolean", "number", "date"]),
     meaning: text7,
     about: id6.nullable(),
-    askOnlyWhen: z52.string().nullable(),
+    askOnlyWhen: z55.string().nullable(),
     when: when.nullable(),
-    unit: z52.string().nullable(),
-    unitWords: z52.array(z52.string()).max(16).nullable(),
-    integer: z52.boolean().nullable(),
-    minimum: z52.number().nullable(),
-    maximum: z52.number().nullable(),
-    answers: z52.array(z52.strictObject({
+    unit: z55.string().nullable(),
+    unitWords: z55.array(z55.string()).max(16).nullable(),
+    integer: z55.boolean().nullable(),
+    minimum: z55.number().nullable(),
+    maximum: z55.number().nullable(),
+    answers: z55.array(z55.strictObject({
       value: id6,
-      meaning: z52.string().nullable(),
+      meaning: z55.string().nullable(),
       inclusions: texts,
       exclusions: texts,
       examples: texts,
       edgeCases: texts
     })).max(64),
-    whereToLook: texts
+    whereToLook: texts,
+    evidence: z55.strictObject({
+      evidenceKinds: z55.array(id6).max(8).nullable(),
+      maxEvidenceAgeDays: z55.number().int().min(1).nullable(),
+      quote: text7
+    }).nullable(),
+    minimumConfidence: z55.number().nullable()
   })).max(64),
-  outcomes: z52.array(z52.strictObject({ id: id6, nextStep: text7.nullable(), escalate: id6.nullable() })).max(64),
-  whenUnresolved: z52.strictObject({ quote: text7, escalate: id6.nullable() }).nullable(),
-  attempts: z52.strictObject({ max: z52.number().int(), escalate: id6.nullable() }).nullable(),
-  rules: z52.array(z52.strictObject({
+  outcomes: z55.array(z55.strictObject({ id: id6, nextStep: text7.nullable(), escalate: id6.nullable() })).max(64),
+  whenUnresolved: z55.strictObject({ quote: text7, escalate: id6.nullable() }).nullable(),
+  attempts: z55.strictObject({ max: z55.number().int(), escalate: id6.nullable() }).nullable(),
+  rules: z55.array(z55.strictObject({
     id: id6,
     meaning: text7,
     outcome: id6,
     when: when.nullable(),
-    conditions: z52.string().nullable(),
-    scoreRange: z52.record(z52.string(), z52.unknown()).nullable(),
+    conditions: z55.string().nullable(),
+    scoreRange: z55.record(z55.string(), z55.unknown()).nullable(),
     score: PackDraftScoreSchema.nullable(),
-    gate: z52.boolean()
+    gate: z55.boolean(),
+    except: z55.array(id6).max(16).nullable()
   })).max(256),
+  ruleOrder: z55.enum(ruleOrders).nullable(),
   scoring: PackDraftScoringSchema.nullable(),
-  cases: z52.array(z52.strictObject({
+  cases: z55.array(z55.strictObject({
     id: id6,
-    why: z52.string().nullable(),
-    facts: z52.record(id6, caseFactSchema),
+    why: z55.string().nullable(),
+    facts: z55.record(id6, caseFactSchema),
     decisionDate: CalendarDateSchema.nullable(),
-    subject: z52.strictObject({ id: id6 }).nullable(),
-    expect: z52.strictObject({ outcome: id6, rule: id6, score: z52.number().nullable() })
+    subject: z55.strictObject({ id: id6 }).nullable(),
+    expect: z55.union([
+      z55.strictObject({ outcome: id6, rule: id6, score: z55.number().nullable() }),
+      z55.strictObject({ held: z55.enum(heldStates), score: z55.number().nullable() })
+    ])
   })).max(200),
   outputChecks: PackDraftOutputsSchema.nullable(),
-  notKept: z52.array(z52.strictObject({ path: z52.string().min(1), reason: z52.string().min(1) })).max(64)
+  manualFacts: z55.strictObject({ allowed: z55.literal(false), quote: z55.string().min(1) }).nullable(),
+  notKept: z55.array(z55.strictObject({ path: z55.string().min(1), reason: z55.string().min(1) })).max(64)
+});
+
+// ../schemas/src/draft-bar-calibration.ts
+import { z as z56 } from "zod";
+var barCalibrationPolicy = {
+  lowestBar: 0.8,
+  highestBar: 0.99,
+  targets: { ordinary: 0.9, strict: 0.97 },
+  minimumCases: 10,
+  minimumDecided: 5,
+  maxLabels: 400
+};
+var barCalibrationId = "felspar-backtest-bar";
+var barCalibrationVersion = "v1";
+var id7 = z56.string().min(1).max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:@-]*$/u);
+var digest23 = z56.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var share = z56.number().min(0).max(1);
+var bar = z56.number().min(barCalibrationPolicy.lowestBar).max(barCalibrationPolicy.highestBar);
+var BacktestLabelSchema = z56.strictObject({
+  executionObjectId: id7,
+  question: draftValue,
+  answer: draftValue.nullable()
+});
+var BacktestLabelsSchema = z56.array(BacktestLabelSchema).min(1).max(barCalibrationPolicy.maxLabels).refine((rows) => {
+  const seen = new Set(rows.map((row2) => JSON.stringify([row2.executionObjectId, row2.question])));
+  return seen.size === rows.length;
+}, "Label each question of a case once");
+var calibrationReadings = ["right", "wrong", "held"];
+var caseRow = z56.strictObject({
+  executionObjectId: id7,
+  label: draftValue.nullable(),
+  leaning: draftValue.nullable(),
+  confidence: share.nullable(),
+  atCurrentBar: z56.enum(calibrationReadings),
+  atSuggestedBar: z56.enum(calibrationReadings).nullable()
+});
+var barRow = z56.strictObject({
+  bar,
+  decided: z56.number().int().min(0),
+  right: z56.number().int().min(0),
+  precision: share.nullable(),
+  coverage: share
+});
+var calibrationStatuses = [
+  "suggested",
+  "too_few_cases",
+  "coverage_gap",
+  "needs_more_evidence_or_rewrite"
+];
+var QuestionCalibrationSchema = z56.strictObject({
+  question: id7,
+  status: z56.enum(calibrationStatuses),
+  consequence: z56.enum(["ordinary", "strict"]),
+  target: share,
+  currentBar: share,
+  labeled: z56.number().int().min(0),
+  insufficient: z56.number().int().min(0),
+  otherAnswers: z56.number().int().min(0),
+  notRead: z56.number().int().min(0),
+  suggestion: z56.strictObject({
+    bar,
+    precision: share,
+    coverage: share,
+    calibration: z56.strictObject({
+      id: z56.literal(barCalibrationId),
+      version: z56.literal(barCalibrationVersion),
+      contentDigest: digest23
+    })
+  }).optional(),
+  bars: z56.array(barRow).max(20),
+  cases: z56.array(caseRow).max(50)
+});
+var BacktestCalibrationSchema = z56.strictObject({
+  schema: z56.literal("felspar.bar-calibration/v1"),
+  calibrationDigest: digest23,
+  minimumCases: z56.number().int().min(1),
+  questions: z56.array(QuestionCalibrationSchema).max(64),
+  ignoredLabels: z56.number().int().min(0)
+});
+var AcceptedBarsSchema = z56.strictObject({
+  savedResultId: z56.string().regex(/^backtest-[a-f0-9]{32}$/u),
+  calibrationDigest: digest23,
+  questions: z56.array(id7).min(1).max(64)
+});
+var ReleaseCalibrationSchema = AcceptedBarsSchema.extend({
+  acceptedBy: z56.string().min(1).max(200),
+  approvedMaterialDigest: digest23,
+  bars: z56.array(z56.strictObject({ question: id7, bar, calibrationDigest: digest23 })).min(1).max(64)
 });
 
 // ../schemas/src/draft-hosted-application.ts
-var id7 = z53.string().min(1).max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:@-]*$/u);
-var digest23 = DraftApplicationReleaseSchema.shape.releaseDigest;
-var HostedSourceInputSchema = z53.strictObject({
-  sourceId: id7,
-  revision: id7,
-  title: z53.string().min(1).max(200),
-  text: z53.string().min(1).max(1048576)
-});
-var HostedProposalInputV0Schema = z53.strictObject({
-  sourceObjectId: id7,
-  expectedSourceDigest: digest23,
+var id8 = z57.string().min(1).max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:@-]*$/u);
+var digest24 = DraftApplicationReleaseSchema.shape.releaseDigest;
+var HostedSourceInputSchema = z57.strictObject({
+  sourceId: id8,
+  revision: id8,
+  title: z57.string().min(1).max(200),
+  text: z57.string().min(1).max(1048576)
+});
+var HostedProposalInputV0Schema = z57.strictObject({
+  sourceObjectId: id8,
+  expectedSourceDigest: digest24,
   material: DraftApplicationJobMaterialSchema,
   compilation: DraftCompilationSchema
 });
-var HostedProposalInputV2Schema = z53.strictObject({
-  schema: z53.literal("felspar.hosted-proposal.draft/v2"),
-  sourceObjectId: id7,
-  expectedSourceDigest: digest23,
+var HostedManualFactsRuleSchema = z57.strictObject({
+  allowed: z57.literal(false),
+  text: z57.string().min(1).max(4e3),
+  sourceLocator: z57.string().min(1).max(4096),
+  contentDigest: digest24
+});
+var HostedProposalInputV2Schema = z57.strictObject({
+  schema: z57.literal("felspar.hosted-proposal.draft/v2"),
+  sourceObjectId: id8,
+  expectedSourceDigest: digest24,
   material: DraftApplicationJobMaterialV2Schema,
   outputChecks: HostedOutputChecksSchema.optional(),
+  manualFacts: HostedManualFactsRuleSchema.optional(),
   draft: KeptPackDraftSchema.optional()
 });
-var HostedProposalInputSchema = z53.union([
+var HostedProposalInputSchema = z57.union([
   HostedProposalInputV2Schema,
   HostedProposalInputV0Schema
 ]);
-var HostedApprovalInputSchema = z53.strictObject({
-  expectedProposalDigest: digest23,
-  reviewedMeaning: z53.literal(true),
-  reviewedFixtures: z53.literal(true),
-  reviewNote: z53.string().min(1).max(2e3)
-});
-var HostedReleaseInputSchema = z53.strictObject({ expectedApprovalDigest: digest23 });
-var HostedReleaseBundleSchema = z53.strictObject({
+var HostedApprovalInputSchema = z57.strictObject({
+  expectedProposalDigest: digest24,
+  reviewedMeaning: z57.literal(true),
+  reviewedFixtures: z57.literal(true),
+  reviewNote: z57.string().min(1).max(2e3)
+});
+var HostedReleaseInputSchema = z57.strictObject({
+  expectedApprovalDigest: digest24,
+  acceptBars: AcceptedBarsSchema.optional()
+});
+var HostedReleaseBundleSchema = z57.strictObject({
   release: DraftApplicationReleaseSchema,
   material: DraftAnyApplicationJobMaterialSchema,
-  approvalObjectId: id7,
-  approvalDigest: digest23,
-  proposalDigest: digest23,
-  sourceDigest: digest23,
-  verifiedCompilation: DraftVerifiedCompilationSchema.optional()
-});
-var HostedJobInputSchema = z53.strictObject({
-  executionId: id7,
-  expectedReleaseDigest: digest23,
+  approvalObjectId: id8,
+  approvalDigest: digest24,
+  proposalDigest: digest24,
+  sourceDigest: digest24,
+  verifiedCompilation: DraftVerifiedCompilationSchema.optional(),
+  calibration: ReleaseCalibrationSchema.optional()
+});
+var HostedJobInputSchema = z57.strictObject({
+  executionId: id8,
+  expectedReleaseDigest: digest24,
   material: DraftAnyApplicationJobMaterialSchema
 });
-var HostedSuppliedJobInputSchema = z53.strictObject({
-  mode: z53.literal("supplied"),
-  executionId: id7,
-  expectedReleaseDigest: digest23,
-  expectedAuthorityDigest: digest23,
-  jobId: id7,
-  entityId: id7,
+var HostedSuppliedJobInputSchema = z57.strictObject({
+  mode: z57.literal("supplied"),
+  executionId: id8,
+  expectedReleaseDigest: digest24,
+  expectedAuthorityDigest: digest24,
+  jobId: id8,
+  entityId: id8,
   evidence: DraftRequiredDecisionSchema.shape.evidence,
   passages: DraftLayeredEvaluationSchema.shape.passages.max(256)
 });
@@ -4630,97 +5281,185 @@ var hostedFactsLimits = {
   maxFactsBytes: 524288,
   maxQuestions: 64
 };
-var factSourceId = z53.string().refine(isDraftSourceId, "source_id_invalid").describe(`The source's own ID or address, such as its page URL with any query: RFC 3986 characters, starting with a letter or digit, at most ${draftSourceIdLimit} characters.`);
-var observedAt = z53.string().refine((value) => normalizedSourceInstant(value) !== null, "observed_at_invalid").transform((value) => normalizedSourceInstant(value) ?? value).describe(`When the source was read: an RFC 3339 date and time with Z or an offset, such as 2026-10-21T10:00:00Z or 2026-10-21T12:00+02:00, at most ${sourceInstantMaxLength} characters. Stored in UTC.`);
-var factSource = z53.strictObject({
-  class: id7,
+var factSourceId = z57.string().refine(isDraftSourceId, "source_id_invalid").describe(`The source's own ID or address, such as its page URL with any query: RFC 3986 characters, starting with a letter or digit, at most ${draftSourceIdLimit} characters.`);
+var observedAt = z57.string().refine((value2) => normalizedSourceInstant(value2) !== null, "observed_at_invalid").transform((value2) => normalizedSourceInstant(value2) ?? value2).describe(`When the source was read: an RFC 3339 date and time with Z or an offset, such as 2026-10-21T10:00:00Z or 2026-10-21T12:00+02:00, at most ${sourceInstantMaxLength} characters. Stored in UTC.`);
+var sourceFields = {
+  class: id8,
   id: factSourceId,
-  revision: id7.optional(),
-  locator: z53.string().min(1).max(4096).optional(),
+  revision: id8.optional(),
+  locator: z57.string().min(1).max(4096).optional(),
   observedAt,
-  sensitivity: id7.optional()
-});
-var excerptText = z53.string().min(1).refine((text8) => text8.length <= hostedFactsLimits.maxExcerptCharacters, "text_too_long");
-var about = z53.string().min(1).max(200).optional();
-var HostedExcerptSchema = z53.strictObject({ text: excerptText, source: factSource, about });
-var HostedValueFactSchema = z53.strictObject({
-  value: z53.union([z53.string().min(1).max(200), z53.number(), z53.boolean()]),
-  source: factSource.extend({ excerpt: excerptText.optional() }),
-  about
-});
-var HostedFactSchema = z53.union([
-  HostedValueFactSchema,
-  HostedExcerptSchema,
-  z53.array(HostedExcerptSchema).min(1).refine((excerpts2) => excerpts2.length <= hostedFactsLimits.maxExcerptsPerQuestion, "too_many_excerpts")
-]);
+  sensitivity: id8.optional()
+};
+var manualSourcePrefix = "felspar:";
+var suppliedBy = z57.string().trim().min(1).max(200);
+var isReserved = (sourceId2) => sourceId2?.toLowerCase().startsWith(manualSourcePrefix) === true;
+function sourceIssues(source3) {
+  if (source3.manual === true) {
+    return [
+      ...source3.id === void 0 ? [] : [{ path: ["id"], code: "manual_source_id" }],
+      ...source3.revision === void 0 ? [] : [{ path: ["revision"], code: "manual_source_id" }]
+    ];
+  }
+  return [
+    ...source3.id === void 0 ? [{ path: ["id"], code: "source_id_required" }] : [],
+    ...isReserved(source3.id) ? [{ path: ["id"], code: "source_id_reserved" }] : [],
+    ...source3.observedAt === void 0 ? [{ path: ["observedAt"], code: "observed_at_required" }] : [],
+    ...source3.suppliedBy === void 0 ? [] : [{ path: ["suppliedBy"], code: "supplied_by_needs_manual" }]
+  ];
+}
+function isAdmittedManual(source3) {
+  return source3.by !== void 0 && source3.id === void 0 && source3.revision === void 0;
+}
+function isAdmittedOrdinary(source3) {
+  const isUnmarked = source3.by === void 0 && source3.stamped === void 0 && source3.suppliedBy === void 0;
+  return source3.id !== void 0 && isUnmarked;
+}
+function isAdmitted(source3) {
+  return source3.manual === true ? isAdmittedManual(source3) : isAdmittedOrdinary(source3);
+}
+var excerptText = z57.string().min(1).refine((text8) => text8.length <= hostedFactsLimits.maxExcerptCharacters, "text_too_long");
+var valueSourceFields = { excerpt: excerptText.optional() };
+var requestSourceFields = {
+  ...sourceFields,
+  id: factSourceId.optional(),
+  observedAt: observedAt.optional(),
+  manual: z57.literal(true).optional(),
+  suppliedBy: suppliedBy.optional()
+};
+function refusedSourceIssues(source3, context3) {
+  for (const issue of sourceIssues(source3)) {
+    context3.addIssue({ code: "custom", path: issue.path, message: issue.code });
+  }
+}
+var admittedSourceFields = {
+  ...sourceFields,
+  id: factSourceId.optional(),
+  manual: z57.literal(true).optional(),
+  suppliedBy: suppliedBy.optional(),
+  by: id8.optional(),
+  stamped: z57.literal(true).optional()
+};
+var requestSource = z57.strictObject(requestSourceFields).superRefine(refusedSourceIssues);
+var requestValueSource = z57.strictObject({ ...requestSourceFields, ...valueSourceFields }).superRefine(refusedSourceIssues);
+var admittedSource = z57.strictObject(admittedSourceFields).refine(isAdmitted, "source_not_admitted");
+var admittedValueSource = z57.strictObject({ ...admittedSourceFields, ...valueSourceFields }).refine(isAdmitted, "source_not_admitted");
+var about = z57.string().min(1).max(200).optional();
+var hostedCaseRecordLimits = {
+  maxExcerptsPerQuestion: 30,
+  maxExcerpts: hostedFactsLimits.maxQuestions * hostedFactsLimits.maxExcerptsPerQuestion,
+  maxAttempts: 12
+};
+function factSchemas(source3, valueSource, isRecord) {
+  const excerpt2 = z57.strictObject({ text: excerptText, source: source3, about });
+  const valueFact = z57.strictObject({
+    value: z57.union([z57.string().min(1).max(200), z57.number(), z57.boolean()]),
+    source: valueSource,
+    about
+  });
+  const cap = isRecord ? hostedCaseRecordLimits.maxExcerptsPerQuestion : hostedFactsLimits.maxExcerptsPerQuestion;
+  const listed = isRecord ? z57.union([excerpt2, valueFact]) : excerpt2;
+  const fact = z57.union([
+    valueFact,
+    excerpt2,
+    z57.array(listed).min(1).refine((excerpts2) => excerpts2.length <= cap, "too_many_excerpts")
+  ]);
+  return { excerpt: excerpt2, valueFact, fact };
+}
+var admittedFacts = factSchemas(admittedSource, admittedValueSource, true);
+var requestFacts = factSchemas(requestSource, requestValueSource, false);
+var HostedExcerptSchema = admittedFacts.excerpt;
+var HostedValueFactSchema = admittedFacts.valueFact;
+var HostedFactSchema = admittedFacts.fact;
 function factsBytes(facts) {
   const encoder2 = new TextEncoder();
   return encoder2.encode(JSON.stringify(facts)).length;
 }
-var HostedFactsJobInputSchema = z53.strictObject({
-  mode: z53.literal("facts"),
-  executionId: id7,
-  expectedReleaseDigest: digest23,
-  jobId: id7,
-  entityId: id7,
+function questionsOf(fact) {
+  return z57.record(id8, fact).refine((facts) => Object.keys(facts).length <= hostedFactsLimits.maxQuestions, "too_many_questions");
+}
+function factsOf(fact) {
+  return questionsOf(fact).refine((facts) => factsBytes(facts) <= hostedFactsLimits.maxFactsBytes, "request_too_large");
+}
+var HostedFactsJobInputSchema = z57.strictObject({
+  mode: z57.literal("facts"),
+  executionId: id8,
+  expectedReleaseDigest: digest24,
+  jobId: id8,
+  entityId: id8,
   related: HostedRelatedSubjectsSchema.optional(),
-  identity: z53.record(z53.string().min(1).max(128), z53.string().min(1).max(200)).optional(),
-  facts: z53.record(id7, HostedFactSchema).refine((facts) => Object.keys(facts).length <= hostedFactsLimits.maxQuestions, "too_many_questions").refine((facts) => factsBytes(facts) <= hostedFactsLimits.maxFactsBytes, "request_too_large")
+  identity: z57.record(z57.string().min(1).max(128), z57.string().min(1).max(200)).optional(),
+  facts: questionsOf(HostedFactSchema)
 });
 var HostedFactsRequestSchema = HostedFactsJobInputSchema.extend({
-  entityId: id7.optional()
+  entityId: id8.optional(),
+  facts: factsOf(requestFacts.fact)
 });
-var HostedJobRequestSchema = z53.union([
+var HostedJobRequestSchema = z57.union([
   HostedJobInputSchema,
   HostedSuppliedJobInputSchema,
   HostedFactsJobInputSchema
 ]);
-var HostedClassificationResultSchema = z53.strictObject({
-  key: id7,
-  observationId: id7,
+var HostedClassificationResultSchema = z57.strictObject({
+  key: id8,
+  observationId: id8,
   record: DraftNormalizedEvidenceSchema.shape.normalizations.element,
-  reason: z53.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable(),
-  cached: z53.boolean()
+  reason: z57.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable(),
+  cached: z57.boolean()
 });
 function retainsFactsExactly(record) {
   const hasFacts = record.facts !== void 0 && record.judgments !== void 0 && record.judgmentsDigest !== void 0;
   return record.schema === "felspar.hosted-supplied-execution/v3" === hasFacts;
 }
-var HostedSuppliedExecutionRecordSchema = z53.strictObject({
-  schema: z53.enum([
+var HostedCaseAttemptSchema = z57.strictObject({
+  executionId: id8,
+  added: z57.array(z57.string().min(1).max(draftSourceIdLimit + 4200)).max(192),
+  considered: z57.boolean()
+});
+var HostedCaseRecordSchema = z57.strictObject({
+  rule: z57.literal("whole-case"),
+  attempt: z57.number().int().min(1).max(hostedCaseRecordLimits.maxAttempts + 1),
+  attempts: z57.array(HostedCaseAttemptSchema).min(1).max(hostedCaseRecordLimits.maxAttempts + 1),
+  facts: questionsOf(HostedFactSchema).optional()
+});
+var HostedSuppliedExecutionRecordSchema = z57.strictObject({
+  schema: z57.enum([
     "felspar.hosted-supplied-execution/v1",
     "felspar.hosted-supplied-execution/v2",
     "felspar.hosted-supplied-execution/v3"
   ]),
-  release: z53.strictObject({ releaseId: id7, releaseDigest: digest23, materialDigest: digest23 }),
-  evaluationTime: z53.iso.datetime(),
+  release: z57.strictObject({ releaseId: id8, releaseDigest: digest24, materialDigest: digest24 }),
+  evaluationTime: z57.iso.datetime(),
   input: HostedSuppliedJobInputSchema,
   facts: HostedFactsJobInputSchema.optional(),
-  judgments: z53.array(HostedClassificationResultSchema).max(192).optional(),
-  judgmentsDigest: digest23.optional(),
-  expansion: z53.literal("agreeing-excerpts").optional(),
-  job: z53.record(z53.string(), z53.unknown())
-}).refine(retainsFactsExactly, "Version 3 records, and only they, retain facts with their judgments");
-var HostedObjectSchema = z53.strictObject({
-  id: id7,
-  kind: z53.enum(["source", "proposal", "approval", "release", "evidence", "result", "execution"]),
-  payloadDigest: digest23,
-  objectKey: z53.string().min(1).max(1e3),
-  parentId: id7.nullable(),
-  status: z53.enum(["active", "released", "revoked"]),
-  metadata: z53.record(z53.string(), z53.unknown())
-});
-var HostedJobResultSchema = z53.object({
-  status: z53.string(),
-  reason: z53.string().nullable(),
-  result: z53.object({
-    executionId: z53.string(),
-    releaseId: id7,
-    releaseDigest: digest23,
-    outcome: z53.string().nullable(),
-    scoring: z53.unknown(),
-    context: z53.unknown(),
-    receipt: z53.unknown()
+  judgments: z57.array(HostedClassificationResultSchema).max(192).optional(),
+  judgmentsDigest: digest24.optional(),
+  expansion: z57.literal("agreeing-excerpts").optional(),
+  caseRecord: HostedCaseRecordSchema.optional(),
+  job: z57.record(z57.string(), z57.unknown())
+}).refine(retainsFactsExactly, "Version 3 records, and only they, retain facts with their judgments").refine((record) => record.caseRecord === void 0 || record.facts !== void 0, {
+  message: "Only a facts record keeps a case record"
+});
+var HostedObjectSchema = z57.strictObject({
+  id: id8,
+  kind: z57.enum(["source", "proposal", "approval", "release", "evidence", "result", "execution"]),
+  payloadDigest: digest24,
+  objectKey: z57.string().min(1).max(1e3),
+  parentId: id8.nullable(),
+  status: z57.enum(["active", "released", "revoked"]),
+  metadata: z57.record(z57.string(), z57.unknown())
+});
+var HostedJobResultSchema = z57.object({
+  status: z57.string(),
+  reason: z57.string().nullable(),
+  result: z57.object({
+    executionId: z57.string(),
+    releaseId: id8,
+    releaseDigest: digest24,
+    outcome: z57.string().nullable(),
+    scoring: z57.unknown(),
+    context: z57.unknown(),
+    receipt: z57.unknown()
   }).loose().nullable()
 });
 
@@ -4730,6 +5469,12 @@ var formatFix = "The request does not match the facts request format at this pat
 var fixes = {
   observed_at_invalid: "Send observedAt as the date and time the source was read, with Z or an offset: for example 2026-10-21T10:00:00Z or 2026-10-21T12:00+02:00. A date alone, a time with no offset or words such as yesterday are not accepted.",
   source_id_invalid: `Send source.id as the source's own ID or address, such as a ticket number or a document URL with its query: at most ${draftSourceIdLimit} characters, starting with a letter or digit, using URL characters only (percent-encode spaces and non-ASCII characters).`,
+  source_id_required: "Send source.id: the source's own ID or address. For words a person gave you, mark the source manual: true instead and leave id out.",
+  observed_at_required: "Send source.observedAt: when the source was read, with Z or an offset. For words a person gave you, mark the source manual: true and Felspar stamps the time it received them.",
+  source_id_reserved: "Source IDs starting with felspar: are Felspar's own. Send the source's own ID, or mark words a person gave you manual: true with no id.",
+  manual_source_id: "A manual source takes no id or revision. Name the source the person gave in locator, such as the record or message it came from.",
+  supplied_by_needs_manual: "suppliedBy is only for words a person gave you: mark that source manual: true, or leave suppliedBy out.",
+  manual_facts_refused: "This job's pack refuses facts supplied by a person (its manualFacts setting). Quote the source record itself, with its source.id and observedAt, or leave the question out.",
   unknown_question: "This question is not in the released job. Use the question keys from describe.",
   source_class_not_accepted: "This question does not accept this source class. Send an excerpt from a source class the question's evidence policy in describe lists.",
   value_not_in_excerpt: "The quoted words do not state this value. Quote the exact words that state it, or send the text without a typed value.",
@@ -4784,6 +5529,8 @@ var fixes = {
   proposal_closed: "This proposal was released, rejected, withdrawn or replaced by a newer proposal, so nothing more can be done with it. Call list_jobs for the job's open proposals.",
   not_proposer: "Only the person who made a proposal may withdraw it; an approver may reject it.",
   not_job_approver: "Only this job's owner and named approvers, or a workspace owner, may approve, release or reject its proposals. details.owners names who may; ask one of them to review it on the Felspar web page.",
+  own_proposal: "The person who proposed a change can't approve it while another approver can. details.reason says why; ask one of the job's other approvers to review it on the Felspar web page.",
+  proposal_review_unavailable: "This proposal's review can't be read. Call list_jobs for the job's open proposals.",
   withdraw_on_web_page: "Withdraw a proposal on the Felspar web page, or propose the job again, which replaces your earlier proposal.",
   change_request_needs_release: "This job has no release yet, so there is no document version to propose changes on. Draft its first pack with check_pack and propose_pack.",
   change_request_quote_invalid: "Each change must quote a passage exactly as it is in the release's version of the document (read_source on the source list_jobs names), found exactly once, with changes that don't overlap and a replacement that differs. details.problems names each change by its index: quote_not_found, quote_not_unique (quote more of the passage), edits_overlap or edit_unchanged.",
@@ -4797,7 +5544,15 @@ var fixes = {
   change_request_close_on_web_page: "Withdraw or reject a change request on the Felspar web page; opening the job's change request again replaces your earlier one.",
   proposal_draft_invalid: "A proposal's draft must be a valid felspar.pack-draft for the proposal's own job. Propose with propose_pack, which keeps the draft it checked.",
   preview_too_large: "This draft changes more than one preview can show (2,048 item changes or 64 breaking changes). Preview a smaller revision, or split the pack.",
+  backtest_allowance_used: "This proposal has used its whole fresh-read allowance, which all its backtests share. Backtest it again without reinterpret: true: the answers already read are reused and nothing new is read.",
   preview_reinterpret_blocked: "Fix the draft's blocking findings (check_pack lists them) before previewing with reinterpret: true. A preview without reinterpret still runs.",
+  readings_blocked: "Fix the draft's blocking findings (check_pack lists them) before check_readings reads its wording.",
+  nothing_to_read: "Send phrasings in variants, or add readingTests to the draft: there is nothing to read.",
+  too_many_readings: `Read at most ${readingCheckLimits.maxPerCheck} phrasings per check_readings call, the draft's readingTests included. Split them across calls, or send include_tests: false.`,
+  too_many_per_answer: `Send at most ${readingCheckLimits.maxPerAnswer} phrasings per answer (and per question for phrasings with no expected answer), the draft's readingTests included.`,
+  duplicate_reading: "Two phrasings have the same id (a readingTests id counts too). Give each its own id, or leave id out.",
+  question_not_read: "check_readings reads only choice questions Felspar classifies from text: not number, date or derived questions. Use a choice question's key from the draft.",
+  answer_not_in_question: "expect must be one of that question's answer values in the draft.",
   pack_job_mismatch: "That release or proposal belongs to another job. Pass the jobId list_jobs shows with it.",
   decision_not_found: "Check the output against a decision this caller made: send the executionId from your get_job_decision result for this job.",
   decision_not_decided: "This decision has no outcome, so nothing is written for it. Follow its next step instead.",
@@ -4839,236 +5594,253 @@ function hostedRefusalRecovery(code) {
 }
 
 // ../schemas/src/draft-hosted-job-description.ts
-import { z as z55 } from "zod";
+import { z as z59 } from "zod";
 
 // ../schemas/src/draft-hosted-output-guides.ts
-import { z as z54 } from "zod";
-var id8 = z54.string().min(1).max(200);
-var located = z54.strictObject({
-  text: z54.string().min(1).max(262144),
-  locator: z54.string().min(1).max(4096)
+import { z as z58 } from "zod";
+var id9 = z58.string().min(1).max(200);
+var located = z58.strictObject({
+  text: z58.string().min(1).max(262144),
+  locator: z58.string().min(1).max(4096)
 });
 var hostedOutputGuideLimits = { maxOutputs: 8, maxContext: 8, maxChecks: 64 };
-var HostedOutputGuideSchema = z54.strictObject({
-  id: id8,
+var HostedOutputGuideSchema = z58.strictObject({
+  id: id9,
   what: located,
-  maxCharacters: z54.number().int().min(1),
-  context: z54.array(located.extend({ id: id8 })).max(hostedOutputGuideLimits.maxContext).optional(),
-  checks: z54.array(z54.strictObject({
-    check: id8,
-    rule: z54.string().nullable(),
-    must: z54.string().min(1).max(8e3)
+  maxCharacters: z58.number().int().min(1),
+  context: z58.array(located.extend({ id: id9 })).max(hostedOutputGuideLimits.maxContext).optional(),
+  checks: z58.array(z58.strictObject({
+    check: id9,
+    rule: z58.string().nullable(),
+    must: z58.string().min(1).max(8e3)
   })).max(hostedOutputGuideLimits.maxChecks)
 });
-var HostedOutputGuidesSchema = z54.array(HostedOutputGuideSchema).max(hostedOutputGuideLimits.maxOutputs);
+var HostedOutputGuidesSchema = z58.array(HostedOutputGuideSchema).max(hostedOutputGuideLimits.maxOutputs);
 
 // ../schemas/src/draft-hosted-job-description.ts
-var id9 = z55.string().min(1).max(200);
-var digest24 = DraftApplicationReleaseSchema.shape.releaseDigest;
+var id10 = z59.string().min(1).max(200);
+var digest25 = DraftApplicationReleaseSchema.shape.releaseDigest;
 var { requirements, rules } = DraftRequiredProposalSchema.shape;
-var quotedText = z55.strictObject({
-  text: z55.string().min(1).max(262144),
+var quotedText = z59.strictObject({
+  text: z59.string().min(1).max(262144),
   source: DraftSourceReferenceSchema.omit({ contentDigest: true }).extend({
-    locator: z55.string().min(1).max(4096),
-    contentDigest: digest24
+    locator: z59.string().min(1).max(4096),
+    contentDigest: digest25
   }),
-  parts: z55.array(z55.strictObject({ locator: z55.string().min(1).max(4096), text: z55.string() })).max(16)
+  parts: z59.array(z59.strictObject({ locator: z59.string().min(1).max(4096), text: z59.string() })).max(16)
 });
 var subjectShape = {
-  identifier: z55.string().min(1).max(200),
-  example: z55.string().min(1).max(200),
-  match: z55.enum(subjectMatchRules)
+  identifier: z59.string().min(1).max(200),
+  example: z59.string().min(1).max(200),
+  match: z59.enum(subjectMatchRules)
 };
-var HostedJobSubjectSchema = z55.strictObject({
-  type: id9,
+var HostedJobSubjectSchema = z59.strictObject({
+  type: id10,
   definition: quotedText,
   identifier: subjectShape.identifier.optional(),
   example: subjectShape.example.optional(),
   match: subjectShape.match,
-  related: z55.array(z55.strictObject({
-    relationship: id9,
+  related: z59.array(z59.strictObject({
+    relationship: id10,
     meaning: quotedText,
-    cardinality: z55.enum(relationshipCardinalities),
-    required: z55.boolean(),
-    subject: id9,
+    cardinality: z59.enum(relationshipCardinalities),
+    required: z59.boolean(),
+    subject: id10,
     definition: quotedText,
     ...subjectShape
   })).max(16),
-  send: z55.string().min(1).max(2e4)
+  send: z59.string().min(1).max(2e4)
 });
-var HostedJobEscalationsSchema = z55.strictObject({
-  routes: z55.array(z55.strictObject({ id: id9, quote: quotedText })).min(1).max(16),
-  unresolved: id9.nullable(),
-  attemptLimit: id9.nullable(),
-  rule: z55.string().min(1).max(1e3)
+var HostedJobEscalationsSchema = z59.strictObject({
+  routes: z59.array(z59.strictObject({ id: id10, quote: quotedText })).min(1).max(16),
+  unresolved: id10.nullable(),
+  attemptLimit: id10.nullable(),
+  rule: z59.string().min(1).max(1e3)
 });
-var HostedEscalationSchema = z55.strictObject({
-  id: id9,
-  trigger: z55.enum(escalationTriggers),
+var HostedEscalationSchema = z59.strictObject({
+  id: id10,
+  trigger: z59.enum(escalationTriggers),
   why: quotedText
 });
-var HostedJobDescriptionSchema = z55.strictObject({
-  schema: z55.literal("felspar.hosted-job-description.draft/v0"),
-  job: id9,
+var HostedJobDescriptionSchema = z59.strictObject({
+  schema: z59.literal("felspar.hosted-job-description.draft/v0"),
+  job: id10,
   purpose: quotedText.optional(),
-  useWhen: z55.array(quotedText).max(8).optional(),
-  notFor: z55.array(quotedText).max(8).optional(),
+  useWhen: z59.array(quotedText).max(8).optional(),
+  notFor: z59.array(quotedText).max(8).optional(),
   owner: quotedText.optional(),
   subject: HostedJobSubjectSchema.optional(),
-  identity: z55.strictObject({
-    mode: z55.enum(identityModes),
-    send: z55.string().min(1).max(4e3),
-    fields: z55.array(z55.strictObject({ name: id9, ...subjectShape })).max(8).optional(),
-    question: id9.optional()
+  identity: z59.strictObject({
+    mode: z59.enum(identityModes),
+    send: z59.string().min(1).max(4e3),
+    fields: z59.array(z59.strictObject({ name: id10, ...subjectShape })).max(8).optional(),
+    question: id10.optional()
   }).optional(),
-  trustDomain: id9,
-  release: z55.strictObject({
-    releaseId: id9,
-    releaseDigest: digest24,
-    materialDigest: digest24,
-    expectedAuthorityDigest: digest24
+  manualFacts: z59.strictObject({ allowed: z59.literal(false), quote: z59.string().min(1).max(4e3) }).optional(),
+  trustDomain: id10,
+  release: z59.strictObject({
+    releaseId: id10,
+    releaseDigest: digest25,
+    materialDigest: digest25,
+    expectedAuthorityDigest: digest25
   }),
   resolutionPolicy: DraftRequiredProposalSchema.shape.resolutionPolicy,
-  questions: z55.array(requirements.element.extend({
-    key: id9,
-    type: z55.enum(["enum", "boolean", "number", "date"]),
+  questions: z59.array(requirements.element.extend({
+    key: id10,
+    type: z59.enum(["enum", "boolean", "number", "date"]),
     meaning: quotedText,
-    answer: z55.strictObject({
-      send: z55.enum(["text", "text_or_value"]),
-      valueFormat: z55.enum(["number", "calendar-date"]).nullable(),
-      interpretation: z55.enum(["classified", "exact_read", "unsupported"]),
-      threshold: z55.number().gt(0).max(1).nullable(),
-      applies: z55.enum(["always", "conditional"]),
-      dependsOn: z55.array(id9).max(32),
-      appliesWhen: z55.string().min(1).max(2e3).nullable(),
+    answer: z59.strictObject({
+      send: z59.enum(["text", "text_or_value"]),
+      valueFormat: z59.enum(["number", "calendar-date"]).nullable(),
+      interpretation: z59.enum(["classified", "exact_read", "unsupported"]),
+      threshold: z59.number().gt(0).max(1).nullable(),
+      applies: z59.enum(["always", "conditional"]),
+      dependsOn: z59.array(id10).max(32),
+      appliesWhen: z59.string().min(1).max(2e3).nullable(),
       reading: ExactReaderSchema.optional()
     }),
-    answers: z55.array(z55.strictObject({
-      value: id9,
-      meaning: z55.string().nullable(),
-      inclusions: z55.array(z55.string()).max(8),
-      exclusions: z55.array(z55.string()).max(8),
-      examples: z55.array(z55.string()).max(8),
-      edgeCases: z55.array(z55.string()).max(8)
+    answers: z59.array(z59.strictObject({
+      value: id10,
+      meaning: z59.string().nullable(),
+      inclusions: z59.array(z59.string()).max(8),
+      exclusions: z59.array(z59.string()).max(8),
+      examples: z59.array(z59.string()).max(8),
+      edgeCases: z59.array(z59.string()).max(8)
     })).max(64).optional(),
-    whereToLook: z55.array(quotedText).max(8).optional(),
-    about: z55.strictObject({ relationship: id9, subject: id9 }).optional()
+    whereToLook: z59.array(quotedText).max(8).optional(),
+    about: z59.strictObject({ relationship: id10, subject: id10 }).optional()
   })).max(64),
-  rules: z55.array(rules.element.extend({ text: quotedText })).max(256),
-  outcomes: z55.array(z55.strictObject({
-    id: id9,
+  rules: z59.array(rules.element.extend({ text: quotedText })).max(256),
+  outcomes: z59.array(z59.strictObject({
+    id: id10,
     meaning: quotedText.nullable(),
     nextStep: quotedText.nullable().optional(),
     outputs: HostedOutputGuidesSchema.optional(),
-    escalate: id9.optional()
+    escalate: id10.optional()
   })).max(64),
   escalations: HostedJobEscalationsSchema.optional(),
   whenUnresolved: quotedText.nullable().optional(),
-  attempts: z55.strictObject({
-    max: z55.number().int().min(1).max(10),
-    withProgress: z55.number().int().min(1).max(10),
-    rule: z55.string().min(1).max(1e3)
+  attempts: z59.strictObject({
+    max: z59.number().int().min(1).max(10),
+    withProgress: z59.number().int().min(1).max(10),
+    rule: z59.string().min(1).max(1e3)
   }).optional(),
-  guidance: z55.strictObject({ gather: z55.string().min(1).max(2e3) }),
-  input: z55.strictObject({
-    jsonSchema: z55.record(z55.string(), z55.unknown()),
+  guidance: z59.strictObject({ gather: z59.string().min(1).max(2e3) }),
+  input: z59.strictObject({
+    jsonSchema: z59.record(z59.string(), z59.unknown()),
     example: HostedFactsJobInputSchema.nullable(),
-    exampleNote: z55.string().max(1e3)
+    exampleNote: z59.string().max(1e3)
   }),
-  limits: z55.strictObject({
-    maxEvidenceItems: z55.number().int().positive(),
-    maxPassages: z55.number().int().positive(),
-    facts: z55.strictObject({
-      maxExcerptCharacters: z55.literal(hostedFactsLimits.maxExcerptCharacters),
-      maxExcerptsPerQuestion: z55.literal(hostedFactsLimits.maxExcerptsPerQuestion),
-      maxFactsBytes: z55.literal(hostedFactsLimits.maxFactsBytes),
-      maxQuestions: z55.literal(hostedFactsLimits.maxQuestions)
+  limits: z59.strictObject({
+    maxEvidenceItems: z59.number().int().positive(),
+    maxPassages: z59.number().int().positive(),
+    facts: z59.strictObject({
+      maxExcerptCharacters: z59.literal(hostedFactsLimits.maxExcerptCharacters),
+      maxExcerptsPerQuestion: z59.literal(hostedFactsLimits.maxExcerptsPerQuestion),
+      maxFactsBytes: z59.literal(hostedFactsLimits.maxFactsBytes),
+      maxQuestions: z59.literal(hostedFactsLimits.maxQuestions)
     })
   })
 });
-var interpretedExcerpt = z55.strictObject({
-  id: id9,
-  method: z55.enum(["value", "exact_read", "classified"]),
-  status: z55.enum(["accepted", "needs_evidence", "not_needed"]),
-  value: z55.union([z55.string(), z55.number(), z55.boolean()]).optional(),
-  reasons: z55.array(z55.string()),
-  classification: z55.strictObject({
-    candidate: z55.string().nullable(),
-    probability: z55.number().min(0).max(1).nullable(),
-    abstention: z55.number().min(0).max(1).nullable(),
-    threshold: z55.number().min(0).max(1),
-    alternatives: z55.array(z55.strictObject({ value: z55.string(), probability: z55.number() }))
+var interpretedExcerpt = z59.strictObject({
+  id: id10,
+  method: z59.enum(["value", "exact_read", "classified"]),
+  status: z59.enum(["accepted", "needs_evidence", "not_needed"]),
+  value: z59.union([z59.string(), z59.number(), z59.boolean()]).optional(),
+  reasons: z59.array(z59.string()),
+  classification: z59.strictObject({
+    candidate: z59.string().nullable(),
+    probability: z59.number().min(0).max(1).nullable(),
+    abstention: z59.number().min(0).max(1).nullable(),
+    threshold: z59.number().min(0).max(1),
+    alternatives: z59.array(z59.strictObject({ value: z59.string(), probability: z59.number() }))
   }).optional()
 });
-var ruleSummary = z55.strictObject({ id: id9, outcome: id9, text: quotedText });
-var HostedJobExplanationSchema = z55.strictObject({
-  schema: z55.literal("felspar.hosted-job-explanation.draft/v0"),
-  decision: z55.strictObject({ status: z55.string().nullable(), reasons: z55.array(z55.string()) }),
-  needs: z55.array(z55.strictObject({
-    key: id9,
-    status: z55.string(),
-    reasons: z55.array(z55.string()),
-    acceptedSourceClasses: z55.array(z55.string()),
-    maxAgeMs: z55.number().int().nonnegative(),
+var ruleSummary = z59.strictObject({ id: id10, outcome: id10, text: quotedText });
+var HostedJobExplanationSchema = z59.strictObject({
+  schema: z59.literal("felspar.hosted-job-explanation.draft/v0"),
+  decision: z59.strictObject({ status: z59.string().nullable(), reasons: z59.array(z59.string()) }),
+  needs: z59.array(z59.strictObject({
+    key: id10,
+    status: z59.string(),
+    reasons: z59.array(z59.string()),
+    acceptedSourceClasses: z59.array(z59.string()),
+    maxAgeMs: z59.number().int().nonnegative(),
     requiredWhen: HostedJobDescriptionSchema.shape.questions.element.shape.requiredWhen,
-    excerpts: z55.array(interpretedExcerpt).optional()
+    excerpts: z59.array(interpretedExcerpt).optional()
   })),
-  why: z55.strictObject({
-    rules: z55.array(ruleSummary),
-    overrides: z55.array(z55.strictObject({ by: id9, target: id9 })),
-    suppressedRuleIds: z55.array(id9),
-    evidence: z55.array(z55.record(z55.string(), z55.unknown()))
+  why: z59.strictObject({
+    rules: z59.array(ruleSummary),
+    overrides: z59.array(z59.strictObject({ by: id10, target: id10 })),
+    suppressedRuleIds: z59.array(id10),
+    evidence: z59.array(z59.record(z59.string(), z59.unknown()))
   }).nullable(),
-  context: z55.strictObject({ status: z55.string(), reason: z55.string().nullable() }).nullable(),
-  reviewNeeds: z55.array(z55.string()),
-  evidenceFreshUntil: z55.iso.datetime().nullable()
+  context: z59.strictObject({ status: z59.string(), reason: z59.string().nullable() }).nullable(),
+  reviewNeeds: z59.array(z59.string()),
+  evidenceFreshUntil: z59.iso.datetime().nullable()
 });
-var HostedReceiptVerificationInputSchema = z55.strictObject({
+var HostedReceiptVerificationInputSchema = z59.strictObject({
   receipt: DraftJobReceiptSchema,
-  expectedReceiptDigest: digest24,
+  expectedReceiptDigest: digest25,
   deliveredCapsule: DraftContextVerificationOptionsSchema.shape.deliveredCapsule
 });
-var HostedReceiptVerificationSchema = z55.strictObject({
-  authority: z55.literal("unapproved"),
-  status: z55.enum(["reproduced", "mismatch"]),
-  mismatches: z55.array(z55.string()),
-  decided: z55.strictObject({
-    jobId: id9,
-    entityId: id9,
-    releaseId: id9,
-    outcome: id9.nullable(),
-    case: z55.strictObject({ id: id9, mode: z55.enum(identityModes) }).optional(),
-    subject: z55.strictObject({
-      type: id9,
-      related: z55.array(z55.strictObject({ relationship: id9, subject: id9, id: id9, questions: z55.array(id9).max(64) })).max(256)
+var HostedReceiptVerificationSchema = z59.strictObject({
+  authority: z59.literal("unapproved"),
+  status: z59.enum(["reproduced", "mismatch"]),
+  mismatches: z59.array(z59.string()),
+  decided: z59.strictObject({
+    jobId: id10,
+    entityId: id10,
+    releaseId: id10,
+    outcome: id10.nullable(),
+    case: z59.strictObject({ id: id10, mode: z59.enum(identityModes) }).optional(),
+    subject: z59.strictObject({
+      type: id10,
+      related: z59.array(z59.strictObject({ relationship: id10, subject: id10, id: id10, questions: z59.array(id10).max(64) })).max(256)
     }).optional(),
-    escalation: HostedEscalationSchema.omit({ why: true }).optional()
+    escalation: HostedEscalationSchema.omit({ why: true }).optional(),
+    manualFacts: z59.array(z59.strictObject({
+      question: id10,
+      excerpt: z59.number().int().min(0).max(hostedCaseRecordLimits.maxExcerptsPerQuestion - 1),
+      via: z59.strictObject({
+        principal: id10,
+        agent: z59.strictObject({ name: z59.string(), accountable: id10 }).nullable()
+      }),
+      observedAt: z59.string(),
+      stampedByFelspar: z59.boolean(),
+      suppliedBy: z59.strictObject({ text: z59.string(), verified: z59.literal(false) }).optional()
+    })).max(192).optional(),
+    caseRecord: z59.strictObject({
+      rule: z59.literal("whole-case"),
+      attempt: z59.number().int().min(1),
+      attempts: z59.array(HostedCaseAttemptSchema).max(hostedCaseRecordLimits.maxAttempts + 1)
+    }).optional()
   }).optional()
 });
 
 // ../schemas/src/draft-hosted-output-check-record.ts
-import { z as z58 } from "zod";
+import { z as z62 } from "zod";
 
 // ../schemas/src/draft-artifact-lint.ts
-import { z as z57 } from "zod";
+import { z as z61 } from "zod";
 
 // ../schemas/src/draft-job-obligations.ts
-import { z as z56 } from "zod";
-var id10 = DraftApplicationScopeSchema.shape.authorityId;
-var digest25 = DraftJobReceiptSchema.shape.receiptDigest;
+import { z as z60 } from "zod";
+var id11 = DraftApplicationScopeSchema.shape.authorityId;
+var digest26 = DraftJobReceiptSchema.shape.receiptDigest;
 var outcome2 = DraftJobObligationsOutcomeSchema;
 var DraftApplicationJobMaterialV3Schema = DraftApplicationJobMaterialV2Schema.extend({
-  schema: z56.literal("felspar.application-job-material.draft/v3"),
+  schema: z60.literal("felspar.application-job-material.draft/v3"),
   obligations: DraftJobObligationsSchema
-}).superRefine((value, context3) => {
+}).superRefine((value2, context3) => {
   if (context3.issues.length > 0) {
     return;
   }
-  const { obligations, discovery } = value;
-  const { proposal } = value.input.invocation.authority.catalog;
+  const { obligations, discovery } = value2;
+  const { proposal } = value2.input.invocation.authority.catalog;
   const isSourceMatches = Object.entries(proposal.source).every(([key3, expected2]) => Reflect.get(obligations.source, key3) === expected2);
-  const outcomes = new Set(obligations.outcomes.map((entry2) => entry2.outcomeId));
-  const isComplete = outcomes.size === proposal.allowedOutcomes.length && proposal.allowedOutcomes.every((entry2) => outcomes.has(entry2));
+  const outcomes = new Set(obligations.outcomes.map((entry3) => entry3.outcomeId));
+  const isComplete = outcomes.size === proposal.allowedOutcomes.length && proposal.allowedOutcomes.every((entry3) => outcomes.has(entry3));
   const matches = [
     isSourceMatches,
     isComplete,
@@ -5086,57 +5858,57 @@ var DraftApplicationJobMaterialV3Schema = DraftApplicationJobMaterialV2Schema.ex
   }
 });
 var HostedProposalInputV3Schema = HostedProposalInputV2Schema.extend({
-  schema: z56.literal("felspar.hosted-proposal.draft/v3"),
+  schema: z60.literal("felspar.hosted-proposal.draft/v3"),
   material: DraftApplicationJobMaterialV3Schema
 });
 var jobObligationsReplayRoutes = ["supplied", "evaluated"];
 var replayRoutes = new Set(jobObligationsReplayRoutes);
 var DraftJobObligationsExecutionSchema = DraftAnyJobExecutionSchema.refine((execution) => replayRoutes.has(execution.invocation.route), "Obligations assessments support supplied and evaluated native executions");
-var DraftJobObligationsNativeResultSchema = z56.strictObject({
-  authority: z56.literal("unapproved"),
-  discovery: z56.record(z56.string(), z56.unknown()),
-  executed: z56.record(z56.string(), z56.unknown()),
+var DraftJobObligationsNativeResultSchema = z60.strictObject({
+  authority: z60.literal("unapproved"),
+  discovery: z60.record(z60.string(), z60.unknown()),
+  executed: z60.record(z60.string(), z60.unknown()),
   receipt: DraftJobReceiptSchema
 });
-var DraftJobObligationsInputSchema = z56.strictObject({
+var DraftJobObligationsInputSchema = z60.strictObject({
   release: DraftApplicationReleaseSchema,
-  material: z56.union([DraftApplicationJobMaterialV3Schema, DraftAnyApplicationJobMaterialSchema]),
+  material: z60.union([DraftApplicationJobMaterialV3Schema, DraftAnyApplicationJobMaterialSchema]),
   execution: DraftJobObligationsExecutionSchema,
-  expectedReceiptDigest: digest25,
+  expectedReceiptDigest: digest26,
   job: DraftJobObligationsNativeResultSchema,
   explanation: HostedJobExplanationSchema,
-  invocation: DraftJobObligationsScopeSchema.extend({ caseId: id10 })
+  invocation: DraftJobObligationsScopeSchema.extend({ caseId: id11 })
 });
-var requirements2 = z56.strictObject({
-  status: z56.enum(["established", "unresolved"]),
+var requirements2 = z60.strictObject({
+  status: z60.enum(["established", "unresolved"]),
   scope: DraftJobObligationsScopeSchema,
   artifacts: outcome2.shape.artifacts,
   approvals: outcome2.shape.approvals,
-  unresolved: z56.array(z56.strictObject({ scopeRef: id10, reasonCodes: z56.array(id10).min(1).max(64) })).max(64)
+  unresolved: z60.array(z60.strictObject({ scopeRef: id11, reasonCodes: z60.array(id11).min(1).max(64) })).max(64)
 });
-var nextReference = z56.discriminatedUnion("kind", [
-  z56.strictObject({ kind: z56.literal("evidence_need"), id: id10 }),
-  z56.strictObject({ kind: z56.literal("artifact_requirement"), id: id10 }),
-  z56.strictObject({ kind: z56.literal("approval_requirement"), id: id10 }),
-  z56.strictObject({ kind: z56.literal("unresolved_scope"), scopeRef: id10 })
+var nextReference = z60.discriminatedUnion("kind", [
+  z60.strictObject({ kind: z60.literal("evidence_need"), id: id11 }),
+  z60.strictObject({ kind: z60.literal("artifact_requirement"), id: id11 }),
+  z60.strictObject({ kind: z60.literal("approval_requirement"), id: id11 }),
+  z60.strictObject({ kind: z60.literal("unresolved_scope"), scopeRef: id11 })
 ]);
-var DraftJobObligationsAssessmentBodySchema = z56.strictObject({
-  schema: z56.literal("felspar.job-obligations-assessment.draft/v0"),
-  binding: z56.strictObject({
-    releaseDigest: digest25,
-    materialDigest: digest25,
-    nativeReceiptDigest: digest25,
-    jobId: id10,
+var DraftJobObligationsAssessmentBodySchema = z60.strictObject({
+  schema: z60.literal("felspar.job-obligations-assessment.draft/v0"),
+  binding: z60.strictObject({
+    releaseDigest: digest26,
+    materialDigest: digest26,
+    nativeReceiptDigest: digest26,
+    jobId: id11,
     applicationScope: DraftApplicationScopeSchema,
-    caseId: id10,
-    entityId: id10,
-    evaluationTime: z56.iso.datetime({ offset: true }),
-    purposeRef: id10,
-    useRef: id10.nullable()
+    caseId: id11,
+    entityId: id11,
+    evaluationTime: z60.iso.datetime({ offset: true }),
+    purposeRef: id11,
+    useRef: id11.nullable()
   }),
   requirements: requirements2,
-  next: z56.strictObject({
-    kind: z56.enum([
+  next: z60.strictObject({
+    kind: z60.enum([
       "stop",
       "review_required",
       "gather_evidence",
@@ -5144,20 +5916,20 @@ var DraftJobObligationsAssessmentBodySchema = z56.strictObject({
       "verify_before_action",
       "return_result"
     ]),
-    reasonCodes: z56.array(id10).max(64),
-    refs: z56.array(nextReference).max(64)
+    reasonCodes: z60.array(id11).max(64),
+    refs: z60.array(nextReference).max(64)
   })
 });
 function isNextRefDeclared(ref, required) {
   switch (ref.kind) {
     case "artifact_requirement": {
-      return required.artifacts.some((entry2) => entry2.id === ref.id);
+      return required.artifacts.some((entry3) => entry3.id === ref.id);
     }
     case "approval_requirement": {
-      return required.approvals.some((entry2) => entry2.id === ref.id);
+      return required.approvals.some((entry3) => entry3.id === ref.id);
     }
     case "unresolved_scope": {
-      return required.unresolved.some((entry2) => entry2.scopeRef === ref.scopeRef);
+      return required.unresolved.some((entry3) => entry3.scopeRef === ref.scopeRef);
     }
     case "evidence_need": {
       return true;
@@ -5168,13 +5940,13 @@ function isNextRefDeclared(ref, required) {
   }
 }
 var DraftJobObligationsAssessmentSchema = DraftJobObligationsAssessmentBodySchema.extend({
-  assessmentDigest: digest25
-}).superRefine((value, context3) => {
-  const { requirements: required } = value;
+  assessmentDigest: digest26
+}).superRefine((value2, context3) => {
+  const { requirements: required } = value2;
   if (required.status === "established" !== (required.unresolved.length === 0) || required.status === "unresolved" && (required.artifacts.length > 0 || required.approvals.length > 0)) {
     context3.addIssue({ code: "custom", message: "Requirements completeness differs" });
   }
-  for (const ref of value.next.refs) {
+  for (const ref of value2.next.refs) {
     if (!isNextRefDeclared(ref, required)) {
       context3.addIssue({ code: "custom", message: "Dangling next reference" });
     }
@@ -5182,48 +5954,48 @@ var DraftJobObligationsAssessmentSchema = DraftJobObligationsAssessmentBodySchem
 });
 
 // ../schemas/src/draft-artifact-lint.ts
-var id11 = DraftApplicationScopeSchema.shape.authorityId;
-var digest26 = DraftJobReceiptSchema.shape.receiptDigest;
+var id12 = DraftApplicationScopeSchema.shape.authorityId;
+var digest27 = DraftJobReceiptSchema.shape.receiptDigest;
 var passage3 = ArtifactSpecificationSchema;
-var plainArtifact = z57.strictObject({
-  id: id11,
-  revision: id11,
-  mediaType: z57.literal("text/plain"),
-  exportProfile: id11.nullable(),
-  content: z57.string().max(artifactLintLimits.maxTotalBytes),
-  expectedContentDigest: digest26
-});
-var structuredArtifact = z57.strictObject({
-  id: id11,
-  revision: id11,
-  mediaType: z57.literal("application/vnd.felspar.structured-output+json"),
-  exportProfile: id11.nullable(),
+var plainArtifact = z61.strictObject({
+  id: id12,
+  revision: id12,
+  mediaType: z61.literal("text/plain"),
+  exportProfile: id12.nullable(),
+  content: z61.string().max(artifactLintLimits.maxTotalBytes),
+  expectedContentDigest: digest27
+});
+var structuredArtifact = z61.strictObject({
+  id: id12,
+  revision: id12,
+  mediaType: z61.literal("application/vnd.felspar.structured-output+json"),
+  exportProfile: id12.nullable(),
   content: DraftStructuredOutputSchema,
-  expectedContentDigest: digest26
+  expectedContentDigest: digest27
 });
-var ArtifactLintArtifactSchema = z57.discriminatedUnion("mediaType", [
+var ArtifactLintArtifactSchema = z61.discriminatedUnion("mediaType", [
   plainArtifact,
   structuredArtifact
 ]);
-var ArtifactLintDecisionSchema = z57.strictObject({
+var ArtifactLintDecisionSchema = z61.strictObject({
   inputs: DraftJobObligationsInputSchema,
   assessment: DraftJobObligationsAssessmentSchema,
-  expectedAssessmentDigest: digest26
+  expectedAssessmentDigest: digest27
 });
-var ArtifactLintInputSchema = z57.strictObject({
-  schema: z57.literal("felspar.lint.draft/v1"),
-  requestId: id11,
+var ArtifactLintInputSchema = z61.strictObject({
+  schema: z61.literal("felspar.lint.draft/v1"),
+  requestId: id12,
   release: DraftApplicationReleaseSchema,
   material: DraftApplicationJobMaterialV3Schema,
   manifest: ArtifactCheckManifestSchema,
-  expectedManifestDigest: digest26,
-  attachedObligations: z57.strictObject({ expectedObligationsDigest: digest26 }).optional(),
-  attachedCase: z57.strictObject({
-    decisionReceiptDigest: digest26,
-    answers: z57.array(z57.strictObject({ key: id11, value: z57.union([z57.string().min(1).max(200), z57.null()]) })).max(256)
+  expectedManifestDigest: digest27,
+  attachedObligations: z61.strictObject({ expectedObligationsDigest: digest27 }).optional(),
+  attachedCase: z61.strictObject({
+    decisionReceiptDigest: digest27,
+    answers: z61.array(z61.strictObject({ key: id12, value: z61.union([z61.string().min(1).max(200), z61.null()]) })).max(256)
   }).optional(),
-  case: z57.strictObject({ caseId: id11, purposeRef: id11, useRef: id11.nullable() }),
-  artifactRequirementId: id11.nullable(),
+  case: z61.strictObject({ caseId: id12, purposeRef: id12, useRef: id12.nullable() }),
+  artifactRequirementId: id12.nullable(),
   decision: ArtifactLintDecisionSchema.nullable(),
   artifact: ArtifactLintArtifactSchema
 });
@@ -5236,11 +6008,11 @@ var artifactCheckStatuses = [
   "not_applicable",
   "skipped"
 ];
-var range = z57.strictObject({
-  sectionId: id11,
-  start: z57.number().int().min(0).max(artifactLintLimits.maxSectionUnits),
-  end: z57.number().int().min(1).max(artifactLintLimits.maxSectionUnits),
-  offsetUnit: z57.literal("utf16_code_units")
+var range = z61.strictObject({
+  sectionId: id12,
+  start: z61.number().int().min(0).max(artifactLintLimits.maxSectionUnits),
+  end: z61.number().int().min(1).max(artifactLintLimits.maxSectionUnits),
+  offsetUnit: z61.literal("utf16_code_units")
 });
 var findingCodes = [
   "section_missing",
@@ -5261,6 +6033,7 @@ var findingCodes = [
   "semantic_violation",
   "semantic_missing",
   "semantic_unresolved",
+  "possible_prompt_injection",
   "case_answer_conflict",
   "case_answer_missing",
   "case_answer_unconfirmed",
@@ -5268,148 +6041,148 @@ var findingCodes = [
   "evaluation_budget_exceeded",
   "evaluation_skipped"
 ];
-var ArtifactFindingSchema = z57.strictObject({
-  code: z57.enum(findingCodes),
-  checkId: id11.nullable(),
-  severity: z57.enum(["error", "warning"]),
+var ArtifactFindingSchema = z61.strictObject({
+  code: z61.enum(findingCodes),
+  checkId: id12.nullable(),
+  severity: z61.enum(["error", "warning"]),
   specification: passage3.nullable(),
   location: range.nullable(),
-  insertionAnchor: z57.strictObject({ sectionId: id11.nullable(), at: z57.number().int().min(0) }).nullable(),
-  literalIndex: z57.number().int().min(0).max(artifactLintLimits.maxLiterals).nullable()
-});
-var ArtifactCheckObservationSchema = z57.strictObject({
-  checkId: id11,
-  kind: z57.enum(artifactCheckKinds),
-  required: z57.boolean(),
-  method: z57.enum(["deterministic", "semantic"]),
-  status: z57.enum(artifactCheckStatuses),
-  occurrences: z57.number().int().min(0),
-  parsedValue: z57.number().nullable(),
-  caseValue: z57.number().nullable()
-});
-var ArtifactLintRecordBodySchema = z57.strictObject({
-  schema: z57.literal("felspar.lint-record.draft/v1"),
-  requestId: id11,
-  status: z57.enum(["pass", "revise", "unavailable", "review_required"]),
-  caseContext: z57.enum(["bound", "not_required"]),
-  binding: z57.strictObject({
+  insertionAnchor: z61.strictObject({ sectionId: id12.nullable(), at: z61.number().int().min(0) }).nullable(),
+  literalIndex: z61.number().int().min(0).max(artifactLintLimits.maxLiterals).nullable()
+});
+var ArtifactCheckObservationSchema = z61.strictObject({
+  checkId: id12,
+  kind: z61.enum(artifactCheckKinds),
+  required: z61.boolean(),
+  method: z61.enum(["deterministic", "semantic"]),
+  status: z61.enum(artifactCheckStatuses),
+  occurrences: z61.number().int().min(0),
+  parsedValue: z61.number().nullable(),
+  caseValue: z61.number().nullable()
+});
+var ArtifactLintRecordBodySchema = z61.strictObject({
+  schema: z61.literal("felspar.lint-record.draft/v1"),
+  requestId: id12,
+  status: z61.enum(["pass", "revise", "unavailable", "review_required"]),
+  caseContext: z61.enum(["bound", "not_required"]),
+  binding: z61.strictObject({
     scope: DraftApplicationScopeSchema,
-    releaseId: id11,
-    releaseDigest: digest26,
-    materialDigest: digest26,
-    obligationsDigest: digest26.optional(),
-    caseFactsDigest: digest26.optional(),
-    jobId: id11,
-    manifestId: id11,
-    manifestDigest: digest26,
-    contract: z57.strictObject({ id: id11, digest: digest26 }),
-    caseId: id11,
-    purposeRef: id11,
-    useRef: id11.nullable(),
-    artifactRequirementId: id11.nullable(),
-    decisionReceiptDigest: digest26.nullable(),
-    obligationsAssessmentDigest: digest26.nullable()
+    releaseId: id12,
+    releaseDigest: digest27,
+    materialDigest: digest27,
+    obligationsDigest: digest27.optional(),
+    caseFactsDigest: digest27.optional(),
+    jobId: id12,
+    manifestId: id12,
+    manifestDigest: digest27,
+    contract: z61.strictObject({ id: id12, digest: digest27 }),
+    caseId: id12,
+    purposeRef: id12,
+    useRef: id12.nullable(),
+    artifactRequirementId: id12.nullable(),
+    decisionReceiptDigest: digest27.nullable(),
+    obligationsAssessmentDigest: digest27.nullable()
   }),
-  artifact: z57.strictObject({
-    id: id11,
-    revision: id11,
-    mediaType: z57.enum(artifactLintMediaTypes),
-    exportProfile: id11.nullable(),
-    contentDigest: digest26,
-    sections: z57.array(z57.strictObject({
-      id: id11,
-      units: z57.number().int().min(0),
-      contentDigest: digest26.nullable()
+  artifact: z61.strictObject({
+    id: id12,
+    revision: id12,
+    mediaType: z61.enum(artifactLintMediaTypes),
+    exportProfile: id12.nullable(),
+    contentDigest: digest27,
+    sections: z61.array(z61.strictObject({
+      id: id12,
+      units: z61.number().int().min(0),
+      contentDigest: digest27.nullable()
     })).max(artifactLintLimits.maxSections)
   }),
-  checks: z57.array(ArtifactCheckObservationSchema).max(artifactLintLimits.maxChecks),
-  findings: z57.array(ArtifactFindingSchema).max(2048),
+  checks: z61.array(ArtifactCheckObservationSchema).max(artifactLintLimits.maxChecks),
+  findings: z61.array(ArtifactFindingSchema).max(2048),
   semantic: ArtifactSemanticRecordSchema.nullable(),
-  coverage: z57.strictObject({
-    scope: z57.literal("declared_checks_only"),
-    declared: z57.number().int().min(0),
-    applicable: z57.number().int().min(0),
-    completed: z57.number().int().min(0),
-    required: z57.number().int().min(0),
-    requiredCompleted: z57.number().int().min(0),
-    textAssigned: z57.enum(["complete", "incomplete"]),
-    semantic: z57.enum(["not_declared", "complete", "incomplete"]),
-    nativeDocumentLayout: z57.literal("not_checked")
+  coverage: z61.strictObject({
+    scope: z61.literal("declared_checks_only"),
+    declared: z61.number().int().min(0),
+    applicable: z61.number().int().min(0),
+    completed: z61.number().int().min(0),
+    required: z61.number().int().min(0),
+    requiredCompleted: z61.number().int().min(0),
+    textAssigned: z61.enum(["complete", "incomplete"]),
+    semantic: z61.enum(["not_declared", "complete", "incomplete"]),
+    nativeDocumentLayout: z61.literal("not_checked")
   }),
-  actionAuthorized: z57.literal(false)
+  actionAuthorized: z61.literal(false)
 });
 var ArtifactLintRecordSchema = ArtifactLintRecordBodySchema.extend({
-  recordDigest: digest26
-});
-var ArtifactLintReceiptSchema = z57.strictObject({
-  schema: z57.literal("felspar.lint-receipt.draft/v1"),
-  recordDigest: digest26,
-  releaseDigest: digest26,
-  manifestDigest: digest26,
-  contractDigest: digest26,
-  caseId: id11,
-  caseContext: z57.enum(["bound", "not_required"]),
-  decisionReceiptDigest: digest26.nullable(),
-  obligationsAssessmentDigest: digest26.nullable(),
-  artifactId: id11,
-  artifactRevision: id11,
-  artifactDigest: digest26,
-  actionAuthorized: z57.literal(false),
-  receiptDigest: digest26
+  recordDigest: digest27
+});
+var ArtifactLintReceiptSchema = z61.strictObject({
+  schema: z61.literal("felspar.lint-receipt.draft/v1"),
+  recordDigest: digest27,
+  releaseDigest: digest27,
+  manifestDigest: digest27,
+  contractDigest: digest27,
+  caseId: id12,
+  caseContext: z61.enum(["bound", "not_required"]),
+  decisionReceiptDigest: digest27.nullable(),
+  obligationsAssessmentDigest: digest27.nullable(),
+  artifactId: id12,
+  artifactRevision: id12,
+  artifactDigest: digest27,
+  actionAuthorized: z61.literal(false),
+  receiptDigest: digest27
 });
 
 // ../schemas/src/draft-hosted-output-check-record.ts
-var id12 = DraftApplicationScopeSchema.shape.authorityId;
-var digest27 = DraftJobReceiptSchema.shape.receiptDigest;
-var HostedOutputCheckInputSchema = z58.strictObject({
-  executionId: id12,
-  output: id12.optional(),
-  text: z58.string().min(1).max(artifactLintLimits.maxTotalBytes).refine(isWellFormedText, "text_not_well_formed"),
-  revision: id12.optional()
-});
-var HostedOutputCheckRecordSchema = z58.strictObject({
-  schema: z58.literal("felspar.hosted-output-check/v0"),
-  checkId: id12,
-  jobId: id12,
-  output: id12,
-  decision: z58.strictObject({ executionId: id12, outcome: id12, receiptDigest: digest27 }),
-  release: z58.strictObject({ releaseId: id12, releaseDigest: digest27 }),
+var id13 = DraftApplicationScopeSchema.shape.authorityId;
+var digest28 = DraftJobReceiptSchema.shape.receiptDigest;
+var HostedOutputCheckInputSchema = z62.strictObject({
+  executionId: id13,
+  output: id13.optional(),
+  text: z62.string().min(1).max(artifactLintLimits.maxTotalBytes).refine(isWellFormedText, "text_not_well_formed"),
+  revision: id13.optional()
+});
+var HostedOutputCheckRecordSchema = z62.strictObject({
+  schema: z62.literal("felspar.hosted-output-check/v0"),
+  checkId: id13,
+  jobId: id13,
+  output: id13,
+  decision: z62.strictObject({ executionId: id13, outcome: id13, receiptDigest: digest28 }),
+  release: z62.strictObject({ releaseId: id13, releaseDigest: digest28 }),
   record: ArtifactLintRecordSchema,
   receipt: ArtifactLintReceiptSchema.nullable(),
-  evaluation: z58.strictObject({
-    modelCalls: z58.number().int().min(0),
-    reason: z58.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable()
+  evaluation: z62.strictObject({
+    modelCalls: z62.number().int().min(0),
+    reason: z62.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable()
   })
 });
 
 // src/draft-hosted-client.ts
-import { z as z59 } from "zod";
-var digestText = z59.string().regex(/^sha256:[a-f0-9]{64}$/u);
-var HostedOutputCheckReplySchema = z59.object({
-  status: z59.enum(["pass", "revise", "review_required", "unavailable"]),
-  checkId: z59.string(),
-  output: z59.string(),
-  findings: z59.array(z59.record(z59.string(), z59.unknown())),
-  receipt: z59.object({ receiptDigest: digestText, artifactDigest: digestText }).loose().nullable(),
-  decision: z59.object({ executionId: z59.string(), receiptDigest: digestText }),
-  actionAuthorized: z59.literal(false)
+import { z as z63 } from "zod";
+var digestText = z63.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var HostedOutputCheckReplySchema = z63.object({
+  status: z63.enum(["pass", "revise", "review_required", "unavailable"]),
+  checkId: z63.string(),
+  output: z63.string(),
+  findings: z63.array(z63.record(z63.string(), z63.unknown())),
+  receipt: z63.object({ receiptDigest: digestText, artifactDigest: digestText }).loose().nullable(),
+  decision: z63.object({ executionId: z63.string(), receiptDigest: digestText }),
+  actionAuthorized: z63.literal(false)
 }).loose();
-var quotedWords = z59.object({ text: z59.string() }).loose();
-var FelsparCaseSchema = z59.object({ id: z59.string().min(1).max(200), mode: z59.enum(identityModes) });
-var FelsparRelatedSchema = z59.object({
-  relationship: z59.string(),
-  subject: z59.string(),
-  id: z59.string(),
-  questions: z59.array(z59.string())
-});
-var FelsparResultSubjectSchema = z59.object({
-  type: z59.string(),
-  id: z59.string(),
-  related: z59.array(FelsparRelatedSchema)
-});
-var FelsparEscalationSchema = z59.object({
-  id: z59.string().min(1).max(200),
-  trigger: z59.enum(escalationTriggers),
+var quotedWords = z63.object({ text: z63.string() }).loose();
+var FelsparCaseSchema = z63.object({ id: z63.string().min(1).max(200), mode: z63.enum(identityModes) });
+var FelsparRelatedSchema = z63.object({
+  relationship: z63.string(),
+  subject: z63.string(),
+  id: z63.string(),
+  questions: z63.array(z63.string())
+});
+var FelsparResultSubjectSchema = z63.object({
+  type: z63.string(),
+  id: z63.string(),
+  related: z63.array(FelsparRelatedSchema)
+});
+var FelsparEscalationSchema = z63.object({
+  id: z63.string().min(1).max(200),
+  trigger: z63.enum(escalationTriggers),
   why: quotedWords
 });
 var FelsparJobResultSchema = HostedJobResultSchema.extend({
@@ -5417,25 +6190,25 @@ var FelsparJobResultSchema = HostedJobResultSchema.extend({
     case: FelsparCaseSchema.optional(),
     subject: FelsparResultSubjectSchema.optional(),
     escalation: FelsparEscalationSchema.optional(),
-    missing: z59.array(z59.string()).optional()
+    missing: z63.array(z63.string()).optional()
   }).nullable()
 });
-var FelsparJobListSchema = z59.object({
-  jobs: z59.array(z59.object({ id: z59.string().min(1).max(200) })).max(256)
+var FelsparJobListSchema = z63.object({
+  jobs: z63.array(z63.object({ id: z63.string().min(1).max(200) })).max(256)
 });
 var hostedPartsContentType = "application/x.felspar-content-parts";
-async function partsBody(value) {
-  const packed = await packContentParts(value);
+async function partsBody(value2) {
+  const packed = await packContentParts(value2);
   return packed.text;
 }
-async function factsRequest(value, describeRelease) {
-  if (typeof value.expectedReleaseDigest === "string") {
-    return HostedFactsRequestSchema.parse({ mode: "facts", ...value });
+async function factsRequest(value2, describeRelease) {
+  if (typeof value2.expectedReleaseDigest === "string") {
+    return HostedFactsRequestSchema.parse({ mode: "facts", ...value2 });
   }
-  const described = await describeRelease(HostedObjectSchema.shape.id.parse(value.jobId));
+  const described = await describeRelease(HostedObjectSchema.shape.id.parse(value2.jobId));
   return HostedFactsRequestSchema.parse({
     mode: "facts",
-    ...value,
+    ...value2,
     expectedReleaseDigest: described.release.releaseDigest
   });
 }
@@ -5473,31 +6246,31 @@ ${jobId}`;
     return result;
   };
 }
-var refusalCode = z59.string().regex(/^[a-z][a-z_]{2,63}$/u);
-var fieldPath = z59.array(z59.string().max(256)).max(32);
-var refusalEscalationSchema = z59.object({
-  id: z59.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/@-]{0,199}$/u),
-  trigger: z59.enum(escalationTriggers),
-  why: z59.object({ text: z59.string().max(2e4) })
+var refusalCode = z63.string().regex(/^[a-z][a-z_]{2,63}$/u);
+var fieldPath = z63.array(z63.string().max(256)).max(32);
+var refusalEscalationSchema = z63.object({
+  id: z63.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/@-]{0,199}$/u),
+  trigger: z63.enum(escalationTriggers),
+  why: z63.object({ text: z63.string().max(2e4) })
 });
-var refusalSchema = z59.object({
+var refusalSchema = z63.object({
   error: refusalCode,
   path: fieldPath.optional(),
-  currentReleaseDigest: z59.string().regex(/^sha256:[a-f0-9]{64}$/u).optional(),
-  retryAfterSeconds: z59.number().int().min(1).max(3600).optional(),
-  escalation: z59.unknown().optional(),
-  issues: z59.array(z59.object({ code: refusalCode, path: fieldPath })).max(64).optional()
-}).transform(({ escalation: named, ...value }) => {
-  const fix = hostedRefusalFix(value.error);
-  const recovery = hostedRefusalRecovery(value.error);
+  currentReleaseDigest: z63.string().regex(/^sha256:[a-f0-9]{64}$/u).optional(),
+  retryAfterSeconds: z63.number().int().min(1).max(3600).optional(),
+  escalation: z63.unknown().optional(),
+  issues: z63.array(z63.object({ code: refusalCode, path: fieldPath })).max(64).optional()
+}).transform(({ escalation: named, ...value2 }) => {
+  const fix = hostedRefusalFix(value2.error);
+  const recovery = hostedRefusalRecovery(value2.error);
   const escalation = refusalEscalationSchema.safeParse(named).data;
   return {
-    ...value,
+    ...value2,
     ...escalation !== void 0 && { escalation },
     ...fix !== null && { fix },
     ...recovery !== null && { recovery },
-    ...value.issues && {
-      issues: value.issues.map((issue) => {
+    ...value2.issues && {
+      issues: value2.issues.map((issue) => {
         const issueFix = hostedRefusalFix(issue.code);
         return issueFix === null ? issue : { ...issue, fix: issueFix };
       })
@@ -5541,7 +6314,7 @@ function outputCheckCalls(call) {
   const objectId = HostedObjectSchema.shape.id;
   const checksOf = (job) => `/v0/jobs/${encodeURIComponent(objectId.parse(job))}/output-checks`;
   return {
-    checkOutput: async (job, value) => await call(checksOf(job), HostedOutputCheckReplySchema, HostedOutputCheckInputSchema.parse(value)),
+    checkOutput: async (job, value2) => await call(checksOf(job), HostedOutputCheckReplySchema, HostedOutputCheckInputSchema.parse(value2)),
     readOutputCheck: async (job, checkId) => await call(`${checksOf(job)}/${encodeURIComponent(objectId.parse(checkId))}`, HostedOutputCheckReplySchema)
   };
 }
@@ -5550,9 +6323,9 @@ function agentCalls(call) {
   return {
     listJobs: async () => await call("/v0/jobs", FelsparJobListSchema),
     describeCurrentJob: async (job) => await call(`/v0/jobs/${encodeURIComponent(objectId.parse(job))}/brief`, HostedJobDescriptionSchema),
-    resolveJob: async (id13, value) => {
-      const input = HostedSuppliedJobInputSchema.parse(value);
-      const releaseId = objectId.parse(id13);
+    resolveJob: async (id14, value2) => {
+      const input = HostedSuppliedJobInputSchema.parse(value2);
+      const releaseId = objectId.parse(id14);
       const path3 = `/v0/releases/${encodeURIComponent(releaseId)}/jobs`;
       return pinnedResult(await call(path3, FelsparJobResultSchema, input), releaseId, input);
     }
@@ -5573,14 +6346,14 @@ function createHostedFelsparClient(configuration) {
   }
   const authorization = authorizationOf(configuration);
   const fetcher = configuration.fetcher ?? fetch;
-  async function call(path3, schema, value) {
+  async function call(path3, schema, value2) {
     const headers = new Headers(authorization === null ? {} : { Authorization: authorization });
-    const body = value === void 0 ? void 0 : await partsBody(value);
+    const body = value2 === void 0 ? void 0 : await partsBody(value2);
     if (body !== void 0) {
       headers.set("Content-Type", hostedPartsContentType);
     }
     const response = await fetcher(`${origin.origin}${path3}`, {
-      method: value === void 0 ? "GET" : "POST",
+      method: value2 === void 0 ? "GET" : "POST",
       headers,
       credentials: "include",
       redirect: "error",
@@ -5595,19 +6368,19 @@ function createHostedFelsparClient(configuration) {
   const objectId = HostedObjectSchema.shape.id;
   const describe = jobDescriber(async (releaseId, jobId) => await call(describePath(releaseId, jobId), HostedJobDescriptionSchema));
   return {
-    submitSource: async (value) => await call("/v0/sources", HostedObjectSchema, HostedSourceInputSchema.parse(value)),
-    submitProposal: async (value) => await call("/v0/proposals", HostedObjectSchema, HostedProposalInputSchema.parse(value)),
-    approveProposal: async (id13, value) => await call(`/v0/proposals/${encodeURIComponent(objectId.parse(id13))}/approve`, HostedObjectSchema, HostedApprovalInputSchema.parse(value)),
-    releasePack: async (id13, value) => await call(`/v0/approvals/${encodeURIComponent(objectId.parse(id13))}/release`, DraftApplicationReleaseSchema, HostedReleaseInputSchema.parse(value)),
-    loadRelease: async (id13) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id13))}`, HostedReleaseBundleSchema),
-    describeJob: async (id13, job) => await describe(objectId.parse(id13), objectId.parse(job)),
-    verifyReceipt: async (executionObjectId, value) => await call(`/v0/executions/${encodeURIComponent(objectId.parse(executionObjectId))}/verify`, HostedReceiptVerificationSchema, HostedReceiptVerificationInputSchema.parse(value)),
+    submitSource: async (value2) => await call("/v0/sources", HostedObjectSchema, HostedSourceInputSchema.parse(value2)),
+    submitProposal: async (value2) => await call("/v0/proposals", HostedObjectSchema, HostedProposalInputSchema.parse(value2)),
+    approveProposal: async (id14, value2) => await call(`/v0/proposals/${encodeURIComponent(objectId.parse(id14))}/approve`, HostedObjectSchema, HostedApprovalInputSchema.parse(value2)),
+    releasePack: async (id14, value2) => await call(`/v0/approvals/${encodeURIComponent(objectId.parse(id14))}/release`, DraftApplicationReleaseSchema, HostedReleaseInputSchema.parse(value2)),
+    loadRelease: async (id14) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id14))}`, HostedReleaseBundleSchema),
+    describeJob: async (id14, job) => await describe(objectId.parse(id14), objectId.parse(job)),
+    verifyReceipt: async (executionObjectId, value2) => await call(`/v0/executions/${encodeURIComponent(objectId.parse(executionObjectId))}/verify`, HostedReceiptVerificationSchema, HostedReceiptVerificationInputSchema.parse(value2)),
     ...outputCheckCalls(call),
-    executeJob: async (id13, value) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id13))}/jobs`, HostedJobResultSchema, HostedJobInputSchema.parse(value)),
+    executeJob: async (id14, value2) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id14))}/jobs`, HostedJobResultSchema, HostedJobInputSchema.parse(value2)),
     ...agentCalls(call),
-    resolveFacts: async (id13, value) => {
-      const releaseId = objectId.parse(id13);
-      const input = await factsRequest(value, async (jobId) => await describe(releaseId, jobId));
+    resolveFacts: async (id14, value2) => {
+      const releaseId = objectId.parse(id14);
+      const input = await factsRequest(value2, async (jobId) => await describe(releaseId, jobId));
       const path3 = `/v0/releases/${encodeURIComponent(releaseId)}/jobs`;
       return pinnedResult(await call(path3, FelsparJobResultSchema, input), releaseId, input);
     }