@domino-sdk/relay 1.0.0-next.13 → 1.0.0-next.15

package/dist/{chunk-CRNQP7NV.js → chunk-J4OYDYJE.js}

@@ -34,19 +34,63 @@ var pageQuerySchema = z3.strictObject({
   cursor: pageCursorSchema.optional()
 });
 
-// src/tracker-data.ts
+// src/discord.ts
 import { z as z4 } from "zod";
+var discordMessageSchema = z4.object({
+  guildId: z4.string(),
+  channelId: z4.string(),
+  messageId: z4.string(),
+  userId: z4.string(),
+  content: z4.string().nullable(),
+  replyTo: z4.string().nullable(),
+  publishedAt: z4.number()
+}).strict();
+var discordMessagesSourceSchema = z4.strictObject({
+  kind: z4.literal("discord-messages"),
+  /** Store each message's text in `data.text`. Off unless set. */
+  text: z4.boolean().optional()
+});
+var discordReactionsSourceSchema = z4.strictObject({
+  kind: z4.literal("discord-reactions")
+});
+var discordMessageDataSchema = z4.object({
+  guildId: z4.string(),
+  channelId: z4.string(),
+  messageId: z4.string(),
+  /** The ID of the message this one replies to, or null. */
+  replyTo: z4.string().nullable(),
+  /** When Discord says the message was posted, in epoch milliseconds. */
+  publishedAt: z4.number()
+});
+var discordMessageTextDataSchema = discordMessageDataSchema.extend({
+  text: z4.string().nullable()
+});
+var discordReactionDataSchema = z4.object({
+  guildId: z4.string(),
+  channelId: z4.string(),
+  /** The message reacted to. */
+  messageId: z4.string(),
+  /** A custom emoji's ID, or null for a Unicode emoji, whose `name` is the emoji itself. */
+  emoji: z4.object({ id: z4.string().nullable(), name: z4.string() }),
+  /** The role IDs the reactor held in the server when reacting. */
+  reactorRoles: z4.array(z4.string()),
+  /** When the reacted-to message was posted, in epoch milliseconds. */
+  messagePublishedAt: z4.number()
+});
+
+// src/tracker-data.ts
+import { z as z5 } from "zod";
 var maxDepth = 16;
 var maxBytes = 32768;
 var trackerDataMaxBranches = 16;
 var trackerDataMaxEntries = 256;
-var scalar = z4.union([z4.string(), z4.number().finite(), z4.boolean(), z4.null()]);
-var size = z4.number().int().safe().nonnegative();
-var bound = z4.number().finite();
-var branches = () => z4.array(node).min(1).max(trackerDataMaxBranches);
-var node = z4.lazy(
-  () => z4.strictObject({
-    type: z4.enum([
+var scalar = z5.union([z5.string(), z5.number().finite(), z5.boolean(), z5.null()]);
+var size = z5.number().int().safe().nonnegative();
+var bound = z5.number().finite();
+var branches = () => z5.array(node).min(1).max(trackerDataMaxBranches);
+var node = z5.lazy(
+  () => z5.strictObject({
+    type: z5.enum([
       "object",
       "array",
       "string",
@@ -55,15 +99,15 @@ var node = z4.lazy(
       "boolean",
       "null"
     ]).optional(),
-    properties: z4.record(z4.string(), node).refine(
+    properties: z5.record(z5.string(), node).refine(
       (properties) => Object.keys(properties).length <= trackerDataMaxEntries,
       `An object schema lists at most ${trackerDataMaxEntries} properties`
     ).optional(),
-    required: z4.array(z4.string()).max(trackerDataMaxEntries).optional(),
-    additionalProperties: z4.union([z4.boolean(), node]).optional(),
-    propertyNames: z4.strictObject({
-      type: z4.literal("string"),
-      enum: z4.array(z4.string()).max(trackerDataMaxEntries).optional()
+    required: z5.array(z5.string()).max(trackerDataMaxEntries).optional(),
+    additionalProperties: z5.union([z5.boolean(), node]).optional(),
+    propertyNames: z5.strictObject({
+      type: z5.literal("string"),
+      enum: z5.array(z5.string()).max(trackerDataMaxEntries).optional()
     }).optional(),
     items: node.optional(),
     minItems: size.optional(),
@@ -74,7 +118,7 @@ var node = z4.lazy(
     maximum: bound.optional(),
     exclusiveMinimum: bound.optional(),
     exclusiveMaximum: bound.optional(),
-    enum: z4.array(scalar).min(1).max(trackerDataMaxEntries).optional(),
+    enum: z5.array(scalar).min(1).max(trackerDataMaxEntries).optional(),
     const: scalar.optional(),
     anyOf: branches().optional(),
     oneOf: branches().optional(),
@@ -136,7 +180,7 @@ function nestedUnionIssue(schema, path, insideUnion) {
   }
   return null;
 }
-var trackerDataSchemaSchema = z4.unknown().superRefine((value, ctx) => {
+var trackerDataSchemaSchema = z5.unknown().superRefine((value, ctx) => {
   const issue = shapeIssue(value);
   if (issue) {
     ctx.addIssue({ code: "custom", message: issue, abort: true });
@@ -243,7 +287,7 @@ function subset(schema, path) {
 function trackerDataSchema(schema) {
   let json;
   try {
-    json = z4.toJSONSchema(schema, {
+    json = z5.toJSONSchema(schema, {
       target: "draft-2020-12",
       io: "input",
       unrepresentable: "throw",
@@ -611,21 +655,21 @@ function whereSchemaIssue(schema, where) {
 }
 
 // src/trackers.ts
-import { z as z5 } from "zod";
-var timestamp = z5.number().int().safe().nonnegative().max(864e13);
-var count = z5.number().int().safe().nonnegative();
-var externalId = z5.string().min(1).max(256);
+import { z as z6 } from "zod";
+var timestamp = z6.number().int().safe().nonnegative().max(864e13);
+var count = z6.number().int().safe().nonnegative();
+var externalId = z6.string().min(1).max(256);
 var metric = count.nullable().default(null);
-var xTweetSchema = z5.looseObject({
+var xTweetSchema = z6.looseObject({
   id: externalId,
   userId: externalId,
-  content: z5.string(),
-  createdAt: z5.iso.datetime({ offset: true }),
-  author: z5.looseObject({
+  content: z6.string(),
+  createdAt: z6.iso.datetime({ offset: true }),
+  author: z6.looseObject({
     id: externalId,
-    username: z5.string(),
-    name: z5.string(),
-    verified: z5.boolean().nullable().default(null)
+    username: z6.string(),
+    name: z6.string(),
+    verified: z6.boolean().nullable().default(null)
   }),
   likeCount: metric,
   replyCount: metric,
@@ -633,90 +677,90 @@ var xTweetSchema = z5.looseObject({
   quoteCount: metric,
   viewCount: metric,
   bookmarkCount: metric,
-  isReply: z5.boolean(),
-  isRetweet: z5.boolean(),
-  isQuoteTweet: z5.boolean()
-});
-var xContentBodySchema = z5.strictObject({
-  version: z5.literal(1),
-  id: z5.string().min(1),
-  authorId: z5.string().min(1),
+  isReply: z6.boolean(),
+  isRetweet: z6.boolean(),
+  isQuoteTweet: z6.boolean()
+});
+var xContentBodySchema = z6.strictObject({
+  version: z6.literal(1),
+  id: z6.string().min(1),
+  authorId: z6.string().min(1),
   publishedAt: timestamp,
-  text: z5.string(),
-  isReply: z5.boolean(),
-  isRetweet: z5.boolean(),
-  isQuoteTweet: z5.boolean(),
-  media: z5.array(z5.strictObject({ type: z5.string(), url: z5.string() })).nullable(),
-  mentionedAuthorIds: z5.array(z5.string().min(1)).nullable(),
-  videoLengthSeconds: z5.number().nonnegative().nullable(),
-  references: z5.strictObject({
-    replyId: z5.string().nullable(),
-    replyAuthorId: z5.string().nullable(),
-    quoteId: z5.string().nullable(),
-    quoteAuthorId: z5.string().nullable(),
-    repostId: z5.string().nullable(),
-    repostAuthorId: z5.string().nullable()
+  text: z6.string(),
+  isReply: z6.boolean(),
+  isRetweet: z6.boolean(),
+  isQuoteTweet: z6.boolean(),
+  media: z6.array(z6.strictObject({ type: z6.string(), url: z6.string() })).nullable(),
+  mentionedAuthorIds: z6.array(z6.string().min(1)).nullable(),
+  videoLengthSeconds: z6.number().nonnegative().nullable(),
+  references: z6.strictObject({
+    replyId: z6.string().nullable(),
+    replyAuthorId: z6.string().nullable(),
+    quoteId: z6.string().nullable(),
+    quoteAuthorId: z6.string().nullable(),
+    repostId: z6.string().nullable(),
+    repostAuthorId: z6.string().nullable()
   })
 });
-var trackerContentQuerySchema = z5.strictObject({
+var trackerContentQuerySchema = z6.strictObject({
   id: externalId,
-  observation: z5.string().regex(/^observation_[a-f0-9]{64}$/)
+  observation: z6.string().regex(/^observation_[a-f0-9]{64}$/)
 });
 var trackerContentReadSchema = trackerContentQuerySchema.extend({
   member: identifier
 });
 var attributionContext = { member: identifier, capturedAt: timestamp };
-var trackerEvidenceSchema = z5.strictObject({
+var trackerEvidenceSchema = z6.strictObject({
   contentRevision: identifier,
   observation: identifier
 });
-var trackerContentSchema = z5.strictObject({
+var trackerContentSchema = z6.strictObject({
   tracker: identifier,
-  source: z5.literal("x"),
+  source: z6.literal("x"),
   evidence: trackerEvidenceSchema,
   content: xContentBodySchema,
   observedAt: timestamp,
-  removed: z5.boolean(),
-  attribution: z5.discriminatedUnion("kind", [
-    z5.strictObject({
+  removed: z6.boolean(),
+  attribution: z6.discriminatedUnion("kind", [
+    z6.strictObject({
       ...attributionContext,
-      kind: z5.literal("linked"),
-      account: z5.strictObject({
-        provider: z5.literal("x"),
-        issuer: z5.string().min(1),
+      kind: z6.literal("linked"),
+      account: z6.strictObject({
+        provider: z6.literal("x"),
+        issuer: z6.string().min(1),
         subject: externalId,
         revision: count,
         linkedAt: timestamp.nullable()
       })
     }),
-    z5.strictObject({ ...attributionContext, kind: z5.literal("unlinked") }),
-    z5.strictObject({
+    z6.strictObject({ ...attributionContext, kind: z6.literal("unlinked") }),
+    z6.strictObject({
       ...attributionContext,
-      kind: z5.literal("different-author")
+      kind: z6.literal("different-author")
     })
   ])
 });
-var identityKindSchema = z5.enum(["wallet", "x", "discord", "member"]);
-var accountRoleSchema = z5.string().regex(
+var identityKindSchema = z6.enum(["wallet", "x", "discord", "member"]);
+var accountRoleSchema = z6.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 = (values) => new Set(values).size === values.length;
-var xSearchSourceSchema = z5.object({
-  kind: z5.literal("x-search"),
-  query: z5.string().trim().min(1).max(2e3)
+var xSearchSourceSchema = z6.object({
+  kind: z6.literal("x-search"),
+  query: z6.string().trim().min(1).max(2e3)
 }).strict();
-var customSourceSchema = z5.object({
-  kind: z5.literal("custom"),
+var customSourceSchema = z6.object({
+  kind: z6.literal("custom"),
   namespace: identifier,
   /**
    * The identity kinds a record's author and named accounts can be, attributed to members
    * through verified links. Omitted when authors are opaque IDs, which no quest can pay.
    */
-  identities: z5.array(identityKindSchema).min(1).max(4).refine(distinct, "List each identity kind once").optional(),
+  identities: z6.array(identityKindSchema).min(1).max(4).refine(distinct, "List each identity kind once").optional(),
   /** Roles of the named accounts records can carry besides their author, such as `recipient`. */
-  accounts: z5.array(accountRoleSchema).min(1).max(10).refine(distinct, "List each account role once").refine(
+  accounts: z6.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(),
@@ -726,7 +770,7 @@ var customSourceSchema = z5.object({
    *
    * @deprecated Use `identities: ["wallet"]`.
    */
-  authors: z5.literal("wallet").optional(),
+  authors: z6.literal("wallet").optional(),
   /**
    * The schema every record's `data` matches, which ingestion enforces. `customSource()`
    * requires it. Trackers published before typed data have none, and take no records until
@@ -740,93 +784,106 @@ var customSourceSchema = z5.object({
   (source) => !source.accounts || source.identities,
   "Named accounts need identities"
 );
-var trackerSourceSchema = z5.discriminatedUnion("kind", [
+var trackerSourceSchema = z6.discriminatedUnion("kind", [
   xSearchSourceSchema,
-  customSourceSchema
+  customSourceSchema,
+  discordMessagesSourceSchema,
+  discordReactionsSourceSchema
 ]);
+var trackerSourceKinds = [
+  "x-search",
+  "custom",
+  "discord-messages",
+  "discord-reactions"
+];
 function sourceIdentities(source) {
-  if (source.kind === "x-search") {
-    return ["x"];
+  switch (source.kind) {
+    case "x-search":
+      return ["x"];
+    case "discord-messages":
+    case "discord-reactions":
+      return ["discord"];
+    case "custom":
+      return source.identities ?? (source.authors === "wallet" ? ["wallet"] : void 0);
   }
-  return source.identities ?? (source.authors === "wallet" ? ["wallet"] : void 0);
 }
-var windowSchema = z5.object({ start: timestamp, end: timestamp.optional() }).strict().refine(
+var windowSchema = z6.object({ start: timestamp, end: timestamp.optional() }).strict().refine(
   (w) => w.end === void 0 || w.end > w.start,
   "End must follow start"
 );
-var trackerDefinitionSchema = z5.object({
+var trackerDefinitionSchema = z6.object({
   key: identifier,
-  title: z5.string().trim().min(1).max(120),
+  title: z6.string().trim().min(1).max(120),
   source: trackerSourceSchema,
   window: windowSchema,
-  refreshSeconds: z5.number().int().min(300).max(86400).default(21600),
-  maxPages: z5.number().int().min(1).max(1e3).default(60)
+  refreshSeconds: z6.number().int().min(300).max(86400).default(21600),
+  maxPages: z6.number().int().min(1).max(1e3).default(60)
 }).strict();
-var trackerArtifactSchema = z5.union([
+var trackerArtifactSchema = z6.union([
   trackerDefinitionSchema,
-  z5.object({ code: z5.string().min(1).max(2e6) }).strict()
+  z6.object({ code: z6.string().min(1).max(2e6) }).strict()
 ]);
-var publishedTrackerSchema = z5.object({
+var publishedTrackerSchema = z6.object({
   id: identifier,
   version: identifier,
   definition: trackerDefinitionSchema,
   publishedAt: timestamp,
-  actor: z5.string().nullable()
+  actor: z6.string().nullable()
 });
-var trackerStatusSchema = z5.object({
+var trackerStatusSchema = z6.object({
   published: publishedTrackerSchema,
-  paused: z5.boolean(),
-  state: z5.enum(["idle", "syncing", "error", "complete"]),
+  paused: z6.boolean(),
+  state: z6.enum(["idle", "syncing", "error", "complete"]),
   lastStartedAt: timestamp.nullable(),
   lastCompletedAt: timestamp.nullable(),
   nextSyncAt: timestamp.nullable(),
-  coverage: z5.enum(["unknown", "partial", "complete"]),
-  error: z5.string().nullable(),
+  coverage: z6.enum(["unknown", "partial", "complete"]),
+  error: z6.string().nullable(),
   records: count
 });
-var trackerControlSchema = z5.object({
+var trackerControlSchema = z6.object({
   actionId: identifier,
-  action: z5.enum(["pause", "resume", "refresh"])
+  action: z6.enum(["pause", "resume", "refresh"])
 }).strict();
-var trackerAccountSchema = z5.strictObject({
+var trackerAccountSchema = z6.strictObject({
   kind: identityKindSchema.optional(),
   id: externalId
 });
-var trackerRecordInputSchema = z5.object({
+var trackerRecordInputSchema = z6.object({
   id: externalId,
   occurredAt: timestamp,
   observedAt: timestamp,
-  author: z5.object({
+  author: z6.object({
     id: externalId,
-    verified: z5.boolean().nullable().default(null),
+    verified: z6.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: z5.record(accountRoleSchema, trackerAccountSchema).refine(
+  accounts: z6.record(accountRoleSchema, trackerAccountSchema).refine(
     (accounts) => Object.keys(accounts).length <= 10,
     "At most 10 accounts"
   ).optional(),
-  data: z5.record(z5.string(), z5.json()),
-  removed: z5.boolean().default(false)
+  data: z6.record(z6.string(), z6.json()),
+  removed: z6.boolean().default(false)
 }).strict().refine(
   (v) => new TextEncoder().encode(JSON.stringify(v.data)).byteLength <= 131072,
   "Record exceeds 128 KB"
 );
 var trackerRecordSchema = trackerRecordInputSchema.safeExtend({
-  source: z5.string(),
+  source: z6.string(),
   firstSeenAt: timestamp,
   /** Present only when includeEvidence is true; custom sources have no X evidence. */
   evidence: trackerEvidenceSchema.nullable().optional()
 });
-var trackerIngestSchema = z5.object({
+var trackerIngestSchema = z6.object({
   actionId: identifier,
-  records: z5.array(trackerRecordInputSchema).min(1).max(100)
+  records: z6.array(trackerRecordInputSchema).min(1).max(100)
 }).strict();
-var trackerIngestResultSchema = z5.object({
+var trackerIngestResultSchema = z6.object({
   stored: count,
   /** Tracker-trigger decisions this ingest caused. Absent from servers without tracker triggers. */
-  admissions: z5.object({
+  admissions: z6.object({
     admitted: count,
     skipped: count,
     /**
@@ -847,11 +904,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: z5.string().nullable(),
+  account: z6.string().nullable(),
   createdAt: timestamp,
   updatedAt: timestamp,
   /** Null for automatic decisions; the staff actor after a retry. */
-  actor: z5.string().nullable()
+  actor: z6.string().nullable()
 };
 var trackerSkipCodes = [
   /** The quest is paused or no longer active. */
@@ -884,84 +941,84 @@ var trackerSkipCodes = [
   /** The attributed member has not completed the quest's prerequisites. */
   "prerequisites-incomplete"
 ];
-var trackerOutcomeSchema = z5.discriminatedUnion("state", [
-  z5.strictObject({
+var trackerOutcomeSchema = z6.discriminatedUnion("state", [
+  z6.strictObject({
     ...trackerOutcomeFields,
-    state: z5.literal("admitted"),
-    code: z5.null(),
-    reason: z5.null(),
+    state: z6.literal("admitted"),
+    code: z6.null(),
+    reason: z6.null(),
     /** The attributed member. */
     member: identifier,
     /** The admitted attempt. Its evaluation, decision and rewards live on the attempt. */
     attempt: identifier
   }),
-  z5.strictObject({
+  z6.strictObject({
     ...trackerOutcomeFields,
-    state: z5.literal("skipped"),
+    state: z6.literal("skipped"),
     /** Why the observation was skipped, as one of `trackerSkipCodes`. */
-    code: z5.string().min(1),
+    code: z6.string().min(1),
     /** Why the observation was skipped, for people. */
-    reason: z5.string(),
+    reason: z6.string(),
     /** The attributed member, when attribution got that far. */
     member: identifier.nullable(),
     attempt: identifier.nullable()
   })
 ]);
-var trackerOutcomeQuerySchema = z5.strictObject({
+var trackerOutcomeQuerySchema = z6.strictObject({
   /** Quest key or ID. */
   quest: identifier.optional(),
   record: externalId.optional(),
   member: identifier.optional(),
-  state: z5.enum(["admitted", "skipped"]).optional(),
+  state: z6.enum(["admitted", "skipped"]).optional(),
   /** Only skips with this code, such as `unlinked-account`. */
-  code: z5.string().min(1).max(100).optional(),
-  limit: z5.coerce.number().int().min(1).max(100).default(25),
+  code: z6.string().min(1).max(100).optional(),
+  limit: z6.coerce.number().int().min(1).max(100).default(25),
   /** Opaque cursor from `next`: older outcomes. */
-  before: z5.string().max(512).optional()
+  before: z6.string().max(512).optional()
 });
-var trackerOutcomePageSchema = z5.strictObject({
+var trackerOutcomePageSchema = z6.strictObject({
   /** Newest first. */
-  items: z5.array(trackerOutcomeSchema).max(100),
-  next: z5.string().nullable()
+  items: z6.array(trackerOutcomeSchema).max(100),
+  next: z6.string().nullable()
 });
-var trackerOutcomeRetrySchema = z5.strictObject({
+var trackerOutcomeRetrySchema = z6.strictObject({
   actionId: identifier,
   /** Quest key or ID. */
   quest: identifier,
   record: externalId,
   observedAt: timestamp
 });
-var booleanQuery = z5.union([
-  z5.boolean(),
-  z5.enum(["true", "false"]).transform((v) => v === "true")
+var booleanQuery = z6.union([
+  z6.boolean(),
+  z6.enum(["true", "false"]).transform((v) => v === "true")
 ]);
-var trackerQuerySchema = z5.object({
+var trackerQuerySchema = z6.object({
   author: externalId.optional(),
   member: identifier.optional(),
   verified: booleanQuery.optional(),
-  since: z5.coerce.number().int().safe().nonnegative().optional(),
-  until: z5.coerce.number().int().safe().nonnegative().optional(),
+  since: z6.coerce.number().int().safe().nonnegative().optional(),
+  until: z6.coerce.number().int().safe().nonnegative().optional(),
   removed: booleanQuery.default(false),
-  minLikes: z5.coerce.number().int().safe().nonnegative().optional(),
-  minViews: z5.coerce.number().int().safe().nonnegative().optional(),
-  limit: z5.coerce.number().int().min(1).max(100).default(25),
-  cursor: z5.string().max(2048).optional(),
+  minLikes: z6.coerce.number().int().safe().nonnegative().optional(),
+  minViews: z6.coerce.number().int().safe().nonnegative().optional(),
+  limit: z6.coerce.number().int().min(1).max(100).default(25),
+  cursor: z6.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 = z5.object({
+var trackerPageSchema = z6.object({
   tracker: identifier,
-  items: z5.array(trackerRecordSchema),
-  nextCursor: z5.string().nullable(),
+  items: z6.array(trackerRecordSchema),
+  nextCursor: z6.string().nullable(),
   total: count,
   status: trackerStatusSchema
 });
-var trackerSummarySchema = z5.object({
+var trackerSummarySchema = z6.object({
   records: count,
   authors: count,
-  metrics: z5.object({
+  metrics: z6.object({
     likes: count,
     replies: count,
     reposts: count,
@@ -977,31 +1034,31 @@ var trackerPreviewLimits = {
   posts: 100,
   days: 30
 };
-var trackerPreviewInputSchema = z5.object({
+var trackerPreviewInputSchema = z6.object({
   query: xSearchSourceSchema.shape.query,
   /** Start of the searched window. The window ends when the sample is fetched. */
   since: timestamp
 }).strict();
-var trackerPreviewSchema = z5.object({
-  query: z5.string(),
+var trackerPreviewSchema = z6.object({
+  query: z6.string(),
   since: timestamp,
   fetchedAt: timestamp,
   pages: count,
   /** Every match in the sample, newest first, verified or not. */
-  posts: z5.array(xTweetSchema).max(trackerPreviewLimits.posts),
+  posts: z6.array(xTweetSchema).max(trackerPreviewLimits.posts),
   /** X had more matches than the sample holds. */
-  more: z5.boolean()
+  more: z6.boolean()
 });
 
 // src/content.ts
-import { z as z6 } from "zod";
-var timestamp2 = z6.number().int().safe().nonnegative().max(864e13);
-var contentPolicySchema = z6.strictObject({
+import { z as z7 } from "zod";
+var timestamp2 = z7.number().int().safe().nonnegative().max(864e13);
+var contentPolicySchema = z7.strictObject({
   tracker: identifier,
   window: trackerDefinitionSchema.shape.window,
-  enrollment: z6.enum(["none", "required"]).default("none"),
-  posts: z6.enum(["after-enrollment", "since-start"]).default("after-enrollment"),
-  historical: z6.enum(["automatic", "claim", "staff"]).default("claim")
+  enrollment: z7.enum(["none", "required"]).default("none"),
+  posts: z7.enum(["after-enrollment", "since-start"]).default("after-enrollment"),
+  historical: z7.enum(["automatic", "claim", "staff"]).default("claim")
 });
 var admittedContentSchema = xContentBodySchema.extend({
   tracker: identifier,
@@ -1009,59 +1066,59 @@ var admittedContentSchema = xContentBodySchema.extend({
   observation: identifier,
   attribution: trackerContentSchema.shape.attribution.options[0],
   enrolledAt: timestamp2.nullable(),
-  completionKey: z6.string().min(1).max(200)
+  completionKey: z7.string().min(1).max(200)
 });
-var contentEnrollmentInputSchema = z6.strictObject({
+var contentEnrollmentInputSchema = z7.strictObject({
   actionId: identifier,
   quest: identifier,
   member: identifier
 });
-var contentEnrollmentSchema = z6.strictObject({
+var contentEnrollmentSchema = z7.strictObject({
   quest: identifier,
   member: identifier,
   enrolledAt: timestamp2
 });
 var contentReleaseInputSchema = contentEnrollmentInputSchema.extend({
-  content: z6.string().min(1).max(256)
+  content: z7.string().min(1).max(256)
 });
-var contentAdmissionSchema = z6.strictObject({
+var contentAdmissionSchema = z7.strictObject({
   quest: identifier,
-  content: z6.string().min(1).max(256),
+  content: z7.string().min(1).max(256),
   release: identifier,
-  state: z6.enum(["pending", "admitted", "excluded"]),
-  reason: z6.string().nullable(),
+  state: z7.enum(["pending", "admitted", "excluded"]),
+  reason: z7.string().nullable(),
   attempt: identifier.nullable()
 });
-var contentAdmissionQuerySchema = z6.strictObject({
+var contentAdmissionQuerySchema = z7.strictObject({
   quest: identifier,
   member: identifier.optional(),
-  content: z6.string().min(1).max(256).optional(),
+  content: z7.string().min(1).max(256).optional(),
   cursor: pageCursorSchema.optional()
 });
-var contentAdmissionPageSchema = z6.strictObject({
-  items: z6.array(contentAdmissionSchema),
+var contentAdmissionPageSchema = z7.strictObject({
+  items: z7.array(contentAdmissionSchema),
   nextCursor: pageCursorSchema.nullable()
 });
-var contentQualificationDecisionSchema = z6.strictObject({
-  kind: z6.enum(["accept", "reject", "review", "superseded"]),
-  reason: z6.string().nullable()
+var contentQualificationDecisionSchema = z7.strictObject({
+  kind: z7.enum(["accept", "reject", "review", "superseded"]),
+  reason: z7.string().nullable()
 });
-var contentQualificationQuerySchema = z6.strictObject({
+var contentQualificationQuerySchema = z7.strictObject({
   quest: identifier,
   member: identifier.optional(),
-  content: z6.string().min(1).max(256).optional(),
+  content: z7.string().min(1).max(256).optional(),
   cursor: pageCursorSchema.optional()
 });
-var contentQualificationSchema = z6.strictObject({
+var contentQualificationSchema = z7.strictObject({
   quest: identifier,
-  content: z6.string(),
+  content: z7.string(),
   member: identifier,
   release: identifier,
   attempt: identifier,
   revision: identifier,
   observation: identifier,
-  current: z6.boolean(),
-  state: z6.enum([
+  current: z7.boolean(),
+  state: z7.enum([
     "pending",
     "qualified",
     "unqualified",
@@ -1072,18 +1129,18 @@ var contentQualificationSchema = z6.strictObject({
     "blocked",
     "unavailable"
   ]),
-  reason: z6.string().nullable(),
-  reward: z6.strictObject({
+  reason: z7.string().nullable(),
+  reward: z7.strictObject({
     attempt: identifier.nullable(),
     completion: identifier.nullable(),
-    state: z6.enum(["unresolved", "awarded", "excluded"])
+    state: z7.enum(["unresolved", "awarded", "excluded"])
   })
 });
-var contentQualificationPageSchema = z6.strictObject({
-  items: z6.array(contentQualificationSchema),
+var contentQualificationPageSchema = z7.strictObject({
+  items: z7.array(contentQualificationSchema),
   nextCursor: pageCursorSchema.nullable()
 });
-var contentMetricSchema = z6.enum([
+var contentMetricSchema = z7.enum([
   "likes",
   "replies",
   "reposts",
@@ -1091,21 +1148,21 @@ var contentMetricSchema = z6.enum([
   "views",
   "bookmarks"
 ]);
-var contentMetricsSchema = z6.partialRecord(
+var contentMetricsSchema = z7.partialRecord(
   contentMetricSchema,
-  z6.number().int().safe().nonnegative()
+  z7.number().int().safe().nonnegative()
 );
-var contentPerformancePolicySchema = z6.strictObject({
-  metrics: z6.array(contentMetricSchema).min(1).max(6).refine(
+var contentPerformancePolicySchema = z7.strictObject({
+  metrics: z7.array(contentMetricSchema).min(1).max(6).refine(
     (values) => new Set(values).size === values.length,
     "Metrics must be unique"
   ),
-  maxAgeMs: z6.number().int().positive().max(864e5).default(36e5)
+  maxAgeMs: z7.number().int().positive().max(864e5).default(36e5)
 });
 
 // src/calendar.ts
-import { z as z7 } from "zod";
-var timestamp3 = z7.number().int().safe();
+import { z as z8 } from "zod";
+var timestamp3 = z8.number().int().safe();
 var fixedOffset = /^(?:[+-]|(?:Etc\/)?GMT[+-]\d|(?:EST|MST|HST)$)/i;
 function canonicalTimeZone(zone) {
   let resolved;
@@ -1121,18 +1178,18 @@ function canonicalTimeZone(zone) {
   }
   return fixedOffset.test(zone) || fixedOffset.test(resolved) ? null : resolved;
 }
-var timeZoneSchema = z7.string().min(1).max(100).transform((zone, ctx) => {
+var timeZoneSchema = z8.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 z7.NEVER;
+    return z8.NEVER;
   }
   return canonical;
 });
-var timeZoneNameSchema = z7.string().min(1).max(100);
+var timeZoneNameSchema = z8.string().min(1).max(100);
 var movedTimeZone = (what) => `${what} no longer take a timeZone: they follow the project calendar. Set calendar.timeZone in relay.json or in Console settings.`;
 var record = (value) => typeof value === "object" && value !== null;
 function refuseStreakTimeZone(value, ctx) {
@@ -1156,99 +1213,99 @@ function refuseWindowTimeZone(value, ctx) {
   }
   return value;
 }
-var calendarPeriodSchema = z7.enum(["lifetime", "day", "week", "month"]);
-var projectCalendarSchema = z7.object({
+var calendarPeriodSchema = z8.enum(["lifetime", "day", "week", "month"]);
+var projectCalendarSchema = z8.object({
   /** The timezone of the current calendar day. */
   timeZone: timeZoneNameSchema,
   /** The current calendar date, such as `2026-10-01`. */
-  today: z7.string(),
+  today: z8.string(),
   /** When the current calendar day ends, in epoch milliseconds. */
   nextBoundary: timestamp3,
   /** A change that takes effect at the next day boundary, or null. */
-  pending: z7.object({ timeZone: timeZoneNameSchema, effectiveAt: timestamp3 }).nullable(),
+  pending: z8.object({ timeZone: timeZoneNameSchema, effectiveAt: timestamp3 }).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: z7.string().nullable().default(null)
+  unsupported: z8.string().nullable().default(null)
 });
-var projectCalendarInputSchema = z7.object({
+var projectCalendarInputSchema = z8.object({
   actionId: identifier,
   timeZone: timeZoneSchema,
-  reason: z7.string().trim().min(1).max(500)
+  reason: z8.string().trim().min(1).max(500)
 }).strict();
-var projectCalendarDeclarationSchema = z7.object({ timeZone: timeZoneSchema }).strict();
+var projectCalendarDeclarationSchema = z8.object({ timeZone: timeZoneSchema }).strict();
 
 // src/streaks.ts
-import { z as z8 } from "zod";
-var streakPolicySchema = z8.object({
-  kind: z8.literal("streak"),
-  days: z8.number().int().min(1).max(3650)
-});
-var streakProgressSchema = z8.object({
-  goal: z8.number().int().positive(),
-  current: z8.number().int().nonnegative(),
-  best: z8.number().int().nonnegative(),
-  today: z8.string(),
-  todayQualified: z8.boolean(),
+import { z as z9 } from "zod";
+var streakPolicySchema = z9.object({
+  kind: z9.literal("streak"),
+  days: z9.number().int().min(1).max(3650)
+});
+var streakProgressSchema = z9.object({
+  goal: z9.number().int().positive(),
+  current: z9.number().int().nonnegative(),
+  best: z9.number().int().nonnegative(),
+  today: z9.string(),
+  todayQualified: z9.boolean(),
   timeZone: timeZoneNameSchema,
-  nextBoundary: z8.number().int(),
-  pendingTimeZone: z8.object({
+  nextBoundary: z9.number().int(),
+  pendingTimeZone: z9.object({
     timeZone: timeZoneNameSchema,
-    effectiveAt: z8.number().int()
+    effectiveAt: z9.number().int()
   }).nullable(),
-  days: z8.array(
-    z8.object({
-      day: z8.number().int(),
-      date: z8.string(),
+  days: z9.array(
+    z9.object({
+      day: z9.number().int(),
+      date: z9.string(),
       // The zone the day was recorded in, as stored: days from before v1 can name a fixed offset.
-      timeZone: z8.string(),
-      occurredAt: z8.number().int()
+      timeZone: z9.string(),
+      occurredAt: z9.number().int()
     })
   ),
-  milestone: z8.discriminatedUnion("status", [
-    z8.object({ status: z8.literal("pending") }),
-    z8.object({
-      status: z8.literal("awarded"),
-      completion: z8.string(),
-      achievedAt: z8.number().int()
+  milestone: z9.discriminatedUnion("status", [
+    z9.object({ status: z9.literal("pending") }),
+    z9.object({
+      status: z9.literal("awarded"),
+      completion: z9.string(),
+      achievedAt: z9.number().int()
     }),
-    z8.object({
-      status: z8.literal("budget-exhausted"),
-      budget: z8.string(),
-      achievedAt: z8.number().int()
+    z9.object({
+      status: z9.literal("budget-exhausted"),
+      budget: z9.string(),
+      achievedAt: z9.number().int()
     })
   ])
 });
 
 // src/tracker-triggers.ts
-import { z as z9 } from "zod";
-var timestamp4 = z9.number().int().safe().nonnegative().max(864e13);
-var count2 = z9.number().int().safe().nonnegative();
-var trackerTriggerModeSchema = z9.enum([
+import { z as z10 } from "zod";
+var timestamp4 = z10.number().int().safe().nonnegative().max(864e13);
+var count2 = z10.number().int().safe().nonnegative();
+var trackerTriggerModeSchema = z10.enum([
   "new-record",
   "new-observation",
   "data-changed"
 ]);
 function defaultTriggerMode(source) {
-  return source === "x-search" ? "new-record" : "new-observation";
+  return source === "custom" ? "new-observation" : "new-record";
 }
-var trackerBoundSchema = z9.union([
-  z9.number().finite(),
-  z9.strictObject({ setting: z9.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/) })
+var trackerBoundSchema = z10.union([
+  z10.number().finite(),
+  z10.strictObject({ setting: z10.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/) })
 ]);
-var dataPath = z9.string().max(200).regex(
+var dataPath = z10.string().max(200).regex(
   /^[^.\s]+(\.[^.\s]+)*$/,
   "Use dot-separated keys, such as metrics.likes"
 );
-var trackerConditionSchema = z9.union([
-  z9.strictObject({
+var trackerConditionSchema = z10.union([
+  z10.strictObject({
     path: dataPath,
-    equals: z9.union([z9.string().max(1e3), z9.number().finite(), z9.boolean()])
+    equals: z10.union([z10.string().max(1e3), z10.number().finite(), z10.boolean()])
   }),
-  z9.strictObject({
+  z10.strictObject({
     path: dataPath,
     gt: trackerBoundSchema.optional(),
     gte: trackerBoundSchema.optional(),
@@ -1261,9 +1318,9 @@ var trackerConditionSchema = z9.union([
     "Compare with equals, gt, gte, lt or lte"
   )
 ]);
-var trackerWhereSchema = z9.union([
+var trackerWhereSchema = z10.union([
   trackerConditionSchema,
-  z9.array(trackerConditionSchema).min(1).max(10)
+  z10.array(trackerConditionSchema).min(1).max(10)
 ]);
 function whereConditions(where) {
   return where === void 0 ? [] : Array.isArray(where) ? where : [where];
@@ -1275,19 +1332,23 @@ function whereSettings(where) {
     )
   );
 }
-var trackerTriggerPolicySchema = z9.strictObject({
+var trackerTriggerPolicySchema = z10.strictObject({
   /** The tracker's authoring key; publication binds it to the tracker's stable ID. */
   tracker: identifier,
-  source: z9.enum(["x-search", "custom"]),
+  /**
+   * 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: z10.string().min(1).max(100),
   /** Which observations fire; absent means the source's default (`defaultTriggerMode`). */
   on: trackerTriggerModeSchema.optional(),
   where: trackerWhereSchema.optional(),
   /**
-   * The record account the quest pays: `author`, `inReplyTo` for an X post, or a named account of
-   * a custom record. Relay attributes it through verified links; evaluators cannot redirect it.
+   * The record account the quest pays: `author`, `inReplyTo` for an X post, `messageAuthor` for a
+   * Discord reaction, or a named account of a custom record. Relay attributes it through verified links; evaluators cannot redirect it.
    * Releases published before account roles store `"replied-to"` for `inReplyTo`.
    */
-  beneficiary: z9.union([accountRoleSchema, z9.literal("replied-to")])
+  beneficiary: z10.union([accountRoleSchema, z10.literal("replied-to")])
 });
 function triggerMode(policy) {
   return policy.on ?? defaultTriggerMode(policy.source);
@@ -1296,52 +1357,52 @@ function beneficiaryRole(policy) {
   return policy.beneficiary === "replied-to" ? "inReplyTo" : policy.beneficiary;
 }
 var xLink = {
-  issuer: z9.string().min(1),
+  issuer: z10.string().min(1),
   /** The account's stable user ID. */
-  subject: z9.string().min(1).max(256),
+  subject: z10.string().min(1).max(256),
   /** The member's account selection revision. */
   revision: count2,
   /** When the member linked the account; null when unknown. */
   linkedAt: timestamp4.nullable()
 };
-var trackerAttributionSchema = z9.strictObject({
+var trackerAttributionSchema = z10.strictObject({
   member: identifier,
   capturedAt: timestamp4,
-  account: z9.discriminatedUnion("provider", [
-    z9.strictObject({
-      provider: z9.literal("wallet"),
+  account: z10.discriminatedUnion("provider", [
+    z10.strictObject({
+      provider: z10.literal("wallet"),
       /** Canonical CAIP-10 account ID, as the record names it. */
-      id: z9.string().min(5).max(256),
+      id: z10.string().min(5).max(256),
       /** The wallet link's revision. */
       revision: count2,
       /** When the member verified the wallet. */
       linkedAt: timestamp4.nullable()
     }),
-    z9.strictObject({ provider: z9.literal("x"), ...xLink }),
-    z9.strictObject({ provider: z9.literal("discord"), ...xLink }),
-    z9.strictObject({
-      provider: z9.literal("member"),
+    z10.strictObject({ provider: z10.literal("x"), ...xLink }),
+    z10.strictObject({ provider: z10.literal("discord"), ...xLink }),
+    z10.strictObject({
+      provider: z10.literal("member"),
       /** The member ID the record names. */
       id: identifier
     })
   ])
 });
-var trackerTriggerRecordSchema = z9.strictObject({
-  id: z9.string().min(1).max(256),
-  source: z9.string(),
+var trackerTriggerRecordSchema = z10.strictObject({
+  id: z10.string().min(1).max(256),
+  source: z10.string(),
   occurredAt: timestamp4,
   observedAt: timestamp4,
   firstSeenAt: timestamp4,
-  author: z9.strictObject({
-    id: z9.string().min(1).max(256),
-    verified: z9.boolean().nullable(),
+  author: z10.strictObject({
+    id: z10.string().min(1).max(256),
+    verified: z10.boolean().nullable(),
     kind: identityKindSchema.optional()
   }).nullable(),
-  accounts: z9.record(accountRoleSchema, trackerAccountSchema).optional(),
-  data: z9.record(z9.string(), z9.json()),
-  removed: z9.boolean()
+  accounts: z10.record(accountRoleSchema, trackerAccountSchema).optional(),
+  data: z10.record(z10.string(), z10.json()),
+  removed: z10.boolean()
 });
-var trackerTriggerContextSchema = z9.strictObject({
+var trackerTriggerContextSchema = z10.strictObject({
   /** The tracker's stable ID. */
   tracker: identifier,
   /** The tracker's authoring key. */
@@ -1350,111 +1411,70 @@ var trackerTriggerContextSchema = z9.strictObject({
    * The record account the attempt pays, as the quest's release names it. Releases published
    * before account roles name `inReplyTo` `"replied-to"`, which their bundled evaluators expect.
    */
-  beneficiary: z9.union([accountRoleSchema, z9.literal("replied-to")]),
+  beneficiary: z10.union([accountRoleSchema, z10.literal("replied-to")]),
   record: trackerTriggerRecordSchema,
-  /** The captured X post of this observation; null for custom trackers. */
-  x: z9.strictObject({
+  /** The captured X post of this observation; null for other trackers. */
+  x: z10.strictObject({
     evidence: trackerEvidenceSchema,
     content: xContentBodySchema
   }).nullable(),
   attribution: trackerAttributionSchema
 });
 
-// src/observations.ts
-import { z as z10 } from "zod";
-var name = z10.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
-var observationInputSchema = z10.object({
-  id: name,
-  source: name,
-  type: name,
-  member: identifier,
-  actor: z10.object({ provider: identifier, subject: z10.string().min(1).max(200) }).strict().optional(),
-  occurredAt: z10.number().int().nonnegative().max(864e13),
-  data: z10.record(z10.string(), z10.json())
-}).strict().refine(
-  (value) => JSON.stringify(value.data).length <= 32768,
-  "Observation data exceeds 32 KB"
-);
-var observationSchema = observationInputSchema.safeExtend({
-  receivedAt: z10.number().int().nonnegative()
-});
-var observationTriggerSchema = z10.object({ source: name, type: name }).strict();
-var completionPolicySchema = z10.discriminatedUnion("kind", [
+// src/completion.ts
+import { z as z11 } from "zod";
+var name = z11.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
+var completionPolicySchema = z11.discriminatedUnion("kind", [
   streakPolicySchema,
-  z10.object({ kind: z10.literal("once") }).strict(),
-  z10.object({ kind: z10.literal("keyed") }).strict()
+  z11.object({ kind: z11.literal("once") }).strict(),
+  z11.object({ kind: z11.literal("keyed") }).strict()
 ]);
-var completionKeySchema = z10.string().min(1).max(500);
-var budgetSchema = z10.object({
+var completionKeySchema = z11.string().min(1).max(500);
+var budgetSchema = z11.object({
   id: name,
-  scope: z10.enum(["member", "project"]),
+  scope: z11.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: z10.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  cost: z10.union([
-    z10.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-    z10.object({ balance: name }).strict()
+  limit: z11.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  cost: z11.union([
+    z11.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    z11.object({ balance: name }).strict()
   ])
 }).strict();
-var observationReceiptSchema = z10.object({
-  id: name,
-  source: name,
-  attempts: z10.array(z10.string()),
-  receivedAt: z10.number()
-});
-var discordReactionSchema = z10.object({
-  guildId: z10.string(),
-  channelId: z10.string(),
-  messageId: z10.string(),
-  userId: z10.string(),
-  messageAuthorId: z10.string().nullable().default(null),
-  actorRoles: z10.array(z10.string()).default([]),
-  emoji: z10.object({ id: z10.string().nullable(), name: z10.string() }),
-  messagePublishedAt: z10.number()
-}).strict();
-var discordMessageSchema = z10.object({
-  guildId: z10.string(),
-  channelId: z10.string(),
-  messageId: z10.string(),
-  userId: z10.string(),
-  content: z10.string().nullable(),
-  replyTo: z10.string().nullable(),
-  publishedAt: z10.number()
-}).strict();
 
 // src/integrations.ts
-import { z as z11 } from "zod";
-var integrationProviderSchema = z11.enum(["discord"]);
-var discordServerSchema = z11.object({
-  id: z11.string().regex(/^[0-9]{1,20}$/),
-  name: z11.string().min(1),
-  icon: z11.string().nullable()
+import { z as z12 } from "zod";
+var integrationProviderSchema = z12.enum(["discord"]);
+var discordServerSchema = z12.object({
+  id: z12.string().regex(/^[0-9]{1,20}$/),
+  name: z12.string().min(1),
+  icon: z12.string().nullable()
 });
-var projectIntegrationSchema = z11.object({
+var projectIntegrationSchema = z12.object({
   provider: integrationProviderSchema,
-  configured: z11.boolean(),
-  status: z11.enum(["disconnected", "ready", "attention"]),
-  revision: z11.number().int().nonnegative(),
+  configured: z12.boolean(),
+  status: z12.enum(["disconnected", "ready", "attention"]),
+  revision: z12.number().int().nonnegative(),
   server: discordServerSchema.nullable(),
-  issue: z11.string().nullable(),
-  connectedAt: z11.number().default(0)
+  issue: z12.string().nullable(),
+  connectedAt: z12.number().default(0)
 });
 
 // src/submission-input.ts
-import { z as z12 } from "zod";
-var textOptionsSchema = z12.object({
-  required: z12.boolean().default(true),
-  minLength: z12.number().int().min(0).max(1e4).default(1),
-  maxLength: z12.number().int().min(1).max(1e4).default(1e4)
+import { z as z13 } from "zod";
+var textOptionsSchema = z13.object({
+  required: z13.boolean().default(true),
+  minLength: z13.number().int().min(0).max(1e4).default(1),
+  maxLength: z13.number().int().min(1).max(1e4).default(1e4)
 }).strict().refine(
   (v) => v.minLength <= v.maxLength,
   "minLength must not exceed maxLength"
 );
-var hostSchema = z12.string().min(1).max(253).refine((host) => {
+var hostSchema = z13.string().min(1).max(253).refine((host) => {
   if (!/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/i.test(host) || host.includes("..")) {
     return false;
   }
@@ -1465,13 +1485,13 @@ var hostSchema = z12.string().min(1).max(253).refine((host) => {
     return false;
   }
 }, "Use a hostname without a scheme, path, port, or wildcard");
-var urlOptionsSchema = z12.object({
-  required: z12.boolean().default(true),
-  allowedHosts: z12.array(hostSchema).min(1).max(100).optional()
+var urlOptionsSchema = z13.object({
+  required: z13.boolean().default(true),
+  allowedHosts: z13.array(hostSchema).min(1).max(100).optional()
 }).strict();
-var textEvidenceSchema = z12.object({ kind: z12.literal("text"), value: z12.string().max(1e4) }).strict();
-var urlEvidenceSchema = z12.object({ kind: z12.literal("url"), value: z12.string().max(2048) }).strict();
-var valueEvidenceSchema = z12.discriminatedUnion("kind", [
+var textEvidenceSchema = z13.object({ kind: z13.literal("text"), value: z13.string().max(1e4) }).strict();
+var urlEvidenceSchema = z13.object({ kind: z13.literal("url"), value: z13.string().max(2048) }).strict();
+var valueEvidenceSchema = z13.discriminatedUnion("kind", [
   textEvidenceSchema,
   urlEvidenceSchema
 ]);
@@ -1534,22 +1554,22 @@ function xPostId(value) {
 }
 
 // src/quiz.ts
-import { z as z13 } from "zod";
-var quizId = z13.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
-var quizChoiceSchema = z13.object({ id: quizId, label: z13.string().trim().min(1).max(500) }).strict();
-var quizQuestionSchema = z13.object({
+import { z as z14 } from "zod";
+var quizId = z14.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
+var quizChoiceSchema = z14.object({ id: quizId, label: z14.string().trim().min(1).max(500) }).strict();
+var quizQuestionSchema = z14.object({
   id: quizId,
-  prompt: z13.string().trim().min(1).max(1e3),
-  choices: z13.array(quizChoiceSchema).min(2).max(8).refine(
+  prompt: z14.string().trim().min(1).max(1e3),
+  choices: z14.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 = z13.array(quizQuestionSchema).min(1).max(20).refine(
+var quizQuestionsSchema = z14.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 = z13.array(
+var quizContentSchema = z14.array(
   quizQuestionSchema.extend({ correct: quizId }).refine(
     (question) => question.choices.some((choice) => choice.id === question.correct),
     "Choose a correct answer from the available choices"
@@ -1560,97 +1580,97 @@ var quizContentSchema = z13.array(
 );
 
 // src/resources.ts
-import { z as z14 } from "zod";
-var channelSourceSchema = z14.object({
-  provider: z14.literal("discord"),
-  resource: z14.literal("channel"),
-  types: z14.array(z14.enum(["text", "announcement"])).min(1)
+import { z as z15 } from "zod";
+var channelSourceSchema = z15.object({
+  provider: z15.literal("discord"),
+  resource: z15.literal("channel"),
+  types: z15.array(z15.enum(["text", "announcement"])).min(1)
 }).strict();
-var resourceSourceSchema = z14.union([
-  z14.object({
-    provider: z14.literal("domino"),
-    resource: z14.literal("point-ledger")
+var resourceSourceSchema = z15.union([
+  z15.object({
+    provider: z15.literal("domino"),
+    resource: z15.literal("point-ledger")
   }).strict(),
   channelSourceSchema,
-  z14.object({
-    provider: z14.literal("discord"),
-    resource: z14.literal("role"),
-    assignable: z14.boolean().default(false)
+  z15.object({
+    provider: z15.literal("discord"),
+    resource: z15.literal("role"),
+    assignable: z15.boolean().default(false)
   }).strict()
 ]);
-var resourceRequestSchema = z14.object({
+var resourceRequestSchema = z15.object({
   source: resourceSourceSchema,
-  query: z14.string().max(100).optional(),
-  cursor: z14.string().regex(/^\d{1,6}$/).optional(),
-  ids: z14.array(z14.string().min(1).max(100)).max(50).optional()
+  query: z15.string().max(100).optional(),
+  cursor: z15.string().regex(/^\d{1,6}$/).optional(),
+  ids: z15.array(z15.string().min(1).max(100)).max(50).optional()
 }).strict();
-var resourceOptionsSchema = z14.object({
-  revision: z14.number().int(),
-  options: z14.array(
-    z14.object({
-      id: z14.string(),
-      label: z14.string(),
-      description: z14.string().optional(),
-      group: z14.string().optional(),
-      disabledReason: z14.string().optional()
+var resourceOptionsSchema = z15.object({
+  revision: z15.number().int(),
+  options: z15.array(
+    z15.object({
+      id: z15.string(),
+      label: z15.string(),
+      description: z15.string().optional(),
+      group: z15.string().optional(),
+      disabledReason: z15.string().optional()
     })
   ),
-  cursor: z14.string().nullable()
+  cursor: z15.string().nullable()
 });
 
 // src/settings.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // src/setting-values.ts
-import { z as z15 } from "zod";
-var settingInstant = z15.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
-var settingResourceId = z15.union([
-  z15.literal(""),
-  z15.string().regex(/^\S{1,200}$/)
+import { z as z16 } from "zod";
+var settingInstant = z16.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
+var settingResourceId = z16.union([
+  z16.literal(""),
+  z16.string().regex(/^\S{1,200}$/)
 ]);
 
 // src/settings.ts
-var base = { label: z16.string().min(1), description: z16.string().optional() };
-var settingFieldSchema = z16.discriminatedUnion("kind", [
-  z16.object({ ...base, kind: z16.literal("point-ledger"), default: identifier }).strict(),
-  z16.object({ ...base, kind: z16.literal("datetime"), default: settingInstant }).strict(),
-  z16.object({
+var base = { label: z17.string().min(1), description: z17.string().optional() };
+var settingFieldSchema = z17.discriminatedUnion("kind", [
+  z17.object({ ...base, kind: z17.literal("point-ledger"), default: identifier }).strict(),
+  z17.object({ ...base, kind: z17.literal("datetime"), default: settingInstant }).strict(),
+  z17.object({
     ...base,
-    kind: z16.literal("resource"),
+    kind: z17.literal("resource"),
     default: settingResourceId,
     source: resourceSourceSchema
   }).strict(),
-  z16.object({ ...base, kind: z16.literal("quiz"), default: quizContentSchema }).strict(),
-  z16.object({
+  z17.object({ ...base, kind: z17.literal("quiz"), default: quizContentSchema }).strict(),
+  z17.object({
     ...base,
-    kind: z16.literal("text"),
-    default: z16.string(),
-    minLength: z16.number().int().nonnegative(),
-    maxLength: z16.number().int().positive(),
-    multiline: z16.boolean()
+    kind: z17.literal("text"),
+    default: z17.string(),
+    minLength: z17.number().int().nonnegative(),
+    maxLength: z17.number().int().positive(),
+    multiline: z17.boolean()
   }).strict(),
-  z16.object({
+  z17.object({
     ...base,
-    kind: z16.literal("integer"),
-    default: z16.number().int(),
-    min: z16.number().int(),
-    max: z16.number().int()
+    kind: z17.literal("integer"),
+    default: z17.number().int(),
+    min: z17.number().int(),
+    max: z17.number().int()
   }).strict(),
-  z16.object({ ...base, kind: z16.literal("boolean"), default: z16.boolean() }).strict(),
-  z16.object({
+  z17.object({ ...base, kind: z17.literal("boolean"), default: z17.boolean() }).strict(),
+  z17.object({
     ...base,
-    kind: z16.literal("choice"),
-    default: z16.string(),
-    options: z16.array(z16.string().min(1)).min(1)
+    kind: z17.literal("choice"),
+    default: z17.string(),
+    options: z17.array(z17.string().min(1)).min(1)
   }).strict()
 ]);
-var settingsFieldsSchema = z16.record(
-  z16.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
+var settingsFieldsSchema = z17.record(
+  z17.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
   settingFieldSchema
 );
-var settingsValuesSchema = z16.record(
-  z16.string(),
-  z16.union([z16.string(), z16.number().finite(), z16.boolean(), quizContentSchema])
+var settingsValuesSchema = z17.record(
+  z17.string(),
+  z17.union([z17.string(), z17.number().finite(), z17.boolean(), quizContentSchema])
 );
 function parseSettings(fields, input) {
   const shape = {};
@@ -1669,20 +1689,20 @@ function parseSettings(fields, input) {
         shape[key] = quizContentSchema.default(field.default);
         break;
       case "text":
-        shape[key] = z16.string().min(field.minLength).max(field.maxLength).default(field.default);
+        shape[key] = z17.string().min(field.minLength).max(field.maxLength).default(field.default);
         break;
       case "integer":
-        shape[key] = z16.number().int().min(field.min).max(field.max).default(field.default);
+        shape[key] = z17.number().int().min(field.min).max(field.max).default(field.default);
         break;
       case "boolean":
-        shape[key] = z16.boolean().default(field.default);
+        shape[key] = z17.boolean().default(field.default);
         break;
       case "choice":
-        shape[key] = z16.enum(field.options).default(field.default);
+        shape[key] = z17.enum(field.options).default(field.default);
         break;
     }
   }
-  return settingsValuesSchema.parse(z16.object(shape).strict().parse(input));
+  return settingsValuesSchema.parse(z17.object(shape).strict().parse(input));
 }
 function missingResourceSettings(fields, values) {
   return Object.entries(fields).filter(([key, field]) => field.kind === "resource" && !values[key]).map(([key]) => key);
@@ -1692,43 +1712,43 @@ function compatibleSettingKinds(previous, next) {
 }
 
 // src/schema.ts
-import { z as z17 } from "zod";
-var pointsRewardSchema = z17.object({
-  kind: z17.literal("points").default("points"),
+import { z as z18 } from "zod";
+var pointsRewardSchema = z18.object({
+  kind: z18.literal("points").default("points"),
   balance: identifier,
-  amount: z17.number().int().min(0).max(1e4)
+  amount: z18.number().int().min(0).max(1e4)
 }).strict();
-var tieredRewardDefinitionSchema = z17.object({
+var tieredRewardDefinitionSchema = z18.object({
   id: identifier,
-  title: z17.string().min(1).max(120),
-  tiers: z17.array(
-    z17.object({ id: identifier, title: z17.string().min(1).max(120) }).strict()
+  title: z18.string().min(1).max(120),
+  tiers: z18.array(
+    z18.object({ id: identifier, title: z18.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: z17.object({ kind: z17.literal("untracked") }).strict(),
-  fulfillment: z17.object({ kind: z17.literal("staff-handover") }).strict()
+  inventory: z18.object({ kind: z18.literal("untracked") }).strict(),
+  fulfillment: z18.object({ kind: z18.literal("staff-handover") }).strict()
 }).strict();
-var tieredRewardReferenceSchema = z17.object({
+var tieredRewardReferenceSchema = z18.object({
   id: identifier,
   key: identifier.nullable()
 });
-var tierRewardSchema = z17.object({
-  kind: z17.literal("tier"),
+var tierRewardSchema = z18.object({
+  kind: z18.literal("tier"),
   reward: tieredRewardDefinitionSchema,
   tier: identifier
 }).strict().refine(
   (value) => value.reward.tiers.some((t) => t.id === value.tier),
   "Unknown reward tier"
 );
-var integrationRewardSchema = z17.object({
-  kind: z17.literal("integration"),
-  provider: z17.literal("discord"),
-  action: z17.literal("grant-role"),
-  roleId: z17.string().regex(/^[0-9]{1,20}$/)
+var integrationRewardSchema = z18.object({
+  kind: z18.literal("integration"),
+  provider: z18.literal("discord"),
+  action: z18.literal("grant-role"),
+  roleId: z18.string().regex(/^[0-9]{1,20}$/)
 }).strict();
-var rewardSchema = z17.union([
+var rewardSchema = z18.union([
   pointsRewardSchema,
   tierRewardSchema,
   integrationRewardSchema
@@ -1739,76 +1759,75 @@ function rewardKey(reward) {
   }
   return reward.kind === "points" ? "points:" + reward.balance : "tier:" + reward.reward.id;
 }
-var triggerSchema = z17.union([
-  z17.object({
-    kind: z17.literal("manual"),
-    input: z17.literal("text"),
+var triggerSchema = z18.union([
+  z18.object({
+    kind: z18.literal("manual"),
+    input: z18.literal("text"),
     constraints: textOptionsSchema,
-    actor: z17.enum(["member", "staff"]).optional()
+    actor: z18.enum(["member", "staff"]).optional()
   }).strict(),
-  z17.object({
-    kind: z17.literal("manual"),
-    input: z17.literal("url"),
+  z18.object({
+    kind: z18.literal("manual"),
+    input: z18.literal("url"),
     constraints: urlOptionsSchema,
-    actor: z17.enum(["member", "staff"]).optional()
+    actor: z18.enum(["member", "staff"]).optional()
   }).strict(),
-  z17.object({
-    kind: z17.literal("manual"),
-    input: z17.enum(["photo", "quiz", "none"]),
-    actor: z17.enum(["member", "staff"]).optional()
+  z18.object({
+    kind: z18.literal("manual"),
+    input: z18.enum(["photo", "quiz", "none"]),
+    actor: z18.enum(["member", "staff"]).optional()
   }).strict(),
-  z17.object({
-    kind: z17.literal("automatic"),
-    observation: observationTriggerSchema.optional(),
+  z18.object({
+    kind: z18.literal("automatic"),
     content: contentPolicySchema.optional(),
     tracker: trackerTriggerPolicySchema.optional()
   }).strict().refine(
-    (value) => [value.observation, value.content, value.tracker].filter(Boolean).length <= 1,
+    (value) => !(value.content && value.tracker),
     "Choose one automatic trigger source"
   )
 ]);
-var prerequisiteSchema = z17.object({ quest: identifier });
-var photoResultSchema = z17.object({
-  kind: z17.enum(["pass", "fail", "unclear"]),
-  reason: z17.string().min(1).max(2e3)
+var prerequisiteSchema = z18.object({ quest: identifier });
+var photoResultSchema = z18.object({
+  kind: z18.enum(["pass", "fail", "unclear"]),
+  reason: z18.string().min(1).max(2e3)
 }).strict();
-var textReviewInputSchema = z17.object({
-  text: z17.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
-  criteria: z17.string().trim().min(1).max(2e3)
+var textReviewInputSchema = z18.object({
+  text: z18.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
+  criteria: z18.string().trim().min(1).max(2e3)
 }).strict();
 var textResultSchema = photoResultSchema;
-var decisionSchema = z17.discriminatedUnion("kind", [
-  z17.object({
-    kind: z17.literal("accept"),
-    rewards: z17.array(rewardSchema).max(10),
+var decisionSchema = z18.discriminatedUnion("kind", [
+  z18.object({
+    kind: z18.literal("accept"),
+    rewards: z18.array(rewardSchema).max(10),
     completionKey: completionKeySchema.optional()
   }).strict(),
-  z17.object({
-    kind: z17.literal("reject"),
-    reason: z17.string().min(1).max(2e3),
+  z18.object({
+    kind: z18.literal("reject"),
+    reason: z18.string().min(1).max(2e3),
     /** The evaluator asked for human review, but review is off for the quest, so this is a reject. */
-    requestedReview: z17.literal(true).optional()
+    requestedReview: z18.literal(true).optional()
   }).strict(),
-  z17.object({
-    kind: z17.literal("review"),
-    reason: z17.string().min(1).max(2e3),
-    rewards: z17.array(rewardSchema).max(10).optional(),
+  z18.object({
+    kind: z18.literal("review"),
+    reason: z18.string().min(1).max(2e3),
+    rewards: z18.array(rewardSchema).max(10).optional(),
     completionKey: completionKeySchema.optional()
   }).strict()
 ]);
-var reviewModeSchema = z17.enum(["workers-ai"]);
-var storedReviewModeSchema = z17.enum([
+var reviewModeSchema = z18.enum(["workers-ai"]);
+var storedReviewModeSchema = z18.enum([
   "fixture-pass",
   "fixture-fail",
   "fixture-unclear",
   "fixture-error",
   "workers-ai"
 ]);
-var rewardBundleSchema = z17.array(rewardSchema).max(10).refine(
+var rewardBundleSchema = z18.array(rewardSchema).max(10).refine(
   (rewards) => new Set(rewards.map(rewardKey)).size === rewards.length,
   "Use one entry per balance or shared reward"
 );
-var mediaUrlSchema = z17.string().max(2e3).refine((value) => {
+var mediaUrlSchema = z18.string().max(2e3).refine((value) => {
   if (/^\/(?!\/)[^\\\s]*$/.test(value)) {
     return true;
   }
@@ -1818,85 +1837,85 @@ var mediaUrlSchema = z17.string().max(2e3).refine((value) => {
     return false;
   }
 }, "Use an HTTPS URL or a same-site path beginning with /");
-var questPresentationSchema = z17.object({
+var questPresentationSchema = z18.object({
   quiz: quizQuestionsSchema.optional(),
-  instructions: z17.string().max(4e3).optional(),
-  video: z17.object({
+  instructions: z18.string().max(4e3).optional(),
+  video: z18.object({
     url: mediaUrlSchema,
     poster: mediaUrlSchema.optional(),
-    captions: z17.object({
+    captions: z18.object({
       url: mediaUrlSchema,
-      language: z17.string().min(2).max(20),
-      label: z17.string().min(1).max(80)
+      language: z18.string().min(2).max(20),
+      label: z18.string().min(1).max(80)
     }).strict().optional()
   }).strict().optional()
 }).strict();
-var questProfileSchema = z17.object({ visible: z17.boolean() }).strict();
-var questDescriptionSchema = z17.object({
+var questProfileSchema = z18.object({ visible: z18.boolean() }).strict();
+var questDescriptionSchema = z18.object({
   quest: identifier,
-  runtimeVersion: z17.union([z17.literal(1), z17.literal(2)]).default(1),
-  title: z17.string().min(1).max(120),
+  runtimeVersion: z18.union([z18.literal(1), z18.literal(2)]).default(1),
+  title: z18.string().min(1).max(120),
   presentation: questPresentationSchema.default({}),
-  integrations: z17.array(integrationProviderSchema).max(10).default([]),
+  integrations: z18.array(integrationProviderSchema).max(10).default([]),
   fields: settingsFieldsSchema,
   values: settingsValuesSchema,
   rewards: rewardBundleSchema,
-  humanReview: z17.boolean(),
+  humanReview: z18.boolean(),
   trigger: triggerSchema,
   performance: contentPerformancePolicySchema.optional(),
-  requires: z17.array(prerequisiteSchema).max(30).default([]),
-  completion: z17.preprocess(refuseStreakTimeZone, completionPolicySchema),
-  visibility: z17.enum(["visible", "hidden"]).default("visible"),
+  requires: z18.array(prerequisiteSchema).max(30).default([]),
+  completion: z18.preprocess(refuseStreakTimeZone, completionPolicySchema),
+  visibility: z18.enum(["visible", "hidden"]).default("visible"),
   /**
    * Whether completions show on participant profiles (`/v1/profiles/:id/completions`). Absent
    * is hidden. Optional, not defaulted: releases carry the key only when the author sets it, so
    * clients and pods that predate it (strict release schemas) still read every other release.
    */
   profile: questProfileSchema.optional(),
-  budgets: z17.array(budgetSchema).max(20).default([])
+  budgets: z18.array(budgetSchema).max(20).default([])
 }).strict();
-var artifactSchema = z17.object({ code: z17.string().min(1).max(1e6) }).strict();
+var artifactSchema = z18.object({ code: z18.string().min(1).max(1e6) }).strict();
 var releaseSchema = artifactSchema.extend({
   settings: settingsValuesSchema,
   provider: reviewModeSchema,
   expectedRelease: identifier.nullable().optional(),
-  settingRenames: z17.record(z17.string(), z17.string()).optional()
+  settingRenames: z18.record(z18.string(), z18.string()).optional()
 }).strict();
-var batchReleaseSchema = z17.object({ releases: z17.array(releaseSchema).min(1).max(50) }).strict();
-var questSettingsInputSchema = z17.object({
+var batchReleaseSchema = z18.object({ releases: z18.array(releaseSchema).min(1).max(50) }).strict();
+var questSettingsInputSchema = z18.object({
   quest: identifier,
   expectedRelease: identifier,
   set: settingsValuesSchema,
-  reset: z17.array(z17.string())
+  reset: z18.array(z18.string())
 }).strict();
 var storedQuestDescriptionSchema = questDescriptionSchema.extend({
   completion: completionPolicySchema
 });
 var storedReleaseSchema = storedQuestDescriptionSchema.extend({
   key: identifier.optional(),
-  code: z17.string(),
+  code: z18.string(),
   provider: storedReviewModeSchema,
   id: identifier,
-  createdAt: z17.number(),
-  legacy: z17.boolean().default(false),
-  origin: z17.object({ typeVersion: identifier }).strict().optional(),
-  lifecycle: z17.enum(["active", "paused", "archived"]).default("active"),
-  configuration: z17.object({
+  createdAt: z18.number(),
+  legacy: z18.boolean().default(false),
+  origin: z18.object({ typeVersion: identifier }).strict().optional(),
+  lifecycle: z18.enum(["active", "paused", "archived"]).default("active"),
+  configuration: z18.object({
     defaults: settingsValuesSchema,
     overrides: settingsValuesSchema,
-    preserved: z17.array(z17.string())
+    preserved: z18.array(z18.string())
   }).strict().optional()
 });
-var legacyReleaseSchema = z17.object({
+var legacyReleaseSchema = z18.object({
   quest: identifier,
-  title: z17.string(),
-  criteria: z17.string(),
-  humanReview: z17.boolean(),
+  title: z18.string(),
+  criteria: z18.string(),
+  humanReview: z18.boolean(),
   rewards: rewardBundleSchema,
-  code: z17.string(),
+  code: z18.string(),
   provider: storedReviewModeSchema,
   id: identifier,
-  createdAt: z17.number()
+  createdAt: z18.number()
 }).transform((r) => {
   const { criteria, ...stored } = r;
   return storedReleaseSchema.parse({
@@ -1908,15 +1927,15 @@ var legacyReleaseSchema = z17.object({
     legacy: true
   });
 });
-var publishedReleaseSchema = z17.union([
+var publishedReleaseSchema = z18.union([
   storedReleaseSchema,
   legacyReleaseSchema
 ]);
-var templateSchema = z17.object({
-  code: z17.string(),
+var templateSchema = z18.object({
+  code: z18.string(),
   definition: questDescriptionSchema
 });
-var quizAnswersSchema = z17.record(identifier, identifier).refine(
+var quizAnswersSchema = z18.record(identifier, identifier).refine(
   (answers) => Object.keys(answers).length > 0 && Object.keys(answers).length <= 50,
   "Provide between 1 and 50 answers"
 ).transform(
@@ -1924,33 +1943,33 @@ var quizAnswersSchema = z17.record(identifier, identifier).refine(
     Object.entries(answers).sort(([a], [b]) => a.localeCompare(b))
   )
 );
-var quizEvidenceSchema = z17.object({
-  kind: z17.literal("quiz"),
+var quizEvidenceSchema = z18.object({
+  kind: z18.literal("quiz"),
   release: identifier.optional(),
   answers: quizAnswersSchema
 }).strict();
-var submissionEvidenceSchema = z17.union([
+var submissionEvidenceSchema = z18.union([
   quizEvidenceSchema,
   textEvidenceSchema,
   urlEvidenceSchema
 ]);
-var submitSchema = z17.object({
+var submitSchema = z18.object({
   actionId: identifier,
   quest: identifier,
   member: identifier,
   evidence: identifier.optional(),
   input: submissionEvidenceSchema.optional(),
   release: identifier.optional(),
-  faultAfterReview: z17.boolean().optional()
+  faultAfterReview: z18.boolean().optional()
 }).strict();
-var attemptSchema = z17.object({
+var attemptSchema = z18.object({
   id: identifier,
   release: identifier,
   quest: identifier,
   member: identifier,
   evidence: identifier.nullable(),
   input: submissionEvidenceSchema.optional(),
-  status: z17.enum([
+  status: z18.enum([
     "queued",
     "evaluating",
     "accepted",
@@ -1959,75 +1978,75 @@ var attemptSchema = z17.object({
     "needs-review",
     "failed"
   ]),
-  reason: z17.string().nullable(),
-  retries: z17.number(),
-  generation: z17.number(),
-  completion: z17.string().nullable(),
+  reason: z18.string().nullable(),
+  retries: z18.number(),
+  generation: z18.number(),
+  completion: z18.string().nullable(),
   reviewRewards: rewardBundleSchema.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: z17.boolean().default(false),
-  createdAt: z17.number()
-});
-var eventSchema = z17.object({
-  id: z17.number(),
-  attempt: z17.string().nullable(),
-  kind: z17.string(),
-  detail: z17.string(),
-  actor: z17.string().nullable().default(null),
-  at: z17.number()
-});
-var pickupSelectionSchema = z17.object({
+  requestedReview: z18.boolean().default(false),
+  createdAt: z18.number()
+});
+var eventSchema = z18.object({
+  id: z18.number(),
+  attempt: z18.string().nullable(),
+  kind: z18.string(),
+  detail: z18.string(),
+  actor: z18.string().nullable().default(null),
+  at: z18.number()
+});
+var pickupSelectionSchema = z18.object({
   item: identifier,
-  revision: z17.number().int().nonnegative()
+  revision: z18.number().int().nonnegative()
 }).strict();
-var pickupAllocationSchema = z17.object({
+var pickupAllocationSchema = z18.object({
   item: identifier,
-  label: z17.string().min(1).max(80)
+  label: z18.string().min(1).max(80)
 }).strict();
-var pickupPolicySchema = z17.discriminatedUnion("kind", [
-  z17.object({ kind: z17.literal("untracked") }).strict(),
-  z17.object({
-    kind: z17.literal("at-pickup"),
-    tiers: z17.array(
-      z17.object({
+var pickupPolicySchema = z18.discriminatedUnion("kind", [
+  z18.object({ kind: z18.literal("untracked") }).strict(),
+  z18.object({
+    kind: z18.literal("at-pickup"),
+    tiers: z18.array(
+      z18.object({
         tier: identifier,
-        variants: z17.array(pickupAllocationSchema).min(1).max(100)
+        variants: z18.array(pickupAllocationSchema).min(1).max(100)
       }).strict()
     ).min(1).max(100)
   }).strict()
 ]);
-var pickupCatalogSchema = z17.object({
+var pickupCatalogSchema = z18.object({
   reward: tieredRewardDefinitionSchema,
-  revision: z17.number().int().nonnegative(),
+  revision: z18.number().int().nonnegative(),
   policy: pickupPolicySchema
 });
-var pickupAvailabilitySchema = z17.discriminatedUnion("kind", [
-  z17.object({ kind: z17.literal("untracked") }).strict(),
-  z17.object({
-    kind: z17.literal("at-pickup"),
-    revision: z17.number().int().nonnegative(),
-    variants: z17.array(
+var pickupAvailabilitySchema = z18.discriminatedUnion("kind", [
+  z18.object({ kind: z18.literal("untracked") }).strict(),
+  z18.object({
+    kind: z18.literal("at-pickup"),
+    revision: z18.number().int().nonnegative(),
+    variants: z18.array(
       pickupAllocationSchema.extend({
-        available: z17.number().int().nonnegative()
+        available: z18.number().int().nonnegative()
       })
     )
   }).strict()
 ]);
-var configurePickupSchema = z17.object({
+var configurePickupSchema = z18.object({
   reward: identifier,
-  revision: z17.number().int().nonnegative(),
+  revision: z18.number().int().nonnegative(),
   actionId: identifier,
-  policy: z17.discriminatedUnion("kind", [
-    z17.object({ kind: z17.literal("untracked") }).strict(),
-    z17.object({
-      kind: z17.literal("at-pickup"),
-      tiers: z17.array(
-        z17.object({
+  policy: z18.discriminatedUnion("kind", [
+    z18.object({ kind: z18.literal("untracked") }).strict(),
+    z18.object({
+      kind: z18.literal("at-pickup"),
+      tiers: z18.array(
+        z18.object({
           tier: identifier,
-          variants: z17.array(
+          variants: z18.array(
             pickupAllocationSchema.extend({
               item: identifier.optional()
             })
@@ -2043,164 +2062,161 @@ var entitlementBase = {
   reward: tieredRewardDefinitionSchema,
   earnedTier: identifier,
   tier: identifier,
-  revision: z17.number().int().positive()
+  revision: z18.number().int().positive()
 };
-var entitlementSchema = z17.discriminatedUnion("status", [
-  z17.object({ ...entitlementBase, status: z17.literal("available") }).strict(),
-  z17.object({
+var entitlementSchema = z18.discriminatedUnion("status", [
+  z18.object({ ...entitlementBase, status: z18.literal("available") }).strict(),
+  z18.object({
     ...entitlementBase,
-    status: z17.literal("handing-over"),
+    status: z18.literal("handing-over"),
     handover: identifier,
-    startedAt: z17.number(),
+    startedAt: z18.number(),
     allocation: pickupAllocationSchema.optional()
   }).strict(),
-  z17.object({
+  z18.object({
     ...entitlementBase,
-    status: z17.literal("collected"),
+    status: z18.literal("collected"),
     handover: identifier,
-    startedAt: z17.number(),
+    startedAt: z18.number(),
     allocation: pickupAllocationSchema.optional(),
-    collectedAt: z17.number()
+    collectedAt: z18.number()
   }).strict()
 ]);
-var beginHandoverSchema = z17.object({
+var beginHandoverSchema = z18.object({
   actionId: identifier,
-  revision: z17.number().int().positive(),
+  revision: z18.number().int().positive(),
   selection: pickupSelectionSchema.optional()
 }).strict();
-var confirmHandoverSchema = z17.object({ actionId: identifier, handover: identifier }).strict();
-var completionRecordSchema = z17.object({
-  key: z17.string().default("once"),
+var confirmHandoverSchema = z18.object({ actionId: identifier, handover: identifier }).strict();
+var completionRecordSchema = z18.object({
+  key: z18.string().default("once"),
   id: identifier,
   quest: identifier,
   member: identifier
 });
-var questAvailabilitySchema = z17.discriminatedUnion("kind", [
-  z17.object({
-    kind: z17.literal("available"),
-    input: z17.enum(["photo", "quiz", "none", "text", "url"])
-  }).strict(),
-  z17.object({ kind: z17.literal("completed") }).strict(),
-  z17.object({
-    kind: z17.literal("locked"),
-    missing: z17.array(z17.object({ quest: identifier, title: z17.string() })).min(1)
+var questAvailabilitySchema = z18.discriminatedUnion("kind", [
+  z18.object({
+    kind: z18.literal("available"),
+    input: z18.enum(["photo", "quiz", "none", "text", "url"])
   }).strict(),
-  z17.object({ kind: z17.literal("staff-required") }).strict(),
-  z17.object({
-    kind: z17.literal("automatic"),
-    observation: observationTriggerSchema.optional()
+  z18.object({ kind: z18.literal("completed") }).strict(),
+  z18.object({
+    kind: z18.literal("locked"),
+    missing: z18.array(z18.object({ quest: identifier, title: z18.string() })).min(1)
   }).strict(),
-  z17.object({ kind: z17.literal("checking"), attempt: identifier }).strict(),
-  z17.object({ kind: z17.literal("needs-review"), attempt: identifier }).strict(),
-  z17.object({ kind: z17.literal("retryable"), attempt: identifier }).strict()
+  z18.object({ kind: z18.literal("staff-required") }).strict(),
+  z18.object({ kind: z18.literal("automatic") }).strict(),
+  z18.object({ kind: z18.literal("checking"), attempt: identifier }).strict(),
+  z18.object({ kind: z18.literal("needs-review"), attempt: identifier }).strict(),
+  z18.object({ kind: z18.literal("retryable"), attempt: identifier }).strict()
 ]);
-var memberProgressSchema = z17.object({
+var memberProgressSchema = z18.object({
   member: identifier,
-  quests: z17.array(
-    z17.object({
+  quests: z18.array(
+    z18.object({
       quest: identifier,
       key: identifier.optional(),
       release: identifier.optional(),
-      title: z17.string(),
+      title: z18.string(),
       presentation: questPresentationSchema.default({}),
-      connections: z17.array(authProviderSchema).default([]),
+      connections: z18.array(authProviderSchema).default([]),
       trigger: triggerSchema,
       availability: questAvailabilitySchema,
-      completed: z17.boolean(),
+      completed: z18.boolean(),
       completion: completionPolicySchema.default({ kind: "once" }),
       streak: streakProgressSchema.nullable().optional(),
-      completionCount: z17.number().int().nonnegative().default(0),
-      visibility: z17.enum(["visible", "hidden"]).default("visible"),
-      missing: z17.array(z17.object({ quest: identifier, title: z17.string() })),
+      completionCount: z18.number().int().nonnegative().default(0),
+      visibility: z18.enum(["visible", "hidden"]).default("visible"),
+      missing: z18.array(z18.object({ quest: identifier, title: z18.string() })),
       attempt: attemptSchema.nullable()
     })
   ),
-  entitlements: z17.array(entitlementSchema)
-});
-var snapshotSchema = z17.object({
-  releases: z17.array(publishedReleaseSchema),
-  completions: z17.array(completionRecordSchema),
-  entitlements: z17.array(entitlementSchema),
-  attempts: z17.array(attemptSchema),
-  balances: z17.array(
-    z17.object({
-      member: z17.string(),
-      balance: z17.string(),
-      earned: z17.number(),
-      held: z17.number(),
-      available: z17.number()
+  entitlements: z18.array(entitlementSchema)
+});
+var snapshotSchema = z18.object({
+  releases: z18.array(publishedReleaseSchema),
+  completions: z18.array(completionRecordSchema),
+  entitlements: z18.array(entitlementSchema),
+  attempts: z18.array(attemptSchema),
+  balances: z18.array(
+    z18.object({
+      member: z18.string(),
+      balance: z18.string(),
+      earned: z18.number(),
+      held: z18.number(),
+      available: z18.number()
     })
   ),
-  events: z17.array(eventSchema)
+  events: z18.array(eventSchema)
 });
-var evidenceSchema = z17.object({
+var evidenceSchema = z18.object({
   id: identifier,
   member: identifier,
-  type: z17.enum(["image/jpeg", "image/png"]),
-  size: z17.number()
+  type: z18.enum(["image/jpeg", "image/png"]),
+  size: z18.number()
 });
-var errorSchema = z17.object({
-  error: z17.string(),
-  code: z17.string().optional(),
-  missing: z17.array(z17.object({ quest: identifier, title: z17.string() })).optional()
+var errorSchema = z18.object({
+  error: z18.string(),
+  code: z18.string().optional(),
+  missing: z18.array(z18.object({ quest: identifier, title: z18.string() })).optional()
 });
-var staffDecisionSchema = z17.object({
+var staffDecisionSchema = z18.object({
   actionId: identifier,
-  generation: z17.number().int().nonnegative(),
-  decision: z17.enum(["accept", "reject"]),
-  reason: z17.string().trim().min(1).max(2e3)
+  generation: z18.number().int().nonnegative(),
+  decision: z18.enum(["accept", "reject"]),
+  reason: z18.string().trim().min(1).max(2e3)
 }).strict();
-var stockSchema = z17.object({ item: identifier, quantity: z17.number().int().min(0).max(1e4) }).strict();
-var reservationSchema = z17.object({
+var stockSchema = z18.object({ item: identifier, quantity: z18.number().int().min(0).max(1e4) }).strict();
+var reservationSchema = z18.object({
   actionId: identifier,
   member: identifier,
   item: identifier,
   balance: identifier,
-  price: z17.number().int().positive().max(1e4)
+  price: z18.number().int().positive().max(1e4)
 }).strict();
 var pageOptions = {
-  limit: z17.number().int().min(1).max(100).default(25),
-  cursor: z17.string().min(1).max(4096).optional()
+  limit: z18.number().int().min(1).max(100).default(25),
+  cursor: z18.string().min(1).max(4096).optional()
 };
-var reviewListSchema = z17.object({
+var reviewListSchema = z18.object({
   ...pageOptions,
   member: identifier.optional(),
   quest: identifier.optional()
 }).strict();
-var memberListSchema = z17.object({
+var memberListSchema = z18.object({
   ...pageOptions,
   prefix: identifier.optional()
 }).strict();
-var reviewItemSchema = z17.object({
+var reviewItemSchema = z18.object({
   attempt: attemptSchema,
-  title: z17.string(),
-  checks: z17.array(
-    z17.object({ criteria: z17.string(), result: photoResultSchema })
+  title: z18.string(),
+  checks: z18.array(
+    z18.object({ criteria: z18.string(), result: photoResultSchema })
   )
 });
-var reviewPageSchema = z17.object({
-  items: z17.array(reviewItemSchema).max(100),
-  nextCursor: z17.string().nullable()
+var reviewPageSchema = z18.object({
+  items: z18.array(reviewItemSchema).max(100),
+  nextCursor: z18.string().nullable()
 });
-var memberPageSchema = z17.object({
-  items: z17.array(z17.object({ member: identifier })).max(100),
-  nextCursor: z17.string().nullable()
+var memberPageSchema = z18.object({
+  items: z18.array(z18.object({ member: identifier })).max(100),
+  nextCursor: z18.string().nullable()
 });
-var createStockItemSchema = z17.object({ actionId: identifier, name: z17.string().trim().min(1).max(80) }).strict();
-var stockItemSchema = z17.object({ id: identifier, name: z17.string() });
-var contentPerformanceSnapshotSchema = z17.strictObject({
+var createStockItemSchema = z18.object({ actionId: identifier, name: z18.string().trim().min(1).max(80) }).strict();
+var stockItemSchema = z18.object({ id: identifier, name: z18.string() });
+var contentPerformanceSnapshotSchema = z18.strictObject({
   contentAttempt: identifier,
   observation: identifier,
-  observedAt: z17.number().int().safe().nonnegative(),
+  observedAt: z18.number().int().safe().nonnegative(),
   metrics: contentMetricsSchema,
   rewards: rewardBundleSchema
 });
 var contentPerformanceQuerySchema = contentQualificationQuerySchema.extend({
-  content: z17.string().min(1).max(256)
+  content: z18.string().min(1).max(256)
 });
-var contentPerformancePageSchema = z17.strictObject({
-  current: z17.strictObject({
-    state: z17.enum([
+var contentPerformancePageSchema = z18.strictObject({
+  current: z18.strictObject({
+    state: z18.enum([
       "content-pending",
       "content-unqualified",
       "waiting",
@@ -2211,19 +2227,19 @@ var contentPerformancePageSchema = z17.strictObject({
       "failed",
       "superseded"
     ]),
-    reason: z17.string().nullable(),
+    reason: z18.string().nullable(),
     contentAttempt: identifier,
     attempt: identifier.nullable(),
     reward: contentQualificationSchema.shape.reward
   }),
-  items: z17.array(
-    z17.strictObject({
+  items: z18.array(
+    z18.strictObject({
       attempt: identifier,
       contentAttempt: identifier,
       observation: identifier,
-      observedAt: z17.number(),
+      observedAt: z18.number(),
       metrics: contentMetricsSchema,
-      state: z17.enum([
+      state: z18.enum([
         "pending",
         "qualified",
         "unqualified",
@@ -2231,7 +2247,7 @@ var contentPerformancePageSchema = z17.strictObject({
         "failed",
         "superseded"
       ]),
-      reason: z17.string().nullable()
+      reason: z18.string().nullable()
     })
   ),
   nextCursor: pageCursorSchema.nullable()
@@ -2246,6 +2262,12 @@ export {
   identifier,
   pageCursorSchema,
   pageQuerySchema,
+  discordMessageSchema,
+  discordMessagesSourceSchema,
+  discordReactionsSourceSchema,
+  discordMessageDataSchema,
+  discordMessageTextDataSchema,
+  discordReactionDataSchema,
   trackerDataMaxBranches,
   trackerDataMaxEntries,
   trackerDataSchemaSchema,
@@ -2269,6 +2291,7 @@ export {
   xSearchSourceSchema,
   customSourceSchema,
   trackerSourceSchema,
+  trackerSourceKinds,
   sourceIdentities,
   trackerDefinitionSchema,
   trackerArtifactSchema,
@@ -2330,15 +2353,9 @@ export {
   trackerAttributionSchema,
   trackerTriggerRecordSchema,
   trackerTriggerContextSchema,
-  observationInputSchema,
-  observationSchema,
-  observationTriggerSchema,
   completionPolicySchema,
   completionKeySchema,
   budgetSchema,
-  observationReceiptSchema,
-  discordReactionSchema,
-  discordMessageSchema,
   integrationProviderSchema,
   discordServerSchema,
   projectIntegrationSchema,