@domino-sdk/relay 1.51.0 → 1.52.1

package/dist/{chunk-VTD4YDEO.js → chunk-IELNFM3V.js}

@@ -2100,8 +2100,40 @@ var trackerTriggerContextSchema = z13.object({
   enrolledAt: timestamp3.optional()
 });
 
-// src/sdk-runtime.ts
+// src/reject-codes.ts
 import * as z14 from "zod";
+var reservedAttemptCodes = Object.freeze([
+  "budget-exhausted",
+  "defer-expired",
+  "defer-limit-exceeded",
+  "evaluator-deferred",
+  "evaluator-progress",
+  "imported",
+  "integration-required",
+  "not-linked",
+  "provider-unavailable",
+  "author-error"
+]);
+var rejectCodeMaxLength = 64;
+var rejectCodePattern = /^[a-z0-9-]+$/;
+function rejectCodeIssue(code) {
+  if (typeof code !== "string" || code.length === 0 || code.length > rejectCodeMaxLength || !rejectCodePattern.test(code)) {
+    return `Invalid reject code ${JSON.stringify(code)}: use lowercase letters, digits and hyphens, at most ${rejectCodeMaxLength} characters, such as "wrong-answers"`;
+  }
+  if (reservedAttemptCodes.includes(code)) {
+    return `Invalid reject code ${JSON.stringify(code)}: Relay writes it itself. A reject code cannot be ${reservedAttemptCodes.join(", ")}`;
+  }
+  return null;
+}
+var rejectCodeSchema = z14.string().superRefine((code, context) => {
+  const issue = rejectCodeIssue(code);
+  if (issue) {
+    context.addIssue({ code: "custom", message: issue });
+  }
+});
+
+// src/sdk-runtime.ts
+import * as z15 from "zod";
 var questScaleLimits = {
   quests: 1e3,
   questTypes: 200,
@@ -2112,22 +2144,22 @@ var sdkRuntimeLimits = {
   /** Characters of module source, summed over all modules. */
   size: 2e6
 };
-var sha256 = z14.string().regex(/^[0-9a-f]{64}$/);
-var sdkRuntimeModulePathSchema = z14.string().max(200).regex(/^[a-z0-9_][a-z0-9_.-]*(\/[a-z0-9_][a-z0-9_.-]*)*\.js$/i).refine(
+var sha256 = z15.string().regex(/^[0-9a-f]{64}$/);
+var sdkRuntimeModulePathSchema = z15.string().max(200).regex(/^[a-z0-9_][a-z0-9_.-]*(\/[a-z0-9_][a-z0-9_.-]*)*\.js$/i).refine(
   (path) => !path.split("/").some((part) => part === "." || part === ".."),
   "Runtime module paths cannot contain . or .. segments"
 );
-var sdkRuntimeReferenceSchema = z14.object({
+var sdkRuntimeReferenceSchema = z15.object({
   digest: sha256,
   /** The SDK version that built the runtime, for display. The digest is what pins it. */
-  sdkVersion: z14.string().min(1).max(64)
+  sdkVersion: z15.string().min(1).max(64)
 }).strict();
-var sdkRuntimeModulesSchema = z14.record(sdkRuntimeModulePathSchema, z14.string().min(1)).refine((modules) => {
+var sdkRuntimeModulesSchema = z15.record(sdkRuntimeModulePathSchema, z15.string().min(1)).refine((modules) => {
   const entries = Object.values(modules);
   return entries.length > 0 && entries.length <= sdkRuntimeLimits.modules && entries.reduce((sum, source) => sum + source.length, 0) <= sdkRuntimeLimits.size;
 }, `A runtime has 1 to ${sdkRuntimeLimits.modules} modules and at most ${sdkRuntimeLimits.size} characters of source`);
 var sdkRuntimeSchema = sdkRuntimeReferenceSchema.extend({
-  zodVersion: z14.string().min(1).max(64),
+  zodVersion: z15.string().min(1).max(64),
   modules: sdkRuntimeModulesSchema
 }).strict();
 async function sdkRuntimeDigest(modules) {
@@ -2142,60 +2174,60 @@ async function sdkRuntimeDigest(modules) {
 }
 
 // src/completion.ts
-import * as z15 from "zod";
-var name = z15.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
-var completionPolicySchema = z15.discriminatedUnion("kind", [
+import * as z16 from "zod";
+var name = z16.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
+var completionPolicySchema = z16.discriminatedUnion("kind", [
   streakPolicySchema,
   counterPolicySchema,
-  z15.object({ kind: z15.literal("once") }).strict(),
-  z15.object({ kind: z15.literal("keyed") }).strict()
+  z16.object({ kind: z16.literal("once") }).strict(),
+  z16.object({ kind: z16.literal("keyed") }).strict()
 ]);
-var completionKeySchema = z15.string().min(1).max(500);
-var budgetSchema = z15.object({
+var completionKeySchema = z16.string().min(1).max(500);
+var budgetSchema = z16.object({
   id: name,
-  scope: z15.enum(["member", "project"]),
+  scope: z16.enum(["member", "project"]),
   /**
    * The project calendar period of the attempt's eligibility time that one bucket covers:
    * `"day"`, `"week"` (ISO, starting on Monday) or `"month"` in the project timezone.
    * `"lifetime"` never resets.
    */
   period: calendarPeriodSchema,
-  limit: z15.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  cost: z15.union([
-    z15.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-    z15.object({ balance: name }).strict()
+  limit: z16.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  cost: z16.union([
+    z16.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    z16.object({ balance: name }).strict()
   ])
 }).strict();
 
 // src/integrations.ts
-import * as z16 from "zod";
-var evaluatorIntegrationProviderSchema = z16.enum(["discord", "x"]);
-var integrationProviderSchema = z16.enum(["discord"]);
-var discordServerSchema = z16.object({
-  id: z16.string().regex(/^[0-9]{1,20}$/),
-  name: z16.string().min(1),
-  icon: z16.string().nullable()
-});
-var projectIntegrationSchema = z16.object({
+import * as z17 from "zod";
+var evaluatorIntegrationProviderSchema = z17.enum(["discord", "x"]);
+var integrationProviderSchema = z17.enum(["discord"]);
+var discordServerSchema = z17.object({
+  id: z17.string().regex(/^[0-9]{1,20}$/),
+  name: z17.string().min(1),
+  icon: z17.string().nullable()
+});
+var projectIntegrationSchema = z17.object({
   provider: integrationProviderSchema,
-  configured: z16.boolean(),
-  status: z16.enum(["disconnected", "ready", "attention"]),
-  revision: z16.number().int().nonnegative(),
+  configured: z17.boolean(),
+  status: z17.enum(["disconnected", "ready", "attention"]),
+  revision: z17.number().int().nonnegative(),
   server: discordServerSchema.nullable(),
-  issue: z16.string().nullable(),
-  connectedAt: z16.number().default(0)
+  issue: z17.string().nullable(),
+  connectedAt: z17.number().default(0)
 });
 
 // src/wallet.ts
-import * as z17 from "zod";
-var solanaAddressSchema = z17.string().min(32).max(44).regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
-var walletChainSchema = z17.enum(["solana", "eip155", "cosmos"]);
+import * as z18 from "zod";
+var solanaAddressSchema = z18.string().min(32).max(44).regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
+var walletChainSchema = z18.enum(["solana", "eip155", "cosmos"]);
 var cosmosNetworkPattern = /^cosmos:[-_a-zA-Z0-9]{1,32}$/;
-var cosmosNetworkSchema = z17.custom(
+var cosmosNetworkSchema = z18.custom(
   (value) => typeof value === "string" && cosmosNetworkPattern.test(value),
   "Use a Cosmos network: cosmos:<chain ID>"
 );
-var cosmosDenomSchema = z17.string().regex(
+var cosmosDenomSchema = z18.string().regex(
   /^[a-zA-Z][a-zA-Z0-9/:._-]{2,127}$/,
   "Use a Cosmos bank denomination such as uatom or uosmo"
 );
@@ -2221,51 +2253,51 @@ function cosmosChain(chain) {
   return { ...value, network };
 }
 var solanaMainnet = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
-var evmAddressSchema = z17.string().regex(/^0x[0-9a-fA-F]{40}$/);
-var cosmosAddressSchema = z17.string().min(8).max(90).regex(
+var evmAddressSchema = z18.string().regex(/^0x[0-9a-fA-F]{40}$/);
+var cosmosAddressSchema = z18.string().min(8).max(90).regex(
   /^(?:[a-z][a-z0-9]{0,82}1[02-9ac-hj-np-z]{38,}|[A-Z][A-Z0-9]{0,82}1[02-9AC-HJ-NP-Z]{38,})$/
 );
-var walletAddressInputSchema = z17.discriminatedUnion("chain", [
-  z17.object({ chain: z17.literal("solana"), address: solanaAddressSchema }).strict(),
-  z17.object({
-    chain: z17.literal("eip155"),
+var walletAddressInputSchema = z18.discriminatedUnion("chain", [
+  z18.object({ chain: z18.literal("solana"), address: solanaAddressSchema }).strict(),
+  z18.object({
+    chain: z18.literal("eip155"),
     address: evmAddressSchema,
     /** Shown in the sign-in message's Chain ID line only: links are chain-agnostic. Defaults to 1. */
-    chainId: z17.number().int().positive().safe().optional()
+    chainId: z18.number().int().positive().safe().optional()
   }).strict(),
-  z17.object({
-    chain: z17.literal("cosmos"),
+  z18.object({
+    chain: z18.literal("cosmos"),
     network: cosmosNetworkSchema,
     address: cosmosAddressSchema
   }).strict()
 ]);
-var walletMessageChallengeSchema = z17.object({
-  id: z17.string().min(1).max(200),
-  purpose: z17.enum(["link", "sign-in"]),
+var walletMessageChallengeSchema = z18.object({
+  id: z18.string().min(1).max(200),
+  purpose: z18.enum(["link", "sign-in"]),
   chain: walletChainSchema,
   network: cosmosNetworkSchema.nullable(),
   /** Canonical (base58, EIP-55 or lowercase bech32). The signer must sign with this address. */
-  address: z17.string(),
-  message: z17.string().max(4096),
-  expiresAt: z17.number().int()
+  address: z18.string(),
+  message: z18.string().max(4096),
+  expiresAt: z18.number().int()
 });
-var walletSignatureSchema = z17.object({
-  challenge: z17.string().min(1).max(200),
+var walletSignatureSchema = z18.object({
+  challenge: z18.string().min(1).max(200),
   /** solana: base58, 64 bytes · eip155: 0x and 130 hex digits (65 bytes) · cosmos: base64, 64 bytes (r‖s) */
-  signature: z17.string().min(1).max(256),
+  signature: z18.string().min(1).max(256),
   /** cosmos only: the base64 33-byte compressed secp256k1 key from signArbitrary's pub_key.value */
-  publicKey: z17.string().max(128).optional()
+  publicKey: z18.string().max(128).optional()
 }).strict();
-var linkedWalletSchema = z17.object({
+var linkedWalletSchema = z18.object({
   chain: walletChainSchema,
   network: cosmosNetworkSchema.nullable(),
-  address: z17.string(),
-  verifiedAt: z17.number().int().nonnegative(),
-  revision: z17.number().int().positive(),
+  address: z18.string(),
+  verifiedAt: z18.number().int().nonnegative(),
+  revision: z18.number().int().positive(),
   /** True when this wallet can sign in: it was first used through wallet sign-in. Linking never enables sign-in. */
-  signIn: z17.boolean()
+  signIn: z18.boolean()
 });
-var walletUnlinkInputSchema = z17.object({ chain: walletChainSchema, address: z17.string().min(1).max(100) }).strict();
+var walletUnlinkInputSchema = z18.object({ chain: walletChainSchema, address: z18.string().min(1).max(100) }).strict();
 async function walletAddressInput(signer) {
   const address = await signer.address();
   switch (signer.chain) {
@@ -2289,8 +2321,8 @@ async function walletAddressInput(signer) {
 }
 var WALLETS_PER_CHAIN = 5;
 var walletSignInFamilies = ["solana", "eip155", "cosmos"];
-var walletSignInNetworkSchema = z17.enum(walletSignInFamilies);
-var walletSignInNetworksSchema = z17.array(walletSignInNetworkSchema).max(walletSignInFamilies.length).refine((values2) => new Set(values2).size === values2.length, {
+var walletSignInNetworkSchema = z18.enum(walletSignInFamilies);
+var walletSignInNetworksSchema = z18.array(walletSignInNetworkSchema).max(walletSignInFamilies.length).refine((values2) => new Set(values2).size === values2.length, {
   message: "Duplicate wallet family"
 }).transform(
   (values2) => walletSignInFamilies.filter((family) => values2.includes(family))
@@ -2315,41 +2347,41 @@ function caip10(wallet, network) {
 function isEvmChainId(value) {
   return /^eip155:[1-9][0-9]{0,15}$/.test(value);
 }
-var evmChainIdSchema = z17.custom(
+var evmChainIdSchema = z18.custom(
   (value) => typeof value === "string" && isEvmChainId(value),
   'Use an EVM chain ID such as "eip155:8453"'
 );
-var units = z17.string().regex(/^(0|[1-9][0-9]*)$/);
+var units = z18.string().regex(/^(0|[1-9][0-9]*)$/);
 var walletBalanceSchema = responseShape(
-  z17.object({
+  z18.object({
     /** Canonical CAIP-2 ID for Solana, EVM or a supported Cosmos SDK chain. */
-    chain: z17.string(),
+    chain: z18.string(),
     /** The canonical mint, EIP-55 contract or Cosmos bank denom; null for a native coin. */
-    token: z17.string().nullable(),
+    token: z18.string().nullable(),
     /** Null when token metadata does not report decimals. */
-    decimals: z17.number().int().min(0).max(255).nullable(),
+    decimals: z18.number().int().min(0).max(255).nullable(),
     /** The sum over `wallets`. */
     total: units,
-    wallets: z17.array(
-      z17.object({ address: z17.string(), amount: units }).strict()
+    wallets: z18.array(
+      z18.object({ address: z18.string(), amount: units }).strict()
     ),
     /** Solana: lowest slot. EVM: approximate latest block. Cosmos: the fixed queried block. */
-    at: z17.object({ kind: z17.enum(["slot", "block"]), number: units }).strict(),
-    observedAt: z17.number().int().nonnegative()
+    at: z18.object({ kind: z18.enum(["slot", "block"]), number: units }).strict(),
+    observedAt: z18.number().int().nonnegative()
   }).strict()
 );
 
 // src/submission-input.ts
-import * as z18 from "zod";
-var textOptionsSchema = z18.object({
-  required: z18.boolean().default(true),
-  minLength: z18.number().int().min(0).max(1e4).default(1),
-  maxLength: z18.number().int().min(1).max(1e4).default(1e4)
+import * as z19 from "zod";
+var textOptionsSchema = z19.object({
+  required: z19.boolean().default(true),
+  minLength: z19.number().int().min(0).max(1e4).default(1),
+  maxLength: z19.number().int().min(1).max(1e4).default(1e4)
 }).strict().refine(
   (v) => v.minLength <= v.maxLength,
   "minLength must not exceed maxLength"
 );
-var hostSchema = z18.string().min(1).max(253).refine((host) => {
+var hostSchema = z19.string().min(1).max(253).refine((host) => {
   if (!/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/i.test(host) || host.includes("..")) {
     return false;
   }
@@ -2360,13 +2392,13 @@ var hostSchema = z18.string().min(1).max(253).refine((host) => {
     return false;
   }
 }, "Use a hostname without a scheme, path, port, or wildcard");
-var urlOptionsSchema = z18.object({
-  required: z18.boolean().default(true),
-  allowedHosts: z18.array(hostSchema).min(1).max(100).optional()
+var urlOptionsSchema = z19.object({
+  required: z19.boolean().default(true),
+  allowedHosts: z19.array(hostSchema).min(1).max(100).optional()
 }).strict();
-var textEvidenceSchema = z18.object({ kind: z18.literal("text"), value: z18.string().max(1e4) }).strict();
-var urlEvidenceSchema = z18.object({ kind: z18.literal("url"), value: z18.string().max(2048) }).strict();
-var valueEvidenceSchema = z18.discriminatedUnion("kind", [
+var textEvidenceSchema = z19.object({ kind: z19.literal("text"), value: z19.string().max(1e4) }).strict();
+var urlEvidenceSchema = z19.object({ kind: z19.literal("url"), value: z19.string().max(2048) }).strict();
+var valueEvidenceSchema = z19.discriminatedUnion("kind", [
   textEvidenceSchema,
   urlEvidenceSchema
 ]);
@@ -2429,22 +2461,22 @@ function xPostId(value) {
 }
 
 // src/quiz.ts
-import * as z19 from "zod";
-var quizId = z19.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
-var quizChoiceSchema = z19.object({ id: quizId, label: z19.string().trim().min(1).max(500) }).strict();
-var quizQuestionSchema = z19.object({
+import * as z20 from "zod";
+var quizId = z20.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
+var quizChoiceSchema = z20.object({ id: quizId, label: z20.string().trim().min(1).max(500) }).strict();
+var quizQuestionSchema = z20.object({
   id: quizId,
-  prompt: z19.string().trim().min(1).max(1e3),
-  choices: z19.array(quizChoiceSchema).min(2).max(8).refine(
+  prompt: z20.string().trim().min(1).max(1e3),
+  choices: z20.array(quizChoiceSchema).min(2).max(8).refine(
     (choices) => new Set(choices.map((choice) => choice.id)).size === choices.length,
     "Choice IDs must be unique"
   )
 }).strict();
-var quizQuestionsSchema = z19.array(quizQuestionSchema).min(1).max(20).refine(
+var quizQuestionsSchema = z20.array(quizQuestionSchema).min(1).max(20).refine(
   (questions) => new Set(questions.map((question) => question.id)).size === questions.length,
   "Question IDs must be unique"
 );
-var quizContentSchema = z19.array(
+var quizContentSchema = z20.array(
   quizQuestionSchema.extend({ correct: quizId }).refine(
     (question) => question.choices.some((choice) => choice.id === question.correct),
     "Choose a correct answer from the available choices"
@@ -2455,99 +2487,99 @@ var quizContentSchema = z19.array(
 );
 
 // src/resources.ts
-import * as z20 from "zod";
-var resourceSourceSchema = z20.union([
-  z20.strictObject({
-    provider: z20.literal("domino"),
-    resource: z20.literal("point-ledger")
+import * as z21 from "zod";
+var resourceSourceSchema = z21.union([
+  z21.strictObject({
+    provider: z21.literal("domino"),
+    resource: z21.literal("point-ledger")
   }),
   discordResourceSourceSchema
 ]);
-var resourceRequestSchema = z20.object({
+var resourceRequestSchema = z21.object({
   source: resourceSourceSchema,
-  query: z20.string().max(100).optional(),
-  cursor: z20.string().regex(/^\d{1,6}$/).optional(),
-  ids: z20.array(z20.string().min(1).max(100)).max(50).optional()
+  query: z21.string().max(100).optional(),
+  cursor: z21.string().regex(/^\d{1,6}$/).optional(),
+  ids: z21.array(z21.string().min(1).max(100)).max(50).optional()
 }).strict();
-var resourceOptionsSchema = z20.object({
-  revision: z20.number().int(),
-  options: z20.array(
-    z20.object({
-      id: z20.string(),
-      label: z20.string(),
-      description: z20.string().optional(),
-      group: z20.string().optional(),
-      disabledReason: z20.string().optional()
+var resourceOptionsSchema = z21.object({
+  revision: z21.number().int(),
+  options: z21.array(
+    z21.object({
+      id: z21.string(),
+      label: z21.string(),
+      description: z21.string().optional(),
+      group: z21.string().optional(),
+      disabledReason: z21.string().optional()
     })
   ),
   /** Pass back as `cursor` for the next page; null on the last one. */
-  nextCursor: z20.string().nullable().default(null),
+  nextCursor: z21.string().nullable().default(null),
   /** @deprecated Use `nextCursor`. Removed in 2.0.0. */
-  cursor: z20.string().nullable()
+  cursor: z21.string().nullable()
 });
 
 // src/settings.ts
-import * as z22 from "zod";
+import * as z23 from "zod";
 
 // src/setting-values.ts
-import * as z21 from "zod";
-var settingInstant = z21.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
-var settingResourceId = z21.union([
-  z21.literal(""),
-  z21.string().regex(/^\S{1,200}$/)
+import * as z22 from "zod";
+var settingInstant = z22.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
+var settingResourceId = z22.union([
+  z22.literal(""),
+  z22.string().regex(/^\S{1,200}$/)
 ]);
 
 // src/settings.ts
-var base = { label: z22.string().min(1), description: z22.string().optional() };
-var settingFieldSchema = z22.discriminatedUnion("kind", [
-  z22.object({
+var base = { label: z23.string().min(1), description: z23.string().optional() };
+var settingFieldSchema = z23.discriminatedUnion("kind", [
+  z23.object({
     ...base,
-    kind: z22.literal("point-ledger"),
-    default: identifier.or(z22.literal(""))
+    kind: z23.literal("point-ledger"),
+    default: identifier.or(z23.literal(""))
   }).strict(),
-  z22.object({ ...base, kind: z22.literal("datetime"), default: settingInstant }).strict(),
-  z22.object({
+  z23.object({ ...base, kind: z23.literal("datetime"), default: settingInstant }).strict(),
+  z23.object({
     ...base,
-    kind: z22.literal("resource"),
+    kind: z23.literal("resource"),
     default: settingResourceId,
     source: resourceSourceSchema
   }).strict(),
-  z22.object({ ...base, kind: z22.literal("quiz"), default: quizContentSchema }).strict(),
-  z22.object({
+  z23.object({ ...base, kind: z23.literal("quiz"), default: quizContentSchema }).strict(),
+  z23.object({
     ...base,
-    kind: z22.literal("text"),
-    default: z22.string(),
-    minLength: z22.number().int().nonnegative(),
-    maxLength: z22.number().int().positive(),
-    multiline: z22.boolean(),
+    kind: z23.literal("text"),
+    default: z23.string(),
+    minLength: z23.number().int().nonnegative(),
+    maxLength: z23.number().int().positive(),
+    multiline: z23.boolean(),
     /**
      * A list Console offers the value from, beside free text: `telegram-chat` lists the
      * project's connected Telegram chats. Unknown pickers read as free text.
      */
-    picker: z22.string().optional()
+    picker: z23.string().optional()
   }).strict(),
-  z22.object({
+  z23.object({
     ...base,
-    kind: z22.literal("integer"),
-    default: z22.number().int(),
-    min: z22.number().int(),
-    max: z22.number().int()
+    kind: z23.literal("integer"),
+    default: z23.number().int(),
+    min: z23.number().int(),
+    max: z23.number().int()
   }).strict(),
-  z22.object({ ...base, kind: z22.literal("boolean"), default: z22.boolean() }).strict(),
-  z22.object({
+  z23.object({ ...base, kind: z23.literal("boolean"), default: z23.boolean() }).strict(),
+  z23.object({
     ...base,
-    kind: z22.literal("choice"),
-    default: z22.string(),
-    options: z22.array(z22.string().min(1)).min(1)
+    kind: z23.literal("choice"),
+    default: z23.string(),
+    options: z23.array(z23.string().min(1)).min(1)
   }).strict()
 ]);
-var settingsFieldsSchema = z22.record(
-  z22.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
+var settingsFieldsSchema = z23.record(
+  z23.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
   settingFieldSchema
 );
-var settingsValuesSchema = z22.record(
-  z22.string(),
-  z22.union([z22.string(), z22.number().finite(), z22.boolean(), quizContentSchema])
+var settingsValuesSchema = z23.record(
+  z23.string(),
+  z23.union([z23.string(), z23.number().finite(), z23.boolean(), quizContentSchema])
 );
 function parseSettings(fields2, input) {
   const shape = {};
@@ -2566,20 +2598,20 @@ function parseSettings(fields2, input) {
         shape[key] = quizContentSchema.default(field.default);
         break;
       case "text":
-        shape[key] = z22.string().min(field.minLength).max(field.maxLength).default(field.default);
+        shape[key] = z23.string().min(field.minLength).max(field.maxLength).default(field.default);
         break;
       case "integer":
-        shape[key] = z22.number().int().min(field.min).max(field.max).default(field.default);
+        shape[key] = z23.number().int().min(field.min).max(field.max).default(field.default);
         break;
       case "boolean":
-        shape[key] = z22.boolean().default(field.default);
+        shape[key] = z23.boolean().default(field.default);
         break;
       case "choice":
-        shape[key] = z22.enum(field.options).default(field.default);
+        shape[key] = z23.enum(field.options).default(field.default);
         break;
     }
   }
-  return settingsValuesSchema.parse(z22.object(shape).strict().parse(input));
+  return settingsValuesSchema.parse(z23.object(shape).strict().parse(input));
 }
 function missingResourceSettings(fields2, values2) {
   return Object.entries(fields2).filter(
@@ -2600,21 +2632,21 @@ function authoringKey(input) {
 }
 
 // src/campaigns.ts
-import * as z23 from "zod";
-var timestamp4 = z23.number().int().safe().nonnegative();
-var availabilityWindowSchema = z23.object({ from: timestamp4, until: timestamp4 }).strict().refine((window) => window.until > window.from, {
+import * as z24 from "zod";
+var timestamp4 = z24.number().int().safe().nonnegative();
+var availabilityWindowSchema = z24.object({ from: timestamp4, until: timestamp4 }).strict().refine((window) => window.until > window.from, {
   message: "Window end must follow its start",
   path: ["until"]
 });
-var campaignDefinitionSchema = z23.object({
+var campaignDefinitionSchema = z24.object({
   key: identifier,
-  title: z23.string().trim().min(1).max(120),
+  title: z24.string().trim().min(1).max(120),
   window: availabilityWindowSchema.optional(),
-  enrollment: z23.enum(["none", "required"]).default("none")
+  enrollment: z24.enum(["none", "required"]).default("none")
 }).strict();
 var campaignAuthoringSchema = campaignDefinitionSchema.omit({ key: true, title: true }).extend({
   ...authoringIdentityShape,
-  title: z23.string().trim().min(1).max(120).optional()
+  title: z24.string().trim().min(1).max(120).optional()
 }).strict().transform((value) => {
   const normalized = value;
   return campaignDefinitionSchema.parse({
@@ -2628,42 +2660,42 @@ function defineCampaign(input) {
 var campaignViewSchema = campaignDefinitionSchema.extend({
   enrolledAt: timestamp4.nullable(),
   withdrawnAt: timestamp4.nullable().default(null),
-  withdrawalReason: z23.string().nullable().default(null)
+  withdrawalReason: z24.string().nullable().default(null)
 });
-var campaignEnrollmentInputSchema = z23.object({ actionId: identifier, campaign: identifier }).strict();
+var campaignEnrollmentInputSchema = z24.object({ actionId: identifier, campaign: identifier }).strict();
 var memberCampaignEnrollmentInputSchema = campaignEnrollmentInputSchema.extend({ member: identifier });
 var campaignWithdrawalInputSchema = campaignEnrollmentInputSchema;
 var memberCampaignWithdrawalInputSchema = campaignWithdrawalInputSchema.extend({
   member: identifier,
-  reason: z23.string().trim().min(1).max(500)
+  reason: z24.string().trim().min(1).max(500)
 });
-var campaignEnrollmentSchema = z23.object({
+var campaignEnrollmentSchema = z24.object({
   campaign: identifier,
   member: identifier,
   enrolledAt: timestamp4,
   withdrawnAt: timestamp4.nullable().default(null),
-  withdrawalReason: z23.string().nullable().default(null)
+  withdrawalReason: z24.string().nullable().default(null)
 });
 
 // src/resource-handle.ts
-import * as z24 from "zod";
+import * as z25 from "zod";
 function resourceHandle(_kind, definition) {
   return definition;
 }
-var ledgerSettingSchema = identifier.or(z24.literal("")).brand();
+var ledgerSettingSchema = identifier.or(z25.literal("")).brand();
 function ledgerKey(ledger) {
   return typeof ledger === "string" ? ledger : ledger.key;
 }
 
 // src/groups.ts
-import * as z25 from "zod";
-var projectGroupSchema = z25.object({
+import * as z26 from "zod";
+var projectGroupSchema = z26.object({
   key: identifier,
-  title: z25.string().trim().min(1).max(120)
+  title: z26.string().trim().min(1).max(120)
 }).strict();
 var projectGroupAuthoringSchema = projectGroupSchema.omit({ key: true, title: true }).extend({
   ...authoringIdentityShape,
-  title: z25.string().trim().min(1).max(120).optional()
+  title: z26.string().trim().min(1).max(120).optional()
 }).strict().transform((value) => {
   return projectGroupSchema.parse({
     ...value,
@@ -2676,92 +2708,92 @@ function defineGroup(input) {
 function projectGroupKey(group) {
   return identifier.parse(group.key);
 }
-var groupTitle = z25.string().trim().min(1).max(120);
-var reason = z25.string().trim().min(1).max(1e3);
-var timestamp5 = z25.number().int().nonnegative().max(864e13);
-var createGroupSchema = z25.object({ actionId: identifier, key: identifier, title: groupTitle }).strict();
-var updateGroupSchema = z25.object({ title: groupTitle }).strict();
-var addGroupMemberSchema = z25.object({ actionId: identifier, member: identifier, reason }).strict();
-var removeGroupMemberSchema = z25.object({ actionId: identifier, reason }).strict();
-var groupPageQuerySchema = z25.strictObject({
+var groupTitle = z26.string().trim().min(1).max(120);
+var reason = z26.string().trim().min(1).max(1e3);
+var timestamp5 = z26.number().int().nonnegative().max(864e13);
+var createGroupSchema = z26.object({ actionId: identifier, key: identifier, title: groupTitle }).strict();
+var updateGroupSchema = z26.object({ title: groupTitle }).strict();
+var addGroupMemberSchema = z26.object({ actionId: identifier, member: identifier, reason }).strict();
+var removeGroupMemberSchema = z26.object({ actionId: identifier, reason }).strict();
+var groupPageQuerySchema = z26.strictObject({
   cursor: pageCursorSchema.optional(),
   /** Items per page, 1–100; the default is 50. */
-  limit: z25.number().int().min(1).max(100).optional()
+  limit: z26.number().int().min(1).max(100).optional()
 });
-var managedGroupSchema = z25.object({
+var managedGroupSchema = z26.object({
   key: identifier,
-  title: z25.string(),
-  members: z25.number().int().nonnegative(),
+  title: z26.string(),
+  members: z26.number().int().nonnegative(),
   createdAt: timestamp5,
   archivedAt: timestamp5.nullable()
 });
-var groupPageSchema = z25.object({
-  items: z25.array(managedGroupSchema),
+var groupPageSchema = z26.object({
+  items: z26.array(managedGroupSchema),
   nextCursor: pageCursorSchema.nullable()
 });
-var groupMemberSchema = z25.object({
+var groupMemberSchema = z26.object({
   member: identifier,
   addedAt: timestamp5.nullable()
 });
-var groupMemberPageSchema = z25.object({
-  items: z25.array(groupMemberSchema),
+var groupMemberPageSchema = z26.object({
+  items: z26.array(groupMemberSchema),
   nextCursor: pageCursorSchema.nullable()
 });
 
 // src/prerequisites.ts
-import * as z26 from "zod";
-var amount = z26.number().int().safe().nonnegative();
+import * as z27 from "zod";
+var amount = z27.number().int().safe().nonnegative();
 var threshold = amount.positive();
-var completionPrerequisiteSchema = z26.discriminatedUnion("scope", [
-  z26.object({
-    kind: z26.literal("completion"),
+var completionPrerequisiteSchema = z27.discriminatedUnion("scope", [
+  z27.object({
+    kind: z27.literal("completion"),
     quest: identifier,
-    scope: z26.literal("ever")
+    scope: z27.literal("ever")
   }).strict(),
-  z26.object({
-    kind: z26.literal("completion"),
+  z27.object({
+    kind: z27.literal("completion"),
     quest: identifier,
-    scope: z26.literal("period"),
+    scope: z27.literal("period"),
     period: calendarPeriodSchema.exclude(["lifetime"])
   }).strict()
 ]);
-var balancePrerequisiteSchema = z26.object({
-  kind: z26.literal("balance"),
+var balancePrerequisiteSchema = z27.object({
+  kind: z27.literal("balance"),
   balance: identifier,
   minimum: threshold
 }).strict();
-var groupPrerequisiteSchema = z26.object({ kind: z26.literal("group"), group: identifier, title: z26.string() }).strict();
-var prerequisiteSchema = z26.discriminatedUnion("kind", [
+var groupPrerequisiteSchema = z27.object({ kind: z27.literal("group"), group: identifier, title: z27.string() }).strict();
+var prerequisiteSchema = z27.discriminatedUnion("kind", [
   completionPrerequisiteSchema,
   balancePrerequisiteSchema,
   groupPrerequisiteSchema
 ]);
-var missingPrerequisiteSchema = z26.union([
-  z26.object({
-    kind: z26.literal("completion"),
+var missingPrerequisiteSchema = z27.union([
+  z27.object({
+    kind: z27.literal("completion"),
     quest: identifier,
-    title: z26.string(),
-    scope: z26.literal("ever")
+    title: z27.string(),
+    scope: z27.literal("ever")
   }),
-  z26.object({
-    kind: z26.literal("completion"),
+  z27.object({
+    kind: z27.literal("completion"),
     quest: identifier,
-    title: z26.string(),
-    scope: z26.literal("period"),
+    title: z27.string(),
+    scope: z27.literal("period"),
     period: calendarPeriodSchema.exclude(["lifetime"]),
-    resetsAt: z26.number().int().safe()
+    resetsAt: z27.number().int().safe()
   }),
-  z26.object({
-    kind: z26.literal("balance"),
+  z27.object({
+    kind: z27.literal("balance"),
     balance: identifier,
-    title: z26.string(),
+    title: z27.string(),
     minimum: threshold,
     current: amount
   }),
-  z26.object({
-    kind: z26.literal("group"),
+  z27.object({
+    kind: z27.literal("group"),
     group: identifier,
-    title: z26.string()
+    title: z27.string()
   })
 ]);
 function completed(quest, options = {}) {
@@ -2792,29 +2824,29 @@ function inGroup(group) {
 var maxPointsAmount = 2147483647;
 
 // src/schema.ts
-import * as z27 from "zod";
-var pointsRewardSchema = z27.object({
-  kind: z27.literal("points").default("points"),
+import * as z28 from "zod";
+var pointsRewardSchema = z28.object({
+  kind: z28.literal("points").default("points"),
   balance: identifier,
-  amount: z27.number().int().min(0).max(maxPointsAmount)
+  amount: z28.number().int().min(0).max(maxPointsAmount)
 }).strict();
-var tieredRewardDefinitionSchema = z27.object({
+var tieredRewardDefinitionSchema = z28.object({
   /** An automatic achievement backed by the project badge catalog. */
   badge: identifier.optional(),
   /** Membership in the project group with this key, added when the reward is delivered. */
   group: identifier.optional(),
   id: identifier,
-  title: z27.string().min(1).max(120),
-  tiers: z27.array(
-    z27.object({ id: identifier, title: z27.string().min(1).max(120) }).strict()
+  title: z28.string().min(1).max(120),
+  tiers: z28.array(
+    z28.object({ id: identifier, title: z28.string().min(1).max(120) }).strict()
   ).min(1).max(20).refine(
     (tiers) => new Set(tiers.map((t) => t.id)).size === tiers.length,
     "Tier IDs must be unique"
   ),
-  inventory: z27.object({ kind: z27.literal("untracked") }).strict(),
-  fulfillment: z27.discriminatedUnion("kind", [
-    z27.object({ kind: z27.literal("staff-handover") }).strict(),
-    z27.object({ kind: z27.literal("automatic") }).strict()
+  inventory: z28.object({ kind: z28.literal("untracked") }).strict(),
+  fulfillment: z28.discriminatedUnion("kind", [
+    z28.object({ kind: z28.literal("staff-handover") }).strict(),
+    z28.object({ kind: z28.literal("automatic") }).strict()
   ])
 }).strict().refine(
   (value) => value.badge === void 0 && value.group === void 0 || value.fulfillment.kind === "automatic" && value.tiers.length === 1 && value.tiers[0].id === "awarded",
@@ -2823,12 +2855,12 @@ var tieredRewardDefinitionSchema = z27.object({
   (value) => value.badge === void 0 || value.group === void 0,
   "A reward is either a badge or a group membership"
 );
-var tieredRewardReferenceSchema = z27.object({
+var tieredRewardReferenceSchema = z28.object({
   id: identifier,
   key: identifier.nullable()
 });
-var tierRewardSchema = z27.object({
-  kind: z27.literal("tier"),
+var tierRewardSchema = z28.object({
+  kind: z28.literal("tier"),
   reward: tieredRewardDefinitionSchema,
   tier: identifier
 }).strict().refine(
@@ -2840,7 +2872,7 @@ var badgeRewardSchema = tierRewardSchema.transform(
     const badge = value.reward.badge;
     if (!badge || value.reward.fulfillment.kind !== "automatic" || value.reward.tiers.length !== 1 || value.tier !== "awarded") {
       context.addIssue({ code: "custom", message: "Invalid badge reward" });
-      return z27.NEVER;
+      return z28.NEVER;
     }
     return { ...value, reward: { ...value.reward, badge } };
   }
@@ -2864,7 +2896,7 @@ var groupRewardSchema = tierRewardSchema.transform(
     const group = value.reward.group;
     if (!group || value.reward.fulfillment.kind !== "automatic" || value.reward.tiers.length !== 1 || value.tier !== "awarded") {
       context.addIssue({ code: "custom", message: "Invalid group reward" });
-      return z27.NEVER;
+      return z28.NEVER;
     }
     return { ...value, reward: { ...value.reward, group } };
   }
@@ -2884,7 +2916,7 @@ function groupReward(key, title) {
   });
 }
 var integrationRewardSchema = discordRewardSchema;
-var rewardSchema = z27.union([
+var rewardSchema = z28.union([
   pointsRewardSchema,
   tierRewardSchema,
   integrationRewardSchema
@@ -2901,39 +2933,39 @@ function rewardKey(reward) {
   }
   return reward.kind === "points" ? "points:" + reward.balance : "tier:" + reward.reward.id;
 }
-var triggerSchema = z27.union([
-  z27.object({
-    kind: z27.literal("manual"),
-    input: z27.literal("text"),
+var triggerSchema = z28.union([
+  z28.object({
+    kind: z28.literal("manual"),
+    input: z28.literal("text"),
     constraints: textOptionsSchema,
-    actor: z27.enum(["member", "staff"]).optional()
+    actor: z28.enum(["member", "staff"]).optional()
   }).strict(),
-  z27.object({
-    kind: z27.literal("manual"),
-    input: z27.literal("url"),
+  z28.object({
+    kind: z28.literal("manual"),
+    input: z28.literal("url"),
     constraints: urlOptionsSchema,
-    actor: z27.enum(["member", "staff"]).optional()
+    actor: z28.enum(["member", "staff"]).optional()
   }).strict(),
-  z27.object({
-    kind: z27.literal("manual"),
-    input: z27.enum(["photo", "quiz", "none"]),
-    actor: z27.enum(["member", "staff"]).optional()
+  z28.object({
+    kind: z28.literal("manual"),
+    input: z28.enum(["photo", "quiz", "none"]),
+    actor: z28.enum(["member", "staff"]).optional()
   }).strict(),
-  z27.object({
-    kind: z27.literal("automatic"),
+  z28.object({
+    kind: z28.literal("automatic"),
     tracker: trackerTriggerPolicySchema.optional()
   }).strict()
 ]);
-var triggerResponseSchema = z27.union(
+var triggerResponseSchema = z28.union(
   triggerSchema.options.map((option) => option.strip())
 );
-var photoResultSchema = z27.object({
-  kind: z27.enum(["pass", "fail", "unclear"]),
-  reason: z27.string().min(1).max(2e3)
+var photoResultSchema = z28.object({
+  kind: z28.enum(["pass", "fail", "unclear"]),
+  reason: z28.string().min(1).max(2e3)
 }).strict();
-var textReviewInputSchema = z27.object({
-  text: z27.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
-  criteria: z27.string().trim().min(1).max(2e3)
+var textReviewInputSchema = z28.object({
+  text: z28.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
+  criteria: z28.string().trim().min(1).max(2e3)
 }).strict();
 var textResultSchema = photoResultSchema;
 var deferPolicy = {
@@ -2947,54 +2979,60 @@ var retryCooldownPolicy = {
   minMs: 1e3,
   maxMs: 6048e5
 };
-var retryCooldownMsSchema = z27.number().int().min(retryCooldownPolicy.minMs).max(retryCooldownPolicy.maxMs);
-var evaluatorProgressSchema = z27.object({
-  current: z27.number().finite().nonnegative(),
-  target: z27.number().finite().positive(),
-  reason: z27.string().min(1).max(2e3)
+var retryCooldownMsSchema = z28.number().int().min(retryCooldownPolicy.minMs).max(retryCooldownPolicy.maxMs);
+var evaluatorProgressSchema = z28.object({
+  current: z28.number().finite().nonnegative(),
+  target: z28.number().finite().positive(),
+  reason: z28.string().min(1).max(2e3)
 }).refine((value) => value.current <= value.target, {
   message: "Progress current must not exceed target"
 });
-var decisionSchema = z27.discriminatedUnion("kind", [
-  z27.strictObject({
-    kind: z27.literal("defer"),
-    reason: z27.string().min(1).max(2e3),
-    retryAfterMs: z27.number().int().min(deferPolicy.minRetryAfterMs).max(deferPolicy.maxRetryAfterMs).optional(),
+var decisionSchema = z28.discriminatedUnion("kind", [
+  z28.strictObject({
+    kind: z28.literal("defer"),
+    reason: z28.string().min(1).max(2e3),
+    retryAfterMs: z28.number().int().min(deferPolicy.minRetryAfterMs).max(deferPolicy.maxRetryAfterMs).optional(),
     /** Absolute Unix milliseconds; the platform can only shorten its existing deadline. */
-    until: z27.number().int().safe().nonnegative().optional()
+    until: z28.number().int().safe().nonnegative().optional()
   }),
-  evaluatorProgressSchema.safeExtend({ kind: z27.literal("progress") }).strict(),
-  z27.object({
-    kind: z27.literal("accept"),
-    rewards: z27.array(rewardSchema).max(10),
+  evaluatorProgressSchema.safeExtend({ kind: z28.literal("progress") }).strict(),
+  z28.object({
+    kind: z28.literal("accept"),
+    rewards: z28.array(rewardSchema).max(10),
     completionKey: completionKeySchema.optional()
   }).strict(),
-  z27.object({
-    kind: z27.literal("reject"),
-    reason: z27.string().min(1).max(2e3),
+  z28.object({
+    kind: z28.literal("reject"),
+    reason: z28.string().min(1).max(2e3),
+    /**
+     * A stable key for the rejection's cause, such as `wrong-answers`, stored as the attempt's
+     * `code`: lowercase letters, digits and hyphens, at most 64 characters, and none of the
+     * codes Relay writes itself.
+     */
+    code: rejectCodeSchema.optional(),
     /** The evaluator asked for human review, but review is off for the quest, so this is a reject. */
-    requestedReview: z27.literal(true).optional()
+    requestedReview: z28.literal(true).optional()
   }).strict(),
-  z27.object({
-    kind: z27.literal("review"),
-    reason: z27.string().min(1).max(2e3),
-    rewards: z27.array(rewardSchema).max(10).optional(),
+  z28.object({
+    kind: z28.literal("review"),
+    reason: z28.string().min(1).max(2e3),
+    rewards: z28.array(rewardSchema).max(10).optional(),
     completionKey: completionKeySchema.optional()
   }).strict()
 ]);
-var reviewModeSchema = z27.enum(["workers-ai"]);
-var storedReviewModeSchema = z27.enum([
+var reviewModeSchema = z28.enum(["workers-ai"]);
+var storedReviewModeSchema = z28.enum([
   "fixture-pass",
   "fixture-fail",
   "fixture-unclear",
   "fixture-error",
   "workers-ai"
 ]);
-var rewardBundleSchema = z27.array(rewardSchema).max(10).refine(
+var rewardBundleSchema = z28.array(rewardSchema).max(10).refine(
   (rewards) => new Set(rewards.map(rewardKey)).size === rewards.length,
   "Use one entry per balance or shared reward"
 );
-var mediaUrlSchema = z27.string().max(2e3).refine((value) => {
+var mediaUrlSchema = z28.string().max(2e3).refine((value) => {
   if (/^\/(?!\/)[^\\\s]*$/.test(value)) {
     return true;
   }
@@ -3004,90 +3042,90 @@ var mediaUrlSchema = z27.string().max(2e3).refine((value) => {
     return false;
   }
 }, "Use an HTTPS URL or a same-site path beginning with /");
-var questStepActionSchema = z27.discriminatedUnion("kind", [
-  z27.object({
-    kind: z27.literal("link"),
+var questStepActionSchema = z28.discriminatedUnion("kind", [
+  z28.object({
+    kind: z28.literal("link"),
     url: mediaUrlSchema.refine(
       (value) => value.startsWith("https://"),
       "Use an HTTPS URL"
     ),
-    label: z27.string().trim().min(1).max(120)
+    label: z28.string().trim().min(1).max(120)
   }).strict()
 ]);
-var questStepSchema = z27.object({
-  title: z27.string().trim().min(1).max(120),
-  description: z27.string().max(4e3).optional(),
+var questStepSchema = z28.object({
+  title: z28.string().trim().min(1).max(120),
+  description: z28.string().max(4e3).optional(),
   action: questStepActionSchema.optional()
 }).strict();
-var questPresentationRequirementSchema = z27.discriminatedUnion("kind", [
-  z27.object({ kind: z27.literal("account"), provider: authProviderSchema }).strict(),
-  z27.object({ kind: z27.literal("wallet"), chain: walletChainSchema.optional() }).strict()
+var questPresentationRequirementSchema = z28.discriminatedUnion("kind", [
+  z28.object({ kind: z28.literal("account"), provider: authProviderSchema }).strict(),
+  z28.object({ kind: z28.literal("wallet"), chain: walletChainSchema.optional() }).strict()
 ]);
-var questPresentationContentSchema = z27.object({
-  steps: z27.array(questStepSchema).max(30).optional(),
+var questPresentationContentSchema = z28.object({
+  steps: z28.array(questStepSchema).max(30).optional(),
   image: mediaUrlSchema.optional(),
-  imageAlt: z27.string().max(500).optional(),
-  requirements: z27.array(questPresentationRequirementSchema).max(10).optional()
+  imageAlt: z28.string().max(500).optional(),
+  requirements: z28.array(questPresentationRequirementSchema).max(10).optional()
 }).strict();
 var questPresentationSchema = questPresentationContentSchema.extend({
   quiz: quizQuestionsSchema.optional(),
-  instructions: z27.string().max(4e3).optional(),
-  video: z27.object({
+  instructions: z28.string().max(4e3).optional(),
+  video: z28.object({
     url: mediaUrlSchema,
     poster: mediaUrlSchema.optional(),
-    captions: z27.object({
+    captions: z28.object({
       url: mediaUrlSchema,
-      language: z27.string().min(2).max(20),
-      label: z27.string().min(1).max(80)
+      language: z28.string().min(2).max(20),
+      label: z28.string().min(1).max(80)
     }).strict().optional()
   }).strict().optional()
 }).strict();
-var questProfileSchema = z27.object({ visible: z27.boolean() }).strict();
+var questProfileSchema = z28.object({ visible: z28.boolean() }).strict();
 var evaluatorProtocol = 2;
-var evaluatorProtocolSchema = z27.literal(evaluatorProtocol);
-var questDescriptionSchema = z27.object({
+var evaluatorProtocolSchema = z28.literal(evaluatorProtocol);
+var questDescriptionSchema = z28.object({
   quest: identifier,
   evaluatorProtocol: evaluatorProtocolSchema,
-  title: z27.string().min(1).max(120),
+  title: z28.string().min(1).max(120),
   presentation: questPresentationSchema.default({}),
-  integrations: z27.array(evaluatorIntegrationProviderSchema).max(10).default([]),
+  integrations: z28.array(evaluatorIntegrationProviderSchema).max(10).default([]),
   fields: settingsFieldsSchema,
   values: settingsValuesSchema,
   rewards: rewardBundleSchema,
-  humanReview: z27.boolean(),
+  humanReview: z28.boolean(),
   trigger: triggerSchema,
   performance: contentPerformancePolicySchema.optional(),
-  requires: z27.array(prerequisiteSchema).max(30).default([]),
+  requires: z28.array(prerequisiteSchema).max(30).default([]),
   campaign: campaignDefinitionSchema.optional(),
   availability: availabilityWindowSchema.optional(),
-  completion: z27.preprocess(refuseStreakTimeZone, completionPolicySchema),
-  visibility: z27.enum(["visible", "hidden"]).default("visible"),
+  completion: z28.preprocess(refuseStreakTimeZone, completionPolicySchema),
+  visibility: z28.enum(["visible", "hidden"]).default("visible"),
   /** Whether completions show on participant profiles (`/v1/profiles/:id/completions`). */
   profile: questProfileSchema.default({ visible: false }),
-  budgets: z27.array(budgetSchema).max(20).default([]),
+  budgets: z28.array(budgetSchema).max(20).default([]),
   /**
    * Milliseconds a member waits after an attempt is rejected (by the evaluator or a reviewer)
    * before submitting this quest again. Only for quests members submit. Omitted: no cooldown.
    */
   retryCooldownMs: retryCooldownMsSchema.optional()
 }).strict();
-var artifactSchema = z27.object({ code: z27.string().min(1).max(1e6) }).strict();
+var artifactSchema = z28.object({ code: z28.string().min(1).max(1e6) }).strict();
 var releaseSchema = artifactSchema.extend({
   /** The SDK runtime the code imports. Absent, the code bundles its own SDK. */
   runtime: sdkRuntimeReferenceSchema.optional(),
   settings: settingsValuesSchema,
   provider: reviewModeSchema,
   expectedRelease: identifier.nullable().optional(),
-  settingRenames: z27.record(z27.string(), z27.string()).optional()
+  settingRenames: z28.record(z28.string(), z28.string()).optional()
 }).strict();
-var batchReleaseSchema = z27.object({
-  releases: z27.array(releaseSchema).min(1).max(questScaleLimits.quests)
+var batchReleaseSchema = z28.object({
+  releases: z28.array(releaseSchema).min(1).max(questScaleLimits.quests)
 }).strict();
-var questSettingsInputSchema = z27.object({
+var questSettingsInputSchema = z28.object({
   quest: identifier,
   expectedRelease: identifier,
   set: settingsValuesSchema,
-  reset: z27.array(z27.string()),
+  reset: z28.array(z28.string()),
   /** Replace the editable presentation fields; null restores the code defaults. */
   presentation: questPresentationContentSchema.nullable().optional()
 }).strict();
@@ -3097,28 +3135,28 @@ var storedQuestDescriptionSchema = questDescriptionSchema.extend({
 var publishedReleaseSchema = responseShape(
   storedQuestDescriptionSchema.extend({
     key: identifier.optional(),
-    code: z27.string(),
+    code: z28.string(),
     /** The SDK runtime `code` imports. Absent, the code bundles its own SDK. */
     runtime: sdkRuntimeReferenceSchema.optional(),
     provider: storedReviewModeSchema,
     id: identifier,
-    createdAt: z27.number(),
-    origin: z27.object({ typeVersion: identifier }).strict().optional(),
-    lifecycle: z27.enum(["active", "paused", "archived"]).default("active"),
-    configuration: z27.object({
+    createdAt: z28.number(),
+    origin: z28.object({ typeVersion: identifier }).strict().optional(),
+    lifecycle: z28.enum(["active", "paused", "archived"]).default("active"),
+    configuration: z28.object({
       defaults: settingsValuesSchema,
       overrides: settingsValuesSchema,
-      preserved: z27.array(z27.string()),
+      preserved: z28.array(z28.string()),
       presentation: questPresentationContentSchema.optional(),
       presentationDefaults: questPresentationContentSchema.optional()
     }).strict().optional()
   })
 );
-var templateSchema = z27.object({
-  code: z27.string(),
+var templateSchema = z28.object({
+  code: z28.string(),
   definition: questDescriptionSchema
 });
-var quizAnswersSchema = z27.record(identifier, identifier).refine(
+var quizAnswersSchema = z28.record(identifier, identifier).refine(
   (answers) => Object.keys(answers).length > 0 && Object.keys(answers).length <= 50,
   "Provide between 1 and 50 answers"
 ).transform(
@@ -3126,17 +3164,17 @@ var quizAnswersSchema = z27.record(identifier, identifier).refine(
     Object.entries(answers).sort(([a], [b]) => a.localeCompare(b))
   )
 );
-var quizEvidenceSchema = z27.object({
-  kind: z27.literal("quiz"),
+var quizEvidenceSchema = z28.object({
+  kind: z28.literal("quiz"),
   release: identifier.optional(),
   answers: quizAnswersSchema
 }).strict();
-var submissionEvidenceSchema = z27.union([
+var submissionEvidenceSchema = z28.union([
   quizEvidenceSchema,
   textEvidenceSchema,
   urlEvidenceSchema
 ]);
-var submitSchema = z27.object({
+var submitSchema = z28.object({
   actionId: identifier,
   quest: identifier,
   member: identifier,
@@ -3144,7 +3182,7 @@ var submitSchema = z27.object({
   input: submissionEvidenceSchema.optional(),
   release: identifier.optional(),
   /** @deprecated Relay refuses a submission that sets it to `true` and ignores `false`. Removed in 2.0.0. */
-  faultAfterReview: z27.boolean().optional()
+  faultAfterReview: z28.boolean().optional()
 }).strict();
 var AttemptStatus = {
   Queued: "queued",
@@ -3156,8 +3194,8 @@ var AttemptStatus = {
   NeedsReview: "needs-review",
   Failed: "failed"
 };
-var attemptStatusSchema = z27.string();
-var attemptSchema = z27.object({
+var attemptStatusSchema = z28.string();
+var attemptSchema = z28.object({
   id: identifier,
   release: identifier,
   quest: identifier,
@@ -3165,25 +3203,29 @@ var attemptSchema = z27.object({
   evidence: identifier.nullable(),
   input: submissionEvidenceSchema.optional(),
   status: attemptStatusSchema,
-  reason: z27.string().nullable(),
-  retries: z27.number(),
-  generation: z27.number(),
-  completion: z27.string().nullable(),
+  reason: z28.string().nullable(),
+  retries: z28.number(),
+  generation: z28.number(),
+  completion: z28.string().nullable(),
   reviewRewards: rewardBundleSchema.nullable().default(null),
   /** Scheduled reruns advance this number; failure retries preserve it. */
-  evaluationRun: z27.number().int().nonnegative().default(0),
-  deferCount: z27.number().int().nonnegative().default(0),
-  deferUntil: z27.number().int().safe().nullable().default(null),
-  nextEvaluationAt: z27.number().int().safe().nullable().default(null),
-  /** Open code: consumers must tolerate new values. */
-  code: z27.string().nullable().default(null),
+  evaluationRun: z28.number().int().nonnegative().default(0),
+  deferCount: z28.number().int().nonnegative().default(0),
+  deferUntil: z28.number().int().safe().nullable().default(null),
+  nextEvaluationAt: z28.number().int().safe().nullable().default(null),
+  /**
+   * Open code: consumers must tolerate new values. Relay writes its own codes, such as
+   * `budget-exhausted`; an attempt the evaluator rejected with `decision.reject({ reason, code })`
+   * carries the evaluator's code in management reads, and null in responses to members.
+   */
+  code: z28.string().nullable().default(null),
   progress: evaluatorProgressSchema.nullable().default(null),
   /**
    * The evaluator asked for human review of a quest with review off, so Domino rejected the attempt
    * with the evaluator's reason. Only set on a rejected attempt.
    */
-  requestedReview: z27.boolean().default(false),
-  createdAt: z27.number()
+  requestedReview: z28.boolean().default(false),
+  createdAt: z28.number()
 });
 var QuestSubmissionStatus = {
   Open: "open",
@@ -3191,9 +3233,9 @@ var QuestSubmissionStatus = {
   Discarded: "discarded",
   Expired: "expired"
 };
-var questSubmissionStatusSchema = z27.string();
+var questSubmissionStatusSchema = z28.string();
 var questSubmissionSchema = responseShape(
-  z27.object({
+  z28.object({
     id: identifier,
     quest: identifier,
     member: identifier,
@@ -3203,85 +3245,85 @@ var questSubmissionSchema = responseShape(
     /** An uploaded photo's evidence ID. */
     evidence: identifier.nullable(),
     /** Submitting was refused because the quest changed: review the draft before submitting again. */
-    reviewRequired: z27.boolean(),
+    reviewRequired: z28.boolean(),
     status: questSubmissionStatusSchema,
     /** The attempt a `submitted` submission admitted. */
     attempt: identifier.nullable(),
-    createdAt: z27.number(),
-    updatedAt: z27.number(),
+    createdAt: z28.number(),
+    updatedAt: z28.number(),
     /** When an open submission expires unless it changes again. */
-    expiresAt: z27.number()
+    expiresAt: z28.number()
   })
 );
-var questSubmissionUpdateSchema = z27.object({
+var questSubmissionUpdateSchema = z28.object({
   release: identifier.nullable().optional(),
   input: submissionEvidenceSchema.nullable().optional(),
   evidence: identifier.nullable().optional()
 }).strict();
 var questSubmissionResultSchema = responseShape(
-  z27.object({
+  z28.object({
     submission: questSubmissionSchema,
     attempt: attemptSchema,
-    replayed: z27.boolean()
+    replayed: z28.boolean()
   })
 );
-var eventSchema = z27.object({
-  id: z27.number(),
-  attempt: z27.string().nullable(),
-  kind: z27.string(),
-  detail: z27.string(),
-  actor: z27.string().nullable().default(null),
-  at: z27.number()
-});
-var pickupSelectionSchema = z27.object({
+var eventSchema = z28.object({
+  id: z28.number(),
+  attempt: z28.string().nullable(),
+  kind: z28.string(),
+  detail: z28.string(),
+  actor: z28.string().nullable().default(null),
+  at: z28.number()
+});
+var pickupSelectionSchema = z28.object({
   item: identifier,
-  revision: z27.number().int().nonnegative()
+  revision: z28.number().int().nonnegative()
 }).strict();
-var pickupAllocationSchema = z27.object({
+var pickupAllocationSchema = z28.object({
   item: identifier,
-  label: z27.string().min(1).max(80)
+  label: z28.string().min(1).max(80)
 }).strict();
-var pickupPolicySchema = z27.discriminatedUnion("kind", [
-  z27.object({ kind: z27.literal("untracked") }).strict(),
-  z27.object({
-    kind: z27.literal("at-pickup"),
-    tiers: z27.array(
-      z27.object({
+var pickupPolicySchema = z28.discriminatedUnion("kind", [
+  z28.object({ kind: z28.literal("untracked") }).strict(),
+  z28.object({
+    kind: z28.literal("at-pickup"),
+    tiers: z28.array(
+      z28.object({
         tier: identifier,
-        variants: z27.array(pickupAllocationSchema).min(1).max(100)
+        variants: z28.array(pickupAllocationSchema).min(1).max(100)
       }).strict()
     ).min(1).max(100)
   }).strict()
 ]);
-var pickupCatalogSchema = z27.object({
+var pickupCatalogSchema = z28.object({
   reward: tieredRewardDefinitionSchema,
-  revision: z27.number().int().nonnegative(),
+  revision: z28.number().int().nonnegative(),
   policy: pickupPolicySchema
 });
-var pickupAvailabilitySchema = z27.discriminatedUnion("kind", [
-  z27.object({ kind: z27.literal("untracked") }).strict(),
-  z27.object({
-    kind: z27.literal("at-pickup"),
-    revision: z27.number().int().nonnegative(),
-    variants: z27.array(
+var pickupAvailabilitySchema = z28.discriminatedUnion("kind", [
+  z28.object({ kind: z28.literal("untracked") }).strict(),
+  z28.object({
+    kind: z28.literal("at-pickup"),
+    revision: z28.number().int().nonnegative(),
+    variants: z28.array(
       pickupAllocationSchema.extend({
-        available: z27.number().int().nonnegative()
+        available: z28.number().int().nonnegative()
       })
     )
   }).strict()
 ]);
-var configurePickupSchema = z27.object({
+var configurePickupSchema = z28.object({
   reward: identifier,
-  revision: z27.number().int().nonnegative(),
+  revision: z28.number().int().nonnegative(),
   actionId: identifier,
-  policy: z27.discriminatedUnion("kind", [
-    z27.object({ kind: z27.literal("untracked") }).strict(),
-    z27.object({
-      kind: z27.literal("at-pickup"),
-      tiers: z27.array(
-        z27.object({
+  policy: z28.discriminatedUnion("kind", [
+    z28.object({ kind: z28.literal("untracked") }).strict(),
+    z28.object({
+      kind: z28.literal("at-pickup"),
+      tiers: z28.array(
+        z28.object({
           tier: identifier,
-          variants: z27.array(
+          variants: z28.array(
             pickupAllocationSchema.extend({
               item: identifier.optional()
             })
@@ -3291,10 +3333,10 @@ var configurePickupSchema = z27.object({
     }).strict()
   ])
 }).strict();
-var entitlementRecoverySchema = z27.object({
+var entitlementRecoverySchema = z28.object({
   completion: identifier,
-  reason: z27.string(),
-  flaggedAt: z27.number(),
+  reason: z28.string(),
+  flaggedAt: z28.number(),
   /** Null means no accepted completion currently earns this reward. */
   remainingTier: identifier.nullable()
 });
@@ -3304,40 +3346,40 @@ var entitlementBase = {
   reward: tieredRewardDefinitionSchema,
   earnedTier: identifier,
   tier: identifier,
-  revision: z27.number().int().positive()
+  revision: z28.number().int().positive()
 };
-var entitlementStateSchema = z27.discriminatedUnion("status", [
-  z27.object({ ...entitlementBase, status: z27.literal("available") }).strict(),
-  z27.object({
+var entitlementStateSchema = z28.discriminatedUnion("status", [
+  z28.object({ ...entitlementBase, status: z28.literal("available") }).strict(),
+  z28.object({
     ...entitlementBase,
-    status: z27.literal("handing-over"),
+    status: z28.literal("handing-over"),
     handover: identifier,
-    startedAt: z27.number(),
+    startedAt: z28.number(),
     allocation: pickupAllocationSchema.optional()
   }).strict(),
-  z27.object({
+  z28.object({
     ...entitlementBase,
-    status: z27.literal("collected"),
+    status: z28.literal("collected"),
     handover: identifier,
-    startedAt: z27.number(),
+    startedAt: z28.number(),
     allocation: pickupAllocationSchema.optional(),
-    collectedAt: z27.number(),
+    collectedAt: z28.number(),
     recovery: entitlementRecoverySchema.optional()
   }).strict(),
   // An operator voided it: it can no longer be handed over. A quest grant of the same reward to
   // the member (the same grant key) makes it available again; a voided referral reward stays void.
-  z27.object({
+  z28.object({
     ...entitlementBase,
-    status: z27.literal("void"),
-    voidedAt: z27.number()
+    status: z28.literal("void"),
+    voidedAt: z28.number()
   }).strict()
 ]);
-var tieredRewardReadSchema = z27.object({
+var tieredRewardReadSchema = z28.object({
   id: identifier,
-  title: z27.string(),
-  tiers: z27.array(z27.object({ id: identifier, title: z27.string() }).loose()),
-  inventory: z27.object({ kind: z27.string() }).loose(),
-  fulfillment: z27.object({ kind: z27.string() }).loose()
+  title: z28.string(),
+  tiers: z28.array(z28.object({ id: identifier, title: z28.string() }).loose()),
+  inventory: z28.object({ kind: z28.string() }).loose(),
+  fulfillment: z28.object({ kind: z28.string() }).loose()
 }).loose();
 var entitlementReadBase = {
   id: identifier,
@@ -3345,63 +3387,63 @@ var entitlementReadBase = {
   reward: tieredRewardReadSchema,
   earnedTier: identifier,
   tier: identifier,
-  revision: z27.number().int()
+  revision: z28.number().int()
 };
-var allocationReadSchema = z27.object({ item: identifier, label: z27.string() }).loose();
-var entitlementSchema = z27.union([
-  z27.discriminatedUnion("status", [
-    z27.object({ ...entitlementReadBase, status: z27.literal("available") }).loose(),
-    z27.object({
+var allocationReadSchema = z28.object({ item: identifier, label: z28.string() }).loose();
+var entitlementSchema = z28.union([
+  z28.discriminatedUnion("status", [
+    z28.object({ ...entitlementReadBase, status: z28.literal("available") }).loose(),
+    z28.object({
       ...entitlementReadBase,
-      status: z27.literal("handing-over"),
+      status: z28.literal("handing-over"),
       handover: identifier,
-      startedAt: z27.number(),
+      startedAt: z28.number(),
       allocation: allocationReadSchema.optional()
     }).loose(),
-    z27.object({
+    z28.object({
       ...entitlementReadBase,
-      status: z27.literal("collected"),
+      status: z28.literal("collected"),
       handover: identifier,
-      startedAt: z27.number(),
+      startedAt: z28.number(),
       allocation: allocationReadSchema.optional(),
-      collectedAt: z27.number(),
+      collectedAt: z28.number(),
       recovery: entitlementRecoverySchema.optional()
     }).loose(),
-    z27.object({
+    z28.object({
       ...entitlementReadBase,
-      status: z27.literal("void"),
-      voidedAt: z27.number()
+      status: z28.literal("void"),
+      voidedAt: z28.number()
     }).loose()
   ]),
-  z27.object({ ...entitlementReadBase, status: z27.string() }).loose().transform(({ status, ...entitlement }) => ({
+  z28.object({ ...entitlementReadBase, status: z28.string() }).loose().transform(({ status, ...entitlement }) => ({
     ...entitlement,
     status: "unsupported",
     reportedStatus: status
   }))
 ]);
-var beginHandoverSchema = z27.object({
+var beginHandoverSchema = z28.object({
   actionId: identifier,
-  revision: z27.number().int().positive(),
+  revision: z28.number().int().positive(),
   selection: pickupSelectionSchema.optional()
 }).strict();
-var confirmHandoverSchema = z27.object({ actionId: identifier, handover: identifier }).strict();
-var entitlementCorrectionSchema = z27.object({
+var confirmHandoverSchema = z28.object({ actionId: identifier, handover: identifier }).strict();
+var entitlementCorrectionSchema = z28.object({
   actionId: identifier,
-  revision: z27.number().int().positive(),
-  reason: z27.string().trim().min(1).max(500)
+  revision: z28.number().int().positive(),
+  reason: z28.string().trim().min(1).max(500)
 }).strict();
 var CompletionSourceKind = {
   Quest: "quest",
   Leaderboard: "leaderboard"
 };
-var completionSourceKindSchema = z27.string().min(1).max(64);
-var completionSourceSchema = z27.object({
+var completionSourceKindSchema = z28.string().min(1).max(64);
+var completionSourceSchema = z28.object({
   kind: completionSourceKindSchema,
   id: identifier
 });
-var completionRecordSchema = z27.object({
+var completionRecordSchema = z28.object({
   /** The occurrence the completion consumed. For a leaderboard prize, the settlement ID. */
-  key: z27.string().default("once"),
+  key: z28.string().default("once"),
   id: identifier,
   /** The quest ID, or the board ID when `source.kind` is `leaderboard`. */
   quest: identifier,
@@ -3409,19 +3451,19 @@ var completionRecordSchema = z27.object({
   /** What paid the completion. `source.id` repeats `quest`. */
   source: completionSourceSchema.optional()
 });
-var questAvailabilitySchema = z27.discriminatedUnion("kind", [
-  z27.object({
-    kind: z27.literal("available"),
-    input: z27.enum(["photo", "quiz", "none", "text", "url"])
+var questAvailabilitySchema = z28.discriminatedUnion("kind", [
+  z28.object({
+    kind: z28.literal("available"),
+    input: z28.enum(["photo", "quiz", "none", "text", "url"])
   }).strict(),
-  z27.object({ kind: z27.literal("completed") }).strict(),
-  z27.object({
-    kind: z27.literal("locked"),
-    missing: z27.array(missingPrerequisiteSchema).min(1)
+  z28.object({ kind: z28.literal("completed") }).strict(),
+  z28.object({
+    kind: z28.literal("locked"),
+    missing: z28.array(missingPrerequisiteSchema).min(1)
   }).strict(),
-  z27.object({
-    kind: z27.literal("blocked"),
-    reason: z27.enum([
+  z28.object({
+    kind: z28.literal("blocked"),
+    reason: z28.enum([
       "budget-exhausted",
       "connection-required",
       "wallet-required",
@@ -3430,152 +3472,152 @@ var questAvailabilitySchema = z27.discriminatedUnion("kind", [
       "enrollment-required"
     ]),
     /** Which window refused admission when `reason` is `outside-window`. */
-    window: z27.enum(["tracker", "quest"]).optional(),
-    resetsAt: z27.number().int().safe().optional()
+    window: z28.enum(["tracker", "quest"]).optional(),
+    resetsAt: z28.number().int().safe().optional()
   }).strict(),
-  z27.object({ kind: z27.literal("staff-required") }).strict(),
-  z27.object({ kind: z27.literal("automatic") }).strict(),
-  z27.object({ kind: z27.literal("checking"), attempt: identifier }).strict(),
-  z27.object({ kind: z27.literal("needs-review"), attempt: identifier }).strict(),
-  z27.object({ kind: z27.literal("retryable"), attempt: identifier }).strict()
+  z28.object({ kind: z28.literal("staff-required") }).strict(),
+  z28.object({ kind: z28.literal("automatic") }).strict(),
+  z28.object({ kind: z28.literal("checking"), attempt: identifier }).strict(),
+  z28.object({ kind: z28.literal("needs-review"), attempt: identifier }).strict(),
+  z28.object({ kind: z28.literal("retryable"), attempt: identifier }).strict()
 ]);
-var questAvailabilityResponseSchema = z27.union(
+var questAvailabilityResponseSchema = z28.union(
   questAvailabilitySchema.options.map((option) => option.strip())
 );
-var questBudgetViewSchema = z27.object({
+var questBudgetViewSchema = z28.object({
   id: identifier,
-  scope: z27.enum(["member", "project"]),
-  period: z27.enum(["day", "week", "month", "lifetime"]),
-  remaining: z27.number().int().safe().nonnegative(),
-  resetsAt: z27.number().int().safe().nullable()
+  scope: z28.enum(["member", "project"]),
+  period: z28.enum(["day", "week", "month", "lifetime"]),
+  remaining: z28.number().int().safe().nonnegative(),
+  resetsAt: z28.number().int().safe().nullable()
 });
 var memberProgressSchema = responseShape(
-  z27.object({
+  z28.object({
     member: identifier,
-    quests: z27.array(
-      z27.object({
+    quests: z28.array(
+      z28.object({
         quest: identifier,
         key: identifier.optional(),
         release: identifier.optional(),
-        title: z27.string(),
+        title: z28.string(),
         presentation: questPresentationSchema.default({}),
-        connections: z27.array(authProviderSchema).default([]),
+        connections: z28.array(authProviderSchema).default([]),
         trigger: triggerResponseSchema,
         availability: questAvailabilityResponseSchema,
-        completed: z27.boolean(),
+        completed: z28.boolean(),
         completion: completionPolicySchema.default({ kind: "once" }),
         streak: streakProgressSchema.nullable().optional(),
         counter: counterProgressSchema.nullable().optional(),
         /** Latest attempt's committed evaluator progress, while it remains deferred/evaluating. */
         progress: evaluatorProgressSchema.nullable().default(null),
-        completionCount: z27.number().int().nonnegative().default(0),
-        visibility: z27.enum(["visible", "hidden"]).default("visible"),
-        missing: z27.array(missingPrerequisiteSchema),
+        completionCount: z28.number().int().nonnegative().default(0),
+        visibility: z28.enum(["visible", "hidden"]).default("visible"),
+        missing: z28.array(missingPrerequisiteSchema),
         campaign: campaignViewSchema.nullable().default(null),
         window: availabilityWindowSchema.nullable().default(null),
-        budgets: z27.array(questBudgetViewSchema).default([]),
+        budgets: z28.array(questBudgetViewSchema).default([]),
         /**
          * Unix milliseconds when the member may submit again, while the quest's retry cooldown
          * after their rejected attempt runs. Until then a new attempt is refused with
          * `retry-cooldown`. Absent when no cooldown is running.
          */
-        retryAt: z27.number().int().safe().optional(),
+        retryAt: z28.number().int().safe().optional(),
         attempt: attemptSchema.nullable()
       })
     ),
-    entitlements: z27.array(entitlementSchema)
+    entitlements: z28.array(entitlementSchema)
   })
 );
 var snapshotSchema = responseShape(
-  z27.object({
-    releases: z27.array(publishedReleaseSchema),
-    completions: z27.array(completionRecordSchema),
-    entitlements: z27.array(entitlementSchema),
-    attempts: z27.array(attemptSchema),
-    balances: z27.array(
-      z27.object({
-        member: z27.string(),
-        balance: z27.string(),
-        earned: z27.number(),
-        held: z27.number(),
-        available: z27.number()
+  z28.object({
+    releases: z28.array(publishedReleaseSchema),
+    completions: z28.array(completionRecordSchema),
+    entitlements: z28.array(entitlementSchema),
+    attempts: z28.array(attemptSchema),
+    balances: z28.array(
+      z28.object({
+        member: z28.string(),
+        balance: z28.string(),
+        earned: z28.number(),
+        held: z28.number(),
+        available: z28.number()
       })
     ),
-    events: z27.array(eventSchema)
+    events: z28.array(eventSchema)
   })
 );
-var evidenceSchema = z27.object({
+var evidenceSchema = z28.object({
   id: identifier,
   member: identifier,
-  type: z27.enum(["image/jpeg", "image/png"]),
-  size: z27.number()
+  type: z28.enum(["image/jpeg", "image/png"]),
+  size: z28.number()
 });
-var errorSchema = z27.object({
-  error: z27.string(),
-  code: z27.string().optional(),
+var errorSchema = z28.object({
+  error: z28.string(),
+  code: z28.string().optional(),
   /** Which window refused admission when `code` is `outside-window`. */
-  window: z27.enum(["tracker", "quest"]).optional(),
-  missing: z27.array(missingPrerequisiteSchema).optional(),
+  window: z28.enum(["tracker", "quest"]).optional(),
+  missing: z28.array(missingPrerequisiteSchema).optional(),
   /** Unix milliseconds when the member may submit again, when `code` is `retry-cooldown`. */
-  retryAt: z27.number().int().safe().optional()
+  retryAt: z28.number().int().safe().optional()
 });
-var staffDecisionSchema = z27.object({
+var staffDecisionSchema = z28.object({
   actionId: identifier,
-  generation: z27.number().int().nonnegative(),
-  decision: z27.enum(["accept", "reject"]),
-  reason: z27.string().trim().min(1).max(2e3)
+  generation: z28.number().int().nonnegative(),
+  decision: z28.enum(["accept", "reject"]),
+  reason: z28.string().trim().min(1).max(2e3)
 }).strict();
-var stockSchema = z27.object({ item: identifier, quantity: z27.number().int().min(0).max(1e4) }).strict();
-var reservationSchema = z27.object({
+var stockSchema = z28.object({ item: identifier, quantity: z28.number().int().min(0).max(1e4) }).strict();
+var reservationSchema = z28.object({
   actionId: identifier,
   member: identifier,
   item: identifier,
   balance: identifier,
-  price: z27.number().int().positive().max(1e4)
+  price: z28.number().int().positive().max(1e4)
 }).strict();
 var pageOptions = {
-  limit: z27.number().int().min(1).max(100).default(25),
-  cursor: z27.string().min(1).max(4096).optional()
+  limit: z28.number().int().min(1).max(100).default(25),
+  cursor: z28.string().min(1).max(4096).optional()
 };
-var reviewListSchema = z27.object({
+var reviewListSchema = z28.object({
   ...pageOptions,
   member: identifier.optional(),
   quest: identifier.optional()
 }).strict();
-var memberListSchema = z27.object({
+var memberListSchema = z28.object({
   ...pageOptions,
   prefix: identifier.optional()
 }).strict();
-var reviewItemSchema = z27.object({
+var reviewItemSchema = z28.object({
   attempt: attemptSchema,
-  title: z27.string(),
-  checks: z27.array(
-    z27.object({ criteria: z27.string(), result: photoResultSchema })
+  title: z28.string(),
+  checks: z28.array(
+    z28.object({ criteria: z28.string(), result: photoResultSchema })
   )
 });
-var reviewPageSchema = z27.object({
-  items: z27.array(reviewItemSchema).max(100),
-  nextCursor: z27.string().nullable()
+var reviewPageSchema = z28.object({
+  items: z28.array(reviewItemSchema).max(100),
+  nextCursor: z28.string().nullable()
 });
-var memberPageSchema = z27.object({
-  items: z27.array(z27.object({ member: identifier })).max(100),
-  nextCursor: z27.string().nullable()
+var memberPageSchema = z28.object({
+  items: z28.array(z28.object({ member: identifier })).max(100),
+  nextCursor: z28.string().nullable()
 });
-var createStockItemSchema = z27.object({ actionId: identifier, name: z27.string().trim().min(1).max(80) }).strict();
-var stockItemSchema = z27.object({ id: identifier, name: z27.string() });
-var contentPerformanceSnapshotSchema = z27.strictObject({
+var createStockItemSchema = z28.object({ actionId: identifier, name: z28.string().trim().min(1).max(80) }).strict();
+var stockItemSchema = z28.object({ id: identifier, name: z28.string() });
+var contentPerformanceSnapshotSchema = z28.strictObject({
   contentAttempt: identifier,
   observation: identifier,
-  observedAt: z27.number().int().safe().nonnegative(),
+  observedAt: z28.number().int().safe().nonnegative(),
   metrics: contentMetricsSchema,
   rewards: rewardBundleSchema
 });
 var contentPerformanceQuerySchema = contentQualificationQuerySchema.extend({
-  content: z27.string().min(1).max(256)
+  content: z28.string().min(1).max(256)
 });
-var contentPerformancePageSchema = z27.strictObject({
-  current: z27.strictObject({
-    state: z27.enum([
+var contentPerformancePageSchema = z28.strictObject({
+  current: z28.strictObject({
+    state: z28.enum([
       "content-pending",
       "content-unqualified",
       "waiting",
@@ -3586,19 +3628,19 @@ var contentPerformancePageSchema = z27.strictObject({
       "failed",
       "superseded"
     ]),
-    reason: z27.string().nullable(),
+    reason: z28.string().nullable(),
     contentAttempt: identifier,
     attempt: identifier.nullable(),
     reward: contentQualificationSchema.shape.reward
   }),
-  items: z27.array(
-    z27.strictObject({
+  items: z28.array(
+    z28.strictObject({
       attempt: identifier,
       contentAttempt: identifier,
       observation: identifier,
-      observedAt: z27.number(),
+      observedAt: z28.number(),
       metrics: contentMetricsSchema,
-      state: z27.enum([
+      state: z28.enum([
         "pending",
         "qualified",
         "unqualified",
@@ -3606,7 +3648,7 @@ var contentPerformancePageSchema = z27.strictObject({
         "failed",
         "superseded"
       ]),
-      reason: z27.string().nullable()
+      reason: z28.string().nullable()
     })
   ),
   nextCursor: pageCursorSchema.nullable()
@@ -3755,6 +3797,8 @@ export {
   trackerTriggerRecordSchema,
   trackerContentStageSchema,
   trackerTriggerContextSchema,
+  reservedAttemptCodes,
+  rejectCodeIssue,
   maxPointsAmount,
   questScaleLimits,
   sdkRuntimeLimits,