@domino-sdk/relay 0.17.2 → 0.18.0

package/dist/chunk-YUAE6PFY.js

@@ -1,1048 +0,0 @@
-// src/streaks.ts
-import { z } from "zod";
-var communityTimeZoneSchema = z.string().min(1).max(100).refine((zone) => {
-  try {
-    if (/^[+-]/.test(zone)) {
-      return false;
-    }
-    new Intl.DateTimeFormat("en", { timeZone: zone });
-    return true;
-  } catch {
-    return false;
-  }
-}, "Use an IANA community timezone, such as Europe/Budapest");
-var streakPolicySchema = z.object({
-  kind: z.literal("streak"),
-  days: z.number().int().min(1).max(3650),
-  timeZone: communityTimeZoneSchema
-}).strict();
-var streak = (options) => streakPolicySchema.parse({ kind: "streak", ...options });
-var streakProgressSchema = z.object({
-  goal: z.number().int().positive(),
-  current: z.number().int().nonnegative(),
-  best: z.number().int().nonnegative(),
-  today: z.string(),
-  todayQualified: z.boolean(),
-  timeZone: communityTimeZoneSchema,
-  nextBoundary: z.number().int(),
-  pendingTimeZone: z.object({
-    timeZone: communityTimeZoneSchema,
-    effectiveAt: z.number().int()
-  }).nullable(),
-  days: z.array(
-    z.object({
-      day: z.number().int(),
-      date: z.string(),
-      timeZone: communityTimeZoneSchema,
-      occurredAt: z.number().int()
-    })
-  ),
-  milestone: z.discriminatedUnion("status", [
-    z.object({ status: z.literal("pending") }),
-    z.object({
-      status: z.literal("awarded"),
-      completion: z.string(),
-      achievedAt: z.number().int()
-    }),
-    z.object({
-      status: z.literal("budget-exhausted"),
-      budget: z.string(),
-      achievedAt: z.number().int()
-    })
-  ])
-});
-
-// src/identifier.ts
-import { z as z2 } from "zod";
-var identifier = z2.string().min(1).max(100).regex(/^[a-zA-Z0-9_-]+$/);
-
-// src/observations.ts
-import { z as z3 } from "zod";
-var name = z3.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
-var observationInputSchema = z3.object({
-  id: name,
-  source: name,
-  type: name,
-  member: identifier,
-  actor: z3.object({ provider: identifier, subject: z3.string().min(1).max(200) }).strict().optional(),
-  occurredAt: z3.number().int().nonnegative().max(864e13),
-  data: z3.record(z3.string(), z3.json())
-}).strict().refine(
-  (value) => JSON.stringify(value.data).length <= 32768,
-  "Observation data exceeds 32 KB"
-);
-var observationSchema = observationInputSchema.safeExtend({
-  receivedAt: z3.number().int().nonnegative()
-});
-var observationTriggerSchema = z3.object({ source: name, type: name }).strict();
-var completionPolicySchema = z3.discriminatedUnion("kind", [
-  streakPolicySchema,
-  z3.object({ kind: z3.literal("once") }).strict(),
-  z3.object({ kind: z3.literal("keyed") }).strict()
-]);
-var completionKeySchema = z3.string().min(1).max(500);
-var budgetSchema = z3.object({
-  id: name,
-  scope: z3.enum(["member", "project"]),
-  period: z3.enum(["lifetime", "day"]),
-  limit: z3.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  cost: z3.union([
-    z3.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-    z3.object({ balance: name }).strict()
-  ])
-}).strict();
-var observationReceiptSchema = z3.object({
-  id: name,
-  source: name,
-  attempts: z3.array(z3.string()),
-  receivedAt: z3.number()
-});
-var discordReactionSchema = z3.object({
-  guildId: z3.string(),
-  channelId: z3.string(),
-  messageId: z3.string(),
-  userId: z3.string(),
-  messageAuthorId: z3.string().nullable().default(null),
-  actorRoles: z3.array(z3.string()).default([]),
-  emoji: z3.object({ id: z3.string().nullable(), name: z3.string() }),
-  messagePublishedAt: z3.number()
-}).strict();
-var discordMessageSchema = z3.object({
-  guildId: z3.string(),
-  channelId: z3.string(),
-  messageId: z3.string(),
-  userId: z3.string(),
-  content: z3.string().nullable(),
-  replyTo: z3.string().nullable(),
-  publishedAt: z3.number()
-}).strict();
-
-// src/integrations.ts
-import { z as z4 } from "zod";
-var integrationProviderSchema = z4.enum(["discord"]);
-var discordServerSchema = z4.object({
-  id: z4.string().regex(/^[0-9]{1,20}$/),
-  name: z4.string().min(1),
-  icon: z4.string().nullable()
-});
-var projectIntegrationSchema = z4.object({
-  provider: integrationProviderSchema,
-  configured: z4.boolean(),
-  status: z4.enum(["disconnected", "ready", "attention"]),
-  revision: z4.number().int().nonnegative(),
-  server: discordServerSchema.nullable(),
-  issue: z4.string().nullable(),
-  connectedAt: z4.number().default(0)
-});
-
-// src/accounts.ts
-import { z as z5 } from "zod";
-var authProviderSchema = z5.enum(["google", "apple", "x", "discord"]);
-var accountConnectionSchema = z5.object({
-  provider: authProviderSchema,
-  configured: z5.boolean(),
-  status: z5.enum(["disconnected", "connected", "reconnect"]),
-  subject: z5.string().nullable(),
-  revision: z5.number().int().nonnegative()
-});
-var discordMemberInputSchema = z5.object({}).strict();
-var discordMessageInputSchema = z5.object({
-  channelId: z5.string().regex(/^[0-9]{1,20}$/),
-  messageId: z5.string().regex(/^[0-9]{1,20}$/)
-}).strict();
-var discordMemberSchema = z5.object({
-  userId: z5.string().regex(/^[0-9]{1,20}$/).nullable().default(null),
-  nickname: z5.string().nullable().default(null),
-  displayName: z5.string().nullable().default(null),
-  boostingSince: z5.string().datetime({ offset: true }).nullable().default(null),
-  roles: z5.array(z5.string().regex(/^[0-9]{1,20}$/)),
-  joinedAt: z5.string().datetime({ offset: true }).nullable(),
-  pending: z5.boolean()
-});
-
-// src/submission-input.ts
-import { z as z6 } from "zod";
-var textOptionsSchema = z6.object({
-  required: z6.boolean().default(true),
-  minLength: z6.number().int().min(0).max(1e4).default(1),
-  maxLength: z6.number().int().min(1).max(1e4).default(1e4)
-}).strict().refine(
-  (v) => v.minLength <= v.maxLength,
-  "minLength must not exceed maxLength"
-);
-var hostSchema = z6.string().min(1).max(253).refine((host) => {
-  if (!/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/i.test(host) || host.includes("..")) {
-    return false;
-  }
-  try {
-    const url = new URL(`https://${host}`);
-    return url.hostname === host.toLowerCase() && !url.port && !url.username && !url.password && url.pathname === "/" && !url.search && !url.hash;
-  } catch {
-    return false;
-  }
-}, "Use a hostname without a scheme, path, port, or wildcard");
-var urlOptionsSchema = z6.object({
-  required: z6.boolean().default(true),
-  allowedHosts: z6.array(hostSchema).min(1).max(100).optional()
-}).strict();
-var textEvidenceSchema = z6.object({ kind: z6.literal("text"), value: z6.string().max(1e4) }).strict();
-var urlEvidenceSchema = z6.object({ kind: z6.literal("url"), value: z6.string().max(2048) }).strict();
-var valueEvidenceSchema = z6.discriminatedUnion("kind", [
-  textEvidenceSchema,
-  urlEvidenceSchema
-]);
-function validateSubmissionValue(input, contract) {
-  const maximum = input.kind === "text" ? 1e4 : 2048;
-  if (input.value.length > maximum) {
-    return `Enter no more than ${maximum} characters`;
-  }
-  if (input.kind !== contract.input) {
-    return `This quest requires ${contract.input} input`;
-  }
-  if (!input.value.trim()) {
-    return contract.constraints.required ? "This field is required" : null;
-  }
-  if (contract.input === "text") {
-    if (input.value.length < contract.constraints.minLength) {
-      return `Enter at least ${contract.constraints.minLength} characters`;
-    }
-    if (input.value.length > contract.constraints.maxLength) {
-      return `Enter no more than ${contract.constraints.maxLength} characters`;
-    }
-    return null;
-  }
-  const url = parseHttpUrl(input.value);
-  if (!url) {
-    return "Enter a valid HTTP or HTTPS URL without credentials";
-  }
-  if (contract.constraints.allowedHosts && !contract.constraints.allowedHosts.some(
-    (host) => host.toLowerCase() === url.hostname.toLowerCase()
-  )) {
-    return `Use a URL hosted on: ${contract.constraints.allowedHosts.join(", ")}`;
-  }
-  return null;
-}
-function parseHttpUrl(value) {
-  if (value !== value.trim() || /[\\\s]/.test(value) || !/^https?:\/\//i.test(value)) {
-    return null;
-  }
-  try {
-    const url = new URL(value);
-    return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password ? url : null;
-  } catch {
-    return null;
-  }
-}
-function xPostId(value) {
-  const url = parseHttpUrl(value);
-  if (!url || url.port || ![
-    "x.com",
-    "www.x.com",
-    "twitter.com",
-    "www.twitter.com",
-    "mobile.twitter.com"
-  ].includes(url.hostname)) {
-    return null;
-  }
-  return /^\/(?:[A-Za-z0-9_]+|i\/web)\/status\/([0-9]{1,20})\/?$/.exec(
-    url.pathname
-  )?.[1] ?? null;
-}
-
-// src/quiz.ts
-import { z as z7 } from "zod";
-var quizId = z7.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
-var quizChoiceSchema = z7.object({ id: quizId, label: z7.string().trim().min(1).max(500) }).strict();
-var quizQuestionSchema = z7.object({
-  id: quizId,
-  prompt: z7.string().trim().min(1).max(1e3),
-  choices: z7.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 = z7.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 = z7.array(
-  quizQuestionSchema.extend({ correct: quizId }).refine(
-    (question) => question.choices.some((choice) => choice.id === question.correct),
-    "Choose a correct answer from the available choices"
-  )
-).min(1).max(20).refine(
-  (questions) => new Set(questions.map((question) => question.id)).size === questions.length,
-  "Question IDs must be unique"
-);
-
-// src/schema.ts
-import { z as z10 } from "zod";
-
-// src/settings.ts
-import { z as z9 } from "zod";
-
-// src/resources.ts
-import { z as z8 } from "zod";
-var channelSourceSchema = z8.object({
-  provider: z8.literal("discord"),
-  resource: z8.literal("channel"),
-  types: z8.array(z8.enum(["text", "announcement"])).min(1)
-}).strict();
-var resourceSourceSchema = z8.union([
-  z8.object({
-    provider: z8.literal("domino"),
-    resource: z8.literal("point-ledger")
-  }).strict(),
-  channelSourceSchema,
-  z8.object({
-    provider: z8.literal("discord"),
-    resource: z8.literal("role"),
-    assignable: z8.boolean().default(false)
-  }).strict()
-]);
-var resourceRequestSchema = z8.object({
-  source: resourceSourceSchema,
-  query: z8.string().max(100).optional(),
-  cursor: z8.string().regex(/^\d{1,6}$/).optional(),
-  ids: z8.array(z8.string().min(1).max(100)).max(50).optional()
-}).strict();
-var resourceOptionsSchema = z8.object({
-  revision: z8.number().int(),
-  options: z8.array(
-    z8.object({
-      id: z8.string(),
-      label: z8.string(),
-      description: z8.string().optional(),
-      group: z8.string().optional(),
-      disabledReason: z8.string().optional()
-    })
-  ),
-  cursor: z8.string().nullable()
-});
-var discord = {
-  roles(options = {}) {
-    return resourceSourceSchema.parse({
-      provider: "discord",
-      resource: "role",
-      assignable: options.assignable ?? false
-    });
-  },
-  channels(options = {}) {
-    return resourceSourceSchema.parse({
-      provider: "discord",
-      resource: "channel",
-      types: options.types ?? ["text", "announcement"]
-    });
-  }
-};
-var pointLedgers = () => ({
-  provider: "domino",
-  resource: "point-ledger"
-});
-
-// src/settings.ts
-var instant = z9.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
-var resourceId = z9.union([z9.literal(""), z9.string().regex(/^\S{1,200}$/)]);
-var base = { label: z9.string().min(1), description: z9.string().optional() };
-var settingFieldSchema = z9.discriminatedUnion("kind", [
-  z9.object({ ...base, kind: z9.literal("point-ledger"), default: identifier }).strict(),
-  z9.object({ ...base, kind: z9.literal("datetime"), default: instant }).strict(),
-  z9.object({
-    ...base,
-    kind: z9.literal("resource"),
-    default: resourceId,
-    source: resourceSourceSchema
-  }).strict(),
-  z9.object({ ...base, kind: z9.literal("quiz"), default: quizContentSchema }).strict(),
-  z9.object({
-    ...base,
-    kind: z9.literal("text"),
-    default: z9.string(),
-    minLength: z9.number().int().nonnegative(),
-    maxLength: z9.number().int().positive(),
-    multiline: z9.boolean()
-  }).strict(),
-  z9.object({
-    ...base,
-    kind: z9.literal("integer"),
-    default: z9.number().int(),
-    min: z9.number().int(),
-    max: z9.number().int()
-  }).strict(),
-  z9.object({ ...base, kind: z9.literal("boolean"), default: z9.boolean() }).strict(),
-  z9.object({
-    ...base,
-    kind: z9.literal("choice"),
-    default: z9.string(),
-    options: z9.array(z9.string().min(1)).min(1)
-  }).strict()
-]);
-var settingsFieldsSchema = z9.record(
-  z9.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
-  settingFieldSchema
-);
-var settingsValuesSchema = z9.record(
-  z9.string(),
-  z9.union([z9.string(), z9.number().finite(), z9.boolean(), quizContentSchema])
-);
-var settings = {
-  pointLedger(options) {
-    const field = {
-      ...options,
-      kind: "point-ledger",
-      default: identifier.parse(options.default)
-    };
-    return identifier.default(field.default).meta(field);
-  },
-  datetime(options) {
-    const field = {
-      ...options,
-      kind: "datetime",
-      default: instant.parse(options.default)
-    };
-    return instant.default(field.default).meta(field);
-  },
-  resource(options) {
-    const field = {
-      ...options,
-      source: resourceSourceSchema.parse(options.source),
-      kind: "resource",
-      default: resourceId.parse(options.default ?? "")
-    };
-    return resourceId.default(field.default).meta(field);
-  },
-  quiz(options) {
-    const value = quizContentSchema.parse(options.default);
-    return quizContentSchema.default(value).meta({ ...options, default: value, kind: "quiz" });
-  },
-  text(options) {
-    const field = {
-      ...options,
-      kind: "text",
-      minLength: options.minLength ?? 1,
-      maxLength: options.maxLength ?? 2e3,
-      multiline: options.multiline ?? false
-    };
-    return z9.string().min(field.minLength).max(field.maxLength).default(field.default).meta(field);
-  },
-  integer(options) {
-    return z9.number().int().min(options.min).max(options.max).default(options.default).meta({ ...options, kind: "integer" });
-  },
-  boolean(options) {
-    return z9.boolean().default(options.default).meta({ ...options, kind: "boolean" });
-  },
-  choice(options) {
-    return z9.enum(options.options).default(options.default).meta({ ...options, kind: "choice" });
-  },
-  object(shape) {
-    return z9.object(shape).strict();
-  }
-};
-function parseSettings(fields, input) {
-  const shape = {};
-  for (const [key, field] of Object.entries(fields)) {
-    switch (field.kind) {
-      case "point-ledger":
-        shape[key] = identifier.default(field.default);
-        break;
-      case "datetime":
-        shape[key] = instant.default(field.default);
-        break;
-      case "resource":
-        shape[key] = resourceId.default(field.default);
-        break;
-      case "quiz":
-        shape[key] = quizContentSchema.default(field.default);
-        break;
-      case "text":
-        shape[key] = z9.string().min(field.minLength).max(field.maxLength).default(field.default);
-        break;
-      case "integer":
-        shape[key] = z9.number().int().min(field.min).max(field.max).default(field.default);
-        break;
-      case "boolean":
-        shape[key] = z9.boolean().default(field.default);
-        break;
-      case "choice":
-        shape[key] = z9.enum(field.options).default(field.default);
-        break;
-    }
-  }
-  return settingsValuesSchema.parse(z9.object(shape).strict().parse(input));
-}
-function missingResourceSettings(fields, values) {
-  return Object.entries(fields).filter(([key, field]) => field.kind === "resource" && !values[key]).map(([key]) => key);
-}
-function compatibleSettingKinds(previous, next) {
-  return previous.kind === next.kind || previous.kind === "text" && (next.kind === "resource" || next.kind === "datetime" || next.kind === "point-ledger");
-}
-
-// src/schema.ts
-var pointsRewardSchema = z10.object({
-  kind: z10.literal("points").default("points"),
-  balance: identifier,
-  amount: z10.number().int().min(0).max(1e4)
-}).strict();
-var tieredRewardDefinitionSchema = z10.object({
-  id: identifier,
-  title: z10.string().min(1).max(120),
-  tiers: z10.array(
-    z10.object({ id: identifier, title: z10.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: z10.object({ kind: z10.literal("untracked") }).strict(),
-  fulfillment: z10.object({ kind: z10.literal("staff-handover") }).strict()
-}).strict();
-var tierRewardSchema = z10.object({
-  kind: z10.literal("tier"),
-  reward: tieredRewardDefinitionSchema,
-  tier: identifier
-}).strict().refine(
-  (value) => value.reward.tiers.some((t) => t.id === value.tier),
-  "Unknown reward tier"
-);
-var integrationRewardSchema = z10.object({
-  kind: z10.literal("integration"),
-  provider: z10.literal("discord"),
-  action: z10.literal("grant-role"),
-  roleId: z10.string().regex(/^[0-9]{1,20}$/)
-}).strict();
-var rewardSchema = z10.union([
-  pointsRewardSchema,
-  tierRewardSchema,
-  integrationRewardSchema
-]);
-function rewardKey(reward) {
-  if (reward.kind === "integration") {
-    return `integration:${reward.provider}:${reward.action}:${reward.roleId}`;
-  }
-  return reward.kind === "points" ? "points:" + reward.balance : "tier:" + reward.reward.id;
-}
-var triggerSchema = z10.union([
-  z10.object({
-    kind: z10.literal("manual"),
-    input: z10.literal("text"),
-    constraints: textOptionsSchema,
-    actor: z10.enum(["member", "staff"]).optional()
-  }).strict(),
-  z10.object({
-    kind: z10.literal("manual"),
-    input: z10.literal("url"),
-    constraints: urlOptionsSchema,
-    actor: z10.enum(["member", "staff"]).optional()
-  }).strict(),
-  z10.object({
-    kind: z10.literal("manual"),
-    input: z10.enum(["photo", "quiz", "none"]),
-    actor: z10.enum(["member", "staff"]).optional()
-  }).strict(),
-  z10.object({
-    kind: z10.literal("automatic"),
-    observation: observationTriggerSchema.optional()
-  }).strict()
-]);
-var prerequisiteSchema = z10.object({ quest: identifier, scope: z10.literal("ever") }).strict();
-var photoResultSchema = z10.object({
-  kind: z10.enum(["pass", "fail", "unclear"]),
-  reason: z10.string().min(1).max(2e3)
-}).strict();
-var textReviewInputSchema = z10.object({
-  text: z10.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
-  criteria: z10.string().trim().min(1).max(2e3)
-}).strict();
-var textResultSchema = photoResultSchema;
-var decisionSchema = z10.discriminatedUnion("kind", [
-  z10.object({
-    kind: z10.literal("accept"),
-    rewards: z10.array(rewardSchema).max(10),
-    completionKey: completionKeySchema.optional()
-  }).strict(),
-  z10.object({ kind: z10.literal("reject"), reason: z10.string().min(1).max(2e3) }).strict(),
-  z10.object({
-    kind: z10.literal("review"),
-    reason: z10.string().min(1).max(2e3),
-    rewards: z10.array(rewardSchema).max(10).optional(),
-    completionKey: completionKeySchema.optional()
-  }).strict()
-]);
-var reviewModeSchema = z10.enum(["workers-ai"]);
-var storedReviewModeSchema = z10.enum([
-  "fixture-pass",
-  "fixture-fail",
-  "fixture-unclear",
-  "fixture-error",
-  "workers-ai"
-]);
-var rewardBundleSchema = z10.array(rewardSchema).max(10).refine(
-  (rewards) => new Set(rewards.map(rewardKey)).size === rewards.length,
-  "Use one entry per balance or shared reward"
-);
-var mediaUrlSchema = z10.string().max(2e3).refine((value) => {
-  if (/^\/(?!\/)[^\\\s]*$/.test(value)) {
-    return true;
-  }
-  try {
-    return new URL(value).protocol === "https:";
-  } catch {
-    return false;
-  }
-}, "Use an HTTPS URL or a same-site path beginning with /");
-var questPresentationSchema = z10.object({
-  quiz: quizQuestionsSchema.optional(),
-  instructions: z10.string().max(4e3).optional(),
-  video: z10.object({
-    url: mediaUrlSchema,
-    poster: mediaUrlSchema.optional(),
-    captions: z10.object({
-      url: mediaUrlSchema,
-      language: z10.string().min(2).max(20),
-      label: z10.string().min(1).max(80)
-    }).strict().optional()
-  }).strict().optional()
-}).strict();
-var questDescriptionSchema = z10.object({
-  quest: identifier,
-  runtimeVersion: z10.union([z10.literal(1), z10.literal(2)]).default(1),
-  title: z10.string().min(1).max(120),
-  presentation: questPresentationSchema.default({}),
-  integrations: z10.array(integrationProviderSchema).max(10).default([]),
-  fields: settingsFieldsSchema,
-  values: settingsValuesSchema,
-  rewards: rewardBundleSchema,
-  humanReview: z10.boolean(),
-  trigger: triggerSchema,
-  requires: z10.array(prerequisiteSchema).max(30).default([]),
-  completion: completionPolicySchema,
-  visibility: z10.enum(["visible", "hidden"]).default("visible"),
-  budgets: z10.array(budgetSchema).max(20).default([])
-}).strict();
-var artifactSchema = z10.object({ code: z10.string().min(1).max(1e6) }).strict();
-var releaseSchema = artifactSchema.extend({
-  settings: settingsValuesSchema,
-  provider: reviewModeSchema,
-  expectedRelease: identifier.nullable().optional(),
-  settingRenames: z10.record(z10.string(), z10.string()).optional()
-}).strict();
-var batchReleaseSchema = z10.object({ releases: z10.array(releaseSchema).min(1).max(50) }).strict();
-var questSettingsInputSchema = z10.object({
-  quest: identifier,
-  expectedRelease: identifier,
-  set: settingsValuesSchema,
-  reset: z10.array(z10.string())
-}).strict();
-var storedReleaseSchema = questDescriptionSchema.extend({
-  key: identifier.optional(),
-  code: z10.string(),
-  provider: storedReviewModeSchema,
-  id: identifier,
-  createdAt: z10.number(),
-  legacy: z10.boolean().default(false),
-  origin: z10.object({ typeVersion: identifier }).strict().optional(),
-  lifecycle: z10.enum(["active", "paused", "archived"]).default("active"),
-  configuration: z10.object({
-    defaults: settingsValuesSchema,
-    overrides: settingsValuesSchema,
-    preserved: z10.array(z10.string())
-  }).strict().optional()
-});
-var legacyReleaseSchema = z10.object({
-  quest: identifier,
-  title: z10.string(),
-  criteria: z10.string(),
-  humanReview: z10.boolean(),
-  rewards: rewardBundleSchema,
-  code: z10.string(),
-  provider: storedReviewModeSchema,
-  id: identifier,
-  createdAt: z10.number()
-}).transform((r) => {
-  const { criteria, ...stored } = r;
-  return storedReleaseSchema.parse({
-    ...stored,
-    fields: {},
-    values: { criteria, humanReview: r.humanReview },
-    trigger: { kind: "manual", input: "photo" },
-    completion: { kind: "once" },
-    legacy: true
-  });
-});
-var publishedReleaseSchema = z10.union([
-  storedReleaseSchema,
-  legacyReleaseSchema
-]);
-var templateSchema = z10.object({
-  code: z10.string(),
-  definition: questDescriptionSchema
-});
-var quizAnswersSchema = z10.record(identifier, identifier).refine(
-  (answers) => Object.keys(answers).length > 0 && Object.keys(answers).length <= 50,
-  "Provide between 1 and 50 answers"
-).transform(
-  (answers) => Object.fromEntries(
-    Object.entries(answers).sort(([a], [b]) => a.localeCompare(b))
-  )
-);
-var quizEvidenceSchema = z10.object({
-  kind: z10.literal("quiz"),
-  release: identifier.optional(),
-  answers: quizAnswersSchema
-}).strict();
-var submissionEvidenceSchema = z10.union([
-  quizEvidenceSchema,
-  textEvidenceSchema,
-  urlEvidenceSchema
-]);
-var submitSchema = z10.object({
-  actionId: identifier,
-  quest: identifier,
-  member: identifier,
-  evidence: identifier.optional(),
-  input: submissionEvidenceSchema.optional(),
-  release: identifier.optional(),
-  faultAfterReview: z10.boolean().optional()
-}).strict();
-var attemptSchema = z10.object({
-  id: identifier,
-  release: identifier,
-  quest: identifier,
-  member: identifier,
-  evidence: identifier.nullable(),
-  input: submissionEvidenceSchema.optional(),
-  status: z10.enum([
-    "queued",
-    "evaluating",
-    "accepted",
-    "progressed",
-    "rejected",
-    "needs-review",
-    "failed"
-  ]),
-  reason: z10.string().nullable(),
-  retries: z10.number(),
-  generation: z10.number(),
-  completion: z10.string().nullable(),
-  reviewRewards: rewardBundleSchema.nullable().default(null),
-  createdAt: z10.number()
-});
-var eventSchema = z10.object({
-  id: z10.number(),
-  attempt: z10.string().nullable(),
-  kind: z10.string(),
-  detail: z10.string(),
-  actor: z10.string().nullable().default(null),
-  at: z10.number()
-});
-var pickupSelectionSchema = z10.object({
-  item: identifier,
-  revision: z10.number().int().nonnegative()
-}).strict();
-var pickupAllocationSchema = z10.object({
-  item: identifier,
-  label: z10.string().min(1).max(80)
-}).strict();
-var pickupPolicySchema = z10.discriminatedUnion("kind", [
-  z10.object({ kind: z10.literal("untracked") }).strict(),
-  z10.object({
-    kind: z10.literal("at-pickup"),
-    tiers: z10.array(
-      z10.object({
-        tier: identifier,
-        variants: z10.array(pickupAllocationSchema).min(1).max(100)
-      }).strict()
-    ).min(1).max(100)
-  }).strict()
-]);
-var pickupCatalogSchema = z10.object({
-  reward: tieredRewardDefinitionSchema,
-  revision: z10.number().int().nonnegative(),
-  policy: pickupPolicySchema
-});
-var pickupAvailabilitySchema = z10.discriminatedUnion("kind", [
-  z10.object({ kind: z10.literal("untracked") }).strict(),
-  z10.object({
-    kind: z10.literal("at-pickup"),
-    revision: z10.number().int().nonnegative(),
-    variants: z10.array(
-      pickupAllocationSchema.extend({
-        available: z10.number().int().nonnegative()
-      })
-    )
-  }).strict()
-]);
-var configurePickupSchema = z10.object({
-  reward: identifier,
-  revision: z10.number().int().nonnegative(),
-  actionId: identifier,
-  policy: z10.discriminatedUnion("kind", [
-    z10.object({ kind: z10.literal("untracked") }).strict(),
-    z10.object({
-      kind: z10.literal("at-pickup"),
-      tiers: z10.array(
-        z10.object({
-          tier: identifier,
-          variants: z10.array(
-            pickupAllocationSchema.extend({
-              item: identifier.optional()
-            })
-          ).min(1).max(100)
-        }).strict()
-      ).min(1).max(100)
-    }).strict()
-  ])
-}).strict();
-var entitlementBase = {
-  id: identifier,
-  member: identifier,
-  reward: tieredRewardDefinitionSchema,
-  earnedTier: identifier,
-  tier: identifier,
-  revision: z10.number().int().positive()
-};
-var entitlementSchema = z10.discriminatedUnion("status", [
-  z10.object({ ...entitlementBase, status: z10.literal("available") }).strict(),
-  z10.object({
-    ...entitlementBase,
-    status: z10.literal("handing-over"),
-    handover: identifier,
-    startedAt: z10.number(),
-    allocation: pickupAllocationSchema.optional()
-  }).strict(),
-  z10.object({
-    ...entitlementBase,
-    status: z10.literal("collected"),
-    handover: identifier,
-    startedAt: z10.number(),
-    allocation: pickupAllocationSchema.optional(),
-    collectedAt: z10.number()
-  }).strict()
-]);
-var beginHandoverSchema = z10.object({
-  actionId: identifier,
-  revision: z10.number().int().positive(),
-  selection: pickupSelectionSchema.optional()
-}).strict();
-var confirmHandoverSchema = z10.object({ actionId: identifier, handover: identifier }).strict();
-var completionRecordSchema = z10.object({
-  key: z10.string().default("once"),
-  id: identifier,
-  quest: identifier,
-  member: identifier
-});
-var questAvailabilitySchema = z10.discriminatedUnion("kind", [
-  z10.object({
-    kind: z10.literal("available"),
-    input: z10.enum(["photo", "quiz", "none", "text", "url"])
-  }).strict(),
-  z10.object({ kind: z10.literal("completed") }).strict(),
-  z10.object({
-    kind: z10.literal("locked"),
-    missing: z10.array(z10.object({ quest: identifier, title: z10.string() })).min(1)
-  }).strict(),
-  z10.object({ kind: z10.literal("staff-required") }).strict(),
-  z10.object({
-    kind: z10.literal("automatic"),
-    observation: observationTriggerSchema.optional()
-  }).strict(),
-  z10.object({ kind: z10.literal("checking"), attempt: identifier }).strict(),
-  z10.object({ kind: z10.literal("needs-review"), attempt: identifier }).strict(),
-  z10.object({ kind: z10.literal("retryable"), attempt: identifier }).strict()
-]);
-var memberProgressSchema = z10.object({
-  member: identifier,
-  quests: z10.array(
-    z10.object({
-      quest: identifier,
-      key: identifier.optional(),
-      release: identifier.optional(),
-      title: z10.string(),
-      presentation: questPresentationSchema.default({}),
-      connections: z10.array(authProviderSchema).default([]),
-      trigger: triggerSchema,
-      availability: questAvailabilitySchema,
-      completed: z10.boolean(),
-      completion: completionPolicySchema.default({ kind: "once" }),
-      streak: streakProgressSchema.nullable().optional(),
-      completionCount: z10.number().int().nonnegative().default(0),
-      visibility: z10.enum(["visible", "hidden"]).default("visible"),
-      missing: z10.array(z10.object({ quest: identifier, title: z10.string() })),
-      attempt: attemptSchema.nullable()
-    })
-  ),
-  entitlements: z10.array(entitlementSchema)
-});
-var snapshotSchema = z10.object({
-  releases: z10.array(publishedReleaseSchema),
-  completions: z10.array(completionRecordSchema),
-  entitlements: z10.array(entitlementSchema),
-  attempts: z10.array(attemptSchema),
-  balances: z10.array(
-    z10.object({
-      member: z10.string(),
-      balance: z10.string(),
-      earned: z10.number(),
-      held: z10.number(),
-      available: z10.number()
-    })
-  ),
-  events: z10.array(eventSchema)
-});
-var evidenceSchema = z10.object({
-  id: identifier,
-  member: identifier,
-  type: z10.enum(["image/jpeg", "image/png"]),
-  size: z10.number()
-});
-var errorSchema = z10.object({
-  error: z10.string(),
-  code: z10.enum(["stale-quiz", "quest-updated", "invalid-submission"]).optional(),
-  missing: z10.array(z10.object({ quest: identifier, title: z10.string() })).optional()
-});
-var staffDecisionSchema = z10.object({
-  actionId: identifier,
-  generation: z10.number().int().nonnegative(),
-  decision: z10.enum(["accept", "reject"]),
-  reason: z10.string().trim().min(1).max(2e3)
-}).strict();
-var stockSchema = z10.object({ item: identifier, quantity: z10.number().int().min(0).max(1e4) }).strict();
-var reservationSchema = z10.object({
-  actionId: identifier,
-  member: identifier,
-  item: identifier,
-  balance: identifier,
-  price: z10.number().int().positive().max(1e4)
-}).strict();
-var pageOptions = {
-  limit: z10.number().int().min(1).max(100).default(25),
-  cursor: z10.string().min(1).max(4096).optional()
-};
-var reviewListSchema = z10.object({
-  ...pageOptions,
-  member: identifier.optional(),
-  quest: identifier.optional()
-}).strict();
-var memberListSchema = z10.object({
-  ...pageOptions,
-  prefix: identifier.optional()
-}).strict();
-var reviewItemSchema = z10.object({
-  attempt: attemptSchema,
-  title: z10.string(),
-  checks: z10.array(
-    z10.object({ criteria: z10.string(), result: photoResultSchema })
-  )
-});
-var reviewPageSchema = z10.object({
-  items: z10.array(reviewItemSchema).max(100),
-  nextCursor: z10.string().nullable()
-});
-var memberPageSchema = z10.object({
-  items: z10.array(z10.object({ member: identifier })).max(100),
-  nextCursor: z10.string().nullable()
-});
-var createStockItemSchema = z10.object({ actionId: identifier, name: z10.string().trim().min(1).max(80) }).strict();
-var stockItemSchema = z10.object({ id: identifier, name: z10.string() });
-
-export {
-  communityTimeZoneSchema,
-  streakPolicySchema,
-  streak,
-  streakProgressSchema,
-  identifier,
-  observationInputSchema,
-  observationSchema,
-  observationTriggerSchema,
-  completionPolicySchema,
-  completionKeySchema,
-  budgetSchema,
-  observationReceiptSchema,
-  discordReactionSchema,
-  discordMessageSchema,
-  integrationProviderSchema,
-  discordServerSchema,
-  projectIntegrationSchema,
-  authProviderSchema,
-  accountConnectionSchema,
-  discordMemberInputSchema,
-  discordMessageInputSchema,
-  discordMemberSchema,
-  textOptionsSchema,
-  urlOptionsSchema,
-  textEvidenceSchema,
-  urlEvidenceSchema,
-  valueEvidenceSchema,
-  validateSubmissionValue,
-  xPostId,
-  quizChoiceSchema,
-  quizQuestionSchema,
-  quizQuestionsSchema,
-  quizContentSchema,
-  resourceSourceSchema,
-  resourceRequestSchema,
-  resourceOptionsSchema,
-  discord,
-  pointLedgers,
-  settingFieldSchema,
-  settingsFieldsSchema,
-  settingsValuesSchema,
-  settings,
-  parseSettings,
-  missingResourceSettings,
-  compatibleSettingKinds,
-  pointsRewardSchema,
-  tieredRewardDefinitionSchema,
-  tierRewardSchema,
-  integrationRewardSchema,
-  rewardSchema,
-  rewardKey,
-  triggerSchema,
-  prerequisiteSchema,
-  photoResultSchema,
-  textReviewInputSchema,
-  textResultSchema,
-  decisionSchema,
-  reviewModeSchema,
-  storedReviewModeSchema,
-  rewardBundleSchema,
-  mediaUrlSchema,
-  questPresentationSchema,
-  questDescriptionSchema,
-  artifactSchema,
-  releaseSchema,
-  batchReleaseSchema,
-  questSettingsInputSchema,
-  publishedReleaseSchema,
-  templateSchema,
-  quizAnswersSchema,
-  quizEvidenceSchema,
-  submissionEvidenceSchema,
-  submitSchema,
-  attemptSchema,
-  eventSchema,
-  pickupSelectionSchema,
-  pickupAllocationSchema,
-  pickupPolicySchema,
-  pickupCatalogSchema,
-  pickupAvailabilitySchema,
-  configurePickupSchema,
-  entitlementSchema,
-  beginHandoverSchema,
-  confirmHandoverSchema,
-  completionRecordSchema,
-  questAvailabilitySchema,
-  memberProgressSchema,
-  snapshotSchema,
-  evidenceSchema,
-  errorSchema,
-  staffDecisionSchema,
-  stockSchema,
-  reservationSchema,
-  reviewListSchema,
-  memberListSchema,
-  reviewItemSchema,
-  reviewPageSchema,
-  memberPageSchema,
-  createStockItemSchema,
-  stockItemSchema
-};