@domino-sdk/relay 0.17.2 → 0.18.1

package/dist/chunk-23ZZTCDK.js

@@ -0,0 +1,1511 @@
+// src/content.ts
+import { z as z3 } from "zod";
+
+// src/identifier.ts
+import { z } from "zod";
+var identifier = z.string().min(1).max(100).regex(/^[a-zA-Z0-9_-]+$/);
+
+// src/trackers.ts
+import { z as z2 } from "zod";
+var timestamp = z2.number().int().safe().nonnegative().max(864e13);
+var count = z2.number().int().safe().nonnegative();
+var externalId = z2.string().min(1).max(256);
+var metric = count.nullable().default(null);
+var xTweetSchema = z2.looseObject({
+  id: externalId,
+  userId: externalId,
+  content: z2.string(),
+  createdAt: z2.iso.datetime({ offset: true }),
+  author: z2.looseObject({
+    id: externalId,
+    username: z2.string(),
+    name: z2.string(),
+    verified: z2.boolean().nullable().default(null)
+  }),
+  likeCount: metric,
+  replyCount: metric,
+  retweetCount: metric,
+  quoteCount: metric,
+  viewCount: metric,
+  bookmarkCount: metric,
+  isReply: z2.boolean(),
+  isRetweet: z2.boolean(),
+  isQuoteTweet: z2.boolean()
+});
+var xContentBodySchema = z2.strictObject({
+  version: z2.literal(1),
+  id: z2.string().min(1),
+  authorId: z2.string().min(1),
+  publishedAt: timestamp,
+  text: z2.string(),
+  isReply: z2.boolean(),
+  isRetweet: z2.boolean(),
+  isQuoteTweet: z2.boolean(),
+  media: z2.array(z2.strictObject({ type: z2.string(), url: z2.string() })).nullable(),
+  mentionedAuthorIds: z2.array(z2.string().min(1)).nullable(),
+  videoLengthSeconds: z2.number().nonnegative().nullable(),
+  references: z2.strictObject({
+    replyId: z2.string().nullable(),
+    replyAuthorId: z2.string().nullable(),
+    quoteId: z2.string().nullable(),
+    quoteAuthorId: z2.string().nullable(),
+    repostId: z2.string().nullable(),
+    repostAuthorId: z2.string().nullable()
+  })
+});
+var trackerContentQuerySchema = z2.strictObject({
+  id: externalId,
+  observation: z2.string().regex(/^observation_[a-f0-9]{64}$/)
+});
+var trackerContentReadSchema = trackerContentQuerySchema.extend({
+  member: identifier
+});
+var attributionContext = { member: identifier, capturedAt: timestamp };
+var trackerEvidenceSchema = z2.strictObject({
+  contentRevision: identifier,
+  observation: identifier
+});
+var trackerContentSchema = z2.strictObject({
+  tracker: identifier,
+  source: z2.literal("x"),
+  evidence: trackerEvidenceSchema,
+  content: xContentBodySchema,
+  observedAt: timestamp,
+  removed: z2.boolean(),
+  attribution: z2.discriminatedUnion("kind", [
+    z2.strictObject({
+      ...attributionContext,
+      kind: z2.literal("linked"),
+      account: z2.strictObject({
+        provider: z2.literal("x"),
+        issuer: z2.string().min(1),
+        subject: externalId,
+        revision: count,
+        linkedAt: timestamp.nullable()
+      })
+    }),
+    z2.strictObject({ ...attributionContext, kind: z2.literal("unlinked") }),
+    z2.strictObject({
+      ...attributionContext,
+      kind: z2.literal("different-author")
+    })
+  ])
+});
+var trackerSourceSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("x-search"),
+    query: z2.string().trim().min(1).max(2e3)
+  }).strict(),
+  z2.object({ kind: z2.literal("custom"), namespace: identifier }).strict()
+]);
+var x = {
+  search: (input) => trackerSourceSchema.options[0].parse({ kind: "x-search", ...input })
+};
+var customSource = (namespace) => trackerSourceSchema.options[1].parse({ kind: "custom", namespace });
+var windowSchema = z2.object({ start: timestamp, end: timestamp.optional() }).strict().refine(
+  (w) => w.end === void 0 || w.end > w.start,
+  "End must follow start"
+);
+var trackerDefinitionSchema = z2.object({
+  key: identifier,
+  title: z2.string().trim().min(1).max(120),
+  source: trackerSourceSchema,
+  window: windowSchema,
+  refreshSeconds: z2.number().int().min(300).max(86400).default(21600),
+  maxPages: z2.number().int().min(1).max(1e3).default(60)
+}).strict();
+var trackerArtifactSchema = z2.union([
+  trackerDefinitionSchema,
+  z2.object({ code: z2.string().min(1).max(2e6) }).strict()
+]);
+function defineTracker(input) {
+  return trackerDefinitionSchema.parse(input);
+}
+var publishedTrackerSchema = z2.object({
+  id: identifier,
+  version: identifier,
+  definition: trackerDefinitionSchema,
+  publishedAt: timestamp,
+  actor: z2.string().nullable()
+});
+var trackerStatusSchema = z2.object({
+  published: publishedTrackerSchema,
+  paused: z2.boolean(),
+  state: z2.enum(["idle", "syncing", "error", "complete"]),
+  lastStartedAt: timestamp.nullable(),
+  lastCompletedAt: timestamp.nullable(),
+  nextSyncAt: timestamp.nullable(),
+  coverage: z2.enum(["unknown", "partial", "complete"]),
+  error: z2.string().nullable(),
+  records: count
+});
+var trackerControlSchema = z2.object({
+  actionId: identifier,
+  action: z2.enum(["pause", "resume", "refresh"])
+}).strict();
+var trackerRecordInputSchema = z2.object({
+  id: externalId,
+  occurredAt: timestamp,
+  observedAt: timestamp,
+  author: z2.object({
+    id: externalId,
+    verified: z2.boolean().nullable().default(null)
+  }).strict().nullable().default(null),
+  data: z2.record(z2.string(), z2.json()),
+  removed: z2.boolean().default(false)
+}).strict().refine(
+  (v) => new TextEncoder().encode(JSON.stringify(v.data)).byteLength <= 131072,
+  "Record exceeds 128 KB"
+);
+var trackerRecordSchema = trackerRecordInputSchema.safeExtend({
+  source: z2.string(),
+  firstSeenAt: timestamp,
+  /** Present only when includeEvidence is true; custom sources have no X evidence. */
+  evidence: trackerEvidenceSchema.nullable().optional()
+});
+var trackerIngestSchema = z2.object({
+  actionId: identifier,
+  records: z2.array(trackerRecordInputSchema).min(1).max(100)
+}).strict();
+var trackerIngestResultSchema = z2.object({ stored: count });
+var booleanQuery = z2.union([
+  z2.boolean(),
+  z2.enum(["true", "false"]).transform((v) => v === "true")
+]);
+var trackerQuerySchema = z2.object({
+  author: externalId.optional(),
+  member: identifier.optional(),
+  verified: booleanQuery.optional(),
+  since: z2.coerce.number().int().safe().nonnegative().optional(),
+  until: z2.coerce.number().int().safe().nonnegative().optional(),
+  removed: booleanQuery.default(false),
+  minLikes: z2.coerce.number().int().safe().nonnegative().optional(),
+  minViews: z2.coerce.number().int().safe().nonnegative().optional(),
+  limit: z2.coerce.number().int().min(1).max(100).default(25),
+  cursor: z2.string().max(2048).optional(),
+  includeEvidence: booleanQuery.optional()
+}).strict().refine(
+  (q) => q.since === void 0 || q.until === void 0 || q.until > q.since,
+  "Until must follow since"
+);
+var trackerPageSchema = z2.object({
+  tracker: identifier,
+  items: z2.array(trackerRecordSchema),
+  nextCursor: z2.string().nullable(),
+  total: count,
+  status: trackerStatusSchema
+});
+var trackerSummarySchema = z2.object({
+  records: count,
+  authors: count,
+  metrics: z2.object({
+    likes: count,
+    replies: count,
+    reposts: count,
+    quotes: count,
+    views: count,
+    bookmarks: count
+  }),
+  missingMetrics: count,
+  status: trackerStatusSchema
+});
+var trackerPreviewLimits = {
+  pages: 3,
+  posts: 100,
+  days: 30
+};
+var trackerPreviewInputSchema = z2.object({
+  query: trackerSourceSchema.options[0].shape.query,
+  /** Start of the searched window. The window ends when the sample is fetched. */
+  since: timestamp
+}).strict();
+var trackerPreviewSchema = z2.object({
+  query: z2.string(),
+  since: timestamp,
+  fetchedAt: timestamp,
+  pages: count,
+  /** Every match in the sample, newest first, verified or not. */
+  posts: z2.array(xTweetSchema).max(trackerPreviewLimits.posts),
+  /** X had more matches than the sample holds. */
+  more: z2.boolean()
+});
+
+// src/content.ts
+var timestamp2 = z3.number().int().safe().nonnegative().max(864e13);
+var contentPolicySchema = z3.strictObject({
+  tracker: identifier,
+  window: trackerDefinitionSchema.shape.window,
+  enrollment: z3.enum(["none", "required"]).default("none"),
+  posts: z3.enum(["after-enrollment", "since-start"]).default("after-enrollment"),
+  historical: z3.enum(["automatic", "claim", "staff"]).default("claim")
+});
+function content(tracker, policy = {}) {
+  if (tracker.source.kind !== "x-search") {
+    throw new Error("Content quests require an X tracker");
+  }
+  return {
+    kind: "automatic",
+    content: contentPolicySchema.parse({
+      tracker: tracker.key,
+      window: tracker.window,
+      ...policy
+    })
+  };
+}
+var admittedContentSchema = xContentBodySchema.extend({
+  tracker: identifier,
+  revision: identifier,
+  observation: identifier,
+  attribution: trackerContentSchema.shape.attribution.options[0],
+  enrolledAt: timestamp2.nullable(),
+  completionKey: z3.string().min(1).max(200)
+});
+function perContent() {
+  return {
+    kind: "keyed",
+    perContent: true,
+    key: (ctx) => {
+      if (!ctx.content) {
+        throw new Error("perContent requires an admitted content item");
+      }
+      return ctx.content.completionKey;
+    }
+  };
+}
+var contentEnrollmentInputSchema = z3.strictObject({
+  actionId: identifier,
+  quest: identifier,
+  member: identifier
+});
+var contentEnrollmentSchema = z3.strictObject({
+  quest: identifier,
+  member: identifier,
+  enrolledAt: timestamp2
+});
+var contentReleaseInputSchema = contentEnrollmentInputSchema.extend({
+  content: z3.string().min(1).max(256)
+});
+var contentAdmissionSchema = z3.strictObject({
+  quest: identifier,
+  content: z3.string().min(1).max(256),
+  release: identifier,
+  state: z3.enum(["pending", "admitted", "excluded"]),
+  reason: z3.string().nullable(),
+  attempt: identifier.nullable()
+});
+var contentAdmissionQuerySchema = z3.strictObject({
+  quest: identifier,
+  member: identifier.optional(),
+  content: z3.string().min(1).max(256).optional(),
+  after: z3.string().min(1).max(256).optional()
+});
+var contentAdmissionPageSchema = z3.strictObject({
+  items: z3.array(contentAdmissionSchema),
+  next: z3.string().nullable()
+});
+function isContentParticipantRoute(path, method) {
+  return method === "GET" && (path === "/v1/content/admissions" || path === "/v1/content/qualifications" || path === "/v1/content/performance" || path === "/v1/engagement/history" || path === "/v1/engagement/boundaries") || method === "POST" && (path === "/v1/content/enrollments" || path === "/v1/content/claims");
+}
+var contentQualificationDecisionSchema = z3.strictObject({
+  kind: z3.enum(["accept", "reject", "review", "superseded"]),
+  reason: z3.string().nullable()
+});
+var contentQualificationQuerySchema = z3.strictObject({
+  quest: identifier,
+  member: identifier.optional(),
+  content: z3.string().min(1).max(256).optional(),
+  before: z3.coerce.number().int().positive().safe().optional()
+});
+var contentQualificationSchema = z3.strictObject({
+  quest: identifier,
+  content: z3.string(),
+  member: identifier,
+  release: identifier,
+  attempt: identifier,
+  revision: identifier,
+  observation: identifier,
+  current: z3.boolean(),
+  state: z3.enum([
+    "pending",
+    "qualified",
+    "unqualified",
+    "needs-review",
+    "failed",
+    "superseded",
+    "stale",
+    "blocked",
+    "unavailable"
+  ]),
+  reason: z3.string().nullable(),
+  reward: z3.strictObject({
+    attempt: identifier.nullable(),
+    completion: identifier.nullable(),
+    state: z3.enum(["unresolved", "awarded", "excluded"])
+  })
+});
+var contentQualificationPageSchema = z3.strictObject({
+  items: z3.array(contentQualificationSchema),
+  next: z3.number().int().positive().safe().nullable()
+});
+var contentMetricSchema = z3.enum([
+  "likes",
+  "replies",
+  "reposts",
+  "quotes",
+  "views",
+  "bookmarks"
+]);
+var contentMetricsSchema = z3.partialRecord(
+  contentMetricSchema,
+  z3.number().int().safe().nonnegative()
+);
+var contentPerformancePolicySchema = z3.strictObject({
+  metrics: z3.array(contentMetricSchema).min(1).max(6).refine(
+    (values) => new Set(values).size === values.length,
+    "Metrics must be unique"
+  ),
+  maxAgeMs: z3.number().int().positive().max(864e5).default(36e5)
+});
+
+// src/streaks.ts
+import { z as z4 } from "zod";
+var communityTimeZoneSchema = z4.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 = z4.object({
+  kind: z4.literal("streak"),
+  days: z4.number().int().min(1).max(3650),
+  timeZone: communityTimeZoneSchema
+}).strict();
+var streak = (options) => streakPolicySchema.parse({ kind: "streak", ...options });
+var streakProgressSchema = z4.object({
+  goal: z4.number().int().positive(),
+  current: z4.number().int().nonnegative(),
+  best: z4.number().int().nonnegative(),
+  today: z4.string(),
+  todayQualified: z4.boolean(),
+  timeZone: communityTimeZoneSchema,
+  nextBoundary: z4.number().int(),
+  pendingTimeZone: z4.object({
+    timeZone: communityTimeZoneSchema,
+    effectiveAt: z4.number().int()
+  }).nullable(),
+  days: z4.array(
+    z4.object({
+      day: z4.number().int(),
+      date: z4.string(),
+      timeZone: communityTimeZoneSchema,
+      occurredAt: z4.number().int()
+    })
+  ),
+  milestone: z4.discriminatedUnion("status", [
+    z4.object({ status: z4.literal("pending") }),
+    z4.object({
+      status: z4.literal("awarded"),
+      completion: z4.string(),
+      achievedAt: z4.number().int()
+    }),
+    z4.object({
+      status: z4.literal("budget-exhausted"),
+      budget: z4.string(),
+      achievedAt: z4.number().int()
+    })
+  ])
+});
+
+// src/observations.ts
+import { z as z5 } from "zod";
+var name = z5.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
+var observationInputSchema = z5.object({
+  id: name,
+  source: name,
+  type: name,
+  member: identifier,
+  actor: z5.object({ provider: identifier, subject: z5.string().min(1).max(200) }).strict().optional(),
+  occurredAt: z5.number().int().nonnegative().max(864e13),
+  data: z5.record(z5.string(), z5.json())
+}).strict().refine(
+  (value) => JSON.stringify(value.data).length <= 32768,
+  "Observation data exceeds 32 KB"
+);
+var observationSchema = observationInputSchema.safeExtend({
+  receivedAt: z5.number().int().nonnegative()
+});
+var observationTriggerSchema = z5.object({ source: name, type: name }).strict();
+var completionPolicySchema = z5.discriminatedUnion("kind", [
+  streakPolicySchema,
+  z5.object({ kind: z5.literal("once") }).strict(),
+  z5.object({ kind: z5.literal("keyed") }).strict()
+]);
+var completionKeySchema = z5.string().min(1).max(500);
+var budgetSchema = z5.object({
+  id: name,
+  scope: z5.enum(["member", "project"]),
+  period: z5.enum(["lifetime", "day"]),
+  limit: z5.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  cost: z5.union([
+    z5.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    z5.object({ balance: name }).strict()
+  ])
+}).strict();
+var observationReceiptSchema = z5.object({
+  id: name,
+  source: name,
+  attempts: z5.array(z5.string()),
+  receivedAt: z5.number()
+});
+var discordReactionSchema = z5.object({
+  guildId: z5.string(),
+  channelId: z5.string(),
+  messageId: z5.string(),
+  userId: z5.string(),
+  messageAuthorId: z5.string().nullable().default(null),
+  actorRoles: z5.array(z5.string()).default([]),
+  emoji: z5.object({ id: z5.string().nullable(), name: z5.string() }),
+  messagePublishedAt: z5.number()
+}).strict();
+var discordMessageSchema = z5.object({
+  guildId: z5.string(),
+  channelId: z5.string(),
+  messageId: z5.string(),
+  userId: z5.string(),
+  content: z5.string().nullable(),
+  replyTo: z5.string().nullable(),
+  publishedAt: z5.number()
+}).strict();
+
+// src/integrations.ts
+import { z as z6 } from "zod";
+var integrationProviderSchema = z6.enum(["discord"]);
+var discordServerSchema = z6.object({
+  id: z6.string().regex(/^[0-9]{1,20}$/),
+  name: z6.string().min(1),
+  icon: z6.string().nullable()
+});
+var projectIntegrationSchema = z6.object({
+  provider: integrationProviderSchema,
+  configured: z6.boolean(),
+  status: z6.enum(["disconnected", "ready", "attention"]),
+  revision: z6.number().int().nonnegative(),
+  server: discordServerSchema.nullable(),
+  issue: z6.string().nullable(),
+  connectedAt: z6.number().default(0)
+});
+
+// src/accounts.ts
+import { z as z7 } from "zod";
+var authProviderSchema = z7.enum(["google", "apple", "x", "discord"]);
+var accountConnectionSchema = z7.object({
+  provider: authProviderSchema,
+  configured: z7.boolean(),
+  status: z7.enum(["disconnected", "connected", "reconnect"]),
+  subject: z7.string().nullable(),
+  revision: z7.number().int().nonnegative()
+});
+var discordMemberInputSchema = z7.object({}).strict();
+var discordMessageInputSchema = z7.object({
+  channelId: z7.string().regex(/^[0-9]{1,20}$/),
+  messageId: z7.string().regex(/^[0-9]{1,20}$/)
+}).strict();
+var discordMemberSchema = z7.object({
+  userId: z7.string().regex(/^[0-9]{1,20}$/).nullable().default(null),
+  nickname: z7.string().nullable().default(null),
+  displayName: z7.string().nullable().default(null),
+  boostingSince: z7.string().datetime({ offset: true }).nullable().default(null),
+  roles: z7.array(z7.string().regex(/^[0-9]{1,20}$/)),
+  joinedAt: z7.string().datetime({ offset: true }).nullable(),
+  pending: z7.boolean()
+});
+
+// src/submission-input.ts
+import { z as z8 } from "zod";
+var textOptionsSchema = z8.object({
+  required: z8.boolean().default(true),
+  minLength: z8.number().int().min(0).max(1e4).default(1),
+  maxLength: z8.number().int().min(1).max(1e4).default(1e4)
+}).strict().refine(
+  (v) => v.minLength <= v.maxLength,
+  "minLength must not exceed maxLength"
+);
+var hostSchema = z8.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 = z8.object({
+  required: z8.boolean().default(true),
+  allowedHosts: z8.array(hostSchema).min(1).max(100).optional()
+}).strict();
+var textEvidenceSchema = z8.object({ kind: z8.literal("text"), value: z8.string().max(1e4) }).strict();
+var urlEvidenceSchema = z8.object({ kind: z8.literal("url"), value: z8.string().max(2048) }).strict();
+var valueEvidenceSchema = z8.discriminatedUnion("kind", [
+  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 z9 } from "zod";
+var quizId = z9.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
+var quizChoiceSchema = z9.object({ id: quizId, label: z9.string().trim().min(1).max(500) }).strict();
+var quizQuestionSchema = z9.object({
+  id: quizId,
+  prompt: z9.string().trim().min(1).max(1e3),
+  choices: z9.array(quizChoiceSchema).min(2).max(8).refine(
+    (choices) => new Set(choices.map((choice) => choice.id)).size === choices.length,
+    "Choice IDs must be unique"
+  )
+}).strict();
+var quizQuestionsSchema = z9.array(quizQuestionSchema).min(1).max(20).refine(
+  (questions) => new Set(questions.map((question) => question.id)).size === questions.length,
+  "Question IDs must be unique"
+);
+var quizContentSchema = z9.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 z12 } from "zod";
+
+// src/settings.ts
+import { z as z11 } from "zod";
+
+// src/resources.ts
+import { z as z10 } from "zod";
+var channelSourceSchema = z10.object({
+  provider: z10.literal("discord"),
+  resource: z10.literal("channel"),
+  types: z10.array(z10.enum(["text", "announcement"])).min(1)
+}).strict();
+var resourceSourceSchema = z10.union([
+  z10.object({
+    provider: z10.literal("domino"),
+    resource: z10.literal("point-ledger")
+  }).strict(),
+  channelSourceSchema,
+  z10.object({
+    provider: z10.literal("discord"),
+    resource: z10.literal("role"),
+    assignable: z10.boolean().default(false)
+  }).strict()
+]);
+var resourceRequestSchema = z10.object({
+  source: resourceSourceSchema,
+  query: z10.string().max(100).optional(),
+  cursor: z10.string().regex(/^\d{1,6}$/).optional(),
+  ids: z10.array(z10.string().min(1).max(100)).max(50).optional()
+}).strict();
+var resourceOptionsSchema = z10.object({
+  revision: z10.number().int(),
+  options: z10.array(
+    z10.object({
+      id: z10.string(),
+      label: z10.string(),
+      description: z10.string().optional(),
+      group: z10.string().optional(),
+      disabledReason: z10.string().optional()
+    })
+  ),
+  cursor: z10.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 = z11.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
+var resourceId = z11.union([z11.literal(""), z11.string().regex(/^\S{1,200}$/)]);
+var base = { label: z11.string().min(1), description: z11.string().optional() };
+var settingFieldSchema = z11.discriminatedUnion("kind", [
+  z11.object({ ...base, kind: z11.literal("point-ledger"), default: identifier }).strict(),
+  z11.object({ ...base, kind: z11.literal("datetime"), default: instant }).strict(),
+  z11.object({
+    ...base,
+    kind: z11.literal("resource"),
+    default: resourceId,
+    source: resourceSourceSchema
+  }).strict(),
+  z11.object({ ...base, kind: z11.literal("quiz"), default: quizContentSchema }).strict(),
+  z11.object({
+    ...base,
+    kind: z11.literal("text"),
+    default: z11.string(),
+    minLength: z11.number().int().nonnegative(),
+    maxLength: z11.number().int().positive(),
+    multiline: z11.boolean()
+  }).strict(),
+  z11.object({
+    ...base,
+    kind: z11.literal("integer"),
+    default: z11.number().int(),
+    min: z11.number().int(),
+    max: z11.number().int()
+  }).strict(),
+  z11.object({ ...base, kind: z11.literal("boolean"), default: z11.boolean() }).strict(),
+  z11.object({
+    ...base,
+    kind: z11.literal("choice"),
+    default: z11.string(),
+    options: z11.array(z11.string().min(1)).min(1)
+  }).strict()
+]);
+var settingsFieldsSchema = z11.record(
+  z11.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
+  settingFieldSchema
+);
+var settingsValuesSchema = z11.record(
+  z11.string(),
+  z11.union([z11.string(), z11.number().finite(), z11.boolean(), quizContentSchema])
+);
+var 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 z11.string().min(field.minLength).max(field.maxLength).default(field.default).meta(field);
+  },
+  integer(options) {
+    return z11.number().int().min(options.min).max(options.max).default(options.default).meta({ ...options, kind: "integer" });
+  },
+  boolean(options) {
+    return z11.boolean().default(options.default).meta({ ...options, kind: "boolean" });
+  },
+  choice(options) {
+    return z11.enum(options.options).default(options.default).meta({ ...options, kind: "choice" });
+  },
+  object(shape) {
+    return z11.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] = z11.string().min(field.minLength).max(field.maxLength).default(field.default);
+        break;
+      case "integer":
+        shape[key] = z11.number().int().min(field.min).max(field.max).default(field.default);
+        break;
+      case "boolean":
+        shape[key] = z11.boolean().default(field.default);
+        break;
+      case "choice":
+        shape[key] = z11.enum(field.options).default(field.default);
+        break;
+    }
+  }
+  return settingsValuesSchema.parse(z11.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 = z12.object({
+  kind: z12.literal("points").default("points"),
+  balance: identifier,
+  amount: z12.number().int().min(0).max(1e4)
+}).strict();
+var tieredRewardDefinitionSchema = z12.object({
+  id: identifier,
+  title: z12.string().min(1).max(120),
+  tiers: z12.array(
+    z12.object({ id: identifier, title: z12.string().min(1).max(120) }).strict()
+  ).min(1).max(20).refine(
+    (tiers) => new Set(tiers.map((t) => t.id)).size === tiers.length,
+    "Tier IDs must be unique"
+  ),
+  inventory: z12.object({ kind: z12.literal("untracked") }).strict(),
+  fulfillment: z12.object({ kind: z12.literal("staff-handover") }).strict()
+}).strict();
+var tierRewardSchema = z12.object({
+  kind: z12.literal("tier"),
+  reward: tieredRewardDefinitionSchema,
+  tier: identifier
+}).strict().refine(
+  (value) => value.reward.tiers.some((t) => t.id === value.tier),
+  "Unknown reward tier"
+);
+var integrationRewardSchema = z12.object({
+  kind: z12.literal("integration"),
+  provider: z12.literal("discord"),
+  action: z12.literal("grant-role"),
+  roleId: z12.string().regex(/^[0-9]{1,20}$/)
+}).strict();
+var rewardSchema = z12.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 = z12.union([
+  z12.object({
+    kind: z12.literal("manual"),
+    input: z12.literal("text"),
+    constraints: textOptionsSchema,
+    actor: z12.enum(["member", "staff"]).optional()
+  }).strict(),
+  z12.object({
+    kind: z12.literal("manual"),
+    input: z12.literal("url"),
+    constraints: urlOptionsSchema,
+    actor: z12.enum(["member", "staff"]).optional()
+  }).strict(),
+  z12.object({
+    kind: z12.literal("manual"),
+    input: z12.enum(["photo", "quiz", "none"]),
+    actor: z12.enum(["member", "staff"]).optional()
+  }).strict(),
+  z12.object({
+    kind: z12.literal("automatic"),
+    observation: observationTriggerSchema.optional(),
+    content: contentPolicySchema.optional()
+  }).strict().refine(
+    (value) => !(value.observation && value.content),
+    "Choose one automatic trigger source"
+  )
+]);
+var prerequisiteSchema = z12.object({ quest: identifier, scope: z12.literal("ever") }).strict();
+var photoResultSchema = z12.object({
+  kind: z12.enum(["pass", "fail", "unclear"]),
+  reason: z12.string().min(1).max(2e3)
+}).strict();
+var textReviewInputSchema = z12.object({
+  text: z12.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
+  criteria: z12.string().trim().min(1).max(2e3)
+}).strict();
+var textResultSchema = photoResultSchema;
+var decisionSchema = z12.discriminatedUnion("kind", [
+  z12.object({
+    kind: z12.literal("accept"),
+    rewards: z12.array(rewardSchema).max(10),
+    completionKey: completionKeySchema.optional()
+  }).strict(),
+  z12.object({ kind: z12.literal("reject"), reason: z12.string().min(1).max(2e3) }).strict(),
+  z12.object({
+    kind: z12.literal("review"),
+    reason: z12.string().min(1).max(2e3),
+    rewards: z12.array(rewardSchema).max(10).optional(),
+    completionKey: completionKeySchema.optional()
+  }).strict()
+]);
+var reviewModeSchema = z12.enum(["workers-ai"]);
+var storedReviewModeSchema = z12.enum([
+  "fixture-pass",
+  "fixture-fail",
+  "fixture-unclear",
+  "fixture-error",
+  "workers-ai"
+]);
+var rewardBundleSchema = z12.array(rewardSchema).max(10).refine(
+  (rewards) => new Set(rewards.map(rewardKey)).size === rewards.length,
+  "Use one entry per balance or shared reward"
+);
+var mediaUrlSchema = z12.string().max(2e3).refine((value) => {
+  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 = z12.object({
+  quiz: quizQuestionsSchema.optional(),
+  instructions: z12.string().max(4e3).optional(),
+  video: z12.object({
+    url: mediaUrlSchema,
+    poster: mediaUrlSchema.optional(),
+    captions: z12.object({
+      url: mediaUrlSchema,
+      language: z12.string().min(2).max(20),
+      label: z12.string().min(1).max(80)
+    }).strict().optional()
+  }).strict().optional()
+}).strict();
+var questDescriptionSchema = z12.object({
+  quest: identifier,
+  runtimeVersion: z12.union([z12.literal(1), z12.literal(2)]).default(1),
+  title: z12.string().min(1).max(120),
+  presentation: questPresentationSchema.default({}),
+  integrations: z12.array(integrationProviderSchema).max(10).default([]),
+  fields: settingsFieldsSchema,
+  values: settingsValuesSchema,
+  rewards: rewardBundleSchema,
+  humanReview: z12.boolean(),
+  trigger: triggerSchema,
+  performance: contentPerformancePolicySchema.optional(),
+  requires: z12.array(prerequisiteSchema).max(30).default([]),
+  completion: completionPolicySchema,
+  visibility: z12.enum(["visible", "hidden"]).default("visible"),
+  budgets: z12.array(budgetSchema).max(20).default([])
+}).strict();
+var artifactSchema = z12.object({ code: z12.string().min(1).max(1e6) }).strict();
+var releaseSchema = artifactSchema.extend({
+  settings: settingsValuesSchema,
+  provider: reviewModeSchema,
+  expectedRelease: identifier.nullable().optional(),
+  settingRenames: z12.record(z12.string(), z12.string()).optional()
+}).strict();
+var batchReleaseSchema = z12.object({ releases: z12.array(releaseSchema).min(1).max(50) }).strict();
+var questSettingsInputSchema = z12.object({
+  quest: identifier,
+  expectedRelease: identifier,
+  set: settingsValuesSchema,
+  reset: z12.array(z12.string())
+}).strict();
+var storedReleaseSchema = questDescriptionSchema.extend({
+  key: identifier.optional(),
+  code: z12.string(),
+  provider: storedReviewModeSchema,
+  id: identifier,
+  createdAt: z12.number(),
+  legacy: z12.boolean().default(false),
+  origin: z12.object({ typeVersion: identifier }).strict().optional(),
+  lifecycle: z12.enum(["active", "paused", "archived"]).default("active"),
+  configuration: z12.object({
+    defaults: settingsValuesSchema,
+    overrides: settingsValuesSchema,
+    preserved: z12.array(z12.string())
+  }).strict().optional()
+});
+var legacyReleaseSchema = z12.object({
+  quest: identifier,
+  title: z12.string(),
+  criteria: z12.string(),
+  humanReview: z12.boolean(),
+  rewards: rewardBundleSchema,
+  code: z12.string(),
+  provider: storedReviewModeSchema,
+  id: identifier,
+  createdAt: z12.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 = z12.union([
+  storedReleaseSchema,
+  legacyReleaseSchema
+]);
+var templateSchema = z12.object({
+  code: z12.string(),
+  definition: questDescriptionSchema
+});
+var quizAnswersSchema = z12.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 = z12.object({
+  kind: z12.literal("quiz"),
+  release: identifier.optional(),
+  answers: quizAnswersSchema
+}).strict();
+var submissionEvidenceSchema = z12.union([
+  quizEvidenceSchema,
+  textEvidenceSchema,
+  urlEvidenceSchema
+]);
+var submitSchema = z12.object({
+  actionId: identifier,
+  quest: identifier,
+  member: identifier,
+  evidence: identifier.optional(),
+  input: submissionEvidenceSchema.optional(),
+  release: identifier.optional(),
+  faultAfterReview: z12.boolean().optional()
+}).strict();
+var attemptSchema = z12.object({
+  id: identifier,
+  release: identifier,
+  quest: identifier,
+  member: identifier,
+  evidence: identifier.nullable(),
+  input: submissionEvidenceSchema.optional(),
+  status: z12.enum([
+    "queued",
+    "evaluating",
+    "accepted",
+    "progressed",
+    "rejected",
+    "needs-review",
+    "failed"
+  ]),
+  reason: z12.string().nullable(),
+  retries: z12.number(),
+  generation: z12.number(),
+  completion: z12.string().nullable(),
+  reviewRewards: rewardBundleSchema.nullable().default(null),
+  createdAt: z12.number()
+});
+var eventSchema = z12.object({
+  id: z12.number(),
+  attempt: z12.string().nullable(),
+  kind: z12.string(),
+  detail: z12.string(),
+  actor: z12.string().nullable().default(null),
+  at: z12.number()
+});
+var pickupSelectionSchema = z12.object({
+  item: identifier,
+  revision: z12.number().int().nonnegative()
+}).strict();
+var pickupAllocationSchema = z12.object({
+  item: identifier,
+  label: z12.string().min(1).max(80)
+}).strict();
+var pickupPolicySchema = z12.discriminatedUnion("kind", [
+  z12.object({ kind: z12.literal("untracked") }).strict(),
+  z12.object({
+    kind: z12.literal("at-pickup"),
+    tiers: z12.array(
+      z12.object({
+        tier: identifier,
+        variants: z12.array(pickupAllocationSchema).min(1).max(100)
+      }).strict()
+    ).min(1).max(100)
+  }).strict()
+]);
+var pickupCatalogSchema = z12.object({
+  reward: tieredRewardDefinitionSchema,
+  revision: z12.number().int().nonnegative(),
+  policy: pickupPolicySchema
+});
+var pickupAvailabilitySchema = z12.discriminatedUnion("kind", [
+  z12.object({ kind: z12.literal("untracked") }).strict(),
+  z12.object({
+    kind: z12.literal("at-pickup"),
+    revision: z12.number().int().nonnegative(),
+    variants: z12.array(
+      pickupAllocationSchema.extend({
+        available: z12.number().int().nonnegative()
+      })
+    )
+  }).strict()
+]);
+var configurePickupSchema = z12.object({
+  reward: identifier,
+  revision: z12.number().int().nonnegative(),
+  actionId: identifier,
+  policy: z12.discriminatedUnion("kind", [
+    z12.object({ kind: z12.literal("untracked") }).strict(),
+    z12.object({
+      kind: z12.literal("at-pickup"),
+      tiers: z12.array(
+        z12.object({
+          tier: identifier,
+          variants: z12.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: z12.number().int().positive()
+};
+var entitlementSchema = z12.discriminatedUnion("status", [
+  z12.object({ ...entitlementBase, status: z12.literal("available") }).strict(),
+  z12.object({
+    ...entitlementBase,
+    status: z12.literal("handing-over"),
+    handover: identifier,
+    startedAt: z12.number(),
+    allocation: pickupAllocationSchema.optional()
+  }).strict(),
+  z12.object({
+    ...entitlementBase,
+    status: z12.literal("collected"),
+    handover: identifier,
+    startedAt: z12.number(),
+    allocation: pickupAllocationSchema.optional(),
+    collectedAt: z12.number()
+  }).strict()
+]);
+var beginHandoverSchema = z12.object({
+  actionId: identifier,
+  revision: z12.number().int().positive(),
+  selection: pickupSelectionSchema.optional()
+}).strict();
+var confirmHandoverSchema = z12.object({ actionId: identifier, handover: identifier }).strict();
+var completionRecordSchema = z12.object({
+  key: z12.string().default("once"),
+  id: identifier,
+  quest: identifier,
+  member: identifier
+});
+var questAvailabilitySchema = z12.discriminatedUnion("kind", [
+  z12.object({
+    kind: z12.literal("available"),
+    input: z12.enum(["photo", "quiz", "none", "text", "url"])
+  }).strict(),
+  z12.object({ kind: z12.literal("completed") }).strict(),
+  z12.object({
+    kind: z12.literal("locked"),
+    missing: z12.array(z12.object({ quest: identifier, title: z12.string() })).min(1)
+  }).strict(),
+  z12.object({ kind: z12.literal("staff-required") }).strict(),
+  z12.object({
+    kind: z12.literal("automatic"),
+    observation: observationTriggerSchema.optional()
+  }).strict(),
+  z12.object({ kind: z12.literal("checking"), attempt: identifier }).strict(),
+  z12.object({ kind: z12.literal("needs-review"), attempt: identifier }).strict(),
+  z12.object({ kind: z12.literal("retryable"), attempt: identifier }).strict()
+]);
+var memberProgressSchema = z12.object({
+  member: identifier,
+  quests: z12.array(
+    z12.object({
+      quest: identifier,
+      key: identifier.optional(),
+      release: identifier.optional(),
+      title: z12.string(),
+      presentation: questPresentationSchema.default({}),
+      connections: z12.array(authProviderSchema).default([]),
+      trigger: triggerSchema,
+      availability: questAvailabilitySchema,
+      completed: z12.boolean(),
+      completion: completionPolicySchema.default({ kind: "once" }),
+      streak: streakProgressSchema.nullable().optional(),
+      completionCount: z12.number().int().nonnegative().default(0),
+      visibility: z12.enum(["visible", "hidden"]).default("visible"),
+      missing: z12.array(z12.object({ quest: identifier, title: z12.string() })),
+      attempt: attemptSchema.nullable()
+    })
+  ),
+  entitlements: z12.array(entitlementSchema)
+});
+var snapshotSchema = z12.object({
+  releases: z12.array(publishedReleaseSchema),
+  completions: z12.array(completionRecordSchema),
+  entitlements: z12.array(entitlementSchema),
+  attempts: z12.array(attemptSchema),
+  balances: z12.array(
+    z12.object({
+      member: z12.string(),
+      balance: z12.string(),
+      earned: z12.number(),
+      held: z12.number(),
+      available: z12.number()
+    })
+  ),
+  events: z12.array(eventSchema)
+});
+var evidenceSchema = z12.object({
+  id: identifier,
+  member: identifier,
+  type: z12.enum(["image/jpeg", "image/png"]),
+  size: z12.number()
+});
+var errorSchema = z12.object({
+  error: z12.string(),
+  code: z12.enum(["stale-quiz", "quest-updated", "invalid-submission"]).optional(),
+  missing: z12.array(z12.object({ quest: identifier, title: z12.string() })).optional()
+});
+var staffDecisionSchema = z12.object({
+  actionId: identifier,
+  generation: z12.number().int().nonnegative(),
+  decision: z12.enum(["accept", "reject"]),
+  reason: z12.string().trim().min(1).max(2e3)
+}).strict();
+var stockSchema = z12.object({ item: identifier, quantity: z12.number().int().min(0).max(1e4) }).strict();
+var reservationSchema = z12.object({
+  actionId: identifier,
+  member: identifier,
+  item: identifier,
+  balance: identifier,
+  price: z12.number().int().positive().max(1e4)
+}).strict();
+var pageOptions = {
+  limit: z12.number().int().min(1).max(100).default(25),
+  cursor: z12.string().min(1).max(4096).optional()
+};
+var reviewListSchema = z12.object({
+  ...pageOptions,
+  member: identifier.optional(),
+  quest: identifier.optional()
+}).strict();
+var memberListSchema = z12.object({
+  ...pageOptions,
+  prefix: identifier.optional()
+}).strict();
+var reviewItemSchema = z12.object({
+  attempt: attemptSchema,
+  title: z12.string(),
+  checks: z12.array(
+    z12.object({ criteria: z12.string(), result: photoResultSchema })
+  )
+});
+var reviewPageSchema = z12.object({
+  items: z12.array(reviewItemSchema).max(100),
+  nextCursor: z12.string().nullable()
+});
+var memberPageSchema = z12.object({
+  items: z12.array(z12.object({ member: identifier })).max(100),
+  nextCursor: z12.string().nullable()
+});
+var createStockItemSchema = z12.object({ actionId: identifier, name: z12.string().trim().min(1).max(80) }).strict();
+var stockItemSchema = z12.object({ id: identifier, name: z12.string() });
+var contentPerformanceSnapshotSchema = z12.strictObject({
+  contentAttempt: identifier,
+  observation: identifier,
+  observedAt: z12.number().int().safe().nonnegative(),
+  metrics: contentMetricsSchema,
+  rewards: rewardBundleSchema
+});
+var contentPerformanceQuerySchema = contentQualificationQuerySchema.extend({
+  content: z12.string().min(1).max(256)
+});
+var contentPerformancePageSchema = z12.strictObject({
+  current: z12.strictObject({
+    state: z12.enum([
+      "content-pending",
+      "content-unqualified",
+      "waiting",
+      "pending",
+      "qualified",
+      "unqualified",
+      "needs-review",
+      "failed",
+      "superseded"
+    ]),
+    reason: z12.string().nullable(),
+    contentAttempt: identifier,
+    attempt: identifier.nullable(),
+    reward: contentQualificationSchema.shape.reward
+  }),
+  items: z12.array(
+    z12.strictObject({
+      attempt: identifier,
+      contentAttempt: identifier,
+      observation: identifier,
+      observedAt: z12.number(),
+      metrics: contentMetricsSchema,
+      state: z12.enum([
+        "pending",
+        "qualified",
+        "unqualified",
+        "needs-review",
+        "failed",
+        "superseded"
+      ]),
+      reason: z12.string().nullable()
+    })
+  ),
+  next: z12.number().int().positive().safe().nullable()
+});
+
+export {
+  identifier,
+  xTweetSchema,
+  xContentBodySchema,
+  trackerContentQuerySchema,
+  trackerContentReadSchema,
+  trackerContentSchema,
+  trackerSourceSchema,
+  x,
+  customSource,
+  trackerDefinitionSchema,
+  trackerArtifactSchema,
+  defineTracker,
+  publishedTrackerSchema,
+  trackerStatusSchema,
+  trackerControlSchema,
+  trackerRecordInputSchema,
+  trackerRecordSchema,
+  trackerIngestSchema,
+  trackerIngestResultSchema,
+  trackerQuerySchema,
+  trackerPageSchema,
+  trackerSummarySchema,
+  trackerPreviewLimits,
+  trackerPreviewInputSchema,
+  trackerPreviewSchema,
+  contentPolicySchema,
+  content,
+  admittedContentSchema,
+  perContent,
+  contentEnrollmentInputSchema,
+  contentEnrollmentSchema,
+  contentReleaseInputSchema,
+  contentAdmissionSchema,
+  contentAdmissionQuerySchema,
+  contentAdmissionPageSchema,
+  isContentParticipantRoute,
+  contentQualificationDecisionSchema,
+  contentQualificationQuerySchema,
+  contentQualificationSchema,
+  contentQualificationPageSchema,
+  contentMetricSchema,
+  contentMetricsSchema,
+  contentPerformancePolicySchema,
+  communityTimeZoneSchema,
+  streakPolicySchema,
+  streak,
+  streakProgressSchema,
+  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,
+  contentPerformanceSnapshotSchema,
+  contentPerformanceQuerySchema,
+  contentPerformancePageSchema
+};