@felspar/sdk 0.0.0-stage → 0.1.1

package/dist/chunks/chunk-C2VMKF3S.js

@@ -0,0 +1,4922 @@
+// ../schemas/src/draft-content-parts.ts
+import { z } from "zod";
+var draftContentPartsFormat = "felspar.content-parts/v1";
+var draftContentPartReferenceKey = "$part";
+var digest = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var DraftContentPartsManifestSchema = z.strictObject({
+  schema: z.literal(draftContentPartsFormat),
+  root: z.unknown(),
+  parts: z.array(digest)
+});
+
+// ../runtime/src/canonical-json.ts
+var canonicalJsonLimits = Object.freeze({
+  maxDepth: 64,
+  maxNodes: 1e5,
+  maxBytes: 1048576
+});
+var sealedEntries = /* @__PURE__ */ new WeakMap();
+var sealedContainers = /* @__PURE__ */ new WeakSet();
+var sealedEntryMinimumBytes = 1024;
+var byteEncoder = new TextEncoder();
+function utf8Bytes(token) {
+  if (token.length >= 64) {
+    return byteEncoder.encode(token).byteLength;
+  }
+  let bytes = 0;
+  for (let index = 0; index < token.length; index += 1) {
+    const code = token.codePointAt(index) ?? 0;
+    if (code < 128) {
+      bytes += 1;
+    } else if (code < 2048) {
+      bytes += 2;
+    } else if (code > 65535) {
+      bytes += 4;
+      index += 1;
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+}
+function append(token, state, bytes = utf8Bytes(token)) {
+  state.bytes += bytes;
+  if (state.bytes > canonicalJsonLimits.maxBytes) {
+    throw new RangeError("Canonical JSON exceeds the byte limit");
+  }
+  state.buffer += token;
+  if (state.buffer.length < 4096) {
+    return;
+  }
+  state.parts.push(state.buffer);
+  state.buffer = "";
+}
+function quoted(value) {
+  if (value.length > canonicalJsonLimits.maxBytes) {
+    throw new RangeError("Canonical JSON string exceeds the byte limit");
+  }
+  if (/[\uD800-\uDFFF]/u.test(value)) {
+    throw new TypeError("Canonical JSON requires valid Unicode strings");
+  }
+  return JSON.stringify(value);
+}
+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;
+    }
+  }
+  append(entry2.token, state, entry2.bytes);
+}
+function dataValue(input, key3) {
+  const descriptor = Object.getOwnPropertyDescriptor(input, key3);
+  if (descriptor?.enumerable !== true || !("value" in descriptor)) {
+    throw new TypeError("Canonical JSON requires enumerable data properties");
+  }
+  return descriptor.value;
+}
+function keysOf(input, nodes) {
+  const keys = Reflect.ownKeys(input);
+  if (keys.length > canonicalJsonLimits.maxNodes - nodes + 1) {
+    throw new RangeError("Canonical JSON exceeds the node limit");
+  }
+  return keys.map((key3) => {
+    if (typeof key3 !== "string") {
+      throw new TypeError("Canonical JSON does not support symbol keys");
+    }
+    return key3;
+  });
+}
+function writeArray(input, state, depth) {
+  const keys = keysOf(input, state.nodes);
+  if (Object.getPrototypeOf(input) !== Array.prototype || keys.length !== input.length + 1) {
+    throw new TypeError("Canonical JSON requires dense ordinary arrays without extra properties");
+  }
+  if (input.length > canonicalJsonLimits.maxNodes - state.nodes) {
+    throw new RangeError("Canonical JSON exceeds the node limit");
+  }
+  append("[", state);
+  for (let index = 0; index < input.length; index += 1) {
+    if (index > 0) {
+      append(",", state);
+    }
+    writeValue(dataValue(input, String(index)), state, depth + 1);
+  }
+  append("]", state);
+}
+function compareKeys(left, right) {
+  if (left === right) {
+    return 0;
+  }
+  return left < right ? -1 : 1;
+}
+function writeObject(input, state, depth) {
+  const prototype = Object.getPrototypeOf(input);
+  if (prototype !== null && prototype !== Object.prototype) {
+    throw new TypeError("Canonical JSON requires ordinary objects");
+  }
+  const keys = keysOf(input, state.nodes).sort(compareKeys);
+  append("{", state);
+  for (const [index, key3] of keys.entries()) {
+    if (index > 0) {
+      append(",", state);
+    }
+    appendQuoted(key3, state);
+    append(":", state);
+    writeValue(dataValue(input, key3), state, depth + 1);
+  }
+  append("}", state);
+}
+function writeSealed(entry2, state, depth) {
+  state.nodes += entry2.nodes - 1;
+  if (depth + entry2.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);
+}
+function writeContainer(input, state, depth) {
+  const sealed = sealedEntries.get(input);
+  if (sealed) {
+    writeSealed(sealed, state, depth);
+    return;
+  }
+  if (state.ancestors.has(input)) {
+    throw new TypeError("Canonical JSON does not support cycles");
+  }
+  state.ancestors.add(input);
+  if (Array.isArray(input)) {
+    writeArray(input, state, depth);
+  } else {
+    writeObject(input, state, depth);
+  }
+  state.ancestors.delete(input);
+}
+function writeValue(input, state, depth) {
+  state.nodes += 1;
+  if (depth > canonicalJsonLimits.maxDepth || state.nodes > canonicalJsonLimits.maxNodes) {
+    throw new RangeError("Canonical JSON exceeds the depth or node limit");
+  }
+  if (depth > state.height) {
+    state.height = depth;
+  }
+  if (input === null || typeof input === "boolean") {
+    append(JSON.stringify(input), state);
+  } else if (typeof input === "string") {
+    appendQuoted(input, state);
+  } else if (typeof input === "number" && Number.isFinite(input)) {
+    append(JSON.stringify(input), state);
+  } else if (typeof input === "object") {
+    writeContainer(input, state, depth);
+  } else {
+    throw new TypeError("Canonical JSON requires finite numbers and JSON-compatible values");
+  }
+}
+function serialize(input) {
+  const state = {
+    parts: [],
+    buffer: "",
+    bytes: 0,
+    nodes: 0,
+    ancestors: /* @__PURE__ */ new Set(),
+    strings: /* @__PURE__ */ new Map(),
+    stringBytes: 0,
+    height: 0
+  };
+  writeValue(input, state, 0);
+  return { json: state.parts.join("") + state.buffer, state };
+}
+function canonicalizeJson(input) {
+  return serialize(input).json;
+}
+function sealedMembers(input) {
+  const keys = keysOf(input, 0);
+  const prototype = Object.getPrototypeOf(input);
+  if (Array.isArray(input)) {
+    if (prototype !== Array.prototype || keys.length !== input.length + 1) {
+      throw new TypeError("Canonical JSON requires dense ordinary arrays without extra properties");
+    }
+    return Array.from(input.keys(), String);
+  }
+  if (prototype !== null && prototype !== Object.prototype) {
+    throw new TypeError("Canonical JSON requires ordinary objects");
+  }
+  keys.sort(compareKeys);
+  return keys;
+}
+function consumeSource(token, source3) {
+  if (!source3) {
+    return;
+  }
+  if (!source3.text.startsWith(token, source3.offset)) {
+    throw new TypeError("JSON text is not canonical");
+  }
+  source3.offset += token.length;
+}
+function sealValue(input, depth, state) {
+  const { ancestors, source: source3 } = state;
+  if (depth > canonicalJsonLimits.maxDepth) {
+    throw new RangeError("Canonical JSON exceeds the depth limit");
+  }
+  if (input === null || typeof input !== "object") {
+    const token = typeof input === "string" ? quoted(input) : canonicalizeJson(input);
+    consumeSource(token, source3);
+    return { json: token, bytes: utf8Bytes(token), nodes: 1, height: 0 };
+  }
+  const known = sealedEntries.get(input);
+  if (known) {
+    consumeSource(known.json, source3);
+    return known;
+  }
+  if (ancestors.has(input)) {
+    throw new TypeError("Canonical JSON does not support cycles");
+  }
+  ancestors.add(input);
+  const isArray = Array.isArray(input);
+  const members = sealedMembers(input);
+  const start = source3?.offset ?? 0;
+  let json = isArray ? "[" : "{";
+  consumeSource(json, source3);
+  let bytes = 2;
+  let nodes = 1;
+  let height = 0;
+  for (const [index, key3] of members.entries()) {
+    let prefix = index > 0 ? "," : "";
+    if (!isArray) {
+      prefix += `${quoted(key3)}:`;
+    }
+    consumeSource(prefix, source3);
+    const child = sealValue(dataValue(input, key3), depth + 1, state);
+    if (!source3) {
+      json += prefix + child.json;
+    }
+    bytes += utf8Bytes(prefix) + child.bytes;
+    nodes += child.nodes;
+    height = Math.max(height, child.height + 1);
+  }
+  const closing = isArray ? "]" : "}";
+  consumeSource(closing, source3);
+  json = source3 ? source3.text.slice(start, source3.offset) : json + closing;
+  ancestors.delete(input);
+  if (depth + height > canonicalJsonLimits.maxDepth || nodes > canonicalJsonLimits.maxNodes || bytes > canonicalJsonLimits.maxBytes) {
+    throw new RangeError("Canonical JSON exceeds the depth, node or byte limit");
+  }
+  Object.freeze(input);
+  const entry2 = { json, bytes, nodes, height };
+  sealedContainers.add(input);
+  if (bytes >= sealedEntryMinimumBytes) {
+    sealedEntries.set(input, entry2);
+  }
+  return entry2;
+}
+function sealCanonicalJson(input) {
+  sealValue(input, 0, { ancestors: /* @__PURE__ */ new Set() });
+  return input;
+}
+function isCanonicalJsonSealed(input) {
+  return input !== null && typeof input === "object" && sealedContainers.has(input);
+}
+
+// ../runtime/src/content-parts.ts
+var mebibyte = 1048576;
+var contentPartsLimits = Object.freeze({
+  minPartBytes: 4096,
+  maxParts: 512,
+  maxStoredBytes: 4 * mebibyte,
+  maxLogicalBytes: 32 * mebibyte,
+  maxLogicalNodes: 32e5,
+  maxLogicalDepth: canonicalJsonLimits.maxDepth
+});
+var encoder = new TextEncoder();
+function utf8(text7) {
+  if (text7.length >= 64) {
+    return encoder.encode(text7).byteLength;
+  }
+  let bytes = 0;
+  for (let index = 0; index < text7.length; index += 1) {
+    const code = text7.codePointAt(index) ?? 0;
+    if (code < 128) {
+      bytes += 1;
+    } else if (code < 2048) {
+      bytes += 2;
+    } else if (code > 65535) {
+      bytes += 4;
+      index += 1;
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+}
+async function sha256(text7) {
+  const hash = new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(text7)));
+  return `sha256:${Array.from(hash, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+function reference(digest28) {
+  return { [draftContentPartReferenceKey]: digest28 };
+}
+var referenceBytes = utf8(canonicalizeJson(reference(`sha256:${"0".repeat(64)}`)));
+var logicalLimit = "Content parts exceed the logical byte, node or depth limit";
+function admit(logical, depth) {
+  if (logical.bytes > contentPartsLimits.maxLogicalBytes || logical.nodes > contentPartsLimits.maxLogicalNodes || depth + logical.height > contentPartsLimits.maxLogicalDepth) {
+    throw new RangeError(logicalLimit);
+  }
+}
+function scalar(value) {
+  if (value === void 0 || typeof value === "function" || typeof value === "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 } };
+}
+function combine(keys, children) {
+  let tokenBytes = 2 + Math.max(children.length - 1, 0);
+  let bytes = tokenBytes;
+  let nodes = 1;
+  let height = 0;
+  for (const [index, child] of children.entries()) {
+    const key3 = keys?.[index];
+    const keyBytes = key3 === void 0 ? 0 : utf8(JSON.stringify(key3)) + 1;
+    tokenBytes += keyBytes + child.tokenBytes;
+    bytes += keyBytes + child.logical.bytes;
+    nodes += child.logical.nodes;
+    height = Math.max(height, child.logical.height + 1);
+  }
+  return { tokenBytes, logical: { bytes, nodes, height } };
+}
+var hydratedValues = /* @__PURE__ */ new WeakSet();
+var knownSplits = /* @__PURE__ */ new WeakMap();
+function isImmutable(value) {
+  return hydratedValues.has(value) || isCanonicalJsonSealed(value);
+}
+function entriesOf(input) {
+  const isArray = Array.isArray(input);
+  const prototype = Object.getPrototypeOf(input);
+  if (isArray ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null) {
+    throw new TypeError("Content parts require plain JSON containers");
+  }
+  const keys = Reflect.ownKeys(input);
+  if (isArray && keys.length !== input.length + 1) {
+    throw new TypeError("Content parts require dense arrays");
+  }
+  const entries2 = [];
+  for (const key3 of keys) {
+    if (isArray && key3 === "length") {
+      continue;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(input, key3);
+    if (typeof key3 !== "string" || descriptor?.enumerable !== true || !("value" in descriptor)) {
+      throw new TypeError("Content parts require enumerable JSON data properties");
+    }
+    if (!isArray && key3 === draftContentPartReferenceKey) {
+      throw new TypeError("Content parts reserve the $part key");
+    }
+    entries2.push([key3, descriptor.value]);
+  }
+  return entries2;
+}
+function rebuild(input, entries2, values) {
+  return Array.isArray(input) ? values : Object.fromEntries(entries2.map(([key3], index) => [key3, values[index]]));
+}
+function measure(input, state, depth) {
+  if (input === null || typeof input !== "object") {
+    return scalar(input);
+  }
+  const known = state.isCollecting ? void 0 : knownSplits.get(input);
+  if (known) {
+    admit(known.logical, depth);
+    return known;
+  }
+  let node = state.measured.get(input);
+  if (!node) {
+    if (depth > contentPartsLimits.maxLogicalDepth) {
+      throw new RangeError(logicalLimit);
+    }
+    const entries2 = entriesOf(input);
+    const children = entries2.map(([, value]) => measure(value, 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;
+    node = { input, entries: entries2, tokenBytes: tokenBytes2, logical, isPart };
+    state.measured.set(input, node);
+    if (isPart) {
+      state.order.push(node);
+    }
+  }
+  admit(node.logical, depth);
+  const tokenBytes = node.isPart ? referenceBytes : node.tokenBytes;
+  return { value: null, tokenBytes, logical: node.logical };
+}
+function storedForm(input, state) {
+  if (input === null || typeof input !== "object") {
+    return input;
+  }
+  const known = state.isCollecting ? void 0 : knownSplits.get(input);
+  if (known) {
+    return known.value;
+  }
+  const digest28 = state.digests.get(input);
+  if (digest28 !== void 0) {
+    return reference(digest28);
+  }
+  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)));
+}
+function remember(node, value, tokenBytes) {
+  if (isImmutable(node.input)) {
+    knownSplits.set(node.input, { value, tokenBytes, logical: node.logical });
+  }
+}
+function isCanonicalDocumentSized(logical) {
+  return logical.bytes <= canonicalJsonLimits.maxBytes && logical.nodes <= canonicalJsonLimits.maxNodes && logical.height <= canonicalJsonLimits.maxDepth;
+}
+function freezeMeasured(state) {
+  for (const node of state.measured.values()) {
+    if (node.isPart && isCanonicalDocumentSized(node.logical)) {
+      sealCanonicalJson(node.input);
+    }
+    Object.freeze(node.input);
+    hydratedValues.add(node.input);
+  }
+}
+async function splitRoot(value, isCollecting, isFreezing = false) {
+  const state = {
+    isCollecting,
+    measured: /* @__PURE__ */ new Map(),
+    order: [],
+    digests: /* @__PURE__ */ new Map(),
+    parts: /* @__PURE__ */ new Map()
+  };
+  const root = measure(value, 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);
+    if (node && !node.isPart) {
+      remember(node, stored, node.tokenBytes);
+    }
+  }
+  const digest28 = await sha256(canonicalizeJson(stored));
+  return { state, root: { ...root, value: stored }, digest: digest28 };
+}
+function byDigest(left, right) {
+  return left < right ? -1 : 1;
+}
+function admitStored(parts, bytes) {
+  if (parts > contentPartsLimits.maxParts || bytes > contentPartsLimits.maxStoredBytes) {
+    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);
+  const parts = [];
+  for (const part of state.parts.keys()) {
+    parts.push(part);
+  }
+  parts.sort(byDigest);
+  const head = canonicalizeJson({ schema: draftContentPartsFormat, root: root.value, parts });
+  const text7 = [head, ...parts.map((part) => state.parts.get(part) ?? "")].join("\n");
+  const storedBytes = utf8(text7);
+  admitStored(parts.length, storedBytes);
+  return {
+    digest: digest28,
+    text: text7,
+    parts: parts.length,
+    storedBytes,
+    logicalBytes: root.logical.bytes,
+    logicalNodes: root.logical.nodes
+  };
+}
+
+// ../schemas/src/draft-application-access.ts
+import { z as z41 } from "zod";
+
+// ../schemas/src/draft-job-handoff.ts
+import { z as z40 } from "zod";
+
+// ../schemas/src/draft-requirements.ts
+import { z as z34 } from "zod";
+
+// ../schemas/src/draft-required-origins.ts
+import { z as z32 } from "zod";
+
+// ../schemas/src/draft-required-decision.ts
+import { z as z15 } from "zod";
+
+// ../schemas/src/draft-relative-date.ts
+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;
+}, "Expected a real Gregorian calendar date in years 0001\u20139999");
+function calendarDay(value) {
+  return Date.parse(`${value}T00:00:00.000Z`) / 864e5;
+}
+
+// ../schemas/src/draft-evidence-scope.ts
+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 reference2 = z3.strictObject({
+  sourceId: identifier,
+  revision: identifier,
+  locator: z3.string().min(1).max(4096).regex(/\S/u),
+  contentDigest: z3.string().regex(/^sha256:[a-f0-9]{64}$/u)
+});
+function draftPassageKey(source3) {
+  return JSON.stringify([source3.sourceId, source3.revision, source3.locator]);
+}
+var DraftEvidenceScopeSchema = z3.strictObject({
+  schema: z3.literal("felspar.evidence-scope.draft/v0"),
+  entityId: identifier,
+  sources: z3.array(reference2.extend({ entityId: identifier })).max(64),
+  observations: z3.array(z3.strictObject({ id: identifier, evidence: reference2 })).max(64)
+}).superRefine((input, context3) => {
+  const sources = /* @__PURE__ */ new Set();
+  for (const [index, source3] of input.sources.entries()) {
+    const key3 = draftPassageKey(source3);
+    if (sources.has(key3)) {
+      context3.addIssue({
+        code: "custom",
+        path: ["sources", index],
+        message: "Duplicate passage identity"
+      });
+    }
+    sources.add(key3);
+  }
+  const observations = /* @__PURE__ */ new Set();
+  for (const [index, observation2] of input.observations.entries()) {
+    if (observations.has(observation2.id)) {
+      context3.addIssue({
+        code: "custom",
+        path: ["observations", index],
+        message: "Duplicate observation identity"
+      });
+    }
+    observations.add(observation2.id);
+  }
+});
+
+// ../schemas/src/draft-evidence-values.ts
+import { z as z4 } from "zod";
+function hasUniqueValues(values) {
+  const unique4 = new Set(values);
+  return unique4.size === values.length;
+}
+var DraftEvidenceValueSchema = z4.union([z4.string().max(4096), z4.number(), z4.boolean()]);
+var DraftValueRuleSchema = z4.discriminatedUnion("type", [
+  z4.strictObject({
+    type: z4.literal("enum"),
+    values: z4.array(z4.string().min(1).max(4096)).min(1).max(64).refine(hasUniqueValues, "Duplicate allowed value")
+  }),
+  z4.strictObject({
+    type: z4.literal("number"),
+    integer: z4.boolean(),
+    minimum: z4.number(),
+    maximum: z4.number()
+  }).refine((rule3) => rule3.minimum <= rule3.maximum, "Reversed number bounds"),
+  z4.strictObject({ type: z4.literal("boolean") }),
+  z4.strictObject({ type: z4.literal("date") })
+]);
+var DraftValueResultSchema = z4.discriminatedUnion("status", [
+  z4.strictObject({ status: z4.literal("supplied"), value: DraftEvidenceValueSchema }),
+  z4.strictObject({ status: z4.enum(["malformed", "timeout", "review_required"]) })
+]);
+
+// ../schemas/src/draft-relative-date.ts
+var relativeDateResolutionPolicy = "relative-date-required-types/direct-overrides/v5";
+var identifier2 = DraftEvidenceScopeSchema.shape.entityId;
+var businessCalendar = z5.strictObject({
+  kind: z5.literal("business_days"),
+  id: identifier2,
+  version: identifier2,
+  validFrom: CalendarDateSchema,
+  validThrough: CalendarDateSchema,
+  workingWeekdays: z5.array(z5.number().int().min(0).max(6)).min(1).max(7).refine((values) => {
+    const unique4 = new Set(values);
+    return unique4.size === values.length;
+  }, "Duplicate working weekday"),
+  holidays: z5.array(CalendarDateSchema).max(3660).refine(hasUniqueValues, "Duplicate holiday")
+}).superRefine((calendar, context3) => {
+  const span = calendarDay(calendar.validThrough) - calendarDay(calendar.validFrom);
+  if (span < 0 || span > 36600) {
+    context3.addIssue({
+      code: "custom",
+      message: "Calendar coverage must be ordered and at most 36600 days"
+    });
+  }
+  if (calendar.holidays.some((day) => {
+    const value = calendarDay(day);
+    return value < calendarDay(calendar.validFrom) || value > calendarDay(calendar.validThrough);
+  })) {
+    context3.addIssue({ code: "custom", message: "Holiday outside declared calendar coverage" });
+  }
+});
+var RelativeDateComparisonSchema = z5.strictObject({
+  operator: z5.enum(["eq", "lt", "lte", "gt", "gte"]),
+  anchorKey: identifier2,
+  offsetDays: z5.number().int().min(-3660).max(3660),
+  calendar: z5.union([z5.strictObject({ kind: z5.literal("calendar_days") }), businessCalendar])
+});
+
+// ../schemas/src/draft-authority.ts
+import { z as z6 } from "zod";
+var identifier3 = z6.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/@-]*$/u);
+var text = z6.string().regex(/\S/u);
+var digest2 = z6.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var identifiers = z6.array(identifier3).min(1);
+var unknownDefinition = "Unknown definition key";
+var DraftSourceReferenceSchema = z6.strictObject({
+  sourceId: identifier3,
+  revision: identifier3,
+  contentDigest: digest2
+});
+var definition = z6.strictObject({
+  key: identifier3,
+  contentDigest: digest2,
+  sourceLocator: text,
+  allowedValues: identifiers
+});
+var rule = z6.strictObject({
+  id: identifier3,
+  sourceLocator: text,
+  contentDigest: digest2,
+  when: z6.strictObject({ key: identifier3, equals: identifier3 }),
+  outcome: identifier3
+});
+var authorityShape = z6.strictObject({
+  kind: z6.literal("proposal"),
+  job: identifier3,
+  source: DraftSourceReferenceSchema,
+  definition,
+  allowedOutcomes: identifiers,
+  rules: z6.array(rule).min(1)
+});
+function requireBinding(isValid, context3, issue) {
+  if (!isValid) {
+    context3.addIssue({ code: "custom", ...issue });
+  }
+}
+function unique(values, context3, path3) {
+  const distinct = new Set(values);
+  requireBinding(distinct.size === values.length, context3, {
+    path: path3,
+    message: "Duplicate identity/value"
+  });
+}
+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"]);
+  const values = new Set(authority.definition.allowedValues);
+  const outcomes = new Set(authority.allowedOutcomes);
+  for (const [index, entry2] of authority.rules.entries()) {
+    const at = ["rules", index];
+    requireBinding(entry2.when.key === authority.definition.key, context3, {
+      path: [...at, "when", "key"],
+      message: unknownDefinition
+    });
+    requireBinding(values.has(entry2.when.equals), context3, {
+      path: [...at, "when", "equals"],
+      message: "Unknown definition value"
+    });
+    requireBinding(outcomes.has(entry2.outcome), context3, {
+      path: [...at, "outcome"],
+      message: "Unknown outcome"
+    });
+  }
+}
+var DraftAuthoritySchema = authorityShape.superRefine(checkAuthority);
+
+// ../schemas/src/draft-decision-run.ts
+import { z as z10 } from "zod";
+
+// ../schemas/src/draft-evidence-validation.ts
+import { z as z8 } from "zod";
+
+// ../schemas/src/draft-observation-checks.ts
+import { z as z7 } from "zod";
+var identifier4 = DraftEvidenceScopeSchema.shape.observations.element.shape.id;
+var digest3 = z7.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var timestamp = z7.iso.datetime().regex(/T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/u);
+var DraftObservationChecksSchema = z7.strictObject({
+  schema: z7.literal("felspar.observation-checks.draft/v0"),
+  scope: DraftEvidenceScopeSchema,
+  evaluationTime: timestamp,
+  requirement: z7.strictObject({
+    key: identifier4,
+    definitionDigest: digest3,
+    maxAgeMs: z7.number().int().min(0).max(Number.MAX_SAFE_INTEGER)
+  }),
+  observations: z7.array(z7.strictObject({
+    id: identifier4,
+    key: identifier4,
+    definitionDigest: digest3,
+    observedAt: timestamp
+  })).max(64)
+}).superRefine((input, context3) => {
+  const remaining = new Set(input.scope.observations.map((observation2) => observation2.id));
+  for (const [index, observation2] of input.observations.entries()) {
+    if (!remaining.delete(observation2.id)) {
+      context3.addIssue({
+        code: "custom",
+        path: ["observations", index, "id"],
+        message: "Unexpected or duplicate observation metadata"
+      });
+    }
+  }
+  if (remaining.size > 0) {
+    context3.addIssue({
+      code: "custom",
+      path: ["observations"],
+      message: "Missing observation metadata"
+    });
+  }
+});
+
+// ../schemas/src/draft-evidence-validation.ts
+var identifier5 = DraftEvidenceScopeSchema.shape.entityId;
+var reference3 = DraftEvidenceScopeSchema.shape.observations.element.shape.evidence;
+var source = z8.strictObject({ reference: reference3, sourceClass: identifier5, sensitivity: identifier5 });
+var admission = z8.strictObject({
+  reference: reference3,
+  purpose: identifier5,
+  sensitivity: identifier5,
+  trustDomain: identifier5,
+  status: z8.enum(["approved", "revoked"])
+});
+function draftEvidenceReferenceKey(value) {
+  return JSON.stringify([draftPassageKey(value), value.contentDigest]);
+}
+function draftAdmissionKey(value) {
+  return JSON.stringify([
+    draftEvidenceReferenceKey(value.reference),
+    value.purpose,
+    value.sensitivity,
+    value.trustDomain
+  ]);
+}
+function requireCoverage({ expected: expected2, actual, path: path3 }, context3) {
+  const remaining = new Set(expected2);
+  for (const [index, key3] of actual.entries()) {
+    if (!remaining.delete(key3)) {
+      context3.addIssue({
+        code: "custom",
+        path: [path3, index],
+        message: "Unexpected or duplicate metadata"
+      });
+    }
+  }
+  if (remaining.size > 0) {
+    context3.addIssue({ code: "custom", path: [path3], message: "Missing metadata" });
+  }
+}
+var evidenceShape = z8.strictObject({
+  schema: z8.literal("felspar.evidence-validation.draft/v0"),
+  mode: z8.literal("new_run"),
+  job: identifier5,
+  trustDomain: identifier5,
+  observationChecks: DraftObservationChecksSchema,
+  allowedSourceClasses: z8.array(identifier5).min(1).max(64).refine(hasUniqueValues, "Duplicate source class"),
+  valueRule: DraftValueRuleSchema,
+  unit: identifier5.optional(),
+  collection: z8.enum([
+    "observed",
+    "not_found",
+    "blocked",
+    "error",
+    "not_applicable",
+    "unattempted"
+  ]),
+  sources: z8.array(source).max(64),
+  admissions: z8.array(admission).max(128)
+});
+function checkMetadata(input, context3) {
+  if (input.unit !== void 0 && input.valueRule.type !== "number") {
+    context3.addIssue({
+      code: "custom",
+      path: ["unit"],
+      message: "Only numeric evidence may declare units"
+    });
+  }
+  requireCoverage({
+    expected: input.observationChecks.scope.sources.map(draftEvidenceReferenceKey),
+    actual: input.sources.map((item) => draftEvidenceReferenceKey(item.reference)),
+    path: "sources"
+  }, context3);
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, record] of input.admissions.entries()) {
+    const key3 = draftAdmissionKey(record);
+    if (seen.has(key3)) {
+      context3.addIssue({
+        code: "custom",
+        path: ["admissions", index],
+        message: "Duplicate admission scope"
+      });
+    }
+    seen.add(key3);
+  }
+}
+var DraftEvidenceMetadataSchema = evidenceShape.superRefine(checkMetadata);
+var DraftEvidenceValidationSchema = evidenceShape.extend({
+  normalization: z8.enum(["supplied", "malformed", "timeout", "review_required"]),
+  results: z8.array(z8.strictObject({ id: identifier5, result: DraftValueResultSchema })).max(64)
+}).superRefine((input, context3) => {
+  checkMetadata(input, context3);
+  requireCoverage({
+    expected: input.observationChecks.scope.observations.map((item) => item.id),
+    actual: input.results.map((item) => item.id),
+    path: "results"
+  }, context3);
+});
+
+// ../schemas/src/draft-pack-candidate.ts
+import { z as z9 } from "zod";
+var DraftPackCandidateSchema = z9.strictObject({
+  schema: z9.literal("felspar.pack-candidate.draft/v0"),
+  candidateId: z9.string().max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/@-]*$/u),
+  authority: DraftAuthoritySchema
+}).superRefine(({ authority }, context3) => {
+  const collections = [
+    { path: ["authority", "rules"], values: authority.rules },
+    { path: ["authority", "allowedOutcomes"], values: authority.allowedOutcomes },
+    {
+      path: ["authority", "definition", "allowedValues"],
+      values: authority.definition.allowedValues
+    }
+  ];
+  for (const { path: path3, values } of collections) {
+    if (values.length > 64) {
+      context3.addIssue({ code: "custom", path: path3, message: "Draft candidate limit is 64 entries" });
+    }
+  }
+});
+
+// ../schemas/src/draft-decision-run.ts
+var DraftDecisionRunSchema = z10.strictObject({
+  schema: z10.literal("felspar.decision-run.draft/v0"),
+  proposal: z10.strictObject({
+    candidate: DraftPackCandidateSchema,
+    evidencePolicy: z10.strictObject({
+      maxAgeMs: DraftObservationChecksSchema.shape.requirement.shape.maxAgeMs,
+      allowedSourceClasses: DraftEvidenceValidationSchema.shape.allowedSourceClasses,
+      trustDomain: DraftEvidenceValidationSchema.shape.trustDomain
+    }),
+    resolutionPolicy: z10.literal("strict-single-value/v1")
+  }),
+  evidence: DraftEvidenceValidationSchema
+}).superRefine(({ proposal }, context3) => {
+  const outcomes = /* @__PURE__ */ new Map();
+  for (const [index, rule3] of proposal.candidate.authority.rules.entries()) {
+    const prior = outcomes.get(rule3.when.equals);
+    if (prior !== void 0 && prior !== rule3.outcome) {
+      context3.addIssue({
+        code: "custom",
+        path: ["proposal", "candidate", "authority", "rules", index],
+        message: "Contradictory equality rules require resolved precedence before evaluation"
+      });
+    }
+    outcomes.set(rule3.when.equals, rule3.outcome);
+  }
+});
+
+// ../schemas/src/draft-required-predicates.ts
+import { z as z12 } from "zod";
+
+// ../schemas/src/draft-decision-date.ts
+import { z as z11 } from "zod";
+function isTimeZone(value) {
+  try {
+    const format = new Intl.DateTimeFormat("en-US", { timeZone: value });
+    const options = format.resolvedOptions();
+    return options.timeZone.length > 0;
+  } catch {
+    return false;
+  }
+}
+var DecisionDateComparisonSchema = z11.strictObject({
+  operator: z11.enum(["eq", "lt", "lte", "gt", "gte"]),
+  offsetDays: z11.number().int().min(-3660).max(3660),
+  timeZone: z11.string().min(1).max(64).regex(/^[A-Za-z][A-Za-z0-9_+/-]*$/u).refine(isTimeZone, "Unknown IANA time zone")
+});
+
+// ../schemas/src/draft-required-predicates.ts
+var base = DraftAuthoritySchema.shape.definition.omit({ allowedValues: true });
+var identifier6 = DraftEvidenceScopeSchema.shape.entityId;
+function isSupportedIntegerDomain(rule3) {
+  return !rule3.integer || rule3.minimum >= Number.MIN_SAFE_INTEGER && rule3.maximum <= Number.MAX_SAFE_INTEGER && Math.ceil(rule3.minimum) <= Math.floor(rule3.maximum);
+}
+var numeric = DraftValueRuleSchema.options[1].refine(isSupportedIntegerDomain, "Integer domain must contain safe integers only");
+var RequiredDefinitionSchema = z12.union([
+  base.extend({
+    allowedValues: z12.array(identifier6).min(1).max(64).refine(hasUniqueValues, "Duplicate value")
+  }),
+  base.extend({ valueRule: DraftValueRuleSchema.options[2] }),
+  base.extend({ valueRule: numeric, unit: identifier6 }),
+  base.extend({ valueRule: DraftValueRuleSchema.options[3] })
+]);
+var RequiredConditionSchema = z12.union([
+  z12.strictObject({ key: identifier6, relativeDate: RelativeDateComparisonSchema }),
+  z12.strictObject({ key: identifier6, relativeToDecision: DecisionDateComparisonSchema }),
+  z12.strictObject({ key: identifier6, equals: z12.union([identifier6, z12.boolean()]) }),
+  z12.strictObject({
+    key: identifier6,
+    oneOf: z12.array(identifier6).min(2).max(64).refine(hasUniqueValues, "Duplicate value")
+  }),
+  z12.strictObject({
+    key: identifier6,
+    compare: z12.strictObject({
+      operator: z12.enum(["eq", "lt", "lte", "gt", "gte"]),
+      value: z12.number()
+    })
+  }),
+  z12.strictObject({
+    key: identifier6,
+    compareFact: z12.strictObject({
+      operator: z12.enum(["eq", "lt", "lte", "gt", "gte"]),
+      key: identifier6
+    })
+  }),
+  z12.strictObject({
+    key: identifier6,
+    compareDate: z12.strictObject({
+      operator: z12.enum(["eq", "lt", "lte", "gt", "gte"]),
+      value: CalendarDateSchema
+    })
+  })
+]);
+function comparisonBounds(clause, definition3) {
+  if (!("valueRule" in definition3)) {
+    return null;
+  }
+  const rule3 = definition3.valueRule;
+  if (rule3.type === "number" && "compare" in clause) {
+    return { ...rule3, ...clause.compare };
+  }
+  if (rule3.type === "date" && "compareDate" in clause) {
+    return {
+      minimum: calendarDay("0001-01-01"),
+      maximum: calendarDay("9999-12-31"),
+      operator: clause.compareDate.operator,
+      value: calendarDay(clause.compareDate.value)
+    };
+  }
+  return null;
+}
+function interval(clause, definition3) {
+  const bounds = comparisonBounds(clause, definition3);
+  if (!bounds) {
+    return null;
+  }
+  const { minimum, maximum, operator, value } = 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
+  };
+}
+function nextNumber(value) {
+  if (value === 0) {
+    return Number.MIN_VALUE;
+  }
+  const view = new DataView(new ArrayBuffer(8));
+  view.setFloat64(0, value);
+  const bits = view.getBigUint64(0);
+  view.setBigUint64(0, value > 0 ? bits + 1n : bits - 1n);
+  return view.getFloat64(0);
+}
+function isNonempty(range2, isInteger) {
+  if (isInteger) {
+    const low = range2.lowClosed ? Math.ceil(range2.low) : Math.floor(range2.low) + 1;
+    const high = range2.highClosed ? Math.floor(range2.high) : Math.ceil(range2.high) - 1;
+    return low <= high;
+  }
+  const witness = range2.lowClosed ? range2.low : nextNumber(range2.low);
+  return witness < range2.high || witness === range2.high && range2.highClosed;
+}
+function areCompatibleFacts(left, right) {
+  if (!right || !("valueRule" in left) || !("valueRule" in right)) {
+    return false;
+  }
+  if (left.valueRule.type === "date") {
+    return right.valueRule.type === "date";
+  }
+  const areNumbers = left.valueRule.type === "number" && right.valueRule.type === "number";
+  const haveSameUnit = "unit" in left && "unit" in right && left.unit === right.unit;
+  return areNumbers && haveSameUnit;
+}
+function isConditionSupported(clause, definition3, definitions) {
+  if (!definition3) {
+    return false;
+  }
+  if ("relativeToDecision" in clause) {
+    return "valueRule" in definition3 && definition3.valueRule.type === "date";
+  }
+  if ("relativeDate" in clause) {
+    const anchor = definitions?.get(clause.relativeDate.anchorKey);
+    const isDate = "valueRule" in definition3 && definition3.valueRule.type === "date";
+    return clause.key !== clause.relativeDate.anchorKey && isDate && areCompatibleFacts(definition3, anchor);
+  }
+  if ("compareFact" in clause) {
+    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);
+  }
+  if (definition3.valueRule.type === "boolean") {
+    return "equals" in clause && typeof clause.equals === "boolean";
+  }
+  const range2 = interval(clause, definition3);
+  return range2 !== null && isNonempty(range2, definition3.valueRule.type === "date" || definition3.valueRule.integer);
+}
+function optionsOf(clause) {
+  if ("oneOf" in clause) {
+    return clause.oneOf;
+  }
+  return "equals" in clause ? [clause.equals] : null;
+}
+function relativeConditionsOverlap(left, right) {
+  if ("relativeDate" in left && "relativeDate" in right) {
+    const { operator: a, ...leftOffset } = left.relativeDate;
+    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 null;
+}
+function offsetSpace(clause) {
+  if ("relativeDate" in clause && clause.relativeDate.calendar.kind === "calendar_days") {
+    const { operator, anchorKey, offsetDays } = clause.relativeDate;
+    return { reference: `anchor:${anchorKey}`, operator, offsetDays };
+  }
+  if ("relativeToDecision" in clause) {
+    const { operator, timeZone, offsetDays } = clause.relativeToDecision;
+    return { reference: `decision:${timeZone}`, operator, offsetDays };
+  }
+  return null;
+}
+function offsetInterval(space) {
+  const { operator, offsetDays } = space;
+  return {
+    low: operator === "lt" || operator === "lte" ? -Infinity : offsetDays,
+    high: operator === "gt" || operator === "gte" ? Infinity : offsetDays,
+    lowClosed: operator !== "gt",
+    highClosed: operator !== "lt"
+  };
+}
+function intersection(a, b) {
+  const low = Math.max(a.low, b.low);
+  const high = Math.min(a.high, b.high);
+  return {
+    low,
+    high,
+    lowClosed: (low !== a.low || a.lowClosed) && (low !== b.low || b.lowClosed),
+    highClosed: (high !== a.high || a.highClosed) && (high !== b.high || b.highClosed)
+  };
+}
+function offsetConditionsOverlap(left, right) {
+  const relativeOverlap = relativeConditionsOverlap(left, right);
+  if (relativeOverlap !== null) {
+    return relativeOverlap;
+  }
+  const a = offsetSpace(left);
+  const b = offsetSpace(right);
+  return a !== null && b !== null && a.reference === b.reference ? isNonempty(intersection(offsetInterval(a), offsetInterval(b)), true) : null;
+}
+function areIntervalsOverlapping(a, b, definition3) {
+  if (a === null || b === null || !("valueRule" in definition3)) {
+    return true;
+  }
+  const rule3 = definition3.valueRule;
+  return rule3.type === "boolean" || isNonempty(intersection(a, b), rule3.type === "date" || rule3.integer);
+}
+function areConditionsOverlapping(left, right, definition3) {
+  if (!definition3) {
+    return true;
+  }
+  const offsetOverlap = offsetConditionsOverlap(left, right);
+  if (offsetOverlap !== null) {
+    return offsetOverlap;
+  }
+  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));
+  }
+  const leftValues = optionsOf(left);
+  const rightValues = optionsOf(right);
+  if (leftValues && rightValues) {
+    return leftValues.some((value) => rightValues.includes(value));
+  }
+  const a = interval(left, definition3);
+  const b = interval(right, definition3);
+  return areIntervalsOverlapping(a, b, definition3);
+}
+function operatorOf(clause) {
+  if ("compare" in clause) {
+    return clause.compare.operator;
+  }
+  if ("compareDate" in clause) {
+    return clause.compareDate.operator;
+  }
+  if ("relativeDate" in clause) {
+    return clause.relativeDate.operator;
+  }
+  return "relativeToDecision" in clause ? clause.relativeToDecision.operator : null;
+}
+function boundSide(clause) {
+  const sides = { gt: "lower", gte: "lower", lt: "upper", lte: "upper" };
+  return sides[operatorOf(clause) ?? ""] ?? null;
+}
+function isRange(group2, definition3) {
+  const [low, high] = group2;
+  if (low === void 0 || high === void 0 || group2.length !== 2) {
+    return false;
+  }
+  const sides = /* @__PURE__ */ new Set([boundSide(low), boundSide(high)]);
+  return sides.has("lower") && sides.has("upper") && areConditionsOverlapping(low, high, definition3);
+}
+function areKeysBounded(clauses2, definitions, canHaveRanges) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const clause of clauses2) {
+    byKey.set(clause.key, [...byKey.get(clause.key) ?? [], clause]);
+  }
+  const isAllowed = ([key3, group2]) => group2.length === 1 || canHaveRanges && isRange(group2, definitions.get(key3));
+  return [...byKey].every(isAllowed);
+}
+
+// ../schemas/src/draft-required-dependencies.ts
+var relationalResolutionPolicy = "relational-required-types/direct-overrides/v4";
+var scoredResolutionPolicy = "scored-required-types/mandatory-gates/v6";
+var windowedResolutionPolicy = "windowed-required-types/mandatory-gates/v7";
+function isWindowedPolicy(policy) {
+  return policy === windowedResolutionPolicy;
+}
+function isScoringPolicy(policy) {
+  return policy === scoredResolutionPolicy || isWindowedPolicy(policy);
+}
+function isRelativeDatePolicy(policy) {
+  return policy === relativeDateResolutionPolicy || isScoringPolicy(policy);
+}
+function isLayeredResolutionPolicy(policy) {
+  return policy === relationalResolutionPolicy || isRelativeDatePolicy(policy);
+}
+function conditionKeys(clause) {
+  if ("relativeDate" in clause) {
+    return [clause.key, clause.relativeDate.anchorKey];
+  }
+  return "compareFact" in clause ? [clause.key, clause.compareFact.key] : [clause.key];
+}
+function requirementLayers(requirements3) {
+  const keys = new Set(requirements3.map((item) => item.definition.key));
+  const done = /* @__PURE__ */ new Set();
+  let pending = [...requirements3];
+  const layers = [];
+  while (pending.length > 0) {
+    const layer = pending.filter((item) => {
+      const dependencies = (item.requiredWhen ?? []).flatMap(conditionKeys);
+      return dependencies.every((key3) => keys.has(key3) && done.has(key3));
+    });
+    if (layer.length === 0) {
+      throw new Error("Unknown or cyclic requirement activation");
+    }
+    layer.sort((left, right) => left.definition.key < right.definition.key ? -1 : 1);
+    layers.push(layer);
+    for (const item of layer) {
+      done.add(item.definition.key);
+    }
+    pending = pending.filter((item) => !done.has(item.definition.key));
+  }
+  return layers;
+}
+function activationGuards(key3, requirements3) {
+  const visited = /* @__PURE__ */ new Set();
+  const guards = [];
+  const visit = (current) => {
+    if (visited.has(current)) {
+      return;
+    }
+    visited.add(current);
+    const clauses2 = requirements3.get(current)?.requiredWhen;
+    if (!clauses2) {
+      return;
+    }
+    for (const clause of clauses2) {
+      guards.push(clause);
+      for (const dependency of conditionKeys(clause)) {
+        visit(dependency);
+      }
+    }
+  };
+  visit(key3);
+  return guards;
+}
+
+// ../schemas/src/draft-required-activation.ts
+var conditionalResolutionPolicy = "conditional-required-types/direct-overrides/v3";
+function clauseIdentity(clause) {
+  if ("relativeToDecision" in clause) {
+    return JSON.stringify([clause.key, "relativeToDecision", clause.relativeToDecision]);
+  }
+  if ("relativeDate" in clause) {
+    return JSON.stringify([clause.key, "relativeDate", clause.relativeDate]);
+  }
+  if ("compareFact" in clause) {
+    return JSON.stringify([
+      clause.key,
+      "fact",
+      clause.compareFact.operator,
+      clause.compareFact.key
+    ]);
+  }
+  if ("equals" in clause) {
+    return JSON.stringify([clause.key, "equals", clause.equals]);
+  }
+  if ("oneOf" in clause) {
+    return JSON.stringify([clause.key, "oneOf", clause.oneOf]);
+  }
+  const isNumeric = "compare" in clause;
+  const comparison = isNumeric ? clause.compare : clause.compareDate;
+  return JSON.stringify([
+    clause.key,
+    isNumeric ? "number" : "date",
+    comparison.operator,
+    comparison.value
+  ]);
+}
+function isSameClause(left, right) {
+  return clauseIdentity(left) === clauseIdentity(right);
+}
+function isPolicyValid(proposal, context3) {
+  const clauses2 = [
+    ...proposal.rules.flatMap((rule3) => rule3.when),
+    ...proposal.requirements.flatMap((item) => item.requiredWhen ?? [])
+  ];
+  if (clauses2.some((clause) => "relativeToDecision" in clause) && !isWindowedPolicy(proposal.resolutionPolicy)) {
+    context3.addIssue({
+      code: "custom",
+      message: "Decision-date windows require the v7 resolution policy"
+    });
+    return false;
+  }
+  const hasRelative = clauses2.some((clause) => "relativeDate" in clause);
+  if (hasRelative && !isRelativeDatePolicy(proposal.resolutionPolicy)) {
+    context3.addIssue({
+      code: "custom",
+      message: "Relative dates require a supporting resolution policy (v5 or v6)"
+    });
+    return false;
+  }
+  if (isLayeredResolutionPolicy(proposal.resolutionPolicy)) {
+    try {
+      requirementLayers(proposal.requirements);
+    } catch {
+      context3.addIssue({
+        code: "custom",
+        path: ["requirements"],
+        message: "Unknown or cyclic requirement activation"
+      });
+      return false;
+    }
+  } else if ([
+    ...proposal.rules.flatMap((rule3) => rule3.when),
+    ...proposal.requirements.flatMap((item) => item.requiredWhen ?? [])
+  ].some((clause) => "compareFact" in clause)) {
+    context3.addIssue({
+      code: "custom",
+      message: "Fact comparisons require the v4 resolution policy"
+    });
+  }
+  if (!isLayeredResolutionPolicy(proposal.resolutionPolicy) && [
+    ...proposal.rules.flatMap((rule3) => rule3.when),
+    ...proposal.requirements.flatMap((item) => item.requiredWhen ?? [])
+  ].some((clause) => "oneOf" in clause)) {
+    context3.addIssue({
+      code: "custom",
+      message: "Any-of conditions require a layered resolution policy (v4 or later)"
+    });
+  }
+  return true;
+}
+function inspectRuleGuards(proposal, context3) {
+  const requirements3 = new Map(proposal.requirements.map((item) => [item.definition.key, item]));
+  const isRelational = isLayeredResolutionPolicy(proposal.resolutionPolicy);
+  for (const [index, rule3] of proposal.rules.entries()) {
+    for (const clause of rule3.when) {
+      const gates = isRelational ? conditionKeys(clause).flatMap((key3) => activationGuards(key3, requirements3)) : requirements3.get(clause.key)?.requiredWhen ?? [];
+      if (gates.some((gate) => rule3.when.every((candidate2) => !isSameClause(gate, candidate2)))) {
+        context3.addIssue({
+          code: "custom",
+          path: ["rules", index],
+          message: "Conditional rule must include every exact activation predicate"
+        });
+      }
+    }
+  }
+}
+function inspectActivation(proposal, context3) {
+  const requirements3 = new Map(proposal.requirements.map((item) => [item.definition.key, item]));
+  const isRelational = isLayeredResolutionPolicy(proposal.resolutionPolicy);
+  const definitions = new Map(proposal.requirements.map((item) => [item.definition.key, item.definition]));
+  if (!isPolicyValid(proposal, context3)) {
+    return;
+  }
+  for (const [index, item] of proposal.requirements.entries()) {
+    const isDate = "valueRule" in item.definition && item.definition.valueRule.type === "date";
+    const fail = (message) => {
+      context3.addIssue({ code: "custom", path: ["requirements", index], message });
+    };
+    if (!isRelational && proposal.resolutionPolicy !== conditionalResolutionPolicy && (isDate || item.requiredWhen)) {
+      fail("Conditional requirements and dates require the v3 resolution policy");
+    }
+    if (!item.requiredWhen) {
+      continue;
+    }
+    if (!areKeysBounded(item.requiredWhen, definitions, isWindowedPolicy(proposal.resolutionPolicy))) {
+      fail("Duplicate activation key");
+    }
+    for (const clause of item.requiredWhen) {
+      const gate = requirements3.get(clause.key);
+      const isSupported = isConditionSupported(clause, gate?.definition, definitions);
+      if (!isSupported || !isRelational && gate?.requiredWhen) {
+        fail(isRelational ? "Activation requires supported predicates over declared, compatible requirements" : "Activation requires supported predicates over unconditional requirements");
+      }
+    }
+  }
+  inspectRuleGuards(proposal, context3);
+}
+
+// ../schemas/src/draft-scoring.ts
+import { z as z13 } from "zod";
+var identifier7 = DraftEvidenceScopeSchema.shape.entityId;
+var units = z13.number().int().min(0).max(1e9);
+var clauses = z13.array(RequiredConditionSchema).min(1).max(16);
+var source2 = {
+  sourceLocator: z13.string().min(1).max(4096).regex(/\S/u),
+  contentDigest: DraftSourceReferenceSchema.shape.contentDigest
+};
+var ScoringCriterionStatusSchema = z13.enum([
+  "matched",
+  "otherwise",
+  "inactive",
+  "unresolved"
+]);
+var contribution = z13.strictObject({
+  id: identifier7,
+  ...source2,
+  when: clauses,
+  pointsUnits: units
+});
+var criterion = z13.strictObject({
+  id: identifier7,
+  ...source2,
+  maximumUnits: units,
+  otherwiseUnits: units,
+  activeWhen: clauses.optional(),
+  cases: z13.array(contribution).min(1).max(16)
+});
+var DraftScoringPolicySchema = z13.strictObject({
+  schema: z13.literal("felspar.scoring.draft/v0"),
+  scale: z13.union([z13.literal(1), z13.literal(100), z13.literal(1e4)]),
+  missingPolicy: z13.literal("withhold_total"),
+  inactivePolicy: z13.literal("exclude_without_redistribution"),
+  criteria: z13.array(criterion).min(1).max(16)
+}).superRefine((policy, context3) => {
+  if (context3.issues.length > 0) {
+    return;
+  }
+  if (!hasUniqueValues(policy.criteria.map((row2) => row2.id))) {
+    context3.addIssue({ code: "custom", path: ["criteria"], message: "Duplicate criterion" });
+  }
+  for (const [index, row2] of policy.criteria.entries()) {
+    if (!hasUniqueValues(row2.cases.map((item) => item.id))) {
+      context3.addIssue({
+        code: "custom",
+        path: ["criteria", index, "cases"],
+        message: "Duplicate contribution case"
+      });
+    }
+    const maximum = Math.max(row2.otherwiseUnits, ...row2.cases.map((item) => item.pointsUnits));
+    if (maximum !== row2.maximumUnits) {
+      context3.addIssue({
+        code: "custom",
+        path: ["criteria", index, "maximumUnits"],
+        message: "Criterion maximum must equal its largest declared contribution"
+      });
+    }
+  }
+});
+
+// ../schemas/src/draft-scored-policy.ts
+import { z as z14 } from "zod";
+
+// ../schemas/src/draft-scoring-references.ts
+function hasClause(clauses2, expected2) {
+  return clauses2.some((clause) => JSON.stringify(clause) === JSON.stringify(expected2));
+}
+function mayOverlap(left, right, definitions) {
+  for (const clause of left) {
+    for (const other of right) {
+      if (clause.key === other.key && !areConditionsOverlapping(clause, other, definitions.get(clause.key))) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function clauseIssues(clause, scope2) {
+  const { active, definitions, byKey } = scope2;
+  const issues = [];
+  if ("relativeToDecision" in clause) {
+    issues.push("Scoring does not support decision-date windows");
+  }
+  if (!isConditionSupported(clause, definitions.get(clause.key), definitions)) {
+    issues.push("Scoring requires declared, compatible typed predicates");
+  }
+  for (const key3 of conditionKeys(clause)) {
+    if (activationGuards(key3, byKey).some((guard) => !hasClause(active, guard))) {
+      issues.push("Scoring applicability must include every exact requirement activation guard");
+    }
+  }
+  return issues;
+}
+function inspectScoringReferences(scoring, requirements3, context3) {
+  const definitions = new Map(requirements3.map((row2) => [row2.definition.key, row2.definition]));
+  const byKey = new Map(requirements3.map((row2) => [row2.definition.key, row2]));
+  for (const [index, criterion2] of scoring.criteria.entries()) {
+    const active = criterion2.activeWhen ?? [];
+    const fail = (message) => {
+      context3.addIssue({ code: "custom", path: ["criteria", index], message });
+    };
+    for (const clause of active) {
+      if (conditionKeys(clause).some((key3) => byKey.get(key3)?.requiredWhen)) {
+        fail("Scoring applicability requires unconditional requirements");
+      }
+    }
+    const all = [...active, ...criterion2.cases.flatMap((item) => item.when)];
+    for (const clause of all) {
+      const messages = clauseIssues(clause, { active, definitions, byKey });
+      for (const message of messages) {
+        fail(message);
+      }
+    }
+    for (const [caseIndex, item] of criterion2.cases.entries()) {
+      if (criterion2.cases.slice(caseIndex + 1).some((other) => mayOverlap(item.when, other.when, definitions))) {
+        fail("Scoring contribution cases must be provably disjoint");
+      }
+    }
+  }
+}
+
+// ../schemas/src/draft-scored-policy.ts
+var ScoreRangeSchema = z14.strictObject({
+  minimumUnits: z14.number().int().min(0).max(16e9),
+  maximumUnits: z14.number().int().min(0).max(16e9)
+});
+function isScoredProposal(proposal) {
+  return isWindowedPolicy(proposal.resolutionPolicy) ? proposal.scoring !== void 0 || proposal.mandatoryGateRuleIds !== void 0 : proposal.resolutionPolicy === scoredResolutionPolicy;
+}
+function inspectScoredPolicy(proposal, context3) {
+  const { scoring, mandatoryGateRuleIds: gates, rules: rules2 } = proposal;
+  const fail = (message) => {
+    context3.addIssue({ code: "custom", message });
+  };
+  if (!isScoredProposal(proposal)) {
+    if (Boolean(scoring) || Boolean(gates) || rules2.some((rule3) => Boolean(rule3.scoreRange) || rule3.when.length === 0)) {
+      fail(isWindowedPolicy(proposal.resolutionPolicy) ? "Score-only rules require scoring" : "Scoring and score-only rules require the v6 resolution policy");
+    }
+    return;
+  }
+  if (!scoring || !gates) {
+    fail("Scored policy requires scoring and explicit mandatory gate identities");
+    return;
+  }
+  inspectScoringReferences(scoring, proposal.requirements, context3);
+  const ids3 = new Set(rules2.map((rule3) => rule3.id));
+  if (gates.some((id11) => !ids3.has(id11))) {
+    fail("Unknown mandatory gate rule");
+  }
+  if (rules2.every((rule3) => gates.includes(rule3.id))) {
+    fail("Scored policy requires at least one score-band rule");
+  }
+  const maximum = scoring.criteria.reduce((sum, row2) => sum + row2.maximumUnits, 0);
+  for (const rule3 of rules2) {
+    const isGate = gates.includes(rule3.id);
+    const hasRange = rule3.scoreRange !== void 0;
+    if (isGate ? hasRange || rule3.when.length === 0 : !hasRange) {
+      fail("Mandatory gates require fact predicates only; other rules require score ranges");
+    }
+    if (rule3.overrides.some((id11) => gates.includes(id11) !== isGate)) {
+      fail("Explicit overrides cannot cross mandatory-gate and score-band classes");
+    }
+    const range2 = rule3.scoreRange;
+    if (range2 && (range2.minimumUnits > range2.maximumUnits || range2.maximumUnits > maximum)) {
+      fail("Score range must be ordered within the fixed maximum units");
+    }
+  }
+}
+function areScoredRulesDisjoint(proposal, left, right) {
+  if (!isScoredProposal(proposal)) {
+    return false;
+  }
+  const gates = proposal.mandatoryGateRuleIds ?? [];
+  if (gates.includes(left.id) !== gates.includes(right.id)) {
+    return true;
+  }
+  return Boolean(left.scoreRange && right.scoreRange && (left.scoreRange.maximumUnits < right.scoreRange.minimumUnits || right.scoreRange.maximumUnits < left.scoreRange.minimumUnits));
+}
+
+// ../schemas/src/draft-required-decision.ts
+var typedResolutionPolicy = "strict-required-types/direct-overrides/v2";
+var identifier8 = DraftEvidenceScopeSchema.shape.entityId;
+var duplicateIdentity = "Duplicate identity";
+var uniqueIds = z15.array(identifier8).max(64).refine(hasUniqueValues, duplicateIdentity);
+var definition2 = RequiredDefinitionSchema;
+var rule2 = z15.strictObject({
+  id: identifier8,
+  sourceLocator: z15.string().min(1).max(4096).regex(/\S/u),
+  contentDigest: DraftSourceReferenceSchema.shape.contentDigest,
+  when: z15.array(RequiredConditionSchema).max(32),
+  scoreRange: ScoreRangeSchema.optional(),
+  outcome: identifier8,
+  overrides: z15.array(identifier8).max(256).refine(hasUniqueValues, duplicateIdentity),
+  priority: z15.number().int().min(0).max(1e6).optional()
+});
+var shape = z15.strictObject({
+  schema: z15.literal("felspar.required-decision.draft/v0"),
+  proposal: z15.strictObject({
+    candidateId: identifier8,
+    source: DraftSourceReferenceSchema,
+    job: identifier8,
+    trustDomain: identifier8,
+    resolutionPolicy: z15.enum([
+      "strict-required-values/direct-overrides/v1",
+      typedResolutionPolicy,
+      conditionalResolutionPolicy,
+      relationalResolutionPolicy,
+      relativeDateResolutionPolicy,
+      scoredResolutionPolicy,
+      windowedResolutionPolicy
+    ]),
+    scoring: DraftScoringPolicySchema.optional(),
+    mandatoryGateRuleIds: uniqueIds.optional(),
+    requirements: z15.array(z15.strictObject({
+      definition: definition2,
+      requiredWhen: z15.array(RequiredConditionSchema).min(1).max(16).optional(),
+      evidencePolicy: DraftDecisionRunSchema.shape.proposal.shape.evidencePolicy
+    })).min(1).max(64),
+    allowedOutcomes: uniqueIds.min(1),
+    rules: z15.array(rule2).min(1).max(256)
+  }),
+  scope: z15.strictObject({
+    entityId: identifier8,
+    evaluationTime: DraftObservationChecksSchema.shape.evaluationTime
+  }),
+  evidence: z15.array(DraftEvidenceValidationSchema).max(64)
+});
+function hasOverlap(left, right, definitions) {
+  for (const clause of left.when) {
+    for (const other of right.when) {
+      if (clause.key === other.key && !areConditionsOverlapping(clause, other, definitions.get(clause.key))) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function draftRulePriority(ranked) {
+  return ranked.priority ?? 0;
+}
+function hasDraftRulePrecedence(winner, other) {
+  return winner.overrides.includes(other.id) || draftRulePriority(winner) > draftRulePriority(other);
+}
+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 = (id11) => {
+    if (visiting.has(id11)) {
+      return true;
+    }
+    if (visited.has(id11)) {
+      return false;
+    }
+    visiting.add(id11);
+    if ((graph.get(id11) ?? []).some(hasPathCycle)) {
+      return true;
+    }
+    visiting.delete(id11);
+    visited.add(id11);
+    return false;
+  };
+  return rules2.some((item) => hasPathCycle(item.id));
+}
+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]));
+  for (const [index, item] of rules2.entries()) {
+    const fail = (message) => {
+      context3.addIssue({
+        code: "custom",
+        path: ["rules", index],
+        message
+      });
+    };
+    if (!allowedOutcomes.includes(item.outcome)) {
+      fail("Undeclared outcome");
+    }
+    if (!areKeysBounded(item.when, definitions, isWindowedPolicy(proposal.resolutionPolicy))) {
+      fail("Duplicate condition key");
+    }
+    for (const clause of item.when) {
+      if (!isConditionSupported(clause, definitions.get(clause.key), definitions)) {
+        fail("Undeclared condition key or value");
+      }
+    }
+    if (item.overrides.some((id11) => id11 === item.id || !ids3.has(id11))) {
+      fail("Unknown or self override");
+    }
+    if (item.overrides.some((id11) => {
+      const target = byId.get(id11);
+      return target !== void 0 && draftRulePriority(target) > 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");
+      }
+    }
+  }
+  if (hasCycle(rules2)) {
+    context3.addIssue({ code: "custom", path: ["rules"], message: "Override cycle" });
+  }
+}
+var DraftRequiredProposalSchema = shape.shape.proposal.superRefine((proposal, context3) => {
+  if (context3.issues.length > 0) {
+    return;
+  }
+  const keys = proposal.requirements.map((item) => item.definition.key);
+  const ids3 = proposal.rules.map((item) => item.id);
+  for (const [values, path3] of [
+    [keys, "requirements"],
+    [ids3, "rules"]
+  ]) {
+    if (!hasUniqueValues(values)) {
+      context3.addIssue({ code: "custom", path: [path3], message: duplicateIdentity });
+    }
+  }
+  for (const [index, requirement] of proposal.requirements.entries()) {
+    if (requirement.evidencePolicy.trustDomain !== proposal.trustDomain) {
+      context3.addIssue({
+        code: "custom",
+        path: ["requirements", index],
+        message: "Requirement trust domain differs from job"
+      });
+    }
+  }
+  if (proposal.resolutionPolicy === "strict-required-values/direct-overrides/v1" && proposal.requirements.some((item) => !("allowedValues" in item.definition))) {
+    context3.addIssue({
+      code: "custom",
+      message: "Typed requirements need the typed resolution policy"
+    });
+  }
+  inspectScoredPolicy(proposal, context3);
+  inspectActivation(proposal, context3);
+  inspectRules(proposal, context3);
+});
+function requiredEvidenceBindingIssues(evidence, keys) {
+  const supplied = evidence.map((item) => item.observationChecks.requirement.key);
+  const issues = [];
+  if (!hasUniqueValues(supplied)) {
+    issues.push({ code: "custom", path: ["evidence"], message: duplicateIdentity });
+  }
+  if (supplied.some((key3) => !keys.has(key3))) {
+    issues.push({ code: "custom", path: ["evidence"], message: "Unexpected requirement evidence" });
+  }
+  return issues;
+}
+var DraftRequiredDecisionSchema = shape.extend({
+  proposal: DraftRequiredProposalSchema
+}).superRefine((input, context3) => {
+  if (context3.issues.length > 0) {
+    return;
+  }
+  const keys = new Set(input.proposal.requirements.map((item) => item.definition.key));
+  for (const issue of requiredEvidenceBindingIssues(input.evidence, keys)) {
+    context3.addIssue(issue);
+  }
+});
+
+// ../schemas/src/draft-authority-origins.ts
+import { z as z17 } from "zod";
+
+// ../schemas/src/draft-decision-case.ts
+import { z as z16 } from "zod";
+var identifier9 = z16.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/@-]*$/u);
+var text2 = z16.string().regex(/\S/u);
+var digest4 = z16.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var timestamp2 = z16.iso.datetime().regex(/T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/u);
+var identifiers2 = z16.array(identifier9).min(1);
+var unknownDefinition2 = "Unknown definition key";
+var observation = z16.strictObject({
+  id: identifier9,
+  key: identifier9,
+  value: identifier9,
+  definitionDigest: digest4,
+  observedAt: timestamp2,
+  evidence: DraftSourceReferenceSchema.extend({ entityId: identifier9, locator: text2 }),
+  interpretation: z16.strictObject({ method: z16.literal("manual"), actorId: identifier9 })
+});
+var expected = z16.discriminatedUnion("state", [
+  z16.strictObject({
+    state: z16.literal("ready"),
+    outcome: identifier9,
+    ruleId: identifier9,
+    observationIds: identifiers2,
+    reason: text2
+  }),
+  z16.strictObject({
+    state: z16.literal("gap"),
+    outcome: z16.null(),
+    key: identifier9,
+    reason: text2
+  }),
+  z16.strictObject({
+    state: z16.literal("conflict"),
+    outcome: z16.null(),
+    observationIds: identifiers2.min(2),
+    reason: text2
+  })
+]);
+var shape2 = z16.strictObject({
+  schema: z16.literal("felspar.decision-case.draft/v0"),
+  caseId: identifier9,
+  entityId: identifier9,
+  evaluatedAt: timestamp2,
+  authority: DraftAuthoritySchema,
+  observations: z16.array(observation),
+  expected
+});
+function requireBinding2(isValid, context3, issue) {
+  if (!isValid) {
+    context3.addIssue({ code: "custom", ...issue });
+  }
+}
+function unique2(values, context3, path3) {
+  const distinct = new Set(values);
+  requireBinding2(distinct.size === values.length, context3, {
+    path: path3,
+    message: "Duplicate identity/value"
+  });
+}
+function checkObservations(candidate2, context3) {
+  const { authority, observations } = candidate2;
+  unique2(observations.map((entry2) => entry2.id), context3, ["observations"]);
+  for (const [index, entry2] of observations.entries()) {
+    const at = ["observations", index];
+    requireBinding2(entry2.key === authority.definition.key, context3, {
+      path: [...at, "key"],
+      message: unknownDefinition2
+    });
+    requireBinding2(authority.definition.allowedValues.includes(entry2.value), context3, {
+      path: [...at, "value"],
+      message: "Unknown definition value"
+    });
+    requireBinding2(entry2.definitionDigest === authority.definition.contentDigest, context3, {
+      path: [...at, "definitionDigest"],
+      message: "Definition fingerprint mismatch"
+    });
+    requireBinding2(entry2.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, {
+      path: [...at, "observedAt"],
+      message: "Observation is later than evaluation"
+    });
+  }
+}
+function checkExpected(candidate2, context3) {
+  const result = candidate2.expected;
+  if (result.state === "gap") {
+    requireBinding2(result.key === candidate2.authority.definition.key, context3, {
+      path: ["expected", "key"],
+      message: unknownDefinition2
+    });
+    return;
+  }
+  unique2(result.observationIds, context3, ["expected", "observationIds"]);
+  const observationIds = new Set(candidate2.observations.map((entry2) => entry2.id));
+  for (const [index, id11] of result.observationIds.entries()) {
+    requireBinding2(observationIds.has(id11), context3, {
+      path: ["expected", "observationIds", index],
+      message: "Unknown observation"
+    });
+  }
+  if (result.state !== "ready") {
+    return;
+  }
+  requireBinding2(candidate2.authority.allowedOutcomes.includes(result.outcome), context3, {
+    path: ["expected", "outcome"],
+    message: "Unknown outcome"
+  });
+  requireBinding2(candidate2.authority.rules.some((entry2) => entry2.id === result.ruleId), context3, { path: ["expected", "ruleId"], message: "Unknown rule" });
+}
+var DraftDecisionCaseSchema = shape2.superRefine((candidate2, context3) => {
+  checkObservations(candidate2, context3);
+  checkExpected(candidate2, context3);
+});
+
+// ../schemas/src/draft-authority-origins.ts
+var text3 = z17.string().max(4096).regex(/\S/u);
+var path = z17.string().max(512).regex(/^\/authority\//u);
+var digest5 = z17.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var DraftAuthorityOriginSchema = z17.discriminatedUnion("kind", [
+  z17.strictObject({
+    kind: z17.literal("source_derived"),
+    source: DraftSourceReferenceSchema,
+    locator: text3,
+    passageDigest: digest5,
+    admissionRef: text3
+  }),
+  z17.strictObject({
+    kind: z17.literal("owner_decision"),
+    actorId: text3,
+    decidedAt: z17.iso.datetime().regex(/T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/u),
+    reviewRef: text3
+  }),
+  z17.strictObject({
+    kind: z17.literal("deterministic_derivation"),
+    transform: z17.strictObject({ id: text3, version: text3, contentDigest: digest5 }),
+    inputs: z17.array(path).min(1).max(130)
+  }),
+  z17.strictObject({ kind: z17.literal("unsupported_suggestion"), reason: text3 })
+]);
+var entries = z17.array(z17.strictObject({ path, origin: DraftAuthorityOriginSchema })).max(130);
+var DraftAuthorityOriginsSchema = z17.strictObject({
+  schema: z17.literal("felspar.authority-origins.draft/v0"),
+  caseId: text3,
+  entries
+});
+var DraftCandidateOriginsSchema = z17.strictObject({
+  schema: z17.literal("felspar.candidate-origins.draft/v0"),
+  candidateId: DraftPackCandidateSchema.shape.candidateId,
+  candidateDigest: digest5,
+  entries
+});
+
+// ../schemas/src/draft-required-normalization.ts
+import { z as z25 } from "zod";
+
+// ../schemas/src/draft-normalized-evidence.ts
+import { z as z24 } from "zod";
+
+// ../schemas/src/draft-semantic-bundle.ts
+import { z as z23 } from "zod";
+
+// ../schemas/src/draft-source-compositions.ts
+import { z as z22 } from "zod";
+
+// ../schemas/src/draft-candidate-compilation.ts
+import { z as z20 } from "zod";
+
+// ../schemas/src/draft-compiled-decision.ts
+import { z as z19 } from "zod";
+
+// ../schemas/src/draft-scoring-expectations.ts
+import { z as z18 } from "zod";
+var identifier10 = DraftEvidenceScopeSchema.shape.entityId;
+var DraftScoringExpectationSchema = z18.strictObject({
+  status: z18.enum(["ready", "unresolved"]),
+  scale: z18.union([z18.literal(1), z18.literal(100), z18.literal(1e4)]),
+  maximumUnits: z18.number().int().min(0).max(16e9),
+  totalUnits: z18.number().int().min(0).max(16e9).nullable(),
+  criteria: z18.array(z18.strictObject({
+    criterionId: identifier10,
+    status: ScoringCriterionStatusSchema,
+    pointsUnits: z18.number().int().min(0).max(1e9).nullable(),
+    matchedCaseId: identifier10.nullable()
+  })).min(1).max(16).refine((rows) => hasUniqueValues(rows.map((row2) => row2.criterionId)), "Duplicate scoring expectation identity")
+});
+
+// ../schemas/src/draft-compiled-decision.ts
+var identifier11 = DraftEvidenceScopeSchema.shape.entityId;
+var digest6 = DraftSourceReferenceSchema.shape.contentDigest;
+var draftCompilerContract = "felspar.local-draft-compiler/v1";
+var draftRequiredRuntimeContract = "felspar.required-decision-run/v1";
+var typedCompilerContract = "felspar.local-typed-draft-compiler/v1";
+var typedRuntimeContract = "felspar.required-typed-decision-run/v1";
+var conditionalCompilerContract = "felspar.local-conditional-draft-compiler/v1";
+var conditionalRuntimeContract = "felspar.required-conditional-decision-run/v1";
+var relationalCompilerContract = "felspar.local-relational-draft-compiler/v1";
+var relationalRuntimeContract = "felspar.required-relational-decision-run/v1";
+var relativeDateCompilerContract = "felspar.local-relative-date-draft-compiler/v1";
+var relativeDateRuntimeContract = "felspar.required-relative-date-decision-run/v1";
+var scoredCompilerContract = "felspar.local-scored-draft-compiler/v1";
+var scoredRuntimeContract = "felspar.required-scored-decision-run/v1";
+var windowedCompilerContract = "felspar.local-windowed-draft-compiler/v1";
+var windowedRuntimeContract = "felspar.required-windowed-decision-run/v1";
+function requiredContracts(policy) {
+  if (policy === windowedResolutionPolicy) {
+    return { compilerContract: windowedCompilerContract, runtimeContract: windowedRuntimeContract };
+  }
+  if (policy === scoredResolutionPolicy) {
+    return { compilerContract: scoredCompilerContract, runtimeContract: scoredRuntimeContract };
+  }
+  if (policy === relativeDateResolutionPolicy) {
+    return {
+      compilerContract: relativeDateCompilerContract,
+      runtimeContract: relativeDateRuntimeContract
+    };
+  }
+  if (policy === relationalResolutionPolicy) {
+    return {
+      compilerContract: relationalCompilerContract,
+      runtimeContract: relationalRuntimeContract
+    };
+  }
+  if (policy === conditionalResolutionPolicy) {
+    return {
+      compilerContract: conditionalCompilerContract,
+      runtimeContract: conditionalRuntimeContract
+    };
+  }
+  return policy === typedResolutionPolicy ? { compilerContract: typedCompilerContract, runtimeContract: typedRuntimeContract } : { compilerContract: draftCompilerContract, runtimeContract: draftRequiredRuntimeContract };
+}
+var expectation = z19.strictObject({
+  scoring: DraftScoringExpectationSchema.optional(),
+  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";
+  if (isReady ? !hasOutcome || !hasRules : hasOutcome || hasRules) {
+    context3.addIssue({
+      code: "custom",
+      message: "Outcome and selected rules require ready status"
+    });
+  }
+});
+var fixtureIdentity = {
+  id: identifier11,
+  scope: DraftRequiredDecisionSchema.shape.scope,
+  expected: expectation
+};
+var DraftEvidenceFixtureSchema = z19.strictObject({
+  ...fixtureIdentity,
+  evidence: DraftRequiredDecisionSchema.shape.evidence
+});
+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")
+});
+var DraftAnyCompilationFixtureSchema = z19.union([
+  DraftEvidenceFixtureSchema,
+  DraftFactFixtureSchema
+]);
+function fixtureList(fixtures) {
+  return z19.array(fixtures).min(1).max(200).refine((rows) => hasUniqueValues(rows.map((item) => item.id)), "Duplicate fixture identity");
+}
+function checkCompilation(input, context3) {
+  const isScored = isScoredProposal(input.proposal);
+  const keys = new Set(input.proposal.requirements.map((item) => item.definition.key));
+  for (const [index, fixture] of input.fixtures.entries()) {
+    if ("facts" in fixture && fixture.facts.some((fact) => !keys.has(fact.key))) {
+      context3.addIssue({
+        code: "custom",
+        path: ["fixtures", index, "facts"],
+        message: "Every fixture fact must name a proposal requirement"
+      });
+    }
+    if (Boolean(fixture.expected.scoring) !== isScored) {
+      context3.addIssue({
+        code: "custom",
+        path: ["fixtures", index, "expected"],
+        message: "Scoring expectations are required exactly for scored policies"
+      });
+    }
+  }
+}
+var compilationVersion = z19.literal("felspar.compilation.draft/v0");
+var DraftCompilationSchema = z19.strictObject({
+  schema: compilationVersion,
+  proposal: DraftRequiredProposalSchema,
+  fixtures: fixtureList(DraftEvidenceFixtureSchema)
+}).superRefine(checkCompilation);
+var DraftAnyCompilationSchema = z19.strictObject({
+  schema: compilationVersion,
+  proposal: DraftRequiredProposalSchema,
+  fixtures: fixtureList(DraftAnyCompilationFixtureSchema)
+}).superRefine(checkCompilation);
+var DraftCompiledBodySchema = z19.strictObject({
+  schema: z19.literal("felspar.compiled-decision.draft/v0"),
+  authority: z19.literal("unapproved"),
+  compilerContract: z19.enum([
+    draftCompilerContract,
+    typedCompilerContract,
+    conditionalCompilerContract,
+    relationalCompilerContract,
+    relativeDateCompilerContract,
+    scoredCompilerContract,
+    windowedCompilerContract
+  ]),
+  runtimeContract: z19.enum([
+    draftRequiredRuntimeContract,
+    typedRuntimeContract,
+    conditionalRuntimeContract,
+    relationalRuntimeContract,
+    relativeDateRuntimeContract,
+    scoredRuntimeContract,
+    windowedRuntimeContract
+  ]),
+  proposal: DraftRequiredProposalSchema,
+  policyDigest: digest6,
+  fixtureSuiteDigest: digest6
+}).superRefine((body, context3) => {
+  const expected2 = requiredContracts(body.proposal.resolutionPolicy);
+  if (body.compilerContract !== expected2.compilerContract || body.runtimeContract !== expected2.runtimeContract) {
+    context3.addIssue({
+      code: "custom",
+      message: "Compiler/runtime identity differs from policy semantics"
+    });
+  }
+});
+var DraftCompiledArtifactSchema = z19.strictObject({
+  format: z19.literal("felspar.json-content-identity/v1"),
+  canonicalJson: z19.string().min(1).max(1048576),
+  contentDigest: digest6
+});
+var DraftCompiledRequestSchema = z19.strictObject({
+  schema: z19.literal("felspar.compiled-request.draft/v0"),
+  expectedArtifactDigest: digest6,
+  job: identifier11,
+  trustDomain: identifier11,
+  scope: DraftRequiredDecisionSchema.shape.scope,
+  evidence: DraftRequiredDecisionSchema.shape.evidence
+});
+var DraftCompiledInvocationSchema = z19.strictObject({
+  artifact: DraftCompiledArtifactSchema,
+  request: DraftCompiledRequestSchema
+});
+var DraftVerifiedCompilationSchema = z19.strictObject({
+  schema: z19.literal("felspar.verified-compilation.draft/v0"),
+  engineVersion: digest6,
+  policyDigest: digest6,
+  fixtureSuiteDigest: digest6
+});
+
+// ../schemas/src/draft-candidate-compilation.ts
+var draftCandidateTransform = "felspar.single-value-candidate-to-required/v1";
+var DraftCandidateCompilationSchema = z20.strictObject({
+  schema: z20.literal("felspar.candidate-compilation.draft/v0"),
+  proposal: DraftDecisionRunSchema.shape.proposal,
+  fixtures: DraftCompilationSchema.shape.fixtures
+});
+var digest7 = DraftCompiledArtifactSchema.shape.contentDigest;
+var DraftCandidateCompilationBindingSchema = z20.strictObject({
+  schema: z20.literal("felspar.candidate-compilation-binding.draft/v0"),
+  authority: z20.literal("unapproved"),
+  transformContract: z20.literal(draftCandidateTransform),
+  candidateDigest: digest7,
+  proposalDigest: digest7,
+  policyDigest: digest7,
+  fixtureSuiteDigest: digest7,
+  artifactDigest: digest7
+});
+var DraftCandidateCompilationVerificationSchema = z20.strictObject({
+  proposal: DraftDecisionRunSchema.shape.proposal,
+  fixtures: DraftCompilationSchema.shape.fixtures,
+  artifact: DraftCompiledArtifactSchema,
+  binding: DraftCompiledArtifactSchema
+});
+
+// ../schemas/src/draft-source-bindings.ts
+import { z as z21 } from "zod";
+var maxDepth = 8;
+var caseNodeLimit = 8192;
+var bundleNodeLimit = 65536;
+function boundedDraftInput(limits2) {
+  return z21.unknown().transform((input, context3) => {
+    let nodes = 0;
+    let text7 = 0;
+    const budgetError = new Error("Draft input budget exceeded or non-data input");
+    function copy(value, depth) {
+      nodes += 1;
+      if (nodes > limits2.nodes || depth > maxDepth) {
+        throw budgetError;
+      }
+      if (typeof value === "string") {
+        text7 += value.length;
+        if (value.length > limits2.stringLength || text7 > limits2.totalText) {
+          throw budgetError;
+        }
+        return value;
+      }
+      if (value === null || typeof value !== "object") {
+        return value;
+      }
+      const isArray = Array.isArray(value);
+      const prototype = Object.getPrototypeOf(value);
+      if (prototype !== null && prototype !== (isArray ? Array.prototype : Object.prototype)) {
+        throw budgetError;
+      }
+      if (isArray && value.length > limits2.arrayLength) {
+        throw budgetError;
+      }
+      const output = isArray ? Array.from({ length: value.length }) : {};
+      let properties = 0;
+      for (const key3 in value) {
+        if (!Object.hasOwn(value, key3)) {
+          continue;
+        }
+        properties += 1;
+        if (properties > (isArray ? limits2.arrayLength : 32)) {
+          throw budgetError;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(value, key3);
+        if (!descriptor || !("value" in descriptor)) {
+          throw budgetError;
+        }
+        copy(key3, depth + 1);
+        Object.defineProperty(output, key3, {
+          value: copy(descriptor.value, depth + 1),
+          enumerable: true,
+          configurable: true,
+          writable: true
+        });
+      }
+      return output;
+    }
+    try {
+      return copy(input, 0);
+    } catch (error) {
+      if (error !== budgetError) {
+        throw error;
+      }
+      context3.addIssue({ code: "custom", message: budgetError.message });
+      return z21.NEVER;
+    }
+  });
+}
+var isUnicodeText = (value) => !/[\uD800-\uDFFF]/u.test(value);
+var isSplitCharacter = (text7, offset) => offset > 0 && offset < text7.length && /[\uDC00-\uDFFF]/u.test(text7.charAt(offset));
+var sourceText = DraftSourceReferenceSchema.omit({ contentDigest: true }).extend({
+  text: z21.string().min(1).max(1048576).refine(isUnicodeText, "Lone Unicode surrogate"),
+  offsetUnit: z21.literal("utf16_code_units"),
+  passages: z21.array(z21.strictObject({
+    locator: z21.string().regex(/\S/u),
+    start: z21.number().int().nonnegative(),
+    end: z21.number().int().positive()
+  })).max(1024)
+});
+var sourceKey = (source3) => JSON.stringify([source3.sourceId, source3.revision]);
+var sourceBundle = z21.strictObject({
+  schema: z21.literal("felspar.source-text-bundle.draft/v0"),
+  sources: z21.array(sourceText).max(32)
+}).superRefine((bundle, context3) => {
+  const identities = /* @__PURE__ */ new Set();
+  for (const [sourceIndex, source3] of bundle.sources.entries()) {
+    const at = ["sources", sourceIndex];
+    const identity = sourceKey(source3);
+    if (identities.has(identity)) {
+      context3.addIssue({ code: "custom", path: at, message: "Duplicate source/revision" });
+    }
+    identities.add(identity);
+    const locators2 = /* @__PURE__ */ new Set();
+    for (const [index, passage4] of source3.passages.entries()) {
+      const path3 = [...at, "passages", index];
+      if (locators2.has(passage4.locator)) {
+        context3.addIssue({ code: "custom", path: path3, message: "Duplicate passage locator" });
+      }
+      locators2.add(passage4.locator);
+      if (passage4.start >= passage4.end || passage4.end > source3.text.length) {
+        context3.addIssue({ code: "custom", path: path3, message: "Passage is outside source text" });
+      } else if (isSplitCharacter(source3.text, passage4.start) || isSplitCharacter(source3.text, passage4.end)) {
+        context3.addIssue({ code: "custom", path: path3, message: "Passage splits a Unicode character" });
+      }
+    }
+  }
+});
+var DraftSourceTextBundleSchema = boundedDraftInput({
+  arrayLength: 1024,
+  stringLength: 1048576,
+  totalText: 33554432,
+  nodes: bundleNodeLimit
+}).pipe(sourceBundle);
+var boundedCase = boundedDraftInput({
+  arrayLength: 64,
+  stringLength: 4096,
+  totalText: 262144,
+  nodes: caseNodeLimit
+}).pipe(DraftDecisionCaseSchema);
+var inputBudgetMessage = "Draft input budget exceeded";
+var caseJson = z21.string().max(262144, inputBudgetMessage);
+var bundleJson = z21.string().max(33554432, inputBudgetMessage);
+
+// ../schemas/src/draft-source-compositions.ts
+var locator = z22.string().min(1).max(200).regex(/\S/u);
+var draftSourceCompositionContract = "felspar.ordered-source-passage-join/v1";
+var DraftSourceCompositionsSchema = z22.strictObject({
+  schema: z22.literal("felspar.source-compositions.draft/v0"),
+  transformContract: z22.literal(draftSourceCompositionContract),
+  candidateDigest: DraftSourceReferenceSchema.shape.contentDigest,
+  entries: z22.array(z22.strictObject({
+    source: DraftSourceReferenceSchema.omit({ contentDigest: true }),
+    locator,
+    parts: z22.array(locator).min(2).max(16),
+    separator: z22.enum(["", "\n", "\n\n"])
+  })).max(64)
+});
+var DraftComposedSourceVerificationSchema = z22.strictObject({
+  candidate: DraftPackCandidateSchema,
+  bundle: DraftSourceTextBundleSchema,
+  compositions: DraftSourceCompositionsSchema
+});
+var DraftSourceBoundCompilationSchema = z22.strictObject({
+  compilation: DraftCandidateCompilationSchema,
+  bundle: DraftSourceTextBundleSchema,
+  compositions: DraftSourceCompositionsSchema
+});
+
+// ../schemas/src/draft-semantic-bundle.ts
+var text4 = z23.string().min(1).max(16384).regex(/\S/u);
+var identifier12 = z23.string().min(1).max(200).regex(/\S/u);
+var semanticGuidanceFields = [
+  "inclusions",
+  "exclusions",
+  "examples",
+  "edgeCases"
+];
+var locators = z23.array(identifier12).max(16).refine((items) => {
+  const unique4 = new Set(items);
+  return unique4.size === items.length;
+}, "Duplicate guidance locator");
+var DraftSemanticProposalSchema = z23.strictObject({
+  values: z23.array(z23.strictObject({
+    value: identifier12,
+    definitionLocator: identifier12,
+    inclusions: locators,
+    exclusions: locators,
+    examples: locators,
+    edgeCases: locators
+  })).min(1).max(64),
+  normalization: z23.strictObject({
+    id: identifier12,
+    version: identifier12,
+    instructions: text4
+  })
+});
+var DraftSemanticBundleInputSchema = z23.strictObject({
+  source: DraftComposedSourceVerificationSchema,
+  proposal: DraftSemanticProposalSchema
+});
+var excerpt = z23.strictObject({ locator: identifier12, body: text4 });
+var excerpts = z23.array(excerpt).max(16);
+var digest8 = DraftSourceReferenceSchema.shape.contentDigest;
+var DraftSemanticBundleSchema = z23.strictObject({
+  schema: z23.literal("felspar.semantic-bundle.draft/v0"),
+  authority: z23.literal("unapproved"),
+  candidateDigest: digest8,
+  sourceBundleDigest: digest8,
+  compositionsDigest: digest8,
+  semanticDefinition: z23.strictObject({
+    key: identifier12,
+    source: DraftSourceReferenceSchema,
+    sourceDefinitionDigest: digest8,
+    sourceLocator: identifier12,
+    body: z23.string().min(1).max(262144),
+    values: z23.array(z23.strictObject({
+      value: identifier12,
+      definition: excerpt,
+      inclusions: excerpts,
+      exclusions: excerpts,
+      examples: excerpts,
+      edgeCases: excerpts
+    })).min(1).max(64)
+  }),
+  semanticDefinitionDigest: digest8,
+  normalizationProposal: z23.strictObject({
+    id: identifier12,
+    version: identifier12,
+    instructions: text4,
+    status: z23.literal("proposal_only"),
+    targetSemanticDefinitionDigest: digest8
+  }),
+  normalizationProposalDigest: digest8,
+  gaps: z23.array(z23.strictObject({
+    value: identifier12,
+    field: z23.enum(semanticGuidanceFields),
+    reason: z23.literal("not_supplied")
+  })).max(256),
+  bundleDigest: digest8
+});
+
+// ../schemas/src/draft-normalized-evidence.ts
+var identifier13 = DraftEvidenceScopeSchema.shape.entityId;
+var reference4 = DraftEvidenceScopeSchema.shape.observations.element.shape.evidence;
+var digest9 = reference4.shape.contentDigest;
+var evaluator = z24.strictObject({
+  provider: identifier13,
+  requestedModel: identifier13,
+  resolvedModel: identifier13
+});
+var DraftEvaluatorContractSchema = z24.strictObject({
+  schema: z24.literal("felspar.evaluator-contract.draft/v0"),
+  authority: z24.literal("unapproved"),
+  id: identifier13,
+  version: identifier13,
+  semanticDefinitionDigest: digest9,
+  normalizationProposalDigest: digest9,
+  evaluator,
+  calibration: z24.strictObject({ id: identifier13, version: identifier13, contentDigest: digest9 }),
+  minimumSelectedProbability: z24.number().gt(0).max(1),
+  inputContextContract: z24.literal("job-entity-time/v1").optional(),
+  probabilityContract: z24.enum([
+    "closed-distribution-unique-maximum/v1",
+    "closed-distribution-with-abstention/v1"
+  ])
+});
+var judgment = z24.discriminatedUnion("status", [
+  z24.strictObject({
+    status: z24.literal("evaluated"),
+    abstentionProbability: z24.number().min(0).max(1).optional(),
+    probabilities: z24.array(z24.strictObject({
+      value: z24.string().min(1).max(200),
+      probability: z24.number().min(0).max(1)
+    })).min(1).max(64)
+  }),
+  z24.strictObject({ status: z24.enum(["abstained", "timeout", "malformed", "review_required"]) })
+]);
+var DraftNormalizedEvidenceSchema = z24.strictObject({
+  schema: z24.literal("felspar.normalized-evidence.draft/v0"),
+  attemptStatus: DraftEvidenceValidationSchema.shape.normalization.optional(),
+  answerType: z24.literal("boolean").optional(),
+  semantics: DraftSemanticBundleInputSchema,
+  expectedSemanticBundleDigest: digest9,
+  evaluatorContract: DraftEvaluatorContractSchema,
+  expectedEvaluatorContractDigest: digest9,
+  proposal: DraftDecisionRunSchema.shape.proposal,
+  evidence: z24.strictObject({
+    schema: DraftEvidenceValidationSchema.shape.schema,
+    mode: DraftEvidenceValidationSchema.shape.mode,
+    job: DraftEvidenceValidationSchema.shape.job,
+    trustDomain: DraftEvidenceValidationSchema.shape.trustDomain,
+    observationChecks: DraftEvidenceValidationSchema.shape.observationChecks,
+    allowedSourceClasses: DraftEvidenceValidationSchema.shape.allowedSourceClasses,
+    collection: DraftEvidenceValidationSchema.shape.collection,
+    sources: DraftEvidenceValidationSchema.shape.sources,
+    admissions: DraftEvidenceValidationSchema.shape.admissions
+  }),
+  normalizations: z24.array(z24.strictObject({
+    observationId: identifier13,
+    evidence: reference4,
+    semanticBundleDigest: digest9,
+    semanticDefinitionDigest: digest9,
+    normalizationProposalDigest: digest9,
+    evaluatorContractDigest: digest9,
+    evaluator,
+    calibrationDigest: digest9,
+    inputScope: z24.strictObject({
+      job: DraftEvidenceValidationSchema.shape.job,
+      entityId: identifier13,
+      evaluationTime: DraftEvidenceValidationSchema.shape.observationChecks.shape.evaluationTime
+    }).optional(),
+    judgment
+  })).max(64)
+});
+
+// ../schemas/src/draft-required-normalization.ts
+var { key } = DraftAuthoritySchema.shape.definition.shape;
+var digest10 = DraftNormalizedEvidenceSchema.shape.expectedSemanticBundleDigest;
+var conditionalNormalizationContract = "felspar.conditional-enum-normalization/v1";
+var DraftRequiredNormalizationSchema = z25.strictObject({
+  schema: z25.enum([
+    "felspar.required-normalization.draft/v0",
+    "felspar.required-normalization.draft/v1"
+  ]),
+  proposal: DraftRequiredProposalSchema,
+  scope: DraftRequiredDecisionSchema.shape.scope,
+  bindings: z25.array(z25.strictObject({
+    key,
+    semanticBundleDigest: digest10,
+    evaluatorContractDigest: digest10
+  })).min(1).max(16),
+  normalizations: z25.array(z25.strictObject({ key, input: DraftNormalizedEvidenceSchema })).max(16)
+}).superRefine((input, context3) => {
+  if (context3.issues.length > 0) {
+    return;
+  }
+  if (isLayeredResolutionPolicy(input.proposal.resolutionPolicy)) {
+    context3.addIssue({
+      code: "custom",
+      message: "The v4/v5 policies require the supplied route; dependency-layer normalization is unsupported"
+    });
+    return;
+  }
+  const isConditional = input.proposal.resolutionPolicy === conditionalResolutionPolicy;
+  if (isConditional !== (input.schema === "felspar.required-normalization.draft/v1")) {
+    context3.addIssue({
+      code: "custom",
+      message: "Conditional policy requires the supplied route or v1 normalization"
+    });
+  }
+  if (input.proposal.requirements.some((item) => !("allowedValues" in item.definition))) {
+    context3.addIssue({
+      code: "custom",
+      message: "This normalization route supports enum definitions only"
+    });
+  }
+  const keys = new Set(input.proposal.requirements.map((item) => item.definition.key));
+  for (const field of ["bindings", "normalizations"]) {
+    const supplied = input[field].map((item) => item.key);
+    const unique4 = new Set(supplied);
+    if (unique4.size !== supplied.length || supplied.some((item) => !keys.has(item))) {
+      context3.addIssue({
+        code: "custom",
+        path: [field],
+        message: "Unknown or duplicate requirement key"
+      });
+    }
+    if (field === "bindings" && supplied.length !== keys.size) {
+      context3.addIssue({
+        code: "custom",
+        path: [field],
+        message: "Every requirement needs a binding"
+      });
+    }
+  }
+});
+
+// ../schemas/src/draft-required-context.ts
+import { z as z31 } from "zod";
+
+// ../schemas/src/draft-context-selection.ts
+import { z as z28 } from "zod";
+
+// ../schemas/src/draft-context.ts
+import { z as z27 } from "zod";
+
+// ../schemas/src/draft-primitive-mapping.ts
+import { z as z26 } from "zod";
+var authorityPrimitives = [
+  "actors",
+  "decision_criteria",
+  "source_signals",
+  "needs_and_requirements",
+  "evidence_and_proof",
+  "boundaries",
+  "output_contracts",
+  "routing_jobs",
+  "gaps",
+  "evaluations"
+];
+var label = z26.string().trim().min(1).max(2e3);
+var id = z26.string().min(1).max(200);
+var reference5 = z26.discriminatedUnion("kind", [
+  z26.strictObject({ kind: z26.literal("interpreter"), observationId: id }),
+  z26.strictObject({ kind: z26.literal("rule"), ruleId: id }),
+  z26.strictObject({ kind: z26.literal("observation"), observationId: id }),
+  z26.strictObject({ kind: z26.literal("evidence"), observationId: id }),
+  z26.strictObject({ kind: z26.literal("definition") }),
+  z26.strictObject({ kind: z26.literal("outcomes") }),
+  z26.strictObject({ kind: z26.literal("job") }),
+  z26.strictObject({ kind: z26.literal("expectation") })
+]);
+var kinds = {
+  actors: ["interpreter"],
+  decision_criteria: ["rule"],
+  source_signals: ["observation"],
+  needs_and_requirements: ["definition"],
+  evidence_and_proof: ["evidence"],
+  boundaries: [],
+  output_contracts: ["outcomes"],
+  routing_jobs: ["job"],
+  gaps: ["expectation"],
+  evaluations: ["expectation"]
+};
+var category = z26.enum(authorityPrimitives);
+var row = z26.discriminatedUnion("status", [
+  z26.strictObject({
+    primitive: category,
+    status: z26.literal("mapped"),
+    explanation: label,
+    references: z26.array(reference5).min(1).max(64),
+    limitation: label
+  }),
+  z26.strictObject({ primitive: category, status: z26.literal("needs_decision"), reason: label })
+]);
+var DraftPrimitiveMappingSchema = z26.strictObject({
+  schema: z26.literal("felspar.primitive-mapping.draft/v0"),
+  caseId: id,
+  rows: z26.array(row).length(authorityPrimitives.length)
+}).superRefine((mapping, context3) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, entry2] of mapping.rows.entries()) {
+    const path3 = ["rows", index];
+    if (seen.has(entry2.primitive)) {
+      context3.addIssue({ code: "custom", path: path3, message: "Duplicate primitive" });
+    }
+    seen.add(entry2.primitive);
+    if (entry2.status !== "mapped") {
+      continue;
+    }
+    const references = /* @__PURE__ */ new Set();
+    for (const [at, ref] of entry2.references.entries()) {
+      if (!kinds[entry2.primitive].includes(ref.kind)) {
+        context3.addIssue({
+          code: "custom",
+          path: [...path3, "references", at],
+          message: "Reference kind does not belong to this primitive"
+        });
+      }
+      const key3 = JSON.stringify(ref);
+      if (references.has(key3)) {
+        context3.addIssue({
+          code: "custom",
+          path: [...path3, "references", at],
+          message: "Duplicate reference"
+        });
+      }
+      references.add(key3);
+    }
+  }
+});
+function readObservation(input, ref) {
+  const index = input.observations.findIndex((entry2) => entry2.id === ref.observationId);
+  const observation2 = input.observations[index];
+  if (!observation2) {
+    return void 0;
+  }
+  const path3 = `observations.${index}`;
+  if (ref.kind === "interpreter") {
+    return { path: `${path3}.interpretation`, value: observation2.interpretation };
+  }
+  const { sourceId, revision, locator: locator2 } = observation2.evidence;
+  return {
+    path: ref.kind === "evidence" ? `${path3}.evidence` : path3,
+    value: ref.kind === "evidence" ? observation2.evidence : observation2,
+    source: { sourceId, revision, locator: locator2 }
+  };
+}
+function readReference(input, ref) {
+  const { authority } = input;
+  switch (ref.kind) {
+    case "definition": {
+      return {
+        path: "authority.definition",
+        value: authority.definition,
+        source: { ...authority.source, locator: authority.definition.sourceLocator }
+      };
+    }
+    case "outcomes": {
+      return { path: "authority.allowedOutcomes", value: authority.allowedOutcomes };
+    }
+    case "job": {
+      return { path: "authority.job", value: authority.job };
+    }
+    case "expectation": {
+      return { path: "expected", value: input.expected };
+    }
+    case "rule": {
+      const index = authority.rules.findIndex((entry2) => entry2.id === ref.ruleId);
+      const rule3 = authority.rules[index];
+      return rule3 ? {
+        path: `authority.rules.${index}`,
+        value: rule3,
+        source: { ...authority.source, locator: rule3.sourceLocator }
+      } : void 0;
+    }
+    case "interpreter":
+    case "observation":
+    case "evidence": {
+      return readObservation(input, ref);
+    }
+    default: {
+      return void 0;
+    }
+  }
+}
+var DraftMappedCaseSchema = z26.strictObject({
+  input: DraftDecisionCaseSchema,
+  mapping: DraftPrimitiveMappingSchema
+}).superRefine(({ input, mapping }, context3) => {
+  if (input.caseId !== mapping.caseId) {
+    context3.addIssue({
+      code: "custom",
+      path: ["mapping", "caseId"],
+      message: "Mapping belongs to a different case"
+    });
+  }
+  for (const [index, entry2] of mapping.rows.entries()) {
+    if (entry2.status !== "mapped") {
+      continue;
+    }
+    if (entry2.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()) {
+      if (!readReference(input, ref)) {
+        context3.addIssue({
+          code: "custom",
+          path: ["mapping", "rows", index, "references", at],
+          message: "Referenced example field does not exist"
+        });
+      }
+    }
+  }
+});
+
+// ../schemas/src/draft-context.ts
+var identifier14 = DraftEvidenceScopeSchema.shape.entityId;
+var reference6 = DraftEvidenceScopeSchema.shape.observations.element.shape.evidence;
+var ids = z27.array(identifier14).max(64).refine(hasUniqueValues, "Duplicate entry ID");
+var entry = z27.strictObject({
+  id: identifier14,
+  primitive: z27.enum(authorityPrimitives),
+  body: z27.string().min(1).max(8192).regex(/\S/u),
+  source: reference6,
+  dependencies: ids,
+  conflictsWith: ids
+});
+var selection = z27.strictObject({
+  outcome: identifier14,
+  requiredIds: ids,
+  optional: z27.array(z27.strictObject({ id: identifier14, priority: z27.number().int().min(0).max(65535) })).max(64)
+});
+var DraftContextPlanSchema = z27.strictObject({
+  schema: z27.literal("felspar.context-plan.draft/v0"),
+  authority: z27.literal("unapproved"),
+  artifactDigest: reference6.shape.contentDigest,
+  job: identifier14,
+  trustDomain: identifier14,
+  selectionBinding: z27.strictObject({
+    selectionPlanDigest: reference6.shape.contentDigest,
+    outputSurface: identifier14
+  }).optional(),
+  entries: z27.array(entry).min(1).max(64),
+  requiredIds: ids,
+  selections: z27.array(selection).min(1).max(64),
+  budget: z27.strictObject({
+    maxEntries: z27.number().int().min(0).max(64),
+    maxBytes: z27.number().int().min(1).max(65536)
+  })
+}).superRefine((plan, context3) => {
+  if (context3.issues.length > 0) {
+    return;
+  }
+  const collections = [
+    plan.entries.map((item) => item.id),
+    plan.selections.map((item) => item.outcome)
+  ];
+  for (const item of plan.selections) {
+    collections.push(item.optional.map((option2) => option2.id));
+    const priorities = new Set(item.optional.map((option2) => option2.priority));
+    if (priorities.size !== item.optional.length) {
+      context3.addIssue({ code: "custom", message: "Optional priorities must be unique" });
+    }
+  }
+  if (collections.some((values) => !hasUniqueValues(values))) {
+    context3.addIssue({ code: "custom", message: "Duplicate entry, outcome or optional root" });
+  }
+});
+var DraftContextInputSchema = z27.strictObject({
+  artifact: DraftCompiledArtifactSchema,
+  decision: DraftCompiledRequestSchema,
+  plan: DraftContextPlanSchema,
+  expectedPlanDigest: reference6.shape.contentDigest
+});
+
+// ../schemas/src/draft-context-selection.ts
+var base2 = DraftContextPlanSchema.shape;
+var identifier15 = base2.job;
+var draftOutputPreparationContract = "felspar.structured-output-preparation/v1";
+var draftRequiredEvaluationContract = "felspar.required-evaluations/v1";
+var evaluationValidation = z28.strictObject({
+  contract: z28.literal(draftRequiredEvaluationContract),
+  recipes: z28.array(z28.strictObject({ entryId: identifier15, expectedRecipeDigest: base2.artifactDigest })).min(1).max(8).refine((items) => hasUniqueValues(items.map((item) => item.entryId)), "Duplicate required recipe"),
+  maxRequests: z28.number().int().min(1).max(128),
+  maxTotalBytes: z28.number().int().min(1).max(65536)
+});
+var hasUniqueIds = (values) => hasUniqueValues(values);
+var candidate = z28.strictObject({
+  entryId: identifier15,
+  outcomes: z28.array(identifier15).min(1).max(64).refine(hasUniqueIds, "Duplicate outcome"),
+  when: z28.array(z28.strictObject({ key: identifier15, equals: identifier15 })).max(16).refine((clauses2) => hasUniqueIds(clauses2.map((clause) => clause.key)), "Duplicate condition key"),
+  priority: z28.number().int().min(0).max(65535)
+});
+var group = z28.strictObject({
+  id: identifier15,
+  min: z28.number().int().min(0).max(64),
+  max: z28.number().int().min(0).max(64),
+  candidates: z28.array(candidate).max(64)
+}).refine((value) => value.min <= value.max, "Group minimum exceeds maximum");
+var DraftContextSelectionPlanSchema = z28.strictObject({
+  schema: z28.enum([
+    "felspar.context-selection.draft/v0",
+    "felspar.context-selection.draft/v1",
+    "felspar.context-selection.draft/v2"
+  ]),
+  evaluationValidation: evaluationValidation.optional(),
+  outputValidation: z28.strictObject({
+    contract: z28.literal(draftOutputPreparationContract),
+    entryId: identifier15,
+    expectedContractDigest: base2.artifactDigest
+  }).optional(),
+  authority: base2.authority,
+  artifactDigest: base2.artifactDigest,
+  job: base2.job,
+  trustDomain: base2.trustDomain,
+  outputSurface: identifier15,
+  unresolvedGuidanceEntryId: identifier15.optional(),
+  attempts: z28.strictObject({
+    max: z28.number().int().min(1).max(10),
+    withProgress: z28.number().int().min(1).max(10)
+  }).refine((value) => value.withProgress >= value.max, "withProgress below max").optional(),
+  entries: base2.entries,
+  requiredIds: base2.requiredIds,
+  budget: base2.budget,
+  groups: z28.array(group).min(1).max(8)
+}).superRefine((plan, context3) => {
+  if (context3.issues.length > 0) {
+    return;
+  }
+  if (plan.schema !== "felspar.context-selection.draft/v0" !== Boolean(plan.outputValidation)) {
+    context3.addIssue({
+      code: "custom",
+      message: "Output validation requires selection-plan v1 or v2"
+    });
+  }
+  if (plan.schema === "felspar.context-selection.draft/v2" !== Boolean(plan.evaluationValidation)) {
+    context3.addIssue({
+      code: "custom",
+      message: "Required evaluations require selection-plan v2"
+    });
+  }
+  const candidateIds = plan.groups.flatMap((item) => item.candidates.map((c) => c.entryId));
+  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((id11) => candidateIds.includes(id11))) {
+    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);
+  if ([
+    !entry2,
+    entry2?.primitive !== "gaps",
+    entry2?.dependencies.length,
+    entry2?.conflictsWith.length,
+    plan.requiredIds.includes(guidanceId),
+    candidateIds.includes(guidanceId),
+    plan.entries.some((row2) => row2.dependencies.includes(guidanceId))
+  ].some(Boolean)) {
+    context3.addIssue({
+      code: "custom",
+      message: "Unresolved guidance must be an isolated gaps entry outside ready context"
+    });
+  }
+});
+var DraftContextSelectionInputSchema = z28.strictObject({
+  artifact: DraftContextInputSchema.shape.artifact,
+  decision: DraftContextInputSchema.shape.decision,
+  plan: DraftContextSelectionPlanSchema,
+  expectedPlanDigest: DraftContextInputSchema.shape.expectedPlanDigest,
+  requestedSurface: identifier15
+});
+
+// ../schemas/src/draft-origin-gates.ts
+import { z as z30 } from "zod";
+
+// ../schemas/src/draft-normalized-context.ts
+import { z as z29 } from "zod";
+var request = DraftCompiledRequestSchema.shape;
+var context = DraftContextSelectionInputSchema.shape;
+var compilation = DraftCandidateCompilationVerificationSchema.shape;
+var draftNormalizedContextContract = "felspar.normalized-context-run/v1";
+var DraftNormalizedContextInputSchema = z29.strictObject({
+  normalization: DraftNormalizedEvidenceSchema,
+  compilation: z29.strictObject({
+    artifact: compilation.artifact,
+    binding: compilation.binding,
+    fixtures: compilation.fixtures
+  }),
+  request: z29.strictObject({
+    expectedArtifactDigest: request.expectedArtifactDigest,
+    job: request.job,
+    trustDomain: request.trustDomain,
+    scope: request.scope
+  }),
+  plan: context.plan,
+  expectedPlanDigest: context.expectedPlanDigest,
+  requestedSurface: context.requestedSurface
+});
+var digest11 = context.expectedPlanDigest;
+var DraftNormalizedContextReceiptBodySchema = z29.strictObject({
+  schema: z29.literal("felspar.normalized-context-receipt.draft/v0"),
+  authority: z29.literal("unapproved"),
+  runtimeContract: z29.literal(draftNormalizedContextContract),
+  inputDigest: digest11,
+  resultDigest: digest11,
+  artifactDigest: digest11,
+  normalizationDigest: digest11,
+  decisionRunDigest: digest11.nullable(),
+  selectionPlanDigest: digest11,
+  capsuleDigest: digest11.nullable(),
+  status: z29.enum(["ready", "blocked"])
+});
+var DraftNormalizedContextReceiptSchema = DraftNormalizedContextReceiptBodySchema.extend({
+  receiptDigest: digest11
+}).refine((receipt) => receipt.status === "ready" === (receipt.capsuleDigest !== null), "Only ready delivery may have a capsule digest");
+
+// ../schemas/src/draft-origin-gates.ts
+var DraftOriginBoundCompilationSchema = DraftSourceBoundCompilationSchema.extend({
+  origins: DraftCandidateOriginsSchema
+});
+var DraftContextOriginsSchema = z30.strictObject({
+  schema: z30.literal("felspar.context-origins.draft/v0"),
+  planDigest: DraftContextSelectionPlanSchema.shape.artifactDigest,
+  entries: z30.array(z30.strictObject({
+    entryId: DraftContextSelectionPlanSchema.shape.job,
+    origin: DraftAuthorityOriginSchema
+  })).max(64)
+});
+var DraftContextOriginInputSchema = z30.strictObject({
+  plan: DraftContextSelectionPlanSchema,
+  origins: DraftContextOriginsSchema,
+  bundle: DraftSourceTextBundleSchema,
+  compositions: DraftSourceCompositionsSchema
+});
+var DraftOriginBoundContextInputSchema = z30.strictObject({
+  schema: z30.literal("felspar.origin-bound-context.draft/v0"),
+  input: DraftNormalizedContextInputSchema,
+  origins: DraftCandidateOriginsSchema,
+  context: z30.strictObject({
+    origins: DraftContextOriginsSchema,
+    bundle: DraftSourceTextBundleSchema
+  })
+});
+
+// ../schemas/src/draft-required-context.ts
+var context2 = DraftContextSelectionInputSchema.shape;
+var draftRequiredContextContract = "felspar.required-context-run/v1";
+var DraftRequiredContextInputSchema = z31.strictObject({
+  normalization: DraftRequiredNormalizationSchema,
+  compilation: z31.strictObject({
+    artifact: DraftCompiledArtifactSchema,
+    fixtures: DraftAnyCompilationSchema.shape.fixtures
+  }),
+  request: DraftCompiledRequestSchema.omit({ schema: true, evidence: true }),
+  plan: context2.plan,
+  expectedPlanDigest: context2.expectedPlanDigest,
+  requestedSurface: context2.requestedSurface,
+  contextOrigins: DraftContextOriginInputSchema.omit({ plan: true })
+});
+var DraftRequiredContextReceiptBodySchema = DraftNormalizedContextReceiptBodySchema.extend({
+  schema: z31.literal("felspar.required-context-receipt.draft/v0"),
+  runtimeContract: z31.literal(draftRequiredContextContract),
+  compilationDigest: context2.expectedPlanDigest,
+  contextOriginsDigest: context2.expectedPlanDigest
+});
+var DraftRequiredContextReceiptSchema = DraftRequiredContextReceiptBodySchema.extend({
+  receiptDigest: context2.expectedPlanDigest
+}).refine((receipt) => receipt.status === "ready" === (receipt.capsuleDigest !== null), "Only ready delivery may have a capsule digest");
+
+// ../schemas/src/draft-required-origins.ts
+var normalization = DraftRequiredNormalizationSchema.shape;
+var packet = DraftNormalizedEvidenceSchema.shape;
+var digest12 = packet.expectedSemanticBundleDigest;
+var path2 = z32.string().max(512).regex(/^\/authority\//u);
+var DraftRequiredAuthoritySchema = z32.strictObject({
+  proposal: normalization.proposal,
+  normalizationContract: z32.literal(conditionalNormalizationContract).optional(),
+  bindings: normalization.bindings,
+  materials: z32.array(z32.strictObject({
+    key: normalization.bindings.element.shape.key,
+    semantics: packet.semantics,
+    evaluatorContract: packet.evaluatorContract
+  })).min(1).max(16)
+}).superRefine((catalog, context3) => {
+  if (isLayeredResolutionPolicy(catalog.proposal.resolutionPolicy)) {
+    context3.addIssue({
+      code: "custom",
+      message: "The v4/v5 policies require the supplied route; dependency-layer normalization is unsupported"
+    });
+    return;
+  }
+  const isConditional = catalog.proposal.resolutionPolicy === conditionalResolutionPolicy;
+  if (isConditional !== (catalog.normalizationContract !== void 0)) {
+    context3.addIssue({
+      code: "custom",
+      message: "Conditional policy requires the supplied route or an explicit normalization contract"
+    });
+  }
+  if (isConditional && catalog.proposal.requirements.some((item) => !("allowedValues" in item.definition))) {
+    context3.addIssue({
+      code: "custom",
+      message: "Conditional normalization supports enum definitions only"
+    });
+  }
+});
+var DraftRequiredOriginsSchema = z32.strictObject({
+  schema: z32.literal("felspar.required-origins.draft/v0"),
+  authorityDigest: digest12,
+  entries: z32.array(z32.strictObject({ path: path2, origin: DraftAuthorityOriginSchema })).max(1024)
+});
+var DraftRequiredOriginInputSchema = z32.strictObject({
+  catalog: DraftRequiredAuthoritySchema,
+  origins: DraftRequiredOriginsSchema,
+  expectedAuthorityDigest: digest12,
+  expectedOriginsDigest: digest12,
+  bundle: DraftSourceTextBundleSchema,
+  compositions: DraftSourceCompositionsSchema
+});
+var DraftCoveredRequiredContextSchema = z32.strictObject({
+  authority: DraftRequiredOriginInputSchema,
+  input: DraftRequiredContextInputSchema
+});
+var DraftCoveredRequiredReceiptBodySchema = z32.strictObject({
+  schema: z32.literal("felspar.covered-required-receipt.draft/v0"),
+  authority: z32.literal("unapproved"),
+  inputDigest: digest12,
+  resultDigest: digest12,
+  authorityDigest: digest12,
+  originsDigest: digest12,
+  capsuleDigest: digest12.nullable(),
+  status: z32.enum(["ready", "blocked"])
+});
+var DraftCoveredRequiredReceiptSchema = DraftCoveredRequiredReceiptBodySchema.extend({
+  receiptDigest: digest12
+}).refine((receipt) => receipt.status === "ready" === (receipt.capsuleDigest !== null), "Only ready delivery has a capsule digest");
+var DraftRequiredPreparationSchema = DraftRequiredContextInputSchema.omit({
+  normalization: true,
+  request: true
+}).extend({
+  authority: DraftRequiredOriginInputSchema,
+  expectedArtifactDigest: digest12
+});
+var DraftPreparedRequiredReadSchema = z32.strictObject({
+  request: DraftRequiredContextInputSchema.shape.request,
+  normalizations: normalization.normalizations
+});
+
+// ../schemas/src/draft-supplied-context.ts
+import { z as z33 } from "zod";
+var draftSuppliedContextContract = "felspar.supplied-context-run/v1";
+var draftSuppliedContextPartsContract = "felspar.supplied-context-run/v2";
+var DraftSuppliedAuthoritySchema = z33.strictObject({
+  proposal: DraftRequiredProposalSchema,
+  route: z33.strictObject({
+    kind: z33.literal("supplied_values"),
+    contract: z33.literal("felspar.declared-scalar-observations/v1")
+  })
+});
+var DraftSuppliedOriginInputSchema = DraftRequiredOriginInputSchema.extend({
+  catalog: DraftSuppliedAuthoritySchema
+});
+var DraftSuppliedContextSchema = DraftRequiredContextInputSchema.omit({
+  normalization: true
+}).extend({
+  schema: z33.literal("felspar.supplied-context.draft/v0"),
+  authority: DraftSuppliedOriginInputSchema,
+  evidence: DraftRequiredDecisionSchema.shape.evidence
+});
+var DraftSuppliedPreparationSchema = DraftSuppliedContextSchema.omit({
+  request: true,
+  evidence: true
+}).extend({
+  schema: z33.literal("felspar.supplied-preparation.draft/v0"),
+  expectedArtifactDigest: DraftSuppliedContextSchema.shape.request.shape.expectedArtifactDigest
+});
+var DraftPreparedSuppliedRequestSchema = DraftSuppliedContextSchema.pick({
+  request: true,
+  evidence: true
+});
+var DraftSuppliedReceiptBodySchema = DraftCoveredRequiredReceiptBodySchema.extend({
+  schema: z33.literal("felspar.supplied-context-receipt.draft/v0"),
+  runtimeContract: z33.enum([draftSuppliedContextContract, draftSuppliedContextPartsContract])
+});
+var DraftSuppliedReceiptSchema = DraftSuppliedReceiptBodySchema.extend({
+  receiptDigest: DraftCoveredRequiredReceiptBodySchema.shape.inputDigest
+}).refine((receipt) => receipt.status === "ready" === (receipt.capsuleDigest !== null), "Only ready delivery has a capsule digest");
+
+// ../schemas/src/draft-requirements.ts
+var request2 = z34.strictObject({
+  schema: z34.literal("felspar.requirements-request.draft/v0"),
+  job: DraftRequiredProposalSchema.shape.job,
+  trustDomain: DraftRequiredProposalSchema.shape.trustDomain,
+  maxResponseBytes: z34.number().int().min(1).max(1048576)
+});
+var DraftRequirementsRequestSchema = z34.discriminatedUnion("route", [
+  request2.extend({
+    route: z34.literal("normalized"),
+    authority: DraftRequiredOriginInputSchema
+  }),
+  request2.extend({
+    route: z34.literal("supplied"),
+    authority: DraftSuppliedOriginInputSchema
+  })
+]);
+
+// ../schemas/src/draft-typed-normalization.ts
+import { z as z37 } from "zod";
+
+// ../schemas/src/draft-exact-reader.ts
+import { z as z35 } from "zod";
+var exactNumberReaderVersion = "felspar.exact-number/v2";
+var exactDateReaderVersion = "felspar.exact-date/v2";
+var numberStyles = ["1,234.56", "1.234,56", "1 234,56", "1'234.56"];
+var dateOrders = ["unstated", "month-first", "day-first"];
+var knownCurrencies = [
+  "AED",
+  "ARS",
+  "AUD",
+  "BRL",
+  "CAD",
+  "CHF",
+  "CLP",
+  "CNY",
+  "COP",
+  "CZK",
+  "DKK",
+  "EGP",
+  "EUR",
+  "GBP",
+  "HKD",
+  "HUF",
+  "IDR",
+  "ILS",
+  "INR",
+  "ISK",
+  "JPY",
+  "KES",
+  "KRW",
+  "MXN",
+  "MYR",
+  "NGN",
+  "NOK",
+  "NZD",
+  "PEN",
+  "PHP",
+  "PKR",
+  "PLN",
+  "RON",
+  "RUB",
+  "SAR",
+  "SEK",
+  "SGD",
+  "THB",
+  "TRY",
+  "TWD",
+  "UAH",
+  "USD",
+  "VND",
+  "ZAR"
+];
+var knownCurrencySet = new Set(knownCurrencies);
+function isKnownCurrency(code) {
+  return knownCurrencySet.has(code);
+}
+var UnitWordSchema = z35.string().min(1).max(64).regex(/^\p{L}[\p{L}\p{N}'’ -]*\p{L}$|^\p{L}$/u, "Use a word or short phrase");
+var ExactNumberUnitSchema = z35.discriminatedUnion("kind", [
+  z35.strictObject({
+    kind: z35.literal("currency"),
+    code: z35.string().regex(/^[A-Z]{3}$/u).refine(isKnownCurrency, "Not a currency code the reader recognises")
+  }),
+  z35.strictObject({ kind: z35.literal("percent") }),
+  z35.strictObject({
+    kind: z35.literal("count"),
+    words: z35.array(UnitWordSchema).min(1).max(16).refine((words) => hasUniqueValues(words.map((word) => word.toLowerCase())), "Duplicate unit word")
+  })
+]);
+var ExactReaderSchema = z35.discriminatedUnion("version", [
+  z35.strictObject({
+    version: z35.literal(exactNumberReaderVersion),
+    unit: ExactNumberUnitSchema,
+    numberStyle: z35.enum(numberStyles)
+  }),
+  z35.strictObject({
+    version: z35.literal(exactDateReaderVersion),
+    dateOrder: z35.enum(dateOrders)
+  })
+]);
+
+// ../schemas/src/draft-scalar-selection.ts
+import { z as z36 } from "zod";
+var scalarSelectionConfidence = "candidate-selected-probability/v1";
+var DraftScalarParserSchema = z36.discriminatedUnion("version", [
+  z36.strictObject({
+    version: z36.literal("iso-currency-decimal/v1"),
+    currency: z36.string().regex(/^[A-Z]{3}$/u)
+  }),
+  z36.strictObject({ version: z36.literal("iso-calendar-date/v1") })
+]);
+var digest13 = z36.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var candidateId = z36.string().regex(/^candidate_(?:\d|[1-5]\d|6[0-3])$/u);
+var DraftScalarSelectionSchema = z36.strictObject({
+  schema: z36.literal("felspar.scalar-candidate-selection.draft/v0"),
+  requestDigest: digest13,
+  parser: DraftScalarParserSchema,
+  sourceText: z36.string().min(1).max(262144),
+  candidatesDigest: digest13,
+  selectedCandidateId: candidateId.nullable(),
+  probabilities: z36.array(z36.strictObject({ value: candidateId, probability: z36.number().min(0).max(1) })).min(1).max(64),
+  abstentionProbability: z36.number().min(0).max(1),
+  providerConfidence: z36.number().min(0).max(1)
+});
+
+// ../schemas/src/draft-typed-normalization.ts
+var identifier16 = z37.string().min(1).max(200).regex(/\S/u);
+var digest14 = DraftNormalizedEvidenceSchema.shape.expectedSemanticBundleDigest;
+var { evaluator: evaluator2 } = DraftNormalizedEvidenceSchema.shape.evaluatorContract.shape;
+var reference7 = DraftEvidenceValidationSchema.shape.observationChecks.shape.scope.shape.observations.element.shape.evidence;
+var key2 = { key: identifier16 };
+var scalarRecipe = z37.strictObject({
+  ...key2,
+  kind: z37.literal("scalar"),
+  definitionDigest: digest14,
+  id: identifier16,
+  version: identifier16,
+  instructions: z37.string().min(1).max(16384).regex(/\S/u),
+  evaluator: evaluator2,
+  calibration: DraftNormalizedEvidenceSchema.shape.evaluatorContract.shape.calibration,
+  confidenceContract: z37.enum(["declared-scalar-confidence/v1", scalarSelectionConfidence]),
+  parser: DraftScalarParserSchema.optional(),
+  minimumConfidence: z37.number().gt(0).max(1),
+  reader: ExactReaderSchema.optional()
+}).refine((recipe2) => recipe2.confidenceContract === scalarSelectionConfidence === Boolean(recipe2.parser), "A candidate-selection recipe requires its parser; legacy recipes cannot carry a parser");
+var DraftInterpretationManifestSchema = z37.strictObject({
+  schema: z37.literal("felspar.typed-interpretation-manifest.draft/v0"),
+  authority: z37.literal("unapproved"),
+  authorityDigest: digest14,
+  recipes: z37.array(z37.discriminatedUnion("kind", [
+    scalarRecipe,
+    z37.strictObject({
+      ...key2,
+      kind: z37.literal("enum"),
+      semanticBundleDigest: digest14,
+      evaluatorContractDigest: digest14
+    })
+  ])).min(1).max(64).refine((items) => hasUniqueValues(items.map((item) => item.key)), "Duplicate recipe key")
+});
+var judgment2 = z37.discriminatedUnion("status", [
+  z37.strictObject({
+    status: z37.literal("evaluated"),
+    value: DraftEvidenceValueSchema,
+    unit: identifier16.optional(),
+    confidence: z37.number().min(0).max(1)
+  }),
+  z37.strictObject({ status: z37.enum(["abstained", "timeout", "malformed", "review_required"]) })
+]);
+var scalarPacket = z37.strictObject({
+  ...key2,
+  kind: z37.literal("scalar"),
+  evidence: z37.strictObject(DraftEvidenceValidationSchema.shape).omit({ results: true }),
+  records: z37.array(z37.strictObject({
+    observationId: identifier16,
+    evidence: reference7,
+    recipeDigest: digest14,
+    evaluator: evaluator2,
+    calibrationDigest: digest14,
+    judgment: judgment2,
+    selection: DraftScalarSelectionSchema.optional()
+  })).max(64)
+});
+var DraftTypedNormalizationSchema = z37.strictObject({
+  schema: z37.literal("felspar.typed-normalization.draft/v0"),
+  invocation: DraftSuppliedContextSchema.omit({ evidence: true }),
+  manifest: DraftInterpretationManifestSchema,
+  expectedManifestDigest: digest14,
+  packets: z37.array(z37.discriminatedUnion("kind", [
+    scalarPacket,
+    z37.strictObject({ ...key2, kind: z37.literal("enum"), input: DraftNormalizedEvidenceSchema })
+  ])).max(64).refine((items) => hasUniqueValues(items.map((item) => item.key)), "Duplicate packet key")
+});
+var DraftLayeredNormalizationSchema = DraftTypedNormalizationSchema.extend({
+  schema: z37.literal("felspar.typed-normalization.draft/v1")
+});
+
+// ../schemas/src/draft-context-receipt.ts
+import { z as z38 } from "zod";
+var digest15 = DraftContextSelectionInputSchema.shape.expectedPlanDigest;
+var { evaluationTime } = DraftContextSelectionInputSchema.shape.decision.shape.scope.shape;
+var draftContextRuntimeContract = "felspar.context-selection-run/v1";
+var DraftContextReceiptBodySchema = z38.strictObject({
+  schema: z38.literal("felspar.context-receipt.draft/v0"),
+  authority: z38.literal("unapproved"),
+  stage: z38.literal("draft-context-selection"),
+  runtimeContract: z38.literal(draftContextRuntimeContract),
+  identityFormat: z38.literal("felspar.json-content-identity/v1"),
+  evaluationTime,
+  inputDigest: digest15,
+  artifactDigest: digest15,
+  selectionPlanDigest: digest15,
+  decisionRunDigest: digest15,
+  resultDigest: digest15,
+  capsuleDigest: digest15.nullable(),
+  status: z38.enum(["ready", "blocked"])
+});
+var DraftContextReceiptSchema = DraftContextReceiptBodySchema.extend({
+  receiptDigest: digest15
+}).refine((receipt) => receipt.status === "ready" === (receipt.capsuleDigest !== null), "Only a ready context receipt has a capsule digest");
+var DraftContextVerificationOptionsSchema = z38.strictObject({
+  expectedReceiptDigest: digest15,
+  deliveredCapsule: z38.record(z38.string(), z38.unknown()).nullable()
+});
+
+// ../schemas/src/draft-evaluation-requests.ts
+import { z as z39 } from "zod";
+var identifier17 = z39.string().min(1).max(200).regex(/\S/u);
+var digest16 = DraftTypedNormalizationSchema.shape.expectedManifestDigest;
+var [scalar2] = DraftTypedNormalizationSchema.shape.packets.element.options;
+var { reference: reference8 } = DraftEvidenceMetadataSchema.shape.sources.element.shape;
+var DraftEvaluationRequestsSchema = z39.strictObject({
+  schema: z39.literal("felspar.evaluation-requests.draft/v0"),
+  invocation: DraftTypedNormalizationSchema.shape.invocation,
+  manifest: DraftTypedNormalizationSchema.shape.manifest,
+  expectedManifestDigest: digest16,
+  limits: z39.strictObject({
+    maxQuestions: z39.number().int().min(1).max(64),
+    maxRequestBytes: z39.number().int().min(1).max(1048576),
+    maxResponseBytes: z39.number().int().min(1).max(1048576)
+  }),
+  packets: z39.array(z39.discriminatedUnion("kind", [
+    z39.strictObject({
+      key: identifier17,
+      kind: z39.literal("scalar"),
+      evidence: DraftEvidenceMetadataSchema
+    }),
+    z39.strictObject({
+      key: identifier17,
+      kind: z39.literal("enum"),
+      input: DraftNormalizedEvidenceSchema.omit({ normalizations: true, attemptStatus: true })
+    })
+  ])).max(64).refine((items) => hasUniqueValues(items.map((item) => item.key)), "Duplicate preparation key"),
+  passages: z39.array(z39.strictObject({ reference: reference8, text: z39.string().min(1).max(262144) })).max(1024)
+});
+var DraftEvaluationResponseSchema = z39.strictObject({
+  schema: z39.literal("felspar.evaluation-response.draft/v0"),
+  requestDigest: digest16,
+  answers: z39.array(z39.discriminatedUnion("kind", [
+    z39.strictObject({
+      key: identifier17,
+      kind: z39.literal("scalar"),
+      records: scalar2.shape.records
+    }),
+    z39.strictObject({
+      key: identifier17,
+      kind: z39.literal("enum"),
+      records: DraftNormalizedEvidenceSchema.shape.normalizations
+    })
+  ])).max(16).refine((items) => hasUniqueValues(items.map((item) => item.key)), "Duplicate answer key")
+});
+var DraftEvaluationResponsesSchema = z39.array(DraftEvaluationResponseSchema).max(2);
+var DraftLayeredEvaluationSchema = DraftEvaluationRequestsSchema.extend({
+  schema: z39.literal("felspar.evaluation-requests.draft/v1"),
+  limits: DraftEvaluationRequestsSchema.shape.limits.extend({
+    maxRounds: z39.number().int().min(1).max(16),
+    maxTotalQuestions: z39.number().int().min(1).max(64),
+    maxTotalRequestBytes: z39.number().int().min(1).max(1048576),
+    maxTotalResponseBytes: z39.number().int().min(1).max(1048576)
+  })
+});
+var DraftLayeredResponsesSchema = z39.array(DraftEvaluationResponseSchema).max(16);
+
+// ../schemas/src/draft-job-handoff.ts
+var digest17 = DraftContextVerificationOptionsSchema.shape.expectedReceiptDigest;
+var draftJobHandoffContract = "felspar.job-handoff/v1";
+var DraftJobDiscoverySchema = z40.strictObject({
+  schema: z40.literal("felspar.job-discovery.draft/v0"),
+  requirements: DraftRequirementsRequestSchema,
+  compilation: DraftRequiredContextInputSchema.shape.compilation,
+  expectedArtifactDigest: digest17
+});
+var executionVersion0 = "felspar.job-execution.draft/v0";
+var DraftJobExecutionSchema = z40.strictObject({
+  schema: z40.literal(executionVersion0),
+  discovery: DraftJobDiscoverySchema,
+  expectedHandoffDigest: digest17,
+  invocation: z40.discriminatedUnion("route", [
+    z40.strictObject({ route: z40.literal("normalized"), input: DraftCoveredRequiredContextSchema }),
+    z40.strictObject({ route: z40.literal("supplied"), input: DraftSuppliedContextSchema }),
+    z40.strictObject({ route: z40.literal("typed"), input: DraftTypedNormalizationSchema }),
+    z40.strictObject({ route: z40.literal("layered"), input: DraftLayeredNormalizationSchema }),
+    z40.strictObject({
+      route: z40.literal("evaluated"),
+      input: DraftLayeredEvaluationSchema,
+      responses: DraftLayeredResponsesSchema
+    })
+  ])
+});
+var DraftJobDiscoveryReferenceSchema = z40.strictObject({
+  schema: z40.literal("felspar.job-discovery-reference.draft/v1"),
+  route: z40.enum(["normalized", "supplied"]),
+  job: DraftRequirementsRequestSchema.options[0].shape.job,
+  trustDomain: DraftRequirementsRequestSchema.options[0].shape.trustDomain,
+  maxResponseBytes: DraftRequirementsRequestSchema.options[0].shape.maxResponseBytes,
+  expectedArtifactDigest: digest17
+});
+var DraftJobExecutionV1Schema = z40.strictObject({
+  schema: z40.literal("felspar.job-execution.draft/v1"),
+  discovery: DraftJobDiscoveryReferenceSchema,
+  expectedHandoffDigest: digest17,
+  invocation: DraftJobExecutionSchema.shape.invocation
+});
+var DraftAnyJobExecutionSchema = z40.discriminatedUnion("schema", [
+  DraftJobExecutionSchema,
+  DraftJobExecutionV1Schema
+]);
+var DraftJobReceiptBodySchema = z40.strictObject({
+  schema: z40.literal("felspar.job-handoff-receipt.draft/v0"),
+  authority: z40.literal("unapproved"),
+  runtimeContract: z40.literal(draftJobHandoffContract),
+  route: z40.enum(["normalized", "supplied", "typed", "layered", "evaluated"]),
+  inputDigest: digest17,
+  handoffDigest: digest17,
+  artifactDigest: digest17,
+  downstreamRunDigest: digest17,
+  capsuleDigest: digest17.nullable(),
+  status: z40.enum(["ready", "blocked"])
+});
+var DraftJobReceiptSchema = DraftJobReceiptBodySchema.extend({
+  receiptDigest: digest17
+}).refine((receipt) => receipt.status === "ready" === (receipt.capsuleDigest !== null), "Only ready delivery has a capsule digest");
+var DraftJobVerificationSchema = z40.strictObject({
+  receipt: DraftJobReceiptSchema,
+  retained: DraftAnyJobExecutionSchema,
+  options: DraftContextVerificationOptionsSchema
+});
+
+// ../schemas/src/draft-application-access.ts
+var identifier18 = z41.string().min(1).max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:/@-]*$/u);
+var digest18 = DraftJobExecutionSchema.shape.expectedHandoffDigest;
+var instant = z41.iso.datetime({ offset: true });
+var applicationActions = [
+  "submit_source",
+  "submit_proposal",
+  "approve_proposal",
+  "release_pack",
+  "execute_job",
+  "inspect_run"
+];
+var action = z41.enum(applicationActions);
+var DraftApplicationScopeSchema = z41.strictObject({
+  organizationId: identifier18,
+  environmentId: identifier18,
+  authorityId: identifier18
+});
+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");
+var DraftApplicationActorSchema = z41.strictObject({
+  principalId: identifier18,
+  organizationId: identifier18,
+  principalType: z41.enum(["user", "delegated_agent", "autonomous_agent"]),
+  actingUserId: identifier18.nullable(),
+  authenticatedAt: instant,
+  expiresAt: instant,
+  permissionCeiling: z41.array(action).max(applicationActions.length)
+}).refine((actor) => actor.principalType === "delegated_agent" === (actor.actingUserId !== null), "Delegated agents preserve the acting user");
+var DraftApplicationPermissionSchema = z41.strictObject({
+  target: DraftApplicationTargetSchema,
+  principalId: identifier18,
+  actingUserId: identifier18.nullable(),
+  allowed: z41.boolean(),
+  checkedAt: instant,
+  expiresAt: instant
+});
+var DraftApplicationJobMaterialSchema = z41.strictObject({
+  discovery: DraftJobExecutionSchema.shape.discovery,
+  expectedHandoffDigest: digest18,
+  input: DraftLayeredEvaluationSchema
+});
+var DraftApplicationJobMaterialV2Schema = z41.strictObject({
+  schema: z41.literal("felspar.application-job-material.draft/v2"),
+  discovery: DraftJobDiscoveryReferenceSchema,
+  expectedHandoffDigest: digest18,
+  input: DraftLayeredEvaluationSchema
+});
+var DraftAnyApplicationJobMaterialSchema = z41.union([
+  DraftApplicationJobMaterialV2Schema,
+  DraftApplicationJobMaterialSchema
+]);
+var DraftApplicationJobRequestSchema = z41.strictObject({
+  schema: z41.literal("felspar.application-job-request.draft/v0"),
+  scope: DraftApplicationScopeSchema,
+  releaseId: identifier18,
+  expectedReleaseDigest: digest18,
+  jobId: identifier18,
+  executionId: identifier18,
+  material: DraftAnyApplicationJobMaterialSchema
+});
+var DraftApplicationReleaseSchema = z41.strictObject({
+  schema: z41.literal("felspar.application-release.draft/v0"),
+  scope: DraftApplicationScopeSchema,
+  releaseId: identifier18,
+  jobId: identifier18,
+  trustDomain: identifier18,
+  materialDigest: digest18,
+  approvalId: identifier18,
+  approvedMaterialDigest: digest18,
+  releaseDigest: digest18,
+  status: z41.enum(["draft", "released", "revoked"])
+});
+
+// ../schemas/src/draft-hosted-application.ts
+import { z as z48 } from "zod";
+
+// ../schemas/src/draft-hosted-output-checks.ts
+import { z as z47 } from "zod";
+
+// ../schemas/src/draft-artifact-check-manifest.ts
+import { z as z45 } from "zod";
+
+// ../schemas/src/draft-artifact-lint-semantic.ts
+import { z as z44 } from "zod";
+
+// ../schemas/src/draft-claim-evaluation-recipe.ts
+import { z as z43 } from "zod";
+
+// ../schemas/src/draft-output-check.ts
+import { z as z42 } from "zod";
+var identifier19 = DraftContextPlanSchema.shape.job;
+var digest19 = DraftJobReceiptBodySchema.shape.inputDigest;
+var byteLimit = z42.number().int().min(1).max(65536);
+var text5 = z42.string().max(16384);
+var sectionRule = z42.discriminatedUnion("check", [
+  z42.strictObject({ id: identifier19, check: z42.literal("text"), maxBytes: byteLimit }),
+  z42.strictObject({
+    id: identifier19,
+    check: z42.literal("exact"),
+    maxBytes: byteLimit,
+    alternatives: z42.array(text5.min(1).regex(/\S/u)).min(1).max(8).refine(hasUniqueValues)
+  })
+]);
+var draftOutputCheckerContract = "felspar.structured-output-check/v1";
+var DraftOutputContractSchema = z42.strictObject({
+  schema: z42.literal("felspar.output-contract.draft/v0"),
+  id: identifier19,
+  version: z42.number().int().min(1).max(65535),
+  compiledArtifactDigest: digest19,
+  job: identifier19,
+  trustDomain: identifier19,
+  outputSurface: identifier19,
+  maxBytes: byteLimit,
+  sections: z42.array(sectionRule).min(1).max(16)
+}).superRefine((contract, context3) => {
+  if (!hasUniqueValues(contract.sections.map((section) => section.id))) {
+    context3.addIssue({ code: "custom", message: "Duplicate output section rule" });
+  }
+  const encoder2 = new TextEncoder();
+  for (const section of contract.sections) {
+    if (section.check === "exact" && section.alternatives.some((value) => encoder2.encode(value).byteLength > section.maxBytes)) {
+      context3.addIssue({ code: "custom", message: "Exact alternative exceeds section budget" });
+    }
+  }
+});
+var DraftStructuredOutputSchema = z42.strictObject({
+  schema: z42.literal("felspar.structured-output.draft/v0"),
+  id: identifier19,
+  revision: identifier19,
+  sections: z42.array(z42.strictObject({ id: identifier19, text: text5 })).max(32).refine((sections) => hasUniqueValues(sections.map((section) => section.id)))
+});
+var DraftOutputCheckSchema = z42.strictObject({
+  schema: z42.literal("felspar.output-check.draft/v0"),
+  execution: DraftJobExecutionSchema,
+  expectedJobReceiptDigest: digest19,
+  contractEntryId: identifier19,
+  expectedContractDigest: digest19,
+  output: DraftStructuredOutputSchema,
+  expectedOutputDigest: digest19
+});
+var DraftOutputDiagnosticSchema = z42.strictObject({
+  code: z42.enum([
+    "upstream_blocked",
+    "contract_coverage_incomplete",
+    "contract_invalid",
+    "output_too_large",
+    "section_missing",
+    "section_unknown",
+    "section_empty",
+    "section_too_large",
+    "section_text_mismatch"
+  ]),
+  sectionId: identifier19.nullable()
+});
+var DraftOutputReceiptBodySchema = z42.strictObject({
+  schema: z42.literal("felspar.output-receipt.draft/v0"),
+  authority: z42.literal("unapproved"),
+  checkerContract: z42.literal(draftOutputCheckerContract),
+  coverage: z42.literal("declared_structure_and_exact_text"),
+  semanticEvaluation: z42.literal("not_performed"),
+  actionAuthorized: z42.literal(false),
+  inputDigest: digest19,
+  jobReceiptDigest: digest19,
+  compiledArtifactDigest: digest19,
+  capsuleDigest: digest19.nullable(),
+  contractDigest: digest19.nullable(),
+  outputDigest: digest19,
+  outputId: identifier19,
+  outputRevision: identifier19,
+  status: z42.enum(["checks_passed", "invalid", "blocked"]),
+  structuralOnlySectionIds: z42.array(identifier19).max(16),
+  diagnostics: z42.array(DraftOutputDiagnosticSchema).max(81)
+});
+var DraftOutputReceiptSchema = DraftOutputReceiptBodySchema.extend({
+  receiptDigest: digest19
+});
+var DraftOutputVerificationOptionsSchema = z42.strictObject({
+  expectedReceiptDigest: digest19
+});
+
+// ../schemas/src/draft-claim-evaluation-recipe.ts
+var scope = DraftOutputContractSchema.shape;
+var identifier20 = scope.id;
+var text6 = z43.string().min(1).max(2048).regex(/\S/u);
+var ids2 = z43.array(identifier20).max(8).refine(hasUniqueValues, "Duplicate identifier");
+var { judgment: judgment3 } = DraftNormalizedEvidenceSchema.shape.normalizations.element.shape;
+var option = z43.strictObject({
+  value: judgment3.options[0].shape.probabilities.element.shape.value,
+  meaning: text6,
+  effect: z43.enum(["satisfied", "violated", "unresolved"])
+});
+var question = z43.strictObject({
+  id: identifier20,
+  sectionIds: ids2.min(1),
+  instructions: text6,
+  authorityEntryIds: ids2.min(1),
+  evidenceKeys: ids2,
+  options: z43.array(option).min(2).max(8).refine((items) => hasUniqueValues(items.map((item) => item.value)), "Duplicate option").refine((items) => items.some((item) => item.effect === "unresolved"), "Explicit unresolved option required"),
+  minimumSelectedProbability: z43.number().gt(0).max(1)
+});
+var DraftClaimEvaluationRecipeSchema = z43.strictObject({
+  schema: z43.literal("felspar.claim-evaluation-recipe.draft/v0"),
+  id: identifier20,
+  version: identifier20,
+  compiledArtifactDigest: scope.compiledArtifactDigest,
+  job: scope.job,
+  trustDomain: scope.trustDomain,
+  outputSurface: scope.outputSurface,
+  evaluator: DraftEvaluatorContractSchema.shape.evaluator,
+  calibration: DraftEvaluatorContractSchema.shape.calibration,
+  probabilityContract: DraftEvaluatorContractSchema.shape.probabilityContract,
+  questions: z43.array(question).min(1).max(8).refine((items) => hasUniqueValues(items.map((item) => item.id)), "Duplicate question"),
+  limits: z43.strictObject({
+    maxRequests: z43.number().int().min(1).max(128),
+    maxRequestBytes: z43.number().int().min(1).max(16384),
+    maxTotalBytes: z43.number().int().min(1).max(65536)
+  })
+});
+
+// ../schemas/src/draft-artifact-lint-semantic.ts
+var id2 = DraftApplicationScopeSchema.shape.authorityId;
+var digest20 = DraftJobReceiptSchema.shape.receiptDigest;
+var recipe = DraftClaimEvaluationRecipeSchema.shape;
+var recipeQuestion = recipe.questions.element.shape;
+var { judgment: judgment4 } = DraftNormalizedEvidenceSchema.shape.normalizations.element.shape;
+var artifactSemanticLimits = {
+  maxQuestions: 8,
+  maxUnits: 64,
+  maxEvaluations: 128,
+  maxRequestBytes: 32768,
+  maxTotalBytes: 1048576
+};
+var ArtifactSemanticQuestionSchema = z44.strictObject({
+  id: id2,
+  instructions: recipeQuestion.instructions,
+  options: recipeQuestion.options,
+  minimumSelectedProbability: recipeQuestion.minimumSelectedProbability,
+  aggregation: z44.enum(["prohibit", "require", "match"])
+});
+var ArtifactSemanticRecipeSchema = z44.strictObject({
+  evaluator: recipe.evaluator,
+  calibration: recipe.calibration,
+  probabilityContract: recipe.probabilityContract,
+  questions: z44.array(ArtifactSemanticQuestionSchema).min(1).max(artifactSemanticLimits.maxQuestions),
+  limits: z44.strictObject({
+    maxEvaluations: z44.number().int().min(1).max(artifactSemanticLimits.maxEvaluations),
+    maxRequestBytes: z44.number().int().min(1).max(artifactSemanticLimits.maxRequestBytes),
+    maxTotalBytes: z44.number().int().min(1).max(artifactSemanticLimits.maxTotalBytes)
+  })
+});
+var ArtifactSemanticRequestSchema = z44.strictObject({
+  schema: z44.literal("felspar.artifact-question.draft/v1"),
+  preparationDigest: digest20,
+  unitId: id2,
+  sectionId: id2,
+  start: z44.number().int().min(0),
+  end: z44.number().int().min(1),
+  textDigest: digest20,
+  text: z44.string().min(1),
+  questionId: id2,
+  instructions: recipeQuestion.instructions,
+  options: z44.array(z44.strictObject({ value: z44.string(), meaning: z44.string() })).min(2).max(8),
+  policy: z44.array(z44.strictObject({ sourceLocator: z44.string(), text: z44.string() })).min(1),
+  evaluator: recipe.evaluator,
+  calibration: recipe.calibration,
+  requestDigest: digest20
+});
+var ArtifactSemanticResponseSchema = z44.strictObject({
+  schema: z44.literal("felspar.artifact-question-response.draft/v1"),
+  preparationDigest: digest20,
+  evaluator: recipe.evaluator,
+  calibrationDigest: digest20,
+  answers: z44.array(z44.strictObject({ unitId: id2, questionId: id2, requestDigest: digest20, judgment: judgment4 })).max(artifactSemanticLimits.maxEvaluations)
+});
+var ArtifactSemanticJudgmentSchema = z44.strictObject({
+  unitId: id2,
+  sectionId: id2,
+  start: z44.number().int().min(0),
+  end: z44.number().int().min(1),
+  textDigest: digest20,
+  questionId: id2,
+  requestDigest: digest20,
+  judgment: judgment4.nullable(),
+  value: z44.string().nullable(),
+  effect: z44.enum(["satisfied", "violated", "unresolved", "unavailable", "not_stated"]),
+  reasons: z44.array(z44.string().max(128)).max(8)
+});
+var ArtifactSemanticRecordSchema = z44.strictObject({
+  state: z44.enum(["ready", "skipped", "over_budget", "not_evaluated"]),
+  preparationDigest: digest20,
+  evaluator: ArtifactSemanticRecipeSchema.shape.evaluator,
+  calibrationDigest: digest20,
+  probabilityContract: ArtifactSemanticRecipeSchema.shape.probabilityContract,
+  questions: z44.array(ArtifactSemanticQuestionSchema.pick({
+    id: true,
+    minimumSelectedProbability: true,
+    aggregation: true
+  }).extend({
+    checkId: id2,
+    anchorSectionId: id2,
+    sectionsAvailable: z44.boolean(),
+    units: z44.number().int().min(0).max(artifactSemanticLimits.maxEvaluations),
+    options: z44.array(z44.strictObject({
+      value: ArtifactSemanticQuestionSchema.shape.options.element.shape.value,
+      effect: z44.enum(["satisfied", "violated", "unresolved", "not_stated"])
+    })).min(2).max(8)
+  })).max(artifactSemanticLimits.maxQuestions),
+  judgments: z44.array(ArtifactSemanticJudgmentSchema).max(artifactSemanticLimits.maxEvaluations)
+});
+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";
+  }
+  const offered = new Set(question2.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));
+}
+function isAsking(check) {
+  const isAsker = check.kind === "semantic_question" || check.kind === "case_answer";
+  return typeof check.questionId === "string" && isAsker;
+}
+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)) {
+      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))) {
+    issue("Every released semantic question is asked by exactly one check");
+  }
+  for (const question2 of questions) {
+    if (question2.aggregation === "match") {
+      continue;
+    }
+    const effects = new Set(question2.options.map((option2) => option2.effect));
+    const needed = question2.aggregation === "prohibit" ? "violated" : "satisfied";
+    if (!effects.has(needed)) {
+      issue("A semantic question needs an option that can decide its aggregation");
+    }
+  }
+}
+
+// ../schemas/src/draft-artifact-check-manifest.ts
+var id3 = DraftApplicationScopeSchema.shape.authorityId;
+var digest21 = DraftJobReceiptSchema.shape.receiptDigest;
+var artifactLintLimits = {
+  maxTotalBytes: 65536,
+  maxSections: 16,
+  maxSectionUnits: 16384,
+  maxChecks: 64,
+  maxAlternatives: 8,
+  maxLiterals: 32,
+  maxLiteralUnits: 512,
+  maxOccurrencesPerCheck: 16
+};
+function isWellFormedText(value) {
+  return !/\p{Cs}/u.test(value);
+}
+var literal = z45.string().min(1).max(artifactLintLimits.maxLiteralUnits).regex(/\S/u).refine(isWellFormedText);
+var passage = z45.strictObject({
+  sourceLocator: z45.string().min(1).max(4096).regex(/\S/u),
+  contentDigest: digest21
+});
+var common = { id: id3, required: z45.boolean(), specification: passage };
+var artifactCheckKinds = [
+  "section",
+  "required_wording",
+  "prohibited_literal",
+  "field_value",
+  "semantic_question",
+  "case_answer"
+];
+var artifactLintMediaTypes = [
+  "text/plain",
+  "application/vnd.felspar.structured-output+json"
+];
+var sectionTargets = z45.array(id3).min(1).max(artifactLintLimits.maxSections);
+var ArtifactCheckSchema = z45.discriminatedUnion("kind", [
+  z45.strictObject({ ...common, kind: z45.literal("section"), sectionId: id3 }),
+  z45.strictObject({
+    ...common,
+    kind: z45.literal("required_wording"),
+    sectionId: id3,
+    alternatives: z45.array(literal).min(1).max(artifactLintLimits.maxAlternatives)
+  }),
+  z45.strictObject({
+    ...common,
+    kind: z45.literal("prohibited_literal"),
+    sectionIds: sectionTargets,
+    literals: z45.array(literal).min(1).max(artifactLintLimits.maxLiterals)
+  }),
+  z45.strictObject({
+    ...common,
+    kind: z45.literal("field_value"),
+    sectionId: id3,
+    label: z45.string().min(1).max(128).regex(/^[^\s:](?:[^\n\r:]*[^\s:])?$/u).refine(isWellFormedText),
+    unit: z45.string().min(1).max(32).regex(/^\S+$/u).refine(isWellFormedText).nullable(),
+    evidenceKey: id3,
+    comparator: z45.enum(["eq", "lte", "gte"])
+  }),
+  z45.strictObject({
+    ...common,
+    kind: z45.literal("case_answer"),
+    sectionIds: sectionTargets,
+    fact: z45.discriminatedUnion("comparison", [
+      z45.strictObject({ key: id3, comparison: z45.literal("choice") }),
+      z45.strictObject({
+        key: id3,
+        comparison: z45.literal("number"),
+        reader: ExactReaderSchema.options[0]
+      }),
+      z45.strictObject({
+        key: id3,
+        comparison: z45.literal("date"),
+        reader: ExactReaderSchema.options[1]
+      })
+    ]),
+    answers: z45.array(z45.strictObject({
+      value: id3,
+      wording: z45.array(literal).max(artifactLintLimits.maxAlternatives)
+    })).max(artifactLintLimits.maxLiterals),
+    questionId: id3.nullable()
+  }),
+  z45.strictObject({
+    ...common,
+    kind: z45.literal("semantic_question"),
+    sectionIds: sectionTargets,
+    questionId: id3
+  })
+]);
+var sectionDeclaration = z45.strictObject({
+  id: id3,
+  heading: z45.string().min(1).max(256).regex(/\S/u).refine((value) => !/[\n\r]/u.test(value) && isWellFormedText(value)).nullable(),
+  maxUnits: z45.number().int().min(1).max(artifactLintLimits.maxSectionUnits)
+});
+function caseAnswerIssues(checks) {
+  const issues = [];
+  for (const check of checks) {
+    if (check.kind !== "case_answer") {
+      continue;
+    }
+    const values = check.answers.map((row2) => row2.value);
+    const distinct = new Set(values);
+    if (distinct.size !== values.length || distinct.has("not_stated")) {
+      issues.push("A case answer check lists each answer once");
+    }
+    const isChoice = check.fact.comparison === "choice";
+    if (isChoice ? values.length < 2 : values.length > 0 || check.questionId !== null) {
+      issues.push("A choice fact lists its answers; a number or date fact has none and no question");
+    }
+  }
+  return issues;
+}
+var ArtifactCheckManifestSchema = z45.strictObject({
+  schema: z45.literal("felspar.artifact-check-manifest.draft/v1"),
+  id: id3,
+  version: z45.number().int().min(1).max(65535),
+  jobId: id3,
+  trustDomain: id3,
+  contract: z45.strictObject({ id: id3, digest: digest21 }),
+  parser: z45.enum(["body", "headings"]),
+  maxBytes: z45.number().int().min(1).max(artifactLintLimits.maxTotalBytes),
+  sections: z45.array(sectionDeclaration).min(1).max(artifactLintLimits.maxSections),
+  caseContext: z45.enum(["required", "not_required"]),
+  checks: z45.array(ArtifactCheckSchema).min(1).max(artifactLintLimits.maxChecks),
+  semantic: ArtifactSemanticRecipeSchema.nullable()
+}).superRefine((manifest2, context3) => {
+  const issue = (message) => {
+    context3.addIssue({ code: "custom", message });
+  };
+  const sectionIds = manifest2.sections.map((section) => section.id);
+  const sections = new Set(sectionIds);
+  const checkIds = new Set(manifest2.checks.map((check) => check.id));
+  if (sections.size !== sectionIds.length || checkIds.size !== manifest2.checks.length) {
+    issue("Duplicate section or check identity");
+  }
+  const headings = manifest2.sections.map((section) => section.heading);
+  const isBody = manifest2.parser === "body";
+  if (isBody ? headings.length !== 1 || headings[0] !== null : headings.includes(null)) {
+    issue("Body parser declares one unheaded section; heading parser heads every section");
+  }
+  const distinctHeadings = new Set(headings);
+  if (distinctHeadings.size !== headings.length) {
+    issue("Duplicate section heading");
+  }
+  for (const check of manifest2.checks) {
+    const targets = "sectionIds" in check ? check.sectionIds : [check.sectionId];
+    const distinctTargets = new Set(targets);
+    if (distinctTargets.size !== targets.length || targets.some((t) => !sections.has(t))) {
+      issue("Check targets an undeclared or repeated section");
+    }
+  }
+  const structural = manifest2.checks.filter((check) => check.kind === "section");
+  const covered = new Set(structural.map((check) => check.sectionId));
+  if (structural.length !== sectionIds.length || covered.size !== sectionIds.length) {
+    issue("Every declared section needs exactly one section check");
+  }
+  inspectSemantic(manifest2, issue);
+  for (const message of caseAnswerIssues(manifest2.checks)) {
+    issue(message);
+  }
+  const isCaseBound = manifest2.checks.some((check) => check.kind === "field_value" || check.kind === "case_answer");
+  if (isCaseBound !== (manifest2.caseContext === "required")) {
+    issue("Case context must be required exactly when a check reads case evidence");
+  }
+});
+var ArtifactSpecificationSchema = passage;
+
+// ../schemas/src/draft-job-obligations-manifest.ts
+import { z as z46 } from "zod";
+var id4 = DraftApplicationScopeSchema.shape.authorityId;
+var digest22 = DraftJobReceiptSchema.shape.receiptDigest;
+var passage2 = {
+  sourceLocator: z46.string().min(1).max(4096).regex(/\S/u),
+  contentDigest: digest22
+};
+var jobObligationsLimits = {
+  maxOutcomes: 64,
+  maxArtifacts: 16,
+  maxApprovals: 16,
+  maxContracts: 16,
+  maxApprovalTargets: 16,
+  maxManifestBytes: 65536
+};
+var DraftJobObligationsScopeSchema = z46.strictObject({
+  purposeRef: id4,
+  useRef: id4.nullable()
+});
+var artifact = z46.strictObject({
+  id: id4,
+  role: id4,
+  contract: z46.strictObject({ id: id4, digest: digest22 }),
+  ...passage2
+});
+var approval = z46.strictObject({
+  id: id4,
+  policy: z46.strictObject({ id: id4, ...passage2 }),
+  phase: z46.enum(["before_decision", "before_generation", "before_use"]),
+  appliesTo: z46.array(z46.discriminatedUnion("kind", [
+    z46.strictObject({ kind: z46.literal("decision") }),
+    z46.strictObject({ kind: z46.literal("artifact"), id: id4 }),
+    z46.strictObject({ kind: z46.literal("use") })
+  ])).min(1).max(jobObligationsLimits.maxApprovalTargets)
+});
+var outcome = z46.strictObject({
+  outcomeId: id4,
+  ...passage2,
+  contextRequired: z46.boolean(),
+  artifacts: z46.array(artifact).max(jobObligationsLimits.maxArtifacts),
+  approvals: z46.array(approval).max(jobObligationsLimits.maxApprovals)
+});
+var manifest = z46.strictObject({
+  schema: z46.literal("felspar.job-obligations.draft/v0"),
+  jobId: id4,
+  trustDomain: id4,
+  scope: DraftJobObligationsScopeSchema,
+  source: DraftSourceReferenceSchema,
+  contracts: z46.array(z46.strictObject({ id: id4, ...passage2 })).max(jobObligationsLimits.maxContracts),
+  outcomes: z46.array(outcome).min(1).max(jobObligationsLimits.maxOutcomes)
+});
+function unique3(values, context3, path3) {
+  const distinct = new Set(values);
+  if (distinct.size !== values.length) {
+    context3.addIssue({ code: "custom", path: path3, message: "Duplicate obligation identity or target" });
+  }
+}
+function isApprovalTargetValid(item, target, useRef) {
+  switch (item.phase) {
+    case "before_decision": {
+      return target.kind === "decision";
+    }
+    case "before_generation": {
+      return target.kind === "artifact";
+    }
+    case "before_use": {
+      return target.kind === "artifact" || target.kind === "use" && useRef !== null;
+    }
+    default: {
+      return false;
+    }
+  }
+}
+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);
+    if (!isKnown || !isValid) {
+      context3.addIssue({
+        code: "custom",
+        path: ["approvals", item.id],
+        message: "Unknown or incompatible approval target"
+      });
+    }
+  }
+}
+function inspectManifest(value, 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) {
+        context3.addIssue({
+          code: "custom",
+          message: "Dangling or mismatched specification reference"
+        });
+      }
+    }
+    for (const item of selected.approvals) {
+      inspectApproval(item, { selected, scope: value.scope }, context3);
+    }
+  }
+  const encoder2 = new TextEncoder();
+  if (encoder2.encode(JSON.stringify(value)).length > jobObligationsLimits.maxManifestBytes) {
+    context3.addIssue({ code: "custom", message: "Obligations manifest byte limit exceeded" });
+  }
+}
+var DraftJobObligationsSchema = manifest.superRefine(inspectManifest);
+var DraftJobObligationsOutcomeSchema = outcome;
+
+// ../schemas/src/draft-hosted-output-checks.ts
+var hostedOutputCheckLimits = { maxOutputs: 8 };
+var HostedOutputChecksSchema = z47.strictObject({
+  schema: z47.literal("felspar.output-checks.draft/v0"),
+  obligations: DraftJobObligationsSchema,
+  manifests: z47.array(ArtifactCheckManifestSchema).min(1).max(hostedOutputCheckLimits.maxOutputs)
+}).superRefine((value, 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 checked = new Set(manifests.map((manifest2) => manifest2.contract.id));
+  if (checked.size !== manifests.length) {
+    issue("One manifest per output contract");
+  }
+  for (const manifest2 of manifests) {
+    const contract = contracts.get(manifest2.contract.id);
+    if (contract?.contentDigest !== manifest2.contract.digest || manifest2.jobId !== obligations.jobId || manifest2.trustDomain !== obligations.trustDomain) {
+      issue("A manifest differs from its job or contract");
+    }
+  }
+  const required = obligations.outcomes.flatMap((entry2) => entry2.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-hosted-application.ts
+var id5 = z48.string().min(1).max(200).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:@-]*$/u);
+var digest23 = DraftApplicationReleaseSchema.shape.releaseDigest;
+var HostedSourceInputSchema = z48.strictObject({
+  sourceId: id5,
+  revision: id5,
+  title: z48.string().min(1).max(200),
+  text: z48.string().min(1).max(1048576)
+});
+var HostedProposalInputV0Schema = z48.strictObject({
+  sourceObjectId: id5,
+  expectedSourceDigest: digest23,
+  material: DraftApplicationJobMaterialSchema,
+  compilation: DraftCompilationSchema
+});
+var HostedProposalInputV2Schema = z48.strictObject({
+  schema: z48.literal("felspar.hosted-proposal.draft/v2"),
+  sourceObjectId: id5,
+  expectedSourceDigest: digest23,
+  material: DraftApplicationJobMaterialV2Schema,
+  outputChecks: HostedOutputChecksSchema.optional()
+});
+var HostedProposalInputSchema = z48.union([
+  HostedProposalInputV2Schema,
+  HostedProposalInputV0Schema
+]);
+var HostedApprovalInputSchema = z48.strictObject({
+  expectedProposalDigest: digest23,
+  reviewedMeaning: z48.literal(true),
+  reviewedFixtures: z48.literal(true),
+  reviewNote: z48.string().min(1).max(2e3)
+});
+var HostedReleaseInputSchema = z48.strictObject({ expectedApprovalDigest: digest23 });
+var HostedReleaseBundleSchema = z48.strictObject({
+  release: DraftApplicationReleaseSchema,
+  material: DraftAnyApplicationJobMaterialSchema,
+  approvalObjectId: id5,
+  approvalDigest: digest23,
+  proposalDigest: digest23,
+  sourceDigest: digest23,
+  verifiedCompilation: DraftVerifiedCompilationSchema.optional()
+});
+var HostedJobInputSchema = z48.strictObject({
+  executionId: id5,
+  expectedReleaseDigest: digest23,
+  material: DraftAnyApplicationJobMaterialSchema
+});
+var HostedSuppliedJobInputSchema = z48.strictObject({
+  mode: z48.literal("supplied"),
+  executionId: id5,
+  expectedReleaseDigest: digest23,
+  expectedAuthorityDigest: digest23,
+  jobId: id5,
+  entityId: id5,
+  evidence: DraftRequiredDecisionSchema.shape.evidence,
+  passages: DraftLayeredEvaluationSchema.shape.passages.max(256)
+});
+var hostedFactsLimits = {
+  maxExcerptCharacters: 2e3,
+  maxExcerptsPerQuestion: 3,
+  maxFactsBytes: 524288,
+  maxQuestions: 64
+};
+var factSource = z48.strictObject({
+  class: id5,
+  id: DraftSourceReferenceSchema.shape.sourceId,
+  revision: id5.optional(),
+  locator: z48.string().min(1).max(4096).optional(),
+  observedAt: DraftObservationChecksSchema.shape.evaluationTime,
+  sensitivity: id5.optional()
+});
+var excerptText = z48.string().min(1).refine((text7) => text7.length <= hostedFactsLimits.maxExcerptCharacters, "text_too_long");
+var HostedExcerptSchema = z48.strictObject({ text: excerptText, source: factSource });
+var HostedValueFactSchema = z48.strictObject({
+  value: z48.union([z48.string().min(1).max(200), z48.number(), z48.boolean()]),
+  source: factSource.extend({ excerpt: excerptText.optional() })
+});
+var HostedFactSchema = z48.union([
+  HostedValueFactSchema,
+  HostedExcerptSchema,
+  z48.array(HostedExcerptSchema).min(1).refine((excerpts2) => excerpts2.length <= hostedFactsLimits.maxExcerptsPerQuestion, "too_many_excerpts")
+]);
+function factsBytes(facts) {
+  const encoder2 = new TextEncoder();
+  return encoder2.encode(JSON.stringify(facts)).length;
+}
+var HostedFactsJobInputSchema = z48.strictObject({
+  mode: z48.literal("facts"),
+  executionId: id5,
+  expectedReleaseDigest: digest23,
+  jobId: id5,
+  entityId: id5,
+  facts: z48.record(id5, HostedFactSchema).refine((facts) => Object.keys(facts).length <= hostedFactsLimits.maxQuestions, "too_many_questions").refine((facts) => factsBytes(facts) <= hostedFactsLimits.maxFactsBytes, "request_too_large")
+});
+var HostedJobRequestSchema = z48.union([
+  HostedJobInputSchema,
+  HostedSuppliedJobInputSchema,
+  HostedFactsJobInputSchema
+]);
+var HostedClassificationResultSchema = z48.strictObject({
+  key: id5,
+  observationId: id5,
+  record: DraftNormalizedEvidenceSchema.shape.normalizations.element,
+  reason: z48.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable(),
+  cached: z48.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 = z48.strictObject({
+  schema: z48.enum([
+    "felspar.hosted-supplied-execution/v1",
+    "felspar.hosted-supplied-execution/v2",
+    "felspar.hosted-supplied-execution/v3"
+  ]),
+  release: z48.strictObject({ releaseId: id5, releaseDigest: digest23, materialDigest: digest23 }),
+  evaluationTime: z48.iso.datetime(),
+  input: HostedSuppliedJobInputSchema,
+  facts: HostedFactsJobInputSchema.optional(),
+  judgments: z48.array(HostedClassificationResultSchema).max(192).optional(),
+  judgmentsDigest: digest23.optional(),
+  expansion: z48.literal("agreeing-excerpts").optional(),
+  job: z48.record(z48.string(), z48.unknown())
+}).refine(retainsFactsExactly, "Version 3 records, and only they, retain facts with their judgments");
+var HostedObjectSchema = z48.strictObject({
+  id: id5,
+  kind: z48.enum(["source", "proposal", "approval", "release", "evidence", "result", "execution"]),
+  payloadDigest: digest23,
+  objectKey: z48.string().min(1).max(1e3),
+  parentId: id5.nullable(),
+  status: z48.enum(["active", "released", "revoked"]),
+  metadata: z48.record(z48.string(), z48.unknown())
+});
+var HostedJobResultSchema = z48.object({
+  status: z48.string(),
+  reason: z48.string().nullable(),
+  result: z48.object({
+    executionId: z48.string(),
+    releaseId: id5,
+    releaseDigest: digest23,
+    outcome: z48.string().nullable(),
+    scoring: z48.unknown(),
+    context: z48.unknown(),
+    receipt: z48.unknown()
+  }).loose().nullable()
+});
+
+// ../schemas/src/draft-hosted-refusals.ts
+var limits = hostedFactsLimits;
+var formatFix = "The request does not match the facts request format at this path; follow input.jsonSchema from describe.";
+var fixes = {
+  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.",
+  duplicate_excerpt: "The same words from the same source were sent twice for this question. Send each excerpt once.",
+  duplicate_source_locator: "Another excerpt in this request names the same source and locator with different words. Give each passage its own locator (for example the page URL with the section heading after #); the same words may answer several questions.",
+  label_needs_mapping: "Felspar decides answer choices and yes/no questions from source text. Send the words the source says, not a label.",
+  value_not_allowed: "A typed value must be a finite number for a number question or a YYYY-MM-DD date for a date question.",
+  answer_choice_needs_excerpt: "Send this question in a facts request with the source text; Felspar classifies answer choices itself.",
+  text_too_long: `An excerpt is at most ${limits.maxExcerptCharacters} characters. Send the shortest passage that states the fact.`,
+  too_many_excerpts: `Send at most ${limits.maxExcerptsPerQuestion} excerpts per question.`,
+  too_many_questions: `Send at most ${limits.maxQuestions} questions per request.`,
+  request_too_large: `The facts in one request are at most ${limits.maxFactsBytes} bytes. Send shorter excerpts.`,
+  release_changed: "The release changed. Describe the job again and resend with the current release digest.",
+  job_mismatch: "This release serves a different job. Use the job and release from describe.",
+  attempt_limit_reached: "This case has used its decision attempts. Don't ask again: escalate it with the next step from your last result.",
+  rate_limited: "This caller or workspace sent more decision requests in the last minute than its plan allows. Wait retryAfterSeconds, then resend the same request with the same execution ID. Send every question you have evidence for in one facts request per entity instead of one request per question, and spread a large run over time; for runs of thousands of entities, ask Felspar about batch scoring.",
+  execution_id_reused: "This execution ID was already used for a different request. Use a new execution ID, or resend the original request unchanged.",
+  invalid_body: "The body must be JSON or content parts within the size limit.",
+  forbidden: "This caller may not run this job on this release, or the release is not available. Check the release ID and the caller's access.",
+  source_read_failed: "Felspar couldn't read the document's current version with your own connection. If access is not_connected or reconnect, connect or reconnect Google Drive on the Felspar Sources page; if no_access, ask the document's owner to share it with you; otherwise try again later.",
+  source_text_not_allowed: "An MCP client can't submit text as a source. To use a document's newest text, call add_current_version with its sourceObjectId from list_sources.",
+  source_not_connected: "This source was not added from a connected document. Use a sourceObjectId from list_sources.",
+  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.",
+  no_output_checks: "This job's release declares no output checks. Use the decision's next step; nothing is checked before sending.",
+  output_not_required: "The decided outcome does not require this output. Send one of the outputs listed in required, or none when it is empty.",
+  output_too_large: "The text is longer than this output allows. Shorten it and check again.",
+  invalid_type: formatFix,
+  invalid_union: formatFix,
+  invalid_value: formatFix,
+  invalid_format: formatFix,
+  unrecognized_keys: formatFix,
+  too_big: formatFix,
+  too_small: formatFix
+};
+function hostedRefusalFix(code) {
+  return Object.hasOwn(fixes, code) ? fixes[code] ?? null : null;
+}
+
+// ../schemas/src/draft-hosted-job-description.ts
+import { z as z50 } from "zod";
+
+// ../schemas/src/draft-hosted-output-guides.ts
+import { z as z49 } from "zod";
+var id6 = z49.string().min(1).max(200);
+var located = z49.strictObject({
+  text: z49.string().min(1).max(262144),
+  locator: z49.string().min(1).max(4096)
+});
+var hostedOutputGuideLimits = { maxOutputs: 8, maxContext: 8, maxChecks: 64 };
+var HostedOutputGuideSchema = z49.strictObject({
+  id: id6,
+  what: located,
+  maxCharacters: z49.number().int().min(1),
+  context: z49.array(located.extend({ id: id6 })).max(hostedOutputGuideLimits.maxContext).optional(),
+  checks: z49.array(z49.strictObject({
+    check: id6,
+    rule: z49.string().nullable(),
+    must: z49.string().min(1).max(8e3)
+  })).max(hostedOutputGuideLimits.maxChecks)
+});
+var HostedOutputGuidesSchema = z49.array(HostedOutputGuideSchema).max(hostedOutputGuideLimits.maxOutputs);
+
+// ../schemas/src/draft-hosted-job-description.ts
+var id7 = z50.string().min(1).max(200);
+var digest24 = DraftApplicationReleaseSchema.shape.releaseDigest;
+var { requirements, rules } = DraftRequiredProposalSchema.shape;
+var quotedText = z50.strictObject({
+  text: z50.string().min(1).max(262144),
+  source: DraftSourceReferenceSchema.omit({ contentDigest: true }).extend({
+    locator: z50.string().min(1).max(4096),
+    contentDigest: digest24
+  }),
+  parts: z50.array(z50.strictObject({ locator: z50.string().min(1).max(4096), text: z50.string() })).max(16)
+});
+var HostedJobDescriptionSchema = z50.strictObject({
+  schema: z50.literal("felspar.hosted-job-description.draft/v0"),
+  job: id7,
+  trustDomain: id7,
+  release: z50.strictObject({
+    releaseId: id7,
+    releaseDigest: digest24,
+    materialDigest: digest24,
+    expectedAuthorityDigest: digest24
+  }),
+  resolutionPolicy: DraftRequiredProposalSchema.shape.resolutionPolicy,
+  questions: z50.array(requirements.element.extend({
+    key: id7,
+    type: z50.enum(["enum", "boolean", "number", "date"]),
+    meaning: quotedText,
+    answer: z50.strictObject({
+      send: z50.enum(["text", "text_or_value"]),
+      valueFormat: z50.enum(["number", "calendar-date"]).nullable(),
+      interpretation: z50.enum(["classified", "exact_read", "unsupported"]),
+      threshold: z50.number().gt(0).max(1).nullable(),
+      applies: z50.enum(["always", "conditional"]),
+      dependsOn: z50.array(id7).max(32),
+      appliesWhen: z50.string().min(1).max(2e3).nullable(),
+      reading: ExactReaderSchema.optional()
+    }),
+    answers: z50.array(z50.strictObject({
+      value: id7,
+      meaning: z50.string().nullable(),
+      inclusions: z50.array(z50.string()).max(8),
+      exclusions: z50.array(z50.string()).max(8),
+      examples: z50.array(z50.string()).max(8),
+      edgeCases: z50.array(z50.string()).max(8)
+    })).max(64).optional(),
+    whereToLook: z50.array(quotedText).max(8).optional()
+  })).max(64),
+  rules: z50.array(rules.element.extend({ text: quotedText })).max(256),
+  outcomes: z50.array(z50.strictObject({
+    id: id7,
+    meaning: quotedText.nullable(),
+    nextStep: quotedText.nullable().optional(),
+    outputs: HostedOutputGuidesSchema.optional()
+  })).max(64),
+  whenUnresolved: quotedText.nullable().optional(),
+  attempts: z50.strictObject({
+    max: z50.number().int().min(1).max(10),
+    withProgress: z50.number().int().min(1).max(10),
+    rule: z50.string().min(1).max(1e3)
+  }).optional(),
+  guidance: z50.strictObject({ gather: z50.string().min(1).max(2e3) }),
+  input: z50.strictObject({
+    jsonSchema: z50.record(z50.string(), z50.unknown()),
+    example: HostedFactsJobInputSchema.nullable(),
+    exampleNote: z50.string().max(1e3)
+  }),
+  limits: z50.strictObject({
+    maxEvidenceItems: z50.number().int().positive(),
+    maxPassages: z50.number().int().positive(),
+    facts: z50.strictObject({
+      maxExcerptCharacters: z50.literal(hostedFactsLimits.maxExcerptCharacters),
+      maxExcerptsPerQuestion: z50.literal(hostedFactsLimits.maxExcerptsPerQuestion),
+      maxFactsBytes: z50.literal(hostedFactsLimits.maxFactsBytes),
+      maxQuestions: z50.literal(hostedFactsLimits.maxQuestions)
+    })
+  })
+});
+var interpretedExcerpt = z50.strictObject({
+  id: id7,
+  method: z50.enum(["value", "exact_read", "classified"]),
+  status: z50.enum(["accepted", "needs_evidence", "not_needed"]),
+  value: z50.union([z50.string(), z50.number(), z50.boolean()]).optional(),
+  reasons: z50.array(z50.string()),
+  classification: z50.strictObject({
+    candidate: z50.string().nullable(),
+    probability: z50.number().min(0).max(1).nullable(),
+    abstention: z50.number().min(0).max(1).nullable(),
+    threshold: z50.number().min(0).max(1),
+    alternatives: z50.array(z50.strictObject({ value: z50.string(), probability: z50.number() }))
+  }).optional()
+});
+var ruleSummary = z50.strictObject({ id: id7, outcome: id7, text: quotedText });
+var HostedJobExplanationSchema = z50.strictObject({
+  schema: z50.literal("felspar.hosted-job-explanation.draft/v0"),
+  decision: z50.strictObject({ status: z50.string().nullable(), reasons: z50.array(z50.string()) }),
+  needs: z50.array(z50.strictObject({
+    key: id7,
+    status: z50.string(),
+    reasons: z50.array(z50.string()),
+    acceptedSourceClasses: z50.array(z50.string()),
+    maxAgeMs: z50.number().int().nonnegative(),
+    requiredWhen: HostedJobDescriptionSchema.shape.questions.element.shape.requiredWhen,
+    excerpts: z50.array(interpretedExcerpt).optional()
+  })),
+  why: z50.strictObject({
+    rules: z50.array(ruleSummary),
+    overrides: z50.array(z50.strictObject({ by: id7, target: id7 })),
+    suppressedRuleIds: z50.array(id7),
+    evidence: z50.array(z50.record(z50.string(), z50.unknown()))
+  }).nullable(),
+  context: z50.strictObject({ status: z50.string(), reason: z50.string().nullable() }).nullable(),
+  reviewNeeds: z50.array(z50.string()),
+  evidenceFreshUntil: z50.iso.datetime().nullable()
+});
+var HostedReceiptVerificationInputSchema = z50.strictObject({
+  receipt: DraftJobReceiptSchema,
+  expectedReceiptDigest: digest24,
+  deliveredCapsule: DraftContextVerificationOptionsSchema.shape.deliveredCapsule
+});
+var HostedReceiptVerificationSchema = z50.strictObject({
+  authority: z50.literal("unapproved"),
+  status: z50.enum(["reproduced", "mismatch"]),
+  mismatches: z50.array(z50.string()),
+  decided: z50.strictObject({
+    jobId: id7,
+    entityId: id7,
+    releaseId: id7,
+    outcome: id7.nullable()
+  }).optional()
+});
+
+// ../schemas/src/draft-hosted-output-check-record.ts
+import { z as z53 } from "zod";
+
+// ../schemas/src/draft-artifact-lint.ts
+import { z as z52 } from "zod";
+
+// ../schemas/src/draft-job-obligations.ts
+import { z as z51 } from "zod";
+var id8 = DraftApplicationScopeSchema.shape.authorityId;
+var digest25 = DraftJobReceiptSchema.shape.receiptDigest;
+var outcome2 = DraftJobObligationsOutcomeSchema;
+var DraftApplicationJobMaterialV3Schema = DraftApplicationJobMaterialV2Schema.extend({
+  schema: z51.literal("felspar.application-job-material.draft/v3"),
+  obligations: DraftJobObligationsSchema
+}).superRefine((value, context3) => {
+  if (context3.issues.length > 0) {
+    return;
+  }
+  const { obligations, discovery } = value;
+  const { proposal } = value.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 matches = [
+    isSourceMatches,
+    isComplete,
+    obligations.jobId === proposal.job,
+    obligations.trustDomain === proposal.trustDomain,
+    discovery.job === proposal.job,
+    discovery.trustDomain === proposal.trustDomain
+  ];
+  if (!matches.every(Boolean)) {
+    context3.addIssue({
+      code: "custom",
+      path: ["obligations"],
+      message: "Obligations differ from released job/source/outcomes"
+    });
+  }
+});
+var HostedProposalInputV3Schema = HostedProposalInputV2Schema.extend({
+  schema: z51.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 = z51.strictObject({
+  authority: z51.literal("unapproved"),
+  discovery: z51.record(z51.string(), z51.unknown()),
+  executed: z51.record(z51.string(), z51.unknown()),
+  receipt: DraftJobReceiptSchema
+});
+var DraftJobObligationsInputSchema = z51.strictObject({
+  release: DraftApplicationReleaseSchema,
+  material: z51.union([DraftApplicationJobMaterialV3Schema, DraftAnyApplicationJobMaterialSchema]),
+  execution: DraftJobObligationsExecutionSchema,
+  expectedReceiptDigest: digest25,
+  job: DraftJobObligationsNativeResultSchema,
+  explanation: HostedJobExplanationSchema,
+  invocation: DraftJobObligationsScopeSchema.extend({ caseId: id8 })
+});
+var requirements2 = z51.strictObject({
+  status: z51.enum(["established", "unresolved"]),
+  scope: DraftJobObligationsScopeSchema,
+  artifacts: outcome2.shape.artifacts,
+  approvals: outcome2.shape.approvals,
+  unresolved: z51.array(z51.strictObject({ scopeRef: id8, reasonCodes: z51.array(id8).min(1).max(64) })).max(64)
+});
+var nextReference = z51.discriminatedUnion("kind", [
+  z51.strictObject({ kind: z51.literal("evidence_need"), id: id8 }),
+  z51.strictObject({ kind: z51.literal("artifact_requirement"), id: id8 }),
+  z51.strictObject({ kind: z51.literal("approval_requirement"), id: id8 }),
+  z51.strictObject({ kind: z51.literal("unresolved_scope"), scopeRef: id8 })
+]);
+var DraftJobObligationsAssessmentBodySchema = z51.strictObject({
+  schema: z51.literal("felspar.job-obligations-assessment.draft/v0"),
+  binding: z51.strictObject({
+    releaseDigest: digest25,
+    materialDigest: digest25,
+    nativeReceiptDigest: digest25,
+    jobId: id8,
+    applicationScope: DraftApplicationScopeSchema,
+    caseId: id8,
+    entityId: id8,
+    evaluationTime: z51.iso.datetime({ offset: true }),
+    purposeRef: id8,
+    useRef: id8.nullable()
+  }),
+  requirements: requirements2,
+  next: z51.strictObject({
+    kind: z51.enum([
+      "stop",
+      "review_required",
+      "gather_evidence",
+      "prepare_artifact",
+      "verify_before_action",
+      "return_result"
+    ]),
+    reasonCodes: z51.array(id8).max(64),
+    refs: z51.array(nextReference).max(64)
+  })
+});
+function isNextRefDeclared(ref, required) {
+  switch (ref.kind) {
+    case "artifact_requirement": {
+      return required.artifacts.some((entry2) => entry2.id === ref.id);
+    }
+    case "approval_requirement": {
+      return required.approvals.some((entry2) => entry2.id === ref.id);
+    }
+    case "unresolved_scope": {
+      return required.unresolved.some((entry2) => entry2.scopeRef === ref.scopeRef);
+    }
+    case "evidence_need": {
+      return true;
+    }
+    default: {
+      return false;
+    }
+  }
+}
+var DraftJobObligationsAssessmentSchema = DraftJobObligationsAssessmentBodySchema.extend({
+  assessmentDigest: digest25
+}).superRefine((value, context3) => {
+  const { requirements: required } = value;
+  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) {
+    if (!isNextRefDeclared(ref, required)) {
+      context3.addIssue({ code: "custom", message: "Dangling next reference" });
+    }
+  }
+});
+
+// ../schemas/src/draft-artifact-lint.ts
+var id9 = DraftApplicationScopeSchema.shape.authorityId;
+var digest26 = DraftJobReceiptSchema.shape.receiptDigest;
+var passage3 = ArtifactSpecificationSchema;
+var plainArtifact = z52.strictObject({
+  id: id9,
+  revision: id9,
+  mediaType: z52.literal("text/plain"),
+  exportProfile: id9.nullable(),
+  content: z52.string().max(artifactLintLimits.maxTotalBytes),
+  expectedContentDigest: digest26
+});
+var structuredArtifact = z52.strictObject({
+  id: id9,
+  revision: id9,
+  mediaType: z52.literal("application/vnd.felspar.structured-output+json"),
+  exportProfile: id9.nullable(),
+  content: DraftStructuredOutputSchema,
+  expectedContentDigest: digest26
+});
+var ArtifactLintArtifactSchema = z52.discriminatedUnion("mediaType", [
+  plainArtifact,
+  structuredArtifact
+]);
+var ArtifactLintDecisionSchema = z52.strictObject({
+  inputs: DraftJobObligationsInputSchema,
+  assessment: DraftJobObligationsAssessmentSchema,
+  expectedAssessmentDigest: digest26
+});
+var ArtifactLintInputSchema = z52.strictObject({
+  schema: z52.literal("felspar.lint.draft/v1"),
+  requestId: id9,
+  release: DraftApplicationReleaseSchema,
+  material: DraftApplicationJobMaterialV3Schema,
+  manifest: ArtifactCheckManifestSchema,
+  expectedManifestDigest: digest26,
+  attachedObligations: z52.strictObject({ expectedObligationsDigest: digest26 }).optional(),
+  attachedCase: z52.strictObject({
+    decisionReceiptDigest: digest26,
+    answers: z52.array(z52.strictObject({ key: id9, value: z52.union([z52.string().min(1).max(200), z52.null()]) })).max(256)
+  }).optional(),
+  case: z52.strictObject({ caseId: id9, purposeRef: id9, useRef: id9.nullable() }),
+  artifactRequirementId: id9.nullable(),
+  decision: ArtifactLintDecisionSchema.nullable(),
+  artifact: ArtifactLintArtifactSchema
+});
+var artifactCheckStatuses = [
+  "passed",
+  "violated",
+  "unresolved",
+  "unsupported",
+  "unavailable",
+  "not_applicable",
+  "skipped"
+];
+var range = z52.strictObject({
+  sectionId: id9,
+  start: z52.number().int().min(0).max(artifactLintLimits.maxSectionUnits),
+  end: z52.number().int().min(1).max(artifactLintLimits.maxSectionUnits),
+  offsetUnit: z52.literal("utf16_code_units")
+});
+var findingCodes = [
+  "section_missing",
+  "section_empty",
+  "section_too_large",
+  "section_duplicated",
+  "required_wording_missing",
+  "prohibited_literal",
+  "field_missing",
+  "field_ambiguous",
+  "field_malformed",
+  "field_mismatch",
+  "case_value_unresolved",
+  "text_unassigned",
+  "hidden_formatting",
+  "dependency_unmet",
+  "check_unsupported",
+  "semantic_violation",
+  "semantic_missing",
+  "semantic_unresolved",
+  "case_answer_conflict",
+  "case_answer_missing",
+  "case_answer_unconfirmed",
+  "evaluation_unavailable",
+  "evaluation_budget_exceeded",
+  "evaluation_skipped"
+];
+var ArtifactFindingSchema = z52.strictObject({
+  code: z52.enum(findingCodes),
+  checkId: id9.nullable(),
+  severity: z52.enum(["error", "warning"]),
+  specification: passage3.nullable(),
+  location: range.nullable(),
+  insertionAnchor: z52.strictObject({ sectionId: id9.nullable(), at: z52.number().int().min(0) }).nullable(),
+  literalIndex: z52.number().int().min(0).max(artifactLintLimits.maxLiterals).nullable()
+});
+var ArtifactCheckObservationSchema = z52.strictObject({
+  checkId: id9,
+  kind: z52.enum(artifactCheckKinds),
+  required: z52.boolean(),
+  method: z52.enum(["deterministic", "semantic"]),
+  status: z52.enum(artifactCheckStatuses),
+  occurrences: z52.number().int().min(0),
+  parsedValue: z52.number().nullable(),
+  caseValue: z52.number().nullable()
+});
+var ArtifactLintRecordBodySchema = z52.strictObject({
+  schema: z52.literal("felspar.lint-record.draft/v1"),
+  requestId: id9,
+  status: z52.enum(["pass", "revise", "unavailable", "review_required"]),
+  caseContext: z52.enum(["bound", "not_required"]),
+  binding: z52.strictObject({
+    scope: DraftApplicationScopeSchema,
+    releaseId: id9,
+    releaseDigest: digest26,
+    materialDigest: digest26,
+    obligationsDigest: digest26.optional(),
+    caseFactsDigest: digest26.optional(),
+    jobId: id9,
+    manifestId: id9,
+    manifestDigest: digest26,
+    contract: z52.strictObject({ id: id9, digest: digest26 }),
+    caseId: id9,
+    purposeRef: id9,
+    useRef: id9.nullable(),
+    artifactRequirementId: id9.nullable(),
+    decisionReceiptDigest: digest26.nullable(),
+    obligationsAssessmentDigest: digest26.nullable()
+  }),
+  artifact: z52.strictObject({
+    id: id9,
+    revision: id9,
+    mediaType: z52.enum(artifactLintMediaTypes),
+    exportProfile: id9.nullable(),
+    contentDigest: digest26,
+    sections: z52.array(z52.strictObject({
+      id: id9,
+      units: z52.number().int().min(0),
+      contentDigest: digest26.nullable()
+    })).max(artifactLintLimits.maxSections)
+  }),
+  checks: z52.array(ArtifactCheckObservationSchema).max(artifactLintLimits.maxChecks),
+  findings: z52.array(ArtifactFindingSchema).max(2048),
+  semantic: ArtifactSemanticRecordSchema.nullable(),
+  coverage: z52.strictObject({
+    scope: z52.literal("declared_checks_only"),
+    declared: z52.number().int().min(0),
+    applicable: z52.number().int().min(0),
+    completed: z52.number().int().min(0),
+    required: z52.number().int().min(0),
+    requiredCompleted: z52.number().int().min(0),
+    textAssigned: z52.enum(["complete", "incomplete"]),
+    semantic: z52.enum(["not_declared", "complete", "incomplete"]),
+    nativeDocumentLayout: z52.literal("not_checked")
+  }),
+  actionAuthorized: z52.literal(false)
+});
+var ArtifactLintRecordSchema = ArtifactLintRecordBodySchema.extend({
+  recordDigest: digest26
+});
+var ArtifactLintReceiptSchema = z52.strictObject({
+  schema: z52.literal("felspar.lint-receipt.draft/v1"),
+  recordDigest: digest26,
+  releaseDigest: digest26,
+  manifestDigest: digest26,
+  contractDigest: digest26,
+  caseId: id9,
+  caseContext: z52.enum(["bound", "not_required"]),
+  decisionReceiptDigest: digest26.nullable(),
+  obligationsAssessmentDigest: digest26.nullable(),
+  artifactId: id9,
+  artifactRevision: id9,
+  artifactDigest: digest26,
+  actionAuthorized: z52.literal(false),
+  receiptDigest: digest26
+});
+
+// ../schemas/src/draft-hosted-output-check-record.ts
+var id10 = DraftApplicationScopeSchema.shape.authorityId;
+var digest27 = DraftJobReceiptSchema.shape.receiptDigest;
+var HostedOutputCheckInputSchema = z53.strictObject({
+  executionId: id10,
+  output: id10.optional(),
+  text: z53.string().min(1).max(artifactLintLimits.maxTotalBytes).refine(isWellFormedText, "text_not_well_formed"),
+  revision: id10.optional()
+});
+var HostedOutputCheckRecordSchema = z53.strictObject({
+  schema: z53.literal("felspar.hosted-output-check/v0"),
+  checkId: id10,
+  jobId: id10,
+  output: id10,
+  decision: z53.strictObject({ executionId: id10, outcome: id10, receiptDigest: digest27 }),
+  release: z53.strictObject({ releaseId: id10, releaseDigest: digest27 }),
+  record: ArtifactLintRecordSchema,
+  receipt: ArtifactLintReceiptSchema.nullable(),
+  evaluation: z53.strictObject({
+    modelCalls: z53.number().int().min(0),
+    reason: z53.string().regex(/^[a-z][a-z_]{2,63}$/u).nullable()
+  })
+});
+
+// src/draft-hosted-client.ts
+import { z as z54 } from "zod";
+var digestText = z54.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var HostedOutputCheckReplySchema = z54.object({
+  status: z54.enum(["pass", "revise", "review_required", "unavailable"]),
+  checkId: z54.string(),
+  output: z54.string(),
+  findings: z54.array(z54.record(z54.string(), z54.unknown())),
+  receipt: z54.object({ receiptDigest: digestText, artifactDigest: digestText }).loose().nullable(),
+  decision: z54.object({ executionId: z54.string(), receiptDigest: digestText }),
+  actionAuthorized: z54.literal(false)
+}).loose();
+var hostedPartsContentType = "application/x.felspar-content-parts";
+async function partsBody(value) {
+  const packed = await packContentParts(value);
+  return packed.text;
+}
+async function factsRequest(value, describeRelease) {
+  if (typeof value.expectedReleaseDigest === "string") {
+    return HostedFactsJobInputSchema.parse({ mode: "facts", ...value });
+  }
+  const described = await describeRelease(HostedObjectSchema.shape.id.parse(value.jobId));
+  return HostedFactsJobInputSchema.parse({
+    mode: "facts",
+    ...value,
+    expectedReleaseDigest: described.release.releaseDigest
+  });
+}
+function pinnedResult(response, releaseId, input) {
+  if (response.result !== null && (response.result.releaseId !== releaseId || response.result.releaseDigest !== input.expectedReleaseDigest || response.result.executionId !== input.executionId)) {
+    throw new Error("Felspar result pin differs");
+  }
+  return response;
+}
+function describePath(releaseId, jobId) {
+  return `/v0/releases/${encodeURIComponent(releaseId)}/describe?job=${encodeURIComponent(jobId)}`;
+}
+function jobDescriber(fetchDescription) {
+  const descriptions = /* @__PURE__ */ new Map();
+  async function fetchOnce(key3, releaseId, jobId) {
+    try {
+      return await fetchDescription(releaseId, jobId);
+    } catch (error) {
+      descriptions.delete(key3);
+      throw error;
+    }
+  }
+  return async (releaseId, jobId) => {
+    const key3 = `${releaseId}
+${jobId}`;
+    let described = descriptions.get(key3);
+    if (!described) {
+      described = fetchOnce(key3, releaseId, jobId);
+      descriptions.set(key3, described);
+    }
+    const result = await described;
+    if (result.release.releaseId !== releaseId || result.job !== jobId) {
+      throw new Error("Felspar description pin differs");
+    }
+    return result;
+  };
+}
+var refusalCode = z54.string().regex(/^[a-z][a-z_]{2,63}$/u);
+var fieldPath = z54.array(z54.string().max(256)).max(32);
+var refusalSchema = z54.object({
+  error: refusalCode,
+  path: fieldPath.optional(),
+  currentReleaseDigest: z54.string().regex(/^sha256:[a-f0-9]{64}$/u).optional(),
+  retryAfterSeconds: z54.number().int().min(1).max(3600).optional(),
+  issues: z54.array(z54.object({ code: refusalCode, path: fieldPath })).max(64).optional()
+}).transform((value) => {
+  const fix = hostedRefusalFix(value.error);
+  return {
+    ...value,
+    ...fix !== null && { fix },
+    ...value.issues && {
+      issues: value.issues.map((issue) => {
+        const issueFix = hostedRefusalFix(issue.code);
+        return issueFix === null ? issue : { ...issue, fix: issueFix };
+      })
+    }
+  };
+});
+var FelsparRequestError = class extends Error {
+  status;
+  refusal;
+  constructor(options) {
+    const code = options.refusal === null ? "" : `: ${options.refusal.error}`;
+    super(`Felspar request failed (${options.status}${code})`, options);
+    this.name = "FelsparRequestError";
+    this.status = options.status;
+    this.refusal = options.refusal;
+  }
+};
+async function refusalOf(response) {
+  const text7 = await response.text();
+  const parsed = refusalSchema.safeParse(text7.length <= 65536 ? JSON.parse(text7) : null);
+  return parsed.success ? parsed.data : null;
+}
+async function requestError(response) {
+  let refusal = null;
+  try {
+    refusal = await refusalOf(response);
+  } catch {
+  }
+  return new FelsparRequestError({ status: response.status, refusal });
+}
+function authorizationOf(configuration) {
+  if (configuration.session !== void 0 && configuration.agentKey !== void 0) {
+    throw new Error("Use a session or an agent key, not both");
+  }
+  if (configuration.session !== void 0) {
+    return `FelsparSession ${configuration.session}`;
+  }
+  return configuration.agentKey === void 0 ? null : `Bearer ${configuration.agentKey}`;
+}
+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)),
+    readOutputCheck: async (job, checkId) => await call(`${checksOf(job)}/${encodeURIComponent(objectId.parse(checkId))}`, HostedOutputCheckReplySchema)
+  };
+}
+function createHostedFelsparClient(configuration) {
+  const origin = new URL(configuration.origin);
+  const invalid = [
+    origin.protocol !== "https:",
+    origin.username !== "",
+    origin.password !== "",
+    origin.pathname !== "/",
+    origin.search !== "",
+    origin.hash !== ""
+  ];
+  if (invalid.some(Boolean)) {
+    throw new Error("HTTPS origin required");
+  }
+  const authorization = authorizationOf(configuration);
+  const fetcher = configuration.fetcher ?? fetch;
+  async function call(path3, schema, value) {
+    const headers = new Headers(authorization === null ? {} : { Authorization: authorization });
+    const body = value === void 0 ? void 0 : await partsBody(value);
+    if (body !== void 0) {
+      headers.set("Content-Type", hostedPartsContentType);
+    }
+    const response = await fetcher(`${origin.origin}${path3}`, {
+      method: value === void 0 ? "GET" : "POST",
+      headers,
+      credentials: "include",
+      redirect: "error",
+      signal: AbortSignal.timeout(9e4),
+      ...body !== void 0 && { body }
+    });
+    if (!response.ok) {
+      throw await requestError(response);
+    }
+    return schema.parse(await response.json());
+  }
+  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 (id11, value) => await call(`/v0/proposals/${encodeURIComponent(objectId.parse(id11))}/approve`, HostedObjectSchema, HostedApprovalInputSchema.parse(value)),
+    releasePack: async (id11, value) => await call(`/v0/approvals/${encodeURIComponent(objectId.parse(id11))}/release`, DraftApplicationReleaseSchema, HostedReleaseInputSchema.parse(value)),
+    loadRelease: async (id11) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id11))}`, HostedReleaseBundleSchema),
+    describeJob: async (id11, job) => await describe(objectId.parse(id11), objectId.parse(job)),
+    verifyReceipt: async (executionObjectId, value) => await call(`/v0/executions/${encodeURIComponent(objectId.parse(executionObjectId))}/verify`, HostedReceiptVerificationSchema, HostedReceiptVerificationInputSchema.parse(value)),
+    ...outputCheckCalls(call),
+    executeJob: async (id11, value) => await call(`/v0/releases/${encodeURIComponent(objectId.parse(id11))}/jobs`, HostedJobResultSchema, HostedJobInputSchema.parse(value)),
+    resolveFacts: async (id11, value) => {
+      const releaseId = objectId.parse(id11);
+      const input = await factsRequest(value, async (jobId) => await describe(releaseId, jobId));
+      const path3 = `/v0/releases/${encodeURIComponent(releaseId)}/jobs`;
+      return pinnedResult(await call(path3, HostedJobResultSchema, input), releaseId, input);
+    },
+    resolveJob: async (id11, value) => {
+      const input = HostedSuppliedJobInputSchema.parse(value);
+      const releaseId = objectId.parse(id11);
+      const response = await call(`/v0/releases/${encodeURIComponent(releaseId)}/jobs`, HostedJobResultSchema, input);
+      return pinnedResult(response, releaseId, input);
+    }
+  };
+}
+
+export {
+  FelsparRequestError,
+  createHostedFelsparClient
+};