@tangle-network/agent-eval 0.128.2 → 0.129.0

package/dist/chunk-PC5DOSM7.js

@@ -0,0 +1,579 @@
+// src/rollout/gate-checks.ts
+var GATE_CHECK_IDS = [
+  "reward-relationship",
+  "gated-evidence",
+  "undeclared-step-payload",
+  "unscreened-reward"
+];
+var field = (subject, name) => subject.outcome?.[name];
+function readReward(value) {
+  if (value === null || value === void 0) return { kind: "absent" };
+  if (typeof value === "number") {
+    if (Number.isNaN(value)) return { kind: "unreadable", shown: "NaN" };
+    return value > 0 ? { kind: "positive", shown: String(value) } : { kind: "cleared" };
+  }
+  return {
+    kind: "unreadable",
+    shown: `${JSON.stringify(value) ?? String(value)} (${typeof value})`
+  };
+}
+var isPlainRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function payloadIsPopulated(value) {
+  if (value === void 0 || value === null) return false;
+  if (isPlainRecord(value)) return Object.keys(value).length > 0;
+  return true;
+}
+var DECLARED_STEP_KEYS = {
+  kind: true,
+  name: true,
+  input: true,
+  output: true,
+  status: true,
+  durationMs: true,
+  llm_call_count: true,
+  prompt_token_ids: true,
+  completion_token_ids: true,
+  logprobs: true
+};
+function undeclaredStepPayload(steps) {
+  if (steps === void 0 || steps === null) return void 0;
+  if (!Array.isArray(steps)) return steps;
+  const extras = [];
+  let found = false;
+  for (const step of steps) {
+    const extra = {};
+    if (isPlainRecord(step)) {
+      for (const [key, value] of Object.entries(step)) {
+        if (key in DECLARED_STEP_KEYS) continue;
+        extra[key] = value;
+        found = true;
+      }
+    } else if (step !== void 0 && step !== null) {
+      extras.push({ step });
+      found = true;
+      continue;
+    }
+    extras.push(extra);
+  }
+  return found ? extras : void 0;
+}
+function declaredSteps(steps) {
+  if (!Array.isArray(steps)) return void 0;
+  const kept = [];
+  for (const step of steps) {
+    if (!isPlainRecord(step)) continue;
+    const projected = {};
+    for (const [key, value] of Object.entries(step)) {
+      if (key in DECLARED_STEP_KEYS) projected[key] = value;
+    }
+    kept.push(projected);
+  }
+  return kept;
+}
+var rewardRelationship = {
+  id: "reward-relationship",
+  refuses: "a positive \u2014 or unreadable \u2014 reward on a line the authenticity screen flagged as gamed",
+  tripwires: [
+    { outcome: { reward: 0.95, realness_gated: true } },
+    // The second population, stated separately because the check held for the
+    // first while passing this one for a full round.
+    { outcome: { reward: "0.95", realness_gated: true } }
+  ],
+  errors: (subject) => {
+    if (field(subject, "realness_gated") !== true) return [];
+    const reading = readReward(field(subject, "reward"));
+    if (reading.kind === "absent" || reading.kind === "cleared") return [];
+    if (reading.kind === "unreadable") {
+      return [
+        `outcome.reward: ${reading.shown} with outcome.realness_gated: true \u2014 the wire format declares this field \`number | null\`, so the gate cannot read this value as a number and cannot establish that the reward was cleared. On a run flagged as gamed that is not evidence of a zero, it is the absence of it, and a consumer that coerces the value (\`"0.95"\`, \`"2"\`) reads a positive reward off a faked success. Emit a number or null \u2014 \`trainingReward\` / \`trainingScore\` from \`rollout/reward.ts\` produce one.`
+      ];
+    }
+    return [
+      `outcome.reward: ${reading.shown} with outcome.realness_gated: true \u2014 a run flagged as gamed may not carry a positive reward. The anti-Goodhart gate forces the reward to 0 (a real verdict: the gate decided) before the line is written, so a fine-tune cannot learn from a faked success. Derive the reward with \`trainingReward\` / \`trainingScore\` from \`rollout/reward.ts\`, or drop the line.`
+    ];
+  }
+};
+function gatedEvidenceOf(subject) {
+  const evidence = {};
+  const metrics = field(subject, "metrics");
+  if (payloadIsPopulated(metrics)) evidence.metrics = metrics;
+  const verdict = field(subject, "verdict");
+  if (verdict !== null && verdict !== void 0) evidence.verdict = verdict;
+  const steps = undeclaredStepPayload(subject.steps);
+  if (steps !== void 0) evidence.steps = steps;
+  return evidence.metrics === void 0 && evidence.verdict === void 0 && steps === void 0 ? void 0 : evidence;
+}
+var gatedEvidence = {
+  id: "gated-evidence",
+  refuses: "the numbers a fabricated reward was computed from, riding along at reward 0",
+  tripwires: [
+    { outcome: { reward: 0, realness_gated: true, metrics: { "layer.tests": 1 } } },
+    // A PRIMITIVE `metrics`: `Object.keys(0.95)` is `[]`, so the emptiness test
+    // this check used to run reported it clean and the verifiers format shipped
+    // it as its per-rubric score dict.
+    { outcome: { reward: 0, realness_gated: true, metrics: 0.95 } }
+  ],
+  errors: (subject) => {
+    if (field(subject, "realness_gated") !== true) return [];
+    const evidence = gatedEvidenceOf(subject);
+    if (evidence === void 0) return [];
+    if (evidence.metrics === void 0 && evidence.verdict === void 0) return [];
+    const path = evidence.metrics !== void 0 ? "outcome.metrics" : "outcome.verdict";
+    return [
+      `${path} is populated with outcome.realness_gated: true \u2014 a run flagged as gamed may not ship the numbers its fabricated reward was computed from, even at reward 0. The per-layer scores in \`metrics\` ARE the reward signal in the verifiers format, and \`verdict\` is the record that claimed the success. Mint through \`assertMinted\`, which relocates both to \`provenance.gated_evidence\` (see \`gateGamedOutcome\`), or drop the line.`
+    ];
+  }
+};
+var undeclaredStepPayloadCheck = {
+  id: "undeclared-step-payload",
+  refuses: "per-step reward signal hung on a gated line\u2019s steps, outside every field the gate read",
+  tripwires: [
+    {
+      outcome: { reward: 0, realness_gated: true },
+      steps: [{ kind: "tool", name: "edit", reward: 0.9 }]
+    }
+  ],
+  errors: (subject) => {
+    if (field(subject, "realness_gated") !== true) return [];
+    const extra = undeclaredStepPayload(subject.steps);
+    if (extra === void 0) return [];
+    return [
+      `steps[] carries fields \`${ROLLOUT_SCHEMA_NAME}\` does not declare (${JSON.stringify(extra).slice(0, 120)}) with outcome.realness_gated: true \u2014 a per-step reward is training signal exactly like the scalar, and the exporters copy \`steps\` through verbatim, so zeroing \`outcome.reward\` while leaving it in place ships the gamed run\u2019s step-level credit assignment at full value. Mint through \`assertMinted\`, which projects the steps down to the declared keys and relocates the rest to \`provenance.gated_evidence.steps\` (see \`gateGamedOutcome\`).`
+    ];
+  }
+};
+var ROLLOUT_SCHEMA_NAME = "tangle.rollout.v1";
+var unscreenedReward = {
+  id: "unscreened-reward",
+  refuses: "a positive reward whose producer declares that no authenticity screen ever ran",
+  tripwires: [
+    { outcome: { reward: 1, realness_gated: false, realness_screened: false } },
+    {
+      outcome: {
+        reward: "2",
+        realness_gated: false,
+        realness_screened: false
+      }
+    }
+  ],
+  errors: (subject) => {
+    if (field(subject, "realness_screened") !== false) return [];
+    const reading = readReward(field(subject, "reward"));
+    if (reading.kind === "absent" || reading.kind === "cleared") return [];
+    return [
+      `outcome.reward: ${reading.shown} with outcome.realness_screened: false \u2014 this producer declares that NO authenticity screen ran on this reward, so nothing has established the success is real, and an unscreened positive reward is exactly the signal the anti-Goodhart gate exists to qualify. Screen the run and write the verdict (\`rolloutRewardFields\` from a \`RunRecord\` carrying \`outcome.realness\`), or emit \`reward: null\` \u2014 an unqualified verdict is a labeled gap, not a measured success.`
+    ];
+  }
+};
+var GATE_CHECKS = {
+  "reward-relationship": rewardRelationship,
+  "gated-evidence": gatedEvidence,
+  "undeclared-step-payload": undeclaredStepPayloadCheck,
+  "unscreened-reward": unscreenedReward
+};
+var enforced = { kind: "enforce" };
+var repairedBy = (by) => ({ kind: "repair", by });
+var omittedBecause = (because) => ({
+  kind: "omit",
+  because
+});
+var GATE_POLICIES = {
+  /**
+   * The schema validator. Rejects the reward relationship and NOTHING ELSE, on
+   * purpose: it runs on every line read off disk, and the other two conditions
+   * describe artifacts that already exist.
+   */
+  validateRolloutLine: {
+    // Stays a REJECTION rather than a transformation. A caller emitting
+    // `{reward: 0.95, realness_gated: true}` is a producer defect and has to
+    // fail loudly; laundering it into `reward: 0` here would hide the producer,
+    // which is the actual bug.
+    "reward-relationship": enforced,
+    "gated-evidence": omittedBecause(
+      "a ledger written before the relocation existed carries `metrics` on its gated lines; rejecting those would make every already-published artifact unreadable. The condition is REPAIRED at `assertMinted` (`gateGamedOutcome`) instead, which is the only door into the training path, so the artifact stays readable and the leak still closes."
+    ),
+    "undeclared-step-payload": omittedBecause(
+      "identical reasoning to `gated-evidence`, one field over: a foreign or pre-unification ledger may carry producer-invented keys on its steps, and refusing to READ those files buys nothing the relocation at `assertMinted` does not already buy. Promotion into training is where it closes."
+    ),
+    "unscreened-reward": omittedBecause(
+      "supervision-journal rows legitimately carry an unscreened positive reward (there is no `RunRecord.outcome.realness` behind them) and must stay writable, readable and reportable. Only PROMOTION into training is closed, at `assertMinted`."
+    )
+  },
+  /**
+   * The mint funnel — the single door every `MintedRolloutLine` passes. Validates
+   * first (so the reward relationship has already been rejected), then refuses
+   * what cannot be repaired, then repairs what can.
+   */
+  assertMinted: {
+    // Re-run after `assertRolloutLine`, which already rejected it. Cheap, and it
+    // makes this entry point independently complete rather than complete only
+    // because of what it happens to call first.
+    "reward-relationship": enforced,
+    "gated-evidence": repairedBy("gateGamedOutcome"),
+    "undeclared-step-payload": repairedBy("gateGamedOutcome"),
+    "unscreened-reward": enforced
+  },
+  /**
+   * The runtime backstop, and the one entry point with no license to omit
+   * anything: it exists for callers the type system never saw (plain JavaScript
+   * handing an object literal to a published exporter), so a check it skips is a
+   * check that does not run at all for them. This is where the fourth leak was.
+   */
+  assertRewardGate: {
+    "reward-relationship": enforced,
+    "gated-evidence": enforced,
+    "undeclared-step-payload": enforced,
+    "unscreened-reward": enforced
+  },
+  /**
+   * The release certifier. Same checks, measured over the rows a release is
+   * ABOUT TO WRITE rather than over one line's outcome — see `REPORT_MEASURES`
+   * in `release/gate-report.ts`, which is the second total map this policy
+   * drives.
+   */
+  assertGateReport: {
+    "reward-relationship": enforced,
+    "gated-evidence": enforced,
+    "undeclared-step-payload": enforced,
+    "unscreened-reward": enforced
+  }
+};
+function gateErrors(subject, policy) {
+  const errors = [];
+  for (const id of GATE_CHECK_IDS) {
+    if (policy[id].kind !== "enforce") continue;
+    errors.push(...GATE_CHECKS[id].errors(subject));
+  }
+  return errors;
+}
+
+// src/rollout/schema.ts
+var ROLLOUT_SCHEMA = "tangle.rollout.v1";
+var ROLLOUT_ROLES = [
+  "agent",
+  "supervisor",
+  "worker",
+  "proposer",
+  "judge",
+  "analyst"
+];
+var ROLLOUT_SPLITS = ["search", "dev", "holdout", "canary"];
+var TRAINABLE_SPLITS = ["search"];
+function isTrainableSplit(split) {
+  return TRAINABLE_SPLITS.includes(split);
+}
+var ROLLOUT_CAPTURES = ["mint", "settle-time", "backfill"];
+var CHAT_ROLES = ["system", "user", "assistant", "tool"];
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isNumberOrNull = (v) => v === null || typeof v === "number";
+var isNumberArray = (v) => Array.isArray(v) && v.every((n) => typeof n === "number" && Number.isFinite(n));
+var isIntegerArray = (v) => Array.isArray(v) && v.every((n) => Number.isInteger(n));
+var isStringOrNull = (v) => v === null || typeof v === "string";
+var isIntegerOrNull = (v) => v === null || Number.isInteger(v);
+function validateChatMessage(value, path, errors) {
+  if (!isRecord(value)) {
+    errors.push(`${path}: not an object`);
+    return;
+  }
+  if (!CHAT_ROLES.includes(value.role))
+    errors.push(`${path}.role: invalid role ${String(value.role)}`);
+  if (!isStringOrNull(value.content)) errors.push(`${path}.content: must be string|null`);
+  if (value.reasoning_content !== void 0 && typeof value.reasoning_content !== "string") {
+    errors.push(`${path}.reasoning_content: must be string when present`);
+  }
+  if (value.tool_call_id !== void 0 && typeof value.tool_call_id !== "string") {
+    errors.push(`${path}.tool_call_id: must be string when present`);
+  }
+  if (value.role === "tool" && typeof value.tool_call_id !== "string") {
+    errors.push(`${path}.tool_call_id: required on role:"tool"`);
+  }
+  if (value.is_copied_context !== void 0 && typeof value.is_copied_context !== "boolean") {
+    errors.push(`${path}.is_copied_context: must be boolean when present`);
+  }
+  if (value.tool_calls !== void 0) {
+    if (!Array.isArray(value.tool_calls)) {
+      errors.push(`${path}.tool_calls: must be an array when present`);
+    } else {
+      value.tool_calls.forEach((call, i) => {
+        if (!isRecord(call) || typeof call.id !== "string" || call.type !== "function") {
+          errors.push(`${path}.tool_calls[${i}]: must be {id, type:"function", function}`);
+          return;
+        }
+        const fn = call.function;
+        if (!isRecord(fn) || typeof fn.name !== "string" || typeof fn.arguments !== "string") {
+          errors.push(
+            `${path}.tool_calls[${i}].function: must be {name: string, arguments: string}`
+          );
+        }
+      });
+    }
+  }
+}
+function validateSection(value, path, fields, errors) {
+  if (!isRecord(value)) {
+    errors.push(`${path}: not an object`);
+    return;
+  }
+  for (const [name, check, expect] of fields) {
+    if (!check(value[name])) errors.push(`${path}.${name}: expected ${expect}`);
+  }
+}
+function gateGamedOutcome(line) {
+  if (line.outcome.realness_gated !== true) return line;
+  const moved = gatedEvidenceOf(line);
+  if (moved === void 0) return line;
+  const kept = line.provenance.gated_evidence;
+  const evidence = {};
+  const metrics = { ...kept?.metrics, ...moved.metrics };
+  if (Object.keys(metrics).length > 0) evidence.metrics = metrics;
+  if (moved.verdict !== void 0) evidence.verdict = moved.verdict;
+  else if (kept?.verdict !== void 0) evidence.verdict = kept.verdict;
+  if (moved.steps !== void 0) evidence.steps = moved.steps;
+  else if (kept?.steps !== void 0) evidence.steps = kept.steps;
+  const steps = moved.steps === void 0 ? line.steps : declaredSteps(line.steps);
+  return {
+    ...line,
+    ...steps === void 0 ? {} : { steps },
+    outcome: { ...line.outcome, metrics: {}, verdict: null },
+    provenance: { ...line.provenance, gated_evidence: evidence }
+  };
+}
+function assertRewardGate(line, context) {
+  const errors = gateErrors(line, GATE_POLICIES.assertRewardGate);
+  if (errors.length > 0) {
+    throw new Error(`${context}: rollout ${line.rollout_id} \u2014 ${errors[0]}`);
+  }
+}
+function validateRolloutLine(value) {
+  const errors = [];
+  if (!isRecord(value)) return ["line: not an object"];
+  if (value.schema !== ROLLOUT_SCHEMA) errors.push(`schema: expected "${ROLLOUT_SCHEMA}"`);
+  if (typeof value.rollout_id !== "string" || value.rollout_id.length === 0)
+    errors.push("rollout_id: expected non-empty string");
+  if (!isStringOrNull(value.parent_rollout_id))
+    errors.push("parent_rollout_id: expected string|null");
+  if (typeof value.run_id !== "string" || value.run_id.length === 0)
+    errors.push("run_id: expected non-empty string");
+  if (!isStringOrNull(value.experiment_id)) errors.push("experiment_id: expected string|null");
+  if (!isStringOrNull(value.candidate_id)) errors.push("candidate_id: expected string|null");
+  if (!isIntegerOrNull(value.generation)) errors.push("generation: expected integer|null");
+  if (!isIntegerOrNull(value.candidate_index)) errors.push("candidate_index: expected integer|null");
+  if (!ROLLOUT_ROLES.includes(value.role))
+    errors.push(`role: invalid role ${String(value.role)}`);
+  validateSection(
+    value.task,
+    "task",
+    [
+      ["suite", (v) => typeof v === "string" && v.length > 0, "non-empty string"],
+      ["instance_id", (v) => typeof v === "string" && v.length > 0, "non-empty string"],
+      [
+        "split",
+        (v) => ROLLOUT_SPLITS.includes(v),
+        `one of ${ROLLOUT_SPLITS.join("|")}`
+      ],
+      ["seed", isNumberOrNull, "number|null"],
+      ["rep", (v) => Number.isInteger(v), "integer"]
+    ],
+    errors
+  );
+  validateSection(
+    value.policy,
+    "policy",
+    [
+      ["harness", isStringOrNull, "string|null"],
+      ["harness_version", isStringOrNull, "string|null"],
+      ["model", isStringOrNull, "string|null"],
+      ["provider", isStringOrNull, "string|null"],
+      ["profile_commit", isStringOrNull, "string|null"],
+      ["sampling", (v) => v === null || isRecord(v), "object|null"]
+    ],
+    errors
+  );
+  if (isRecord(value.policy)) {
+    for (const key of ["prompt_hash", "config_hash", "agent_profile_cell_id"]) {
+      if (value.policy[key] !== void 0 && !isStringOrNull(value.policy[key])) {
+        errors.push(`policy.${key}: expected string|null when present`);
+      }
+    }
+  }
+  if (!Array.isArray(value.messages)) {
+    errors.push("messages: expected array");
+  } else {
+    for (const [i, m] of value.messages.entries()) validateChatMessage(m, `messages[${i}]`, errors);
+  }
+  if (!Array.isArray(value.tool_defs)) {
+    errors.push("tool_defs: expected array");
+  } else {
+    value.tool_defs.forEach((d, i) => {
+      if (!isRecord(d) || d.type !== "function" || !isRecord(d.function) || typeof d.function.name !== "string") {
+        errors.push(`tool_defs[${i}]: must be {type:"function", function:{name}}`);
+      }
+    });
+  }
+  if (value.steps !== void 0) {
+    if (!Array.isArray(value.steps)) {
+      errors.push("steps: expected array when present");
+    } else {
+      value.steps.forEach((s, i) => {
+        if (!isRecord(s) || typeof s.kind !== "string" || typeof s.name !== "string") {
+          errors.push(`steps[${i}]: must be {kind: string, name: string, \u2026}`);
+          return;
+        }
+        if (s.llm_call_count !== void 0 && !Number.isInteger(s.llm_call_count)) {
+          errors.push(`steps[${i}].llm_call_count: expected integer when present`);
+        }
+        for (const key of ["prompt_token_ids", "completion_token_ids"]) {
+          if (s[key] !== void 0 && !isIntegerArray(s[key])) {
+            errors.push(`steps[${i}].${key}: expected integer[] when present`);
+          }
+        }
+        if (s.logprobs !== void 0 && !isNumberArray(s.logprobs)) {
+          errors.push(`steps[${i}].logprobs: expected number[] when present`);
+        }
+      });
+    }
+  }
+  validateSection(
+    value.outcome,
+    "outcome",
+    [
+      ["reward", isNumberOrNull, "number|null"],
+      ["reward_source", isStringOrNull, "string|null"],
+      ["metrics", isRecord, "object"],
+      ["is_completed", (v) => typeof v === "boolean", "boolean"],
+      ["is_truncated", (v) => typeof v === "boolean", "boolean"],
+      ["error", isStringOrNull, "string|null"]
+    ],
+    errors
+  );
+  if (isRecord(value.outcome)) {
+    if (!("verdict" in value.outcome)) errors.push("outcome.verdict: field required (may be null)");
+    if (typeof value.outcome.realness_gated !== "boolean") {
+      errors.push("outcome.realness_gated: expected boolean");
+    }
+    if (value.outcome.realness_screened !== void 0 && typeof value.outcome.realness_screened !== "boolean") {
+      errors.push("outcome.realness_screened: expected boolean when present");
+    }
+    errors.push(
+      ...gateErrors(
+        { outcome: value.outcome, steps: value.steps },
+        GATE_POLICIES.validateRolloutLine
+      )
+    );
+  }
+  validateSection(
+    value.cost,
+    "cost",
+    [
+      ["usd", isNumberOrNull, "number|null"],
+      ["tokens_in", isNumberOrNull, "number|null"],
+      ["tokens_out", isNumberOrNull, "number|null"],
+      ["tokens_reasoning", isNumberOrNull, "number|null"],
+      ["cache_read", isNumberOrNull, "number|null"],
+      ["cache_write", isNumberOrNull, "number|null"],
+      ["wall_s", isNumberOrNull, "number|null"]
+    ],
+    errors
+  );
+  if (isRecord(value.cost) && value.cost.llm_call_count !== void 0 && !(value.cost.llm_call_count === null || Number.isInteger(value.cost.llm_call_count))) {
+    errors.push("cost.llm_call_count: expected integer|null when present");
+  }
+  validateSection(
+    value.artifacts,
+    "artifacts",
+    [
+      ["patch_path", isStringOrNull, "string|null"],
+      ["run_dir", isStringOrNull, "string|null"],
+      ["transcript_ref", isStringOrNull, "string|null"]
+    ],
+    errors
+  );
+  validateSection(
+    value.provenance,
+    "provenance",
+    [
+      [
+        "captured_at",
+        (v) => typeof v === "string" && !Number.isNaN(Date.parse(v)),
+        "ISO-8601 timestamp"
+      ],
+      [
+        "capture",
+        (v) => ROLLOUT_CAPTURES.includes(v),
+        `one of ${ROLLOUT_CAPTURES.join("|")}`
+      ]
+    ],
+    errors
+  );
+  if (isRecord(value.provenance)) {
+    if (value.provenance.gap !== void 0 && typeof value.provenance.gap !== "string") {
+      errors.push("provenance.gap: must be string when present");
+    }
+    const evidence = value.provenance.gated_evidence;
+    if (evidence !== void 0) {
+      if (!isRecord(evidence)) {
+        errors.push("provenance.gated_evidence: must be an object when present");
+      } else if (evidence.metrics !== void 0 && !isRecord(evidence.metrics)) {
+        errors.push("provenance.gated_evidence.metrics: must be an object when present");
+      }
+    }
+  }
+  if (Array.isArray(value.messages) && isRecord(value.provenance)) {
+    if (value.messages.length === 0 && typeof value.provenance.gap !== "string") {
+      errors.push("provenance.gap: required when messages is empty");
+    }
+  }
+  return errors;
+}
+function assertRolloutLine(value, context = "rollout line") {
+  const errors = validateRolloutLine(value);
+  if (errors.length > 0) {
+    throw new Error(`invalid ${context}:
+  ${errors.join("\n  ")}`);
+  }
+}
+function isRolloutLine(value) {
+  return validateRolloutLine(value).length === 0;
+}
+function assertMinted(value, context = "rollout line") {
+  assertRolloutLine(value, context);
+  const refused = gateErrors(value, GATE_POLICIES.assertMinted);
+  if (refused.length > 0) {
+    throw new Error(`invalid ${context}: rollout ${value.rollout_id} \u2014 ${refused[0]}`);
+  }
+  const gated = gateGamedOutcome(value);
+  if (gated.outcome.realness_gated === void 0) {
+    return {
+      ...gated,
+      outcome: { ...gated.outcome, realness_gated: false }
+    };
+  }
+  return gated;
+}
+function assertMintedLines(values, context = "rollout line") {
+  return values.map((value, i) => assertMinted(value, `${context} [${i}]`));
+}
+
+export {
+  GATE_CHECK_IDS,
+  undeclaredStepPayload,
+  gatedEvidenceOf,
+  GATE_CHECKS,
+  GATE_POLICIES,
+  gateErrors,
+  ROLLOUT_SCHEMA,
+  ROLLOUT_ROLES,
+  ROLLOUT_SPLITS,
+  TRAINABLE_SPLITS,
+  isTrainableSplit,
+  ROLLOUT_CAPTURES,
+  CHAT_ROLES,
+  gateGamedOutcome,
+  assertRewardGate,
+  validateRolloutLine,
+  assertRolloutLine,
+  isRolloutLine,
+  assertMinted,
+  assertMintedLines
+};
+//# sourceMappingURL=chunk-PC5DOSM7.js.map