@domino-sdk/relay 0.23.1 → 0.25.0

package/dist/{chunk-UYS522ER.js → chunk-IXLY3A7B.js}

@@ -96,12 +96,24 @@ var trackerSourceSchema = z2.discriminatedUnion("kind", [
     kind: z2.literal("x-search"),
     query: z2.string().trim().min(1).max(2e3)
   }).strict(),
-  z2.object({ kind: z2.literal("custom"), namespace: identifier }).strict()
+  z2.object({
+    kind: z2.literal("custom"),
+    namespace: identifier,
+    /**
+     * Record authors are canonical CAIP-10 wallet account IDs, attributed to members through
+     * their verified wallet links. Omitted when authors are opaque IDs.
+     */
+    authors: z2.literal("wallet").optional()
+  }).strict()
 ]);
 var x = {
   search: (input) => trackerSourceSchema.options[0].parse({ kind: "x-search", ...input })
 };
-var customSource = (namespace) => trackerSourceSchema.options[1].parse({ kind: "custom", namespace });
+var customSource = (namespace, options = {}) => trackerSourceSchema.options[1].parse({
+  kind: "custom",
+  namespace,
+  ...options
+});
 var windowSchema = z2.object({ start: timestamp, end: timestamp.optional() }).strict().refine(
   (w) => w.end === void 0 || w.end > w.start,
   "End must follow start"
@@ -167,7 +179,69 @@ var trackerIngestSchema = z2.object({
   actionId: identifier,
   records: z2.array(trackerRecordInputSchema).min(1).max(100)
 }).strict();
-var trackerIngestResultSchema = z2.object({ stored: count });
+var trackerIngestResultSchema = z2.object({
+  stored: count,
+  /** Tracker-trigger decisions this ingest caused. Absent from servers without tracker triggers. */
+  admissions: z2.object({ admitted: count, skipped: count }).optional()
+});
+var trackerOutcomeFields = {
+  /** Stable quest ID. */
+  quest: identifier,
+  /** Stable tracker ID. */
+  tracker: identifier,
+  record: externalId,
+  observedAt: timestamp,
+  /** 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: z2.string().nullable(),
+  createdAt: timestamp,
+  updatedAt: timestamp,
+  /** Null for automatic decisions; the staff actor after a retry. */
+  actor: z2.string().nullable()
+};
+var trackerOutcomeSchema = z2.discriminatedUnion("state", [
+  z2.strictObject({
+    ...trackerOutcomeFields,
+    state: z2.literal("admitted"),
+    reason: z2.null(),
+    /** The attributed member. */
+    member: identifier,
+    /** The admitted attempt. Its evaluation, decision and rewards live on the attempt. */
+    attempt: identifier
+  }),
+  z2.strictObject({
+    ...trackerOutcomeFields,
+    state: z2.literal("skipped"),
+    /** Why the observation was skipped. */
+    reason: z2.string(),
+    /** The attributed member, when attribution got that far. */
+    member: identifier.nullable(),
+    attempt: identifier.nullable()
+  })
+]);
+var trackerOutcomeQuerySchema = z2.strictObject({
+  /** Quest key or ID. */
+  quest: identifier.optional(),
+  record: externalId.optional(),
+  member: identifier.optional(),
+  state: z2.enum(["admitted", "skipped"]).optional(),
+  limit: z2.coerce.number().int().min(1).max(100).default(25),
+  /** Opaque cursor from `next`: older outcomes. */
+  before: z2.string().max(512).optional()
+});
+var trackerOutcomePageSchema = z2.strictObject({
+  /** Newest first. */
+  items: z2.array(trackerOutcomeSchema).max(100),
+  next: z2.string().nullable()
+});
+var trackerOutcomeRetrySchema = z2.strictObject({
+  actionId: identifier,
+  /** Quest key or ID. */
+  quest: identifier,
+  record: externalId,
+  observedAt: timestamp
+});
 var booleanQuery = z2.union([
   z2.boolean(),
   z2.enum(["true", "false"]).transform((v) => v === "true")
@@ -421,121 +495,190 @@ var streakProgressSchema = z4.object({
   ])
 });
 
-// src/observations.ts
+// src/tracker-triggers.ts
 import { z as z5 } from "zod";
-var name = z5.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
-var observationInputSchema = z5.object({
+var timestamp3 = z5.number().int().safe().nonnegative().max(864e13);
+var count2 = z5.number().int().safe().nonnegative();
+var trackerBeneficiarySchema = z5.enum(["author", "replied-to"]);
+var trackerTriggerPolicySchema = z5.strictObject({
+  /** The tracker's authoring key; publication binds it to the tracker's stable ID. */
+  tracker: identifier,
+  source: z5.enum(["x-search", "custom"]),
+  beneficiary: trackerBeneficiarySchema
+});
+var accountId = z5.string().min(5).max(256);
+var trackerAttributionSchema = z5.strictObject({
+  member: identifier,
+  capturedAt: timestamp3,
+  account: z5.discriminatedUnion("provider", [
+    z5.strictObject({
+      provider: z5.literal("wallet"),
+      /** Canonical CAIP-10 account ID, as the record's author. */
+      id: accountId,
+      /** The wallet link's revision. */
+      revision: count2,
+      /** When the member verified the wallet. */
+      linkedAt: timestamp3.nullable()
+    }),
+    z5.strictObject({
+      provider: z5.literal("x"),
+      issuer: z5.string().min(1),
+      /** The X account's stable user ID. */
+      subject: z5.string().min(1).max(256),
+      /** The member's X account selection revision. */
+      revision: count2,
+      /** When the member linked the X account; null when unknown. */
+      linkedAt: timestamp3.nullable()
+    })
+  ])
+});
+var trackerTriggerRecordSchema = z5.strictObject({
+  id: z5.string().min(1).max(256),
+  source: z5.string(),
+  occurredAt: timestamp3,
+  observedAt: timestamp3,
+  firstSeenAt: timestamp3,
+  author: z5.strictObject({
+    id: z5.string().min(1).max(256),
+    verified: z5.boolean().nullable()
+  }).nullable(),
+  data: z5.record(z5.string(), z5.json()),
+  removed: z5.boolean()
+});
+var trackerTriggerContextSchema = z5.strictObject({
+  /** The tracker's stable ID. */
+  tracker: identifier,
+  /** The tracker's authoring key. */
+  key: identifier,
+  beneficiary: trackerBeneficiarySchema,
+  record: trackerTriggerRecordSchema,
+  /** The captured X post of this observation; null for custom trackers. */
+  x: z5.strictObject({
+    evidence: trackerEvidenceSchema,
+    content: xContentBodySchema
+  }).nullable(),
+  attribution: trackerAttributionSchema
+});
+
+// src/observations.ts
+import { z as z6 } from "zod";
+var name = z6.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
+var observationInputSchema = z6.object({
   id: name,
   source: name,
   type: name,
   member: identifier,
-  actor: z5.object({ provider: identifier, subject: z5.string().min(1).max(200) }).strict().optional(),
-  occurredAt: z5.number().int().nonnegative().max(864e13),
-  data: z5.record(z5.string(), z5.json())
+  actor: z6.object({ provider: identifier, subject: z6.string().min(1).max(200) }).strict().optional(),
+  occurredAt: z6.number().int().nonnegative().max(864e13),
+  data: z6.record(z6.string(), z6.json())
 }).strict().refine(
   (value) => JSON.stringify(value.data).length <= 32768,
   "Observation data exceeds 32 KB"
 );
 var observationSchema = observationInputSchema.safeExtend({
-  receivedAt: z5.number().int().nonnegative()
+  receivedAt: z6.number().int().nonnegative()
 });
-var observationTriggerSchema = z5.object({ source: name, type: name }).strict();
-var completionPolicySchema = z5.discriminatedUnion("kind", [
+var observationTriggerSchema = z6.object({ source: name, type: name }).strict();
+var completionPolicySchema = z6.discriminatedUnion("kind", [
   streakPolicySchema,
-  z5.object({ kind: z5.literal("once") }).strict(),
-  z5.object({ kind: z5.literal("keyed") }).strict()
+  z6.object({ kind: z6.literal("once") }).strict(),
+  z6.object({ kind: z6.literal("keyed") }).strict()
 ]);
-var completionKeySchema = z5.string().min(1).max(500);
-var budgetSchema = z5.object({
+var completionKeySchema = z6.string().min(1).max(500);
+var budgetSchema = z6.object({
   id: name,
-  scope: z5.enum(["member", "project"]),
-  period: z5.enum(["lifetime", "day"]),
-  limit: z5.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  cost: z5.union([
-    z5.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-    z5.object({ balance: name }).strict()
+  scope: z6.enum(["member", "project"]),
+  /**
+   * `"day"` buckets by UTC date and `"week"` by ISO week (UTC, weeks start on Monday), both of
+   * the attempt's eligibility time; `"lifetime"` never resets.
+   */
+  period: z6.enum(["lifetime", "day", "week"]),
+  limit: z6.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  cost: z6.union([
+    z6.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    z6.object({ balance: name }).strict()
   ])
 }).strict();
-var observationReceiptSchema = z5.object({
+var observationReceiptSchema = z6.object({
   id: name,
   source: name,
-  attempts: z5.array(z5.string()),
-  receivedAt: z5.number()
+  attempts: z6.array(z6.string()),
+  receivedAt: z6.number()
 });
-var discordReactionSchema = z5.object({
-  guildId: z5.string(),
-  channelId: z5.string(),
-  messageId: z5.string(),
-  userId: z5.string(),
-  messageAuthorId: z5.string().nullable().default(null),
-  actorRoles: z5.array(z5.string()).default([]),
-  emoji: z5.object({ id: z5.string().nullable(), name: z5.string() }),
-  messagePublishedAt: z5.number()
+var discordReactionSchema = z6.object({
+  guildId: z6.string(),
+  channelId: z6.string(),
+  messageId: z6.string(),
+  userId: z6.string(),
+  messageAuthorId: z6.string().nullable().default(null),
+  actorRoles: z6.array(z6.string()).default([]),
+  emoji: z6.object({ id: z6.string().nullable(), name: z6.string() }),
+  messagePublishedAt: z6.number()
 }).strict();
-var discordMessageSchema = z5.object({
-  guildId: z5.string(),
-  channelId: z5.string(),
-  messageId: z5.string(),
-  userId: z5.string(),
-  content: z5.string().nullable(),
-  replyTo: z5.string().nullable(),
-  publishedAt: z5.number()
+var discordMessageSchema = z6.object({
+  guildId: z6.string(),
+  channelId: z6.string(),
+  messageId: z6.string(),
+  userId: z6.string(),
+  content: z6.string().nullable(),
+  replyTo: z6.string().nullable(),
+  publishedAt: z6.number()
 }).strict();
 
 // src/integrations.ts
-import { z as z6 } from "zod";
-var integrationProviderSchema = z6.enum(["discord"]);
-var discordServerSchema = z6.object({
-  id: z6.string().regex(/^[0-9]{1,20}$/),
-  name: z6.string().min(1),
-  icon: z6.string().nullable()
+import { z as z7 } from "zod";
+var integrationProviderSchema = z7.enum(["discord"]);
+var discordServerSchema = z7.object({
+  id: z7.string().regex(/^[0-9]{1,20}$/),
+  name: z7.string().min(1),
+  icon: z7.string().nullable()
 });
-var projectIntegrationSchema = z6.object({
+var projectIntegrationSchema = z7.object({
   provider: integrationProviderSchema,
-  configured: z6.boolean(),
-  status: z6.enum(["disconnected", "ready", "attention"]),
-  revision: z6.number().int().nonnegative(),
+  configured: z7.boolean(),
+  status: z7.enum(["disconnected", "ready", "attention"]),
+  revision: z7.number().int().nonnegative(),
   server: discordServerSchema.nullable(),
-  issue: z6.string().nullable(),
-  connectedAt: z6.number().default(0)
+  issue: z7.string().nullable(),
+  connectedAt: z7.number().default(0)
 });
 
 // src/accounts.ts
-import { z as z7 } from "zod";
-var authProviderSchema = z7.enum(["google", "apple", "x", "discord"]);
-var accountConnectionSchema = z7.object({
+import { z as z8 } from "zod";
+var authProviderSchema = z8.enum(["google", "apple", "x", "discord"]);
+var accountConnectionSchema = z8.object({
   provider: authProviderSchema,
-  configured: z7.boolean(),
-  status: z7.enum(["disconnected", "connected", "reconnect"]),
-  subject: z7.string().nullable(),
-  revision: z7.number().int().nonnegative()
+  configured: z8.boolean(),
+  status: z8.enum(["disconnected", "connected", "reconnect"]),
+  subject: z8.string().nullable(),
+  revision: z8.number().int().nonnegative()
 });
-var discordMemberInputSchema = z7.object({}).strict();
-var discordMessageInputSchema = z7.object({
-  channelId: z7.string().regex(/^[0-9]{1,20}$/),
-  messageId: z7.string().regex(/^[0-9]{1,20}$/)
+var discordMemberInputSchema = z8.object({}).strict();
+var discordMessageInputSchema = z8.object({
+  channelId: z8.string().regex(/^[0-9]{1,20}$/),
+  messageId: z8.string().regex(/^[0-9]{1,20}$/)
 }).strict();
-var discordMemberSchema = z7.object({
-  userId: z7.string().regex(/^[0-9]{1,20}$/).nullable().default(null),
-  nickname: z7.string().nullable().default(null),
-  displayName: z7.string().nullable().default(null),
-  boostingSince: z7.string().datetime({ offset: true }).nullable().default(null),
-  roles: z7.array(z7.string().regex(/^[0-9]{1,20}$/)),
-  joinedAt: z7.string().datetime({ offset: true }).nullable(),
-  pending: z7.boolean()
+var discordMemberSchema = z8.object({
+  userId: z8.string().regex(/^[0-9]{1,20}$/).nullable().default(null),
+  nickname: z8.string().nullable().default(null),
+  displayName: z8.string().nullable().default(null),
+  boostingSince: z8.string().datetime({ offset: true }).nullable().default(null),
+  roles: z8.array(z8.string().regex(/^[0-9]{1,20}$/)),
+  joinedAt: z8.string().datetime({ offset: true }).nullable(),
+  pending: z8.boolean()
 });
 
 // src/submission-input.ts
-import { z as z8 } from "zod";
-var textOptionsSchema = z8.object({
-  required: z8.boolean().default(true),
-  minLength: z8.number().int().min(0).max(1e4).default(1),
-  maxLength: z8.number().int().min(1).max(1e4).default(1e4)
+import { z as z9 } from "zod";
+var textOptionsSchema = z9.object({
+  required: z9.boolean().default(true),
+  minLength: z9.number().int().min(0).max(1e4).default(1),
+  maxLength: z9.number().int().min(1).max(1e4).default(1e4)
 }).strict().refine(
   (v) => v.minLength <= v.maxLength,
   "minLength must not exceed maxLength"
 );
-var hostSchema = z8.string().min(1).max(253).refine((host) => {
+var hostSchema = z9.string().min(1).max(253).refine((host) => {
   if (!/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/i.test(host) || host.includes("..")) {
     return false;
   }
@@ -546,13 +689,13 @@ var hostSchema = z8.string().min(1).max(253).refine((host) => {
     return false;
   }
 }, "Use a hostname without a scheme, path, port, or wildcard");
-var urlOptionsSchema = z8.object({
-  required: z8.boolean().default(true),
-  allowedHosts: z8.array(hostSchema).min(1).max(100).optional()
+var urlOptionsSchema = z9.object({
+  required: z9.boolean().default(true),
+  allowedHosts: z9.array(hostSchema).min(1).max(100).optional()
 }).strict();
-var textEvidenceSchema = z8.object({ kind: z8.literal("text"), value: z8.string().max(1e4) }).strict();
-var urlEvidenceSchema = z8.object({ kind: z8.literal("url"), value: z8.string().max(2048) }).strict();
-var valueEvidenceSchema = z8.discriminatedUnion("kind", [
+var textEvidenceSchema = z9.object({ kind: z9.literal("text"), value: z9.string().max(1e4) }).strict();
+var urlEvidenceSchema = z9.object({ kind: z9.literal("url"), value: z9.string().max(2048) }).strict();
+var valueEvidenceSchema = z9.discriminatedUnion("kind", [
   textEvidenceSchema,
   urlEvidenceSchema
 ]);
@@ -615,22 +758,22 @@ function xPostId(value) {
 }
 
 // src/quiz.ts
-import { z as z9 } from "zod";
-var quizId = z9.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
-var quizChoiceSchema = z9.object({ id: quizId, label: z9.string().trim().min(1).max(500) }).strict();
-var quizQuestionSchema = z9.object({
+import { z as z10 } from "zod";
+var quizId = z10.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
+var quizChoiceSchema = z10.object({ id: quizId, label: z10.string().trim().min(1).max(500) }).strict();
+var quizQuestionSchema = z10.object({
   id: quizId,
-  prompt: z9.string().trim().min(1).max(1e3),
-  choices: z9.array(quizChoiceSchema).min(2).max(8).refine(
+  prompt: z10.string().trim().min(1).max(1e3),
+  choices: z10.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 = z9.array(quizQuestionSchema).min(1).max(20).refine(
+var quizQuestionsSchema = z10.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 = z9.array(
+var quizContentSchema = z10.array(
   quizQuestionSchema.extend({ correct: quizId }).refine(
     (question) => question.choices.some((choice) => choice.id === question.correct),
     "Choose a correct answer from the available choices"
@@ -641,48 +784,48 @@ var quizContentSchema = z9.array(
 );
 
 // src/schema.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // src/settings.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/resources.ts
-import { z as z10 } from "zod";
-var channelSourceSchema = z10.object({
-  provider: z10.literal("discord"),
-  resource: z10.literal("channel"),
-  types: z10.array(z10.enum(["text", "announcement"])).min(1)
+import { z as z11 } from "zod";
+var channelSourceSchema = z11.object({
+  provider: z11.literal("discord"),
+  resource: z11.literal("channel"),
+  types: z11.array(z11.enum(["text", "announcement"])).min(1)
 }).strict();
-var resourceSourceSchema = z10.union([
-  z10.object({
-    provider: z10.literal("domino"),
-    resource: z10.literal("point-ledger")
+var resourceSourceSchema = z11.union([
+  z11.object({
+    provider: z11.literal("domino"),
+    resource: z11.literal("point-ledger")
   }).strict(),
   channelSourceSchema,
-  z10.object({
-    provider: z10.literal("discord"),
-    resource: z10.literal("role"),
-    assignable: z10.boolean().default(false)
+  z11.object({
+    provider: z11.literal("discord"),
+    resource: z11.literal("role"),
+    assignable: z11.boolean().default(false)
   }).strict()
 ]);
-var resourceRequestSchema = z10.object({
+var resourceRequestSchema = z11.object({
   source: resourceSourceSchema,
-  query: z10.string().max(100).optional(),
-  cursor: z10.string().regex(/^\d{1,6}$/).optional(),
-  ids: z10.array(z10.string().min(1).max(100)).max(50).optional()
+  query: z11.string().max(100).optional(),
+  cursor: z11.string().regex(/^\d{1,6}$/).optional(),
+  ids: z11.array(z11.string().min(1).max(100)).max(50).optional()
 }).strict();
-var resourceOptionsSchema = z10.object({
-  revision: z10.number().int(),
-  options: z10.array(
-    z10.object({
-      id: z10.string(),
-      label: z10.string(),
-      description: z10.string().optional(),
-      group: z10.string().optional(),
-      disabledReason: z10.string().optional()
+var resourceOptionsSchema = z11.object({
+  revision: z11.number().int(),
+  options: z11.array(
+    z11.object({
+      id: z11.string(),
+      label: z11.string(),
+      description: z11.string().optional(),
+      group: z11.string().optional(),
+      disabledReason: z11.string().optional()
     })
   ),
-  cursor: z10.string().nullable()
+  cursor: z11.string().nullable()
 });
 var discord = {
   roles(options = {}) {
@@ -706,49 +849,49 @@ var pointLedgers = () => ({
 });
 
 // src/settings.ts
-var instant = z11.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
-var resourceId = z11.union([z11.literal(""), z11.string().regex(/^\S{1,200}$/)]);
-var base = { label: z11.string().min(1), description: z11.string().optional() };
-var settingFieldSchema = z11.discriminatedUnion("kind", [
-  z11.object({ ...base, kind: z11.literal("point-ledger"), default: identifier }).strict(),
-  z11.object({ ...base, kind: z11.literal("datetime"), default: instant }).strict(),
-  z11.object({
+var instant = z12.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
+var resourceId = z12.union([z12.literal(""), z12.string().regex(/^\S{1,200}$/)]);
+var base = { label: z12.string().min(1), description: z12.string().optional() };
+var settingFieldSchema = z12.discriminatedUnion("kind", [
+  z12.object({ ...base, kind: z12.literal("point-ledger"), default: identifier }).strict(),
+  z12.object({ ...base, kind: z12.literal("datetime"), default: instant }).strict(),
+  z12.object({
     ...base,
-    kind: z11.literal("resource"),
+    kind: z12.literal("resource"),
     default: resourceId,
     source: resourceSourceSchema
   }).strict(),
-  z11.object({ ...base, kind: z11.literal("quiz"), default: quizContentSchema }).strict(),
-  z11.object({
+  z12.object({ ...base, kind: z12.literal("quiz"), default: quizContentSchema }).strict(),
+  z12.object({
     ...base,
-    kind: z11.literal("text"),
-    default: z11.string(),
-    minLength: z11.number().int().nonnegative(),
-    maxLength: z11.number().int().positive(),
-    multiline: z11.boolean()
+    kind: z12.literal("text"),
+    default: z12.string(),
+    minLength: z12.number().int().nonnegative(),
+    maxLength: z12.number().int().positive(),
+    multiline: z12.boolean()
   }).strict(),
-  z11.object({
+  z12.object({
     ...base,
-    kind: z11.literal("integer"),
-    default: z11.number().int(),
-    min: z11.number().int(),
-    max: z11.number().int()
+    kind: z12.literal("integer"),
+    default: z12.number().int(),
+    min: z12.number().int(),
+    max: z12.number().int()
   }).strict(),
-  z11.object({ ...base, kind: z11.literal("boolean"), default: z11.boolean() }).strict(),
-  z11.object({
+  z12.object({ ...base, kind: z12.literal("boolean"), default: z12.boolean() }).strict(),
+  z12.object({
     ...base,
-    kind: z11.literal("choice"),
-    default: z11.string(),
-    options: z11.array(z11.string().min(1)).min(1)
+    kind: z12.literal("choice"),
+    default: z12.string(),
+    options: z12.array(z12.string().min(1)).min(1)
   }).strict()
 ]);
-var settingsFieldsSchema = z11.record(
-  z11.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
+var settingsFieldsSchema = z12.record(
+  z12.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
   settingFieldSchema
 );
-var settingsValuesSchema = z11.record(
-  z11.string(),
-  z11.union([z11.string(), z11.number().finite(), z11.boolean(), quizContentSchema])
+var settingsValuesSchema = z12.record(
+  z12.string(),
+  z12.union([z12.string(), z12.number().finite(), z12.boolean(), quizContentSchema])
 );
 var settings = {
   pointLedger(options) {
@@ -788,19 +931,19 @@ var settings = {
       maxLength: options.maxLength ?? 2e3,
       multiline: options.multiline ?? false
     };
-    return z11.string().min(field.minLength).max(field.maxLength).default(field.default).meta(field);
+    return z12.string().min(field.minLength).max(field.maxLength).default(field.default).meta(field);
   },
   integer(options) {
-    return z11.number().int().min(options.min).max(options.max).default(options.default).meta({ ...options, kind: "integer" });
+    return z12.number().int().min(options.min).max(options.max).default(options.default).meta({ ...options, kind: "integer" });
   },
   boolean(options) {
-    return z11.boolean().default(options.default).meta({ ...options, kind: "boolean" });
+    return z12.boolean().default(options.default).meta({ ...options, kind: "boolean" });
   },
   choice(options) {
-    return z11.enum(options.options).default(options.default).meta({ ...options, kind: "choice" });
+    return z12.enum(options.options).default(options.default).meta({ ...options, kind: "choice" });
   },
   object(shape) {
-    return z11.object(shape).strict();
+    return z12.object(shape).strict();
   }
 };
 function parseSettings(fields, input) {
@@ -820,20 +963,20 @@ function parseSettings(fields, input) {
         shape[key] = quizContentSchema.default(field.default);
         break;
       case "text":
-        shape[key] = z11.string().min(field.minLength).max(field.maxLength).default(field.default);
+        shape[key] = z12.string().min(field.minLength).max(field.maxLength).default(field.default);
         break;
       case "integer":
-        shape[key] = z11.number().int().min(field.min).max(field.max).default(field.default);
+        shape[key] = z12.number().int().min(field.min).max(field.max).default(field.default);
         break;
       case "boolean":
-        shape[key] = z11.boolean().default(field.default);
+        shape[key] = z12.boolean().default(field.default);
         break;
       case "choice":
-        shape[key] = z11.enum(field.options).default(field.default);
+        shape[key] = z12.enum(field.options).default(field.default);
         break;
     }
   }
-  return settingsValuesSchema.parse(z11.object(shape).strict().parse(input));
+  return settingsValuesSchema.parse(z12.object(shape).strict().parse(input));
 }
 function missingResourceSettings(fields, values) {
   return Object.entries(fields).filter(([key, field]) => field.kind === "resource" && !values[key]).map(([key]) => key);
@@ -843,42 +986,42 @@ function compatibleSettingKinds(previous, next) {
 }
 
 // src/schema.ts
-var pointsRewardSchema = z12.object({
-  kind: z12.literal("points").default("points"),
+var pointsRewardSchema = z13.object({
+  kind: z13.literal("points").default("points"),
   balance: identifier,
-  amount: z12.number().int().min(0).max(1e4)
+  amount: z13.number().int().min(0).max(1e4)
 }).strict();
-var tieredRewardDefinitionSchema = z12.object({
+var tieredRewardDefinitionSchema = z13.object({
   id: identifier,
-  title: z12.string().min(1).max(120),
-  tiers: z12.array(
-    z12.object({ id: identifier, title: z12.string().min(1).max(120) }).strict()
+  title: z13.string().min(1).max(120),
+  tiers: z13.array(
+    z13.object({ id: identifier, title: z13.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: z12.object({ kind: z12.literal("untracked") }).strict(),
-  fulfillment: z12.object({ kind: z12.literal("staff-handover") }).strict()
+  inventory: z13.object({ kind: z13.literal("untracked") }).strict(),
+  fulfillment: z13.object({ kind: z13.literal("staff-handover") }).strict()
 }).strict();
-var tieredRewardReferenceSchema = z12.object({
+var tieredRewardReferenceSchema = z13.object({
   id: identifier,
   key: identifier.nullable()
 });
-var tierRewardSchema = z12.object({
-  kind: z12.literal("tier"),
+var tierRewardSchema = z13.object({
+  kind: z13.literal("tier"),
   reward: tieredRewardDefinitionSchema,
   tier: identifier
 }).strict().refine(
   (value) => value.reward.tiers.some((t) => t.id === value.tier),
   "Unknown reward tier"
 );
-var integrationRewardSchema = z12.object({
-  kind: z12.literal("integration"),
-  provider: z12.literal("discord"),
-  action: z12.literal("grant-role"),
-  roleId: z12.string().regex(/^[0-9]{1,20}$/)
+var integrationRewardSchema = z13.object({
+  kind: z13.literal("integration"),
+  provider: z13.literal("discord"),
+  action: z13.literal("grant-role"),
+  roleId: z13.string().regex(/^[0-9]{1,20}$/)
 }).strict();
-var rewardSchema = z12.union([
+var rewardSchema = z13.union([
   pointsRewardSchema,
   tierRewardSchema,
   integrationRewardSchema
@@ -889,70 +1032,71 @@ function rewardKey(reward) {
   }
   return reward.kind === "points" ? "points:" + reward.balance : "tier:" + reward.reward.id;
 }
-var triggerSchema = z12.union([
-  z12.object({
-    kind: z12.literal("manual"),
-    input: z12.literal("text"),
+var triggerSchema = z13.union([
+  z13.object({
+    kind: z13.literal("manual"),
+    input: z13.literal("text"),
     constraints: textOptionsSchema,
-    actor: z12.enum(["member", "staff"]).optional()
+    actor: z13.enum(["member", "staff"]).optional()
   }).strict(),
-  z12.object({
-    kind: z12.literal("manual"),
-    input: z12.literal("url"),
+  z13.object({
+    kind: z13.literal("manual"),
+    input: z13.literal("url"),
     constraints: urlOptionsSchema,
-    actor: z12.enum(["member", "staff"]).optional()
+    actor: z13.enum(["member", "staff"]).optional()
   }).strict(),
-  z12.object({
-    kind: z12.literal("manual"),
-    input: z12.enum(["photo", "quiz", "none"]),
-    actor: z12.enum(["member", "staff"]).optional()
+  z13.object({
+    kind: z13.literal("manual"),
+    input: z13.enum(["photo", "quiz", "none"]),
+    actor: z13.enum(["member", "staff"]).optional()
   }).strict(),
-  z12.object({
-    kind: z12.literal("automatic"),
+  z13.object({
+    kind: z13.literal("automatic"),
     observation: observationTriggerSchema.optional(),
-    content: contentPolicySchema.optional()
+    content: contentPolicySchema.optional(),
+    tracker: trackerTriggerPolicySchema.optional()
   }).strict().refine(
-    (value) => !(value.observation && value.content),
+    (value) => [value.observation, value.content, value.tracker].filter(Boolean).length <= 1,
     "Choose one automatic trigger source"
   )
 ]);
-var prerequisiteSchema = z12.object({ quest: identifier, scope: z12.literal("ever") }).strict();
-var photoResultSchema = z12.object({
-  kind: z12.enum(["pass", "fail", "unclear"]),
-  reason: z12.string().min(1).max(2e3)
+var prerequisiteSchema = z13.object({ quest: identifier, scope: z13.literal("ever") }).strict();
+var photoResultSchema = z13.object({
+  kind: z13.enum(["pass", "fail", "unclear"]),
+  reason: z13.string().min(1).max(2e3)
 }).strict();
-var textReviewInputSchema = z12.object({
-  text: z12.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
-  criteria: z12.string().trim().min(1).max(2e3)
+var textReviewInputSchema = z13.object({
+  text: z13.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
+  criteria: z13.string().trim().min(1).max(2e3)
 }).strict();
 var textResultSchema = photoResultSchema;
-var decisionSchema = z12.discriminatedUnion("kind", [
-  z12.object({
-    kind: z12.literal("accept"),
-    rewards: z12.array(rewardSchema).max(10),
+var decisionSchema = z13.discriminatedUnion("kind", [
+  z13.object({
+    kind: z13.literal("accept"),
+    rewards: z13.array(rewardSchema).max(10),
     completionKey: completionKeySchema.optional()
   }).strict(),
-  z12.object({ kind: z12.literal("reject"), reason: z12.string().min(1).max(2e3) }).strict(),
-  z12.object({
-    kind: z12.literal("review"),
-    reason: z12.string().min(1).max(2e3),
-    rewards: z12.array(rewardSchema).max(10).optional(),
+  z13.object({ kind: z13.literal("reject"), reason: z13.string().min(1).max(2e3) }).strict(),
+  z13.object({
+    kind: z13.literal("review"),
+    reason: z13.string().min(1).max(2e3),
+    rewards: z13.array(rewardSchema).max(10).optional(),
     completionKey: completionKeySchema.optional()
   }).strict()
 ]);
-var reviewModeSchema = z12.enum(["workers-ai"]);
-var storedReviewModeSchema = z12.enum([
+var reviewModeSchema = z13.enum(["workers-ai"]);
+var storedReviewModeSchema = z13.enum([
   "fixture-pass",
   "fixture-fail",
   "fixture-unclear",
   "fixture-error",
   "workers-ai"
 ]);
-var rewardBundleSchema = z12.array(rewardSchema).max(10).refine(
+var rewardBundleSchema = z13.array(rewardSchema).max(10).refine(
   (rewards) => new Set(rewards.map(rewardKey)).size === rewards.length,
   "Use one entry per balance or shared reward"
 );
-var mediaUrlSchema = z12.string().max(2e3).refine((value) => {
+var mediaUrlSchema = z13.string().max(2e3).refine((value) => {
   if (/^\/(?!\/)[^\\\s]*$/.test(value)) {
     return true;
   }
@@ -962,75 +1106,75 @@ var mediaUrlSchema = z12.string().max(2e3).refine((value) => {
     return false;
   }
 }, "Use an HTTPS URL or a same-site path beginning with /");
-var questPresentationSchema = z12.object({
+var questPresentationSchema = z13.object({
   quiz: quizQuestionsSchema.optional(),
-  instructions: z12.string().max(4e3).optional(),
-  video: z12.object({
+  instructions: z13.string().max(4e3).optional(),
+  video: z13.object({
     url: mediaUrlSchema,
     poster: mediaUrlSchema.optional(),
-    captions: z12.object({
+    captions: z13.object({
       url: mediaUrlSchema,
-      language: z12.string().min(2).max(20),
-      label: z12.string().min(1).max(80)
+      language: z13.string().min(2).max(20),
+      label: z13.string().min(1).max(80)
     }).strict().optional()
   }).strict().optional()
 }).strict();
-var questDescriptionSchema = z12.object({
+var questDescriptionSchema = z13.object({
   quest: identifier,
-  runtimeVersion: z12.union([z12.literal(1), z12.literal(2)]).default(1),
-  title: z12.string().min(1).max(120),
+  runtimeVersion: z13.union([z13.literal(1), z13.literal(2)]).default(1),
+  title: z13.string().min(1).max(120),
   presentation: questPresentationSchema.default({}),
-  integrations: z12.array(integrationProviderSchema).max(10).default([]),
+  integrations: z13.array(integrationProviderSchema).max(10).default([]),
   fields: settingsFieldsSchema,
   values: settingsValuesSchema,
   rewards: rewardBundleSchema,
-  humanReview: z12.boolean(),
+  humanReview: z13.boolean(),
   trigger: triggerSchema,
   performance: contentPerformancePolicySchema.optional(),
-  requires: z12.array(prerequisiteSchema).max(30).default([]),
+  requires: z13.array(prerequisiteSchema).max(30).default([]),
   completion: completionPolicySchema,
-  visibility: z12.enum(["visible", "hidden"]).default("visible"),
-  budgets: z12.array(budgetSchema).max(20).default([])
+  visibility: z13.enum(["visible", "hidden"]).default("visible"),
+  budgets: z13.array(budgetSchema).max(20).default([])
 }).strict();
-var artifactSchema = z12.object({ code: z12.string().min(1).max(1e6) }).strict();
+var artifactSchema = z13.object({ code: z13.string().min(1).max(1e6) }).strict();
 var releaseSchema = artifactSchema.extend({
   settings: settingsValuesSchema,
   provider: reviewModeSchema,
   expectedRelease: identifier.nullable().optional(),
-  settingRenames: z12.record(z12.string(), z12.string()).optional()
+  settingRenames: z13.record(z13.string(), z13.string()).optional()
 }).strict();
-var batchReleaseSchema = z12.object({ releases: z12.array(releaseSchema).min(1).max(50) }).strict();
-var questSettingsInputSchema = z12.object({
+var batchReleaseSchema = z13.object({ releases: z13.array(releaseSchema).min(1).max(50) }).strict();
+var questSettingsInputSchema = z13.object({
   quest: identifier,
   expectedRelease: identifier,
   set: settingsValuesSchema,
-  reset: z12.array(z12.string())
+  reset: z13.array(z13.string())
 }).strict();
 var storedReleaseSchema = questDescriptionSchema.extend({
   key: identifier.optional(),
-  code: z12.string(),
+  code: z13.string(),
   provider: storedReviewModeSchema,
   id: identifier,
-  createdAt: z12.number(),
-  legacy: z12.boolean().default(false),
-  origin: z12.object({ typeVersion: identifier }).strict().optional(),
-  lifecycle: z12.enum(["active", "paused", "archived"]).default("active"),
-  configuration: z12.object({
+  createdAt: z13.number(),
+  legacy: z13.boolean().default(false),
+  origin: z13.object({ typeVersion: identifier }).strict().optional(),
+  lifecycle: z13.enum(["active", "paused", "archived"]).default("active"),
+  configuration: z13.object({
     defaults: settingsValuesSchema,
     overrides: settingsValuesSchema,
-    preserved: z12.array(z12.string())
+    preserved: z13.array(z13.string())
   }).strict().optional()
 });
-var legacyReleaseSchema = z12.object({
+var legacyReleaseSchema = z13.object({
   quest: identifier,
-  title: z12.string(),
-  criteria: z12.string(),
-  humanReview: z12.boolean(),
+  title: z13.string(),
+  criteria: z13.string(),
+  humanReview: z13.boolean(),
   rewards: rewardBundleSchema,
-  code: z12.string(),
+  code: z13.string(),
   provider: storedReviewModeSchema,
   id: identifier,
-  createdAt: z12.number()
+  createdAt: z13.number()
 }).transform((r) => {
   const { criteria, ...stored } = r;
   return storedReleaseSchema.parse({
@@ -1042,15 +1186,15 @@ var legacyReleaseSchema = z12.object({
     legacy: true
   });
 });
-var publishedReleaseSchema = z12.union([
+var publishedReleaseSchema = z13.union([
   storedReleaseSchema,
   legacyReleaseSchema
 ]);
-var templateSchema = z12.object({
-  code: z12.string(),
+var templateSchema = z13.object({
+  code: z13.string(),
   definition: questDescriptionSchema
 });
-var quizAnswersSchema = z12.record(identifier, identifier).refine(
+var quizAnswersSchema = z13.record(identifier, identifier).refine(
   (answers) => Object.keys(answers).length > 0 && Object.keys(answers).length <= 50,
   "Provide between 1 and 50 answers"
 ).transform(
@@ -1058,33 +1202,33 @@ var quizAnswersSchema = z12.record(identifier, identifier).refine(
     Object.entries(answers).sort(([a], [b]) => a.localeCompare(b))
   )
 );
-var quizEvidenceSchema = z12.object({
-  kind: z12.literal("quiz"),
+var quizEvidenceSchema = z13.object({
+  kind: z13.literal("quiz"),
   release: identifier.optional(),
   answers: quizAnswersSchema
 }).strict();
-var submissionEvidenceSchema = z12.union([
+var submissionEvidenceSchema = z13.union([
   quizEvidenceSchema,
   textEvidenceSchema,
   urlEvidenceSchema
 ]);
-var submitSchema = z12.object({
+var submitSchema = z13.object({
   actionId: identifier,
   quest: identifier,
   member: identifier,
   evidence: identifier.optional(),
   input: submissionEvidenceSchema.optional(),
   release: identifier.optional(),
-  faultAfterReview: z12.boolean().optional()
+  faultAfterReview: z13.boolean().optional()
 }).strict();
-var attemptSchema = z12.object({
+var attemptSchema = z13.object({
   id: identifier,
   release: identifier,
   quest: identifier,
   member: identifier,
   evidence: identifier.nullable(),
   input: submissionEvidenceSchema.optional(),
-  status: z12.enum([
+  status: z13.enum([
     "queued",
     "evaluating",
     "accepted",
@@ -1093,70 +1237,70 @@ var attemptSchema = z12.object({
     "needs-review",
     "failed"
   ]),
-  reason: z12.string().nullable(),
-  retries: z12.number(),
-  generation: z12.number(),
-  completion: z12.string().nullable(),
+  reason: z13.string().nullable(),
+  retries: z13.number(),
+  generation: z13.number(),
+  completion: z13.string().nullable(),
   reviewRewards: rewardBundleSchema.nullable().default(null),
-  createdAt: z12.number()
+  createdAt: z13.number()
 });
-var eventSchema = z12.object({
-  id: z12.number(),
-  attempt: z12.string().nullable(),
-  kind: z12.string(),
-  detail: z12.string(),
-  actor: z12.string().nullable().default(null),
-  at: z12.number()
+var eventSchema = z13.object({
+  id: z13.number(),
+  attempt: z13.string().nullable(),
+  kind: z13.string(),
+  detail: z13.string(),
+  actor: z13.string().nullable().default(null),
+  at: z13.number()
 });
-var pickupSelectionSchema = z12.object({
+var pickupSelectionSchema = z13.object({
   item: identifier,
-  revision: z12.number().int().nonnegative()
+  revision: z13.number().int().nonnegative()
 }).strict();
-var pickupAllocationSchema = z12.object({
+var pickupAllocationSchema = z13.object({
   item: identifier,
-  label: z12.string().min(1).max(80)
+  label: z13.string().min(1).max(80)
 }).strict();
-var pickupPolicySchema = z12.discriminatedUnion("kind", [
-  z12.object({ kind: z12.literal("untracked") }).strict(),
-  z12.object({
-    kind: z12.literal("at-pickup"),
-    tiers: z12.array(
-      z12.object({
+var pickupPolicySchema = z13.discriminatedUnion("kind", [
+  z13.object({ kind: z13.literal("untracked") }).strict(),
+  z13.object({
+    kind: z13.literal("at-pickup"),
+    tiers: z13.array(
+      z13.object({
         tier: identifier,
-        variants: z12.array(pickupAllocationSchema).min(1).max(100)
+        variants: z13.array(pickupAllocationSchema).min(1).max(100)
       }).strict()
     ).min(1).max(100)
   }).strict()
 ]);
-var pickupCatalogSchema = z12.object({
+var pickupCatalogSchema = z13.object({
   reward: tieredRewardDefinitionSchema,
-  revision: z12.number().int().nonnegative(),
+  revision: z13.number().int().nonnegative(),
   policy: pickupPolicySchema
 });
-var pickupAvailabilitySchema = z12.discriminatedUnion("kind", [
-  z12.object({ kind: z12.literal("untracked") }).strict(),
-  z12.object({
-    kind: z12.literal("at-pickup"),
-    revision: z12.number().int().nonnegative(),
-    variants: z12.array(
+var pickupAvailabilitySchema = z13.discriminatedUnion("kind", [
+  z13.object({ kind: z13.literal("untracked") }).strict(),
+  z13.object({
+    kind: z13.literal("at-pickup"),
+    revision: z13.number().int().nonnegative(),
+    variants: z13.array(
       pickupAllocationSchema.extend({
-        available: z12.number().int().nonnegative()
+        available: z13.number().int().nonnegative()
       })
     )
   }).strict()
 ]);
-var configurePickupSchema = z12.object({
+var configurePickupSchema = z13.object({
   reward: identifier,
-  revision: z12.number().int().nonnegative(),
+  revision: z13.number().int().nonnegative(),
   actionId: identifier,
-  policy: z12.discriminatedUnion("kind", [
-    z12.object({ kind: z12.literal("untracked") }).strict(),
-    z12.object({
-      kind: z12.literal("at-pickup"),
-      tiers: z12.array(
-        z12.object({
+  policy: z13.discriminatedUnion("kind", [
+    z13.object({ kind: z13.literal("untracked") }).strict(),
+    z13.object({
+      kind: z13.literal("at-pickup"),
+      tiers: z13.array(
+        z13.object({
           tier: identifier,
-          variants: z12.array(
+          variants: z13.array(
             pickupAllocationSchema.extend({
               item: identifier.optional()
             })
@@ -1172,164 +1316,164 @@ var entitlementBase = {
   reward: tieredRewardDefinitionSchema,
   earnedTier: identifier,
   tier: identifier,
-  revision: z12.number().int().positive()
+  revision: z13.number().int().positive()
 };
-var entitlementSchema = z12.discriminatedUnion("status", [
-  z12.object({ ...entitlementBase, status: z12.literal("available") }).strict(),
-  z12.object({
+var entitlementSchema = z13.discriminatedUnion("status", [
+  z13.object({ ...entitlementBase, status: z13.literal("available") }).strict(),
+  z13.object({
     ...entitlementBase,
-    status: z12.literal("handing-over"),
+    status: z13.literal("handing-over"),
     handover: identifier,
-    startedAt: z12.number(),
+    startedAt: z13.number(),
     allocation: pickupAllocationSchema.optional()
   }).strict(),
-  z12.object({
+  z13.object({
     ...entitlementBase,
-    status: z12.literal("collected"),
+    status: z13.literal("collected"),
     handover: identifier,
-    startedAt: z12.number(),
+    startedAt: z13.number(),
     allocation: pickupAllocationSchema.optional(),
-    collectedAt: z12.number()
+    collectedAt: z13.number()
   }).strict()
 ]);
-var beginHandoverSchema = z12.object({
+var beginHandoverSchema = z13.object({
   actionId: identifier,
-  revision: z12.number().int().positive(),
+  revision: z13.number().int().positive(),
   selection: pickupSelectionSchema.optional()
 }).strict();
-var confirmHandoverSchema = z12.object({ actionId: identifier, handover: identifier }).strict();
-var completionRecordSchema = z12.object({
-  key: z12.string().default("once"),
+var confirmHandoverSchema = z13.object({ actionId: identifier, handover: identifier }).strict();
+var completionRecordSchema = z13.object({
+  key: z13.string().default("once"),
   id: identifier,
   quest: identifier,
   member: identifier
 });
-var questAvailabilitySchema = z12.discriminatedUnion("kind", [
-  z12.object({
-    kind: z12.literal("available"),
-    input: z12.enum(["photo", "quiz", "none", "text", "url"])
+var questAvailabilitySchema = z13.discriminatedUnion("kind", [
+  z13.object({
+    kind: z13.literal("available"),
+    input: z13.enum(["photo", "quiz", "none", "text", "url"])
   }).strict(),
-  z12.object({ kind: z12.literal("completed") }).strict(),
-  z12.object({
-    kind: z12.literal("locked"),
-    missing: z12.array(z12.object({ quest: identifier, title: z12.string() })).min(1)
+  z13.object({ kind: z13.literal("completed") }).strict(),
+  z13.object({
+    kind: z13.literal("locked"),
+    missing: z13.array(z13.object({ quest: identifier, title: z13.string() })).min(1)
   }).strict(),
-  z12.object({ kind: z12.literal("staff-required") }).strict(),
-  z12.object({
-    kind: z12.literal("automatic"),
+  z13.object({ kind: z13.literal("staff-required") }).strict(),
+  z13.object({
+    kind: z13.literal("automatic"),
     observation: observationTriggerSchema.optional()
   }).strict(),
-  z12.object({ kind: z12.literal("checking"), attempt: identifier }).strict(),
-  z12.object({ kind: z12.literal("needs-review"), attempt: identifier }).strict(),
-  z12.object({ kind: z12.literal("retryable"), attempt: identifier }).strict()
+  z13.object({ kind: z13.literal("checking"), attempt: identifier }).strict(),
+  z13.object({ kind: z13.literal("needs-review"), attempt: identifier }).strict(),
+  z13.object({ kind: z13.literal("retryable"), attempt: identifier }).strict()
 ]);
-var memberProgressSchema = z12.object({
+var memberProgressSchema = z13.object({
   member: identifier,
-  quests: z12.array(
-    z12.object({
+  quests: z13.array(
+    z13.object({
       quest: identifier,
       key: identifier.optional(),
       release: identifier.optional(),
-      title: z12.string(),
+      title: z13.string(),
       presentation: questPresentationSchema.default({}),
-      connections: z12.array(authProviderSchema).default([]),
+      connections: z13.array(authProviderSchema).default([]),
       trigger: triggerSchema,
       availability: questAvailabilitySchema,
-      completed: z12.boolean(),
+      completed: z13.boolean(),
       completion: completionPolicySchema.default({ kind: "once" }),
       streak: streakProgressSchema.nullable().optional(),
-      completionCount: z12.number().int().nonnegative().default(0),
-      visibility: z12.enum(["visible", "hidden"]).default("visible"),
-      missing: z12.array(z12.object({ quest: identifier, title: z12.string() })),
+      completionCount: z13.number().int().nonnegative().default(0),
+      visibility: z13.enum(["visible", "hidden"]).default("visible"),
+      missing: z13.array(z13.object({ quest: identifier, title: z13.string() })),
       attempt: attemptSchema.nullable()
     })
   ),
-  entitlements: z12.array(entitlementSchema)
+  entitlements: z13.array(entitlementSchema)
 });
-var snapshotSchema = z12.object({
-  releases: z12.array(publishedReleaseSchema),
-  completions: z12.array(completionRecordSchema),
-  entitlements: z12.array(entitlementSchema),
-  attempts: z12.array(attemptSchema),
-  balances: z12.array(
-    z12.object({
-      member: z12.string(),
-      balance: z12.string(),
-      earned: z12.number(),
-      held: z12.number(),
-      available: z12.number()
+var snapshotSchema = z13.object({
+  releases: z13.array(publishedReleaseSchema),
+  completions: z13.array(completionRecordSchema),
+  entitlements: z13.array(entitlementSchema),
+  attempts: z13.array(attemptSchema),
+  balances: z13.array(
+    z13.object({
+      member: z13.string(),
+      balance: z13.string(),
+      earned: z13.number(),
+      held: z13.number(),
+      available: z13.number()
     })
   ),
-  events: z12.array(eventSchema)
+  events: z13.array(eventSchema)
 });
-var evidenceSchema = z12.object({
+var evidenceSchema = z13.object({
   id: identifier,
   member: identifier,
-  type: z12.enum(["image/jpeg", "image/png"]),
-  size: z12.number()
+  type: z13.enum(["image/jpeg", "image/png"]),
+  size: z13.number()
 });
-var errorSchema = z12.object({
-  error: z12.string(),
-  code: z12.enum(["stale-quiz", "quest-updated", "invalid-submission"]).optional(),
-  missing: z12.array(z12.object({ quest: identifier, title: z12.string() })).optional()
+var errorSchema = z13.object({
+  error: z13.string(),
+  code: z13.enum(["stale-quiz", "quest-updated", "invalid-submission"]).optional(),
+  missing: z13.array(z13.object({ quest: identifier, title: z13.string() })).optional()
 });
-var staffDecisionSchema = z12.object({
+var staffDecisionSchema = z13.object({
   actionId: identifier,
-  generation: z12.number().int().nonnegative(),
-  decision: z12.enum(["accept", "reject"]),
-  reason: z12.string().trim().min(1).max(2e3)
+  generation: z13.number().int().nonnegative(),
+  decision: z13.enum(["accept", "reject"]),
+  reason: z13.string().trim().min(1).max(2e3)
 }).strict();
-var stockSchema = z12.object({ item: identifier, quantity: z12.number().int().min(0).max(1e4) }).strict();
-var reservationSchema = z12.object({
+var stockSchema = z13.object({ item: identifier, quantity: z13.number().int().min(0).max(1e4) }).strict();
+var reservationSchema = z13.object({
   actionId: identifier,
   member: identifier,
   item: identifier,
   balance: identifier,
-  price: z12.number().int().positive().max(1e4)
+  price: z13.number().int().positive().max(1e4)
 }).strict();
 var pageOptions = {
-  limit: z12.number().int().min(1).max(100).default(25),
-  cursor: z12.string().min(1).max(4096).optional()
+  limit: z13.number().int().min(1).max(100).default(25),
+  cursor: z13.string().min(1).max(4096).optional()
 };
-var reviewListSchema = z12.object({
+var reviewListSchema = z13.object({
   ...pageOptions,
   member: identifier.optional(),
   quest: identifier.optional()
 }).strict();
-var memberListSchema = z12.object({
+var memberListSchema = z13.object({
   ...pageOptions,
   prefix: identifier.optional()
 }).strict();
-var reviewItemSchema = z12.object({
+var reviewItemSchema = z13.object({
   attempt: attemptSchema,
-  title: z12.string(),
-  checks: z12.array(
-    z12.object({ criteria: z12.string(), result: photoResultSchema })
+  title: z13.string(),
+  checks: z13.array(
+    z13.object({ criteria: z13.string(), result: photoResultSchema })
   )
 });
-var reviewPageSchema = z12.object({
-  items: z12.array(reviewItemSchema).max(100),
-  nextCursor: z12.string().nullable()
+var reviewPageSchema = z13.object({
+  items: z13.array(reviewItemSchema).max(100),
+  nextCursor: z13.string().nullable()
 });
-var memberPageSchema = z12.object({
-  items: z12.array(z12.object({ member: identifier })).max(100),
-  nextCursor: z12.string().nullable()
+var memberPageSchema = z13.object({
+  items: z13.array(z13.object({ member: identifier })).max(100),
+  nextCursor: z13.string().nullable()
 });
-var createStockItemSchema = z12.object({ actionId: identifier, name: z12.string().trim().min(1).max(80) }).strict();
-var stockItemSchema = z12.object({ id: identifier, name: z12.string() });
-var contentPerformanceSnapshotSchema = z12.strictObject({
+var createStockItemSchema = z13.object({ actionId: identifier, name: z13.string().trim().min(1).max(80) }).strict();
+var stockItemSchema = z13.object({ id: identifier, name: z13.string() });
+var contentPerformanceSnapshotSchema = z13.strictObject({
   contentAttempt: identifier,
   observation: identifier,
-  observedAt: z12.number().int().safe().nonnegative(),
+  observedAt: z13.number().int().safe().nonnegative(),
   metrics: contentMetricsSchema,
   rewards: rewardBundleSchema
 });
 var contentPerformanceQuerySchema = contentQualificationQuerySchema.extend({
-  content: z12.string().min(1).max(256)
+  content: z13.string().min(1).max(256)
 });
-var contentPerformancePageSchema = z12.strictObject({
-  current: z12.strictObject({
-    state: z12.enum([
+var contentPerformancePageSchema = z13.strictObject({
+  current: z13.strictObject({
+    state: z13.enum([
       "content-pending",
       "content-unqualified",
       "waiting",
@@ -1340,19 +1484,19 @@ var contentPerformancePageSchema = z12.strictObject({
       "failed",
       "superseded"
     ]),
-    reason: z12.string().nullable(),
+    reason: z13.string().nullable(),
     contentAttempt: identifier,
     attempt: identifier.nullable(),
     reward: contentQualificationSchema.shape.reward
   }),
-  items: z12.array(
-    z12.strictObject({
+  items: z13.array(
+    z13.strictObject({
       attempt: identifier,
       contentAttempt: identifier,
       observation: identifier,
-      observedAt: z12.number(),
+      observedAt: z13.number(),
       metrics: contentMetricsSchema,
-      state: z12.enum([
+      state: z13.enum([
         "pending",
         "qualified",
         "unqualified",
@@ -1360,10 +1504,10 @@ var contentPerformancePageSchema = z12.strictObject({
         "failed",
         "superseded"
       ]),
-      reason: z12.string().nullable()
+      reason: z13.string().nullable()
     })
   ),
-  next: z12.number().int().positive().safe().nullable()
+  next: z13.number().int().positive().safe().nullable()
 });
 
 export {
@@ -1372,6 +1516,7 @@ export {
   xContentBodySchema,
   trackerContentQuerySchema,
   trackerContentReadSchema,
+  trackerEvidenceSchema,
   trackerContentSchema,
   trackerSourceSchema,
   x,
@@ -1386,6 +1531,10 @@ export {
   trackerRecordSchema,
   trackerIngestSchema,
   trackerIngestResultSchema,
+  trackerOutcomeSchema,
+  trackerOutcomeQuerySchema,
+  trackerOutcomePageSchema,
+  trackerOutcomeRetrySchema,
   trackerQuerySchema,
   trackerPageSchema,
   trackerSummarySchema,
@@ -1414,6 +1563,11 @@ export {
   streakPolicySchema,
   streak,
   streakProgressSchema,
+  trackerBeneficiarySchema,
+  trackerTriggerPolicySchema,
+  trackerAttributionSchema,
+  trackerTriggerRecordSchema,
+  trackerTriggerContextSchema,
   observationInputSchema,
   observationSchema,
   observationTriggerSchema,