@domino-sdk/relay 1.56.0 → 1.60.0

package/dist/{chunk-BHHUSBSD.js → chunk-GBSDAD3N.js}

@@ -508,7 +508,9 @@ var discordResourceSourceSchema = z6.union([
   z6.strictObject({
     provider: z6.literal("discord"),
     resource: z6.literal("channel"),
-    types: z6.array(z6.enum(["text", "announcement"])).min(1)
+    types: z6.array(z6.enum(["text", "announcement"])).min(1),
+    /** List channels Domino's bot cannot post in as unavailable, for an announcement's channel. */
+    postable: z6.literal(true).optional()
   }),
   z6.strictObject({
     provider: z6.literal("discord"),
@@ -692,6 +694,26 @@ var annotations = /* @__PURE__ */ new Set([
   "readOnly",
   "writeOnly"
 ]);
+function singleTypes(schema) {
+  if (Array.isArray(schema)) {
+    return schema.map(singleTypes);
+  }
+  if (typeof schema !== "object" || schema === null) {
+    return schema;
+  }
+  const node2 = Object.fromEntries(
+    Object.entries(schema).map(([key, value]) => [key, singleTypes(value)])
+  );
+  if (!Array.isArray(node2.type)) {
+    return node2;
+  }
+  const { type, ...rest } = node2;
+  return {
+    anyOf: type.map(
+      (each) => each === "null" ? { type: each } : { ...rest, type: each }
+    )
+  };
+}
 function subset(schema, path) {
   if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
     return schema;
@@ -725,9 +747,9 @@ function subset(schema, path) {
   return kept;
 }
 function trackerDataSchema(schema) {
-  let json4;
+  let json5;
   try {
-    json4 = z7.toJSONSchema(schema, {
+    json5 = z7.toJSONSchema(schema, {
       target: "draft-2020-12",
       io: "input",
       unrepresentable: "throw",
@@ -754,7 +776,9 @@ function trackerDataSchema(schema) {
       message.startsWith("Tracker data schemas") ? message : `Tracker data schemas describe JSON: ${message}. Use z.unknown() for any JSON value.`
     );
   }
-  const parsed = trackerDataSchemaSchema.safeParse(subset(json4, "data"));
+  const parsed = trackerDataSchemaSchema.safeParse(
+    subset(singleTypes(json5), "data")
+  );
   if (!parsed.success) {
     throw new Error(
       parsed.error.issues.map((issue) => issue.message).join("; ")
@@ -901,26 +925,26 @@ function matches(schema, value, at, budget) {
     }
   }
   if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-    const object20 = value;
+    const object21 = value;
     const properties = schema.properties ?? {};
     const required = schema.required ?? [];
     charge(budget, required.length);
     for (const key of required) {
-      if (!Object.hasOwn(object20, key)) {
+      if (!Object.hasOwn(object21, key)) {
         return issue(() => `missing required key "${clip(key, maxKeyText)}"`);
       }
     }
     const literals = literalsOf(schema);
     charge(budget, literals.length);
     for (const [key, property] of literals) {
-      if (Object.hasOwn(object20, key) && object20[key] !== property.const) {
+      if (Object.hasOwn(object21, key) && object21[key] !== property.const) {
         return {
           at: { parent: at, key },
           reason: () => `expected ${JSON.stringify(property.const)}`
         };
       }
     }
-    const keys = Object.keys(object20);
+    const keys = Object.keys(object21);
     charge(budget, keys.length);
     const names = schema.propertyNames?.enum;
     const allowed = names && setOf(schema.propertyNames, names);
@@ -941,7 +965,7 @@ function matches(schema, value, at, budget) {
       if (property && property !== true) {
         const found = matches(
           property,
-          object20[key],
+          object21[key],
           { parent: at, key },
           budget
         );
@@ -1072,7 +1096,7 @@ function schemaCheckedReader(reader) {
       }
       const issues = trackerDataIssues(
         schema,
-        page.items.map((record10) => record10.data)
+        page.items.map((record11) => record11.data)
       );
       const items = page.items.filter((_, index) => !issues[index]);
       return { ...page, items, excluded: page.items.length - items.length };
@@ -1094,22 +1118,42 @@ function whereSchemaIssue(schema, where) {
   return null;
 }
 
+// src/tracker-namespaces.ts
+var telegramReactionsNamespace = "telegram-reactions";
+var telegramMessagesNamespace = "telegram-messages";
+var youtubeShortsNamespace = "youtube-shorts";
+var tiktokVideosNamespace = "tiktok-videos";
+var walletBalancesNamespace = "wallet-balances";
+
 // src/trackers.ts
+import * as z10 from "zod";
+
+// src/lifecycle-reason.ts
 import * 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 lifecycleReasonSchema = z8.string().trim().min(1).max(500);
+
+// src/offset-date-time.ts
+import * as z9 from "zod";
+var offsetDateTime = /^(?:(?:\d\d[2468][048]|\d\d[13579][26]|\d\d0[48]|[02468][048]00|[13579][26]00)-02-29|\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\d|30)|(?:02)-(?:0[1-9]|1\d|2[0-8])))T(?:(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d(?:\.\d+)?)?(?:Z|([+-](?:[01]\d|2[0-3]):[0-5]\d)))$/;
+function offsetDateTimeSchema() {
+  return z9.iso.datetime({ offset: true, pattern: offsetDateTime });
+}
+
+// src/trackers.ts
+var timestamp = z10.number().int().safe().nonnegative().max(864e13);
+var count = z10.number().int().safe().nonnegative();
+var externalId = z10.string().min(1).max(256);
 var metric = count.nullable().default(null);
-var xTweetSchema = z8.looseObject({
+var xTweetSchema = z10.looseObject({
   id: externalId,
   userId: externalId,
-  content: z8.string(),
-  createdAt: z8.iso.datetime({ offset: true }),
-  author: z8.looseObject({
+  content: z10.string(),
+  createdAt: offsetDateTimeSchema(),
+  author: z10.looseObject({
     id: externalId,
-    username: z8.string(),
-    name: z8.string(),
-    verified: z8.boolean().nullable().default(null)
+    username: z10.string(),
+    name: z10.string(),
+    verified: z10.boolean().nullable().default(null)
   }),
   likeCount: metric,
   replyCount: metric,
@@ -1117,84 +1161,84 @@ var xTweetSchema = z8.looseObject({
   quoteCount: metric,
   viewCount: metric,
   bookmarkCount: metric,
-  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),
+  isReply: z10.boolean(),
+  isRetweet: z10.boolean(),
+  isQuoteTweet: z10.boolean()
+});
+var xContentBodySchema = z10.strictObject({
+  version: z10.literal(1),
+  id: z10.string().min(1),
+  authorId: z10.string().min(1),
   publishedAt: timestamp,
-  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()
+  text: z10.string(),
+  isReply: z10.boolean(),
+  isRetweet: z10.boolean(),
+  isQuoteTweet: z10.boolean(),
+  media: z10.array(z10.strictObject({ type: z10.string(), url: z10.string() })).nullable(),
+  mentionedAuthorIds: z10.array(z10.string().min(1)).nullable(),
+  videoLengthSeconds: z10.number().nonnegative().nullable(),
+  references: z10.strictObject({
+    replyId: z10.string().nullable(),
+    replyAuthorId: z10.string().nullable(),
+    quoteId: z10.string().nullable(),
+    quoteAuthorId: z10.string().nullable(),
+    repostId: z10.string().nullable(),
+    repostAuthorId: z10.string().nullable()
   })
 });
-var trackerContentQuerySchema = z8.strictObject({
+var trackerContentQuerySchema = z10.strictObject({
   id: externalId,
-  observation: z8.string().regex(/^observation_[a-f0-9]{64}$/)
+  observation: z10.string().regex(/^observation_[a-f0-9]{64}$/)
 });
 var trackerContentReadSchema = trackerContentQuerySchema.extend({
   member: identifier
 });
 var attributionContext = { member: identifier, capturedAt: timestamp };
-var trackerEvidenceSchema = z8.strictObject({
+var trackerEvidenceSchema = z10.strictObject({
   contentRevision: identifier,
   observation: identifier
 });
-var trackerContentSchema = z8.strictObject({
+var trackerContentSchema = z10.strictObject({
   tracker: identifier,
-  source: z8.literal("x"),
+  source: z10.literal("x"),
   evidence: trackerEvidenceSchema,
   content: xContentBodySchema,
   observedAt: timestamp,
-  removed: z8.boolean(),
-  attribution: z8.discriminatedUnion("kind", [
-    z8.strictObject({
+  removed: z10.boolean(),
+  attribution: z10.discriminatedUnion("kind", [
+    z10.strictObject({
       ...attributionContext,
-      kind: z8.literal("linked"),
-      account: z8.strictObject({
-        provider: z8.literal("x"),
-        issuer: z8.string().min(1),
+      kind: z10.literal("linked"),
+      account: z10.strictObject({
+        provider: z10.literal("x"),
+        issuer: z10.string().min(1),
         subject: externalId,
         revision: count,
         linkedAt: timestamp.nullable()
       })
     }),
-    z8.strictObject({ ...attributionContext, kind: z8.literal("unlinked") }),
-    z8.strictObject({
+    z10.strictObject({ ...attributionContext, kind: z10.literal("unlinked") }),
+    z10.strictObject({
       ...attributionContext,
-      kind: z8.literal("different-author")
+      kind: z10.literal("different-author")
     })
   ])
 });
 var knownIdentityKinds = ["wallet", "x", "discord", "member"];
-var appIdentityKindSchema = z8.templateLiteral([
+var appIdentityKindSchema = z10.templateLiteral([
   "app:",
-  z8.string().regex(
+  z10.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 = z8.union([
-  z8.enum(knownIdentityKinds),
+var identityKindSchema = z10.union([
+  z10.enum(knownIdentityKinds),
   appIdentityKindSchema
 ]);
 var isAppIdentityKind = (kind) => kind.startsWith("app:");
-var openIdentityKindSchema = z8.string().min(1).max(64);
-var memberIdentitySchema = z8.object({
+var openIdentityKindSchema = z10.string().min(1).max(64);
+var memberIdentitySchema = z10.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,
@@ -1206,13 +1250,13 @@ var memberIdentitySchema = z8.object({
   /** The latest link time, refreshed on app identity relink; null when the link time is unknown. */
   linkedAt: timestamp.nullable()
 });
-var accountRoleSchema = z8.string().regex(
+var accountRoleSchema = z10.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 = z8.string().regex(
+var contentMetricNameSchema = z10.string().regex(
   /^[a-z][a-zA-Z0-9]{0,39}$/,
   "Name metrics like likes or watchTime: a lowercase letter, then letters or digits"
 );
@@ -1224,24 +1268,31 @@ var xContentMetrics = [
   "views",
   "bookmarks"
 ];
-var customContentSchema = z8.strictObject({
-  metrics: z8.array(contentMetricNameSchema).max(10).refine(distinct, "List each metric once")
+var customContentSchema = z10.strictObject({
+  metrics: z10.array(contentMetricNameSchema).max(10).refine(distinct, "List each metric once")
+});
+var walletBalanceSourceSchema = z10.strictObject({
+  chain: z10.string().regex(
+    /^(?:solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp|eip155:[1-9][0-9]{0,15}|cosmos:[-_a-zA-Z0-9]{1,32})$/,
+    'Use "solana", an EVM chain such as "eip155:8453" or a Cosmos network such as "cosmos:cosmoshub-4"'
+  ),
+  token: z10.string().min(1).max(128).nullable()
 });
-var xSearchSourceSchema = z8.object({
-  kind: z8.literal("x-search"),
-  query: z8.string().trim().min(1).max(2e3)
+var xSearchSourceSchema = z10.object({
+  kind: z10.literal("x-search"),
+  query: z10.string().trim().min(1).max(2e3)
 }).strict();
-var customSourceSchema = z8.object({
-  kind: z8.literal("custom"),
+var customSourceSchema = z10.object({
+  kind: z10.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: z8.array(identityKindSchema).min(1).max(8).refine(distinct, "List each identity kind once").optional(),
+  identities: z10.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: z8.array(accountRoleSchema).min(1).max(10).refine(distinct, "List each account role once").refine(
+  accounts: z10.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(),
@@ -1256,15 +1307,23 @@ var customSourceSchema = z8.object({
    * use the tracker with `content()`. `customSource(namespace, { content })` sets it with the
    * matching `data` schema.
    */
-  content: customContentSchema.optional()
+  content: customContentSchema.optional(),
+  /**
+   * The chain and token Relay samples, on `wallet.balances()`'s reserved namespace only.
+   * `wallet.balances()` sets it.
+   */
+  balance: walletBalanceSourceSchema.optional()
 }).strict().refine(
+  (source) => source.balance === void 0 || source.namespace === walletBalancesNamespace,
+  "Only wallet.balances() samples a balance"
+).refine(
   (source) => !source.content || source.data?.properties?.body?.type === "object" && (source.data.required ?? []).includes("body"),
   "A content source's data schema has a required object body"
 ).refine(
   (source) => !source.accounts || source.identities,
   "Named accounts need identities"
 );
-var trackerSourceSchema = z8.discriminatedUnion("kind", [
+var trackerSourceSchema = z10.discriminatedUnion("kind", [
   xSearchSourceSchema,
   customSourceSchema,
   discordMessagesSourceSchema,
@@ -1301,59 +1360,59 @@ function sourceContent(source) {
       return void 0;
   }
 }
-var windowSchema = z8.object({ start: timestamp, end: timestamp.optional() }).strict().refine(
+var windowSchema = z10.object({ start: timestamp, end: timestamp.optional() }).strict().refine(
   (w) => w.end === void 0 || w.end > w.start,
   "End must follow start"
 );
-var trackerDefinitionSchema = z8.object({
+var trackerDefinitionSchema = z10.object({
   key: identifier,
-  title: z8.string().trim().min(1).max(120),
+  title: z10.string().trim().min(1).max(120),
   source: trackerSourceSchema,
   window: windowSchema,
-  refreshSeconds: z8.number().int().min(300).max(86400).default(21600),
-  maxPages: z8.number().int().min(1).max(1e3).default(60)
+  refreshSeconds: z10.number().int().min(300).max(86400).default(21600),
+  maxPages: z10.number().int().min(1).max(1e3).default(60)
 }).strict();
-var trackerArtifactSchema = z8.union([
+var trackerArtifactSchema = z10.union([
   trackerDefinitionSchema,
-  z8.object({ code: z8.string().min(1).max(2e6) }).strict()
+  z10.object({ code: z10.string().min(1).max(2e6) }).strict()
 ]);
-var knownTrackerSourceResponseSchema = z8.discriminatedUnion("kind", [
-  z8.object(xSearchSourceSchema.shape),
-  z8.object({
+var knownTrackerSourceResponseSchema = z10.discriminatedUnion("kind", [
+  z10.object(xSearchSourceSchema.shape),
+  z10.object({
     ...customSourceSchema.shape,
-    identities: z8.array(openIdentityKindSchema).optional()
+    identities: z10.array(openIdentityKindSchema).optional()
   }),
-  z8.object(discordMessagesSourceSchema.shape),
-  z8.object(discordReactionsSourceSchema.shape)
+  z10.object(discordMessagesSourceSchema.shape),
+  z10.object(discordReactionsSourceSchema.shape)
 ]);
-var trackerSourceResponseSchema = z8.union([
+var trackerSourceResponseSchema = z10.union([
   knownTrackerSourceResponseSchema,
-  z8.object({
-    kind: z8.string().min(1).refine(
+  z10.object({
+    kind: z10.string().min(1).refine(
       (kind) => !trackerSourceKinds.some((known) => known === kind),
       "Known source kinds must match their schema"
     )
-  }).catchall(z8.json())
+  }).catchall(z10.json())
 ]);
 function isKnownTrackerSource(source) {
   return knownTrackerSourceResponseSchema.safeParse(source).success;
 }
-var trackerDefinitionResponseSchema = z8.object({
+var trackerDefinitionResponseSchema = z10.object({
   ...trackerDefinitionSchema.shape,
   source: trackerSourceResponseSchema,
-  window: z8.object(windowSchema.shape)
+  window: z10.object(windowSchema.shape)
 });
-var publishedTrackerSchema = z8.object({
+var publishedTrackerSchema = z10.object({
   id: identifier,
   version: identifier,
   definition: trackerDefinitionResponseSchema,
   publishedAt: timestamp,
-  actor: z8.string().nullable()
+  actor: z10.string().nullable()
 });
-var trackerStatusSchema = z8.object({
-  archivedAt: z8.number().int().nonnegative().nullable().optional(),
+var trackerStatusSchema = z10.object({
+  archivedAt: z10.number().int().nonnegative().nullable().optional(),
   published: publishedTrackerSchema,
-  paused: z8.boolean(),
+  paused: z10.boolean(),
   /**
    * Why a paused tracker is paused, null when it isn't: `operator` (paused by hand),
    * `x-budget-exhausted` (the project's monthly X budget, or in test the organization's, is spent;
@@ -1361,29 +1420,79 @@ var trackerStatusSchema = z8.object({
    * `test-window-ended` (a test X tracker collects for 14 days; resume it for another 14). Treat an
    * unknown reason, which a newer Relay can add, as paused. Older servers leave it out.
    */
-  pauseReason: z8.string().nullable().optional(),
+  pauseReason: z10.string().nullable().optional(),
   /** When a tracker paused on its X budget resumes on its own: the start of the next UTC month. */
   resumesAt: timestamp.nullable().optional(),
   /**
    * The interval a scheduled tracker actually runs at: `refreshSeconds`, but no shorter than the
    * project's plan allows (6 hours, shorter on Enterprise). Older servers leave it out.
    */
-  effectiveRefreshSeconds: z8.number().int().positive().optional(),
-  state: z8.enum(["idle", "syncing", "error", "complete"]),
+  effectiveRefreshSeconds: z10.number().int().positive().optional(),
+  state: z10.enum(["idle", "syncing", "error", "complete"]),
   lastStartedAt: timestamp.nullable(),
   lastCompletedAt: timestamp.nullable(),
   nextSyncAt: timestamp.nullable(),
-  coverage: z8.enum(["unknown", "partial", "complete"]),
-  error: z8.string().nullable(),
+  coverage: z10.enum(["unknown", "partial", "complete"]),
+  error: z10.string().nullable(),
   records: count,
   /**
    * Who owns the definition: `code` for a tracker a deployment publishes from `defineTracker`,
-   * `data` for an X search tracker created with `management.trackers.create` or in Console, which
-   * only `management.trackers.update` changes. Older servers leave it out.
+   * `data` for a tracker created with `management.trackers.create` or in Console, which only
+   * `management.trackers.update` changes. Older servers leave it out.
    */
-  origin: z8.enum(["code", "data"]).optional()
+  origin: z10.enum(["code", "data"]).optional()
 });
-var trackerPropertiesSchema = z8.object({
+var managedTrackerSourceSchema = z10.discriminatedUnion("kind", [
+  xSearchSourceSchema,
+  discordMessagesSourceSchema,
+  discordReactionsSourceSchema,
+  z10.strictObject({ kind: z10.literal("telegram-messages") }),
+  z10.strictObject({ kind: z10.literal("telegram-reactions") }),
+  z10.strictObject({ kind: z10.literal("youtube-shorts") }),
+  z10.strictObject({ kind: z10.literal("tiktok-videos") }),
+  /** `wallet.balances({ chain, token })`, with the chain's CAIP-2 ID and a null `token` for a native coin. */
+  z10.strictObject({
+    kind: z10.literal("wallet-balances"),
+    ...walletBalanceSourceSchema.shape
+  })
+]);
+var managedTrackerSourceKinds = [
+  "x-search",
+  "discord-messages",
+  "discord-reactions",
+  "telegram-messages",
+  "telegram-reactions",
+  "youtube-shorts",
+  "tiktok-videos",
+  "wallet-balances"
+];
+var namespacedSourceKinds = {
+  [telegramMessagesNamespace]: "telegram-messages",
+  [telegramReactionsNamespace]: "telegram-reactions",
+  [youtubeShortsNamespace]: "youtube-shorts",
+  [tiktokVideosNamespace]: "tiktok-videos"
+};
+function managedTrackerSource(source) {
+  if (!isKnownTrackerSource(source)) {
+    return void 0;
+  }
+  switch (source.kind) {
+    case "x-search":
+      return { kind: "x-search", query: source.query };
+    case "discord-messages":
+      return { kind: "discord-messages", text: source.text ?? false };
+    case "discord-reactions":
+      return { kind: "discord-reactions" };
+    case "custom":
+      if (source.namespace === walletBalancesNamespace) {
+        return source.balance ? { kind: "wallet-balances", ...source.balance } : void 0;
+      }
+      return Object.hasOwn(namespacedSourceKinds, source.namespace) ? {
+        kind: namespacedSourceKinds[source.namespace]
+      } : void 0;
+  }
+}
+var trackerPropertiesSchema = z10.object({
   title: trackerDefinitionSchema.shape.title,
   /** The X search query. A new query collects from now on; it never searches the past. */
   query: xSearchSourceSchema.shape.query,
@@ -1398,73 +1507,87 @@ var trackerCreateSchema = trackerPropertiesSchema.extend({
   maxPages: trackerDefinitionSchema.shape.maxPages,
   actionId: identifier
 }).strict();
-var trackerUpdateSchema = trackerPropertiesSchema.partial().extend({ actionId: identifier }).strict().refine(
+var managedTrackerCreateSchema = trackerCreateSchema.extend({
+  query: xSearchSourceSchema.shape.query.optional(),
+  source: managedTrackerSourceSchema.optional()
+}).refine(
+  (input) => input.query === void 0 !== (input.source === void 0),
+  "Name the source with source, or an X search with query, not both"
+);
+var trackerUpdateSchema = trackerPropertiesSchema.partial().extend({
+  source: managedTrackerSourceSchema.optional(),
+  actionId: identifier
+}).strict().refine(
   ({ actionId: _, ...changes }) => Object.values(changes).some((value) => value !== void 0),
   "Change at least one field"
+).refine(
+  (input) => input.query === void 0 || input.source === void 0,
+  "Change the query with source or query, not both"
 );
-var trackerControlSchema = z8.object({
+var trackerControlSchema = z10.object({
   actionId: identifier,
-  action: z8.enum(["pause", "resume", "refresh"])
+  action: z10.enum(["pause", "resume", "refresh"]),
+  reason: lifecycleReasonSchema.optional()
 }).strict();
-var trackerAccountSchema = z8.strictObject({
+var trackerAccountSchema = z10.strictObject({
   kind: identityKindSchema.optional(),
   id: externalId
 });
-var trackerRecordInputSchema = z8.object({
+var trackerRecordInputSchema = z10.object({
   id: externalId,
   occurredAt: timestamp,
   observedAt: timestamp,
-  author: z8.object({
+  author: z10.object({
     id: externalId,
-    verified: z8.boolean().nullable().default(null),
+    verified: z10.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: z8.record(accountRoleSchema, trackerAccountSchema).refine(
+  accounts: z10.record(accountRoleSchema, trackerAccountSchema).refine(
     (accounts) => Object.keys(accounts).length <= 10,
     "At most 10 accounts"
   ).optional(),
-  data: z8.record(z8.string(), z8.json()),
-  removed: z8.boolean().default(false)
+  data: z10.record(z10.string(), z10.json()),
+  removed: z10.boolean().default(false)
 }).strict().refine(
   (v) => new TextEncoder().encode(JSON.stringify(v.data)).byteLength <= 131072,
   "Record exceeds 128 KB"
 );
-var trackerRecordAccountSchema = z8.object({
+var trackerRecordAccountSchema = z10.object({
   kind: openIdentityKindSchema.optional(),
-  id: z8.string()
+  id: z10.string()
 });
-var trackerRecordSchema = z8.object({
-  id: z8.string(),
+var trackerRecordSchema = z10.object({
+  id: z10.string(),
   occurredAt: timestamp,
   observedAt: timestamp,
-  author: z8.object({
-    id: z8.string(),
-    verified: z8.boolean().nullable().default(null),
+  author: z10.object({
+    id: z10.string(),
+    verified: z10.boolean().nullable().default(null),
     kind: openIdentityKindSchema.optional()
   }).nullable().default(null),
-  accounts: z8.record(z8.string(), trackerRecordAccountSchema).optional(),
-  data: z8.record(z8.string(), z8.json()),
-  removed: z8.boolean().default(false),
-  source: z8.string(),
+  accounts: z10.record(z10.string(), trackerRecordAccountSchema).optional(),
+  data: z10.record(z10.string(), z10.json()),
+  removed: z10.boolean().default(false),
+  source: z10.string(),
   firstSeenAt: timestamp,
   /**
    * True on a record an operator sent for a test member (`management.testMembers.record`), in
    * test only. Absent on every other record.
    */
-  synthetic: z8.literal(true).optional(),
+  synthetic: z10.literal(true).optional(),
   /** Present only when includeEvidence is true; custom sources have no X evidence. */
   evidence: trackerEvidenceSchema.nullable().optional()
 });
-var trackerIngestSchema = z8.object({
+var trackerIngestSchema = z10.object({
   actionId: identifier,
-  records: z8.array(trackerRecordInputSchema).min(1).max(100)
+  records: z10.array(trackerRecordInputSchema).min(1).max(100)
 }).strict();
-var trackerIngestResultSchema = z8.object({
+var trackerIngestResultSchema = z10.object({
   stored: count,
   /** Tracker-trigger decisions this ingest caused. Absent from servers without tracker triggers. */
-  admissions: z8.object({
+  admissions: z10.object({
     admitted: count,
     skipped: count,
     /**
@@ -1485,11 +1608,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: z8.string().nullable(),
+  account: z10.string().nullable(),
   createdAt: timestamp,
   updatedAt: timestamp,
   /** Null for automatic decisions; the staff actor after a retry. */
-  actor: z8.string().nullable()
+  actor: z10.string().nullable()
 };
 var trackerSkipCodes = [
   /** The quest is paused or no longer active. Catch-up after a pause is an operator decision. */
@@ -1544,26 +1667,26 @@ var trackerSkipCodes = [
   /** A prerequisite quest was not complete when the record occurred. */
   "prerequisites-incomplete"
 ];
-var trackerOutcomeSchema = z8.discriminatedUnion("state", [
-  z8.object({
+var trackerOutcomeSchema = z10.discriminatedUnion("state", [
+  z10.object({
     ...trackerOutcomeFields,
-    state: z8.literal("admitted"),
-    code: z8.null(),
-    reason: z8.null(),
+    state: z10.literal("admitted"),
+    code: z10.null(),
+    reason: z10.null(),
     /** The attributed member. */
     member: identifier,
     /** The admitted attempt. Its evaluation, decision and rewards live on the attempt. */
     attempt: identifier
   }),
-  z8.object({
+  z10.object({
     ...trackerOutcomeFields,
-    state: z8.literal("skipped"),
+    state: z10.literal("skipped"),
     /** Why the observation was skipped, as one of `trackerSkipCodes`. */
-    code: z8.string().min(1),
+    code: z10.string().min(1),
     /** Why the observation was skipped, for people. */
-    reason: z8.string(),
+    reason: z10.string(),
     /** Which window refused admission when `code` is `outside-window`. */
-    window: z8.enum(["tracker", "quest"]).optional(),
+    window: z10.enum(["tracker", "quest"]).optional(),
     /** The attributed member, when attribution got that far. */
     member: identifier.nullable(),
     attempt: identifier.nullable()
@@ -1574,67 +1697,67 @@ var trackerOutcomeFilters = {
   quest: identifier.optional(),
   record: externalId.optional(),
   member: identifier.optional(),
-  state: z8.enum(["admitted", "skipped"]).optional(),
+  state: z10.enum(["admitted", "skipped"]).optional(),
   /** Only skips with this code, such as `unlinked-account`. */
-  code: z8.string().min(1).max(100).optional(),
-  limit: z8.coerce.number().int().min(1).max(100).default(25)
+  code: z10.string().min(1).max(100).optional(),
+  limit: z10.coerce.number().int().min(1).max(100).default(25)
 };
-var trackerTriggerOutcomeQuerySchema = z8.strictObject({
+var trackerTriggerOutcomeQuerySchema = z10.strictObject({
   ...trackerOutcomeFilters,
   cursor: pageCursorSchema.optional()
 });
-var trackerTriggerOutcomePageSchema = z8.object({
-  items: z8.array(trackerOutcomeSchema).max(100),
+var trackerTriggerOutcomePageSchema = z10.object({
+  items: z10.array(trackerOutcomeSchema).max(100),
   nextCursor: pageCursorSchema.nullable()
 });
-var trackerOutcomeQuerySchema = z8.strictObject({
+var trackerOutcomeQuerySchema = z10.strictObject({
   ...trackerOutcomeFilters,
   /** Opaque cursor from `next`: older outcomes. */
-  before: z8.string().max(512).optional()
+  before: z10.string().max(512).optional()
 });
-var trackerOutcomePageSchema = z8.strictObject({
+var trackerOutcomePageSchema = z10.strictObject({
   /** Newest first. */
-  items: z8.array(trackerOutcomeSchema).max(100),
-  next: z8.string().nullable()
+  items: z10.array(trackerOutcomeSchema).max(100),
+  next: z10.string().nullable()
 });
-var trackerOutcomeRetrySchema = z8.strictObject({
+var trackerOutcomeRetrySchema = z10.strictObject({
   actionId: identifier,
   /** Quest key or ID. */
   quest: identifier,
   record: externalId,
   observedAt: timestamp
 });
-var booleanQuery = z8.union([
-  z8.boolean(),
-  z8.enum(["true", "false"]).transform((v) => v === "true")
+var booleanQuery = z10.union([
+  z10.boolean(),
+  z10.enum(["true", "false"]).transform((v) => v === "true")
 ]);
-var trackerQuerySchema = z8.object({
+var trackerQuerySchema = z10.object({
   author: externalId.optional(),
   member: identifier.optional(),
   verified: booleanQuery.optional(),
-  since: z8.coerce.number().int().safe().nonnegative().optional(),
-  until: z8.coerce.number().int().safe().nonnegative().optional(),
+  since: z10.coerce.number().int().safe().nonnegative().optional(),
+  until: z10.coerce.number().int().safe().nonnegative().optional(),
   removed: booleanQuery.default(false),
-  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(),
+  minLikes: z10.coerce.number().int().safe().nonnegative().optional(),
+  minViews: z10.coerce.number().int().safe().nonnegative().optional(),
+  limit: z10.coerce.number().int().min(1).max(100).default(25),
+  cursor: z10.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 = z8.object({
+var trackerPageSchema = z10.object({
   tracker: identifier,
-  items: z8.array(trackerRecordSchema),
-  nextCursor: z8.string().nullable(),
+  items: z10.array(trackerRecordSchema),
+  nextCursor: z10.string().nullable(),
   total: count,
   status: trackerStatusSchema
 });
-var trackerSummarySchema = z8.object({
+var trackerSummarySchema = z10.object({
   records: count,
   authors: count,
-  metrics: z8.object({
+  metrics: z10.object({
     likes: count,
     replies: count,
     reposts: count,
@@ -1650,26 +1773,26 @@ var trackerPreviewLimits = {
   posts: 100,
   days: 30
 };
-var trackerPreviewInputSchema = z8.object({
+var trackerPreviewInputSchema = z10.object({
   query: xSearchSourceSchema.shape.query,
   /** Start of the searched window. The window ends when the sample is fetched. */
   since: timestamp
 }).strict();
-var trackerPreviewSchema = z8.object({
-  query: z8.string(),
+var trackerPreviewSchema = z10.object({
+  query: z10.string(),
   since: timestamp,
   fetchedAt: timestamp,
   pages: count,
   /** Every match in the sample, newest first, verified or not. */
-  posts: z8.array(xTweetSchema).max(trackerPreviewLimits.posts),
+  posts: z10.array(xTweetSchema).max(trackerPreviewLimits.posts),
   /** X had more matches than the sample holds. */
-  more: z8.boolean()
+  more: z10.boolean()
 });
 
 // src/content.ts
-import * as z9 from "zod";
-var contentQualificationDecisionSchema = z9.strictObject({
-  kind: z9.enum([
+import * as z11 from "zod";
+var contentQualificationDecisionSchema = z11.strictObject({
+  kind: z11.enum([
     "accept",
     "reject",
     "review",
@@ -1677,26 +1800,26 @@ var contentQualificationDecisionSchema = z9.strictObject({
     "progress",
     "superseded"
   ]),
-  reason: z9.string().nullable()
+  reason: z11.string().nullable()
 });
-var contentQualificationQuerySchema = z9.strictObject({
+var contentQualificationQuerySchema = z11.strictObject({
   quest: identifier,
   member: identifier.optional(),
   /** A content item's record ID in the quest's tracker. */
-  content: z9.string().min(1).max(256).optional(),
+  content: z11.string().min(1).max(256).optional(),
   cursor: pageCursorSchema.optional()
 });
-var contentQualificationSchema = z9.strictObject({
+var contentQualificationSchema = z11.strictObject({
   quest: identifier,
   /** The content item's record ID in the quest's tracker. */
-  content: z9.string(),
+  content: z11.string(),
   member: identifier,
   release: identifier,
   attempt: identifier,
   revision: identifier,
   observation: identifier,
-  current: z9.boolean(),
-  state: z9.enum([
+  current: z11.boolean(),
+  state: z11.enum([
     "pending",
     "qualified",
     "unqualified",
@@ -1707,117 +1830,117 @@ var contentQualificationSchema = z9.strictObject({
     "blocked",
     "unavailable"
   ]),
-  reason: z9.string().nullable(),
-  reward: z9.strictObject({
+  reason: z11.string().nullable(),
+  reward: z11.strictObject({
     attempt: identifier.nullable(),
     completion: identifier.nullable(),
-    state: z9.enum(["unresolved", "awarded", "excluded"])
+    state: z11.enum(["unresolved", "awarded", "excluded"])
   })
 });
-var contentQualificationPageSchema = z9.strictObject({
-  items: z9.array(contentQualificationSchema),
+var contentQualificationPageSchema = z11.strictObject({
+  items: z11.array(contentQualificationSchema),
   nextCursor: pageCursorSchema.nullable()
 });
 var contentMetricSchema = contentMetricNameSchema;
-var contentMetricsSchema = z9.record(
+var contentMetricsSchema = z11.record(
   contentMetricSchema,
-  z9.number().int().safe().nonnegative()
+  z11.number().int().safe().nonnegative()
 );
-var contentPerformancePolicySchema = z9.strictObject({
-  metrics: z9.array(contentMetricSchema).min(1).max(10).refine(
+var contentPerformancePolicySchema = z11.strictObject({
+  metrics: z11.array(contentMetricSchema).min(1).max(10).refine(
     (values2) => new Set(values2).size === values2.length,
     "Metrics must be unique"
   ),
-  maxAgeMs: z9.number().int().positive().max(864e5).default(36e5)
+  maxAgeMs: z11.number().int().positive().max(864e5).default(36e5)
 });
 
 // src/counters.ts
-import * as z10 from "zod";
+import * as z12 from "zod";
 var day = 864e5;
-var counterGoalSchema = z10.object({
-  kind: z10.literal("count"),
-  count: z10.number().int().min(1).max(1e4)
+var counterGoalSchema = z12.object({
+  kind: z12.literal("count"),
+  count: z12.number().int().min(1).max(1e4)
 }).strict();
-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)
+var counterWindowSchema = z12.discriminatedUnion("kind", [
+  z12.object({ kind: z12.literal("lifetime") }).strict(),
+  z12.object({
+    kind: z12.literal("calendar"),
+    period: z12.enum(["day", "week", "month"]),
+    latenessMs: z12.number().int().min(0).max(90 * day).default(7 * day)
   }).strict(),
-  z10.object({
-    kind: z10.literal("rolling"),
-    durationMs: z10.number().int().min(1).max(365 * day)
+  z12.object({
+    kind: z12.literal("rolling"),
+    durationMs: z12.number().int().min(1).max(365 * day)
   }).strict()
 ]);
-var counterPolicySchema = z10.object({
-  kind: z10.literal("progress"),
+var counterPolicySchema = z12.object({
+  kind: z12.literal("progress"),
   goal: counterGoalSchema,
   window: counterWindowSchema,
-  repeat: z10.enum(["once", "repeat"]).default("once")
+  repeat: z12.enum(["once", "repeat"]).default("once")
 }).strict();
-var achievementBase = z10.object({
+var achievementBase = z12.object({
   id: identifier,
-  ordinal: z10.number().int().positive(),
-  achievedAt: z10.number().int(),
-  window: z10.string()
+  ordinal: z12.number().int().positive(),
+  achievedAt: z12.number().int(),
+  window: z12.string()
 });
-var counterAchievementSchema = z10.discriminatedUnion("status", [
+var counterAchievementSchema = z12.discriminatedUnion("status", [
   achievementBase.extend({
-    status: z10.literal("revoked"),
+    status: z12.literal("revoked"),
     completion: identifier,
-    revokedAt: z10.number().int()
+    revokedAt: z12.number().int()
   }),
   achievementBase.extend({
-    status: z10.literal("awarded"),
+    status: z12.literal("awarded"),
     completion: identifier
   }),
   achievementBase.extend({
-    status: z10.literal("budget-exhausted"),
+    status: z12.literal("budget-exhausted"),
     budget: identifier
   })
 ]);
-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()
+var counterProgressSchema = z12.object({
+  goal: z12.number().int().positive(),
+  current: z12.number().int().nonnegative(),
+  window: z12.object({
+    key: z12.string(),
+    start: z12.number().int().nullable(),
+    end: z12.number().int().nullable()
   }),
-  repeat: z10.enum(["once", "repeat"]),
-  settled: z10.number().int().nonnegative(),
+  repeat: z12.enum(["once", "repeat"]),
+  settled: z12.number().int().nonnegative(),
   latest: counterAchievementSchema.nullable()
 });
-var counterContributionSchema = z10.object({
+var counterContributionSchema = z12.object({
   id: identifier,
-  distinct: z10.string(),
+  distinct: z12.string(),
   attempt: identifier,
-  occurredAt: z10.number().int(),
-  recordedAt: z10.number().int(),
-  window: z10.string(),
-  status: z10.enum(["counted", "late", "future", "excluded"]),
+  occurredAt: z12.number().int(),
+  recordedAt: z12.number().int(),
+  window: z12.string(),
+  status: z12.enum(["counted", "late", "future", "excluded"]),
   achievement: counterAchievementSchema.nullable(),
-  reason: z10.string().nullable()
+  reason: z12.string().nullable()
 });
-var counterHistorySchema = z10.object({
-  items: z10.array(counterContributionSchema),
-  nextCursor: z10.string().nullable()
+var counterHistorySchema = z12.object({
+  items: z12.array(counterContributionSchema),
+  nextCursor: z12.string().nullable()
 });
-var counterModerationSchema = z10.object({
-  actionId: z10.uuid(),
-  excluded: z10.boolean(),
-  reason: z10.string().trim().min(1).max(2e3)
+var counterModerationSchema = z12.object({
+  actionId: z12.uuid(),
+  excluded: z12.boolean(),
+  reason: z12.string().trim().min(1).max(2e3)
 }).strict();
-var counterHistoryQuerySchema = z10.object({
-  cursor: z10.string().max(2e3).optional(),
-  limit: z10.coerce.number().int().min(1).max(100).optional()
+var counterHistoryQuerySchema = z12.object({
+  cursor: z12.string().max(2e3).optional(),
+  limit: z12.coerce.number().int().min(1).max(100).optional()
 }).strict();
-var counterModerationResultSchema = z10.object({ excluded: z10.boolean() });
+var counterModerationResultSchema = z12.object({ excluded: z12.boolean() });
 
 // src/calendar.ts
-import * as z11 from "zod";
-var timestamp2 = z11.number().int().safe();
+import * as z13 from "zod";
+var timestamp2 = z13.number().int().safe();
 var fixedOffset = /^(?:[+-]|(?:Etc\/)?GMT[+-]\d|(?:EST|MST|HST)$)/i;
 function canonicalTimeZone(zone) {
   let resolved;
@@ -1833,18 +1956,18 @@ function canonicalTimeZone(zone) {
   }
   return fixedOffset.test(zone) || fixedOffset.test(resolved) ? null : resolved;
 }
-var timeZoneSchema = z11.string().min(1).max(100).transform((zone, ctx) => {
+var timeZoneSchema = z13.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 z11.NEVER;
+    return z13.NEVER;
   }
   return canonical;
 });
-var timeZoneNameSchema = z11.string().min(1).max(100);
+var timeZoneNameSchema = z13.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 record5 = (value) => typeof value === "object" && value !== null;
 function refuseStreakTimeZone(value, ctx) {
@@ -1868,78 +1991,78 @@ function refuseWindowTimeZone(value, ctx) {
   }
   return value;
 }
-var calendarPeriodSchema = z11.enum(["lifetime", "day", "week", "month"]);
-var projectCalendarSchema = z11.object({
+var calendarPeriodSchema = z13.enum(["lifetime", "day", "week", "month"]);
+var projectCalendarSchema = z13.object({
   /** The timezone of the current calendar day. */
   timeZone: timeZoneNameSchema,
   /** The current calendar date, such as `2026-10-01`. */
-  today: z11.string(),
+  today: z13.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: z11.object({ timeZone: timeZoneNameSchema, effectiveAt: timestamp2 }).nullable(),
+  pending: z13.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: z11.string().nullable().default(null)
+  unsupported: z13.string().nullable().default(null)
 });
-var projectCalendarInputSchema = z11.object({
+var projectCalendarInputSchema = z13.object({
   actionId: identifier,
   timeZone: timeZoneSchema,
-  reason: z11.string().trim().min(1).max(500)
+  reason: z13.string().trim().min(1).max(500)
 }).strict();
-var projectCalendarDeclarationSchema = z11.object({ timeZone: timeZoneSchema }).strict();
+var projectCalendarDeclarationSchema = z13.object({ timeZone: timeZoneSchema }).strict();
 
 // src/streaks.ts
-import * as z12 from "zod";
-var streakPolicySchema = z12.object({
-  kind: z12.literal("streak"),
-  days: z12.number().int().min(1).max(3650)
+import * as z14 from "zod";
+var streakPolicySchema = z14.object({
+  kind: z14.literal("streak"),
+  days: z14.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(),
+var streakProgressSchema = z14.object({
+  goal: z14.number().int().positive(),
+  current: z14.number().int().nonnegative(),
+  best: z14.number().int().nonnegative(),
+  today: z14.string(),
+  todayQualified: z14.boolean(),
   timeZone: timeZoneNameSchema,
-  nextBoundary: z12.number().int(),
-  pendingTimeZone: z12.object({
+  nextBoundary: z14.number().int(),
+  pendingTimeZone: z14.object({
     timeZone: timeZoneNameSchema,
-    effectiveAt: z12.number().int()
+    effectiveAt: z14.number().int()
   }).nullable(),
-  days: z12.array(
-    z12.object({
-      day: z12.number().int(),
-      date: z12.string(),
+  days: z14.array(
+    z14.object({
+      day: z14.number().int(),
+      date: z14.string(),
       // The zone the day was recorded in, as stored: days from before v1 can name a fixed offset.
-      timeZone: z12.string(),
-      occurredAt: z12.number().int()
+      timeZone: z14.string(),
+      occurredAt: z14.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()
+  milestone: z14.discriminatedUnion("status", [
+    z14.object({ status: z14.literal("pending") }),
+    z14.object({
+      status: z14.literal("awarded"),
+      completion: z14.string(),
+      achievedAt: z14.number().int()
     }),
-    z12.object({
-      status: z12.literal("budget-exhausted"),
-      budget: z12.string(),
-      achievedAt: z12.number().int()
+    z14.object({
+      status: z14.literal("budget-exhausted"),
+      budget: z14.string(),
+      achievedAt: z14.number().int()
     })
   ])
 });
 
 // src/tracker-triggers.ts
-import * as z13 from "zod";
-var timestamp3 = z13.number().int().safe().nonnegative().max(864e13);
-var count2 = z13.number().int().safe().nonnegative();
-var trackerTriggerModeSchema = z13.enum([
+import * as z15 from "zod";
+var timestamp3 = z15.number().int().safe().nonnegative().max(864e13);
+var count2 = z15.number().int().safe().nonnegative();
+var trackerTriggerModeSchema = z15.enum([
   "new-record",
   "new-observation",
   "data-changed"
@@ -1947,20 +2070,20 @@ var trackerTriggerModeSchema = z13.enum([
 function defaultTriggerMode(source) {
   return source === "custom" ? "new-observation" : "new-record";
 }
-var trackerBoundSchema = z13.union([
-  z13.number().finite(),
-  z13.strictObject({ setting: z13.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/) })
+var trackerBoundSchema = z15.union([
+  z15.number().finite(),
+  z15.strictObject({ setting: z15.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/) })
 ]);
-var dataPath = z13.string().max(200).regex(
+var dataPath = z15.string().max(200).regex(
   /^[^.\s]+(\.[^.\s]+)*$/,
   "Use dot-separated keys, such as metrics.likes"
 );
-var trackerConditionSchema = z13.union([
-  z13.strictObject({
+var trackerConditionSchema = z15.union([
+  z15.strictObject({
     path: dataPath,
-    equals: z13.union([z13.string().max(1e3), z13.number().finite(), z13.boolean()])
+    equals: z15.union([z15.string().max(1e3), z15.number().finite(), z15.boolean()])
   }),
-  z13.strictObject({
+  z15.strictObject({
     path: dataPath,
     gt: trackerBoundSchema.optional(),
     gte: trackerBoundSchema.optional(),
@@ -1973,9 +2096,9 @@ var trackerConditionSchema = z13.union([
     "Compare with equals, gt, gte, lt or lte"
   )
 ]);
-var trackerWhereSchema = z13.union([
+var trackerWhereSchema = z15.union([
   trackerConditionSchema,
-  z13.array(trackerConditionSchema).min(1).max(10)
+  z15.array(trackerConditionSchema).min(1).max(10)
 ]);
 function whereConditions(where) {
   return where === void 0 ? [] : Array.isArray(where) ? where : [where];
@@ -1987,17 +2110,17 @@ function whereSettings(where) {
     )
   );
 }
-var triggerEnrollmentSchema = z13.enum(["none", "required"]);
-var triggerSinceSchema = z13.enum(["activation", "window", "enrollment"]);
-var triggerHistoricalSchema = z13.enum(["staff", "claim", "automatic"]);
-var trackerTriggerPolicySchema = z13.strictObject({
+var triggerEnrollmentSchema = z15.enum(["none", "required"]);
+var triggerSinceSchema = z15.enum(["activation", "window", "enrollment"]);
+var triggerHistoricalSchema = z15.enum(["staff", "claim", "automatic"]);
+var trackerTriggerPolicySchema = z15.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: z13.string().min(1).max(100),
+  source: z15.string().min(1).max(100),
   /** Which observations fire. */
   on: trackerTriggerModeSchema,
   where: trackerWhereSchema.optional(),
@@ -2018,7 +2141,7 @@ var trackerTriggerPolicySchema = z13.strictObject({
    * that re-evaluates edits and runs `performance`, firing on each new record and paying its
    * author.
    */
-  content: z13.literal(true).optional()
+  content: z15.literal(true).optional()
 }).refine(
   (policy) => policy.since !== "enrollment" || policy.enrollment === "required",
   'since: "enrollment" needs enrollment: "required"'
@@ -2037,72 +2160,72 @@ function beneficiaryRole(policy) {
   return policy.beneficiary;
 }
 var xLink = {
-  issuer: z13.string().min(1),
+  issuer: z15.string().min(1),
   /** The account's stable user ID. */
-  subject: z13.string().min(1).max(256),
+  subject: z15.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 = z13.object({
+var trackerAttributionSchema = z15.object({
   member: identifier,
   capturedAt: timestamp3,
-  account: z13.union([
-    z13.object({
-      provider: z13.literal("wallet"),
+  account: z15.union([
+    z15.object({
+      provider: z15.literal("wallet"),
       /** Canonical CAIP-10 account ID, as the record names it. */
-      id: z13.string().min(5).max(256),
+      id: z15.string().min(5).max(256),
       /** The wallet link's revision. */
       revision: count2,
       /** When the member verified the wallet. */
       linkedAt: timestamp3.nullable()
     }),
-    z13.object({ provider: z13.literal("x"), ...xLink }),
-    z13.object({ provider: z13.literal("discord"), ...xLink }),
-    z13.object({
-      provider: z13.literal("member"),
+    z15.object({ provider: z15.literal("x"), ...xLink }),
+    z15.object({ provider: z15.literal("discord"), ...xLink }),
+    z15.object({
+      provider: z15.literal("member"),
       /** The member ID the record names. */
       id: identifier
     }),
-    z13.object({
+    z15.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: z13.string().min(1).max(256),
+      subject: z15.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. */
-    z13.object({ provider: z13.string().min(1) })
+    z15.object({ provider: z15.string().min(1) })
   ])
 });
-var trackerTriggerRecordSchema = z13.object({
-  id: z13.string().min(1).max(256),
-  source: z13.string(),
+var trackerTriggerRecordSchema = z15.object({
+  id: z15.string().min(1).max(256),
+  source: z15.string(),
   occurredAt: timestamp3,
   observedAt: timestamp3,
   firstSeenAt: timestamp3,
-  author: z13.object({
-    id: z13.string().min(1).max(256),
-    verified: z13.boolean().nullable(),
+  author: z15.object({
+    id: z15.string().min(1).max(256),
+    verified: z15.boolean().nullable(),
     kind: openIdentityKindSchema.optional()
   }).nullable(),
-  accounts: z13.record(accountRoleSchema, trackerRecordAccountSchema).optional(),
-  data: z13.record(z13.string(), z13.json()),
-  removed: z13.boolean()
+  accounts: z15.record(accountRoleSchema, trackerRecordAccountSchema).optional(),
+  data: z15.record(z15.string(), z15.json()),
+  removed: z15.boolean()
 });
-var trackerContentStageSchema = z13.object({
+var trackerContentStageSchema = z15.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: z13.record(z13.string(), z13.json())
+  body: z15.record(z15.string(), z15.json())
 });
-var trackerTriggerContextSchema = z13.object({
+var trackerTriggerContextSchema = z15.object({
   /** The tracker's stable ID. */
   tracker: identifier,
   /** The tracker's authoring key. */
@@ -2124,7 +2247,7 @@ var trackerTriggerContextSchema = z13.object({
 });
 
 // src/reject-codes.ts
-import * as z14 from "zod";
+import * as z16 from "zod";
 var reservedAttemptCodes = Object.freeze([
   "budget-exhausted",
   "defer-expired",
@@ -2150,7 +2273,7 @@ function rejectCodeIssue(code) {
   }
   return null;
 }
-var rejectCodeSchema = z14.string().superRefine((code, context) => {
+var rejectCodeSchema = z16.string().superRefine((code, context) => {
   const issue = rejectCodeIssue(code);
   if (issue) {
     context.addIssue({ code: "custom", message: issue });
@@ -2158,7 +2281,7 @@ var rejectCodeSchema = z14.string().superRefine((code, context) => {
 });
 
 // src/sdk-runtime.ts
-import * as z15 from "zod";
+import * as z17 from "zod";
 var questScaleLimits = {
   quests: 1e3,
   questTypes: 200,
@@ -2169,22 +2292,22 @@ var sdkRuntimeLimits = {
   /** Characters of module source, summed over all modules. */
   size: 2e6
 };
-var sha256 = z15.string().regex(/^[0-9a-f]{64}$/);
-var sdkRuntimeModulePathSchema = z15.string().max(200).regex(/^[a-z0-9_][a-z0-9_.-]*(\/[a-z0-9_][a-z0-9_.-]*)*\.js$/i).refine(
+var sha256 = z17.string().regex(/^[0-9a-f]{64}$/);
+var sdkRuntimeModulePathSchema = z17.string().max(200).regex(/^[a-z0-9_][a-z0-9_.-]*(\/[a-z0-9_][a-z0-9_.-]*)*\.js$/i).refine(
   (path) => !path.split("/").some((part) => part === "." || part === ".."),
   "Runtime module paths cannot contain . or .. segments"
 );
-var sdkRuntimeReferenceSchema = z15.object({
+var sdkRuntimeReferenceSchema = z17.object({
   digest: sha256,
   /** The SDK version that built the runtime, for display. The digest is what pins it. */
-  sdkVersion: z15.string().min(1).max(64)
+  sdkVersion: z17.string().min(1).max(64)
 }).strict();
-var sdkRuntimeModulesSchema = z15.record(sdkRuntimeModulePathSchema, z15.string().min(1)).refine((modules) => {
+var sdkRuntimeModulesSchema = z17.record(sdkRuntimeModulePathSchema, z17.string().min(1)).refine((modules) => {
   const entries = Object.values(modules);
   return entries.length > 0 && entries.length <= sdkRuntimeLimits.modules && entries.reduce((sum, source) => sum + source.length, 0) <= sdkRuntimeLimits.size;
 }, `A runtime has 1 to ${sdkRuntimeLimits.modules} modules and at most ${sdkRuntimeLimits.size} characters of source`);
 var sdkRuntimeSchema = sdkRuntimeReferenceSchema.extend({
-  zodVersion: z15.string().min(1).max(64),
+  zodVersion: z17.string().min(1).max(64),
   modules: sdkRuntimeModulesSchema
 }).strict();
 async function sdkRuntimeDigest(modules) {
@@ -2199,66 +2322,260 @@ async function sdkRuntimeDigest(modules) {
 }
 
 // src/completion.ts
-import * as z16 from "zod";
-var name = z16.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
-var completionPolicySchema = z16.discriminatedUnion("kind", [
+import * as z18 from "zod";
+var name = z18.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
+var completionPolicySchema = z18.discriminatedUnion("kind", [
   streakPolicySchema,
   counterPolicySchema,
-  z16.object({ kind: z16.literal("once") }).strict(),
-  z16.object({ kind: z16.literal("keyed") }).strict()
+  z18.object({ kind: z18.literal("once") }).strict(),
+  z18.object({ kind: z18.literal("keyed") }).strict()
 ]);
-var completionKeySchema = z16.string().min(1).max(500);
-var budgetSchema = z16.object({
+var completionKeySchema = z18.string().min(1).max(500);
+var budgetSchema = z18.object({
   id: name,
-  scope: z16.enum(["member", "project"]),
+  scope: z18.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: z16.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  cost: z16.union([
-    z16.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-    z16.object({ balance: name }).strict()
+  limit: z18.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  cost: z18.union([
+    z18.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    z18.object({ balance: name }).strict()
   ])
 }).strict();
-var memberCompletionSchema = z16.object({
-  quest: z16.string().min(1).max(200),
+var authorBudgetSchema = budgetSchema.extend({ scope: z18.literal("author") }).strict();
+var memberCompletionSchema = z18.object({
+  quest: z18.string().min(1).max(200),
   key: completionKeySchema,
-  completedAt: z16.number().int().nonnegative().safe().nullable()
+  completedAt: z18.number().int().nonnegative().safe().nullable()
 });
 var maxMemberCompletions = 100;
 
 // src/integrations.ts
-import * as z17 from "zod";
-var evaluatorIntegrationProviderSchema = z17.enum(["discord", "x"]);
-var integrationProviderSchema = z17.enum(["discord"]);
-var discordServerSchema = z17.object({
-  id: z17.string().regex(/^[0-9]{1,20}$/),
-  name: z17.string().min(1),
-  icon: z17.string().nullable()
-});
-var projectIntegrationSchema = z17.object({
+import * as z19 from "zod";
+var evaluatorIntegrationProviderSchema = z19.enum(["discord", "x"]);
+var integrationProviderSchema = z19.enum(["discord"]);
+var discordServerSchema = z19.object({
+  id: z19.string().regex(/^[0-9]{1,20}$/),
+  name: z19.string().min(1),
+  icon: z19.string().nullable()
+});
+var projectIntegrationSchema = z19.object({
   provider: integrationProviderSchema,
-  configured: z17.boolean(),
-  status: z17.enum(["disconnected", "ready", "attention"]),
-  revision: z17.number().int().nonnegative(),
+  configured: z19.boolean(),
+  status: z19.enum(["disconnected", "ready", "attention"]),
+  revision: z19.number().int().nonnegative(),
   server: discordServerSchema.nullable(),
-  issue: z17.string().nullable(),
-  connectedAt: z17.number().default(0)
+  issue: z19.string().nullable(),
+  connectedAt: z19.number().default(0)
+});
+
+// src/announcement-template.ts
+var announcementPlaceholders = [
+  "beneficiary",
+  "author",
+  "quest",
+  "points",
+  "rewards"
+];
+var placeholderNames = new Set(announcementPlaceholders);
+function parseAnnouncementTemplate(text) {
+  const segments = [];
+  let literal18 = "";
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === "{" && text[index + 1] === "{") {
+      literal18 += "{";
+      index += 2;
+      continue;
+    }
+    if (char === "}" && text[index + 1] === "}") {
+      literal18 += "}";
+      index += 2;
+      continue;
+    }
+    if (char === "}") {
+      return { error: "Write }} for a literal } in an announcement" };
+    }
+    if (char !== "{") {
+      literal18 += char;
+      index += 1;
+      continue;
+    }
+    const end = text.indexOf("}", index);
+    const name2 = end === -1 ? "" : text.slice(index + 1, end);
+    if (!placeholderNames.has(name2)) {
+      return {
+        error: `Unknown announcement placeholder {${name2}}: use ${announcementPlaceholders.map((known) => `{${known}}`).join(", ")}, or {{ for a literal {`
+      };
+    }
+    if (literal18) {
+      segments.push({ kind: "text", text: literal18 });
+      literal18 = "";
+    }
+    segments.push({
+      kind: "placeholder",
+      name: name2
+    });
+    index = end + 1;
+  }
+  if (literal18) {
+    segments.push({ kind: "text", text: literal18 });
+  }
+  return { segments };
+}
+
+// src/telegram.ts
+import * as z20 from "zod";
+var telegramSignInMethodsSchema = z20.object({
+  /** Telegram Login, the OpenID Connect sign-in Domino configures for the platform. */
+  login: z20.boolean(),
+  /** Mini App sign-in, which the project enables in Console with its bot's ID. */
+  miniApp: z20.boolean()
+});
+var telegramAccountConnectionSchema = accountConnectionSchema.extend({
+  provider: z20.literal("telegram")
+});
+var telegramInitDataSchema = z20.string().min(1, "Pass the Mini App's Telegram.WebApp.initData").max(8192);
+var telegramMiniAppSignInSchema = z20.object({
+  initData: telegramInitDataSchema,
+  mode: z20.enum(["sign-in", "connect"])
+}).strict();
+var telegramChatIdSchema = z20.string().regex(
+  /^-?[1-9][0-9]{0,19}$/,
+  "Use the chat's numeric ID, such as -1001234567890"
+);
+var telegramChatSchema = z20.object({
+  /** The numeric chat ID, as a string. */
+  id: telegramChatIdSchema,
+  /** `group`, `supergroup` or `channel`; a later Telegram may add others. */
+  type: z20.string(),
+  title: z20.string(),
+  /** The public @username, without the @, or null for a private chat. */
+  username: z20.string().nullable(),
+  status: z20.string(),
+  issue: z20.string().nullable(),
+  /**
+   * Whether Domino's bot may post in the chat, as announcements do: as an administrator of a
+   * group, or with the right to post in a channel. Absent from older Relay versions.
+   */
+  canPost: z20.boolean().optional(),
+  connectedAt: z20.number()
+});
+var telegramChatsSchema = z20.object({
+  configured: z20.boolean(),
+  /** Domino's bot, the one operators add to their chats. */
+  bot: z20.object({ username: z20.string() }).nullable(),
+  chats: z20.array(telegramChatSchema)
+});
+var telegramChatConnectionSchema = z20.object({
+  url: z20.string(),
+  expiresAt: z20.number()
+});
+var telegramMemberInputSchema = z20.object({
+  chat: z20.string().regex(
+    /^(-?[1-9][0-9]{0,19}|@[A-Za-z][A-Za-z0-9_]{3,31})$/,
+    "Name a chat the project connected, by its numeric ID or @username"
+  )
+}).strict();
+var telegramChatMemberSchema = z20.object({
+  /** The numeric Telegram user ID. */
+  userId: z20.string(),
+  username: z20.string().nullable(),
+  status: z20.custom(
+    (value) => typeof value === "string"
+  ),
+  /** Whether they are in the chat now: a creator, administrator, member, or restricted member. */
+  isMember: z20.boolean(),
+  /** Whether they are its creator or an administrator. */
+  isAdmin: z20.boolean(),
+  /** When a paid subscription or a restriction ends, epoch milliseconds; null when it does not. */
+  untilDate: z20.number().nullable()
+});
+var telegramReactionDataSchema = z20.object({
+  /** The chat's numeric ID, as a string. */
+  chatId: z20.string(),
+  /** `group` or `supergroup`: channel reactions are anonymous and never recorded. */
+  chatType: z20.string(),
+  messageId: z20.number(),
+  /** `emoji`, `custom_emoji` or `paid`. */
+  reactionType: z20.string(),
+  /** The emoji, such as "❤", for an `emoji` reaction; null otherwise. */
+  emoji: z20.string().nullable(),
+  /** The custom emoji's ID for a `custom_emoji` reaction; null otherwise. */
+  customEmojiId: z20.string().nullable(),
+  /**
+   * `creator` or `administrator` for one of the chat's administrators, read at most ten minutes
+   * before Relay recorded the reaction; `member` for anyone else.
+   */
+  reactorStatus: z20.string(),
+  /** Whether the reactor was the chat's creator or an administrator then. */
+  reactorIsAdmin: z20.boolean()
+});
+var telegramMessageDataSchema = z20.object({
+  /** The chat's numeric ID, as a string. */
+  chatId: z20.string(),
+  /** `group` or `supergroup`: channel posts are authored by the channel and never recorded. */
+  chatType: z20.string(),
+  messageId: z20.number(),
+  /** The ID of the message it replies to in the same chat; null when it is not a reply. */
+  replyToMessageId: z20.number().nullable(),
+  /**
+   * The message thread it belongs to: the forum topic in a supergroup with topics, or the reply
+   * thread otherwise. Null when Telegram names none.
+   */
+  threadId: z20.number().nullable()
+});
+
+// src/announcements.ts
+import * as z21 from "zod";
+var announcementTextSchema = z21.string().trim().min(1).max(1e3).superRefine((text, context) => {
+  const parsed = parseAnnouncementTemplate(text);
+  if ("error" in parsed) {
+    context.addIssue({ code: "custom", message: parsed.error });
+  }
 });
+var announcementFields = {
+  action: z21.literal("post-message"),
+  text: announcementTextSchema,
+  /**
+   * Post as a reply to the message that triggered the completion: the message itself, or the
+   * message a reaction was added to. Only when that message is in the same chat or channel; the
+   * post is a plain message otherwise.
+   */
+  replyToTriggeringMessage: z21.boolean().optional()
+};
+var telegramAnnouncementSchema = z21.strictObject({
+  provider: z21.literal("telegram"),
+  /** The chat's numeric ID, as `settings.telegramChat()` holds it. */
+  chat: telegramChatIdSchema,
+  ...announcementFields
+});
+var discordAnnouncementSchema = z21.strictObject({
+  provider: z21.literal("discord"),
+  /** The channel's ID, as a `discord.channels()` resource setting holds it. */
+  channel: z21.string().regex(/^[0-9]{1,20}$/),
+  ...announcementFields
+});
+var announcementSchema = z21.discriminatedUnion("provider", [
+  telegramAnnouncementSchema,
+  discordAnnouncementSchema
+]);
 
 // src/wallet.ts
-import * as z18 from "zod";
-var solanaAddressSchema = z18.string().min(32).max(44).regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
-var walletChainSchema = z18.enum(["solana", "eip155", "cosmos"]);
+import * as z22 from "zod";
+var solanaAddressSchema = z22.string().min(32).max(44).regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
+var walletChainSchema = z22.enum(["solana", "eip155", "cosmos"]);
 var cosmosNetworkPattern = /^cosmos:[-_a-zA-Z0-9]{1,32}$/;
-var cosmosNetworkSchema = z18.custom(
+var cosmosNetworkSchema = z22.custom(
   (value) => typeof value === "string" && cosmosNetworkPattern.test(value),
   "Use a Cosmos network: cosmos:<chain ID>"
 );
-var cosmosDenomSchema = z18.string().regex(
+var cosmosDenomSchema = z22.string().regex(
   /^[a-zA-Z][a-zA-Z0-9/:._-]{2,127}$/,
   "Use a Cosmos bank denomination such as uatom or uosmo"
 );
@@ -2284,51 +2601,51 @@ function cosmosChain(chain) {
   return { ...value, network };
 }
 var solanaMainnet = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
-var evmAddressSchema = z18.string().regex(/^0x[0-9a-fA-F]{40}$/);
-var cosmosAddressSchema = z18.string().min(8).max(90).regex(
+var evmAddressSchema = z22.string().regex(/^0x[0-9a-fA-F]{40}$/);
+var cosmosAddressSchema = z22.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 = z18.discriminatedUnion("chain", [
-  z18.object({ chain: z18.literal("solana"), address: solanaAddressSchema }).strict(),
-  z18.object({
-    chain: z18.literal("eip155"),
+var walletAddressInputSchema = z22.discriminatedUnion("chain", [
+  z22.object({ chain: z22.literal("solana"), address: solanaAddressSchema }).strict(),
+  z22.object({
+    chain: z22.literal("eip155"),
     address: evmAddressSchema,
     /** Shown in the sign-in message's Chain ID line only: links are chain-agnostic. Defaults to 1. */
-    chainId: z18.number().int().positive().safe().optional()
+    chainId: z22.number().int().positive().safe().optional()
   }).strict(),
-  z18.object({
-    chain: z18.literal("cosmos"),
+  z22.object({
+    chain: z22.literal("cosmos"),
     network: cosmosNetworkSchema,
     address: cosmosAddressSchema
   }).strict()
 ]);
-var walletMessageChallengeSchema = z18.object({
-  id: z18.string().min(1).max(200),
-  purpose: z18.enum(["link", "sign-in"]),
+var walletMessageChallengeSchema = z22.object({
+  id: z22.string().min(1).max(200),
+  purpose: z22.enum(["link", "sign-in"]),
   chain: walletChainSchema,
   network: cosmosNetworkSchema.nullable(),
   /** Canonical (base58, EIP-55 or lowercase bech32). The signer must sign with this address. */
-  address: z18.string(),
-  message: z18.string().max(4096),
-  expiresAt: z18.number().int()
+  address: z22.string(),
+  message: z22.string().max(4096),
+  expiresAt: z22.number().int()
 });
-var walletSignatureSchema = z18.object({
-  challenge: z18.string().min(1).max(200),
+var walletSignatureSchema = z22.object({
+  challenge: z22.string().min(1).max(200),
   /** solana: base58, 64 bytes · eip155: 0x and 130 hex digits (65 bytes) · cosmos: base64, 64 bytes (r‖s) */
-  signature: z18.string().min(1).max(256),
+  signature: z22.string().min(1).max(256),
   /** cosmos only: the base64 33-byte compressed secp256k1 key from signArbitrary's pub_key.value */
-  publicKey: z18.string().max(128).optional()
+  publicKey: z22.string().max(128).optional()
 }).strict();
-var linkedWalletSchema = z18.object({
+var linkedWalletSchema = z22.object({
   chain: walletChainSchema,
   network: cosmosNetworkSchema.nullable(),
-  address: z18.string(),
-  verifiedAt: z18.number().int().nonnegative(),
-  revision: z18.number().int().positive(),
+  address: z22.string(),
+  verifiedAt: z22.number().int().nonnegative(),
+  revision: z22.number().int().positive(),
   /** True when this wallet can sign in: it was first used through wallet sign-in. Linking never enables sign-in. */
-  signIn: z18.boolean()
+  signIn: z22.boolean()
 });
-var walletUnlinkInputSchema = z18.object({ chain: walletChainSchema, address: z18.string().min(1).max(100) }).strict();
+var walletUnlinkInputSchema = z22.object({ chain: walletChainSchema, address: z22.string().min(1).max(100) }).strict();
 async function walletAddressInput(signer) {
   const address = await signer.address();
   switch (signer.chain) {
@@ -2352,8 +2669,8 @@ async function walletAddressInput(signer) {
 }
 var WALLETS_PER_CHAIN = 5;
 var walletSignInFamilies = ["solana", "eip155", "cosmos"];
-var walletSignInNetworkSchema = z18.enum(walletSignInFamilies);
-var walletSignInNetworksSchema = z18.array(walletSignInNetworkSchema).max(walletSignInFamilies.length).refine((values2) => new Set(values2).size === values2.length, {
+var walletSignInNetworkSchema = z22.enum(walletSignInFamilies);
+var walletSignInNetworksSchema = z22.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))
@@ -2378,41 +2695,361 @@ function caip10(wallet, network) {
 function isEvmChainId(value) {
   return /^eip155:[1-9][0-9]{0,15}$/.test(value);
 }
-var evmChainIdSchema = z18.custom(
+var evmChainIdSchema = z22.custom(
   (value) => typeof value === "string" && isEvmChainId(value),
   'Use an EVM chain ID such as "eip155:8453"'
 );
-var units = z18.string().regex(/^(0|[1-9][0-9]*)$/);
+var units = z22.string().regex(/^(0|[1-9][0-9]*)$/);
 var walletBalanceSchema = responseShape(
-  z18.object({
+  z22.object({
     /** Canonical CAIP-2 ID for Solana, EVM or a supported Cosmos SDK chain. */
-    chain: z18.string(),
+    chain: z22.string(),
     /** The canonical mint, EIP-55 contract or Cosmos bank denom; null for a native coin. */
-    token: z18.string().nullable(),
+    token: z22.string().nullable(),
     /** Null when token metadata does not report decimals. */
-    decimals: z18.number().int().min(0).max(255).nullable(),
+    decimals: z22.number().int().min(0).max(255).nullable(),
     /** The sum over `wallets`. */
     total: units,
-    wallets: z18.array(
-      z18.object({ address: z18.string(), amount: units }).strict()
+    wallets: z22.array(
+      z22.object({ address: z22.string(), amount: units }).strict()
     ),
     /** Solana: lowest slot. EVM: approximate latest block. Cosmos: the fixed queried block. */
-    at: z18.object({ kind: z18.enum(["slot", "block"]), number: units }).strict(),
-    observedAt: z18.number().int().nonnegative()
+    at: z22.object({ kind: z22.enum(["slot", "block"]), number: units }).strict(),
+    observedAt: z22.number().int().nonnegative()
+  }).strict()
+);
+var walletBalanceSampleSchema = z22.object({
+  /** The balance in base units, as a decimal integer string. */
+  amount: z22.string(),
+  /** The token's decimals; null when token metadata does not report them. */
+  decimals: z22.number().int().min(0).max(255).nullable(),
+  /**
+   * Where the run read: the EVM block number or Cosmos height every wallet of the run was read at,
+   * or on Solana the slot this wallet's answer reflects (at or after the run's pinned slot), as
+   * a decimal integer string.
+   */
+  block: z22.string()
+});
+var nftCollectionPattern = /^(eip155:[1-9][0-9]{0,15})\/(erc721|erc1155):(0x[0-9a-fA-F]{40})(?:\/(0|[1-9][0-9]{0,77}))?$/;
+var solanaNftCollectionPrefix = `${solanaMainnet}/nft:`;
+var maxTokenId = 2n ** 256n - 1n;
+function parseNftCollection(value) {
+  if (value.startsWith(solanaNftCollectionPrefix)) {
+    const mint = value.slice(solanaNftCollectionPrefix.length);
+    return solanaAddressSchema.safeParse(mint).success ? { chain: solanaMainnet, standard: "metaplex", mint } : null;
+  }
+  const match = nftCollectionPattern.exec(value);
+  if (!match) {
+    return null;
+  }
+  const [, chain, standard, contract, tokenId] = match;
+  if (standard === "erc1155" !== (tokenId !== void 0) || tokenId !== void 0 && BigInt(tokenId) > maxTokenId) {
+    return null;
+  }
+  return {
+    chain,
+    standard,
+    contract,
+    tokenId: tokenId ?? null
+  };
+}
+function isNftCollection(value) {
+  return parseNftCollection(value) !== null;
+}
+var walletNftsSchema = responseShape(
+  z22.object({
+    /** The collection read, in canonical form: an EVM contract EIP-55 checksummed. */
+    collection: z22.string(),
+    /** The collection's chain, canonical CAIP-2. */
+    chain: z22.string(),
+    standard: z22.enum(["erc721", "erc1155", "metaplex"]),
+    /** How many the wallets hold together: the sum over `wallets`. */
+    total: units,
+    wallets: z22.array(
+      z22.object({ address: z22.string(), count: units }).strict()
+    ),
+    /** Solana: the lowest slot of the reads. EVM: the approximate latest block. */
+    at: z22.object({ kind: z22.enum(["slot", "block"]), number: units }).strict(),
+    observedAt: z22.number().int().nonnegative()
+  }).strict()
+);
+var integerType = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
+var bytesType = /^bytes([1-9]|[12][0-9]|3[0-2])?$/;
+function elementaryType(type) {
+  const integer = integerType.exec(type);
+  if (integer) {
+    return `${integer[1]}${integer[2] ?? "256"}`;
+  }
+  return type === "address" || type === "bool" || type === "string" || bytesType.test(type) ? type : null;
+}
+function parameterType(parameter) {
+  const match = /^([a-z0-9]+)(?:\s+[A-Za-z_$][A-Za-z0-9_$]*)?$/.exec(
+    parameter.trim()
+  );
+  return match ? elementaryType(match[1]) : null;
+}
+function parseContractFunction(signature) {
+  const match = /^function\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\(([^()]*)\)\s+(?:external\s+)?(view|pure)\s+returns\s*\(([^()]*)\)$/.exec(
+    signature.trim()
+  );
+  if (!match) {
+    return null;
+  }
+  const [, name2, parameters, mutability, returned] = match;
+  const inputs = parameters.trim() ? parameters.split(",").map(parameterType) : [];
+  const output = returned.includes(",") ? null : parameterType(returned);
+  if (inputs.length > 16 || inputs.some((type) => type === null) || !output || !(output === "bool" || output === "address" || integerType.test(output))) {
+    return null;
+  }
+  return {
+    name: name2,
+    inputs,
+    returns: output,
+    mutability,
+    signature: `function ${name2}(${inputs.join(",")}) ${mutability} returns (${output})`
+  };
+}
+function parseContractCall(value) {
+  const match = /^(eip155:[1-9][0-9]{0,15}):(0x[0-9a-fA-F]{40}) (function .+)$/.exec(value);
+  const parsed = match && value.length <= 400 ? parseContractFunction(match[3]) : null;
+  return parsed ? {
+    chain: match[1],
+    contract: match[2],
+    function: parsed
+  } : null;
+}
+function isContractCall(value) {
+  return parseContractCall(value) !== null;
+}
+var signedUnits = z22.string().regex(/^(0|-?[1-9][0-9]*)$/);
+var walletCallSchema = responseShape(
+  z22.object({
+    /** The call read, canonical: the contract EIP-55 checksummed, the signature without names. */
+    call: z22.string(),
+    /** The contract's chain, canonical CAIP-2. */
+    chain: z22.string(),
+    /** The contract, EIP-55 checksummed. */
+    contract: z22.string(),
+    /** The return value's ABI type, such as `"uint256"` or `"bool"`. */
+    returns: z22.string(),
+    /** The sum of the wallets' values when the function returns an integer; null otherwise. */
+    total: signedUnits.nullable(),
+    wallets: z22.array(
+      z22.object({
+        address: z22.string(),
+        /** An integer as a decimal string, a bool, or an EIP-55 address. */
+        value: z22.union([z22.string(), z22.boolean()])
+      }).strict()
+    ),
+    /** The block every call read. */
+    at: z22.object({ kind: z22.enum(["block"]), number: units }).strict(),
+    observedAt: z22.number().int().nonnegative()
+  }).strict()
+);
+var walletDelegationsSchema = responseShape(
+  z22.object({
+    chain: z22.string(),
+    /** The chain's staking denomination, such as `uatom`: every amount is in its base units. */
+    denom: z22.string(),
+    /** The validator the read counted, or null for every validator. */
+    validator: z22.string().nullable(),
+    /** The sum over `wallets`. */
+    total: units,
+    wallets: z22.array(
+      z22.object({ address: z22.string(), amount: units }).strict()
+    ),
+    /** What the wallets delegate to each validator, summed over the wallets; none at zero. */
+    validators: z22.array(
+      z22.object({ validator: z22.string(), amount: units }).strict()
+    ),
+    /** The block every request read. */
+    at: z22.object({ kind: z22.enum(["block"]), number: units }).strict(),
+    observedAt: z22.number().int().nonnegative()
+  }).strict()
+);
+var contractEventPattern = /^(eip155:[1-9][0-9]{0,15}):(0x[0-9a-fA-F]{40})\s+(?:event\s+)?([A-Za-z_$][A-Za-z0-9_$]*)\s*\(([^()]*)\)\s*;?$/;
+var eventArgumentPattern = /^([a-z0-9]+(?:\[[0-9]*\])*)(\s+indexed)?\s+([A-Za-z_$][A-Za-z0-9_$]*)$/;
+function eventArgumentType(type) {
+  const match = /^([a-z]+)([0-9]*)((?:\[[0-9]*\])*)$/.exec(type);
+  if (!match) {
+    return null;
+  }
+  const [, base2, size2, arrays] = match;
+  const bits = size2 === "" ? 256 : Number(size2);
+  let canonical = null;
+  if (size2.startsWith("0")) {
+    return null;
+  }
+  if (base2 === "uint" || base2 === "int") {
+    canonical = bits >= 8 && bits <= 256 && bits % 8 === 0 ? base2 + bits : null;
+  } else if (base2 === "bytes") {
+    canonical = size2 === "" || bits <= 32 ? base2 + size2 : null;
+  } else if ((base2 === "address" || base2 === "bool" || base2 === "string") && size2 === "") {
+    canonical = base2;
+  }
+  return canonical && /^(\[([1-9][0-9]*)?\])?$/.test(arrays) ? canonical + arrays : null;
+}
+function parseContractEvent(value) {
+  const match = contractEventPattern.exec(value.trim());
+  if (!match) {
+    return null;
+  }
+  const [, chain, contract, name2, list] = match;
+  const inputs = [];
+  for (const part of list.trim() ? list.split(",") : []) {
+    const argument = eventArgumentPattern.exec(part.trim());
+    const type = argument && eventArgumentType(argument[1]);
+    if (!argument || !type || argument[3] === "indexed" || inputs.some((input) => input.name === argument[3])) {
+      return null;
+    }
+    inputs.push({ name: argument[3], type, indexed: !!argument[2] });
+  }
+  const indexed = inputs.filter((input) => input.indexed);
+  if (indexed.length > 3 || !indexed.some((input) => input.type === "address")) {
+    return null;
+  }
+  return {
+    chain,
+    contract,
+    name: name2,
+    inputs,
+    signature: `${name2}(${inputs.map((input) => input.type).join(",")})`
+  };
+}
+function isContractEvent(value) {
+  return parseContractEvent(value) !== null;
+}
+var maxWalletEventLogs = 1e3;
+var maxWalletEventLookback = 30 * 24 * 60 * 60 * 1e3;
+var walletEventScalarSchema = z22.union([z22.string(), z22.boolean()]);
+var walletEventValueSchema = z22.union([
+  walletEventScalarSchema,
+  z22.array(walletEventScalarSchema)
+]);
+var walletEventsSchema = responseShape(
+  z22.object({
+    /** The event read, in canonical form: the contract EIP-55 checksummed. */
+    event: z22.string(),
+    /** The event's chain, canonical CAIP-2. */
+    chain: z22.string(),
+    contract: z22.string(),
+    /** The earliest block time read, in epoch milliseconds: `since`, or the activation. */
+    since: z22.number().int().nonnegative(),
+    /**
+     * The newest block read: the chain's `finalized` block, or its `safe` block on a chain without
+     * finality. Events in later blocks are not read yet.
+     */
+    at: z22.object({ kind: z22.enum(["block"]), number: units }).strict(),
+    finality: z22.enum(["finalized", "safe"]),
+    /** The matching events, oldest first. */
+    logs: z22.array(
+      z22.object({
+        /** The member's linked wallet the `account` argument names. */
+        wallet: z22.string(),
+        block: units,
+        /** The block's time, in epoch milliseconds. */
+        timestamp: z22.number().int().nonnegative(),
+        tx: z22.string(),
+        logIndex: z22.number().int().nonnegative(),
+        /** Every argument, by name. */
+        args: z22.record(z22.string(), walletEventValueSchema)
+      }).strict()
+    ).max(maxWalletEventLogs),
+    observedAt: z22.number().int().nonnegative()
+  }).strict()
+);
+function isSolanaProgram(value) {
+  return solanaAddressSchema.safeParse(value).success;
+}
+var anchorIdlSchema = z22.record(z22.string(), z22.json());
+var solanaProgramIdlSchema = z22.object({
+  /** The program the setting held when the IDL was stored. */
+  program: z22.string(),
+  source: z22.string(),
+  idl: anchorIdlSchema
+}).strict();
+var maxWalletTransactions = 1e3;
+var maxWalletTransactionLookback = 30 * 24 * 60 * 60 * 1e3;
+var walletTransactionsSchema = responseShape(
+  z22.object({
+    program: z22.string(),
+    /** Solana mainnet's CAIP-2 ID. */
+    chain: z22.string(),
+    /** The mint whose associated token accounts were read, or null for the wallets themselves. */
+    mint: z22.string().nullable(),
+    /** The earliest block time read, in epoch milliseconds: `since`, or the activation. */
+    since: z22.number().int().nonnegative(),
+    /** The newest finalized slot read. Transactions in later slots are not read yet. */
+    at: z22.object({ kind: z22.enum(["slot"]), number: units }).strict(),
+    /**
+     * False when a wallet had more than {@link maxWalletTransactions} transactions to read since
+     * `since`: its newest ones are returned and older ones are not.
+     */
+    complete: z22.boolean(),
+    /** The matching transactions, oldest first: one entry per linked wallet a transaction touched. */
+    transactions: z22.array(
+      z22.object({
+        /** The member's linked wallet whose history holds the transaction. */
+        wallet: z22.string(),
+        signature: z22.string(),
+        slot: units,
+        /** The block's time, in epoch milliseconds. */
+        timestamp: z22.number().int().nonnegative(),
+        /**
+         * Whether the wallet signed the transaction. False for one someone else signed that only
+         * touched the wallet, such as a transfer into it. Check it before rewarding an action.
+         * Results captured before Relay reported it read as false.
+         */
+        signer: z22.boolean().default(false),
+        /**
+         * Every program the transaction invoked, in call order: each top-level instruction's
+         * program, then the programs it called.
+         */
+        programs: z22.array(z22.string()),
+        /**
+         * The wallet's balance changes: `"SOL"` from its lamports (rent included, the fee left out
+         * when the wallet paid it), and
+         * each mint from the token accounts it owns. Mints whose balance did not change are left out.
+         */
+        balanceChanges: z22.array(
+          z22.object({ mint: z22.string(), delta: signedUnits }).strict()
+        ),
+        /**
+         * The program's instructions in the transaction, top-level and inner, in call order,
+         * decoded with the program's Anchor IDL. Instructions the IDL does not describe are left
+         * out. Absent when the program's setting has no IDL.
+         */
+        instructions: z22.array(
+          z22.object({
+            /** The instruction's name, as the IDL spells it. */
+            name: z22.string(),
+            /**
+             * Its arguments by name: integers up to 32 bits and floats as numbers, wider
+             * integers as decimal strings, public keys in base58, `bytes` and arrays as arrays,
+             * an absent option as null, and an enum as `{ Variant: fields }`.
+             */
+            args: z22.record(z22.string(), z22.json()),
+            /** The accounts the IDL names, by name: each a base58 address. */
+            accounts: z22.record(z22.string(), z22.string())
+          }).strict()
+        ).optional()
+      }).strict()
+    ),
+    observedAt: z22.number().int().nonnegative()
   }).strict()
 );
 
 // src/submission-input.ts
-import * as z19 from "zod";
-var textOptionsSchema = z19.object({
-  required: z19.boolean().default(true),
-  minLength: z19.number().int().min(0).max(1e4).default(1),
-  maxLength: z19.number().int().min(1).max(1e4).default(1e4)
+import * as z23 from "zod";
+var textOptionsSchema = z23.object({
+  required: z23.boolean().default(true),
+  minLength: z23.number().int().min(0).max(1e4).default(1),
+  maxLength: z23.number().int().min(1).max(1e4).default(1e4)
 }).strict().refine(
   (v) => v.minLength <= v.maxLength,
   "minLength must not exceed maxLength"
 );
-var hostSchema = z19.string().min(1).max(253).refine((host) => {
+var hostSchema = z23.string().min(1).max(253).refine((host) => {
   if (!/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/i.test(host) || host.includes("..")) {
     return false;
   }
@@ -2423,13 +3060,13 @@ var hostSchema = z19.string().min(1).max(253).refine((host) => {
     return false;
   }
 }, "Use a hostname without a scheme, path, port, or wildcard");
-var urlOptionsSchema = z19.object({
-  required: z19.boolean().default(true),
-  allowedHosts: z19.array(hostSchema).min(1).max(100).optional()
+var urlOptionsSchema = z23.object({
+  required: z23.boolean().default(true),
+  allowedHosts: z23.array(hostSchema).min(1).max(100).optional()
 }).strict();
-var textEvidenceSchema = z19.object({ kind: z19.literal("text"), value: z19.string().max(1e4) }).strict();
-var urlEvidenceSchema = z19.object({ kind: z19.literal("url"), value: z19.string().max(2048) }).strict();
-var valueEvidenceSchema = z19.discriminatedUnion("kind", [
+var textEvidenceSchema = z23.object({ kind: z23.literal("text"), value: z23.string().max(1e4) }).strict();
+var urlEvidenceSchema = z23.object({ kind: z23.literal("url"), value: z23.string().max(2048) }).strict();
+var valueEvidenceSchema = z23.discriminatedUnion("kind", [
   textEvidenceSchema,
   urlEvidenceSchema
 ]);
@@ -2492,22 +3129,22 @@ function xPostId(value) {
 }
 
 // src/quiz.ts
-import * as z20 from "zod";
-var quizId = z20.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
-var quizChoiceSchema = z20.object({ id: quizId, label: z20.string().trim().min(1).max(500) }).strict();
-var quizQuestionSchema = z20.object({
+import * as z24 from "zod";
+var quizId = z24.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
+var quizChoiceSchema = z24.object({ id: quizId, label: z24.string().trim().min(1).max(500) }).strict();
+var quizQuestionSchema = z24.object({
   id: quizId,
-  prompt: z20.string().trim().min(1).max(1e3),
-  choices: z20.array(quizChoiceSchema).min(2).max(8).refine(
+  prompt: z24.string().trim().min(1).max(1e3),
+  choices: z24.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 = z20.array(quizQuestionSchema).min(1).max(20).refine(
+var quizQuestionsSchema = z24.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 = z20.array(
+var quizContentSchema = z24.array(
   quizQuestionSchema.extend({ correct: quizId }).refine(
     (question) => question.choices.some((choice) => choice.id === question.correct),
     "Choose a correct answer from the available choices"
@@ -2518,107 +3155,116 @@ var quizContentSchema = z20.array(
 );
 
 // src/resources.ts
-import * as z21 from "zod";
-var resourceSourceSchema = z21.union([
-  z21.strictObject({
-    provider: z21.literal("domino"),
-    resource: z21.literal("point-ledger")
+import * as z25 from "zod";
+var resourceSourceSchema = z25.union([
+  z25.strictObject({
+    provider: z25.literal("domino"),
+    resource: z25.literal("point-ledger")
   }),
   discordResourceSourceSchema
 ]);
-var resourceRequestSchema = z21.object({
+var resourceRequestSchema = z25.object({
   source: resourceSourceSchema,
-  query: z21.string().max(100).optional(),
-  cursor: z21.string().regex(/^\d{1,6}$/).optional(),
-  ids: z21.array(z21.string().min(1).max(100)).max(50).optional()
+  query: z25.string().max(100).optional(),
+  cursor: z25.string().regex(/^\d{1,6}$/).optional(),
+  ids: z25.array(z25.string().min(1).max(100)).max(50).optional()
 }).strict();
-var resourceOptionsSchema = z21.object({
-  revision: z21.number().int(),
-  options: z21.array(
-    z21.object({
-      id: z21.string(),
-      label: z21.string(),
-      description: z21.string().optional(),
-      group: z21.string().optional(),
-      disabledReason: z21.string().optional()
+var resourceOptionsSchema = z25.object({
+  revision: z25.number().int(),
+  options: z25.array(
+    z25.object({
+      id: z25.string(),
+      label: z25.string(),
+      description: z25.string().optional(),
+      group: z25.string().optional(),
+      disabledReason: z25.string().optional()
     })
   ),
   /** Pass back as `cursor` for the next page; null on the last one. */
-  nextCursor: z21.string().nullable().default(null),
+  nextCursor: z25.string().nullable().default(null),
   /** @deprecated Use `nextCursor`. Removed in 2.0.0. */
-  cursor: z21.string().nullable()
+  cursor: z25.string().nullable()
 });
 
 // src/settings.ts
-import * as z23 from "zod";
+import * as z27 from "zod";
 
 // src/setting-values.ts
-import * as z22 from "zod";
-var settingInstant = z22.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
-var settingResourceId = z22.union([
-  z22.literal(""),
-  z22.string().regex(/^\S{1,200}$/)
+import * as z26 from "zod";
+var settingInstant = offsetDateTimeSchema().transform(
+  (value) => new Date(value).toISOString()
+);
+var settingResourceId = z26.union([
+  z26.literal(""),
+  z26.string().regex(/^\S{1,200}$/)
 ]);
 
 // src/settings.ts
-var base = { label: z23.string().min(1), description: z23.string().optional() };
-var settingFieldSchema = z23.discriminatedUnion("kind", [
-  z23.object({
+var base = { label: z27.string().min(1), description: z27.string().optional() };
+var settingFieldSchema = z27.discriminatedUnion("kind", [
+  z27.object({
     ...base,
-    kind: z23.literal("point-ledger"),
-    default: identifier.or(z23.literal(""))
+    kind: z27.literal("point-ledger"),
+    default: identifier.or(z27.literal(""))
   }).strict(),
-  z23.object({ ...base, kind: z23.literal("datetime"), default: settingInstant }).strict(),
-  z23.object({
+  z27.object({ ...base, kind: z27.literal("datetime"), default: settingInstant }).strict(),
+  z27.object({
     ...base,
-    kind: z23.literal("resource"),
+    kind: z27.literal("resource"),
     default: settingResourceId,
     source: resourceSourceSchema
   }).strict(),
-  z23.object({ ...base, kind: z23.literal("quiz"), default: quizContentSchema }).strict(),
-  z23.object({
+  z27.object({ ...base, kind: z27.literal("quiz"), default: quizContentSchema }).strict(),
+  z27.object({
     ...base,
-    kind: z23.literal("text"),
-    default: z23.string(),
-    minLength: z23.number().int().nonnegative(),
-    maxLength: z23.number().int().positive(),
-    multiline: z23.boolean(),
+    kind: z27.literal("text"),
+    default: z27.string(),
+    minLength: z27.number().int().nonnegative(),
+    maxLength: z27.number().int().positive(),
+    multiline: z27.boolean(),
     /**
      * A list Console offers the value from, beside free text: `telegram-chat` lists the
-     * project's connected Telegram chats. Unknown pickers read as free text. Two pickers also
+     * project's connected Telegram chats. Unknown pickers read as free text. Six pickers also
      * constrain the value, at publication and when an operator edits it: `amount`, a
-     * non-negative integer in a token's base units (`settings.amount()`), and `chain`, a chain
-     * `ctx.wallet.balance()` reads (`settings.chain()`).
+     * non-negative integer in a token's base units (`settings.amount()`), `chain`, a chain
+     * `ctx.wallet.balance()` reads (`settings.chain()`), `nft`, an NFT collection
+     * `ctx.wallet.nfts()` reads (`settings.nft()`), whose contract or Solana collection mint
+     * Relay also checks on its chain, `contract-call`, a contract function `ctx.wallet.call()`
+     * reads (`settings.contractCall()`), whose chain Relay also checks, and `contract-event`, a
+     * contract event `ctx.wallet.events()` reads (`settings.contractEvent()`), whose chain and
+     * contract Relay also checks, and `solana-program`, a Solana program
+     * `ctx.wallet.transactions()` reads (`settings.solanaProgram()`), which Relay also checks is
+     * an executable program.
      */
-    picker: z23.string().optional(),
+    picker: z27.string().optional(),
     /**
      * On an `amount` setting, the token's decimals: Console shows and edits the value in whole
      * tokens.
      */
-    decimals: z23.number().int().min(0).max(255).optional()
+    decimals: z27.number().int().min(0).max(255).optional()
   }).strict(),
-  z23.object({
+  z27.object({
     ...base,
-    kind: z23.literal("integer"),
-    default: z23.number().int(),
-    min: z23.number().int(),
-    max: z23.number().int()
+    kind: z27.literal("integer"),
+    default: z27.number().int(),
+    min: z27.number().int(),
+    max: z27.number().int()
   }).strict(),
-  z23.object({ ...base, kind: z23.literal("boolean"), default: z23.boolean() }).strict(),
-  z23.object({
+  z27.object({ ...base, kind: z27.literal("boolean"), default: z27.boolean() }).strict(),
+  z27.object({
     ...base,
-    kind: z23.literal("choice"),
-    default: z23.string(),
-    options: z23.array(z23.string().min(1)).min(1)
+    kind: z27.literal("choice"),
+    default: z27.string(),
+    options: z27.array(z27.string().min(1)).min(1)
   }).strict()
 ]);
-var settingsFieldsSchema = z23.record(
-  z23.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
+var settingsFieldsSchema = z27.record(
+  z27.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
   settingFieldSchema
 );
-var settingsValuesSchema = z23.record(
-  z23.string(),
-  z23.union([z23.string(), z23.number().finite(), z23.boolean(), quizContentSchema])
+var settingsValuesSchema = z27.record(
+  z27.string(),
+  z27.union([z27.string(), z27.number().finite(), z27.boolean(), quizContentSchema])
 );
 function isAmount(value) {
   return value.length <= 100 && /^(0|[1-9][0-9]*)$/.test(value);
@@ -2630,7 +3276,7 @@ function isBoundSetting(field) {
   return field?.kind === "integer" || field?.kind === "text" && field.picker === "amount";
 }
 function textSettingSchema(field) {
-  const text = z23.string().min(field.minLength).max(field.maxLength);
+  const text = z27.string().min(field.minLength).max(field.maxLength);
   switch (field.picker) {
     case "amount":
       return text.refine(
@@ -2642,6 +3288,26 @@ function textSettingSchema(field) {
         isBalanceChain,
         'Use "solana" or an EVM chain ID such as "eip155:8453"'
       );
+    case "nft":
+      return text.refine(
+        isNftCollection,
+        'Use an NFT collection such as "eip155:1/erc721:0x\u2026", "eip155:8453/erc1155:0x\u2026/1" for one ERC-1155 token ID, or "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/nft:<collection mint>"'
+      );
+    case "contract-call":
+      return text.refine(
+        isContractCall,
+        `Use a contract call: the contract's CAIP-10 ID and a view or pure function returning one uint, int, bool or address, such as "eip155:8453:0x\u2026 function stakedOf(address) view returns (uint256)"`
+      );
+    case "contract-event":
+      return text.refine(
+        isContractEvent,
+        'Use a contract event such as "eip155:8453:0x\u2026 Transfer(address indexed from, address indexed to, uint256 value)": name every argument, and index at least one address argument'
+      );
+    case "solana-program":
+      return text.refine(
+        isSolanaProgram,
+        'Use a Solana program address in base58, such as "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"'
+      );
     default:
       return text;
   }
@@ -2666,17 +3332,17 @@ function parseSettings(fields2, input) {
         shape[key] = textSettingSchema(field).default(field.default);
         break;
       case "integer":
-        shape[key] = z23.number().int().min(field.min).max(field.max).default(field.default);
+        shape[key] = z27.number().int().min(field.min).max(field.max).default(field.default);
         break;
       case "boolean":
-        shape[key] = z23.boolean().default(field.default);
+        shape[key] = z27.boolean().default(field.default);
         break;
       case "choice":
-        shape[key] = z23.enum(field.options).default(field.default);
+        shape[key] = z27.enum(field.options).default(field.default);
         break;
     }
   }
-  return settingsValuesSchema.parse(z23.object(shape).strict().parse(input));
+  return settingsValuesSchema.parse(z27.object(shape).strict().parse(input));
 }
 function missingResourceSettings(fields2, values2) {
   return Object.entries(fields2).filter(
@@ -2697,21 +3363,21 @@ function authoringKey(input) {
 }
 
 // src/campaigns.ts
-import * as z24 from "zod";
-var timestamp4 = z24.number().int().safe().nonnegative();
-var availabilityWindowSchema = z24.object({ from: timestamp4, until: timestamp4 }).strict().refine((window) => window.until > window.from, {
+import * as z28 from "zod";
+var timestamp4 = z28.number().int().safe().nonnegative();
+var availabilityWindowSchema = z28.object({ from: timestamp4, until: timestamp4 }).strict().refine((window) => window.until > window.from, {
   message: "Window end must follow its start",
   path: ["until"]
 });
-var campaignDefinitionSchema = z24.object({
+var campaignDefinitionSchema = z28.object({
   key: identifier,
-  title: z24.string().trim().min(1).max(120),
+  title: z28.string().trim().min(1).max(120),
   window: availabilityWindowSchema.optional(),
-  enrollment: z24.enum(["none", "required"]).default("none")
+  enrollment: z28.enum(["none", "required"]).default("none")
 }).strict();
 var campaignAuthoringSchema = campaignDefinitionSchema.omit({ key: true, title: true }).extend({
   ...authoringIdentityShape,
-  title: z24.string().trim().min(1).max(120).optional()
+  title: z28.string().trim().min(1).max(120).optional()
 }).strict().transform((value) => {
   const normalized = value;
   return campaignDefinitionSchema.parse({
@@ -2725,42 +3391,42 @@ function defineCampaign(input) {
 var campaignViewSchema = campaignDefinitionSchema.extend({
   enrolledAt: timestamp4.nullable(),
   withdrawnAt: timestamp4.nullable().default(null),
-  withdrawalReason: z24.string().nullable().default(null)
+  withdrawalReason: z28.string().nullable().default(null)
 });
-var campaignEnrollmentInputSchema = z24.object({ actionId: identifier, campaign: identifier }).strict();
+var campaignEnrollmentInputSchema = z28.object({ actionId: identifier, campaign: identifier }).strict();
 var memberCampaignEnrollmentInputSchema = campaignEnrollmentInputSchema.extend({ member: identifier });
 var campaignWithdrawalInputSchema = campaignEnrollmentInputSchema;
 var memberCampaignWithdrawalInputSchema = campaignWithdrawalInputSchema.extend({
   member: identifier,
-  reason: z24.string().trim().min(1).max(500)
+  reason: z28.string().trim().min(1).max(500)
 });
-var campaignEnrollmentSchema = z24.object({
+var campaignEnrollmentSchema = z28.object({
   campaign: identifier,
   member: identifier,
   enrolledAt: timestamp4,
   withdrawnAt: timestamp4.nullable().default(null),
-  withdrawalReason: z24.string().nullable().default(null)
+  withdrawalReason: z28.string().nullable().default(null)
 });
 
 // src/resource-handle.ts
-import * as z25 from "zod";
+import * as z29 from "zod";
 function resourceHandle(_kind, definition) {
   return definition;
 }
-var ledgerSettingSchema = identifier.or(z25.literal("")).brand();
+var ledgerSettingSchema = identifier.or(z29.literal("")).brand();
 function ledgerKey(ledger) {
   return typeof ledger === "string" ? ledger : ledger.key;
 }
 
 // src/groups.ts
-import * as z26 from "zod";
-var projectGroupSchema = z26.object({
+import * as z30 from "zod";
+var projectGroupSchema = z30.object({
   key: identifier,
-  title: z26.string().trim().min(1).max(120)
+  title: z30.string().trim().min(1).max(120)
 }).strict();
 var projectGroupAuthoringSchema = projectGroupSchema.omit({ key: true, title: true }).extend({
   ...authoringIdentityShape,
-  title: z26.string().trim().min(1).max(120).optional()
+  title: z30.string().trim().min(1).max(120).optional()
 }).strict().transform((value) => {
   return projectGroupSchema.parse({
     ...value,
@@ -2773,92 +3439,93 @@ function defineGroup(input) {
 function projectGroupKey(group) {
   return identifier.parse(group.key);
 }
-var groupTitle = z26.string().trim().min(1).max(120);
-var reason = z26.string().trim().min(1).max(1e3);
-var timestamp5 = z26.number().int().nonnegative().max(864e13);
-var createGroupSchema = z26.object({ actionId: identifier, key: identifier, title: groupTitle }).strict();
-var updateGroupSchema = z26.object({ title: groupTitle }).strict();
-var addGroupMemberSchema = z26.object({ actionId: identifier, member: identifier, reason }).strict();
-var removeGroupMemberSchema = z26.object({ actionId: identifier, reason }).strict();
-var groupPageQuerySchema = z26.strictObject({
+var groupTitle = z30.string().trim().min(1).max(120);
+var reason = z30.string().trim().min(1).max(1e3);
+var timestamp5 = z30.number().int().nonnegative().max(864e13);
+var createGroupSchema = z30.object({ actionId: identifier, key: identifier, title: groupTitle }).strict();
+var updateGroupSchema = z30.object({ title: groupTitle }).strict();
+var addGroupMemberSchema = z30.object({ actionId: identifier, member: identifier, reason }).strict();
+var removeGroupMemberSchema = z30.object({ actionId: identifier, reason }).strict();
+var groupArchiveInputSchema = z30.object({ reason: lifecycleReasonSchema.optional() }).strict();
+var groupPageQuerySchema = z30.strictObject({
   cursor: pageCursorSchema.optional(),
   /** Items per page, 1–100; the default is 50. */
-  limit: z26.number().int().min(1).max(100).optional()
+  limit: z30.number().int().min(1).max(100).optional()
 });
-var managedGroupSchema = z26.object({
+var managedGroupSchema = z30.object({
   key: identifier,
-  title: z26.string(),
-  members: z26.number().int().nonnegative(),
+  title: z30.string(),
+  members: z30.number().int().nonnegative(),
   createdAt: timestamp5,
   archivedAt: timestamp5.nullable()
 });
-var groupPageSchema = z26.object({
-  items: z26.array(managedGroupSchema),
+var groupPageSchema = z30.object({
+  items: z30.array(managedGroupSchema),
   nextCursor: pageCursorSchema.nullable()
 });
-var groupMemberSchema = z26.object({
+var groupMemberSchema = z30.object({
   member: identifier,
   addedAt: timestamp5.nullable()
 });
-var groupMemberPageSchema = z26.object({
-  items: z26.array(groupMemberSchema),
+var groupMemberPageSchema = z30.object({
+  items: z30.array(groupMemberSchema),
   nextCursor: pageCursorSchema.nullable()
 });
 
 // src/prerequisites.ts
-import * as z27 from "zod";
-var amount = z27.number().int().safe().nonnegative();
+import * as z31 from "zod";
+var amount = z31.number().int().safe().nonnegative();
 var threshold = amount.positive();
-var completionPrerequisiteSchema = z27.discriminatedUnion("scope", [
-  z27.object({
-    kind: z27.literal("completion"),
+var completionPrerequisiteSchema = z31.discriminatedUnion("scope", [
+  z31.object({
+    kind: z31.literal("completion"),
     quest: identifier,
-    scope: z27.literal("ever")
+    scope: z31.literal("ever")
   }).strict(),
-  z27.object({
-    kind: z27.literal("completion"),
+  z31.object({
+    kind: z31.literal("completion"),
     quest: identifier,
-    scope: z27.literal("period"),
+    scope: z31.literal("period"),
     period: calendarPeriodSchema.exclude(["lifetime"])
   }).strict()
 ]);
-var balancePrerequisiteSchema = z27.object({
-  kind: z27.literal("balance"),
+var balancePrerequisiteSchema = z31.object({
+  kind: z31.literal("balance"),
   balance: identifier,
   minimum: threshold
 }).strict();
-var groupPrerequisiteSchema = z27.object({ kind: z27.literal("group"), group: identifier, title: z27.string() }).strict();
-var prerequisiteSchema = z27.discriminatedUnion("kind", [
+var groupPrerequisiteSchema = z31.object({ kind: z31.literal("group"), group: identifier, title: z31.string() }).strict();
+var prerequisiteSchema = z31.discriminatedUnion("kind", [
   completionPrerequisiteSchema,
   balancePrerequisiteSchema,
   groupPrerequisiteSchema
 ]);
-var missingPrerequisiteSchema = z27.union([
-  z27.object({
-    kind: z27.literal("completion"),
+var missingPrerequisiteSchema = z31.union([
+  z31.object({
+    kind: z31.literal("completion"),
     quest: identifier,
-    title: z27.string(),
-    scope: z27.literal("ever")
+    title: z31.string(),
+    scope: z31.literal("ever")
   }),
-  z27.object({
-    kind: z27.literal("completion"),
+  z31.object({
+    kind: z31.literal("completion"),
     quest: identifier,
-    title: z27.string(),
-    scope: z27.literal("period"),
+    title: z31.string(),
+    scope: z31.literal("period"),
     period: calendarPeriodSchema.exclude(["lifetime"]),
-    resetsAt: z27.number().int().safe()
+    resetsAt: z31.number().int().safe()
   }),
-  z27.object({
-    kind: z27.literal("balance"),
+  z31.object({
+    kind: z31.literal("balance"),
     balance: identifier,
-    title: z27.string(),
+    title: z31.string(),
     minimum: threshold,
     current: amount
   }),
-  z27.object({
-    kind: z27.literal("group"),
+  z31.object({
+    kind: z31.literal("group"),
     group: identifier,
-    title: z27.string()
+    title: z31.string()
   })
 ]);
 function completed(quest, options = {}) {
@@ -2889,29 +3556,29 @@ function inGroup(group) {
 var maxPointsAmount = 2147483647;
 
 // src/schema.ts
-import * as z28 from "zod";
-var pointsRewardSchema = z28.object({
-  kind: z28.literal("points").default("points"),
+import * as z32 from "zod";
+var pointsRewardSchema = z32.object({
+  kind: z32.literal("points").default("points"),
   balance: identifier,
-  amount: z28.number().int().min(0).max(maxPointsAmount)
+  amount: z32.number().int().min(0).max(maxPointsAmount)
 }).strict();
-var tieredRewardDefinitionSchema = z28.object({
+var tieredRewardDefinitionSchema = z32.object({
   /** An automatic achievement backed by the project badge catalog. */
   badge: identifier.optional(),
   /** Membership in the project group with this key, added when the reward is delivered. */
   group: identifier.optional(),
   id: identifier,
-  title: z28.string().min(1).max(120),
-  tiers: z28.array(
-    z28.object({ id: identifier, title: z28.string().min(1).max(120) }).strict()
+  title: z32.string().min(1).max(120),
+  tiers: z32.array(
+    z32.object({ id: identifier, title: z32.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: z28.object({ kind: z28.literal("untracked") }).strict(),
-  fulfillment: z28.discriminatedUnion("kind", [
-    z28.object({ kind: z28.literal("staff-handover") }).strict(),
-    z28.object({ kind: z28.literal("automatic") }).strict()
+  inventory: z32.object({ kind: z32.literal("untracked") }).strict(),
+  fulfillment: z32.discriminatedUnion("kind", [
+    z32.object({ kind: z32.literal("staff-handover") }).strict(),
+    z32.object({ kind: z32.literal("automatic") }).strict()
   ])
 }).strict().refine(
   (value) => value.badge === void 0 && value.group === void 0 || value.fulfillment.kind === "automatic" && value.tiers.length === 1 && value.tiers[0].id === "awarded",
@@ -2920,12 +3587,12 @@ var tieredRewardDefinitionSchema = z28.object({
   (value) => value.badge === void 0 || value.group === void 0,
   "A reward is either a badge or a group membership"
 );
-var tieredRewardReferenceSchema = z28.object({
+var tieredRewardReferenceSchema = z32.object({
   id: identifier,
   key: identifier.nullable()
 });
-var tierRewardSchema = z28.object({
-  kind: z28.literal("tier"),
+var tierRewardSchema = z32.object({
+  kind: z32.literal("tier"),
   reward: tieredRewardDefinitionSchema,
   tier: identifier
 }).strict().refine(
@@ -2937,7 +3604,7 @@ var badgeRewardSchema = tierRewardSchema.transform(
     const badge = value.reward.badge;
     if (!badge || value.reward.fulfillment.kind !== "automatic" || value.reward.tiers.length !== 1 || value.tier !== "awarded") {
       context.addIssue({ code: "custom", message: "Invalid badge reward" });
-      return z28.NEVER;
+      return z32.NEVER;
     }
     return { ...value, reward: { ...value.reward, badge } };
   }
@@ -2961,7 +3628,7 @@ var groupRewardSchema = tierRewardSchema.transform(
     const group = value.reward.group;
     if (!group || value.reward.fulfillment.kind !== "automatic" || value.reward.tiers.length !== 1 || value.tier !== "awarded") {
       context.addIssue({ code: "custom", message: "Invalid group reward" });
-      return z28.NEVER;
+      return z32.NEVER;
     }
     return { ...value, reward: { ...value.reward, group } };
   }
@@ -2981,7 +3648,7 @@ function groupReward(key, title) {
   });
 }
 var integrationRewardSchema = discordRewardSchema;
-var rewardSchema = z28.union([
+var rewardSchema = z32.union([
   pointsRewardSchema,
   tierRewardSchema,
   integrationRewardSchema
@@ -2998,39 +3665,39 @@ function rewardKey(reward) {
   }
   return reward.kind === "points" ? "points:" + reward.balance : "tier:" + reward.reward.id;
 }
-var triggerSchema = z28.union([
-  z28.object({
-    kind: z28.literal("manual"),
-    input: z28.literal("text"),
+var triggerSchema = z32.union([
+  z32.object({
+    kind: z32.literal("manual"),
+    input: z32.literal("text"),
     constraints: textOptionsSchema,
-    actor: z28.enum(["member", "staff"]).optional()
+    actor: z32.enum(["member", "staff"]).optional()
   }).strict(),
-  z28.object({
-    kind: z28.literal("manual"),
-    input: z28.literal("url"),
+  z32.object({
+    kind: z32.literal("manual"),
+    input: z32.literal("url"),
     constraints: urlOptionsSchema,
-    actor: z28.enum(["member", "staff"]).optional()
+    actor: z32.enum(["member", "staff"]).optional()
   }).strict(),
-  z28.object({
-    kind: z28.literal("manual"),
-    input: z28.enum(["photo", "quiz", "none"]),
-    actor: z28.enum(["member", "staff"]).optional()
+  z32.object({
+    kind: z32.literal("manual"),
+    input: z32.enum(["photo", "quiz", "none"]),
+    actor: z32.enum(["member", "staff"]).optional()
   }).strict(),
-  z28.object({
-    kind: z28.literal("automatic"),
+  z32.object({
+    kind: z32.literal("automatic"),
     tracker: trackerTriggerPolicySchema.optional()
   }).strict()
 ]);
-var triggerResponseSchema = z28.union(
+var triggerResponseSchema = z32.union(
   triggerSchema.options.map((option) => option.strip())
 );
-var photoResultSchema = z28.object({
-  kind: z28.enum(["pass", "fail", "unclear"]),
-  reason: z28.string().min(1).max(2e3)
+var photoResultSchema = z32.object({
+  kind: z32.enum(["pass", "fail", "unclear"]),
+  reason: z32.string().min(1).max(2e3)
 }).strict();
-var textReviewInputSchema = z28.object({
-  text: z28.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
-  criteria: z28.string().trim().min(1).max(2e3)
+var textReviewInputSchema = z32.object({
+  text: z32.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
+  criteria: z32.string().trim().min(1).max(2e3)
 }).strict();
 var textResultSchema = photoResultSchema;
 var deferPolicy = {
@@ -3044,31 +3711,31 @@ var retryCooldownPolicy = {
   minMs: 1e3,
   maxMs: 6048e5
 };
-var retryCooldownMsSchema = z28.number().int().min(retryCooldownPolicy.minMs).max(retryCooldownPolicy.maxMs);
-var evaluatorProgressSchema = z28.object({
-  current: z28.number().finite().nonnegative(),
-  target: z28.number().finite().positive(),
-  reason: z28.string().min(1).max(2e3)
+var retryCooldownMsSchema = z32.number().int().min(retryCooldownPolicy.minMs).max(retryCooldownPolicy.maxMs);
+var evaluatorProgressSchema = z32.object({
+  current: z32.number().finite().nonnegative(),
+  target: z32.number().finite().positive(),
+  reason: z32.string().min(1).max(2e3)
 }).refine((value) => value.current <= value.target, {
   message: "Progress current must not exceed target"
 });
-var decisionSchema = z28.discriminatedUnion("kind", [
-  z28.strictObject({
-    kind: z28.literal("defer"),
-    reason: z28.string().min(1).max(2e3),
-    retryAfterMs: z28.number().int().min(deferPolicy.minRetryAfterMs).max(deferPolicy.maxRetryAfterMs).optional(),
+var decisionSchema = z32.discriminatedUnion("kind", [
+  z32.strictObject({
+    kind: z32.literal("defer"),
+    reason: z32.string().min(1).max(2e3),
+    retryAfterMs: z32.number().int().min(deferPolicy.minRetryAfterMs).max(deferPolicy.maxRetryAfterMs).optional(),
     /** Absolute Unix milliseconds; the platform can only shorten its existing deadline. */
-    until: z28.number().int().safe().nonnegative().optional()
+    until: z32.number().int().safe().nonnegative().optional()
   }),
-  evaluatorProgressSchema.safeExtend({ kind: z28.literal("progress") }).strict(),
-  z28.object({
-    kind: z28.literal("accept"),
-    rewards: z28.array(rewardSchema).max(10),
+  evaluatorProgressSchema.safeExtend({ kind: z32.literal("progress") }).strict(),
+  z32.object({
+    kind: z32.literal("accept"),
+    rewards: z32.array(rewardSchema).max(10),
     completionKey: completionKeySchema.optional()
   }).strict(),
-  z28.object({
-    kind: z28.literal("reject"),
-    reason: z28.string().min(1).max(2e3),
+  z32.object({
+    kind: z32.literal("reject"),
+    reason: z32.string().min(1).max(2e3),
     /**
      * A stable key for the rejection's cause, such as `wrong-answers`, stored as the attempt's
      * `code`: lowercase letters, digits and hyphens, at most 64 characters, and none of the
@@ -3076,28 +3743,28 @@ var decisionSchema = z28.discriminatedUnion("kind", [
      */
     code: rejectCodeSchema.optional(),
     /** The evaluator asked for human review, but review is off for the quest, so this is a reject. */
-    requestedReview: z28.literal(true).optional()
+    requestedReview: z32.literal(true).optional()
   }).strict(),
-  z28.object({
-    kind: z28.literal("review"),
-    reason: z28.string().min(1).max(2e3),
-    rewards: z28.array(rewardSchema).max(10).optional(),
+  z32.object({
+    kind: z32.literal("review"),
+    reason: z32.string().min(1).max(2e3),
+    rewards: z32.array(rewardSchema).max(10).optional(),
     completionKey: completionKeySchema.optional()
   }).strict()
 ]);
-var reviewModeSchema = z28.enum(["workers-ai"]);
-var storedReviewModeSchema = z28.enum([
+var reviewModeSchema = z32.enum(["workers-ai"]);
+var storedReviewModeSchema = z32.enum([
   "fixture-pass",
   "fixture-fail",
   "fixture-unclear",
   "fixture-error",
   "workers-ai"
 ]);
-var rewardBundleSchema = z28.array(rewardSchema).max(10).refine(
+var rewardBundleSchema = z32.array(rewardSchema).max(10).refine(
   (rewards) => new Set(rewards.map(rewardKey)).size === rewards.length,
   "Use one entry per balance or shared reward"
 );
-var mediaUrlSchema = z28.string().max(2e3).refine((value) => {
+var mediaUrlSchema = z32.string().max(2e3).refine((value) => {
   if (/^\/(?!\/)[^\\\s]*$/.test(value)) {
     return true;
   }
@@ -3107,67 +3774,71 @@ var mediaUrlSchema = z28.string().max(2e3).refine((value) => {
     return false;
   }
 }, "Use an HTTPS URL or a same-site path beginning with /");
-var questStepActionSchema = z28.discriminatedUnion("kind", [
-  z28.object({
-    kind: z28.literal("link"),
+var questStepActionSchema = z32.discriminatedUnion("kind", [
+  z32.object({
+    kind: z32.literal("link"),
     url: mediaUrlSchema.refine(
       (value) => value.startsWith("https://"),
       "Use an HTTPS URL"
     ),
-    label: z28.string().trim().min(1).max(120)
+    label: z32.string().trim().min(1).max(120)
   }).strict()
 ]);
-var questStepSchema = z28.object({
-  title: z28.string().trim().min(1).max(120),
-  description: z28.string().max(4e3).optional(),
+var questStepSchema = z32.object({
+  title: z32.string().trim().min(1).max(120),
+  description: z32.string().max(4e3).optional(),
   action: questStepActionSchema.optional()
 }).strict();
-var questPresentationRequirementSchema = z28.discriminatedUnion("kind", [
-  z28.object({ kind: z28.literal("account"), provider: authProviderSchema }).strict(),
-  z28.object({ kind: z28.literal("wallet"), chain: walletChainSchema.optional() }).strict()
+var questPresentationRequirementSchema = z32.discriminatedUnion("kind", [
+  z32.object({ kind: z32.literal("account"), provider: authProviderSchema }).strict(),
+  z32.object({ kind: z32.literal("wallet"), chain: walletChainSchema.optional() }).strict()
 ]);
-var questPresentationContentSchema = z28.object({
-  steps: z28.array(questStepSchema).max(30).optional(),
+var questPresentationContentSchema = z32.object({
+  steps: z32.array(questStepSchema).max(30).optional(),
   image: mediaUrlSchema.optional(),
-  imageAlt: z28.string().max(500).optional(),
-  requirements: z28.array(questPresentationRequirementSchema).max(10).optional()
+  imageAlt: z32.string().max(500).optional(),
+  requirements: z32.array(questPresentationRequirementSchema).max(10).optional()
 }).strict();
 var questPresentationSchema = questPresentationContentSchema.extend({
   quiz: quizQuestionsSchema.optional(),
-  instructions: z28.string().max(4e3).optional(),
-  video: z28.object({
+  instructions: z32.string().max(4e3).optional(),
+  video: z32.object({
     url: mediaUrlSchema,
     poster: mediaUrlSchema.optional(),
-    captions: z28.object({
+    captions: z32.object({
       url: mediaUrlSchema,
-      language: z28.string().min(2).max(20),
-      label: z28.string().min(1).max(80)
+      language: z32.string().min(2).max(20),
+      label: z32.string().min(1).max(80)
     }).strict().optional()
   }).strict().optional()
 }).strict();
-var questProfileSchema = z28.object({ visible: z28.boolean() }).strict();
+var questProfileSchema = z32.object({ visible: z32.boolean() }).strict();
 var evaluatorProtocol = 2;
-var evaluatorProtocolSchema = z28.literal(evaluatorProtocol);
-var questDescriptionSchema = z28.object({
+var evaluatorProtocolSchema = z32.literal(evaluatorProtocol);
+var questDescriptionSchema = z32.object({
   quest: identifier,
   evaluatorProtocol: evaluatorProtocolSchema,
-  title: z28.string().min(1).max(120),
+  title: z32.string().min(1).max(120),
   presentation: questPresentationSchema.default({}),
-  integrations: z28.array(evaluatorIntegrationProviderSchema).max(10).default([]),
+  integrations: z32.array(evaluatorIntegrationProviderSchema).max(10).default([]),
   fields: settingsFieldsSchema,
   values: settingsValuesSchema,
   rewards: rewardBundleSchema,
-  humanReview: z28.boolean(),
+  /** Messages Relay posts in connected chats and channels when a completion pays. */
+  announcements: z32.array(announcementSchema).max(3).optional(),
+  humanReview: z32.boolean(),
   trigger: triggerSchema,
   performance: contentPerformancePolicySchema.optional(),
-  requires: z28.array(prerequisiteSchema).max(30).default([]),
+  requires: z32.array(prerequisiteSchema).max(30).default([]),
   campaign: campaignDefinitionSchema.optional(),
   availability: availabilityWindowSchema.optional(),
-  completion: z28.preprocess(refuseStreakTimeZone, completionPolicySchema),
-  visibility: z28.enum(["visible", "hidden"]).default("visible"),
+  completion: z32.preprocess(refuseStreakTimeZone, completionPolicySchema),
+  visibility: z32.enum(["visible", "hidden"]).default("visible"),
   /** Whether completions show on participant profiles (`/v1/profiles/:id/completions`). */
   profile: questProfileSchema.default({ visible: false }),
-  budgets: z28.array(budgetSchema).max(20).default([]),
+  budgets: z32.array(budgetSchema).max(20).default([]),
+  /** Budgets counted per tracker record author; only on quests with a tracker trigger. */
+  authorBudgets: z32.array(authorBudgetSchema).max(20).optional(),
   /**
    * Milliseconds a member waits after an attempt is rejected (by the evaluator or a reviewer)
    * before submitting this quest again. Only for quests members submit. Omitted: no cooldown.
@@ -3180,25 +3851,31 @@ var questDescriptionSchema = z28.object({
    */
   completionCooldownMs: retryCooldownMsSchema.optional()
 }).strict();
-var artifactSchema = z28.object({ code: z28.string().min(1).max(1e6) }).strict();
+var artifactSchema = z32.object({ code: z32.string().min(1).max(1e6) }).strict();
 var releaseSchema = artifactSchema.extend({
   /** The SDK runtime the code imports. Absent, the code bundles its own SDK. */
   runtime: sdkRuntimeReferenceSchema.optional(),
   settings: settingsValuesSchema,
   provider: reviewModeSchema,
   expectedRelease: identifier.nullable().optional(),
-  settingRenames: z28.record(z28.string(), z28.string()).optional()
+  settingRenames: z32.record(z32.string(), z32.string()).optional()
 }).strict();
-var batchReleaseSchema = z28.object({
-  releases: z28.array(releaseSchema).min(1).max(questScaleLimits.quests)
+var batchReleaseSchema = z32.object({
+  releases: z32.array(releaseSchema).min(1).max(questScaleLimits.quests)
 }).strict();
-var questSettingsInputSchema = z28.object({
+var questSettingsInputSchema = z32.object({
   quest: identifier,
   expectedRelease: identifier,
   set: settingsValuesSchema,
-  reset: z28.array(z28.string()),
+  reset: z32.array(z32.string()),
   /** Replace the editable presentation fields; null restores the code defaults. */
-  presentation: questPresentationContentSchema.nullable().optional()
+  presentation: questPresentationContentSchema.nullable().optional(),
+  /**
+   * Anchor IDLs to paste, by `settings.solanaProgram()` setting key, for programs that publish
+   * none on chain; null removes a pasted one. An IDL the program publishes on chain takes
+   * precedence.
+   */
+  solanaIdls: z32.record(z32.string(), anchorIdlSchema.nullable()).optional()
 }).strict();
 var storedQuestDescriptionSchema = questDescriptionSchema.extend({
   completion: completionPolicySchema
@@ -3206,28 +3883,34 @@ var storedQuestDescriptionSchema = questDescriptionSchema.extend({
 var publishedReleaseSchema = responseShape(
   storedQuestDescriptionSchema.extend({
     key: identifier.optional(),
-    code: z28.string(),
+    code: z32.string(),
     /** The SDK runtime `code` imports. Absent, the code bundles its own SDK. */
     runtime: sdkRuntimeReferenceSchema.optional(),
     provider: storedReviewModeSchema,
     id: identifier,
-    createdAt: z28.number(),
-    origin: z28.object({ typeVersion: identifier }).strict().optional(),
-    lifecycle: z28.enum(["active", "paused", "archived"]).default("active"),
-    configuration: z28.object({
+    createdAt: z32.number(),
+    origin: z32.object({ typeVersion: identifier }).strict().optional(),
+    lifecycle: z32.enum(["active", "paused", "archived"]).default("active"),
+    configuration: z32.object({
       defaults: settingsValuesSchema,
       overrides: settingsValuesSchema,
-      preserved: z28.array(z28.string()),
+      preserved: z32.array(z32.string()),
       presentation: questPresentationContentSchema.optional(),
       presentationDefaults: questPresentationContentSchema.optional()
-    }).strict().optional()
+    }).strict().optional(),
+    /**
+     * The Anchor IDLs `ctx.wallet.transactions()` decodes instructions with, by
+     * `settings.solanaProgram()` setting key. Stored when the setting is saved; a setting without
+     * an IDL has no entry.
+     */
+    solanaIdls: z32.record(z32.string(), solanaProgramIdlSchema).optional()
   })
 );
-var templateSchema = z28.object({
-  code: z28.string(),
+var templateSchema = z32.object({
+  code: z32.string(),
   definition: questDescriptionSchema
 });
-var quizAnswersSchema = z28.record(identifier, identifier).refine(
+var quizAnswersSchema = z32.record(identifier, identifier).refine(
   (answers) => Object.keys(answers).length > 0 && Object.keys(answers).length <= 50,
   "Provide between 1 and 50 answers"
 ).transform(
@@ -3235,17 +3918,17 @@ var quizAnswersSchema = z28.record(identifier, identifier).refine(
     Object.entries(answers).sort(([a], [b]) => a.localeCompare(b))
   )
 );
-var quizEvidenceSchema = z28.object({
-  kind: z28.literal("quiz"),
+var quizEvidenceSchema = z32.object({
+  kind: z32.literal("quiz"),
   release: identifier.optional(),
   answers: quizAnswersSchema
 }).strict();
-var submissionEvidenceSchema = z28.union([
+var submissionEvidenceSchema = z32.union([
   quizEvidenceSchema,
   textEvidenceSchema,
   urlEvidenceSchema
 ]);
-var submitSchema = z28.object({
+var submitSchema = z32.object({
   actionId: identifier,
   quest: identifier,
   member: identifier,
@@ -3253,7 +3936,7 @@ var submitSchema = z28.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: z28.boolean().optional()
+  faultAfterReview: z32.boolean().optional()
 }).strict();
 var AttemptStatus = {
   Queued: "queued",
@@ -3265,8 +3948,8 @@ var AttemptStatus = {
   NeedsReview: "needs-review",
   Failed: "failed"
 };
-var attemptStatusSchema = z28.string();
-var attemptSchema = z28.object({
+var attemptStatusSchema = z32.string();
+var attemptSchema = z32.object({
   id: identifier,
   release: identifier,
   quest: identifier,
@@ -3274,29 +3957,29 @@ var attemptSchema = z28.object({
   evidence: identifier.nullable(),
   input: submissionEvidenceSchema.optional(),
   status: attemptStatusSchema,
-  reason: z28.string().nullable(),
-  retries: z28.number(),
-  generation: z28.number(),
-  completion: z28.string().nullable(),
+  reason: z32.string().nullable(),
+  retries: z32.number(),
+  generation: z32.number(),
+  completion: z32.string().nullable(),
   reviewRewards: rewardBundleSchema.nullable().default(null),
   /** Scheduled reruns advance this number; failure retries preserve it. */
-  evaluationRun: z28.number().int().nonnegative().default(0),
-  deferCount: z28.number().int().nonnegative().default(0),
-  deferUntil: z28.number().int().safe().nullable().default(null),
-  nextEvaluationAt: z28.number().int().safe().nullable().default(null),
+  evaluationRun: z32.number().int().nonnegative().default(0),
+  deferCount: z32.number().int().nonnegative().default(0),
+  deferUntil: z32.number().int().safe().nullable().default(null),
+  nextEvaluationAt: z32.number().int().safe().nullable().default(null),
   /**
    * Open code: consumers must tolerate new values. Relay writes its own codes, such as
    * `budget-exhausted`; an attempt the evaluator rejected with `decision.reject({ reason, code })`
    * carries the evaluator's code in management reads, and null in responses to members.
    */
-  code: z28.string().nullable().default(null),
+  code: z32.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: z28.boolean().default(false),
-  createdAt: z28.number()
+  requestedReview: z32.boolean().default(false),
+  createdAt: z32.number()
 });
 var QuestSubmissionStatus = {
   Open: "open",
@@ -3304,9 +3987,9 @@ var QuestSubmissionStatus = {
   Discarded: "discarded",
   Expired: "expired"
 };
-var questSubmissionStatusSchema = z28.string();
+var questSubmissionStatusSchema = z32.string();
 var questSubmissionSchema = responseShape(
-  z28.object({
+  z32.object({
     id: identifier,
     quest: identifier,
     member: identifier,
@@ -3316,85 +3999,85 @@ var questSubmissionSchema = responseShape(
     /** An uploaded photo's evidence ID. */
     evidence: identifier.nullable(),
     /** Submitting was refused because the quest changed: review the draft before submitting again. */
-    reviewRequired: z28.boolean(),
+    reviewRequired: z32.boolean(),
     status: questSubmissionStatusSchema,
     /** The attempt a `submitted` submission admitted. */
     attempt: identifier.nullable(),
-    createdAt: z28.number(),
-    updatedAt: z28.number(),
+    createdAt: z32.number(),
+    updatedAt: z32.number(),
     /** When an open submission expires unless it changes again. */
-    expiresAt: z28.number()
+    expiresAt: z32.number()
   })
 );
-var questSubmissionUpdateSchema = z28.object({
+var questSubmissionUpdateSchema = z32.object({
   release: identifier.nullable().optional(),
   input: submissionEvidenceSchema.nullable().optional(),
   evidence: identifier.nullable().optional()
 }).strict();
 var questSubmissionResultSchema = responseShape(
-  z28.object({
+  z32.object({
     submission: questSubmissionSchema,
     attempt: attemptSchema,
-    replayed: z28.boolean()
+    replayed: z32.boolean()
   })
 );
-var eventSchema = z28.object({
-  id: z28.number(),
-  attempt: z28.string().nullable(),
-  kind: z28.string(),
-  detail: z28.string(),
-  actor: z28.string().nullable().default(null),
-  at: z28.number()
-});
-var pickupSelectionSchema = z28.object({
+var eventSchema = z32.object({
+  id: z32.number(),
+  attempt: z32.string().nullable(),
+  kind: z32.string(),
+  detail: z32.string(),
+  actor: z32.string().nullable().default(null),
+  at: z32.number()
+});
+var pickupSelectionSchema = z32.object({
   item: identifier,
-  revision: z28.number().int().nonnegative()
+  revision: z32.number().int().nonnegative()
 }).strict();
-var pickupAllocationSchema = z28.object({
+var pickupAllocationSchema = z32.object({
   item: identifier,
-  label: z28.string().min(1).max(80)
+  label: z32.string().min(1).max(80)
 }).strict();
-var pickupPolicySchema = z28.discriminatedUnion("kind", [
-  z28.object({ kind: z28.literal("untracked") }).strict(),
-  z28.object({
-    kind: z28.literal("at-pickup"),
-    tiers: z28.array(
-      z28.object({
+var pickupPolicySchema = z32.discriminatedUnion("kind", [
+  z32.object({ kind: z32.literal("untracked") }).strict(),
+  z32.object({
+    kind: z32.literal("at-pickup"),
+    tiers: z32.array(
+      z32.object({
         tier: identifier,
-        variants: z28.array(pickupAllocationSchema).min(1).max(100)
+        variants: z32.array(pickupAllocationSchema).min(1).max(100)
       }).strict()
     ).min(1).max(100)
   }).strict()
 ]);
-var pickupCatalogSchema = z28.object({
+var pickupCatalogSchema = z32.object({
   reward: tieredRewardDefinitionSchema,
-  revision: z28.number().int().nonnegative(),
+  revision: z32.number().int().nonnegative(),
   policy: pickupPolicySchema
 });
-var pickupAvailabilitySchema = z28.discriminatedUnion("kind", [
-  z28.object({ kind: z28.literal("untracked") }).strict(),
-  z28.object({
-    kind: z28.literal("at-pickup"),
-    revision: z28.number().int().nonnegative(),
-    variants: z28.array(
+var pickupAvailabilitySchema = z32.discriminatedUnion("kind", [
+  z32.object({ kind: z32.literal("untracked") }).strict(),
+  z32.object({
+    kind: z32.literal("at-pickup"),
+    revision: z32.number().int().nonnegative(),
+    variants: z32.array(
       pickupAllocationSchema.extend({
-        available: z28.number().int().nonnegative()
+        available: z32.number().int().nonnegative()
       })
     )
   }).strict()
 ]);
-var configurePickupSchema = z28.object({
+var configurePickupSchema = z32.object({
   reward: identifier,
-  revision: z28.number().int().nonnegative(),
+  revision: z32.number().int().nonnegative(),
   actionId: identifier,
-  policy: z28.discriminatedUnion("kind", [
-    z28.object({ kind: z28.literal("untracked") }).strict(),
-    z28.object({
-      kind: z28.literal("at-pickup"),
-      tiers: z28.array(
-        z28.object({
+  policy: z32.discriminatedUnion("kind", [
+    z32.object({ kind: z32.literal("untracked") }).strict(),
+    z32.object({
+      kind: z32.literal("at-pickup"),
+      tiers: z32.array(
+        z32.object({
           tier: identifier,
-          variants: z28.array(
+          variants: z32.array(
             pickupAllocationSchema.extend({
               item: identifier.optional()
             })
@@ -3404,10 +4087,10 @@ var configurePickupSchema = z28.object({
     }).strict()
   ])
 }).strict();
-var entitlementRecoverySchema = z28.object({
+var entitlementRecoverySchema = z32.object({
   completion: identifier,
-  reason: z28.string(),
-  flaggedAt: z28.number(),
+  reason: z32.string(),
+  flaggedAt: z32.number(),
   /** Null means no accepted completion currently earns this reward. */
   remainingTier: identifier.nullable()
 });
@@ -3417,40 +4100,40 @@ var entitlementBase = {
   reward: tieredRewardDefinitionSchema,
   earnedTier: identifier,
   tier: identifier,
-  revision: z28.number().int().positive()
+  revision: z32.number().int().positive()
 };
-var entitlementStateSchema = z28.discriminatedUnion("status", [
-  z28.object({ ...entitlementBase, status: z28.literal("available") }).strict(),
-  z28.object({
+var entitlementStateSchema = z32.discriminatedUnion("status", [
+  z32.object({ ...entitlementBase, status: z32.literal("available") }).strict(),
+  z32.object({
     ...entitlementBase,
-    status: z28.literal("handing-over"),
+    status: z32.literal("handing-over"),
     handover: identifier,
-    startedAt: z28.number(),
+    startedAt: z32.number(),
     allocation: pickupAllocationSchema.optional()
   }).strict(),
-  z28.object({
+  z32.object({
     ...entitlementBase,
-    status: z28.literal("collected"),
+    status: z32.literal("collected"),
     handover: identifier,
-    startedAt: z28.number(),
+    startedAt: z32.number(),
     allocation: pickupAllocationSchema.optional(),
-    collectedAt: z28.number(),
+    collectedAt: z32.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.
-  z28.object({
+  z32.object({
     ...entitlementBase,
-    status: z28.literal("void"),
-    voidedAt: z28.number()
+    status: z32.literal("void"),
+    voidedAt: z32.number()
   }).strict()
 ]);
-var tieredRewardReadSchema = z28.object({
+var tieredRewardReadSchema = z32.object({
   id: identifier,
-  title: z28.string(),
-  tiers: z28.array(z28.object({ id: identifier, title: z28.string() }).loose()),
-  inventory: z28.object({ kind: z28.string() }).loose(),
-  fulfillment: z28.object({ kind: z28.string() }).loose()
+  title: z32.string(),
+  tiers: z32.array(z32.object({ id: identifier, title: z32.string() }).loose()),
+  inventory: z32.object({ kind: z32.string() }).loose(),
+  fulfillment: z32.object({ kind: z32.string() }).loose()
 }).loose();
 var entitlementReadBase = {
   id: identifier,
@@ -3458,63 +4141,63 @@ var entitlementReadBase = {
   reward: tieredRewardReadSchema,
   earnedTier: identifier,
   tier: identifier,
-  revision: z28.number().int()
+  revision: z32.number().int()
 };
-var allocationReadSchema = z28.object({ item: identifier, label: z28.string() }).loose();
-var entitlementSchema = z28.union([
-  z28.discriminatedUnion("status", [
-    z28.object({ ...entitlementReadBase, status: z28.literal("available") }).loose(),
-    z28.object({
+var allocationReadSchema = z32.object({ item: identifier, label: z32.string() }).loose();
+var entitlementSchema = z32.union([
+  z32.discriminatedUnion("status", [
+    z32.object({ ...entitlementReadBase, status: z32.literal("available") }).loose(),
+    z32.object({
       ...entitlementReadBase,
-      status: z28.literal("handing-over"),
+      status: z32.literal("handing-over"),
       handover: identifier,
-      startedAt: z28.number(),
+      startedAt: z32.number(),
       allocation: allocationReadSchema.optional()
     }).loose(),
-    z28.object({
+    z32.object({
       ...entitlementReadBase,
-      status: z28.literal("collected"),
+      status: z32.literal("collected"),
       handover: identifier,
-      startedAt: z28.number(),
+      startedAt: z32.number(),
       allocation: allocationReadSchema.optional(),
-      collectedAt: z28.number(),
+      collectedAt: z32.number(),
       recovery: entitlementRecoverySchema.optional()
     }).loose(),
-    z28.object({
+    z32.object({
       ...entitlementReadBase,
-      status: z28.literal("void"),
-      voidedAt: z28.number()
+      status: z32.literal("void"),
+      voidedAt: z32.number()
     }).loose()
   ]),
-  z28.object({ ...entitlementReadBase, status: z28.string() }).loose().transform(({ status, ...entitlement }) => ({
+  z32.object({ ...entitlementReadBase, status: z32.string() }).loose().transform(({ status, ...entitlement }) => ({
     ...entitlement,
     status: "unsupported",
     reportedStatus: status
   }))
 ]);
-var beginHandoverSchema = z28.object({
+var beginHandoverSchema = z32.object({
   actionId: identifier,
-  revision: z28.number().int().positive(),
+  revision: z32.number().int().positive(),
   selection: pickupSelectionSchema.optional()
 }).strict();
-var confirmHandoverSchema = z28.object({ actionId: identifier, handover: identifier }).strict();
-var entitlementCorrectionSchema = z28.object({
+var confirmHandoverSchema = z32.object({ actionId: identifier, handover: identifier }).strict();
+var entitlementCorrectionSchema = z32.object({
   actionId: identifier,
-  revision: z28.number().int().positive(),
-  reason: z28.string().trim().min(1).max(500)
+  revision: z32.number().int().positive(),
+  reason: z32.string().trim().min(1).max(500)
 }).strict();
 var CompletionSourceKind = {
   Quest: "quest",
   Leaderboard: "leaderboard"
 };
-var completionSourceKindSchema = z28.string().min(1).max(64);
-var completionSourceSchema = z28.object({
+var completionSourceKindSchema = z32.string().min(1).max(64);
+var completionSourceSchema = z32.object({
   kind: completionSourceKindSchema,
   id: identifier
 });
-var completionRecordSchema = z28.object({
+var completionRecordSchema = z32.object({
   /** The occurrence the completion consumed. For a leaderboard prize, the settlement ID. */
-  key: z28.string().default("once"),
+  key: z32.string().default("once"),
   id: identifier,
   /** The quest ID, or the board ID when `source.kind` is `leaderboard`. */
   quest: identifier,
@@ -3522,19 +4205,19 @@ var completionRecordSchema = z28.object({
   /** What paid the completion. `source.id` repeats `quest`. */
   source: completionSourceSchema.optional()
 });
-var questAvailabilitySchema = z28.discriminatedUnion("kind", [
-  z28.object({
-    kind: z28.literal("available"),
-    input: z28.enum(["photo", "quiz", "none", "text", "url"])
+var questAvailabilitySchema = z32.discriminatedUnion("kind", [
+  z32.object({
+    kind: z32.literal("available"),
+    input: z32.enum(["photo", "quiz", "none", "text", "url"])
   }).strict(),
-  z28.object({ kind: z28.literal("completed") }).strict(),
-  z28.object({
-    kind: z28.literal("locked"),
-    missing: z28.array(missingPrerequisiteSchema).min(1)
+  z32.object({ kind: z32.literal("completed") }).strict(),
+  z32.object({
+    kind: z32.literal("locked"),
+    missing: z32.array(missingPrerequisiteSchema).min(1)
   }).strict(),
-  z28.object({
-    kind: z28.literal("blocked"),
-    reason: z28.enum([
+  z32.object({
+    kind: z32.literal("blocked"),
+    reason: z32.enum([
       "budget-exhausted",
       "connection-required",
       "wallet-required",
@@ -3543,56 +4226,56 @@ var questAvailabilitySchema = z28.discriminatedUnion("kind", [
       "enrollment-required"
     ]),
     /** Which window refused admission when `reason` is `outside-window`. */
-    window: z28.enum(["tracker", "quest"]).optional(),
-    resetsAt: z28.number().int().safe().optional()
+    window: z32.enum(["tracker", "quest"]).optional(),
+    resetsAt: z32.number().int().safe().optional()
   }).strict(),
-  z28.object({ kind: z28.literal("staff-required") }).strict(),
-  z28.object({ kind: z28.literal("automatic") }).strict(),
-  z28.object({ kind: z28.literal("checking"), attempt: identifier }).strict(),
-  z28.object({ kind: z28.literal("needs-review"), attempt: identifier }).strict(),
-  z28.object({ kind: z28.literal("retryable"), attempt: identifier }).strict()
+  z32.object({ kind: z32.literal("staff-required") }).strict(),
+  z32.object({ kind: z32.literal("automatic") }).strict(),
+  z32.object({ kind: z32.literal("checking"), attempt: identifier }).strict(),
+  z32.object({ kind: z32.literal("needs-review"), attempt: identifier }).strict(),
+  z32.object({ kind: z32.literal("retryable"), attempt: identifier }).strict()
 ]);
-var questAvailabilityResponseSchema = z28.union(
+var questAvailabilityResponseSchema = z32.union(
   questAvailabilitySchema.options.map((option) => option.strip())
 );
-var questBudgetViewSchema = z28.object({
+var questBudgetViewSchema = z32.object({
   id: identifier,
-  scope: z28.enum(["member", "project"]),
-  period: z28.enum(["day", "week", "month", "lifetime"]),
-  remaining: z28.number().int().safe().nonnegative(),
-  resetsAt: z28.number().int().safe().nullable()
+  scope: z32.enum(["member", "project"]),
+  period: z32.enum(["day", "week", "month", "lifetime"]),
+  remaining: z32.number().int().safe().nonnegative(),
+  resetsAt: z32.number().int().safe().nullable()
 });
 var memberProgressSchema = responseShape(
-  z28.object({
+  z32.object({
     member: identifier,
-    quests: z28.array(
-      z28.object({
+    quests: z32.array(
+      z32.object({
         quest: identifier,
         key: identifier.optional(),
         release: identifier.optional(),
-        title: z28.string(),
+        title: z32.string(),
         presentation: questPresentationSchema.default({}),
-        connections: z28.array(authProviderSchema).default([]),
+        connections: z32.array(authProviderSchema).default([]),
         trigger: triggerResponseSchema,
         availability: questAvailabilityResponseSchema,
-        completed: z28.boolean(),
+        completed: z32.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: z28.number().int().nonnegative().default(0),
-        visibility: z28.enum(["visible", "hidden"]).default("visible"),
-        missing: z28.array(missingPrerequisiteSchema),
+        completionCount: z32.number().int().nonnegative().default(0),
+        visibility: z32.enum(["visible", "hidden"]).default("visible"),
+        missing: z32.array(missingPrerequisiteSchema),
         campaign: campaignViewSchema.nullable().default(null),
         window: availabilityWindowSchema.nullable().default(null),
-        budgets: z28.array(questBudgetViewSchema).default([]),
+        budgets: z32.array(questBudgetViewSchema).default([]),
         /**
          * Unix milliseconds when the member may submit again, while the quest's retry cooldown
          * after their rejected attempt runs. Until then a new attempt is refused with
          * `retry-cooldown`. Absent when no cooldown is running.
          */
-        retryAt: z28.number().int().safe().optional(),
+        retryAt: z32.number().int().safe().optional(),
         /**
          * Unix milliseconds when the member may next submit the quest, while it waits on something
          * that ends by itself: the retry cooldown after a rejection, the completion cooldown after
@@ -3601,106 +4284,110 @@ var memberProgressSchema = responseShape(
          * several apply; use it for countdowns. Absent when the member can submit now, or when
          * nothing will reopen the quest (a used-up lifetime budget, a closed window).
          */
-        nextAvailableAt: z28.number().int().safe().optional(),
+        nextAvailableAt: z32.number().int().safe().optional(),
         attempt: attemptSchema.nullable()
       })
     ),
-    entitlements: z28.array(entitlementSchema)
+    entitlements: z32.array(entitlementSchema)
   })
 );
 var snapshotSchema = responseShape(
-  z28.object({
-    releases: z28.array(publishedReleaseSchema),
-    completions: z28.array(completionRecordSchema),
-    entitlements: z28.array(entitlementSchema),
-    attempts: z28.array(attemptSchema),
-    balances: z28.array(
-      z28.object({
-        member: z28.string(),
-        balance: z28.string(),
-        earned: z28.number(),
-        held: z28.number(),
-        available: z28.number()
+  z32.object({
+    releases: z32.array(publishedReleaseSchema),
+    completions: z32.array(completionRecordSchema),
+    entitlements: z32.array(entitlementSchema),
+    attempts: z32.array(attemptSchema),
+    balances: z32.array(
+      z32.object({
+        member: z32.string(),
+        balance: z32.string(),
+        earned: z32.number(),
+        held: z32.number(),
+        available: z32.number()
       })
     ),
-    events: z28.array(eventSchema)
+    events: z32.array(eventSchema)
   })
 );
-var evidenceSchema = z28.object({
+var evidenceSchema = z32.object({
   id: identifier,
   member: identifier,
-  type: z28.enum(["image/jpeg", "image/png"]),
-  size: z28.number()
+  type: z32.enum(["image/jpeg", "image/png"]),
+  size: z32.number()
 });
-var errorSchema = z28.object({
-  error: z28.string(),
-  code: z28.string().optional(),
+var errorSchema = z32.object({
+  error: z32.string(),
+  code: z32.string().optional(),
   /** Which window refused admission when `code` is `outside-window`. */
-  window: z28.enum(["tracker", "quest"]).optional(),
-  missing: z28.array(missingPrerequisiteSchema).optional(),
+  window: z32.enum(["tracker", "quest"]).optional(),
+  missing: z32.array(missingPrerequisiteSchema).optional(),
   /**
    * Unix milliseconds when the member may submit again, when `code` is `retry-cooldown` or
    * `completion-cooldown`.
    */
-  retryAt: z28.number().int().safe().optional()
+  retryAt: z32.number().int().safe().optional()
 });
-var staffDecisionSchema = z28.object({
+var staffDecisionSchema = z32.object({
+  actionId: identifier,
+  generation: z32.number().int().nonnegative(),
+  decision: z32.enum(["accept", "reject"]),
+  reason: z32.string().trim().min(1).max(2e3)
+}).strict();
+var acceptAnywaySchema = z32.object({
   actionId: identifier,
-  generation: z28.number().int().nonnegative(),
-  decision: z28.enum(["accept", "reject"]),
-  reason: z28.string().trim().min(1).max(2e3)
+  reason: z32.string().trim().min(1).max(2e3)
 }).strict();
-var stockSchema = z28.object({ item: identifier, quantity: z28.number().int().min(0).max(1e4) }).strict();
-var reservationSchema = z28.object({
+var stockSchema = z32.object({ item: identifier, quantity: z32.number().int().min(0).max(1e4) }).strict();
+var reservationSchema = z32.object({
   actionId: identifier,
   member: identifier,
   item: identifier,
   balance: identifier,
-  price: z28.number().int().positive().max(1e4)
+  price: z32.number().int().positive().max(1e4)
 }).strict();
 var pageOptions = {
-  limit: z28.number().int().min(1).max(100).default(25),
-  cursor: z28.string().min(1).max(4096).optional()
+  limit: z32.number().int().min(1).max(100).default(25),
+  cursor: z32.string().min(1).max(4096).optional()
 };
-var reviewListSchema = z28.object({
+var reviewListSchema = z32.object({
   ...pageOptions,
   member: identifier.optional(),
   quest: identifier.optional()
 }).strict();
-var memberListSchema = z28.object({
+var memberListSchema = z32.object({
   ...pageOptions,
   prefix: identifier.optional()
 }).strict();
-var reviewItemSchema = z28.object({
+var reviewItemSchema = z32.object({
   attempt: attemptSchema,
-  title: z28.string(),
-  checks: z28.array(
-    z28.object({ criteria: z28.string(), result: photoResultSchema })
+  title: z32.string(),
+  checks: z32.array(
+    z32.object({ criteria: z32.string(), result: photoResultSchema })
   )
 });
-var reviewPageSchema = z28.object({
-  items: z28.array(reviewItemSchema).max(100),
-  nextCursor: z28.string().nullable()
+var reviewPageSchema = z32.object({
+  items: z32.array(reviewItemSchema).max(100),
+  nextCursor: z32.string().nullable()
 });
-var memberPageSchema = z28.object({
-  items: z28.array(z28.object({ member: identifier })).max(100),
-  nextCursor: z28.string().nullable()
+var memberPageSchema = z32.object({
+  items: z32.array(z32.object({ member: identifier })).max(100),
+  nextCursor: z32.string().nullable()
 });
-var createStockItemSchema = z28.object({ actionId: identifier, name: z28.string().trim().min(1).max(80) }).strict();
-var stockItemSchema = z28.object({ id: identifier, name: z28.string() });
-var contentPerformanceSnapshotSchema = z28.strictObject({
+var createStockItemSchema = z32.object({ actionId: identifier, name: z32.string().trim().min(1).max(80) }).strict();
+var stockItemSchema = z32.object({ id: identifier, name: z32.string() });
+var contentPerformanceSnapshotSchema = z32.strictObject({
   contentAttempt: identifier,
   observation: identifier,
-  observedAt: z28.number().int().safe().nonnegative(),
+  observedAt: z32.number().int().safe().nonnegative(),
   metrics: contentMetricsSchema,
   rewards: rewardBundleSchema
 });
 var contentPerformanceQuerySchema = contentQualificationQuerySchema.extend({
-  content: z28.string().min(1).max(256)
+  content: z32.string().min(1).max(256)
 });
-var contentPerformancePageSchema = z28.strictObject({
-  current: z28.strictObject({
-    state: z28.enum([
+var contentPerformancePageSchema = z32.strictObject({
+  current: z32.strictObject({
+    state: z32.enum([
       "content-pending",
       "content-unqualified",
       "waiting",
@@ -3711,19 +4398,19 @@ var contentPerformancePageSchema = z28.strictObject({
       "failed",
       "superseded"
     ]),
-    reason: z28.string().nullable(),
+    reason: z32.string().nullable(),
     contentAttempt: identifier,
     attempt: identifier.nullable(),
     reward: contentQualificationSchema.shape.reward
   }),
-  items: z28.array(
-    z28.strictObject({
+  items: z32.array(
+    z32.strictObject({
       attempt: identifier,
       contentAttempt: identifier,
       observation: identifier,
-      observedAt: z28.number(),
+      observedAt: z32.number(),
       metrics: contentMetricsSchema,
-      state: z28.enum([
+      state: z32.enum([
         "pending",
         "qualified",
         "unqualified",
@@ -3731,7 +4418,7 @@ var contentPerformancePageSchema = z28.strictObject({
         "failed",
         "superseded"
       ]),
-      reason: z28.string().nullable()
+      reason: z32.string().nullable()
     })
   ),
   nextCursor: pageCursorSchema.nullable()
@@ -3762,6 +4449,8 @@ export {
   discordMemberInputSchema,
   discordMessageInputSchema,
   discordMemberSchema,
+  lifecycleReasonSchema,
+  offsetDateTimeSchema,
   discordMessageSchema,
   discordMessagesSourceSchema,
   discordReactionsSourceSchema,
@@ -3781,6 +4470,11 @@ export {
   trackerDataPathTypes,
   schemaCheckedReader,
   whereSchemaIssue,
+  telegramReactionsNamespace,
+  telegramMessagesNamespace,
+  youtubeShortsNamespace,
+  tiktokVideosNamespace,
+  walletBalancesNamespace,
   xTweetSchema,
   xContentBodySchema,
   trackerContentQuerySchema,
@@ -3798,6 +4492,7 @@ export {
   contentMetricNameSchema,
   xContentMetrics,
   customContentSchema,
+  walletBalanceSourceSchema,
   xSearchSourceSchema,
   customSourceSchema,
   trackerSourceSchema,
@@ -3811,8 +4506,12 @@ export {
   trackerDefinitionResponseSchema,
   publishedTrackerSchema,
   trackerStatusSchema,
+  managedTrackerSourceSchema,
+  managedTrackerSourceKinds,
+  managedTrackerSource,
   trackerPropertiesSchema,
   trackerCreateSchema,
+  managedTrackerCreateSchema,
   trackerUpdateSchema,
   trackerControlSchema,
   trackerAccountSchema,
@@ -3893,12 +4592,31 @@ export {
   completionPolicySchema,
   completionKeySchema,
   budgetSchema,
+  authorBudgetSchema,
   memberCompletionSchema,
   maxMemberCompletions,
   evaluatorIntegrationProviderSchema,
   integrationProviderSchema,
   discordServerSchema,
   projectIntegrationSchema,
+  announcementPlaceholders,
+  parseAnnouncementTemplate,
+  telegramSignInMethodsSchema,
+  telegramAccountConnectionSchema,
+  telegramInitDataSchema,
+  telegramMiniAppSignInSchema,
+  telegramChatIdSchema,
+  telegramChatSchema,
+  telegramChatsSchema,
+  telegramChatConnectionSchema,
+  telegramMemberInputSchema,
+  telegramChatMemberSchema,
+  telegramReactionDataSchema,
+  telegramMessageDataSchema,
+  announcementTextSchema,
+  telegramAnnouncementSchema,
+  discordAnnouncementSchema,
+  announcementSchema,
   solanaAddressSchema,
   walletChainSchema,
   cosmosNetworkSchema,
@@ -3922,6 +4640,26 @@ export {
   isEvmChainId,
   evmChainIdSchema,
   walletBalanceSchema,
+  walletBalanceSampleSchema,
+  parseNftCollection,
+  isNftCollection,
+  walletNftsSchema,
+  parseContractFunction,
+  parseContractCall,
+  isContractCall,
+  walletCallSchema,
+  walletDelegationsSchema,
+  parseContractEvent,
+  isContractEvent,
+  maxWalletEventLogs,
+  maxWalletEventLookback,
+  walletEventsSchema,
+  isSolanaProgram,
+  anchorIdlSchema,
+  solanaProgramIdlSchema,
+  maxWalletTransactions,
+  maxWalletTransactionLookback,
+  walletTransactionsSchema,
   textOptionsSchema,
   urlOptionsSchema,
   textEvidenceSchema,
@@ -3969,6 +4707,7 @@ export {
   updateGroupSchema,
   addGroupMemberSchema,
   removeGroupMemberSchema,
+  groupArchiveInputSchema,
   groupPageQuerySchema,
   managedGroupSchema,
   groupPageSchema,
@@ -4055,6 +4794,7 @@ export {
   evidenceSchema,
   errorSchema,
   staffDecisionSchema,
+  acceptAnywaySchema,
   stockSchema,
   reservationSchema,
   reviewListSchema,