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

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

@@ -588,7 +588,7 @@ function schemaCheckedReader(reader) {
       }
       const issues = trackerDataIssues(
         schema,
-        page.items.map((record) => record.data)
+        page.items.map((record2) => record2.data)
       );
       const items = page.items.filter((_, index) => !issues[index]);
       return { ...page, items, excluded: page.items.length - items.length };
@@ -1103,64 +1103,131 @@ var contentPerformancePolicySchema = z6.strictObject({
   maxAgeMs: z6.number().int().positive().max(864e5).default(36e5)
 });
 
-// src/streaks.ts
+// src/calendar.ts
 import { z as z7 } from "zod";
-var communityTimeZoneSchema = z7.string().min(1).max(100).refine((zone) => {
+var timestamp3 = z7.number().int().safe();
+var fixedOffset = /^(?:[+-]|(?:Etc\/)?GMT[+-]\d|(?:EST|MST|HST)$)/i;
+function canonicalTimeZone(zone) {
+  let resolved;
   try {
-    if (/^[+-]/.test(zone)) {
-      return false;
-    }
-    new Intl.DateTimeFormat("en", { timeZone: zone });
-    return true;
+    resolved = new Intl.DateTimeFormat("en", {
+      timeZone: zone
+    }).resolvedOptions().timeZone;
   } catch {
-    return false;
+    return null;
   }
-}, "Use an IANA community timezone, such as Europe/Budapest");
-var streakPolicySchema = z7.object({
-  kind: z7.literal("streak"),
-  days: z7.number().int().min(1).max(3650),
-  timeZone: communityTimeZoneSchema
-}).strict();
-var streakProgressSchema = z7.object({
-  goal: z7.number().int().positive(),
-  current: z7.number().int().nonnegative(),
-  best: z7.number().int().nonnegative(),
+  if (resolved === "UTC") {
+    return "UTC";
+  }
+  return fixedOffset.test(zone) || fixedOffset.test(resolved) ? null : resolved;
+}
+var timeZoneSchema = z7.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 canonical;
+});
+var timeZoneNameSchema = z7.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) {
+  if (record(value) && value.kind === "streak" && "timeZone" in value) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["timeZone"],
+      message: movedTimeZone("Streaks")
+    });
+  }
+  return value;
+}
+function refuseWindowTimeZone(value, ctx) {
+  const window = record(value) ? value.window : void 0;
+  if (record(window) && window.kind === "calendar" && "timeZone" in window) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["window", "timeZone"],
+      message: movedTimeZone("Calendar leaderboard windows")
+    });
+  }
+  return value;
+}
+var calendarPeriodSchema = z7.enum(["lifetime", "day", "week", "month"]);
+var projectCalendarSchema = z7.object({
+  /** The timezone of the current calendar day. */
+  timeZone: timeZoneNameSchema,
+  /** The current calendar date, such as `2026-10-01`. */
   today: z7.string(),
-  todayQualified: z7.boolean(),
-  timeZone: communityTimeZoneSchema,
-  nextBoundary: z7.number().int(),
-  pendingTimeZone: z7.object({
-    timeZone: communityTimeZoneSchema,
-    effectiveAt: z7.number().int()
+  /** 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(),
+  /** 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)
+});
+var projectCalendarInputSchema = z7.object({
+  actionId: identifier,
+  timeZone: timeZoneSchema,
+  reason: z7.string().trim().min(1).max(500)
+}).strict();
+var projectCalendarDeclarationSchema = z7.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(),
+  timeZone: timeZoneNameSchema,
+  nextBoundary: z8.number().int(),
+  pendingTimeZone: z8.object({
+    timeZone: timeZoneNameSchema,
+    effectiveAt: z8.number().int()
   }).nullable(),
-  days: z7.array(
-    z7.object({
-      day: z7.number().int(),
-      date: z7.string(),
-      timeZone: communityTimeZoneSchema,
-      occurredAt: z7.number().int()
+  days: z8.array(
+    z8.object({
+      day: z8.number().int(),
+      date: z8.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()
     })
   ),
-  milestone: z7.discriminatedUnion("status", [
-    z7.object({ status: z7.literal("pending") }),
-    z7.object({
-      status: z7.literal("awarded"),
-      completion: z7.string(),
-      achievedAt: z7.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()
     }),
-    z7.object({
-      status: z7.literal("budget-exhausted"),
-      budget: z7.string(),
-      achievedAt: z7.number().int()
+    z8.object({
+      status: z8.literal("budget-exhausted"),
+      budget: z8.string(),
+      achievedAt: z8.number().int()
     })
   ])
 });
 
 // src/tracker-triggers.ts
-import { z as z8 } from "zod";
-var timestamp3 = z8.number().int().safe().nonnegative().max(864e13);
-var count2 = z8.number().int().safe().nonnegative();
-var trackerTriggerModeSchema = z8.enum([
+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([
   "new-record",
   "new-observation",
   "data-changed"
@@ -1168,20 +1235,20 @@ var trackerTriggerModeSchema = z8.enum([
 function defaultTriggerMode(source) {
   return source === "x-search" ? "new-record" : "new-observation";
 }
-var trackerBoundSchema = z8.union([
-  z8.number().finite(),
-  z8.strictObject({ setting: z8.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/) })
+var trackerBoundSchema = z9.union([
+  z9.number().finite(),
+  z9.strictObject({ setting: z9.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/) })
 ]);
-var dataPath = z8.string().max(200).regex(
+var dataPath = z9.string().max(200).regex(
   /^[^.\s]+(\.[^.\s]+)*$/,
   "Use dot-separated keys, such as metrics.likes"
 );
-var trackerConditionSchema = z8.union([
-  z8.strictObject({
+var trackerConditionSchema = z9.union([
+  z9.strictObject({
     path: dataPath,
-    equals: z8.union([z8.string().max(1e3), z8.number().finite(), z8.boolean()])
+    equals: z9.union([z9.string().max(1e3), z9.number().finite(), z9.boolean()])
   }),
-  z8.strictObject({
+  z9.strictObject({
     path: dataPath,
     gt: trackerBoundSchema.optional(),
     gte: trackerBoundSchema.optional(),
@@ -1194,9 +1261,9 @@ var trackerConditionSchema = z8.union([
     "Compare with equals, gt, gte, lt or lte"
   )
 ]);
-var trackerWhereSchema = z8.union([
+var trackerWhereSchema = z9.union([
   trackerConditionSchema,
-  z8.array(trackerConditionSchema).min(1).max(10)
+  z9.array(trackerConditionSchema).min(1).max(10)
 ]);
 function whereConditions(where) {
   return where === void 0 ? [] : Array.isArray(where) ? where : [where];
@@ -1208,10 +1275,10 @@ function whereSettings(where) {
     )
   );
 }
-var trackerTriggerPolicySchema = z8.strictObject({
+var trackerTriggerPolicySchema = z9.strictObject({
   /** The tracker's authoring key; publication binds it to the tracker's stable ID. */
   tracker: identifier,
-  source: z8.enum(["x-search", "custom"]),
+  source: z9.enum(["x-search", "custom"]),
   /** Which observations fire; absent means the source's default (`defaultTriggerMode`). */
   on: trackerTriggerModeSchema.optional(),
   where: trackerWhereSchema.optional(),
@@ -1220,7 +1287,7 @@ var trackerTriggerPolicySchema = z8.strictObject({
    * a custom record. Relay attributes it through verified links; evaluators cannot redirect it.
    * Releases published before account roles store `"replied-to"` for `inReplyTo`.
    */
-  beneficiary: z8.union([accountRoleSchema, z8.literal("replied-to")])
+  beneficiary: z9.union([accountRoleSchema, z9.literal("replied-to")])
 });
 function triggerMode(policy) {
   return policy.on ?? defaultTriggerMode(policy.source);
@@ -1229,52 +1296,52 @@ function beneficiaryRole(policy) {
   return policy.beneficiary === "replied-to" ? "inReplyTo" : policy.beneficiary;
 }
 var xLink = {
-  issuer: z8.string().min(1),
+  issuer: z9.string().min(1),
   /** The account's stable user ID. */
-  subject: z8.string().min(1).max(256),
+  subject: z9.string().min(1).max(256),
   /** The member's account selection revision. */
   revision: count2,
   /** When the member linked the account; null when unknown. */
-  linkedAt: timestamp3.nullable()
+  linkedAt: timestamp4.nullable()
 };
-var trackerAttributionSchema = z8.strictObject({
+var trackerAttributionSchema = z9.strictObject({
   member: identifier,
-  capturedAt: timestamp3,
-  account: z8.discriminatedUnion("provider", [
-    z8.strictObject({
-      provider: z8.literal("wallet"),
+  capturedAt: timestamp4,
+  account: z9.discriminatedUnion("provider", [
+    z9.strictObject({
+      provider: z9.literal("wallet"),
       /** Canonical CAIP-10 account ID, as the record names it. */
-      id: z8.string().min(5).max(256),
+      id: z9.string().min(5).max(256),
       /** The wallet link's revision. */
       revision: count2,
       /** When the member verified the wallet. */
-      linkedAt: timestamp3.nullable()
+      linkedAt: timestamp4.nullable()
     }),
-    z8.strictObject({ provider: z8.literal("x"), ...xLink }),
-    z8.strictObject({ provider: z8.literal("discord"), ...xLink }),
-    z8.strictObject({
-      provider: z8.literal("member"),
+    z9.strictObject({ provider: z9.literal("x"), ...xLink }),
+    z9.strictObject({ provider: z9.literal("discord"), ...xLink }),
+    z9.strictObject({
+      provider: z9.literal("member"),
       /** The member ID the record names. */
       id: identifier
     })
   ])
 });
-var trackerTriggerRecordSchema = z8.strictObject({
-  id: z8.string().min(1).max(256),
-  source: z8.string(),
-  occurredAt: timestamp3,
-  observedAt: timestamp3,
-  firstSeenAt: timestamp3,
-  author: z8.strictObject({
-    id: z8.string().min(1).max(256),
-    verified: z8.boolean().nullable(),
+var trackerTriggerRecordSchema = z9.strictObject({
+  id: z9.string().min(1).max(256),
+  source: z9.string(),
+  occurredAt: timestamp4,
+  observedAt: timestamp4,
+  firstSeenAt: timestamp4,
+  author: z9.strictObject({
+    id: z9.string().min(1).max(256),
+    verified: z9.boolean().nullable(),
     kind: identityKindSchema.optional()
   }).nullable(),
-  accounts: z8.record(accountRoleSchema, trackerAccountSchema).optional(),
-  data: z8.record(z8.string(), z8.json()),
-  removed: z8.boolean()
+  accounts: z9.record(accountRoleSchema, trackerAccountSchema).optional(),
+  data: z9.record(z9.string(), z9.json()),
+  removed: z9.boolean()
 });
-var trackerTriggerContextSchema = z8.strictObject({
+var trackerTriggerContextSchema = z9.strictObject({
   /** The tracker's stable ID. */
   tracker: identifier,
   /** The tracker's authoring key. */
@@ -1283,10 +1350,10 @@ var trackerTriggerContextSchema = z8.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: z8.union([accountRoleSchema, z8.literal("replied-to")]),
+  beneficiary: z9.union([accountRoleSchema, z9.literal("replied-to")]),
   record: trackerTriggerRecordSchema,
   /** The captured X post of this observation; null for custom trackers. */
-  x: z8.strictObject({
+  x: z9.strictObject({
     evidence: trackerEvidenceSchema,
     content: xContentBodySchema
   }).nullable(),
@@ -1294,99 +1361,100 @@ var trackerTriggerContextSchema = z8.strictObject({
 });
 
 // src/observations.ts
-import { z as z9 } from "zod";
-var name = z9.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
-var observationInputSchema = z9.object({
+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: z9.object({ provider: identifier, subject: z9.string().min(1).max(200) }).strict().optional(),
-  occurredAt: z9.number().int().nonnegative().max(864e13),
-  data: z9.record(z9.string(), z9.json())
+  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: z9.number().int().nonnegative()
+  receivedAt: z10.number().int().nonnegative()
 });
-var observationTriggerSchema = z9.object({ source: name, type: name }).strict();
-var completionPolicySchema = z9.discriminatedUnion("kind", [
+var observationTriggerSchema = z10.object({ source: name, type: name }).strict();
+var completionPolicySchema = z10.discriminatedUnion("kind", [
   streakPolicySchema,
-  z9.object({ kind: z9.literal("once") }).strict(),
-  z9.object({ kind: z9.literal("keyed") }).strict()
+  z10.object({ kind: z10.literal("once") }).strict(),
+  z10.object({ kind: z10.literal("keyed") }).strict()
 ]);
-var completionKeySchema = z9.string().min(1).max(500);
-var budgetSchema = z9.object({
+var completionKeySchema = z10.string().min(1).max(500);
+var budgetSchema = z10.object({
   id: name,
-  scope: z9.enum(["member", "project"]),
+  scope: z10.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.
+   * 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: z9.enum(["lifetime", "day", "week"]),
-  limit: z9.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  cost: z9.union([
-    z9.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-    z9.object({ balance: name }).strict()
+  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()
   ])
 }).strict();
-var observationReceiptSchema = z9.object({
+var observationReceiptSchema = z10.object({
   id: name,
   source: name,
-  attempts: z9.array(z9.string()),
-  receivedAt: z9.number()
-});
-var discordReactionSchema = z9.object({
-  guildId: z9.string(),
-  channelId: z9.string(),
-  messageId: z9.string(),
-  userId: z9.string(),
-  messageAuthorId: z9.string().nullable().default(null),
-  actorRoles: z9.array(z9.string()).default([]),
-  emoji: z9.object({ id: z9.string().nullable(), name: z9.string() }),
-  messagePublishedAt: z9.number()
+  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 = z9.object({
-  guildId: z9.string(),
-  channelId: z9.string(),
-  messageId: z9.string(),
-  userId: z9.string(),
-  content: z9.string().nullable(),
-  replyTo: z9.string().nullable(),
-  publishedAt: z9.number()
+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 z10 } from "zod";
-var integrationProviderSchema = z10.enum(["discord"]);
-var discordServerSchema = z10.object({
-  id: z10.string().regex(/^[0-9]{1,20}$/),
-  name: z10.string().min(1),
-  icon: z10.string().nullable()
+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()
 });
-var projectIntegrationSchema = z10.object({
+var projectIntegrationSchema = z11.object({
   provider: integrationProviderSchema,
-  configured: z10.boolean(),
-  status: z10.enum(["disconnected", "ready", "attention"]),
-  revision: z10.number().int().nonnegative(),
+  configured: z11.boolean(),
+  status: z11.enum(["disconnected", "ready", "attention"]),
+  revision: z11.number().int().nonnegative(),
   server: discordServerSchema.nullable(),
-  issue: z10.string().nullable(),
-  connectedAt: z10.number().default(0)
+  issue: z11.string().nullable(),
+  connectedAt: z11.number().default(0)
 });
 
 // src/submission-input.ts
-import { z as z11 } from "zod";
-var textOptionsSchema = z11.object({
-  required: z11.boolean().default(true),
-  minLength: z11.number().int().min(0).max(1e4).default(1),
-  maxLength: z11.number().int().min(1).max(1e4).default(1e4)
+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)
 }).strict().refine(
   (v) => v.minLength <= v.maxLength,
   "minLength must not exceed maxLength"
 );
-var hostSchema = z11.string().min(1).max(253).refine((host) => {
+var hostSchema = z12.string().min(1).max(253).refine((host) => {
   if (!/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/i.test(host) || host.includes("..")) {
     return false;
   }
@@ -1397,13 +1465,13 @@ var hostSchema = z11.string().min(1).max(253).refine((host) => {
     return false;
   }
 }, "Use a hostname without a scheme, path, port, or wildcard");
-var urlOptionsSchema = z11.object({
-  required: z11.boolean().default(true),
-  allowedHosts: z11.array(hostSchema).min(1).max(100).optional()
+var urlOptionsSchema = z12.object({
+  required: z12.boolean().default(true),
+  allowedHosts: z12.array(hostSchema).min(1).max(100).optional()
 }).strict();
-var textEvidenceSchema = z11.object({ kind: z11.literal("text"), value: z11.string().max(1e4) }).strict();
-var urlEvidenceSchema = z11.object({ kind: z11.literal("url"), value: z11.string().max(2048) }).strict();
-var valueEvidenceSchema = z11.discriminatedUnion("kind", [
+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", [
   textEvidenceSchema,
   urlEvidenceSchema
 ]);
@@ -1466,22 +1534,22 @@ function xPostId(value) {
 }
 
 // src/quiz.ts
-import { z as z12 } from "zod";
-var quizId = z12.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
-var quizChoiceSchema = z12.object({ id: quizId, label: z12.string().trim().min(1).max(500) }).strict();
-var quizQuestionSchema = z12.object({
+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({
   id: quizId,
-  prompt: z12.string().trim().min(1).max(1e3),
-  choices: z12.array(quizChoiceSchema).min(2).max(8).refine(
+  prompt: z13.string().trim().min(1).max(1e3),
+  choices: z13.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 = z12.array(quizQuestionSchema).min(1).max(20).refine(
+var quizQuestionsSchema = z13.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 = z12.array(
+var quizContentSchema = z13.array(
   quizQuestionSchema.extend({ correct: quizId }).refine(
     (question) => question.choices.some((choice) => choice.id === question.correct),
     "Choose a correct answer from the available choices"
@@ -1492,97 +1560,97 @@ var quizContentSchema = z12.array(
 );
 
 // src/resources.ts
-import { z as z13 } from "zod";
-var channelSourceSchema = z13.object({
-  provider: z13.literal("discord"),
-  resource: z13.literal("channel"),
-  types: z13.array(z13.enum(["text", "announcement"])).min(1)
+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)
 }).strict();
-var resourceSourceSchema = z13.union([
-  z13.object({
-    provider: z13.literal("domino"),
-    resource: z13.literal("point-ledger")
+var resourceSourceSchema = z14.union([
+  z14.object({
+    provider: z14.literal("domino"),
+    resource: z14.literal("point-ledger")
   }).strict(),
   channelSourceSchema,
-  z13.object({
-    provider: z13.literal("discord"),
-    resource: z13.literal("role"),
-    assignable: z13.boolean().default(false)
+  z14.object({
+    provider: z14.literal("discord"),
+    resource: z14.literal("role"),
+    assignable: z14.boolean().default(false)
   }).strict()
 ]);
-var resourceRequestSchema = z13.object({
+var resourceRequestSchema = z14.object({
   source: resourceSourceSchema,
-  query: z13.string().max(100).optional(),
-  cursor: z13.string().regex(/^\d{1,6}$/).optional(),
-  ids: z13.array(z13.string().min(1).max(100)).max(50).optional()
+  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()
 }).strict();
-var resourceOptionsSchema = z13.object({
-  revision: z13.number().int(),
-  options: z13.array(
-    z13.object({
-      id: z13.string(),
-      label: z13.string(),
-      description: z13.string().optional(),
-      group: z13.string().optional(),
-      disabledReason: z13.string().optional()
+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()
     })
   ),
-  cursor: z13.string().nullable()
+  cursor: z14.string().nullable()
 });
 
 // src/settings.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/setting-values.ts
-import { z as z14 } from "zod";
-var settingInstant = z14.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
-var settingResourceId = z14.union([
-  z14.literal(""),
-  z14.string().regex(/^\S{1,200}$/)
+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}$/)
 ]);
 
 // src/settings.ts
-var base = { label: z15.string().min(1), description: z15.string().optional() };
-var settingFieldSchema = z15.discriminatedUnion("kind", [
-  z15.object({ ...base, kind: z15.literal("point-ledger"), default: identifier }).strict(),
-  z15.object({ ...base, kind: z15.literal("datetime"), default: settingInstant }).strict(),
-  z15.object({
+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({
     ...base,
-    kind: z15.literal("resource"),
+    kind: z16.literal("resource"),
     default: settingResourceId,
     source: resourceSourceSchema
   }).strict(),
-  z15.object({ ...base, kind: z15.literal("quiz"), default: quizContentSchema }).strict(),
-  z15.object({
+  z16.object({ ...base, kind: z16.literal("quiz"), default: quizContentSchema }).strict(),
+  z16.object({
     ...base,
-    kind: z15.literal("text"),
-    default: z15.string(),
-    minLength: z15.number().int().nonnegative(),
-    maxLength: z15.number().int().positive(),
-    multiline: z15.boolean()
+    kind: z16.literal("text"),
+    default: z16.string(),
+    minLength: z16.number().int().nonnegative(),
+    maxLength: z16.number().int().positive(),
+    multiline: z16.boolean()
   }).strict(),
-  z15.object({
+  z16.object({
     ...base,
-    kind: z15.literal("integer"),
-    default: z15.number().int(),
-    min: z15.number().int(),
-    max: z15.number().int()
+    kind: z16.literal("integer"),
+    default: z16.number().int(),
+    min: z16.number().int(),
+    max: z16.number().int()
   }).strict(),
-  z15.object({ ...base, kind: z15.literal("boolean"), default: z15.boolean() }).strict(),
-  z15.object({
+  z16.object({ ...base, kind: z16.literal("boolean"), default: z16.boolean() }).strict(),
+  z16.object({
     ...base,
-    kind: z15.literal("choice"),
-    default: z15.string(),
-    options: z15.array(z15.string().min(1)).min(1)
+    kind: z16.literal("choice"),
+    default: z16.string(),
+    options: z16.array(z16.string().min(1)).min(1)
   }).strict()
 ]);
-var settingsFieldsSchema = z15.record(
-  z15.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
+var settingsFieldsSchema = z16.record(
+  z16.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
   settingFieldSchema
 );
-var settingsValuesSchema = z15.record(
-  z15.string(),
-  z15.union([z15.string(), z15.number().finite(), z15.boolean(), quizContentSchema])
+var settingsValuesSchema = z16.record(
+  z16.string(),
+  z16.union([z16.string(), z16.number().finite(), z16.boolean(), quizContentSchema])
 );
 function parseSettings(fields, input) {
   const shape = {};
@@ -1601,20 +1669,20 @@ function parseSettings(fields, input) {
         shape[key] = quizContentSchema.default(field.default);
         break;
       case "text":
-        shape[key] = z15.string().min(field.minLength).max(field.maxLength).default(field.default);
+        shape[key] = z16.string().min(field.minLength).max(field.maxLength).default(field.default);
         break;
       case "integer":
-        shape[key] = z15.number().int().min(field.min).max(field.max).default(field.default);
+        shape[key] = z16.number().int().min(field.min).max(field.max).default(field.default);
         break;
       case "boolean":
-        shape[key] = z15.boolean().default(field.default);
+        shape[key] = z16.boolean().default(field.default);
         break;
       case "choice":
-        shape[key] = z15.enum(field.options).default(field.default);
+        shape[key] = z16.enum(field.options).default(field.default);
         break;
     }
   }
-  return settingsValuesSchema.parse(z15.object(shape).strict().parse(input));
+  return settingsValuesSchema.parse(z16.object(shape).strict().parse(input));
 }
 function missingResourceSettings(fields, values) {
   return Object.entries(fields).filter(([key, field]) => field.kind === "resource" && !values[key]).map(([key]) => key);
@@ -1624,43 +1692,43 @@ function compatibleSettingKinds(previous, next) {
 }
 
 // src/schema.ts
-import { z as z16 } from "zod";
-var pointsRewardSchema = z16.object({
-  kind: z16.literal("points").default("points"),
+import { z as z17 } from "zod";
+var pointsRewardSchema = z17.object({
+  kind: z17.literal("points").default("points"),
   balance: identifier,
-  amount: z16.number().int().min(0).max(1e4)
+  amount: z17.number().int().min(0).max(1e4)
 }).strict();
-var tieredRewardDefinitionSchema = z16.object({
+var tieredRewardDefinitionSchema = z17.object({
   id: identifier,
-  title: z16.string().min(1).max(120),
-  tiers: z16.array(
-    z16.object({ id: identifier, title: z16.string().min(1).max(120) }).strict()
+  title: z17.string().min(1).max(120),
+  tiers: z17.array(
+    z17.object({ id: identifier, title: z17.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: z16.object({ kind: z16.literal("untracked") }).strict(),
-  fulfillment: z16.object({ kind: z16.literal("staff-handover") }).strict()
+  inventory: z17.object({ kind: z17.literal("untracked") }).strict(),
+  fulfillment: z17.object({ kind: z17.literal("staff-handover") }).strict()
 }).strict();
-var tieredRewardReferenceSchema = z16.object({
+var tieredRewardReferenceSchema = z17.object({
   id: identifier,
   key: identifier.nullable()
 });
-var tierRewardSchema = z16.object({
-  kind: z16.literal("tier"),
+var tierRewardSchema = z17.object({
+  kind: z17.literal("tier"),
   reward: tieredRewardDefinitionSchema,
   tier: identifier
 }).strict().refine(
   (value) => value.reward.tiers.some((t) => t.id === value.tier),
   "Unknown reward tier"
 );
-var integrationRewardSchema = z16.object({
-  kind: z16.literal("integration"),
-  provider: z16.literal("discord"),
-  action: z16.literal("grant-role"),
-  roleId: z16.string().regex(/^[0-9]{1,20}$/)
+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}$/)
 }).strict();
-var rewardSchema = z16.union([
+var rewardSchema = z17.union([
   pointsRewardSchema,
   tierRewardSchema,
   integrationRewardSchema
@@ -1671,26 +1739,26 @@ function rewardKey(reward) {
   }
   return reward.kind === "points" ? "points:" + reward.balance : "tier:" + reward.reward.id;
 }
-var triggerSchema = z16.union([
-  z16.object({
-    kind: z16.literal("manual"),
-    input: z16.literal("text"),
+var triggerSchema = z17.union([
+  z17.object({
+    kind: z17.literal("manual"),
+    input: z17.literal("text"),
     constraints: textOptionsSchema,
-    actor: z16.enum(["member", "staff"]).optional()
+    actor: z17.enum(["member", "staff"]).optional()
   }).strict(),
-  z16.object({
-    kind: z16.literal("manual"),
-    input: z16.literal("url"),
+  z17.object({
+    kind: z17.literal("manual"),
+    input: z17.literal("url"),
     constraints: urlOptionsSchema,
-    actor: z16.enum(["member", "staff"]).optional()
+    actor: z17.enum(["member", "staff"]).optional()
   }).strict(),
-  z16.object({
-    kind: z16.literal("manual"),
-    input: z16.enum(["photo", "quiz", "none"]),
-    actor: z16.enum(["member", "staff"]).optional()
+  z17.object({
+    kind: z17.literal("manual"),
+    input: z17.enum(["photo", "quiz", "none"]),
+    actor: z17.enum(["member", "staff"]).optional()
   }).strict(),
-  z16.object({
-    kind: z16.literal("automatic"),
+  z17.object({
+    kind: z17.literal("automatic"),
     observation: observationTriggerSchema.optional(),
     content: contentPolicySchema.optional(),
     tracker: trackerTriggerPolicySchema.optional()
@@ -1699,48 +1767,48 @@ var triggerSchema = z16.union([
     "Choose one automatic trigger source"
   )
 ]);
-var prerequisiteSchema = z16.object({ quest: identifier });
-var photoResultSchema = z16.object({
-  kind: z16.enum(["pass", "fail", "unclear"]),
-  reason: z16.string().min(1).max(2e3)
+var prerequisiteSchema = z17.object({ quest: identifier });
+var photoResultSchema = z17.object({
+  kind: z17.enum(["pass", "fail", "unclear"]),
+  reason: z17.string().min(1).max(2e3)
 }).strict();
-var textReviewInputSchema = z16.object({
-  text: z16.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
-  criteria: z16.string().trim().min(1).max(2e3)
+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)
 }).strict();
 var textResultSchema = photoResultSchema;
-var decisionSchema = z16.discriminatedUnion("kind", [
-  z16.object({
-    kind: z16.literal("accept"),
-    rewards: z16.array(rewardSchema).max(10),
+var decisionSchema = z17.discriminatedUnion("kind", [
+  z17.object({
+    kind: z17.literal("accept"),
+    rewards: z17.array(rewardSchema).max(10),
     completionKey: completionKeySchema.optional()
   }).strict(),
-  z16.object({
-    kind: z16.literal("reject"),
-    reason: z16.string().min(1).max(2e3),
+  z17.object({
+    kind: z17.literal("reject"),
+    reason: z17.string().min(1).max(2e3),
     /** The evaluator asked for human review, but review is off for the quest, so this is a reject. */
-    requestedReview: z16.literal(true).optional()
+    requestedReview: z17.literal(true).optional()
   }).strict(),
-  z16.object({
-    kind: z16.literal("review"),
-    reason: z16.string().min(1).max(2e3),
-    rewards: z16.array(rewardSchema).max(10).optional(),
+  z17.object({
+    kind: z17.literal("review"),
+    reason: z17.string().min(1).max(2e3),
+    rewards: z17.array(rewardSchema).max(10).optional(),
     completionKey: completionKeySchema.optional()
   }).strict()
 ]);
-var reviewModeSchema = z16.enum(["workers-ai"]);
-var storedReviewModeSchema = z16.enum([
+var reviewModeSchema = z17.enum(["workers-ai"]);
+var storedReviewModeSchema = z17.enum([
   "fixture-pass",
   "fixture-fail",
   "fixture-unclear",
   "fixture-error",
   "workers-ai"
 ]);
-var rewardBundleSchema = z16.array(rewardSchema).max(10).refine(
+var rewardBundleSchema = z17.array(rewardSchema).max(10).refine(
   (rewards) => new Set(rewards.map(rewardKey)).size === rewards.length,
   "Use one entry per balance or shared reward"
 );
-var mediaUrlSchema = z16.string().max(2e3).refine((value) => {
+var mediaUrlSchema = z17.string().max(2e3).refine((value) => {
   if (/^\/(?!\/)[^\\\s]*$/.test(value)) {
     return true;
   }
@@ -1750,82 +1818,85 @@ var mediaUrlSchema = z16.string().max(2e3).refine((value) => {
     return false;
   }
 }, "Use an HTTPS URL or a same-site path beginning with /");
-var questPresentationSchema = z16.object({
+var questPresentationSchema = z17.object({
   quiz: quizQuestionsSchema.optional(),
-  instructions: z16.string().max(4e3).optional(),
-  video: z16.object({
+  instructions: z17.string().max(4e3).optional(),
+  video: z17.object({
     url: mediaUrlSchema,
     poster: mediaUrlSchema.optional(),
-    captions: z16.object({
+    captions: z17.object({
       url: mediaUrlSchema,
-      language: z16.string().min(2).max(20),
-      label: z16.string().min(1).max(80)
+      language: z17.string().min(2).max(20),
+      label: z17.string().min(1).max(80)
     }).strict().optional()
   }).strict().optional()
 }).strict();
-var questProfileSchema = z16.object({ visible: z16.boolean() }).strict();
-var questDescriptionSchema = z16.object({
+var questProfileSchema = z17.object({ visible: z17.boolean() }).strict();
+var questDescriptionSchema = z17.object({
   quest: identifier,
-  runtimeVersion: z16.union([z16.literal(1), z16.literal(2)]).default(1),
-  title: z16.string().min(1).max(120),
+  runtimeVersion: z17.union([z17.literal(1), z17.literal(2)]).default(1),
+  title: z17.string().min(1).max(120),
   presentation: questPresentationSchema.default({}),
-  integrations: z16.array(integrationProviderSchema).max(10).default([]),
+  integrations: z17.array(integrationProviderSchema).max(10).default([]),
   fields: settingsFieldsSchema,
   values: settingsValuesSchema,
   rewards: rewardBundleSchema,
-  humanReview: z16.boolean(),
+  humanReview: z17.boolean(),
   trigger: triggerSchema,
   performance: contentPerformancePolicySchema.optional(),
-  requires: z16.array(prerequisiteSchema).max(30).default([]),
-  completion: completionPolicySchema,
-  visibility: z16.enum(["visible", "hidden"]).default("visible"),
+  requires: z17.array(prerequisiteSchema).max(30).default([]),
+  completion: z17.preprocess(refuseStreakTimeZone, completionPolicySchema),
+  visibility: z17.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: z16.array(budgetSchema).max(20).default([])
+  budgets: z17.array(budgetSchema).max(20).default([])
 }).strict();
-var artifactSchema = z16.object({ code: z16.string().min(1).max(1e6) }).strict();
+var artifactSchema = z17.object({ code: z17.string().min(1).max(1e6) }).strict();
 var releaseSchema = artifactSchema.extend({
   settings: settingsValuesSchema,
   provider: reviewModeSchema,
   expectedRelease: identifier.nullable().optional(),
-  settingRenames: z16.record(z16.string(), z16.string()).optional()
+  settingRenames: z17.record(z17.string(), z17.string()).optional()
 }).strict();
-var batchReleaseSchema = z16.object({ releases: z16.array(releaseSchema).min(1).max(50) }).strict();
-var questSettingsInputSchema = z16.object({
+var batchReleaseSchema = z17.object({ releases: z17.array(releaseSchema).min(1).max(50) }).strict();
+var questSettingsInputSchema = z17.object({
   quest: identifier,
   expectedRelease: identifier,
   set: settingsValuesSchema,
-  reset: z16.array(z16.string())
+  reset: z17.array(z17.string())
 }).strict();
-var storedReleaseSchema = questDescriptionSchema.extend({
+var storedQuestDescriptionSchema = questDescriptionSchema.extend({
+  completion: completionPolicySchema
+});
+var storedReleaseSchema = storedQuestDescriptionSchema.extend({
   key: identifier.optional(),
-  code: z16.string(),
+  code: z17.string(),
   provider: storedReviewModeSchema,
   id: identifier,
-  createdAt: z16.number(),
-  legacy: z16.boolean().default(false),
-  origin: z16.object({ typeVersion: identifier }).strict().optional(),
-  lifecycle: z16.enum(["active", "paused", "archived"]).default("active"),
-  configuration: z16.object({
+  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({
     defaults: settingsValuesSchema,
     overrides: settingsValuesSchema,
-    preserved: z16.array(z16.string())
+    preserved: z17.array(z17.string())
   }).strict().optional()
 });
-var legacyReleaseSchema = z16.object({
+var legacyReleaseSchema = z17.object({
   quest: identifier,
-  title: z16.string(),
-  criteria: z16.string(),
-  humanReview: z16.boolean(),
+  title: z17.string(),
+  criteria: z17.string(),
+  humanReview: z17.boolean(),
   rewards: rewardBundleSchema,
-  code: z16.string(),
+  code: z17.string(),
   provider: storedReviewModeSchema,
   id: identifier,
-  createdAt: z16.number()
+  createdAt: z17.number()
 }).transform((r) => {
   const { criteria, ...stored } = r;
   return storedReleaseSchema.parse({
@@ -1837,15 +1908,15 @@ var legacyReleaseSchema = z16.object({
     legacy: true
   });
 });
-var publishedReleaseSchema = z16.union([
+var publishedReleaseSchema = z17.union([
   storedReleaseSchema,
   legacyReleaseSchema
 ]);
-var templateSchema = z16.object({
-  code: z16.string(),
+var templateSchema = z17.object({
+  code: z17.string(),
   definition: questDescriptionSchema
 });
-var quizAnswersSchema = z16.record(identifier, identifier).refine(
+var quizAnswersSchema = z17.record(identifier, identifier).refine(
   (answers) => Object.keys(answers).length > 0 && Object.keys(answers).length <= 50,
   "Provide between 1 and 50 answers"
 ).transform(
@@ -1853,33 +1924,33 @@ var quizAnswersSchema = z16.record(identifier, identifier).refine(
     Object.entries(answers).sort(([a], [b]) => a.localeCompare(b))
   )
 );
-var quizEvidenceSchema = z16.object({
-  kind: z16.literal("quiz"),
+var quizEvidenceSchema = z17.object({
+  kind: z17.literal("quiz"),
   release: identifier.optional(),
   answers: quizAnswersSchema
 }).strict();
-var submissionEvidenceSchema = z16.union([
+var submissionEvidenceSchema = z17.union([
   quizEvidenceSchema,
   textEvidenceSchema,
   urlEvidenceSchema
 ]);
-var submitSchema = z16.object({
+var submitSchema = z17.object({
   actionId: identifier,
   quest: identifier,
   member: identifier,
   evidence: identifier.optional(),
   input: submissionEvidenceSchema.optional(),
   release: identifier.optional(),
-  faultAfterReview: z16.boolean().optional()
+  faultAfterReview: z17.boolean().optional()
 }).strict();
-var attemptSchema = z16.object({
+var attemptSchema = z17.object({
   id: identifier,
   release: identifier,
   quest: identifier,
   member: identifier,
   evidence: identifier.nullable(),
   input: submissionEvidenceSchema.optional(),
-  status: z16.enum([
+  status: z17.enum([
     "queued",
     "evaluating",
     "accepted",
@@ -1888,75 +1959,75 @@ var attemptSchema = z16.object({
     "needs-review",
     "failed"
   ]),
-  reason: z16.string().nullable(),
-  retries: z16.number(),
-  generation: z16.number(),
-  completion: z16.string().nullable(),
+  reason: z17.string().nullable(),
+  retries: z17.number(),
+  generation: z17.number(),
+  completion: z17.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: z16.boolean().default(false),
-  createdAt: z16.number()
-});
-var eventSchema = z16.object({
-  id: z16.number(),
-  attempt: z16.string().nullable(),
-  kind: z16.string(),
-  detail: z16.string(),
-  actor: z16.string().nullable().default(null),
-  at: z16.number()
-});
-var pickupSelectionSchema = z16.object({
+  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({
   item: identifier,
-  revision: z16.number().int().nonnegative()
+  revision: z17.number().int().nonnegative()
 }).strict();
-var pickupAllocationSchema = z16.object({
+var pickupAllocationSchema = z17.object({
   item: identifier,
-  label: z16.string().min(1).max(80)
+  label: z17.string().min(1).max(80)
 }).strict();
-var pickupPolicySchema = z16.discriminatedUnion("kind", [
-  z16.object({ kind: z16.literal("untracked") }).strict(),
-  z16.object({
-    kind: z16.literal("at-pickup"),
-    tiers: z16.array(
-      z16.object({
+var pickupPolicySchema = z17.discriminatedUnion("kind", [
+  z17.object({ kind: z17.literal("untracked") }).strict(),
+  z17.object({
+    kind: z17.literal("at-pickup"),
+    tiers: z17.array(
+      z17.object({
         tier: identifier,
-        variants: z16.array(pickupAllocationSchema).min(1).max(100)
+        variants: z17.array(pickupAllocationSchema).min(1).max(100)
       }).strict()
     ).min(1).max(100)
   }).strict()
 ]);
-var pickupCatalogSchema = z16.object({
+var pickupCatalogSchema = z17.object({
   reward: tieredRewardDefinitionSchema,
-  revision: z16.number().int().nonnegative(),
+  revision: z17.number().int().nonnegative(),
   policy: pickupPolicySchema
 });
-var pickupAvailabilitySchema = z16.discriminatedUnion("kind", [
-  z16.object({ kind: z16.literal("untracked") }).strict(),
-  z16.object({
-    kind: z16.literal("at-pickup"),
-    revision: z16.number().int().nonnegative(),
-    variants: z16.array(
+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(
       pickupAllocationSchema.extend({
-        available: z16.number().int().nonnegative()
+        available: z17.number().int().nonnegative()
       })
     )
   }).strict()
 ]);
-var configurePickupSchema = z16.object({
+var configurePickupSchema = z17.object({
   reward: identifier,
-  revision: z16.number().int().nonnegative(),
+  revision: z17.number().int().nonnegative(),
   actionId: identifier,
-  policy: z16.discriminatedUnion("kind", [
-    z16.object({ kind: z16.literal("untracked") }).strict(),
-    z16.object({
-      kind: z16.literal("at-pickup"),
-      tiers: z16.array(
-        z16.object({
+  policy: z17.discriminatedUnion("kind", [
+    z17.object({ kind: z17.literal("untracked") }).strict(),
+    z17.object({
+      kind: z17.literal("at-pickup"),
+      tiers: z17.array(
+        z17.object({
           tier: identifier,
-          variants: z16.array(
+          variants: z17.array(
             pickupAllocationSchema.extend({
               item: identifier.optional()
             })
@@ -1972,164 +2043,164 @@ var entitlementBase = {
   reward: tieredRewardDefinitionSchema,
   earnedTier: identifier,
   tier: identifier,
-  revision: z16.number().int().positive()
+  revision: z17.number().int().positive()
 };
-var entitlementSchema = z16.discriminatedUnion("status", [
-  z16.object({ ...entitlementBase, status: z16.literal("available") }).strict(),
-  z16.object({
+var entitlementSchema = z17.discriminatedUnion("status", [
+  z17.object({ ...entitlementBase, status: z17.literal("available") }).strict(),
+  z17.object({
     ...entitlementBase,
-    status: z16.literal("handing-over"),
+    status: z17.literal("handing-over"),
     handover: identifier,
-    startedAt: z16.number(),
+    startedAt: z17.number(),
     allocation: pickupAllocationSchema.optional()
   }).strict(),
-  z16.object({
+  z17.object({
     ...entitlementBase,
-    status: z16.literal("collected"),
+    status: z17.literal("collected"),
     handover: identifier,
-    startedAt: z16.number(),
+    startedAt: z17.number(),
     allocation: pickupAllocationSchema.optional(),
-    collectedAt: z16.number()
+    collectedAt: z17.number()
   }).strict()
 ]);
-var beginHandoverSchema = z16.object({
+var beginHandoverSchema = z17.object({
   actionId: identifier,
-  revision: z16.number().int().positive(),
+  revision: z17.number().int().positive(),
   selection: pickupSelectionSchema.optional()
 }).strict();
-var confirmHandoverSchema = z16.object({ actionId: identifier, handover: identifier }).strict();
-var completionRecordSchema = z16.object({
-  key: z16.string().default("once"),
+var confirmHandoverSchema = z17.object({ actionId: identifier, handover: identifier }).strict();
+var completionRecordSchema = z17.object({
+  key: z17.string().default("once"),
   id: identifier,
   quest: identifier,
   member: identifier
 });
-var questAvailabilitySchema = z16.discriminatedUnion("kind", [
-  z16.object({
-    kind: z16.literal("available"),
-    input: z16.enum(["photo", "quiz", "none", "text", "url"])
+var questAvailabilitySchema = z17.discriminatedUnion("kind", [
+  z17.object({
+    kind: z17.literal("available"),
+    input: z17.enum(["photo", "quiz", "none", "text", "url"])
   }).strict(),
-  z16.object({ kind: z16.literal("completed") }).strict(),
-  z16.object({
-    kind: z16.literal("locked"),
-    missing: z16.array(z16.object({ quest: identifier, title: z16.string() })).min(1)
+  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)
   }).strict(),
-  z16.object({ kind: z16.literal("staff-required") }).strict(),
-  z16.object({
-    kind: z16.literal("automatic"),
+  z17.object({ kind: z17.literal("staff-required") }).strict(),
+  z17.object({
+    kind: z17.literal("automatic"),
     observation: observationTriggerSchema.optional()
   }).strict(),
-  z16.object({ kind: z16.literal("checking"), attempt: identifier }).strict(),
-  z16.object({ kind: z16.literal("needs-review"), attempt: identifier }).strict(),
-  z16.object({ kind: z16.literal("retryable"), attempt: identifier }).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()
 ]);
-var memberProgressSchema = z16.object({
+var memberProgressSchema = z17.object({
   member: identifier,
-  quests: z16.array(
-    z16.object({
+  quests: z17.array(
+    z17.object({
       quest: identifier,
       key: identifier.optional(),
       release: identifier.optional(),
-      title: z16.string(),
+      title: z17.string(),
       presentation: questPresentationSchema.default({}),
-      connections: z16.array(authProviderSchema).default([]),
+      connections: z17.array(authProviderSchema).default([]),
       trigger: triggerSchema,
       availability: questAvailabilitySchema,
-      completed: z16.boolean(),
+      completed: z17.boolean(),
       completion: completionPolicySchema.default({ kind: "once" }),
       streak: streakProgressSchema.nullable().optional(),
-      completionCount: z16.number().int().nonnegative().default(0),
-      visibility: z16.enum(["visible", "hidden"]).default("visible"),
-      missing: z16.array(z16.object({ quest: identifier, title: z16.string() })),
+      completionCount: z17.number().int().nonnegative().default(0),
+      visibility: z17.enum(["visible", "hidden"]).default("visible"),
+      missing: z17.array(z17.object({ quest: identifier, title: z17.string() })),
       attempt: attemptSchema.nullable()
     })
   ),
-  entitlements: z16.array(entitlementSchema)
-});
-var snapshotSchema = z16.object({
-  releases: z16.array(publishedReleaseSchema),
-  completions: z16.array(completionRecordSchema),
-  entitlements: z16.array(entitlementSchema),
-  attempts: z16.array(attemptSchema),
-  balances: z16.array(
-    z16.object({
-      member: z16.string(),
-      balance: z16.string(),
-      earned: z16.number(),
-      held: z16.number(),
-      available: z16.number()
+  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()
     })
   ),
-  events: z16.array(eventSchema)
+  events: z17.array(eventSchema)
 });
-var evidenceSchema = z16.object({
+var evidenceSchema = z17.object({
   id: identifier,
   member: identifier,
-  type: z16.enum(["image/jpeg", "image/png"]),
-  size: z16.number()
+  type: z17.enum(["image/jpeg", "image/png"]),
+  size: z17.number()
 });
-var errorSchema = z16.object({
-  error: z16.string(),
-  code: z16.string().optional(),
-  missing: z16.array(z16.object({ quest: identifier, title: z16.string() })).optional()
+var errorSchema = z17.object({
+  error: z17.string(),
+  code: z17.string().optional(),
+  missing: z17.array(z17.object({ quest: identifier, title: z17.string() })).optional()
 });
-var staffDecisionSchema = z16.object({
+var staffDecisionSchema = z17.object({
   actionId: identifier,
-  generation: z16.number().int().nonnegative(),
-  decision: z16.enum(["accept", "reject"]),
-  reason: z16.string().trim().min(1).max(2e3)
+  generation: z17.number().int().nonnegative(),
+  decision: z17.enum(["accept", "reject"]),
+  reason: z17.string().trim().min(1).max(2e3)
 }).strict();
-var stockSchema = z16.object({ item: identifier, quantity: z16.number().int().min(0).max(1e4) }).strict();
-var reservationSchema = z16.object({
+var stockSchema = z17.object({ item: identifier, quantity: z17.number().int().min(0).max(1e4) }).strict();
+var reservationSchema = z17.object({
   actionId: identifier,
   member: identifier,
   item: identifier,
   balance: identifier,
-  price: z16.number().int().positive().max(1e4)
+  price: z17.number().int().positive().max(1e4)
 }).strict();
 var pageOptions = {
-  limit: z16.number().int().min(1).max(100).default(25),
-  cursor: z16.string().min(1).max(4096).optional()
+  limit: z17.number().int().min(1).max(100).default(25),
+  cursor: z17.string().min(1).max(4096).optional()
 };
-var reviewListSchema = z16.object({
+var reviewListSchema = z17.object({
   ...pageOptions,
   member: identifier.optional(),
   quest: identifier.optional()
 }).strict();
-var memberListSchema = z16.object({
+var memberListSchema = z17.object({
   ...pageOptions,
   prefix: identifier.optional()
 }).strict();
-var reviewItemSchema = z16.object({
+var reviewItemSchema = z17.object({
   attempt: attemptSchema,
-  title: z16.string(),
-  checks: z16.array(
-    z16.object({ criteria: z16.string(), result: photoResultSchema })
+  title: z17.string(),
+  checks: z17.array(
+    z17.object({ criteria: z17.string(), result: photoResultSchema })
   )
 });
-var reviewPageSchema = z16.object({
-  items: z16.array(reviewItemSchema).max(100),
-  nextCursor: z16.string().nullable()
+var reviewPageSchema = z17.object({
+  items: z17.array(reviewItemSchema).max(100),
+  nextCursor: z17.string().nullable()
 });
-var memberPageSchema = z16.object({
-  items: z16.array(z16.object({ member: identifier })).max(100),
-  nextCursor: z16.string().nullable()
+var memberPageSchema = z17.object({
+  items: z17.array(z17.object({ member: identifier })).max(100),
+  nextCursor: z17.string().nullable()
 });
-var createStockItemSchema = z16.object({ actionId: identifier, name: z16.string().trim().min(1).max(80) }).strict();
-var stockItemSchema = z16.object({ id: identifier, name: z16.string() });
-var contentPerformanceSnapshotSchema = z16.strictObject({
+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({
   contentAttempt: identifier,
   observation: identifier,
-  observedAt: z16.number().int().safe().nonnegative(),
+  observedAt: z17.number().int().safe().nonnegative(),
   metrics: contentMetricsSchema,
   rewards: rewardBundleSchema
 });
 var contentPerformanceQuerySchema = contentQualificationQuerySchema.extend({
-  content: z16.string().min(1).max(256)
+  content: z17.string().min(1).max(256)
 });
-var contentPerformancePageSchema = z16.strictObject({
-  current: z16.strictObject({
-    state: z16.enum([
+var contentPerformancePageSchema = z17.strictObject({
+  current: z17.strictObject({
+    state: z17.enum([
       "content-pending",
       "content-unqualified",
       "waiting",
@@ -2140,19 +2211,19 @@ var contentPerformancePageSchema = z16.strictObject({
       "failed",
       "superseded"
     ]),
-    reason: z16.string().nullable(),
+    reason: z17.string().nullable(),
     contentAttempt: identifier,
     attempt: identifier.nullable(),
     reward: contentQualificationSchema.shape.reward
   }),
-  items: z16.array(
-    z16.strictObject({
+  items: z17.array(
+    z17.strictObject({
       attempt: identifier,
       contentAttempt: identifier,
       observation: identifier,
-      observedAt: z16.number(),
+      observedAt: z17.number(),
       metrics: contentMetricsSchema,
-      state: z16.enum([
+      state: z17.enum([
         "pending",
         "qualified",
         "unqualified",
@@ -2160,7 +2231,7 @@ var contentPerformancePageSchema = z16.strictObject({
         "failed",
         "superseded"
       ]),
-      reason: z16.string().nullable()
+      reason: z17.string().nullable()
     })
   ),
   nextCursor: pageCursorSchema.nullable()
@@ -2235,7 +2306,15 @@ export {
   contentMetricSchema,
   contentMetricsSchema,
   contentPerformancePolicySchema,
-  communityTimeZoneSchema,
+  canonicalTimeZone,
+  timeZoneSchema,
+  timeZoneNameSchema,
+  refuseStreakTimeZone,
+  refuseWindowTimeZone,
+  calendarPeriodSchema,
+  projectCalendarSchema,
+  projectCalendarInputSchema,
+  projectCalendarDeclarationSchema,
   streakPolicySchema,
   streakProgressSchema,
   trackerTriggerModeSchema,
@@ -2309,6 +2388,7 @@ export {
   releaseSchema,
   batchReleaseSchema,
   questSettingsInputSchema,
+  storedQuestDescriptionSchema,
   publishedReleaseSchema,
   templateSchema,
   quizAnswersSchema,