@domino-sdk/relay 1.16.0 → 1.18.1

package/dist/{chunk-46C33ASD.js → chunk-EMLDFUTV.js}

@@ -1,5 +1,164 @@
-// src/response.ts
+// src/request-error.ts
+var requestErrorBrand = /* @__PURE__ */ Symbol.for("@domino-sdk/relay.RequestError");
+function isRequestError(value) {
+  return typeof value === "object" && value !== null && value[requestErrorBrand] === true;
+}
+var RequestError = class extends Error {
+  name = "RequestError";
+  [requestErrorBrand] = true;
+  kind;
+  uncertain;
+  status;
+  code;
+  operationId;
+  /** `replay` for a replay-safe operation ID, else `reconcile`; only when `uncertain`. */
+  recovery;
+  /**
+   * Milliseconds the server asked the client to wait before trying again, from the `Retry-After`
+   * header of an error answer such as a 429 or 503. The client's own retries never wait past the
+   * call's deadline, so a longer wait is left to the caller.
+   */
+  retryAfter;
+  constructor(message, details) {
+    super(message, details.cause === void 0 ? {} : { cause: details.cause });
+    this.kind = details.kind;
+    this.uncertain = details.uncertain ?? false;
+    this.status = details.status;
+    this.code = details.code;
+    this.operationId = details.operationId;
+    this.retryAfter = details.retryAfter;
+    this.recovery = this.uncertain ? details.operationId && (details.replaySafe ?? true) ? "replay" : "reconcile" : void 0;
+  }
+};
+
+// src/errors.ts
 import { z } from "zod";
+var RelayErrorCode = {
+  /** The call needs a signed-in member. */
+  NotSignedIn: "not-signed-in",
+  /** The session changed since the app read it (the `session` option). Reload before retrying. */
+  StaleSession: "stale-session",
+  /** The input failed validation before it was sent. */
+  InvalidInput: "invalid-input",
+  /** Relay's answer was not JSON or not the expected shape (kind `invalid-response`). */
+  InvalidResponse: "invalid-response",
+  /** The transport failed, before a response or while reading its body (kind `network`). */
+  Network: "network",
+  /** The client's deadline elapsed (kind `timeout`). */
+  Timeout: "timeout",
+  /** The caller cancelled the request (kind `aborted`). */
+  Aborted: "aborted",
+  /** A quest or collection the call named is not in the member's experience. */
+  NotFound: "not-found",
+  /** The quest has no failed attempt the member can retry. */
+  RetryUnavailable: "retry-unavailable",
+  /**
+   * Durable submission storage is missing, blocked or unreadable. Nothing was lost: call the
+   * handle's `status()` or `resume()` again once storage is available.
+   */
+  SubmissionStorage: "submission-storage",
+  /** Browser storage is full, so submission progress was not saved. Free space, then resume. */
+  SubmissionStorageQuota: "submission-storage-quota",
+  /** The saved submission is in a state that does not allow this action. */
+  SubmissionConflict: "submission-conflict",
+  /** The quest changed since the member saw it; review it before submitting again. */
+  QuestUpdated: "quest-updated",
+  /** Wait for the deferred attempt before submitting another action. */
+  AttemptPending: "attempt-pending",
+  /** The quiz changed since the member answered it. */
+  StaleQuiz: "stale-quiz",
+  /** Relay refused the submitted evidence. */
+  InvalidSubmission: "invalid-submission",
+  /** A page cursor Relay cannot read; start again from the first page. */
+  InvalidCursor: "invalid-cursor",
+  /** No point ledger in the project has the key or ID the call named. */
+  PointLedgerNotFound: "point-ledger-not-found",
+  /** The member has not joined this project, so it holds no points here. */
+  NotJoined: "not-joined",
+  /** The quest or campaign is not open at this time. */
+  OutsideWindow: "outside-window",
+  /** The signed-in member must enroll in the campaign first. */
+  EnrollmentRequired: "enrollment-required",
+  /** The quest's current reward budget has no remaining capacity. */
+  BudgetExhausted: "budget-exhausted",
+  /** No published offer has the key or ID the call named. */
+  OfferNotFound: "offer-not-found",
+  /** The operator paused this offer. */
+  OfferPaused: "offer-paused",
+  /** This member has already used the offer's allowed number of redemptions. */
+  OfferLimitReached: "offer-limit-reached",
+  /** No declared units remain. */
+  OfferOutOfStock: "offer-out-of-stock",
+  /** The participant's available point balance is below the offer price. */
+  InsufficientPoints: "insufficient-points",
+  /** A wallet signer failed or the member refused to sign; `cause` is the wallet's own error. */
+  WalletSigner: "wallet-signer",
+  /** The member has not met the quest's prerequisites; `missing` lists them. */
+  PrerequisitesIncomplete: "prerequisites-incomplete",
+  /** The quest is archived or retired: it takes no new participation. */
+  QuestClosed: "quest-closed",
+  /** An operator paused the quest. */
+  QuestPaused: "quest-paused",
+  /** An operator locked the member's profile; hiding it is still allowed. */
+  ProfileLocked: "profile-locked",
+  /** No member in the project has the invitation code the member accepted. */
+  InvitationNotFound: "invitation-not-found",
+  /** The email sign-in code is wrong; the member can type it again. */
+  InvalidCode: "invalid-code",
+  /** The email sign-in code expired, was used or had too many attempts; request another. */
+  CodeExpired: "code-expired",
+  /** The wallet sign-in challenge expired, was used or changed; start sign-in again. */
+  ChallengeExpired: "challenge-expired",
+  /** Too many requests; `retryAfter` says how long to wait when Relay knows. */
+  RateLimited: "rate-limited"
+};
+var relayErrorBrand = /* @__PURE__ */ Symbol.for("@domino-sdk/relay.RelayError");
+function isRelayError(value) {
+  return isRequestError(value) && value[relayErrorBrand] === true;
+}
+var RelayError = class extends RequestError {
+  name = "RelayError";
+  [relayErrorBrand] = true;
+  /** Which window refused admission when `code` is `outside-window`. */
+  window;
+  /** Prerequisites the member does not currently meet, when Relay refused for that reason. */
+  missing;
+  constructor(message, details) {
+    super(message, details);
+    this.window = details.window;
+    this.missing = details.missing ?? [];
+  }
+};
+function asRelayError(cause, fallback = "Request failed") {
+  if (isRelayError(cause)) {
+    return cause;
+  }
+  return new RelayError(
+    cause instanceof Error && cause.message ? cause.message : fallback,
+    { kind: "client", cause }
+  );
+}
+function clientError(message, code, details = {}) {
+  return new RelayError(message, { ...details, kind: "client", code });
+}
+function parseInput(schema, value) {
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) {
+    throw clientError(
+      z.prettifyError(parsed.error),
+      RelayErrorCode.InvalidInput,
+      { cause: parsed.error }
+    );
+  }
+  return parsed.data;
+}
+
+// src/identifier.ts
+import { z as z2 } from "zod";
+var identifier = z2.string().min(1).max(100).regex(/^[a-zA-Z0-9_-]+$/);
+
+// src/response.ts
+import { z as z3 } from "zod";
 var responseFormat = /* @__PURE__ */ Symbol("domino.response.tolerant-v1");
 function markResponseSchema(schema) {
   return Object.assign(schema, { [responseFormat]: true });
@@ -38,7 +197,7 @@ function responseShape(schema) {
     Object.getPrototypeOf(schema._zod.def),
     Object.getOwnPropertyDescriptors(schema._zod.def)
   );
-  if (schema instanceof z.ZodObject) {
+  if (schema instanceof z3.ZodObject) {
     let shape;
     Object.defineProperty(definition, "shape", {
       get: () => shape ??= Object.fromEntries(
@@ -51,49 +210,49 @@ function responseShape(schema) {
       enumerable: true
     });
     Object.assign(definition, {
-      catchall: schema._zod.def.catchall instanceof z.ZodNever || !schema._zod.def.catchall ? void 0 : responseShape(schema._zod.def.catchall)
+      catchall: schema._zod.def.catchall instanceof z3.ZodNever || !schema._zod.def.catchall ? void 0 : responseShape(schema._zod.def.catchall)
     });
-  } else if (schema instanceof z.ZodNumber) {
+  } else if (schema instanceof z3.ZodNumber) {
     Object.assign(definition, {
       checks: schema._zod.def.checks?.filter((check) => {
         const rule = check._zod.def;
         return rule.check !== "less_than" || !("value" in rule) || rule.value === Number.MAX_SAFE_INTEGER || rule.value === 864e13;
       })
     });
-  } else if (schema instanceof z.ZodArray) {
+  } else if (schema instanceof z3.ZodArray) {
     Object.assign(definition, {
       element: responseShape(schema.element),
       checks: []
     });
-  } else if (schema instanceof z.ZodUnion) {
+  } else if (schema instanceof z3.ZodUnion) {
     Object.assign(definition, { options: schema.options.map(responseShape) });
-  } else if (schema instanceof z.ZodTuple) {
+  } else if (schema instanceof z3.ZodTuple) {
     Object.assign(definition, {
       items: schema._zod.def.items.map(responseShape),
       rest: schema._zod.def.rest ? responseShape(schema._zod.def.rest) : null
     });
-  } else if (schema instanceof z.ZodIntersection) {
+  } else if (schema instanceof z3.ZodIntersection) {
     Object.assign(definition, {
       left: responseShape(schema._zod.def.left),
       right: responseShape(schema._zod.def.right)
     });
-  } else if (schema instanceof z.ZodLazy) {
+  } else if (schema instanceof z3.ZodLazy) {
     Object.assign(definition, {
       getter: () => responseShape(schema._zod.def.getter())
     });
-  } else if (schema instanceof z.ZodRecord) {
+  } else if (schema instanceof z3.ZodRecord) {
     Object.assign(definition, { valueType: responseShape(schema.valueType) });
-  } else if (schema instanceof z.ZodPipe) {
+  } else if (schema instanceof z3.ZodPipe) {
     Object.assign(definition, {
       in: responseShape(schema.in),
       out: responseShape(schema.out)
     });
-  } else if ("innerType" in definition && definition.innerType instanceof z.ZodType) {
+  } else if ("innerType" in definition && definition.innerType instanceof z3.ZodType) {
     Object.assign(definition, {
       innerType: responseShape(definition.innerType)
     });
   }
-  const reader = z.clone(schema, definition);
+  const reader = z3.clone(schema, definition);
   shapes.set(schema, reader);
   shapes.set(reader, reader);
   return reader;
@@ -102,54 +261,54 @@ function knownResponse(schema) {
   return responseShape(schema);
 }
 function fields(schema) {
-  if (schema instanceof z.ZodObject) {
+  if (schema instanceof z3.ZodObject) {
     return schema.shape;
   }
-  if ("innerType" in schema._zod.def && schema._zod.def.innerType instanceof z.ZodType) {
+  if ("innerType" in schema._zod.def && schema._zod.def.innerType instanceof z3.ZodType) {
     return fields(schema._zod.def.innerType);
   }
   return void 0;
 }
 function values(schema) {
-  if (schema instanceof z.ZodLiteral) {
+  if (schema instanceof z3.ZodLiteral) {
     return [...schema.values];
   }
-  if (schema instanceof z.ZodEnum) {
+  if (schema instanceof z3.ZodEnum) {
     return schema.options;
   }
-  if ("innerType" in schema._zod.def && schema._zod.def.innerType instanceof z.ZodType) {
+  if ("innerType" in schema._zod.def && schema._zod.def.innerType instanceof z3.ZodType) {
     return values(schema._zod.def.innerType);
   }
   return void 0;
 }
 function unknownVariant(schema, input) {
-  if (schema instanceof z.ZodLiteral) {
+  if (schema instanceof z3.ZodLiteral) {
     return typeof input === "string" && [...schema.values].every((value) => typeof value === "string") && !schema.values.has(input);
   }
-  if (schema instanceof z.ZodEnum) {
+  if (schema instanceof z3.ZodEnum) {
     return typeof input === "string" && !schema.options.includes(input);
   }
-  if (schema instanceof z.ZodArray && Array.isArray(input)) {
+  if (schema instanceof z3.ZodArray && Array.isArray(input)) {
     return input.some((item) => unknownVariant(schema.element, item));
   }
-  if (schema instanceof z.ZodTuple && Array.isArray(input)) {
+  if (schema instanceof z3.ZodTuple && Array.isArray(input)) {
     return input.some((item, index) => {
       const child = schema._zod.def.items[index] ?? schema._zod.def.rest;
       return child ? unknownVariant(child, item) : false;
     });
   }
-  if (schema instanceof z.ZodIntersection) {
+  if (schema instanceof z3.ZodIntersection) {
     return unknownVariant(schema._zod.def.left, input) || unknownVariant(schema._zod.def.right, input);
   }
-  if (schema instanceof z.ZodLazy) {
+  if (schema instanceof z3.ZodLazy) {
     return unknownVariant(schema._zod.def.getter(), input);
   }
-  if (schema instanceof z.ZodRecord && input !== null && typeof input === "object" && !Array.isArray(input)) {
+  if (schema instanceof z3.ZodRecord && input !== null && typeof input === "object" && !Array.isArray(input)) {
     return Object.entries(input).some(
       ([key, value]) => unknownVariant(schema.keyType, key) || unknownVariant(schema.valueType, value)
     );
   }
-  if (schema instanceof z.ZodUnion) {
+  if (schema instanceof z3.ZodUnion) {
     let options = [...schema.options];
     if (typeof input === "string") {
       const choices = options.flatMap((option) => values(option) ?? []);
@@ -158,7 +317,7 @@ function unknownVariant(schema, input) {
       }
     }
     if (input !== null && typeof input === "object" && !Array.isArray(input)) {
-      const raw = z.record(z.string(), z.unknown()).parse(input);
+      const raw = z3.record(z3.string(), z3.unknown()).parse(input);
       const keys = ["kind", "status", "provider", "input", "type", "mode"];
       for (const key of keys) {
         if (typeof raw[key] !== "string") {
@@ -182,29 +341,29 @@ function unknownVariant(schema, input) {
     }
     return options.every((option) => unknownVariant(option, input));
   }
-  if (schema instanceof z.ZodObject && input !== null && typeof input === "object" && !Array.isArray(input)) {
-    const raw = z.record(z.string(), z.unknown()).parse(input);
+  if (schema instanceof z3.ZodObject && input !== null && typeof input === "object" && !Array.isArray(input)) {
+    const raw = z3.record(z3.string(), z3.unknown()).parse(input);
     return Object.entries(schema.shape).some(
       ([key, child]) => unknownVariant(child, raw[key])
     ) || Object.entries(raw).some(
       ([key, value]) => !(key in schema.shape) && !!schema._zod.def.catchall && unknownVariant(schema._zod.def.catchall, value)
     );
   }
-  if (schema instanceof z.ZodPipe) {
+  if (schema instanceof z3.ZodPipe) {
     if (unknownVariant(schema.in, input)) {
       return true;
     }
-    const intermediate = z.safeParse(schema.in, input);
+    const intermediate = z3.safeParse(schema.in, input);
     return intermediate.success && unknownVariant(schema.out, intermediate.data);
   }
-  if ("innerType" in schema._zod.def && schema._zod.def.innerType instanceof z.ZodType) {
+  if ("innerType" in schema._zod.def && schema._zod.def.innerType instanceof z3.ZodType) {
     return unknownVariant(schema._zod.def.innerType, input);
   }
   return false;
 }
 function responseSchema(schema) {
   return markResponseSchema(
-    z.json().transform((raw, context) => {
+    z3.json().transform((raw, context) => {
       const reader = knownResponse(schema);
       const parsed = reader.safeParse(raw);
       if (parsed.success) {
@@ -216,13 +375,13 @@ function responseSchema(schema) {
       for (const issue of parsed.error.issues) {
         context.addIssue({ ...issue });
       }
-      return z.NEVER;
+      return z3.NEVER;
     })
   );
 }
 function responseListSchema(schema) {
   return markResponseSchema(
-    z.array(responseSchema(schema)).transform((items) => ({
+    z3.array(responseSchema(schema)).transform((items) => ({
       items,
       unsupportedCount: items.filter((item) => item.kind === "unsupported").length
     }))
@@ -230,120 +389,116 @@ function responseListSchema(schema) {
 }
 
 // src/pages.ts
-import { z as z2 } from "zod";
-var pageCursorSchema = z2.string().min(1).max(4096);
-var pageQuerySchema = z2.strictObject({
+import { z as z4 } from "zod";
+var pageCursorSchema = z4.string().min(1).max(4096);
+var pageQuerySchema = z4.strictObject({
   cursor: pageCursorSchema.optional()
 });
-var managementStateQuerySchema = z2.strictObject({
+var managementStateQuerySchema = z4.strictObject({
   cursor: pageCursorSchema.optional(),
-  limit: z2.coerce.number().int().min(1).max(100).default(50)
+  limit: z4.coerce.number().int().min(1).max(100).default(50)
 });
 
 // src/accounts.ts
-import { z as z3 } from "zod";
-var authProviderSchema = z3.enum(["google", "apple", "x", "discord"]);
-var accountConnectionSchema = z3.object({
+import { z as z5 } from "zod";
+var authProviderSchema = z5.enum(["google", "apple", "x", "discord"]);
+var accountConnectionSchema = z5.object({
   provider: authProviderSchema,
-  configured: z3.boolean(),
-  status: z3.enum(["disconnected", "connected", "reconnect"]),
-  subject: z3.string().nullable(),
-  revision: z3.number().int().nonnegative()
-});
-var discordMemberInputSchema = z3.object({}).strict();
-var discordMessageInputSchema = z3.object({
-  channelId: z3.string().regex(/^[0-9]{1,20}$/),
-  messageId: z3.string().regex(/^[0-9]{1,20}$/)
+  configured: z5.boolean(),
+  status: z5.enum(["disconnected", "connected", "reconnect"]),
+  subject: z5.string().nullable(),
+  revision: z5.number().int().nonnegative()
+});
+var discordMemberInputSchema = z5.object({}).strict();
+var discordMessageInputSchema = z5.object({
+  channelId: z5.string().regex(/^[0-9]{1,20}$/),
+  messageId: z5.string().regex(/^[0-9]{1,20}$/)
 }).strict();
-var discordMemberSchema = z3.object({
-  userId: z3.string().regex(/^[0-9]{1,20}$/).nullable().default(null),
-  nickname: z3.string().nullable().default(null),
-  displayName: z3.string().nullable().default(null),
-  boostingSince: z3.string().datetime({ offset: true }).nullable().default(null),
-  roles: z3.array(z3.string().regex(/^[0-9]{1,20}$/)),
-  joinedAt: z3.string().datetime({ offset: true }).nullable(),
-  pending: z3.boolean()
+var discordMemberSchema = z5.object({
+  userId: z5.string().regex(/^[0-9]{1,20}$/).nullable().default(null),
+  nickname: z5.string().nullable().default(null),
+  displayName: z5.string().nullable().default(null),
+  boostingSince: z5.string().datetime({ offset: true }).nullable().default(null),
+  roles: z5.array(z5.string().regex(/^[0-9]{1,20}$/)),
+  joinedAt: z5.string().datetime({ offset: true }).nullable(),
+  pending: z5.boolean()
 });
 
-// src/identifier.ts
-import { z as z4 } from "zod";
-var identifier = z4.string().min(1).max(100).regex(/^[a-zA-Z0-9_-]+$/);
-
 // src/discord.ts
-import { z as z5 } from "zod";
-var discordMessageSchema = z5.object({
-  guildId: z5.string(),
-  channelId: z5.string(),
-  messageId: z5.string(),
-  userId: z5.string(),
-  content: z5.string().nullable(),
-  replyTo: z5.string().nullable(),
-  publishedAt: z5.number()
+import { z as z6 } from "zod";
+var discordMessageSchema = z6.object({
+  guildId: z6.string(),
+  channelId: z6.string(),
+  messageId: z6.string(),
+  userId: z6.string(),
+  content: z6.string().nullable(),
+  replyTo: z6.string().nullable(),
+  publishedAt: z6.number()
 }).strict();
-var discordMessagesSourceSchema = z5.strictObject({
-  kind: z5.literal("discord-messages"),
+var discordMessagesSourceSchema = z6.strictObject({
+  kind: z6.literal("discord-messages"),
   /** Store each message's text in `data.text`. Off unless set. */
-  text: z5.boolean().optional()
+  text: z6.boolean().optional()
 });
-var discordReactionsSourceSchema = z5.strictObject({
-  kind: z5.literal("discord-reactions")
+var discordReactionsSourceSchema = z6.strictObject({
+  kind: z6.literal("discord-reactions")
 });
-var discordMessageDataSchema = z5.object({
-  guildId: z5.string(),
-  channelId: z5.string(),
-  messageId: z5.string(),
+var discordMessageDataSchema = z6.object({
+  guildId: z6.string(),
+  channelId: z6.string(),
+  messageId: z6.string(),
   /** The ID of the message this one replies to, or null. */
-  replyTo: z5.string().nullable(),
+  replyTo: z6.string().nullable(),
   /** When Discord says the message was posted, in epoch milliseconds. */
-  publishedAt: z5.number()
+  publishedAt: z6.number()
 });
 var discordMessageTextDataSchema = discordMessageDataSchema.extend({
-  text: z5.string().nullable()
+  text: z6.string().nullable()
 });
-var discordReactionDataSchema = z5.object({
-  guildId: z5.string(),
-  channelId: z5.string(),
+var discordReactionDataSchema = z6.object({
+  guildId: z6.string(),
+  channelId: z6.string(),
   /** The message reacted to. */
-  messageId: z5.string(),
+  messageId: z6.string(),
   /** A custom emoji's ID, or null for a Unicode emoji, whose `name` is the emoji itself. */
-  emoji: z5.object({ id: z5.string().nullable(), name: z5.string() }),
+  emoji: z6.object({ id: z6.string().nullable(), name: z6.string() }),
   /** The role IDs the reactor held in the server when reacting. */
-  reactorRoles: z5.array(z5.string()),
+  reactorRoles: z6.array(z6.string()),
   /** When the reacted-to message was posted, in epoch milliseconds. */
-  messagePublishedAt: z5.number()
-});
-var discordRewardSchema = z5.strictObject({
-  kind: z5.literal("integration"),
-  provider: z5.literal("discord"),
-  action: z5.literal("grant-role"),
-  roleId: z5.string().regex(/^[0-9]{1,20}$/)
-});
-var discordResourceSourceSchema = z5.union([
-  z5.strictObject({
-    provider: z5.literal("discord"),
-    resource: z5.literal("channel"),
-    types: z5.array(z5.enum(["text", "announcement"])).min(1)
+  messagePublishedAt: z6.number()
+});
+var discordRewardSchema = z6.strictObject({
+  kind: z6.literal("integration"),
+  provider: z6.literal("discord"),
+  action: z6.literal("grant-role"),
+  roleId: z6.string().regex(/^[0-9]{1,20}$/)
+});
+var discordResourceSourceSchema = z6.union([
+  z6.strictObject({
+    provider: z6.literal("discord"),
+    resource: z6.literal("channel"),
+    types: z6.array(z6.enum(["text", "announcement"])).min(1)
   }),
-  z5.strictObject({
-    provider: z5.literal("discord"),
-    resource: z5.literal("role"),
-    assignable: z5.boolean().default(false)
+  z6.strictObject({
+    provider: z6.literal("discord"),
+    resource: z6.literal("role"),
+    assignable: z6.boolean().default(false)
   })
 ]);
 
 // src/tracker-data.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var maxDepth = 16;
 var maxBytes = 32768;
 var trackerDataMaxBranches = 16;
 var trackerDataMaxEntries = 256;
-var scalar = z6.union([z6.string(), z6.number().finite(), z6.boolean(), z6.null()]);
-var size = z6.number().int().safe().nonnegative();
-var bound = z6.number().finite();
-var branches = () => z6.array(node).min(1).max(trackerDataMaxBranches);
-var node = z6.lazy(
-  () => z6.strictObject({
-    type: z6.enum([
+var scalar = z7.union([z7.string(), z7.number().finite(), z7.boolean(), z7.null()]);
+var size = z7.number().int().safe().nonnegative();
+var bound = z7.number().finite();
+var branches = () => z7.array(node).min(1).max(trackerDataMaxBranches);
+var node = z7.lazy(
+  () => z7.strictObject({
+    type: z7.enum([
       "object",
       "array",
       "string",
@@ -352,15 +507,15 @@ var node = z6.lazy(
       "boolean",
       "null"
     ]).optional(),
-    properties: z6.record(z6.string(), node).refine(
+    properties: z7.record(z7.string(), node).refine(
       (properties) => Object.keys(properties).length <= trackerDataMaxEntries,
       `An object schema lists at most ${trackerDataMaxEntries} properties`
     ).optional(),
-    required: z6.array(z6.string()).max(trackerDataMaxEntries).optional(),
-    additionalProperties: z6.union([z6.boolean(), node]).optional(),
-    propertyNames: z6.strictObject({
-      type: z6.literal("string"),
-      enum: z6.array(z6.string()).max(trackerDataMaxEntries).optional()
+    required: z7.array(z7.string()).max(trackerDataMaxEntries).optional(),
+    additionalProperties: z7.union([z7.boolean(), node]).optional(),
+    propertyNames: z7.strictObject({
+      type: z7.literal("string"),
+      enum: z7.array(z7.string()).max(trackerDataMaxEntries).optional()
     }).optional(),
     items: node.optional(),
     minItems: size.optional(),
@@ -371,7 +526,7 @@ var node = z6.lazy(
     maximum: bound.optional(),
     exclusiveMinimum: bound.optional(),
     exclusiveMaximum: bound.optional(),
-    enum: z6.array(scalar).min(1).max(trackerDataMaxEntries).optional(),
+    enum: z7.array(scalar).min(1).max(trackerDataMaxEntries).optional(),
     const: scalar.optional(),
     anyOf: branches().optional(),
     oneOf: branches().optional(),
@@ -433,7 +588,7 @@ function nestedUnionIssue(schema, path, insideUnion) {
   }
   return null;
 }
-var trackerDataSchemaSchema = z6.unknown().superRefine((value, ctx) => {
+var trackerDataSchemaSchema = z7.unknown().superRefine((value, ctx) => {
   const issue = shapeIssue(value);
   if (issue) {
     ctx.addIssue({ code: "custom", message: issue, abort: true });
@@ -540,7 +695,7 @@ function subset(schema, path) {
 function trackerDataSchema(schema) {
   let json;
   try {
-    json = z6.toJSONSchema(schema, {
+    json = z7.toJSONSchema(schema, {
       target: "draft-2020-12",
       io: "input",
       unrepresentable: "throw",
@@ -908,21 +1063,21 @@ function whereSchemaIssue(schema, where) {
 }
 
 // src/trackers.ts
-import { z as z7 } from "zod";
-var timestamp = z7.number().int().safe().nonnegative().max(864e13);
-var count = z7.number().int().safe().nonnegative();
-var externalId = z7.string().min(1).max(256);
+import { z as z8 } from "zod";
+var timestamp = z8.number().int().safe().nonnegative().max(864e13);
+var count = z8.number().int().safe().nonnegative();
+var externalId = z8.string().min(1).max(256);
 var metric = count.nullable().default(null);
-var xTweetSchema = z7.looseObject({
+var xTweetSchema = z8.looseObject({
   id: externalId,
   userId: externalId,
-  content: z7.string(),
-  createdAt: z7.iso.datetime({ offset: true }),
-  author: z7.looseObject({
+  content: z8.string(),
+  createdAt: z8.iso.datetime({ offset: true }),
+  author: z8.looseObject({
     id: externalId,
-    username: z7.string(),
-    name: z7.string(),
-    verified: z7.boolean().nullable().default(null)
+    username: z8.string(),
+    name: z8.string(),
+    verified: z8.boolean().nullable().default(null)
   }),
   likeCount: metric,
   replyCount: metric,
@@ -930,84 +1085,84 @@ var xTweetSchema = z7.looseObject({
   quoteCount: metric,
   viewCount: metric,
   bookmarkCount: metric,
-  isReply: z7.boolean(),
-  isRetweet: z7.boolean(),
-  isQuoteTweet: z7.boolean()
-});
-var xContentBodySchema = z7.strictObject({
-  version: z7.literal(1),
-  id: z7.string().min(1),
-  authorId: z7.string().min(1),
+  isReply: z8.boolean(),
+  isRetweet: z8.boolean(),
+  isQuoteTweet: z8.boolean()
+});
+var xContentBodySchema = z8.strictObject({
+  version: z8.literal(1),
+  id: z8.string().min(1),
+  authorId: z8.string().min(1),
   publishedAt: timestamp,
-  text: z7.string(),
-  isReply: z7.boolean(),
-  isRetweet: z7.boolean(),
-  isQuoteTweet: z7.boolean(),
-  media: z7.array(z7.strictObject({ type: z7.string(), url: z7.string() })).nullable(),
-  mentionedAuthorIds: z7.array(z7.string().min(1)).nullable(),
-  videoLengthSeconds: z7.number().nonnegative().nullable(),
-  references: z7.strictObject({
-    replyId: z7.string().nullable(),
-    replyAuthorId: z7.string().nullable(),
-    quoteId: z7.string().nullable(),
-    quoteAuthorId: z7.string().nullable(),
-    repostId: z7.string().nullable(),
-    repostAuthorId: z7.string().nullable()
+  text: z8.string(),
+  isReply: z8.boolean(),
+  isRetweet: z8.boolean(),
+  isQuoteTweet: z8.boolean(),
+  media: z8.array(z8.strictObject({ type: z8.string(), url: z8.string() })).nullable(),
+  mentionedAuthorIds: z8.array(z8.string().min(1)).nullable(),
+  videoLengthSeconds: z8.number().nonnegative().nullable(),
+  references: z8.strictObject({
+    replyId: z8.string().nullable(),
+    replyAuthorId: z8.string().nullable(),
+    quoteId: z8.string().nullable(),
+    quoteAuthorId: z8.string().nullable(),
+    repostId: z8.string().nullable(),
+    repostAuthorId: z8.string().nullable()
   })
 });
-var trackerContentQuerySchema = z7.strictObject({
+var trackerContentQuerySchema = z8.strictObject({
   id: externalId,
-  observation: z7.string().regex(/^observation_[a-f0-9]{64}$/)
+  observation: z8.string().regex(/^observation_[a-f0-9]{64}$/)
 });
 var trackerContentReadSchema = trackerContentQuerySchema.extend({
   member: identifier
 });
 var attributionContext = { member: identifier, capturedAt: timestamp };
-var trackerEvidenceSchema = z7.strictObject({
+var trackerEvidenceSchema = z8.strictObject({
   contentRevision: identifier,
   observation: identifier
 });
-var trackerContentSchema = z7.strictObject({
+var trackerContentSchema = z8.strictObject({
   tracker: identifier,
-  source: z7.literal("x"),
+  source: z8.literal("x"),
   evidence: trackerEvidenceSchema,
   content: xContentBodySchema,
   observedAt: timestamp,
-  removed: z7.boolean(),
-  attribution: z7.discriminatedUnion("kind", [
-    z7.strictObject({
+  removed: z8.boolean(),
+  attribution: z8.discriminatedUnion("kind", [
+    z8.strictObject({
       ...attributionContext,
-      kind: z7.literal("linked"),
-      account: z7.strictObject({
-        provider: z7.literal("x"),
-        issuer: z7.string().min(1),
+      kind: z8.literal("linked"),
+      account: z8.strictObject({
+        provider: z8.literal("x"),
+        issuer: z8.string().min(1),
         subject: externalId,
         revision: count,
         linkedAt: timestamp.nullable()
       })
     }),
-    z7.strictObject({ ...attributionContext, kind: z7.literal("unlinked") }),
-    z7.strictObject({
+    z8.strictObject({ ...attributionContext, kind: z8.literal("unlinked") }),
+    z8.strictObject({
       ...attributionContext,
-      kind: z7.literal("different-author")
+      kind: z8.literal("different-author")
     })
   ])
 });
 var knownIdentityKinds = ["wallet", "x", "discord", "member"];
-var appIdentityKindSchema = z7.templateLiteral([
+var appIdentityKindSchema = z8.templateLiteral([
   "app:",
-  z7.string().regex(
+  z8.string().regex(
     /^[a-z0-9][a-z0-9_-]{0,39}$/,
     "Name an app identity kind like app:telegram: lowercase letters, digits, _ or -, at most 40"
   )
 ]);
-var identityKindSchema = z7.union([
-  z7.enum(knownIdentityKinds),
+var identityKindSchema = z8.union([
+  z8.enum(knownIdentityKinds),
   appIdentityKindSchema
 ]);
 var isAppIdentityKind = (kind) => kind.startsWith("app:");
-var openIdentityKindSchema = z7.string().min(1).max(64);
-var memberIdentitySchema = z7.object({
+var openIdentityKindSchema = z8.string().min(1).max(64);
+var memberIdentitySchema = z8.object({
   kind: openIdentityKindSchema,
   /** The stable user ID for `x` and `discord`; the subject your app signed the member in with for `app:<name>`. */
   subject: externalId,
@@ -1019,13 +1174,13 @@ var memberIdentitySchema = z7.object({
   /** The latest link time, refreshed on app identity relink; null when the link time is unknown. */
   linkedAt: timestamp.nullable()
 });
-var accountRoleSchema = z7.string().regex(
+var accountRoleSchema = z8.string().regex(
   /^[a-zA-Z][a-zA-Z0-9_]{0,39}$/,
   "Name roles like author or recipient: a letter, then letters, digits or underscores"
 );
 var xAccountRoles = ["author", "inReplyTo"];
 var distinct = (values2) => new Set(values2).size === values2.length;
-var contentMetricNameSchema = z7.string().regex(
+var contentMetricNameSchema = z8.string().regex(
   /^[a-z][a-zA-Z0-9]{0,39}$/,
   "Name metrics like likes or watchTime: a lowercase letter, then letters or digits"
 );
@@ -1037,24 +1192,24 @@ var xContentMetrics = [
   "views",
   "bookmarks"
 ];
-var customContentSchema = z7.strictObject({
-  metrics: z7.array(contentMetricNameSchema).max(10).refine(distinct, "List each metric once")
+var customContentSchema = z8.strictObject({
+  metrics: z8.array(contentMetricNameSchema).max(10).refine(distinct, "List each metric once")
 });
-var xSearchSourceSchema = z7.object({
-  kind: z7.literal("x-search"),
-  query: z7.string().trim().min(1).max(2e3)
+var xSearchSourceSchema = z8.object({
+  kind: z8.literal("x-search"),
+  query: z8.string().trim().min(1).max(2e3)
 }).strict();
-var customSourceSchema = z7.object({
-  kind: z7.literal("custom"),
+var customSourceSchema = z8.object({
+  kind: z8.literal("custom"),
   namespace: identifier,
   /**
    * The identity kinds a record's author and named accounts can be, attributed to members
    * through verified links: `wallet`, `x`, `discord`, `member`, or your app's own `app:<name>`.
    * Omitted when authors are opaque IDs, which no quest can pay.
    */
-  identities: z7.array(identityKindSchema).min(1).max(8).refine(distinct, "List each identity kind once").optional(),
+  identities: z8.array(identityKindSchema).min(1).max(8).refine(distinct, "List each identity kind once").optional(),
   /** Roles of the named accounts records can carry besides their author, such as `recipient`. */
-  accounts: z7.array(accountRoleSchema).min(1).max(10).refine(distinct, "List each account role once").refine(
+  accounts: z8.array(accountRoleSchema).min(1).max(10).refine(distinct, "List each account role once").refine(
     (roles) => !roles.includes("author"),
     "author is every record's own role; name other accounts"
   ).optional(),
@@ -1077,7 +1232,7 @@ var customSourceSchema = z7.object({
   (source) => !source.accounts || source.identities,
   "Named accounts need identities"
 );
-var trackerSourceSchema = z7.discriminatedUnion("kind", [
+var trackerSourceSchema = z8.discriminatedUnion("kind", [
   xSearchSourceSchema,
   customSourceSchema,
   discordMessagesSourceSchema,
@@ -1114,125 +1269,125 @@ function sourceContent(source) {
       return void 0;
   }
 }
-var windowSchema = z7.object({ start: timestamp, end: timestamp.optional() }).strict().refine(
+var windowSchema = z8.object({ start: timestamp, end: timestamp.optional() }).strict().refine(
   (w) => w.end === void 0 || w.end > w.start,
   "End must follow start"
 );
-var trackerDefinitionSchema = z7.object({
+var trackerDefinitionSchema = z8.object({
   key: identifier,
-  title: z7.string().trim().min(1).max(120),
+  title: z8.string().trim().min(1).max(120),
   source: trackerSourceSchema,
   window: windowSchema,
-  refreshSeconds: z7.number().int().min(300).max(86400).default(21600),
-  maxPages: z7.number().int().min(1).max(1e3).default(60)
+  refreshSeconds: z8.number().int().min(300).max(86400).default(21600),
+  maxPages: z8.number().int().min(1).max(1e3).default(60)
 }).strict();
-var trackerArtifactSchema = z7.union([
+var trackerArtifactSchema = z8.union([
   trackerDefinitionSchema,
-  z7.object({ code: z7.string().min(1).max(2e6) }).strict()
+  z8.object({ code: z8.string().min(1).max(2e6) }).strict()
 ]);
-var knownTrackerSourceResponseSchema = z7.discriminatedUnion("kind", [
-  z7.object(xSearchSourceSchema.shape),
-  z7.object({
+var knownTrackerSourceResponseSchema = z8.discriminatedUnion("kind", [
+  z8.object(xSearchSourceSchema.shape),
+  z8.object({
     ...customSourceSchema.shape,
-    identities: z7.array(openIdentityKindSchema).optional()
+    identities: z8.array(openIdentityKindSchema).optional()
   }),
-  z7.object(discordMessagesSourceSchema.shape),
-  z7.object(discordReactionsSourceSchema.shape)
+  z8.object(discordMessagesSourceSchema.shape),
+  z8.object(discordReactionsSourceSchema.shape)
 ]);
-var trackerSourceResponseSchema = z7.union([
+var trackerSourceResponseSchema = z8.union([
   knownTrackerSourceResponseSchema,
-  z7.object({
-    kind: z7.string().min(1).refine(
+  z8.object({
+    kind: z8.string().min(1).refine(
       (kind) => !trackerSourceKinds.some((known) => known === kind),
       "Known source kinds must match their schema"
     )
-  }).catchall(z7.json())
+  }).catchall(z8.json())
 ]);
 function isKnownTrackerSource(source) {
   return knownTrackerSourceResponseSchema.safeParse(source).success;
 }
-var trackerDefinitionResponseSchema = z7.object({
+var trackerDefinitionResponseSchema = z8.object({
   ...trackerDefinitionSchema.shape,
   source: trackerSourceResponseSchema,
-  window: z7.object(windowSchema.shape)
+  window: z8.object(windowSchema.shape)
 });
-var publishedTrackerSchema = z7.object({
+var publishedTrackerSchema = z8.object({
   id: identifier,
   version: identifier,
   definition: trackerDefinitionResponseSchema,
   publishedAt: timestamp,
-  actor: z7.string().nullable()
+  actor: z8.string().nullable()
 });
-var trackerStatusSchema = z7.object({
-  archivedAt: z7.number().int().nonnegative().nullable().optional(),
+var trackerStatusSchema = z8.object({
+  archivedAt: z8.number().int().nonnegative().nullable().optional(),
   published: publishedTrackerSchema,
-  paused: z7.boolean(),
-  state: z7.enum(["idle", "syncing", "error", "complete"]),
+  paused: z8.boolean(),
+  state: z8.enum(["idle", "syncing", "error", "complete"]),
   lastStartedAt: timestamp.nullable(),
   lastCompletedAt: timestamp.nullable(),
   nextSyncAt: timestamp.nullable(),
-  coverage: z7.enum(["unknown", "partial", "complete"]),
-  error: z7.string().nullable(),
+  coverage: z8.enum(["unknown", "partial", "complete"]),
+  error: z8.string().nullable(),
   records: count
 });
-var trackerControlSchema = z7.object({
+var trackerControlSchema = z8.object({
   actionId: identifier,
-  action: z7.enum(["pause", "resume", "refresh"])
+  action: z8.enum(["pause", "resume", "refresh"])
 }).strict();
-var trackerAccountSchema = z7.strictObject({
+var trackerAccountSchema = z8.strictObject({
   kind: identityKindSchema.optional(),
   id: externalId
 });
-var trackerRecordInputSchema = z7.object({
+var trackerRecordInputSchema = z8.object({
   id: externalId,
   occurredAt: timestamp,
   observedAt: timestamp,
-  author: z7.object({
+  author: z8.object({
     id: externalId,
-    verified: z7.boolean().nullable().default(null),
+    verified: z8.boolean().nullable().default(null),
     /** The author's identity kind; needed when the source names more than one. */
     kind: identityKindSchema.optional()
   }).strict().nullable().default(null),
   /** Named accounts besides the author, by the roles the custom source declares. */
-  accounts: z7.record(accountRoleSchema, trackerAccountSchema).refine(
+  accounts: z8.record(accountRoleSchema, trackerAccountSchema).refine(
     (accounts) => Object.keys(accounts).length <= 10,
     "At most 10 accounts"
   ).optional(),
-  data: z7.record(z7.string(), z7.json()),
-  removed: z7.boolean().default(false)
+  data: z8.record(z8.string(), z8.json()),
+  removed: z8.boolean().default(false)
 }).strict().refine(
   (v) => new TextEncoder().encode(JSON.stringify(v.data)).byteLength <= 131072,
   "Record exceeds 128 KB"
 );
-var trackerRecordAccountSchema = z7.object({
+var trackerRecordAccountSchema = z8.object({
   kind: openIdentityKindSchema.optional(),
-  id: z7.string()
+  id: z8.string()
 });
-var trackerRecordSchema = z7.object({
-  id: z7.string(),
+var trackerRecordSchema = z8.object({
+  id: z8.string(),
   occurredAt: timestamp,
   observedAt: timestamp,
-  author: z7.object({
-    id: z7.string(),
-    verified: z7.boolean().nullable().default(null),
+  author: z8.object({
+    id: z8.string(),
+    verified: z8.boolean().nullable().default(null),
     kind: openIdentityKindSchema.optional()
   }).nullable().default(null),
-  accounts: z7.record(z7.string(), trackerRecordAccountSchema).optional(),
-  data: z7.record(z7.string(), z7.json()),
-  removed: z7.boolean().default(false),
-  source: z7.string(),
+  accounts: z8.record(z8.string(), trackerRecordAccountSchema).optional(),
+  data: z8.record(z8.string(), z8.json()),
+  removed: z8.boolean().default(false),
+  source: z8.string(),
   firstSeenAt: timestamp,
   /** Present only when includeEvidence is true; custom sources have no X evidence. */
   evidence: trackerEvidenceSchema.nullable().optional()
 });
-var trackerIngestSchema = z7.object({
+var trackerIngestSchema = z8.object({
   actionId: identifier,
-  records: z7.array(trackerRecordInputSchema).min(1).max(100)
+  records: z8.array(trackerRecordInputSchema).min(1).max(100)
 }).strict();
-var trackerIngestResultSchema = z7.object({
+var trackerIngestResultSchema = z8.object({
   stored: count,
   /** Tracker-trigger decisions this ingest caused. Absent from servers without tracker triggers. */
-  admissions: z7.object({
+  admissions: z8.object({
     admitted: count,
     skipped: count,
     /**
@@ -1253,11 +1408,11 @@ var trackerOutcomeFields = {
   /** The release admitted, or the one active when the observation was skipped. */
   release: identifier,
   /** The account attribution resolved or failed to resolve, such as a CAIP-10 wallet ID. */
-  account: z7.string().nullable(),
+  account: z8.string().nullable(),
   createdAt: timestamp,
   updatedAt: timestamp,
   /** Null for automatic decisions; the staff actor after a retry. */
-  actor: z7.string().nullable()
+  actor: z8.string().nullable()
 };
 var trackerSkipCodes = [
   /** The quest is paused or no longer active. Catch-up after a pause is an operator decision. */
@@ -1312,26 +1467,26 @@ var trackerSkipCodes = [
   /** A prerequisite quest was not complete when the record occurred. */
   "prerequisites-incomplete"
 ];
-var trackerOutcomeSchema = z7.discriminatedUnion("state", [
-  z7.object({
+var trackerOutcomeSchema = z8.discriminatedUnion("state", [
+  z8.object({
     ...trackerOutcomeFields,
-    state: z7.literal("admitted"),
-    code: z7.null(),
-    reason: z7.null(),
+    state: z8.literal("admitted"),
+    code: z8.null(),
+    reason: z8.null(),
     /** The attributed member. */
     member: identifier,
     /** The admitted attempt. Its evaluation, decision and rewards live on the attempt. */
     attempt: identifier
   }),
-  z7.object({
+  z8.object({
     ...trackerOutcomeFields,
-    state: z7.literal("skipped"),
+    state: z8.literal("skipped"),
     /** Why the observation was skipped, as one of `trackerSkipCodes`. */
-    code: z7.string().min(1),
+    code: z8.string().min(1),
     /** Why the observation was skipped, for people. */
-    reason: z7.string(),
+    reason: z8.string(),
     /** Which window refused admission when `code` is `outside-window`. */
-    window: z7.enum(["tracker", "quest"]).optional(),
+    window: z8.enum(["tracker", "quest"]).optional(),
     /** The attributed member, when attribution got that far. */
     member: identifier.nullable(),
     attempt: identifier.nullable()
@@ -1342,67 +1497,67 @@ var trackerOutcomeFilters = {
   quest: identifier.optional(),
   record: externalId.optional(),
   member: identifier.optional(),
-  state: z7.enum(["admitted", "skipped"]).optional(),
+  state: z8.enum(["admitted", "skipped"]).optional(),
   /** Only skips with this code, such as `unlinked-account`. */
-  code: z7.string().min(1).max(100).optional(),
-  limit: z7.coerce.number().int().min(1).max(100).default(25)
+  code: z8.string().min(1).max(100).optional(),
+  limit: z8.coerce.number().int().min(1).max(100).default(25)
 };
-var trackerTriggerOutcomeQuerySchema = z7.strictObject({
+var trackerTriggerOutcomeQuerySchema = z8.strictObject({
   ...trackerOutcomeFilters,
   cursor: pageCursorSchema.optional()
 });
-var trackerTriggerOutcomePageSchema = z7.object({
-  items: z7.array(trackerOutcomeSchema).max(100),
+var trackerTriggerOutcomePageSchema = z8.object({
+  items: z8.array(trackerOutcomeSchema).max(100),
   nextCursor: pageCursorSchema.nullable()
 });
-var trackerOutcomeQuerySchema = z7.strictObject({
+var trackerOutcomeQuerySchema = z8.strictObject({
   ...trackerOutcomeFilters,
   /** Opaque cursor from `next`: older outcomes. */
-  before: z7.string().max(512).optional()
+  before: z8.string().max(512).optional()
 });
-var trackerOutcomePageSchema = z7.strictObject({
+var trackerOutcomePageSchema = z8.strictObject({
   /** Newest first. */
-  items: z7.array(trackerOutcomeSchema).max(100),
-  next: z7.string().nullable()
+  items: z8.array(trackerOutcomeSchema).max(100),
+  next: z8.string().nullable()
 });
-var trackerOutcomeRetrySchema = z7.strictObject({
+var trackerOutcomeRetrySchema = z8.strictObject({
   actionId: identifier,
   /** Quest key or ID. */
   quest: identifier,
   record: externalId,
   observedAt: timestamp
 });
-var booleanQuery = z7.union([
-  z7.boolean(),
-  z7.enum(["true", "false"]).transform((v) => v === "true")
+var booleanQuery = z8.union([
+  z8.boolean(),
+  z8.enum(["true", "false"]).transform((v) => v === "true")
 ]);
-var trackerQuerySchema = z7.object({
+var trackerQuerySchema = z8.object({
   author: externalId.optional(),
   member: identifier.optional(),
   verified: booleanQuery.optional(),
-  since: z7.coerce.number().int().safe().nonnegative().optional(),
-  until: z7.coerce.number().int().safe().nonnegative().optional(),
+  since: z8.coerce.number().int().safe().nonnegative().optional(),
+  until: z8.coerce.number().int().safe().nonnegative().optional(),
   removed: booleanQuery.default(false),
-  minLikes: z7.coerce.number().int().safe().nonnegative().optional(),
-  minViews: z7.coerce.number().int().safe().nonnegative().optional(),
-  limit: z7.coerce.number().int().min(1).max(100).default(25),
-  cursor: z7.string().max(2048).optional(),
+  minLikes: z8.coerce.number().int().safe().nonnegative().optional(),
+  minViews: z8.coerce.number().int().safe().nonnegative().optional(),
+  limit: z8.coerce.number().int().min(1).max(100).default(25),
+  cursor: z8.string().max(2048).optional(),
   includeEvidence: booleanQuery.optional()
 }).strict().refine(
   (q) => q.since === void 0 || q.until === void 0 || q.until > q.since,
   "Until must follow since"
 );
-var trackerPageSchema = z7.object({
+var trackerPageSchema = z8.object({
   tracker: identifier,
-  items: z7.array(trackerRecordSchema),
-  nextCursor: z7.string().nullable(),
+  items: z8.array(trackerRecordSchema),
+  nextCursor: z8.string().nullable(),
   total: count,
   status: trackerStatusSchema
 });
-var trackerSummarySchema = z7.object({
+var trackerSummarySchema = z8.object({
   records: count,
   authors: count,
-  metrics: z7.object({
+  metrics: z8.object({
     likes: count,
     replies: count,
     reposts: count,
@@ -1418,26 +1573,26 @@ var trackerPreviewLimits = {
   posts: 100,
   days: 30
 };
-var trackerPreviewInputSchema = z7.object({
+var trackerPreviewInputSchema = z8.object({
   query: xSearchSourceSchema.shape.query,
   /** Start of the searched window. The window ends when the sample is fetched. */
   since: timestamp
 }).strict();
-var trackerPreviewSchema = z7.object({
-  query: z7.string(),
+var trackerPreviewSchema = z8.object({
+  query: z8.string(),
   since: timestamp,
   fetchedAt: timestamp,
   pages: count,
   /** Every match in the sample, newest first, verified or not. */
-  posts: z7.array(xTweetSchema).max(trackerPreviewLimits.posts),
+  posts: z8.array(xTweetSchema).max(trackerPreviewLimits.posts),
   /** X had more matches than the sample holds. */
-  more: z7.boolean()
+  more: z8.boolean()
 });
 
 // src/content.ts
-import { z as z8 } from "zod";
-var contentQualificationDecisionSchema = z8.strictObject({
-  kind: z8.enum([
+import { z as z9 } from "zod";
+var contentQualificationDecisionSchema = z9.strictObject({
+  kind: z9.enum([
     "accept",
     "reject",
     "review",
@@ -1445,26 +1600,26 @@ var contentQualificationDecisionSchema = z8.strictObject({
     "progress",
     "superseded"
   ]),
-  reason: z8.string().nullable()
+  reason: z9.string().nullable()
 });
-var contentQualificationQuerySchema = z8.strictObject({
+var contentQualificationQuerySchema = z9.strictObject({
   quest: identifier,
   member: identifier.optional(),
   /** A content item's record ID in the quest's tracker. */
-  content: z8.string().min(1).max(256).optional(),
+  content: z9.string().min(1).max(256).optional(),
   cursor: pageCursorSchema.optional()
 });
-var contentQualificationSchema = z8.strictObject({
+var contentQualificationSchema = z9.strictObject({
   quest: identifier,
   /** The content item's record ID in the quest's tracker. */
-  content: z8.string(),
+  content: z9.string(),
   member: identifier,
   release: identifier,
   attempt: identifier,
   revision: identifier,
   observation: identifier,
-  current: z8.boolean(),
-  state: z8.enum([
+  current: z9.boolean(),
+  state: z9.enum([
     "pending",
     "qualified",
     "unqualified",
@@ -1475,117 +1630,117 @@ var contentQualificationSchema = z8.strictObject({
     "blocked",
     "unavailable"
   ]),
-  reason: z8.string().nullable(),
-  reward: z8.strictObject({
+  reason: z9.string().nullable(),
+  reward: z9.strictObject({
     attempt: identifier.nullable(),
     completion: identifier.nullable(),
-    state: z8.enum(["unresolved", "awarded", "excluded"])
+    state: z9.enum(["unresolved", "awarded", "excluded"])
   })
 });
-var contentQualificationPageSchema = z8.strictObject({
-  items: z8.array(contentQualificationSchema),
+var contentQualificationPageSchema = z9.strictObject({
+  items: z9.array(contentQualificationSchema),
   nextCursor: pageCursorSchema.nullable()
 });
 var contentMetricSchema = contentMetricNameSchema;
-var contentMetricsSchema = z8.record(
+var contentMetricsSchema = z9.record(
   contentMetricSchema,
-  z8.number().int().safe().nonnegative()
+  z9.number().int().safe().nonnegative()
 );
-var contentPerformancePolicySchema = z8.strictObject({
-  metrics: z8.array(contentMetricSchema).min(1).max(10).refine(
+var contentPerformancePolicySchema = z9.strictObject({
+  metrics: z9.array(contentMetricSchema).min(1).max(10).refine(
     (values2) => new Set(values2).size === values2.length,
     "Metrics must be unique"
   ),
-  maxAgeMs: z8.number().int().positive().max(864e5).default(36e5)
+  maxAgeMs: z9.number().int().positive().max(864e5).default(36e5)
 });
 
 // src/counters.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var day = 864e5;
-var counterGoalSchema = z9.object({
-  kind: z9.literal("count"),
-  count: z9.number().int().min(1).max(1e4)
+var counterGoalSchema = z10.object({
+  kind: z10.literal("count"),
+  count: z10.number().int().min(1).max(1e4)
 }).strict();
-var counterWindowSchema = z9.discriminatedUnion("kind", [
-  z9.object({ kind: z9.literal("lifetime") }).strict(),
-  z9.object({
-    kind: z9.literal("calendar"),
-    period: z9.enum(["day", "week", "month"]),
-    latenessMs: z9.number().int().min(0).max(90 * day).default(7 * day)
+var counterWindowSchema = z10.discriminatedUnion("kind", [
+  z10.object({ kind: z10.literal("lifetime") }).strict(),
+  z10.object({
+    kind: z10.literal("calendar"),
+    period: z10.enum(["day", "week", "month"]),
+    latenessMs: z10.number().int().min(0).max(90 * day).default(7 * day)
   }).strict(),
-  z9.object({
-    kind: z9.literal("rolling"),
-    durationMs: z9.number().int().min(1).max(365 * day)
+  z10.object({
+    kind: z10.literal("rolling"),
+    durationMs: z10.number().int().min(1).max(365 * day)
   }).strict()
 ]);
-var counterPolicySchema = z9.object({
-  kind: z9.literal("progress"),
+var counterPolicySchema = z10.object({
+  kind: z10.literal("progress"),
   goal: counterGoalSchema,
   window: counterWindowSchema,
-  repeat: z9.enum(["once", "repeat"]).default("once")
+  repeat: z10.enum(["once", "repeat"]).default("once")
 }).strict();
-var achievementBase = z9.object({
+var achievementBase = z10.object({
   id: identifier,
-  ordinal: z9.number().int().positive(),
-  achievedAt: z9.number().int(),
-  window: z9.string()
+  ordinal: z10.number().int().positive(),
+  achievedAt: z10.number().int(),
+  window: z10.string()
 });
-var counterAchievementSchema = z9.discriminatedUnion("status", [
+var counterAchievementSchema = z10.discriminatedUnion("status", [
   achievementBase.extend({
-    status: z9.literal("revoked"),
+    status: z10.literal("revoked"),
     completion: identifier,
-    revokedAt: z9.number().int()
+    revokedAt: z10.number().int()
   }),
   achievementBase.extend({
-    status: z9.literal("awarded"),
+    status: z10.literal("awarded"),
     completion: identifier
   }),
   achievementBase.extend({
-    status: z9.literal("budget-exhausted"),
+    status: z10.literal("budget-exhausted"),
     budget: identifier
   })
 ]);
-var counterProgressSchema = z9.object({
-  goal: z9.number().int().positive(),
-  current: z9.number().int().nonnegative(),
-  window: z9.object({
-    key: z9.string(),
-    start: z9.number().int().nullable(),
-    end: z9.number().int().nullable()
+var counterProgressSchema = z10.object({
+  goal: z10.number().int().positive(),
+  current: z10.number().int().nonnegative(),
+  window: z10.object({
+    key: z10.string(),
+    start: z10.number().int().nullable(),
+    end: z10.number().int().nullable()
   }),
-  repeat: z9.enum(["once", "repeat"]),
-  settled: z9.number().int().nonnegative(),
+  repeat: z10.enum(["once", "repeat"]),
+  settled: z10.number().int().nonnegative(),
   latest: counterAchievementSchema.nullable()
 });
-var counterContributionSchema = z9.object({
+var counterContributionSchema = z10.object({
   id: identifier,
-  distinct: z9.string(),
+  distinct: z10.string(),
   attempt: identifier,
-  occurredAt: z9.number().int(),
-  recordedAt: z9.number().int(),
-  window: z9.string(),
-  status: z9.enum(["counted", "late", "future", "excluded"]),
+  occurredAt: z10.number().int(),
+  recordedAt: z10.number().int(),
+  window: z10.string(),
+  status: z10.enum(["counted", "late", "future", "excluded"]),
   achievement: counterAchievementSchema.nullable(),
-  reason: z9.string().nullable()
+  reason: z10.string().nullable()
 });
-var counterHistorySchema = z9.object({
-  items: z9.array(counterContributionSchema),
-  nextCursor: z9.string().nullable()
+var counterHistorySchema = z10.object({
+  items: z10.array(counterContributionSchema),
+  nextCursor: z10.string().nullable()
 });
-var counterModerationSchema = z9.object({
-  actionId: z9.uuid(),
-  excluded: z9.boolean(),
-  reason: z9.string().trim().min(1).max(2e3)
+var counterModerationSchema = z10.object({
+  actionId: z10.uuid(),
+  excluded: z10.boolean(),
+  reason: z10.string().trim().min(1).max(2e3)
 }).strict();
-var counterHistoryQuerySchema = z9.object({
-  cursor: z9.string().max(2e3).optional(),
-  limit: z9.coerce.number().int().min(1).max(100).optional()
+var counterHistoryQuerySchema = z10.object({
+  cursor: z10.string().max(2e3).optional(),
+  limit: z10.coerce.number().int().min(1).max(100).optional()
 }).strict();
-var counterModerationResultSchema = z9.object({ excluded: z9.boolean() });
+var counterModerationResultSchema = z10.object({ excluded: z10.boolean() });
 
 // src/calendar.ts
-import { z as z10 } from "zod";
-var timestamp2 = z10.number().int().safe();
+import { z as z11 } from "zod";
+var timestamp2 = z11.number().int().safe();
 var fixedOffset = /^(?:[+-]|(?:Etc\/)?GMT[+-]\d|(?:EST|MST|HST)$)/i;
 function canonicalTimeZone(zone) {
   let resolved;
@@ -1601,18 +1756,18 @@ function canonicalTimeZone(zone) {
   }
   return fixedOffset.test(zone) || fixedOffset.test(resolved) ? null : resolved;
 }
-var timeZoneSchema = z10.string().min(1).max(100).transform((zone, ctx) => {
+var timeZoneSchema = z11.string().min(1).max(100).transform((zone, ctx) => {
   const canonical = canonicalTimeZone(zone);
   if (canonical === null) {
     ctx.addIssue({
       code: "custom",
       message: fixedOffset.test(zone) ? "Use a named IANA timezone, such as Europe/Budapest or UTC. Fixed offsets have no daylight-saving rules." : "Use an IANA timezone name, such as Europe/Budapest or UTC"
     });
-    return z10.NEVER;
+    return z11.NEVER;
   }
   return canonical;
 });
-var timeZoneNameSchema = z10.string().min(1).max(100);
+var timeZoneNameSchema = z11.string().min(1).max(100);
 var movedTimeZone = (what) => `${what} no longer take a timeZone: they follow the project calendar. Set calendar.timeZone in relay.json or in Console settings.`;
 var record = (value) => typeof value === "object" && value !== null;
 function refuseStreakTimeZone(value, ctx) {
@@ -1636,78 +1791,78 @@ function refuseWindowTimeZone(value, ctx) {
   }
   return value;
 }
-var calendarPeriodSchema = z10.enum(["lifetime", "day", "week", "month"]);
-var projectCalendarSchema = z10.object({
+var calendarPeriodSchema = z11.enum(["lifetime", "day", "week", "month"]);
+var projectCalendarSchema = z11.object({
   /** The timezone of the current calendar day. */
   timeZone: timeZoneNameSchema,
   /** The current calendar date, such as `2026-10-01`. */
-  today: z10.string(),
+  today: z11.string(),
   /** When the current calendar day ends, in epoch milliseconds. */
   nextBoundary: timestamp2,
   /** A change that takes effect at the next day boundary, or null. */
-  pending: z10.object({ timeZone: timeZoneNameSchema, effectiveAt: timestamp2 }).nullable(),
+  pending: z11.object({ timeZone: timeZoneNameSchema, effectiveAt: timestamp2 }).nullable(),
   /** The `calendar.timeZone` the last deployment that declared one set, or null. */
   declared: timeZoneNameSchema.nullable(),
   /**
    * A stored timezone the calendar no longer accepts, such as a fixed offset a streak named before
    * v1. The calendar reads it as UTC until an operator chooses a timezone. Null otherwise.
    */
-  unsupported: z10.string().nullable().default(null)
+  unsupported: z11.string().nullable().default(null)
 });
-var projectCalendarInputSchema = z10.object({
+var projectCalendarInputSchema = z11.object({
   actionId: identifier,
   timeZone: timeZoneSchema,
-  reason: z10.string().trim().min(1).max(500)
+  reason: z11.string().trim().min(1).max(500)
 }).strict();
-var projectCalendarDeclarationSchema = z10.object({ timeZone: timeZoneSchema }).strict();
+var projectCalendarDeclarationSchema = z11.object({ timeZone: timeZoneSchema }).strict();
 
 // src/streaks.ts
-import { z as z11 } from "zod";
-var streakPolicySchema = z11.object({
-  kind: z11.literal("streak"),
-  days: z11.number().int().min(1).max(3650)
-});
-var streakProgressSchema = z11.object({
-  goal: z11.number().int().positive(),
-  current: z11.number().int().nonnegative(),
-  best: z11.number().int().nonnegative(),
-  today: z11.string(),
-  todayQualified: z11.boolean(),
+import { z as z12 } from "zod";
+var streakPolicySchema = z12.object({
+  kind: z12.literal("streak"),
+  days: z12.number().int().min(1).max(3650)
+});
+var streakProgressSchema = z12.object({
+  goal: z12.number().int().positive(),
+  current: z12.number().int().nonnegative(),
+  best: z12.number().int().nonnegative(),
+  today: z12.string(),
+  todayQualified: z12.boolean(),
   timeZone: timeZoneNameSchema,
-  nextBoundary: z11.number().int(),
-  pendingTimeZone: z11.object({
+  nextBoundary: z12.number().int(),
+  pendingTimeZone: z12.object({
     timeZone: timeZoneNameSchema,
-    effectiveAt: z11.number().int()
+    effectiveAt: z12.number().int()
   }).nullable(),
-  days: z11.array(
-    z11.object({
-      day: z11.number().int(),
-      date: z11.string(),
+  days: z12.array(
+    z12.object({
+      day: z12.number().int(),
+      date: z12.string(),
       // The zone the day was recorded in, as stored: days from before v1 can name a fixed offset.
-      timeZone: z11.string(),
-      occurredAt: z11.number().int()
+      timeZone: z12.string(),
+      occurredAt: z12.number().int()
     })
   ),
-  milestone: z11.discriminatedUnion("status", [
-    z11.object({ status: z11.literal("pending") }),
-    z11.object({
-      status: z11.literal("awarded"),
-      completion: z11.string(),
-      achievedAt: z11.number().int()
+  milestone: z12.discriminatedUnion("status", [
+    z12.object({ status: z12.literal("pending") }),
+    z12.object({
+      status: z12.literal("awarded"),
+      completion: z12.string(),
+      achievedAt: z12.number().int()
     }),
-    z11.object({
-      status: z11.literal("budget-exhausted"),
-      budget: z11.string(),
-      achievedAt: z11.number().int()
+    z12.object({
+      status: z12.literal("budget-exhausted"),
+      budget: z12.string(),
+      achievedAt: z12.number().int()
     })
   ])
 });
 
 // src/tracker-triggers.ts
-import { z as z12 } from "zod";
-var timestamp3 = z12.number().int().safe().nonnegative().max(864e13);
-var count2 = z12.number().int().safe().nonnegative();
-var trackerTriggerModeSchema = z12.enum([
+import { z as z13 } from "zod";
+var timestamp3 = z13.number().int().safe().nonnegative().max(864e13);
+var count2 = z13.number().int().safe().nonnegative();
+var trackerTriggerModeSchema = z13.enum([
   "new-record",
   "new-observation",
   "data-changed"
@@ -1715,20 +1870,20 @@ var trackerTriggerModeSchema = z12.enum([
 function defaultTriggerMode(source) {
   return source === "custom" ? "new-observation" : "new-record";
 }
-var trackerBoundSchema = z12.union([
-  z12.number().finite(),
-  z12.strictObject({ setting: z12.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/) })
+var trackerBoundSchema = z13.union([
+  z13.number().finite(),
+  z13.strictObject({ setting: z13.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/) })
 ]);
-var dataPath = z12.string().max(200).regex(
+var dataPath = z13.string().max(200).regex(
   /^[^.\s]+(\.[^.\s]+)*$/,
   "Use dot-separated keys, such as metrics.likes"
 );
-var trackerConditionSchema = z12.union([
-  z12.strictObject({
+var trackerConditionSchema = z13.union([
+  z13.strictObject({
     path: dataPath,
-    equals: z12.union([z12.string().max(1e3), z12.number().finite(), z12.boolean()])
+    equals: z13.union([z13.string().max(1e3), z13.number().finite(), z13.boolean()])
   }),
-  z12.strictObject({
+  z13.strictObject({
     path: dataPath,
     gt: trackerBoundSchema.optional(),
     gte: trackerBoundSchema.optional(),
@@ -1741,9 +1896,9 @@ var trackerConditionSchema = z12.union([
     "Compare with equals, gt, gte, lt or lte"
   )
 ]);
-var trackerWhereSchema = z12.union([
+var trackerWhereSchema = z13.union([
   trackerConditionSchema,
-  z12.array(trackerConditionSchema).min(1).max(10)
+  z13.array(trackerConditionSchema).min(1).max(10)
 ]);
 function whereConditions(where) {
   return where === void 0 ? [] : Array.isArray(where) ? where : [where];
@@ -1755,17 +1910,17 @@ function whereSettings(where) {
     )
   );
 }
-var triggerEnrollmentSchema = z12.enum(["none", "required"]);
-var triggerSinceSchema = z12.enum(["activation", "window", "enrollment"]);
-var triggerHistoricalSchema = z12.enum(["staff", "claim", "automatic"]);
-var trackerTriggerPolicySchema = z12.strictObject({
+var triggerEnrollmentSchema = z13.enum(["none", "required"]);
+var triggerSinceSchema = z13.enum(["activation", "window", "enrollment"]);
+var triggerHistoricalSchema = z13.enum(["staff", "claim", "automatic"]);
+var trackerTriggerPolicySchema = z13.strictObject({
   /** The tracker's authoring key; publication binds it to the tracker's stable ID. */
   tracker: identifier,
   /**
    * The tracker's source kind, one of `trackerSourceKinds` today. An open string, so readers of
    * releases keep parsing them when a later Relay adds a managed source.
    */
-  source: z12.string().min(1).max(100),
+  source: z13.string().min(1).max(100),
   /** Which observations fire. */
   on: trackerTriggerModeSchema,
   where: trackerWhereSchema.optional(),
@@ -1786,7 +1941,7 @@ var trackerTriggerPolicySchema = z12.strictObject({
    * that re-evaluates edits and runs `performance`, firing on each new record and paying its
    * author.
    */
-  content: z12.literal(true).optional()
+  content: z13.literal(true).optional()
 }).refine(
   (policy) => policy.since !== "enrollment" || policy.enrollment === "required",
   'since: "enrollment" needs enrollment: "required"'
@@ -1805,72 +1960,72 @@ function beneficiaryRole(policy) {
   return policy.beneficiary;
 }
 var xLink = {
-  issuer: z12.string().min(1),
+  issuer: z13.string().min(1),
   /** The account's stable user ID. */
-  subject: z12.string().min(1).max(256),
+  subject: z13.string().min(1).max(256),
   /** The member's account selection revision. */
   revision: count2,
   /** When the member linked the account; null when unknown. */
   linkedAt: timestamp3.nullable()
 };
-var trackerAttributionSchema = z12.object({
+var trackerAttributionSchema = z13.object({
   member: identifier,
   capturedAt: timestamp3,
-  account: z12.union([
-    z12.object({
-      provider: z12.literal("wallet"),
+  account: z13.union([
+    z13.object({
+      provider: z13.literal("wallet"),
       /** Canonical CAIP-10 account ID, as the record names it. */
-      id: z12.string().min(5).max(256),
+      id: z13.string().min(5).max(256),
       /** The wallet link's revision. */
       revision: count2,
       /** When the member verified the wallet. */
       linkedAt: timestamp3.nullable()
     }),
-    z12.object({ provider: z12.literal("x"), ...xLink }),
-    z12.object({ provider: z12.literal("discord"), ...xLink }),
-    z12.object({
-      provider: z12.literal("member"),
+    z13.object({ provider: z13.literal("x"), ...xLink }),
+    z13.object({ provider: z13.literal("discord"), ...xLink }),
+    z13.object({
+      provider: z13.literal("member"),
       /** The member ID the record names. */
       id: identifier
     }),
-    z12.object({
+    z13.object({
       /** Your app's identity kind, such as `app:telegram`. */
       provider: appIdentityKindSchema,
       /** The subject your app signed the member in with, as the record names it. */
-      subject: z12.string().min(1).max(256),
+      subject: z13.string().min(1).max(256),
       /** The identity's revision in the project. */
       revision: count2,
       /** When the identity was linked to the member. */
       linkedAt: timestamp3.nullable()
     }),
     /** A kind a later Relay adds. */
-    z12.object({ provider: z12.string().min(1) })
+    z13.object({ provider: z13.string().min(1) })
   ])
 });
-var trackerTriggerRecordSchema = z12.object({
-  id: z12.string().min(1).max(256),
-  source: z12.string(),
+var trackerTriggerRecordSchema = z13.object({
+  id: z13.string().min(1).max(256),
+  source: z13.string(),
   occurredAt: timestamp3,
   observedAt: timestamp3,
   firstSeenAt: timestamp3,
-  author: z12.object({
-    id: z12.string().min(1).max(256),
-    verified: z12.boolean().nullable(),
+  author: z13.object({
+    id: z13.string().min(1).max(256),
+    verified: z13.boolean().nullable(),
     kind: openIdentityKindSchema.optional()
   }).nullable(),
-  accounts: z12.record(accountRoleSchema, trackerRecordAccountSchema).optional(),
-  data: z12.record(z12.string(), z12.json()),
-  removed: z12.boolean()
+  accounts: z13.record(accountRoleSchema, trackerRecordAccountSchema).optional(),
+  data: z13.record(z13.string(), z13.json()),
+  removed: z13.boolean()
 });
-var trackerContentStageSchema = z12.object({
+var trackerContentStageSchema = z13.object({
   /** The body's revision: the hash of its canonical JSON. Edits make a new one. */
   revision: identifier,
   /** The captured observation that carried this body. */
   observation: identifier,
   /** The body: an X post's normalized body, or a custom record's `data.body`. */
-  body: z12.record(z12.string(), z12.json())
+  body: z13.record(z13.string(), z13.json())
 });
-var trackerTriggerContextSchema = z12.object({
+var trackerTriggerContextSchema = z13.object({
   /** The tracker's stable ID. */
   tracker: identifier,
   /** The tracker's authoring key. */
@@ -1892,61 +2047,214 @@ var trackerTriggerContextSchema = z12.object({
 });
 
 // src/completion.ts
-import { z as z13 } from "zod";
-var name = z13.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
-var completionPolicySchema = z13.discriminatedUnion("kind", [
+import { z as z14 } from "zod";
+var name = z14.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
+var completionPolicySchema = z14.discriminatedUnion("kind", [
   streakPolicySchema,
   counterPolicySchema,
-  z13.object({ kind: z13.literal("once") }).strict(),
-  z13.object({ kind: z13.literal("keyed") }).strict()
+  z14.object({ kind: z14.literal("once") }).strict(),
+  z14.object({ kind: z14.literal("keyed") }).strict()
 ]);
-var completionKeySchema = z13.string().min(1).max(500);
-var budgetSchema = z13.object({
+var completionKeySchema = z14.string().min(1).max(500);
+var budgetSchema = z14.object({
   id: name,
-  scope: z13.enum(["member", "project"]),
+  scope: z14.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: z13.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  cost: z13.union([
-    z13.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-    z13.object({ balance: name }).strict()
+  limit: z14.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  cost: z14.union([
+    z14.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    z14.object({ balance: name }).strict()
   ])
 }).strict();
 
 // src/integrations.ts
-import { z as z14 } from "zod";
-var evaluatorIntegrationProviderSchema = z14.enum(["discord", "x"]);
-var integrationProviderSchema = z14.enum(["discord"]);
-var discordServerSchema = z14.object({
-  id: z14.string().regex(/^[0-9]{1,20}$/),
-  name: z14.string().min(1),
-  icon: z14.string().nullable()
-});
-var projectIntegrationSchema = z14.object({
+import { z as z15 } from "zod";
+var evaluatorIntegrationProviderSchema = z15.enum(["discord", "x"]);
+var integrationProviderSchema = z15.enum(["discord"]);
+var discordServerSchema = z15.object({
+  id: z15.string().regex(/^[0-9]{1,20}$/),
+  name: z15.string().min(1),
+  icon: z15.string().nullable()
+});
+var projectIntegrationSchema = z15.object({
   provider: integrationProviderSchema,
-  configured: z14.boolean(),
-  status: z14.enum(["disconnected", "ready", "attention"]),
-  revision: z14.number().int().nonnegative(),
+  configured: z15.boolean(),
+  status: z15.enum(["disconnected", "ready", "attention"]),
+  revision: z15.number().int().nonnegative(),
   server: discordServerSchema.nullable(),
-  issue: z14.string().nullable(),
-  connectedAt: z14.number().default(0)
+  issue: z15.string().nullable(),
+  connectedAt: z15.number().default(0)
 });
 
+// src/wallet.ts
+import { z as z16 } from "zod";
+var solanaAddressSchema = z16.string().min(32).max(44).regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
+var walletChainSchema = z16.enum(["solana", "eip155", "cosmos"]);
+var cosmosNetworkPattern = /^cosmos:[-_a-zA-Z0-9]{1,32}$/;
+var cosmosNetworkSchema = z16.custom(
+  (value) => typeof value === "string" && cosmosNetworkPattern.test(value),
+  "Use a Cosmos network: cosmos:<chain ID>"
+);
+var cosmosDenomSchema = z16.string().regex(
+  /^[a-zA-Z][a-zA-Z0-9/:._-]{2,127}$/,
+  "Use a Cosmos bank denomination such as uatom or uosmo"
+);
+function cosmosChain(chain) {
+  if (typeof chain === "string" && !chain.startsWith("cosmos:")) {
+    throw new Error('Use a Cosmos network such as "cosmos:cosmoshub-4"');
+  }
+  const value = typeof chain === "string" ? { chainId: chain.slice("cosmos:".length) } : chain;
+  if (typeof value?.chainId !== "string") {
+    throw new Error(
+      'Pass a Cosmos chain as { chainId } or a network such as "cosmos:cosmoshub-4"'
+    );
+  }
+  const network = `cosmos:${value.chainId}`;
+  if (!cosmosNetworkPattern.test(network)) {
+    throw new Error(
+      "A Cosmos chain ID has 1 to 32 letters, digits, hyphens or underscores"
+    );
+  }
+  if (value.chainInfo && value.chainInfo.chainId !== value.chainId) {
+    throw new Error("The chain info describes another chain ID");
+  }
+  return { ...value, network };
+}
+var solanaMainnet = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+var evmAddressSchema = z16.string().regex(/^0x[0-9a-fA-F]{40}$/);
+var cosmosAddressSchema = z16.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 = z16.discriminatedUnion("chain", [
+  z16.object({ chain: z16.literal("solana"), address: solanaAddressSchema }).strict(),
+  z16.object({
+    chain: z16.literal("eip155"),
+    address: evmAddressSchema,
+    /** Shown in the sign-in message's Chain ID line only: links are chain-agnostic. Defaults to 1. */
+    chainId: z16.number().int().positive().safe().optional()
+  }).strict(),
+  z16.object({
+    chain: z16.literal("cosmos"),
+    network: cosmosNetworkSchema,
+    address: cosmosAddressSchema
+  }).strict()
+]);
+var walletMessageChallengeSchema = z16.object({
+  id: z16.string().min(1).max(200),
+  purpose: z16.enum(["link", "sign-in"]),
+  chain: walletChainSchema,
+  network: cosmosNetworkSchema.nullable(),
+  /** Canonical (base58, EIP-55 or lowercase bech32). The signer must sign with this address. */
+  address: z16.string(),
+  message: z16.string().max(4096),
+  expiresAt: z16.number().int()
+});
+var walletSignatureSchema = z16.object({
+  challenge: z16.string().min(1).max(200),
+  /** solana: base58, 64 bytes · eip155: 0x and 130 hex digits (65 bytes) · cosmos: base64, 64 bytes (r‖s) */
+  signature: z16.string().min(1).max(256),
+  /** cosmos only: the base64 33-byte compressed secp256k1 key from signArbitrary's pub_key.value */
+  publicKey: z16.string().max(128).optional()
+}).strict();
+var linkedWalletSchema = z16.object({
+  chain: walletChainSchema,
+  network: cosmosNetworkSchema.nullable(),
+  address: z16.string(),
+  verifiedAt: z16.number().int().nonnegative(),
+  revision: z16.number().int().positive(),
+  /** True when this wallet can sign in: it was first used through wallet sign-in. Linking never enables sign-in. */
+  signIn: z16.boolean()
+});
+var walletUnlinkInputSchema = z16.object({ chain: walletChainSchema, address: z16.string().min(1).max(100) }).strict();
+async function walletAddressInput(signer) {
+  const address = await signer.address();
+  switch (signer.chain) {
+    case "solana":
+      return { chain: "solana", address };
+    case "eip155":
+      return {
+        chain: "eip155",
+        address,
+        ...signer.chainId ? { chainId: await signer.chainId() } : {}
+      };
+    case "cosmos":
+      if (!signer.network) {
+        throw clientError(
+          "Choose the Cosmos chain for this wallet",
+          RelayErrorCode.InvalidInput
+        );
+      }
+      return { chain: "cosmos", network: signer.network, address };
+  }
+}
+var WALLETS_PER_CHAIN = 5;
+var walletSignInFamilies = ["solana", "eip155", "cosmos"];
+var walletSignInNetworkSchema = z16.enum(walletSignInFamilies);
+var walletSignInNetworksSchema = z16.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))
+);
+function walletSignInNetwork(wallet) {
+  return wallet.chain;
+}
+function caip10(wallet, network) {
+  if (wallet.chain === "cosmos") {
+    if (!wallet.network || network && network !== wallet.network) {
+      throw new Error("A Cosmos wallet belongs to its own network");
+    }
+    return `${wallet.network}:${wallet.address}`;
+  }
+  const selected = network ?? (wallet.chain === "solana" ? solanaMainnet : "eip155:1");
+  const valid = wallet.chain === "solana" ? /^solana:[1-9A-HJ-NP-Za-km-z]{32}$/.test(selected) : isEvmChainId(selected);
+  if (!valid) {
+    throw new Error(`Use a ${wallet.chain} network for this wallet`);
+  }
+  return `${selected}:${wallet.address}`;
+}
+function isEvmChainId(value) {
+  return /^eip155:[1-9][0-9]{0,15}$/.test(value);
+}
+var evmChainIdSchema = z16.custom(
+  (value) => typeof value === "string" && isEvmChainId(value),
+  'Use an EVM chain ID such as "eip155:8453"'
+);
+var units = z16.string().regex(/^(0|[1-9][0-9]*)$/);
+var walletBalanceSchema = responseShape(
+  z16.object({
+    /** Canonical CAIP-2 ID for Solana, EVM or a supported Cosmos SDK chain. */
+    chain: z16.string(),
+    /** The canonical mint, EIP-55 contract or Cosmos bank denom; null for a native coin. */
+    token: z16.string().nullable(),
+    /** Null when token metadata does not report decimals. */
+    decimals: z16.number().int().min(0).max(255).nullable(),
+    /** The sum over `wallets`. */
+    total: units,
+    wallets: z16.array(
+      z16.object({ address: z16.string(), amount: units }).strict()
+    ),
+    /** Solana: lowest slot. EVM: approximate latest block. Cosmos: the fixed queried block. */
+    at: z16.object({ kind: z16.enum(["slot", "block"]), number: units }).strict(),
+    observedAt: z16.number().int().nonnegative()
+  }).strict()
+);
+
 // src/submission-input.ts
-import { z as z15 } from "zod";
-var textOptionsSchema = z15.object({
-  required: z15.boolean().default(true),
-  minLength: z15.number().int().min(0).max(1e4).default(1),
-  maxLength: z15.number().int().min(1).max(1e4).default(1e4)
+import { z as z17 } from "zod";
+var textOptionsSchema = z17.object({
+  required: z17.boolean().default(true),
+  minLength: z17.number().int().min(0).max(1e4).default(1),
+  maxLength: z17.number().int().min(1).max(1e4).default(1e4)
 }).strict().refine(
   (v) => v.minLength <= v.maxLength,
   "minLength must not exceed maxLength"
 );
-var hostSchema = z15.string().min(1).max(253).refine((host) => {
+var hostSchema = z17.string().min(1).max(253).refine((host) => {
   if (!/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/i.test(host) || host.includes("..")) {
     return false;
   }
@@ -1957,13 +2265,13 @@ var hostSchema = z15.string().min(1).max(253).refine((host) => {
     return false;
   }
 }, "Use a hostname without a scheme, path, port, or wildcard");
-var urlOptionsSchema = z15.object({
-  required: z15.boolean().default(true),
-  allowedHosts: z15.array(hostSchema).min(1).max(100).optional()
+var urlOptionsSchema = z17.object({
+  required: z17.boolean().default(true),
+  allowedHosts: z17.array(hostSchema).min(1).max(100).optional()
 }).strict();
-var textEvidenceSchema = z15.object({ kind: z15.literal("text"), value: z15.string().max(1e4) }).strict();
-var urlEvidenceSchema = z15.object({ kind: z15.literal("url"), value: z15.string().max(2048) }).strict();
-var valueEvidenceSchema = z15.discriminatedUnion("kind", [
+var textEvidenceSchema = z17.object({ kind: z17.literal("text"), value: z17.string().max(1e4) }).strict();
+var urlEvidenceSchema = z17.object({ kind: z17.literal("url"), value: z17.string().max(2048) }).strict();
+var valueEvidenceSchema = z17.discriminatedUnion("kind", [
   textEvidenceSchema,
   urlEvidenceSchema
 ]);
@@ -2026,22 +2334,22 @@ function xPostId(value) {
 }
 
 // src/quiz.ts
-import { z as z16 } from "zod";
-var quizId = z16.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
-var quizChoiceSchema = z16.object({ id: quizId, label: z16.string().trim().min(1).max(500) }).strict();
-var quizQuestionSchema = z16.object({
+import { z as z18 } from "zod";
+var quizId = z18.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
+var quizChoiceSchema = z18.object({ id: quizId, label: z18.string().trim().min(1).max(500) }).strict();
+var quizQuestionSchema = z18.object({
   id: quizId,
-  prompt: z16.string().trim().min(1).max(1e3),
-  choices: z16.array(quizChoiceSchema).min(2).max(8).refine(
+  prompt: z18.string().trim().min(1).max(1e3),
+  choices: z18.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 = z16.array(quizQuestionSchema).min(1).max(20).refine(
+var quizQuestionsSchema = z18.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 = z16.array(
+var quizContentSchema = z18.array(
   quizQuestionSchema.extend({ correct: quizId }).refine(
     (question) => question.choices.some((choice) => choice.id === question.correct),
     "Choose a correct answer from the available choices"
@@ -2052,94 +2360,94 @@ var quizContentSchema = z16.array(
 );
 
 // src/resources.ts
-import { z as z17 } from "zod";
-var resourceSourceSchema = z17.union([
-  z17.strictObject({
-    provider: z17.literal("domino"),
-    resource: z17.literal("point-ledger")
+import { z as z19 } from "zod";
+var resourceSourceSchema = z19.union([
+  z19.strictObject({
+    provider: z19.literal("domino"),
+    resource: z19.literal("point-ledger")
   }),
   discordResourceSourceSchema
 ]);
-var resourceRequestSchema = z17.object({
+var resourceRequestSchema = z19.object({
   source: resourceSourceSchema,
-  query: z17.string().max(100).optional(),
-  cursor: z17.string().regex(/^\d{1,6}$/).optional(),
-  ids: z17.array(z17.string().min(1).max(100)).max(50).optional()
+  query: z19.string().max(100).optional(),
+  cursor: z19.string().regex(/^\d{1,6}$/).optional(),
+  ids: z19.array(z19.string().min(1).max(100)).max(50).optional()
 }).strict();
-var resourceOptionsSchema = z17.object({
-  revision: z17.number().int(),
-  options: z17.array(
-    z17.object({
-      id: z17.string(),
-      label: z17.string(),
-      description: z17.string().optional(),
-      group: z17.string().optional(),
-      disabledReason: z17.string().optional()
+var resourceOptionsSchema = z19.object({
+  revision: z19.number().int(),
+  options: z19.array(
+    z19.object({
+      id: z19.string(),
+      label: z19.string(),
+      description: z19.string().optional(),
+      group: z19.string().optional(),
+      disabledReason: z19.string().optional()
     })
   ),
   /** Pass back as `cursor` for the next page; null on the last one. */
-  nextCursor: z17.string().nullable().default(null),
+  nextCursor: z19.string().nullable().default(null),
   /** @deprecated Use `nextCursor`. Removed in 2.0.0. */
-  cursor: z17.string().nullable()
+  cursor: z19.string().nullable()
 });
 
 // src/settings.ts
-import { z as z19 } from "zod";
+import { z as z21 } from "zod";
 
 // src/setting-values.ts
-import { z as z18 } from "zod";
-var settingInstant = z18.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
-var settingResourceId = z18.union([
-  z18.literal(""),
-  z18.string().regex(/^\S{1,200}$/)
+import { z as z20 } from "zod";
+var settingInstant = z20.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
+var settingResourceId = z20.union([
+  z20.literal(""),
+  z20.string().regex(/^\S{1,200}$/)
 ]);
 
 // src/settings.ts
-var base = { label: z19.string().min(1), description: z19.string().optional() };
-var settingFieldSchema = z19.discriminatedUnion("kind", [
-  z19.object({
+var base = { label: z21.string().min(1), description: z21.string().optional() };
+var settingFieldSchema = z21.discriminatedUnion("kind", [
+  z21.object({
     ...base,
-    kind: z19.literal("point-ledger"),
-    default: identifier.or(z19.literal(""))
+    kind: z21.literal("point-ledger"),
+    default: identifier.or(z21.literal(""))
   }).strict(),
-  z19.object({ ...base, kind: z19.literal("datetime"), default: settingInstant }).strict(),
-  z19.object({
+  z21.object({ ...base, kind: z21.literal("datetime"), default: settingInstant }).strict(),
+  z21.object({
     ...base,
-    kind: z19.literal("resource"),
+    kind: z21.literal("resource"),
     default: settingResourceId,
     source: resourceSourceSchema
   }).strict(),
-  z19.object({ ...base, kind: z19.literal("quiz"), default: quizContentSchema }).strict(),
-  z19.object({
+  z21.object({ ...base, kind: z21.literal("quiz"), default: quizContentSchema }).strict(),
+  z21.object({
     ...base,
-    kind: z19.literal("text"),
-    default: z19.string(),
-    minLength: z19.number().int().nonnegative(),
-    maxLength: z19.number().int().positive(),
-    multiline: z19.boolean()
+    kind: z21.literal("text"),
+    default: z21.string(),
+    minLength: z21.number().int().nonnegative(),
+    maxLength: z21.number().int().positive(),
+    multiline: z21.boolean()
   }).strict(),
-  z19.object({
+  z21.object({
     ...base,
-    kind: z19.literal("integer"),
-    default: z19.number().int(),
-    min: z19.number().int(),
-    max: z19.number().int()
+    kind: z21.literal("integer"),
+    default: z21.number().int(),
+    min: z21.number().int(),
+    max: z21.number().int()
   }).strict(),
-  z19.object({ ...base, kind: z19.literal("boolean"), default: z19.boolean() }).strict(),
-  z19.object({
+  z21.object({ ...base, kind: z21.literal("boolean"), default: z21.boolean() }).strict(),
+  z21.object({
     ...base,
-    kind: z19.literal("choice"),
-    default: z19.string(),
-    options: z19.array(z19.string().min(1)).min(1)
+    kind: z21.literal("choice"),
+    default: z21.string(),
+    options: z21.array(z21.string().min(1)).min(1)
   }).strict()
 ]);
-var settingsFieldsSchema = z19.record(
-  z19.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
+var settingsFieldsSchema = z21.record(
+  z21.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
   settingFieldSchema
 );
-var settingsValuesSchema = z19.record(
-  z19.string(),
-  z19.union([z19.string(), z19.number().finite(), z19.boolean(), quizContentSchema])
+var settingsValuesSchema = z21.record(
+  z21.string(),
+  z21.union([z21.string(), z21.number().finite(), z21.boolean(), quizContentSchema])
 );
 function parseSettings(fields2, input) {
   const shape = {};
@@ -2158,20 +2466,20 @@ function parseSettings(fields2, input) {
         shape[key] = quizContentSchema.default(field.default);
         break;
       case "text":
-        shape[key] = z19.string().min(field.minLength).max(field.maxLength).default(field.default);
+        shape[key] = z21.string().min(field.minLength).max(field.maxLength).default(field.default);
         break;
       case "integer":
-        shape[key] = z19.number().int().min(field.min).max(field.max).default(field.default);
+        shape[key] = z21.number().int().min(field.min).max(field.max).default(field.default);
         break;
       case "boolean":
-        shape[key] = z19.boolean().default(field.default);
+        shape[key] = z21.boolean().default(field.default);
         break;
       case "choice":
-        shape[key] = z19.enum(field.options).default(field.default);
+        shape[key] = z21.enum(field.options).default(field.default);
         break;
     }
   }
-  return settingsValuesSchema.parse(z19.object(shape).strict().parse(input));
+  return settingsValuesSchema.parse(z21.object(shape).strict().parse(input));
 }
 function missingResourceSettings(fields2, values2) {
   return Object.entries(fields2).filter(
@@ -2192,21 +2500,21 @@ function authoringKey(input) {
 }
 
 // src/campaigns.ts
-import { z as z20 } from "zod";
-var timestamp4 = z20.number().int().safe().nonnegative();
-var availabilityWindowSchema = z20.object({ from: timestamp4, until: timestamp4 }).strict().refine((window) => window.until > window.from, {
+import { z as z22 } from "zod";
+var timestamp4 = z22.number().int().safe().nonnegative();
+var availabilityWindowSchema = z22.object({ from: timestamp4, until: timestamp4 }).strict().refine((window) => window.until > window.from, {
   message: "Window end must follow its start",
   path: ["until"]
 });
-var campaignDefinitionSchema = z20.object({
+var campaignDefinitionSchema = z22.object({
   key: identifier,
-  title: z20.string().trim().min(1).max(120),
+  title: z22.string().trim().min(1).max(120),
   window: availabilityWindowSchema.optional(),
-  enrollment: z20.enum(["none", "required"]).default("none")
+  enrollment: z22.enum(["none", "required"]).default("none")
 }).strict();
 var campaignAuthoringSchema = campaignDefinitionSchema.omit({ key: true, title: true }).extend({
   ...authoringIdentityShape,
-  title: z20.string().trim().min(1).max(120).optional()
+  title: z22.string().trim().min(1).max(120).optional()
 }).strict().transform((value) => {
   const normalized = value;
   return campaignDefinitionSchema.parse({
@@ -2220,42 +2528,42 @@ function defineCampaign(input) {
 var campaignViewSchema = campaignDefinitionSchema.extend({
   enrolledAt: timestamp4.nullable(),
   withdrawnAt: timestamp4.nullable().default(null),
-  withdrawalReason: z20.string().nullable().default(null)
+  withdrawalReason: z22.string().nullable().default(null)
 });
-var campaignEnrollmentInputSchema = z20.object({ actionId: identifier, campaign: identifier }).strict();
+var campaignEnrollmentInputSchema = z22.object({ actionId: identifier, campaign: identifier }).strict();
 var memberCampaignEnrollmentInputSchema = campaignEnrollmentInputSchema.extend({ member: identifier });
 var campaignWithdrawalInputSchema = campaignEnrollmentInputSchema;
 var memberCampaignWithdrawalInputSchema = campaignWithdrawalInputSchema.extend({
   member: identifier,
-  reason: z20.string().trim().min(1).max(500)
+  reason: z22.string().trim().min(1).max(500)
 });
-var campaignEnrollmentSchema = z20.object({
+var campaignEnrollmentSchema = z22.object({
   campaign: identifier,
   member: identifier,
   enrolledAt: timestamp4,
   withdrawnAt: timestamp4.nullable().default(null),
-  withdrawalReason: z20.string().nullable().default(null)
+  withdrawalReason: z22.string().nullable().default(null)
 });
 
 // src/resource-handle.ts
-import { z as z21 } from "zod";
+import { z as z23 } from "zod";
 function resourceHandle(_kind, definition) {
   return definition;
 }
-var ledgerSettingSchema = identifier.or(z21.literal("")).brand();
+var ledgerSettingSchema = identifier.or(z23.literal("")).brand();
 function ledgerKey(ledger) {
   return typeof ledger === "string" ? ledger : ledger.key;
 }
 
 // src/groups.ts
-import { z as z22 } from "zod";
-var projectGroupSchema = z22.object({
+import { z as z24 } from "zod";
+var projectGroupSchema = z24.object({
   key: identifier,
-  title: z22.string().trim().min(1).max(120)
+  title: z24.string().trim().min(1).max(120)
 }).strict();
 var projectGroupAuthoringSchema = projectGroupSchema.omit({ key: true, title: true }).extend({
   ...authoringIdentityShape,
-  title: z22.string().trim().min(1).max(120).optional()
+  title: z24.string().trim().min(1).max(120).optional()
 }).strict().transform((value) => {
   return projectGroupSchema.parse({
     ...value,
@@ -2268,92 +2576,92 @@ function defineGroup(input) {
 function projectGroupKey(group) {
   return identifier.parse(group.key);
 }
-var groupTitle = z22.string().trim().min(1).max(120);
-var reason = z22.string().trim().min(1).max(1e3);
-var timestamp5 = z22.number().int().nonnegative().max(864e13);
-var createGroupSchema = z22.object({ actionId: identifier, key: identifier, title: groupTitle }).strict();
-var updateGroupSchema = z22.object({ title: groupTitle }).strict();
-var addGroupMemberSchema = z22.object({ actionId: identifier, member: identifier, reason }).strict();
-var removeGroupMemberSchema = z22.object({ actionId: identifier, reason }).strict();
-var groupPageQuerySchema = z22.strictObject({
+var groupTitle = z24.string().trim().min(1).max(120);
+var reason = z24.string().trim().min(1).max(1e3);
+var timestamp5 = z24.number().int().nonnegative().max(864e13);
+var createGroupSchema = z24.object({ actionId: identifier, key: identifier, title: groupTitle }).strict();
+var updateGroupSchema = z24.object({ title: groupTitle }).strict();
+var addGroupMemberSchema = z24.object({ actionId: identifier, member: identifier, reason }).strict();
+var removeGroupMemberSchema = z24.object({ actionId: identifier, reason }).strict();
+var groupPageQuerySchema = z24.strictObject({
   cursor: pageCursorSchema.optional(),
   /** Items per page, 1–100; the default is 50. */
-  limit: z22.number().int().min(1).max(100).optional()
+  limit: z24.number().int().min(1).max(100).optional()
 });
-var managedGroupSchema = z22.object({
+var managedGroupSchema = z24.object({
   key: identifier,
-  title: z22.string(),
-  members: z22.number().int().nonnegative(),
+  title: z24.string(),
+  members: z24.number().int().nonnegative(),
   createdAt: timestamp5,
   archivedAt: timestamp5.nullable()
 });
-var groupPageSchema = z22.object({
-  items: z22.array(managedGroupSchema),
+var groupPageSchema = z24.object({
+  items: z24.array(managedGroupSchema),
   nextCursor: pageCursorSchema.nullable()
 });
-var groupMemberSchema = z22.object({
+var groupMemberSchema = z24.object({
   member: identifier,
   addedAt: timestamp5.nullable()
 });
-var groupMemberPageSchema = z22.object({
-  items: z22.array(groupMemberSchema),
+var groupMemberPageSchema = z24.object({
+  items: z24.array(groupMemberSchema),
   nextCursor: pageCursorSchema.nullable()
 });
 
 // src/prerequisites.ts
-import { z as z23 } from "zod";
-var amount = z23.number().int().safe().nonnegative();
+import { z as z25 } from "zod";
+var amount = z25.number().int().safe().nonnegative();
 var threshold = amount.positive();
-var completionPrerequisiteSchema = z23.discriminatedUnion("scope", [
-  z23.object({
-    kind: z23.literal("completion"),
+var completionPrerequisiteSchema = z25.discriminatedUnion("scope", [
+  z25.object({
+    kind: z25.literal("completion"),
     quest: identifier,
-    scope: z23.literal("ever")
+    scope: z25.literal("ever")
   }).strict(),
-  z23.object({
-    kind: z23.literal("completion"),
+  z25.object({
+    kind: z25.literal("completion"),
     quest: identifier,
-    scope: z23.literal("period"),
+    scope: z25.literal("period"),
     period: calendarPeriodSchema.exclude(["lifetime"])
   }).strict()
 ]);
-var balancePrerequisiteSchema = z23.object({
-  kind: z23.literal("balance"),
+var balancePrerequisiteSchema = z25.object({
+  kind: z25.literal("balance"),
   balance: identifier,
   minimum: threshold
 }).strict();
-var groupPrerequisiteSchema = z23.object({ kind: z23.literal("group"), group: identifier, title: z23.string() }).strict();
-var prerequisiteSchema = z23.discriminatedUnion("kind", [
+var groupPrerequisiteSchema = z25.object({ kind: z25.literal("group"), group: identifier, title: z25.string() }).strict();
+var prerequisiteSchema = z25.discriminatedUnion("kind", [
   completionPrerequisiteSchema,
   balancePrerequisiteSchema,
   groupPrerequisiteSchema
 ]);
-var missingPrerequisiteSchema = z23.union([
-  z23.object({
-    kind: z23.literal("completion"),
+var missingPrerequisiteSchema = z25.union([
+  z25.object({
+    kind: z25.literal("completion"),
     quest: identifier,
-    title: z23.string(),
-    scope: z23.literal("ever")
+    title: z25.string(),
+    scope: z25.literal("ever")
   }),
-  z23.object({
-    kind: z23.literal("completion"),
+  z25.object({
+    kind: z25.literal("completion"),
     quest: identifier,
-    title: z23.string(),
-    scope: z23.literal("period"),
+    title: z25.string(),
+    scope: z25.literal("period"),
     period: calendarPeriodSchema.exclude(["lifetime"]),
-    resetsAt: z23.number().int().safe()
+    resetsAt: z25.number().int().safe()
   }),
-  z23.object({
-    kind: z23.literal("balance"),
+  z25.object({
+    kind: z25.literal("balance"),
     balance: identifier,
-    title: z23.string(),
+    title: z25.string(),
     minimum: threshold,
     current: amount
   }),
-  z23.object({
-    kind: z23.literal("group"),
+  z25.object({
+    kind: z25.literal("group"),
     group: identifier,
-    title: z23.string()
+    title: z25.string()
   })
 ]);
 function completed(quest, options = {}) {
@@ -2381,84 +2689,116 @@ function inGroup(group) {
 }
 
 // src/schema.ts
-import { z as z24 } from "zod";
-var pointsRewardSchema = z24.object({
-  kind: z24.literal("points").default("points"),
+import { z as z26 } from "zod";
+var pointsRewardSchema = z26.object({
+  kind: z26.literal("points").default("points"),
   balance: identifier,
-  amount: z24.number().int().min(0).max(1e4)
+  amount: z26.number().int().min(0).max(1e4)
 }).strict();
-var tieredRewardDefinitionSchema = z24.object({
+var tieredRewardDefinitionSchema = z26.object({
+  /** An automatic achievement backed by the project badge catalog. */
+  badge: identifier.optional(),
   id: identifier,
-  title: z24.string().min(1).max(120),
-  tiers: z24.array(
-    z24.object({ id: identifier, title: z24.string().min(1).max(120) }).strict()
+  title: z26.string().min(1).max(120),
+  tiers: z26.array(
+    z26.object({ id: identifier, title: z26.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: z24.object({ kind: z24.literal("untracked") }).strict(),
-  fulfillment: z24.discriminatedUnion("kind", [
-    z24.object({ kind: z24.literal("staff-handover") }).strict(),
-    z24.object({ kind: z24.literal("automatic") }).strict()
+  inventory: z26.object({ kind: z26.literal("untracked") }).strict(),
+  fulfillment: z26.discriminatedUnion("kind", [
+    z26.object({ kind: z26.literal("staff-handover") }).strict(),
+    z26.object({ kind: z26.literal("automatic") }).strict()
   ])
-}).strict();
-var tieredRewardReferenceSchema = z24.object({
+}).strict().refine(
+  (value) => value.badge === void 0 || value.fulfillment.kind === "automatic" && value.tiers.length === 1 && value.tiers[0].id === "awarded",
+  "Badge rewards require the fixed automatic achievement envelope"
+);
+var tieredRewardReferenceSchema = z26.object({
   id: identifier,
   key: identifier.nullable()
 });
-var tierRewardSchema = z24.object({
-  kind: z24.literal("tier"),
+var tierRewardSchema = z26.object({
+  kind: z26.literal("tier"),
   reward: tieredRewardDefinitionSchema,
   tier: identifier
 }).strict().refine(
   (value) => value.reward.tiers.some((t) => t.id === value.tier),
   "Unknown reward tier"
 );
+var badgeRewardSchema = tierRewardSchema.transform(
+  (value, context) => {
+    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 z26.NEVER;
+    }
+    return { ...value, reward: { ...value.reward, badge } };
+  }
+);
+function badgeReward(reference, title) {
+  return badgeRewardSchema.parse({
+    kind: "tier",
+    tier: "awarded",
+    reward: {
+      id: reference,
+      badge: reference,
+      title,
+      tiers: [{ id: "awarded", title: "Awarded" }],
+      inventory: { kind: "untracked" },
+      fulfillment: { kind: "automatic" }
+    }
+  });
+}
 var integrationRewardSchema = discordRewardSchema;
-var rewardSchema = z24.union([
+var rewardSchema = z26.union([
   pointsRewardSchema,
   tierRewardSchema,
   integrationRewardSchema
 ]);
 function rewardKey(reward) {
+  if (reward.kind === "tier" && reward.reward.badge) {
+    return "badge:" + reward.reward.badge;
+  }
   if (reward.kind === "integration") {
     return `integration:${reward.provider}:${reward.action}:${reward.roleId}`;
   }
   return reward.kind === "points" ? "points:" + reward.balance : "tier:" + reward.reward.id;
 }
-var triggerSchema = z24.union([
-  z24.object({
-    kind: z24.literal("manual"),
-    input: z24.literal("text"),
+var triggerSchema = z26.union([
+  z26.object({
+    kind: z26.literal("manual"),
+    input: z26.literal("text"),
     constraints: textOptionsSchema,
-    actor: z24.enum(["member", "staff"]).optional()
+    actor: z26.enum(["member", "staff"]).optional()
   }).strict(),
-  z24.object({
-    kind: z24.literal("manual"),
-    input: z24.literal("url"),
+  z26.object({
+    kind: z26.literal("manual"),
+    input: z26.literal("url"),
     constraints: urlOptionsSchema,
-    actor: z24.enum(["member", "staff"]).optional()
+    actor: z26.enum(["member", "staff"]).optional()
   }).strict(),
-  z24.object({
-    kind: z24.literal("manual"),
-    input: z24.enum(["photo", "quiz", "none"]),
-    actor: z24.enum(["member", "staff"]).optional()
+  z26.object({
+    kind: z26.literal("manual"),
+    input: z26.enum(["photo", "quiz", "none"]),
+    actor: z26.enum(["member", "staff"]).optional()
   }).strict(),
-  z24.object({
-    kind: z24.literal("automatic"),
+  z26.object({
+    kind: z26.literal("automatic"),
     tracker: trackerTriggerPolicySchema.optional()
   }).strict()
 ]);
-var triggerResponseSchema = z24.union(
+var triggerResponseSchema = z26.union(
   triggerSchema.options.map((option) => option.strip())
 );
-var photoResultSchema = z24.object({
-  kind: z24.enum(["pass", "fail", "unclear"]),
-  reason: z24.string().min(1).max(2e3)
+var photoResultSchema = z26.object({
+  kind: z26.enum(["pass", "fail", "unclear"]),
+  reason: z26.string().min(1).max(2e3)
 }).strict();
-var textReviewInputSchema = z24.object({
-  text: z24.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
-  criteria: z24.string().trim().min(1).max(2e3)
+var textReviewInputSchema = z26.object({
+  text: z26.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
+  criteria: z26.string().trim().min(1).max(2e3)
 }).strict();
 var textResultSchema = photoResultSchema;
 var deferPolicy = {
@@ -2468,53 +2808,53 @@ var deferPolicy = {
   horizonMs: 864e5,
   maxDefers: 100
 };
-var evaluatorProgressSchema = z24.object({
-  current: z24.number().finite().nonnegative(),
-  target: z24.number().finite().positive(),
-  reason: z24.string().min(1).max(2e3)
+var evaluatorProgressSchema = z26.object({
+  current: z26.number().finite().nonnegative(),
+  target: z26.number().finite().positive(),
+  reason: z26.string().min(1).max(2e3)
 }).refine((value) => value.current <= value.target, {
   message: "Progress current must not exceed target"
 });
-var decisionSchema = z24.discriminatedUnion("kind", [
-  z24.strictObject({
-    kind: z24.literal("defer"),
-    reason: z24.string().min(1).max(2e3),
-    retryAfterMs: z24.number().int().min(deferPolicy.minRetryAfterMs).max(deferPolicy.maxRetryAfterMs).optional(),
+var decisionSchema = z26.discriminatedUnion("kind", [
+  z26.strictObject({
+    kind: z26.literal("defer"),
+    reason: z26.string().min(1).max(2e3),
+    retryAfterMs: z26.number().int().min(deferPolicy.minRetryAfterMs).max(deferPolicy.maxRetryAfterMs).optional(),
     /** Absolute Unix milliseconds; the platform can only shorten its existing deadline. */
-    until: z24.number().int().safe().nonnegative().optional()
+    until: z26.number().int().safe().nonnegative().optional()
   }),
-  evaluatorProgressSchema.safeExtend({ kind: z24.literal("progress") }).strict(),
-  z24.object({
-    kind: z24.literal("accept"),
-    rewards: z24.array(rewardSchema).max(10),
+  evaluatorProgressSchema.safeExtend({ kind: z26.literal("progress") }).strict(),
+  z26.object({
+    kind: z26.literal("accept"),
+    rewards: z26.array(rewardSchema).max(10),
     completionKey: completionKeySchema.optional()
   }).strict(),
-  z24.object({
-    kind: z24.literal("reject"),
-    reason: z24.string().min(1).max(2e3),
+  z26.object({
+    kind: z26.literal("reject"),
+    reason: z26.string().min(1).max(2e3),
     /** The evaluator asked for human review, but review is off for the quest, so this is a reject. */
-    requestedReview: z24.literal(true).optional()
+    requestedReview: z26.literal(true).optional()
   }).strict(),
-  z24.object({
-    kind: z24.literal("review"),
-    reason: z24.string().min(1).max(2e3),
-    rewards: z24.array(rewardSchema).max(10).optional(),
+  z26.object({
+    kind: z26.literal("review"),
+    reason: z26.string().min(1).max(2e3),
+    rewards: z26.array(rewardSchema).max(10).optional(),
     completionKey: completionKeySchema.optional()
   }).strict()
 ]);
-var reviewModeSchema = z24.enum(["workers-ai"]);
-var storedReviewModeSchema = z24.enum([
+var reviewModeSchema = z26.enum(["workers-ai"]);
+var storedReviewModeSchema = z26.enum([
   "fixture-pass",
   "fixture-fail",
   "fixture-unclear",
   "fixture-error",
   "workers-ai"
 ]);
-var rewardBundleSchema = z24.array(rewardSchema).max(10).refine(
+var rewardBundleSchema = z26.array(rewardSchema).max(10).refine(
   (rewards) => new Set(rewards.map(rewardKey)).size === rewards.length,
   "Use one entry per balance or shared reward"
 );
-var mediaUrlSchema = z24.string().max(2e3).refine((value) => {
+var mediaUrlSchema = z26.string().max(2e3).refine((value) => {
   if (/^\/(?!\/)[^\\\s]*$/.test(value)) {
     return true;
   }
@@ -2524,56 +2864,83 @@ var mediaUrlSchema = z24.string().max(2e3).refine((value) => {
     return false;
   }
 }, "Use an HTTPS URL or a same-site path beginning with /");
-var questPresentationSchema = z24.object({
+var questStepActionSchema = z26.discriminatedUnion("kind", [
+  z26.object({
+    kind: z26.literal("link"),
+    url: mediaUrlSchema.refine(
+      (value) => value.startsWith("https://"),
+      "Use an HTTPS URL"
+    ),
+    label: z26.string().trim().min(1).max(120)
+  }).strict()
+]);
+var questStepSchema = z26.object({
+  title: z26.string().trim().min(1).max(120),
+  description: z26.string().max(4e3).optional(),
+  action: questStepActionSchema.optional()
+}).strict();
+var questPresentationRequirementSchema = z26.discriminatedUnion("kind", [
+  z26.object({ kind: z26.literal("account"), provider: authProviderSchema }).strict(),
+  z26.object({ kind: z26.literal("wallet"), chain: walletChainSchema.optional() }).strict()
+]);
+var questPresentationContentSchema = z26.object({
+  steps: z26.array(questStepSchema).max(30).optional(),
+  image: mediaUrlSchema.optional(),
+  imageAlt: z26.string().max(500).optional(),
+  requirements: z26.array(questPresentationRequirementSchema).max(10).optional()
+}).strict();
+var questPresentationSchema = questPresentationContentSchema.extend({
   quiz: quizQuestionsSchema.optional(),
-  instructions: z24.string().max(4e3).optional(),
-  video: z24.object({
+  instructions: z26.string().max(4e3).optional(),
+  video: z26.object({
     url: mediaUrlSchema,
     poster: mediaUrlSchema.optional(),
-    captions: z24.object({
+    captions: z26.object({
       url: mediaUrlSchema,
-      language: z24.string().min(2).max(20),
-      label: z24.string().min(1).max(80)
+      language: z26.string().min(2).max(20),
+      label: z26.string().min(1).max(80)
     }).strict().optional()
   }).strict().optional()
 }).strict();
-var questProfileSchema = z24.object({ visible: z24.boolean() }).strict();
+var questProfileSchema = z26.object({ visible: z26.boolean() }).strict();
 var evaluatorProtocol = 2;
-var evaluatorProtocolSchema = z24.literal(evaluatorProtocol);
-var questDescriptionSchema = z24.object({
+var evaluatorProtocolSchema = z26.literal(evaluatorProtocol);
+var questDescriptionSchema = z26.object({
   quest: identifier,
   evaluatorProtocol: evaluatorProtocolSchema,
-  title: z24.string().min(1).max(120),
+  title: z26.string().min(1).max(120),
   presentation: questPresentationSchema.default({}),
-  integrations: z24.array(evaluatorIntegrationProviderSchema).max(10).default([]),
+  integrations: z26.array(evaluatorIntegrationProviderSchema).max(10).default([]),
   fields: settingsFieldsSchema,
   values: settingsValuesSchema,
   rewards: rewardBundleSchema,
-  humanReview: z24.boolean(),
+  humanReview: z26.boolean(),
   trigger: triggerSchema,
   performance: contentPerformancePolicySchema.optional(),
-  requires: z24.array(prerequisiteSchema).max(30).default([]),
+  requires: z26.array(prerequisiteSchema).max(30).default([]),
   campaign: campaignDefinitionSchema.optional(),
   availability: availabilityWindowSchema.optional(),
-  completion: z24.preprocess(refuseStreakTimeZone, completionPolicySchema),
-  visibility: z24.enum(["visible", "hidden"]).default("visible"),
+  completion: z26.preprocess(refuseStreakTimeZone, completionPolicySchema),
+  visibility: z26.enum(["visible", "hidden"]).default("visible"),
   /** Whether completions show on participant profiles (`/v1/profiles/:id/completions`). */
   profile: questProfileSchema.default({ visible: false }),
-  budgets: z24.array(budgetSchema).max(20).default([])
+  budgets: z26.array(budgetSchema).max(20).default([])
 }).strict();
-var artifactSchema = z24.object({ code: z24.string().min(1).max(1e6) }).strict();
+var artifactSchema = z26.object({ code: z26.string().min(1).max(1e6) }).strict();
 var releaseSchema = artifactSchema.extend({
   settings: settingsValuesSchema,
   provider: reviewModeSchema,
   expectedRelease: identifier.nullable().optional(),
-  settingRenames: z24.record(z24.string(), z24.string()).optional()
+  settingRenames: z26.record(z26.string(), z26.string()).optional()
 }).strict();
-var batchReleaseSchema = z24.object({ releases: z24.array(releaseSchema).min(1).max(50) }).strict();
-var questSettingsInputSchema = z24.object({
+var batchReleaseSchema = z26.object({ releases: z26.array(releaseSchema).min(1).max(50) }).strict();
+var questSettingsInputSchema = z26.object({
   quest: identifier,
   expectedRelease: identifier,
   set: settingsValuesSchema,
-  reset: z24.array(z24.string())
+  reset: z26.array(z26.string()),
+  /** Replace the editable presentation fields; null restores the code defaults. */
+  presentation: questPresentationContentSchema.nullable().optional()
 }).strict();
 var storedQuestDescriptionSchema = questDescriptionSchema.extend({
   completion: completionPolicySchema
@@ -2581,24 +2948,26 @@ var storedQuestDescriptionSchema = questDescriptionSchema.extend({
 var publishedReleaseSchema = responseShape(
   storedQuestDescriptionSchema.extend({
     key: identifier.optional(),
-    code: z24.string(),
+    code: z26.string(),
     provider: storedReviewModeSchema,
     id: identifier,
-    createdAt: z24.number(),
-    origin: z24.object({ typeVersion: identifier }).strict().optional(),
-    lifecycle: z24.enum(["active", "paused", "archived"]).default("active"),
-    configuration: z24.object({
+    createdAt: z26.number(),
+    origin: z26.object({ typeVersion: identifier }).strict().optional(),
+    lifecycle: z26.enum(["active", "paused", "archived"]).default("active"),
+    configuration: z26.object({
       defaults: settingsValuesSchema,
       overrides: settingsValuesSchema,
-      preserved: z24.array(z24.string())
+      preserved: z26.array(z26.string()),
+      presentation: questPresentationContentSchema.optional(),
+      presentationDefaults: questPresentationContentSchema.optional()
     }).strict().optional()
   })
 );
-var templateSchema = z24.object({
-  code: z24.string(),
+var templateSchema = z26.object({
+  code: z26.string(),
   definition: questDescriptionSchema
 });
-var quizAnswersSchema = z24.record(identifier, identifier).refine(
+var quizAnswersSchema = z26.record(identifier, identifier).refine(
   (answers) => Object.keys(answers).length > 0 && Object.keys(answers).length <= 50,
   "Provide between 1 and 50 answers"
 ).transform(
@@ -2606,17 +2975,17 @@ var quizAnswersSchema = z24.record(identifier, identifier).refine(
     Object.entries(answers).sort(([a], [b]) => a.localeCompare(b))
   )
 );
-var quizEvidenceSchema = z24.object({
-  kind: z24.literal("quiz"),
+var quizEvidenceSchema = z26.object({
+  kind: z26.literal("quiz"),
   release: identifier.optional(),
   answers: quizAnswersSchema
 }).strict();
-var submissionEvidenceSchema = z24.union([
+var submissionEvidenceSchema = z26.union([
   quizEvidenceSchema,
   textEvidenceSchema,
   urlEvidenceSchema
 ]);
-var submitSchema = z24.object({
+var submitSchema = z26.object({
   actionId: identifier,
   quest: identifier,
   member: identifier,
@@ -2624,7 +2993,7 @@ var submitSchema = z24.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: z24.boolean().optional()
+  faultAfterReview: z26.boolean().optional()
 }).strict();
 var AttemptStatus = {
   Queued: "queued",
@@ -2636,8 +3005,8 @@ var AttemptStatus = {
   NeedsReview: "needs-review",
   Failed: "failed"
 };
-var attemptStatusSchema = z24.string();
-var attemptSchema = z24.object({
+var attemptStatusSchema = z26.string();
+var attemptSchema = z26.object({
   id: identifier,
   release: identifier,
   quest: identifier,
@@ -2645,83 +3014,83 @@ var attemptSchema = z24.object({
   evidence: identifier.nullable(),
   input: submissionEvidenceSchema.optional(),
   status: attemptStatusSchema,
-  reason: z24.string().nullable(),
-  retries: z24.number(),
-  generation: z24.number(),
-  completion: z24.string().nullable(),
+  reason: z26.string().nullable(),
+  retries: z26.number(),
+  generation: z26.number(),
+  completion: z26.string().nullable(),
   reviewRewards: rewardBundleSchema.nullable().default(null),
   /** Scheduled reruns advance this number; failure retries preserve it. */
-  evaluationRun: z24.number().int().nonnegative().default(0),
-  deferCount: z24.number().int().nonnegative().default(0),
-  deferUntil: z24.number().int().safe().nullable().default(null),
-  nextEvaluationAt: z24.number().int().safe().nullable().default(null),
+  evaluationRun: z26.number().int().nonnegative().default(0),
+  deferCount: z26.number().int().nonnegative().default(0),
+  deferUntil: z26.number().int().safe().nullable().default(null),
+  nextEvaluationAt: z26.number().int().safe().nullable().default(null),
   /** Open code: consumers must tolerate new values. */
-  code: z24.string().nullable().default(null),
+  code: z26.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: z24.boolean().default(false),
-  createdAt: z24.number()
-});
-var eventSchema = z24.object({
-  id: z24.number(),
-  attempt: z24.string().nullable(),
-  kind: z24.string(),
-  detail: z24.string(),
-  actor: z24.string().nullable().default(null),
-  at: z24.number()
-});
-var pickupSelectionSchema = z24.object({
+  requestedReview: z26.boolean().default(false),
+  createdAt: z26.number()
+});
+var eventSchema = z26.object({
+  id: z26.number(),
+  attempt: z26.string().nullable(),
+  kind: z26.string(),
+  detail: z26.string(),
+  actor: z26.string().nullable().default(null),
+  at: z26.number()
+});
+var pickupSelectionSchema = z26.object({
   item: identifier,
-  revision: z24.number().int().nonnegative()
+  revision: z26.number().int().nonnegative()
 }).strict();
-var pickupAllocationSchema = z24.object({
+var pickupAllocationSchema = z26.object({
   item: identifier,
-  label: z24.string().min(1).max(80)
+  label: z26.string().min(1).max(80)
 }).strict();
-var pickupPolicySchema = z24.discriminatedUnion("kind", [
-  z24.object({ kind: z24.literal("untracked") }).strict(),
-  z24.object({
-    kind: z24.literal("at-pickup"),
-    tiers: z24.array(
-      z24.object({
+var pickupPolicySchema = z26.discriminatedUnion("kind", [
+  z26.object({ kind: z26.literal("untracked") }).strict(),
+  z26.object({
+    kind: z26.literal("at-pickup"),
+    tiers: z26.array(
+      z26.object({
         tier: identifier,
-        variants: z24.array(pickupAllocationSchema).min(1).max(100)
+        variants: z26.array(pickupAllocationSchema).min(1).max(100)
       }).strict()
     ).min(1).max(100)
   }).strict()
 ]);
-var pickupCatalogSchema = z24.object({
+var pickupCatalogSchema = z26.object({
   reward: tieredRewardDefinitionSchema,
-  revision: z24.number().int().nonnegative(),
+  revision: z26.number().int().nonnegative(),
   policy: pickupPolicySchema
 });
-var pickupAvailabilitySchema = z24.discriminatedUnion("kind", [
-  z24.object({ kind: z24.literal("untracked") }).strict(),
-  z24.object({
-    kind: z24.literal("at-pickup"),
-    revision: z24.number().int().nonnegative(),
-    variants: z24.array(
+var pickupAvailabilitySchema = z26.discriminatedUnion("kind", [
+  z26.object({ kind: z26.literal("untracked") }).strict(),
+  z26.object({
+    kind: z26.literal("at-pickup"),
+    revision: z26.number().int().nonnegative(),
+    variants: z26.array(
       pickupAllocationSchema.extend({
-        available: z24.number().int().nonnegative()
+        available: z26.number().int().nonnegative()
       })
     )
   }).strict()
 ]);
-var configurePickupSchema = z24.object({
+var configurePickupSchema = z26.object({
   reward: identifier,
-  revision: z24.number().int().nonnegative(),
+  revision: z26.number().int().nonnegative(),
   actionId: identifier,
-  policy: z24.discriminatedUnion("kind", [
-    z24.object({ kind: z24.literal("untracked") }).strict(),
-    z24.object({
-      kind: z24.literal("at-pickup"),
-      tiers: z24.array(
-        z24.object({
+  policy: z26.discriminatedUnion("kind", [
+    z26.object({ kind: z26.literal("untracked") }).strict(),
+    z26.object({
+      kind: z26.literal("at-pickup"),
+      tiers: z26.array(
+        z26.object({
           tier: identifier,
-          variants: z24.array(
+          variants: z26.array(
             pickupAllocationSchema.extend({
               item: identifier.optional()
             })
@@ -2731,10 +3100,10 @@ var configurePickupSchema = z24.object({
     }).strict()
   ])
 }).strict();
-var entitlementRecoverySchema = z24.object({
+var entitlementRecoverySchema = z26.object({
   completion: identifier,
-  reason: z24.string(),
-  flaggedAt: z24.number(),
+  reason: z26.string(),
+  flaggedAt: z26.number(),
   /** Null means no accepted completion currently earns this reward. */
   remainingTier: identifier.nullable()
 });
@@ -2744,40 +3113,40 @@ var entitlementBase = {
   reward: tieredRewardDefinitionSchema,
   earnedTier: identifier,
   tier: identifier,
-  revision: z24.number().int().positive()
+  revision: z26.number().int().positive()
 };
-var entitlementStateSchema = z24.discriminatedUnion("status", [
-  z24.object({ ...entitlementBase, status: z24.literal("available") }).strict(),
-  z24.object({
+var entitlementStateSchema = z26.discriminatedUnion("status", [
+  z26.object({ ...entitlementBase, status: z26.literal("available") }).strict(),
+  z26.object({
     ...entitlementBase,
-    status: z24.literal("handing-over"),
+    status: z26.literal("handing-over"),
     handover: identifier,
-    startedAt: z24.number(),
+    startedAt: z26.number(),
     allocation: pickupAllocationSchema.optional()
   }).strict(),
-  z24.object({
+  z26.object({
     ...entitlementBase,
-    status: z24.literal("collected"),
+    status: z26.literal("collected"),
     handover: identifier,
-    startedAt: z24.number(),
+    startedAt: z26.number(),
     allocation: pickupAllocationSchema.optional(),
-    collectedAt: z24.number(),
+    collectedAt: z26.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.
-  z24.object({
+  z26.object({
     ...entitlementBase,
-    status: z24.literal("void"),
-    voidedAt: z24.number()
+    status: z26.literal("void"),
+    voidedAt: z26.number()
   }).strict()
 ]);
-var tieredRewardReadSchema = z24.object({
+var tieredRewardReadSchema = z26.object({
   id: identifier,
-  title: z24.string(),
-  tiers: z24.array(z24.object({ id: identifier, title: z24.string() }).loose()),
-  inventory: z24.object({ kind: z24.string() }).loose(),
-  fulfillment: z24.object({ kind: z24.string() }).loose()
+  title: z26.string(),
+  tiers: z26.array(z26.object({ id: identifier, title: z26.string() }).loose()),
+  inventory: z26.object({ kind: z26.string() }).loose(),
+  fulfillment: z26.object({ kind: z26.string() }).loose()
 }).loose();
 var entitlementReadBase = {
   id: identifier,
@@ -2785,63 +3154,63 @@ var entitlementReadBase = {
   reward: tieredRewardReadSchema,
   earnedTier: identifier,
   tier: identifier,
-  revision: z24.number().int()
+  revision: z26.number().int()
 };
-var allocationReadSchema = z24.object({ item: identifier, label: z24.string() }).loose();
-var entitlementSchema = z24.union([
-  z24.discriminatedUnion("status", [
-    z24.object({ ...entitlementReadBase, status: z24.literal("available") }).loose(),
-    z24.object({
+var allocationReadSchema = z26.object({ item: identifier, label: z26.string() }).loose();
+var entitlementSchema = z26.union([
+  z26.discriminatedUnion("status", [
+    z26.object({ ...entitlementReadBase, status: z26.literal("available") }).loose(),
+    z26.object({
       ...entitlementReadBase,
-      status: z24.literal("handing-over"),
+      status: z26.literal("handing-over"),
       handover: identifier,
-      startedAt: z24.number(),
+      startedAt: z26.number(),
       allocation: allocationReadSchema.optional()
     }).loose(),
-    z24.object({
+    z26.object({
       ...entitlementReadBase,
-      status: z24.literal("collected"),
+      status: z26.literal("collected"),
       handover: identifier,
-      startedAt: z24.number(),
+      startedAt: z26.number(),
       allocation: allocationReadSchema.optional(),
-      collectedAt: z24.number(),
+      collectedAt: z26.number(),
       recovery: entitlementRecoverySchema.optional()
     }).loose(),
-    z24.object({
+    z26.object({
       ...entitlementReadBase,
-      status: z24.literal("void"),
-      voidedAt: z24.number()
+      status: z26.literal("void"),
+      voidedAt: z26.number()
     }).loose()
   ]),
-  z24.object({ ...entitlementReadBase, status: z24.string() }).loose().transform(({ status, ...entitlement }) => ({
+  z26.object({ ...entitlementReadBase, status: z26.string() }).loose().transform(({ status, ...entitlement }) => ({
     ...entitlement,
     status: "unsupported",
     reportedStatus: status
   }))
 ]);
-var beginHandoverSchema = z24.object({
+var beginHandoverSchema = z26.object({
   actionId: identifier,
-  revision: z24.number().int().positive(),
+  revision: z26.number().int().positive(),
   selection: pickupSelectionSchema.optional()
 }).strict();
-var confirmHandoverSchema = z24.object({ actionId: identifier, handover: identifier }).strict();
-var entitlementCorrectionSchema = z24.object({
+var confirmHandoverSchema = z26.object({ actionId: identifier, handover: identifier }).strict();
+var entitlementCorrectionSchema = z26.object({
   actionId: identifier,
-  revision: z24.number().int().positive(),
-  reason: z24.string().trim().min(1).max(500)
+  revision: z26.number().int().positive(),
+  reason: z26.string().trim().min(1).max(500)
 }).strict();
 var CompletionSourceKind = {
   Quest: "quest",
   Leaderboard: "leaderboard"
 };
-var completionSourceKindSchema = z24.string().min(1).max(64);
-var completionSourceSchema = z24.object({
+var completionSourceKindSchema = z26.string().min(1).max(64);
+var completionSourceSchema = z26.object({
   kind: completionSourceKindSchema,
   id: identifier
 });
-var completionRecordSchema = z24.object({
+var completionRecordSchema = z26.object({
   /** The occurrence the completion consumed. For a leaderboard prize, the settlement ID. */
-  key: z24.string().default("once"),
+  key: z26.string().default("once"),
   id: identifier,
   /** The quest ID, or the board ID when `source.kind` is `leaderboard`. */
   quest: identifier,
@@ -2849,19 +3218,19 @@ var completionRecordSchema = z24.object({
   /** What paid the completion. `source.id` repeats `quest`. */
   source: completionSourceSchema.optional()
 });
-var questAvailabilitySchema = z24.discriminatedUnion("kind", [
-  z24.object({
-    kind: z24.literal("available"),
-    input: z24.enum(["photo", "quiz", "none", "text", "url"])
+var questAvailabilitySchema = z26.discriminatedUnion("kind", [
+  z26.object({
+    kind: z26.literal("available"),
+    input: z26.enum(["photo", "quiz", "none", "text", "url"])
   }).strict(),
-  z24.object({ kind: z24.literal("completed") }).strict(),
-  z24.object({
-    kind: z24.literal("locked"),
-    missing: z24.array(missingPrerequisiteSchema).min(1)
+  z26.object({ kind: z26.literal("completed") }).strict(),
+  z26.object({
+    kind: z26.literal("locked"),
+    missing: z26.array(missingPrerequisiteSchema).min(1)
   }).strict(),
-  z24.object({
-    kind: z24.literal("blocked"),
-    reason: z24.enum([
+  z26.object({
+    kind: z26.literal("blocked"),
+    reason: z26.enum([
       "budget-exhausted",
       "connection-required",
       "wallet-required",
@@ -2870,144 +3239,144 @@ var questAvailabilitySchema = z24.discriminatedUnion("kind", [
       "enrollment-required"
     ]),
     /** Which window refused admission when `reason` is `outside-window`. */
-    window: z24.enum(["tracker", "quest"]).optional(),
-    resetsAt: z24.number().int().safe().optional()
+    window: z26.enum(["tracker", "quest"]).optional(),
+    resetsAt: z26.number().int().safe().optional()
   }).strict(),
-  z24.object({ kind: z24.literal("staff-required") }).strict(),
-  z24.object({ kind: z24.literal("automatic") }).strict(),
-  z24.object({ kind: z24.literal("checking"), attempt: identifier }).strict(),
-  z24.object({ kind: z24.literal("needs-review"), attempt: identifier }).strict(),
-  z24.object({ kind: z24.literal("retryable"), attempt: identifier }).strict()
+  z26.object({ kind: z26.literal("staff-required") }).strict(),
+  z26.object({ kind: z26.literal("automatic") }).strict(),
+  z26.object({ kind: z26.literal("checking"), attempt: identifier }).strict(),
+  z26.object({ kind: z26.literal("needs-review"), attempt: identifier }).strict(),
+  z26.object({ kind: z26.literal("retryable"), attempt: identifier }).strict()
 ]);
-var questAvailabilityResponseSchema = z24.union(
+var questAvailabilityResponseSchema = z26.union(
   questAvailabilitySchema.options.map((option) => option.strip())
 );
-var questBudgetViewSchema = z24.object({
+var questBudgetViewSchema = z26.object({
   id: identifier,
-  scope: z24.enum(["member", "project"]),
-  period: z24.enum(["day", "week", "month", "lifetime"]),
-  remaining: z24.number().int().safe().nonnegative(),
-  resetsAt: z24.number().int().safe().nullable()
+  scope: z26.enum(["member", "project"]),
+  period: z26.enum(["day", "week", "month", "lifetime"]),
+  remaining: z26.number().int().safe().nonnegative(),
+  resetsAt: z26.number().int().safe().nullable()
 });
 var memberProgressSchema = responseShape(
-  z24.object({
+  z26.object({
     member: identifier,
-    quests: z24.array(
-      z24.object({
+    quests: z26.array(
+      z26.object({
         quest: identifier,
         key: identifier.optional(),
         release: identifier.optional(),
-        title: z24.string(),
+        title: z26.string(),
         presentation: questPresentationSchema.default({}),
-        connections: z24.array(authProviderSchema).default([]),
+        connections: z26.array(authProviderSchema).default([]),
         trigger: triggerResponseSchema,
         availability: questAvailabilityResponseSchema,
-        completed: z24.boolean(),
+        completed: z26.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: z24.number().int().nonnegative().default(0),
-        visibility: z24.enum(["visible", "hidden"]).default("visible"),
-        missing: z24.array(missingPrerequisiteSchema),
+        completionCount: z26.number().int().nonnegative().default(0),
+        visibility: z26.enum(["visible", "hidden"]).default("visible"),
+        missing: z26.array(missingPrerequisiteSchema),
         campaign: campaignViewSchema.nullable().default(null),
         window: availabilityWindowSchema.nullable().default(null),
-        budgets: z24.array(questBudgetViewSchema).default([]),
+        budgets: z26.array(questBudgetViewSchema).default([]),
         attempt: attemptSchema.nullable()
       })
     ),
-    entitlements: z24.array(entitlementSchema)
+    entitlements: z26.array(entitlementSchema)
   })
 );
 var snapshotSchema = responseShape(
-  z24.object({
-    releases: z24.array(publishedReleaseSchema),
-    completions: z24.array(completionRecordSchema),
-    entitlements: z24.array(entitlementSchema),
-    attempts: z24.array(attemptSchema),
-    balances: z24.array(
-      z24.object({
-        member: z24.string(),
-        balance: z24.string(),
-        earned: z24.number(),
-        held: z24.number(),
-        available: z24.number()
+  z26.object({
+    releases: z26.array(publishedReleaseSchema),
+    completions: z26.array(completionRecordSchema),
+    entitlements: z26.array(entitlementSchema),
+    attempts: z26.array(attemptSchema),
+    balances: z26.array(
+      z26.object({
+        member: z26.string(),
+        balance: z26.string(),
+        earned: z26.number(),
+        held: z26.number(),
+        available: z26.number()
       })
     ),
-    events: z24.array(eventSchema)
+    events: z26.array(eventSchema)
   })
 );
-var evidenceSchema = z24.object({
+var evidenceSchema = z26.object({
   id: identifier,
   member: identifier,
-  type: z24.enum(["image/jpeg", "image/png"]),
-  size: z24.number()
+  type: z26.enum(["image/jpeg", "image/png"]),
+  size: z26.number()
 });
-var errorSchema = z24.object({
-  error: z24.string(),
-  code: z24.string().optional(),
+var errorSchema = z26.object({
+  error: z26.string(),
+  code: z26.string().optional(),
   /** Which window refused admission when `code` is `outside-window`. */
-  window: z24.enum(["tracker", "quest"]).optional(),
-  missing: z24.array(missingPrerequisiteSchema).optional()
+  window: z26.enum(["tracker", "quest"]).optional(),
+  missing: z26.array(missingPrerequisiteSchema).optional()
 });
-var staffDecisionSchema = z24.object({
+var staffDecisionSchema = z26.object({
   actionId: identifier,
-  generation: z24.number().int().nonnegative(),
-  decision: z24.enum(["accept", "reject"]),
-  reason: z24.string().trim().min(1).max(2e3)
+  generation: z26.number().int().nonnegative(),
+  decision: z26.enum(["accept", "reject"]),
+  reason: z26.string().trim().min(1).max(2e3)
 }).strict();
-var stockSchema = z24.object({ item: identifier, quantity: z24.number().int().min(0).max(1e4) }).strict();
-var reservationSchema = z24.object({
+var stockSchema = z26.object({ item: identifier, quantity: z26.number().int().min(0).max(1e4) }).strict();
+var reservationSchema = z26.object({
   actionId: identifier,
   member: identifier,
   item: identifier,
   balance: identifier,
-  price: z24.number().int().positive().max(1e4)
+  price: z26.number().int().positive().max(1e4)
 }).strict();
 var pageOptions = {
-  limit: z24.number().int().min(1).max(100).default(25),
-  cursor: z24.string().min(1).max(4096).optional()
+  limit: z26.number().int().min(1).max(100).default(25),
+  cursor: z26.string().min(1).max(4096).optional()
 };
-var reviewListSchema = z24.object({
+var reviewListSchema = z26.object({
   ...pageOptions,
   member: identifier.optional(),
   quest: identifier.optional()
 }).strict();
-var memberListSchema = z24.object({
+var memberListSchema = z26.object({
   ...pageOptions,
   prefix: identifier.optional()
 }).strict();
-var reviewItemSchema = z24.object({
+var reviewItemSchema = z26.object({
   attempt: attemptSchema,
-  title: z24.string(),
-  checks: z24.array(
-    z24.object({ criteria: z24.string(), result: photoResultSchema })
+  title: z26.string(),
+  checks: z26.array(
+    z26.object({ criteria: z26.string(), result: photoResultSchema })
   )
 });
-var reviewPageSchema = z24.object({
-  items: z24.array(reviewItemSchema).max(100),
-  nextCursor: z24.string().nullable()
+var reviewPageSchema = z26.object({
+  items: z26.array(reviewItemSchema).max(100),
+  nextCursor: z26.string().nullable()
 });
-var memberPageSchema = z24.object({
-  items: z24.array(z24.object({ member: identifier })).max(100),
-  nextCursor: z24.string().nullable()
+var memberPageSchema = z26.object({
+  items: z26.array(z26.object({ member: identifier })).max(100),
+  nextCursor: z26.string().nullable()
 });
-var createStockItemSchema = z24.object({ actionId: identifier, name: z24.string().trim().min(1).max(80) }).strict();
-var stockItemSchema = z24.object({ id: identifier, name: z24.string() });
-var contentPerformanceSnapshotSchema = z24.strictObject({
+var createStockItemSchema = z26.object({ actionId: identifier, name: z26.string().trim().min(1).max(80) }).strict();
+var stockItemSchema = z26.object({ id: identifier, name: z26.string() });
+var contentPerformanceSnapshotSchema = z26.strictObject({
   contentAttempt: identifier,
   observation: identifier,
-  observedAt: z24.number().int().safe().nonnegative(),
+  observedAt: z26.number().int().safe().nonnegative(),
   metrics: contentMetricsSchema,
   rewards: rewardBundleSchema
 });
 var contentPerformanceQuerySchema = contentQualificationQuerySchema.extend({
-  content: z24.string().min(1).max(256)
+  content: z26.string().min(1).max(256)
 });
-var contentPerformancePageSchema = z24.strictObject({
-  current: z24.strictObject({
-    state: z24.enum([
+var contentPerformancePageSchema = z26.strictObject({
+  current: z26.strictObject({
+    state: z26.enum([
       "content-pending",
       "content-unqualified",
       "waiting",
@@ -3018,19 +3387,19 @@ var contentPerformancePageSchema = z24.strictObject({
       "failed",
       "superseded"
     ]),
-    reason: z24.string().nullable(),
+    reason: z26.string().nullable(),
     contentAttempt: identifier,
     attempt: identifier.nullable(),
     reward: contentQualificationSchema.shape.reward
   }),
-  items: z24.array(
-    z24.strictObject({
+  items: z26.array(
+    z26.strictObject({
       attempt: identifier,
       contentAttempt: identifier,
       observation: identifier,
-      observedAt: z24.number(),
+      observedAt: z26.number(),
       metrics: contentMetricsSchema,
-      state: z24.enum([
+      state: z26.enum([
         "pending",
         "qualified",
         "unqualified",
@@ -3038,13 +3407,22 @@ var contentPerformancePageSchema = z24.strictObject({
         "failed",
         "superseded"
       ]),
-      reason: z24.string().nullable()
+      reason: z26.string().nullable()
     })
   ),
   nextCursor: pageCursorSchema.nullable()
 });
 
 export {
+  isRequestError,
+  RequestError,
+  RelayErrorCode,
+  isRelayError,
+  RelayError,
+  asRelayError,
+  clientError,
+  parseInput,
+  identifier,
   markResponseSchema,
   lazyResponseReaders,
   responseShape,
@@ -3059,7 +3437,6 @@ export {
   discordMemberInputSchema,
   discordMessageInputSchema,
   discordMemberSchema,
-  identifier,
   discordMessageSchema,
   discordMessagesSourceSchema,
   discordReactionsSourceSchema,
@@ -3182,6 +3559,29 @@ export {
   integrationProviderSchema,
   discordServerSchema,
   projectIntegrationSchema,
+  solanaAddressSchema,
+  walletChainSchema,
+  cosmosNetworkSchema,
+  cosmosDenomSchema,
+  cosmosChain,
+  solanaMainnet,
+  evmAddressSchema,
+  cosmosAddressSchema,
+  walletAddressInputSchema,
+  walletMessageChallengeSchema,
+  walletSignatureSchema,
+  linkedWalletSchema,
+  walletUnlinkInputSchema,
+  walletAddressInput,
+  WALLETS_PER_CHAIN,
+  walletSignInFamilies,
+  walletSignInNetworkSchema,
+  walletSignInNetworksSchema,
+  walletSignInNetwork,
+  caip10,
+  isEvmChainId,
+  evmChainIdSchema,
+  walletBalanceSchema,
   textOptionsSchema,
   urlOptionsSchema,
   textEvidenceSchema,
@@ -3242,6 +3642,8 @@ export {
   tieredRewardDefinitionSchema,
   tieredRewardReferenceSchema,
   tierRewardSchema,
+  badgeRewardSchema,
+  badgeReward,
   integrationRewardSchema,
   rewardSchema,
   rewardKey,
@@ -3256,6 +3658,10 @@ export {
   storedReviewModeSchema,
   rewardBundleSchema,
   mediaUrlSchema,
+  questStepActionSchema,
+  questStepSchema,
+  questPresentationRequirementSchema,
+  questPresentationContentSchema,
   questPresentationSchema,
   questProfileSchema,
   evaluatorProtocol,