@domino-sdk/relay 1.0.0-next.8 → 1.0.0

package/dist/chunk-VARGF4JS.js

@@ -1,1733 +0,0 @@
-// src/accounts.ts
-import { z } from "zod";
-var authProviderSchema = z.enum(["google", "apple", "x", "discord"]);
-var accountConnectionSchema = z.object({
-  provider: authProviderSchema,
-  configured: z.boolean(),
-  status: z.enum(["disconnected", "connected", "reconnect"]),
-  subject: z.string().nullable(),
-  revision: z.number().int().nonnegative()
-});
-var discordMemberInputSchema = z.object({}).strict();
-var discordMessageInputSchema = z.object({
-  channelId: z.string().regex(/^[0-9]{1,20}$/),
-  messageId: z.string().regex(/^[0-9]{1,20}$/)
-}).strict();
-var discordMemberSchema = z.object({
-  userId: z.string().regex(/^[0-9]{1,20}$/).nullable().default(null),
-  nickname: z.string().nullable().default(null),
-  displayName: z.string().nullable().default(null),
-  boostingSince: z.string().datetime({ offset: true }).nullable().default(null),
-  roles: z.array(z.string().regex(/^[0-9]{1,20}$/)),
-  joinedAt: z.string().datetime({ offset: true }).nullable(),
-  pending: z.boolean()
-});
-
-// src/identifier.ts
-import { z as z2 } from "zod";
-var identifier = z2.string().min(1).max(100).regex(/^[a-zA-Z0-9_-]+$/);
-
-// src/pages.ts
-import { z as z3 } from "zod";
-var pageCursorSchema = z3.string().min(1).max(4096);
-var pageQuerySchema = z3.strictObject({
-  cursor: pageCursorSchema.optional()
-});
-
-// src/trackers.ts
-import { z as z4 } from "zod";
-var timestamp = z4.number().int().safe().nonnegative().max(864e13);
-var count = z4.number().int().safe().nonnegative();
-var externalId = z4.string().min(1).max(256);
-var metric = count.nullable().default(null);
-var xTweetSchema = z4.looseObject({
-  id: externalId,
-  userId: externalId,
-  content: z4.string(),
-  createdAt: z4.iso.datetime({ offset: true }),
-  author: z4.looseObject({
-    id: externalId,
-    username: z4.string(),
-    name: z4.string(),
-    verified: z4.boolean().nullable().default(null)
-  }),
-  likeCount: metric,
-  replyCount: metric,
-  retweetCount: metric,
-  quoteCount: metric,
-  viewCount: metric,
-  bookmarkCount: metric,
-  isReply: z4.boolean(),
-  isRetweet: z4.boolean(),
-  isQuoteTweet: z4.boolean()
-});
-var xContentBodySchema = z4.strictObject({
-  version: z4.literal(1),
-  id: z4.string().min(1),
-  authorId: z4.string().min(1),
-  publishedAt: timestamp,
-  text: z4.string(),
-  isReply: z4.boolean(),
-  isRetweet: z4.boolean(),
-  isQuoteTweet: z4.boolean(),
-  media: z4.array(z4.strictObject({ type: z4.string(), url: z4.string() })).nullable(),
-  mentionedAuthorIds: z4.array(z4.string().min(1)).nullable(),
-  videoLengthSeconds: z4.number().nonnegative().nullable(),
-  references: z4.strictObject({
-    replyId: z4.string().nullable(),
-    replyAuthorId: z4.string().nullable(),
-    quoteId: z4.string().nullable(),
-    quoteAuthorId: z4.string().nullable(),
-    repostId: z4.string().nullable(),
-    repostAuthorId: z4.string().nullable()
-  })
-});
-var trackerContentQuerySchema = z4.strictObject({
-  id: externalId,
-  observation: z4.string().regex(/^observation_[a-f0-9]{64}$/)
-});
-var trackerContentReadSchema = trackerContentQuerySchema.extend({
-  member: identifier
-});
-var attributionContext = { member: identifier, capturedAt: timestamp };
-var trackerEvidenceSchema = z4.strictObject({
-  contentRevision: identifier,
-  observation: identifier
-});
-var trackerContentSchema = z4.strictObject({
-  tracker: identifier,
-  source: z4.literal("x"),
-  evidence: trackerEvidenceSchema,
-  content: xContentBodySchema,
-  observedAt: timestamp,
-  removed: z4.boolean(),
-  attribution: z4.discriminatedUnion("kind", [
-    z4.strictObject({
-      ...attributionContext,
-      kind: z4.literal("linked"),
-      account: z4.strictObject({
-        provider: z4.literal("x"),
-        issuer: z4.string().min(1),
-        subject: externalId,
-        revision: count,
-        linkedAt: timestamp.nullable()
-      })
-    }),
-    z4.strictObject({ ...attributionContext, kind: z4.literal("unlinked") }),
-    z4.strictObject({
-      ...attributionContext,
-      kind: z4.literal("different-author")
-    })
-  ])
-});
-var identityKindSchema = z4.enum(["wallet", "x", "discord", "member"]);
-var accountRoleSchema = z4.string().regex(
-  /^[a-zA-Z][a-zA-Z0-9_]{0,39}$/,
-  "Name roles like author or recipient: a letter, then letters, digits or underscores"
-);
-var xAccountRoles = ["author", "inReplyTo"];
-var distinct = (values) => new Set(values).size === values.length;
-var xSearchSourceSchema = z4.object({
-  kind: z4.literal("x-search"),
-  query: z4.string().trim().min(1).max(2e3)
-}).strict();
-var customSourceSchema = z4.object({
-  kind: z4.literal("custom"),
-  namespace: identifier,
-  /**
-   * The identity kinds a record's author and named accounts can be, attributed to members
-   * through verified links. Omitted when authors are opaque IDs, which no quest can pay.
-   */
-  identities: z4.array(identityKindSchema).min(1).max(4).refine(distinct, "List each identity kind once").optional(),
-  /** Roles of the named accounts records can carry besides their author, such as `recipient`. */
-  accounts: z4.array(accountRoleSchema).min(1).max(10).refine(distinct, "List each account role once").refine(
-    (roles) => !roles.includes("author"),
-    "author is every record's own role; name other accounts"
-  ).optional(),
-  /**
-   * How trackers published before identity kinds stored `identities: ["wallet"]`. Reads return
-   * those definitions as stored; write `identities` instead.
-   *
-   * @deprecated Use `identities: ["wallet"]`.
-   */
-  authors: z4.literal("wallet").optional()
-}).strict().refine(
-  (source) => !(source.authors && source.identities),
-  "Use identities, not authors"
-).refine(
-  (source) => !source.accounts || source.identities,
-  "Named accounts need identities"
-);
-var trackerSourceSchema = z4.discriminatedUnion("kind", [
-  xSearchSourceSchema,
-  customSourceSchema
-]);
-function sourceIdentities(source) {
-  if (source.kind === "x-search") {
-    return ["x"];
-  }
-  return source.identities ?? (source.authors === "wallet" ? ["wallet"] : void 0);
-}
-var windowSchema = z4.object({ start: timestamp, end: timestamp.optional() }).strict().refine(
-  (w) => w.end === void 0 || w.end > w.start,
-  "End must follow start"
-);
-var trackerDefinitionSchema = z4.object({
-  key: identifier,
-  title: z4.string().trim().min(1).max(120),
-  source: trackerSourceSchema,
-  window: windowSchema,
-  refreshSeconds: z4.number().int().min(300).max(86400).default(21600),
-  maxPages: z4.number().int().min(1).max(1e3).default(60)
-}).strict();
-var trackerArtifactSchema = z4.union([
-  trackerDefinitionSchema,
-  z4.object({ code: z4.string().min(1).max(2e6) }).strict()
-]);
-var publishedTrackerSchema = z4.object({
-  id: identifier,
-  version: identifier,
-  definition: trackerDefinitionSchema,
-  publishedAt: timestamp,
-  actor: z4.string().nullable()
-});
-var trackerStatusSchema = z4.object({
-  published: publishedTrackerSchema,
-  paused: z4.boolean(),
-  state: z4.enum(["idle", "syncing", "error", "complete"]),
-  lastStartedAt: timestamp.nullable(),
-  lastCompletedAt: timestamp.nullable(),
-  nextSyncAt: timestamp.nullable(),
-  coverage: z4.enum(["unknown", "partial", "complete"]),
-  error: z4.string().nullable(),
-  records: count
-});
-var trackerControlSchema = z4.object({
-  actionId: identifier,
-  action: z4.enum(["pause", "resume", "refresh"])
-}).strict();
-var trackerAccountSchema = z4.strictObject({
-  kind: identityKindSchema.optional(),
-  id: externalId
-});
-var trackerRecordInputSchema = z4.object({
-  id: externalId,
-  occurredAt: timestamp,
-  observedAt: timestamp,
-  author: z4.object({
-    id: externalId,
-    verified: z4.boolean().nullable().default(null),
-    /** The author's identity kind; needed when the source names more than one. */
-    kind: identityKindSchema.optional()
-  }).strict().nullable().default(null),
-  /** Named accounts besides the author, by the roles the custom source declares. */
-  accounts: z4.record(accountRoleSchema, trackerAccountSchema).refine(
-    (accounts) => Object.keys(accounts).length <= 10,
-    "At most 10 accounts"
-  ).optional(),
-  data: z4.record(z4.string(), z4.json()),
-  removed: z4.boolean().default(false)
-}).strict().refine(
-  (v) => new TextEncoder().encode(JSON.stringify(v.data)).byteLength <= 131072,
-  "Record exceeds 128 KB"
-);
-var trackerRecordSchema = trackerRecordInputSchema.safeExtend({
-  source: z4.string(),
-  firstSeenAt: timestamp,
-  /** Present only when includeEvidence is true; custom sources have no X evidence. */
-  evidence: trackerEvidenceSchema.nullable().optional()
-});
-var trackerIngestSchema = z4.object({
-  actionId: identifier,
-  records: z4.array(trackerRecordInputSchema).min(1).max(100)
-}).strict();
-var trackerIngestResultSchema = z4.object({
-  stored: count,
-  /** Tracker-trigger decisions this ingest caused. Absent from servers without tracker triggers. */
-  admissions: z4.object({
-    admitted: count,
-    skipped: count,
-    /**
-     * Observations a quest's firing mode selected but its `where` filter did not match, counted
-     * per quest like `admitted` and `skipped`. They record no outcome. Present only when
-     * nonzero.
-     */
-    filtered: count.optional()
-  }).optional()
-});
-var trackerOutcomeFields = {
-  /** Stable quest ID. */
-  quest: identifier,
-  /** Stable tracker ID. */
-  tracker: identifier,
-  record: externalId,
-  observedAt: timestamp,
-  /** The release admitted, or the one active when the observation was skipped. */
-  release: identifier,
-  /** The account attribution resolved or failed to resolve, such as a CAIP-10 wallet ID. */
-  account: z4.string().nullable(),
-  createdAt: timestamp,
-  updatedAt: timestamp,
-  /** Null for automatic decisions; the staff actor after a retry. */
-  actor: z4.string().nullable()
-};
-var trackerSkipCodes = [
-  /** The quest is paused or no longer active. */
-  "quest-paused",
-  /** The record occurred before the quest was published. */
-  "before-activation",
-  /** The record is marked removed. */
-  "record-removed",
-  /** The captured X post of this observation cannot be read. */
-  "content-unavailable",
-  /** The record has no account in the beneficiary role, such as a post that is not a reply. */
-  "no-account",
-  /**
-   * The beneficiary account is the record's author account, such as a reply to oneself, or both
-   * belong to the same member. A different account is judged once it resolves to a member, after
-   * `unlinked-account` and `ambiguous-account`.
-   */
-  "beneficiary-is-author",
-  /** No member has verified the beneficiary account. */
-  "unlinked-account",
-  /** More than one member has the beneficiary account. */
-  "ambiguous-account",
-  /** The attributed member has not joined the project. */
-  "not-joined",
-  /** The attributed member has not completed the quest's prerequisites. */
-  "prerequisites-incomplete"
-];
-var trackerOutcomeSchema = z4.discriminatedUnion("state", [
-  z4.strictObject({
-    ...trackerOutcomeFields,
-    state: z4.literal("admitted"),
-    code: z4.null(),
-    reason: z4.null(),
-    /** The attributed member. */
-    member: identifier,
-    /** The admitted attempt. Its evaluation, decision and rewards live on the attempt. */
-    attempt: identifier
-  }),
-  z4.strictObject({
-    ...trackerOutcomeFields,
-    state: z4.literal("skipped"),
-    /** Why the observation was skipped, as one of `trackerSkipCodes`. */
-    code: z4.string().min(1),
-    /** Why the observation was skipped, for people. */
-    reason: z4.string(),
-    /** The attributed member, when attribution got that far. */
-    member: identifier.nullable(),
-    attempt: identifier.nullable()
-  })
-]);
-var trackerOutcomeQuerySchema = z4.strictObject({
-  /** Quest key or ID. */
-  quest: identifier.optional(),
-  record: externalId.optional(),
-  member: identifier.optional(),
-  state: z4.enum(["admitted", "skipped"]).optional(),
-  /** Only skips with this code, such as `unlinked-account`. */
-  code: z4.string().min(1).max(100).optional(),
-  limit: z4.coerce.number().int().min(1).max(100).default(25),
-  /** Opaque cursor from `next`: older outcomes. */
-  before: z4.string().max(512).optional()
-});
-var trackerOutcomePageSchema = z4.strictObject({
-  /** Newest first. */
-  items: z4.array(trackerOutcomeSchema).max(100),
-  next: z4.string().nullable()
-});
-var trackerOutcomeRetrySchema = z4.strictObject({
-  actionId: identifier,
-  /** Quest key or ID. */
-  quest: identifier,
-  record: externalId,
-  observedAt: timestamp
-});
-var booleanQuery = z4.union([
-  z4.boolean(),
-  z4.enum(["true", "false"]).transform((v) => v === "true")
-]);
-var trackerQuerySchema = z4.object({
-  author: externalId.optional(),
-  member: identifier.optional(),
-  verified: booleanQuery.optional(),
-  since: z4.coerce.number().int().safe().nonnegative().optional(),
-  until: z4.coerce.number().int().safe().nonnegative().optional(),
-  removed: booleanQuery.default(false),
-  minLikes: z4.coerce.number().int().safe().nonnegative().optional(),
-  minViews: z4.coerce.number().int().safe().nonnegative().optional(),
-  limit: z4.coerce.number().int().min(1).max(100).default(25),
-  cursor: z4.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 = z4.object({
-  tracker: identifier,
-  items: z4.array(trackerRecordSchema),
-  nextCursor: z4.string().nullable(),
-  total: count,
-  status: trackerStatusSchema
-});
-var trackerSummarySchema = z4.object({
-  records: count,
-  authors: count,
-  metrics: z4.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 = z4.object({
-  query: xSearchSourceSchema.shape.query,
-  /** Start of the searched window. The window ends when the sample is fetched. */
-  since: timestamp
-}).strict();
-var trackerPreviewSchema = z4.object({
-  query: z4.string(),
-  since: timestamp,
-  fetchedAt: timestamp,
-  pages: count,
-  /** Every match in the sample, newest first, verified or not. */
-  posts: z4.array(xTweetSchema).max(trackerPreviewLimits.posts),
-  /** X had more matches than the sample holds. */
-  more: z4.boolean()
-});
-
-// src/content.ts
-import { z as z5 } from "zod";
-var timestamp2 = z5.number().int().safe().nonnegative().max(864e13);
-var contentPolicySchema = z5.strictObject({
-  tracker: identifier,
-  window: trackerDefinitionSchema.shape.window,
-  enrollment: z5.enum(["none", "required"]).default("none"),
-  posts: z5.enum(["after-enrollment", "since-start"]).default("after-enrollment"),
-  historical: z5.enum(["automatic", "claim", "staff"]).default("claim")
-});
-var admittedContentSchema = xContentBodySchema.extend({
-  tracker: identifier,
-  revision: identifier,
-  observation: identifier,
-  attribution: trackerContentSchema.shape.attribution.options[0],
-  enrolledAt: timestamp2.nullable(),
-  completionKey: z5.string().min(1).max(200)
-});
-var contentEnrollmentInputSchema = z5.strictObject({
-  actionId: identifier,
-  quest: identifier,
-  member: identifier
-});
-var contentEnrollmentSchema = z5.strictObject({
-  quest: identifier,
-  member: identifier,
-  enrolledAt: timestamp2
-});
-var contentReleaseInputSchema = contentEnrollmentInputSchema.extend({
-  content: z5.string().min(1).max(256)
-});
-var contentAdmissionSchema = z5.strictObject({
-  quest: identifier,
-  content: z5.string().min(1).max(256),
-  release: identifier,
-  state: z5.enum(["pending", "admitted", "excluded"]),
-  reason: z5.string().nullable(),
-  attempt: identifier.nullable()
-});
-var contentAdmissionQuerySchema = z5.strictObject({
-  quest: identifier,
-  member: identifier.optional(),
-  content: z5.string().min(1).max(256).optional(),
-  cursor: pageCursorSchema.optional()
-});
-var contentAdmissionPageSchema = z5.strictObject({
-  items: z5.array(contentAdmissionSchema),
-  nextCursor: pageCursorSchema.nullable()
-});
-var contentQualificationDecisionSchema = z5.strictObject({
-  kind: z5.enum(["accept", "reject", "review", "superseded"]),
-  reason: z5.string().nullable()
-});
-var contentQualificationQuerySchema = z5.strictObject({
-  quest: identifier,
-  member: identifier.optional(),
-  content: z5.string().min(1).max(256).optional(),
-  cursor: pageCursorSchema.optional()
-});
-var contentQualificationSchema = z5.strictObject({
-  quest: identifier,
-  content: z5.string(),
-  member: identifier,
-  release: identifier,
-  attempt: identifier,
-  revision: identifier,
-  observation: identifier,
-  current: z5.boolean(),
-  state: z5.enum([
-    "pending",
-    "qualified",
-    "unqualified",
-    "needs-review",
-    "failed",
-    "superseded",
-    "stale",
-    "blocked",
-    "unavailable"
-  ]),
-  reason: z5.string().nullable(),
-  reward: z5.strictObject({
-    attempt: identifier.nullable(),
-    completion: identifier.nullable(),
-    state: z5.enum(["unresolved", "awarded", "excluded"])
-  })
-});
-var contentQualificationPageSchema = z5.strictObject({
-  items: z5.array(contentQualificationSchema),
-  nextCursor: pageCursorSchema.nullable()
-});
-var contentMetricSchema = z5.enum([
-  "likes",
-  "replies",
-  "reposts",
-  "quotes",
-  "views",
-  "bookmarks"
-]);
-var contentMetricsSchema = z5.partialRecord(
-  contentMetricSchema,
-  z5.number().int().safe().nonnegative()
-);
-var contentPerformancePolicySchema = z5.strictObject({
-  metrics: z5.array(contentMetricSchema).min(1).max(6).refine(
-    (values) => new Set(values).size === values.length,
-    "Metrics must be unique"
-  ),
-  maxAgeMs: z5.number().int().positive().max(864e5).default(36e5)
-});
-
-// src/streaks.ts
-import { z as z6 } from "zod";
-var communityTimeZoneSchema = z6.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 = z6.object({
-  kind: z6.literal("streak"),
-  days: z6.number().int().min(1).max(3650),
-  timeZone: communityTimeZoneSchema
-}).strict();
-var streakProgressSchema = z6.object({
-  goal: z6.number().int().positive(),
-  current: z6.number().int().nonnegative(),
-  best: z6.number().int().nonnegative(),
-  today: z6.string(),
-  todayQualified: z6.boolean(),
-  timeZone: communityTimeZoneSchema,
-  nextBoundary: z6.number().int(),
-  pendingTimeZone: z6.object({
-    timeZone: communityTimeZoneSchema,
-    effectiveAt: z6.number().int()
-  }).nullable(),
-  days: z6.array(
-    z6.object({
-      day: z6.number().int(),
-      date: z6.string(),
-      timeZone: communityTimeZoneSchema,
-      occurredAt: z6.number().int()
-    })
-  ),
-  milestone: z6.discriminatedUnion("status", [
-    z6.object({ status: z6.literal("pending") }),
-    z6.object({
-      status: z6.literal("awarded"),
-      completion: z6.string(),
-      achievedAt: z6.number().int()
-    }),
-    z6.object({
-      status: z6.literal("budget-exhausted"),
-      budget: z6.string(),
-      achievedAt: z6.number().int()
-    })
-  ])
-});
-
-// src/tracker-triggers.ts
-import { z as z7 } from "zod";
-var timestamp3 = z7.number().int().safe().nonnegative().max(864e13);
-var count2 = z7.number().int().safe().nonnegative();
-var trackerTriggerModeSchema = z7.enum([
-  "new-record",
-  "new-observation",
-  "data-changed"
-]);
-function defaultTriggerMode(source) {
-  return source === "x-search" ? "new-record" : "new-observation";
-}
-var trackerBoundSchema = z7.union([
-  z7.number().finite(),
-  z7.strictObject({ setting: z7.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/) })
-]);
-var dataPath = z7.string().max(200).regex(
-  /^[^.\s]+(\.[^.\s]+)*$/,
-  "Use dot-separated keys, such as metrics.likes"
-);
-var trackerWhereSchema = z7.union([
-  z7.strictObject({
-    path: dataPath,
-    equals: z7.union([z7.string().max(1e3), z7.number().finite(), z7.boolean()])
-  }),
-  z7.strictObject({
-    path: dataPath,
-    gt: trackerBoundSchema.optional(),
-    gte: trackerBoundSchema.optional(),
-    lt: trackerBoundSchema.optional(),
-    lte: trackerBoundSchema.optional()
-  }).refine(
-    (where) => [where.gt, where.gte, where.lt, where.lte].some(
-      (bound) => bound !== void 0
-    ),
-    "Compare with equals, gt, gte, lt or lte"
-  )
-]);
-var trackerTriggerPolicySchema = z7.strictObject({
-  /** The tracker's authoring key; publication binds it to the tracker's stable ID. */
-  tracker: identifier,
-  source: z7.enum(["x-search", "custom"]),
-  /** Which observations fire; absent means the source's default (`defaultTriggerMode`). */
-  on: trackerTriggerModeSchema.optional(),
-  where: trackerWhereSchema.optional(),
-  /**
-   * The record account the quest pays: `author`, `inReplyTo` for an X post, or a named account of
-   * a custom record. Relay attributes it through verified links; evaluators cannot redirect it.
-   * Releases published before account roles store `"replied-to"` for `inReplyTo`.
-   */
-  beneficiary: z7.union([accountRoleSchema, z7.literal("replied-to")])
-});
-function triggerMode(policy) {
-  return policy.on ?? defaultTriggerMode(policy.source);
-}
-function beneficiaryRole(policy) {
-  return policy.beneficiary === "replied-to" ? "inReplyTo" : policy.beneficiary;
-}
-var xLink = {
-  issuer: z7.string().min(1),
-  /** The account's stable user ID. */
-  subject: z7.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()
-};
-var trackerAttributionSchema = z7.strictObject({
-  member: identifier,
-  capturedAt: timestamp3,
-  account: z7.discriminatedUnion("provider", [
-    z7.strictObject({
-      provider: z7.literal("wallet"),
-      /** Canonical CAIP-10 account ID, as the record names it. */
-      id: z7.string().min(5).max(256),
-      /** The wallet link's revision. */
-      revision: count2,
-      /** When the member verified the wallet. */
-      linkedAt: timestamp3.nullable()
-    }),
-    z7.strictObject({ provider: z7.literal("x"), ...xLink }),
-    z7.strictObject({ provider: z7.literal("discord"), ...xLink }),
-    z7.strictObject({
-      provider: z7.literal("member"),
-      /** The member ID the record names. */
-      id: identifier
-    })
-  ])
-});
-var trackerTriggerRecordSchema = z7.strictObject({
-  id: z7.string().min(1).max(256),
-  source: z7.string(),
-  occurredAt: timestamp3,
-  observedAt: timestamp3,
-  firstSeenAt: timestamp3,
-  author: z7.strictObject({
-    id: z7.string().min(1).max(256),
-    verified: z7.boolean().nullable(),
-    kind: identityKindSchema.optional()
-  }).nullable(),
-  accounts: z7.record(accountRoleSchema, trackerAccountSchema).optional(),
-  data: z7.record(z7.string(), z7.json()),
-  removed: z7.boolean()
-});
-var trackerTriggerContextSchema = z7.strictObject({
-  /** The tracker's stable ID. */
-  tracker: identifier,
-  /** The tracker's authoring key. */
-  key: identifier,
-  /**
-   * 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: z7.union([accountRoleSchema, z7.literal("replied-to")]),
-  record: trackerTriggerRecordSchema,
-  /** The captured X post of this observation; null for custom trackers. */
-  x: z7.strictObject({
-    evidence: trackerEvidenceSchema,
-    content: xContentBodySchema
-  }).nullable(),
-  attribution: trackerAttributionSchema
-});
-
-// src/observations.ts
-import { z as z8 } from "zod";
-var name = z8.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
-var observationInputSchema = z8.object({
-  id: name,
-  source: name,
-  type: name,
-  member: identifier,
-  actor: z8.object({ provider: identifier, subject: z8.string().min(1).max(200) }).strict().optional(),
-  occurredAt: z8.number().int().nonnegative().max(864e13),
-  data: z8.record(z8.string(), z8.json())
-}).strict().refine(
-  (value) => JSON.stringify(value.data).length <= 32768,
-  "Observation data exceeds 32 KB"
-);
-var observationSchema = observationInputSchema.safeExtend({
-  receivedAt: z8.number().int().nonnegative()
-});
-var observationTriggerSchema = z8.object({ source: name, type: name }).strict();
-var completionPolicySchema = z8.discriminatedUnion("kind", [
-  streakPolicySchema,
-  z8.object({ kind: z8.literal("once") }).strict(),
-  z8.object({ kind: z8.literal("keyed") }).strict()
-]);
-var completionKeySchema = z8.string().min(1).max(500);
-var budgetSchema = z8.object({
-  id: name,
-  scope: z8.enum(["member", "project"]),
-  /**
-   * `"day"` buckets by UTC date and `"week"` by ISO week (UTC, weeks start on Monday), both of
-   * the attempt's eligibility time; `"lifetime"` never resets.
-   */
-  period: z8.enum(["lifetime", "day", "week"]),
-  limit: z8.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  cost: z8.union([
-    z8.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-    z8.object({ balance: name }).strict()
-  ])
-}).strict();
-var observationReceiptSchema = z8.object({
-  id: name,
-  source: name,
-  attempts: z8.array(z8.string()),
-  receivedAt: z8.number()
-});
-var discordReactionSchema = z8.object({
-  guildId: z8.string(),
-  channelId: z8.string(),
-  messageId: z8.string(),
-  userId: z8.string(),
-  messageAuthorId: z8.string().nullable().default(null),
-  actorRoles: z8.array(z8.string()).default([]),
-  emoji: z8.object({ id: z8.string().nullable(), name: z8.string() }),
-  messagePublishedAt: z8.number()
-}).strict();
-var discordMessageSchema = z8.object({
-  guildId: z8.string(),
-  channelId: z8.string(),
-  messageId: z8.string(),
-  userId: z8.string(),
-  content: z8.string().nullable(),
-  replyTo: z8.string().nullable(),
-  publishedAt: z8.number()
-}).strict();
-
-// src/integrations.ts
-import { z as z9 } from "zod";
-var integrationProviderSchema = z9.enum(["discord"]);
-var discordServerSchema = z9.object({
-  id: z9.string().regex(/^[0-9]{1,20}$/),
-  name: z9.string().min(1),
-  icon: z9.string().nullable()
-});
-var projectIntegrationSchema = z9.object({
-  provider: integrationProviderSchema,
-  configured: z9.boolean(),
-  status: z9.enum(["disconnected", "ready", "attention"]),
-  revision: z9.number().int().nonnegative(),
-  server: discordServerSchema.nullable(),
-  issue: z9.string().nullable(),
-  connectedAt: z9.number().default(0)
-});
-
-// src/submission-input.ts
-import { z as z10 } from "zod";
-var textOptionsSchema = z10.object({
-  required: z10.boolean().default(true),
-  minLength: z10.number().int().min(0).max(1e4).default(1),
-  maxLength: z10.number().int().min(1).max(1e4).default(1e4)
-}).strict().refine(
-  (v) => v.minLength <= v.maxLength,
-  "minLength must not exceed maxLength"
-);
-var hostSchema = z10.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 = z10.object({
-  required: z10.boolean().default(true),
-  allowedHosts: z10.array(hostSchema).min(1).max(100).optional()
-}).strict();
-var textEvidenceSchema = z10.object({ kind: z10.literal("text"), value: z10.string().max(1e4) }).strict();
-var urlEvidenceSchema = z10.object({ kind: z10.literal("url"), value: z10.string().max(2048) }).strict();
-var valueEvidenceSchema = z10.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 z11 } from "zod";
-var quizId = z11.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
-var quizChoiceSchema = z11.object({ id: quizId, label: z11.string().trim().min(1).max(500) }).strict();
-var quizQuestionSchema = z11.object({
-  id: quizId,
-  prompt: z11.string().trim().min(1).max(1e3),
-  choices: z11.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 = z11.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 = z11.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/resources.ts
-import { z as z12 } from "zod";
-var channelSourceSchema = z12.object({
-  provider: z12.literal("discord"),
-  resource: z12.literal("channel"),
-  types: z12.array(z12.enum(["text", "announcement"])).min(1)
-}).strict();
-var resourceSourceSchema = z12.union([
-  z12.object({
-    provider: z12.literal("domino"),
-    resource: z12.literal("point-ledger")
-  }).strict(),
-  channelSourceSchema,
-  z12.object({
-    provider: z12.literal("discord"),
-    resource: z12.literal("role"),
-    assignable: z12.boolean().default(false)
-  }).strict()
-]);
-var resourceRequestSchema = z12.object({
-  source: resourceSourceSchema,
-  query: z12.string().max(100).optional(),
-  cursor: z12.string().regex(/^\d{1,6}$/).optional(),
-  ids: z12.array(z12.string().min(1).max(100)).max(50).optional()
-}).strict();
-var resourceOptionsSchema = z12.object({
-  revision: z12.number().int(),
-  options: z12.array(
-    z12.object({
-      id: z12.string(),
-      label: z12.string(),
-      description: z12.string().optional(),
-      group: z12.string().optional(),
-      disabledReason: z12.string().optional()
-    })
-  ),
-  cursor: z12.string().nullable()
-});
-
-// src/settings.ts
-import { z as z14 } from "zod";
-
-// src/setting-values.ts
-import { z as z13 } from "zod";
-var settingInstant = z13.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
-var settingResourceId = z13.union([
-  z13.literal(""),
-  z13.string().regex(/^\S{1,200}$/)
-]);
-
-// src/settings.ts
-var base = { label: z14.string().min(1), description: z14.string().optional() };
-var settingFieldSchema = z14.discriminatedUnion("kind", [
-  z14.object({ ...base, kind: z14.literal("point-ledger"), default: identifier }).strict(),
-  z14.object({ ...base, kind: z14.literal("datetime"), default: settingInstant }).strict(),
-  z14.object({
-    ...base,
-    kind: z14.literal("resource"),
-    default: settingResourceId,
-    source: resourceSourceSchema
-  }).strict(),
-  z14.object({ ...base, kind: z14.literal("quiz"), default: quizContentSchema }).strict(),
-  z14.object({
-    ...base,
-    kind: z14.literal("text"),
-    default: z14.string(),
-    minLength: z14.number().int().nonnegative(),
-    maxLength: z14.number().int().positive(),
-    multiline: z14.boolean()
-  }).strict(),
-  z14.object({
-    ...base,
-    kind: z14.literal("integer"),
-    default: z14.number().int(),
-    min: z14.number().int(),
-    max: z14.number().int()
-  }).strict(),
-  z14.object({ ...base, kind: z14.literal("boolean"), default: z14.boolean() }).strict(),
-  z14.object({
-    ...base,
-    kind: z14.literal("choice"),
-    default: z14.string(),
-    options: z14.array(z14.string().min(1)).min(1)
-  }).strict()
-]);
-var settingsFieldsSchema = z14.record(
-  z14.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
-  settingFieldSchema
-);
-var settingsValuesSchema = z14.record(
-  z14.string(),
-  z14.union([z14.string(), z14.number().finite(), z14.boolean(), quizContentSchema])
-);
-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] = settingInstant.default(field.default);
-        break;
-      case "resource":
-        shape[key] = settingResourceId.default(field.default);
-        break;
-      case "quiz":
-        shape[key] = quizContentSchema.default(field.default);
-        break;
-      case "text":
-        shape[key] = z14.string().min(field.minLength).max(field.maxLength).default(field.default);
-        break;
-      case "integer":
-        shape[key] = z14.number().int().min(field.min).max(field.max).default(field.default);
-        break;
-      case "boolean":
-        shape[key] = z14.boolean().default(field.default);
-        break;
-      case "choice":
-        shape[key] = z14.enum(field.options).default(field.default);
-        break;
-    }
-  }
-  return settingsValuesSchema.parse(z14.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
-import { z as z15 } from "zod";
-var pointsRewardSchema = z15.object({
-  kind: z15.literal("points").default("points"),
-  balance: identifier,
-  amount: z15.number().int().min(0).max(1e4)
-}).strict();
-var tieredRewardDefinitionSchema = z15.object({
-  id: identifier,
-  title: z15.string().min(1).max(120),
-  tiers: z15.array(
-    z15.object({ id: identifier, title: z15.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: z15.object({ kind: z15.literal("untracked") }).strict(),
-  fulfillment: z15.object({ kind: z15.literal("staff-handover") }).strict()
-}).strict();
-var tieredRewardReferenceSchema = z15.object({
-  id: identifier,
-  key: identifier.nullable()
-});
-var tierRewardSchema = z15.object({
-  kind: z15.literal("tier"),
-  reward: tieredRewardDefinitionSchema,
-  tier: identifier
-}).strict().refine(
-  (value) => value.reward.tiers.some((t) => t.id === value.tier),
-  "Unknown reward tier"
-);
-var integrationRewardSchema = z15.object({
-  kind: z15.literal("integration"),
-  provider: z15.literal("discord"),
-  action: z15.literal("grant-role"),
-  roleId: z15.string().regex(/^[0-9]{1,20}$/)
-}).strict();
-var rewardSchema = z15.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 = z15.union([
-  z15.object({
-    kind: z15.literal("manual"),
-    input: z15.literal("text"),
-    constraints: textOptionsSchema,
-    actor: z15.enum(["member", "staff"]).optional()
-  }).strict(),
-  z15.object({
-    kind: z15.literal("manual"),
-    input: z15.literal("url"),
-    constraints: urlOptionsSchema,
-    actor: z15.enum(["member", "staff"]).optional()
-  }).strict(),
-  z15.object({
-    kind: z15.literal("manual"),
-    input: z15.enum(["photo", "quiz", "none"]),
-    actor: z15.enum(["member", "staff"]).optional()
-  }).strict(),
-  z15.object({
-    kind: z15.literal("automatic"),
-    observation: observationTriggerSchema.optional(),
-    content: contentPolicySchema.optional(),
-    tracker: trackerTriggerPolicySchema.optional()
-  }).strict().refine(
-    (value) => [value.observation, value.content, value.tracker].filter(Boolean).length <= 1,
-    "Choose one automatic trigger source"
-  )
-]);
-var prerequisiteSchema = z15.object({ quest: identifier });
-var photoResultSchema = z15.object({
-  kind: z15.enum(["pass", "fail", "unclear"]),
-  reason: z15.string().min(1).max(2e3)
-}).strict();
-var textReviewInputSchema = z15.object({
-  text: z15.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
-  criteria: z15.string().trim().min(1).max(2e3)
-}).strict();
-var textResultSchema = photoResultSchema;
-var decisionSchema = z15.discriminatedUnion("kind", [
-  z15.object({
-    kind: z15.literal("accept"),
-    rewards: z15.array(rewardSchema).max(10),
-    completionKey: completionKeySchema.optional()
-  }).strict(),
-  z15.object({
-    kind: z15.literal("reject"),
-    reason: z15.string().min(1).max(2e3),
-    /** The evaluator asked for human review, but review is off for the quest, so this is a reject. */
-    requestedReview: z15.literal(true).optional()
-  }).strict(),
-  z15.object({
-    kind: z15.literal("review"),
-    reason: z15.string().min(1).max(2e3),
-    rewards: z15.array(rewardSchema).max(10).optional(),
-    completionKey: completionKeySchema.optional()
-  }).strict()
-]);
-var reviewModeSchema = z15.enum(["workers-ai"]);
-var storedReviewModeSchema = z15.enum([
-  "fixture-pass",
-  "fixture-fail",
-  "fixture-unclear",
-  "fixture-error",
-  "workers-ai"
-]);
-var rewardBundleSchema = z15.array(rewardSchema).max(10).refine(
-  (rewards) => new Set(rewards.map(rewardKey)).size === rewards.length,
-  "Use one entry per balance or shared reward"
-);
-var mediaUrlSchema = z15.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 = z15.object({
-  quiz: quizQuestionsSchema.optional(),
-  instructions: z15.string().max(4e3).optional(),
-  video: z15.object({
-    url: mediaUrlSchema,
-    poster: mediaUrlSchema.optional(),
-    captions: z15.object({
-      url: mediaUrlSchema,
-      language: z15.string().min(2).max(20),
-      label: z15.string().min(1).max(80)
-    }).strict().optional()
-  }).strict().optional()
-}).strict();
-var questProfileSchema = z15.object({ visible: z15.boolean() }).strict();
-var questDescriptionSchema = z15.object({
-  quest: identifier,
-  runtimeVersion: z15.union([z15.literal(1), z15.literal(2)]).default(1),
-  title: z15.string().min(1).max(120),
-  presentation: questPresentationSchema.default({}),
-  integrations: z15.array(integrationProviderSchema).max(10).default([]),
-  fields: settingsFieldsSchema,
-  values: settingsValuesSchema,
-  rewards: rewardBundleSchema,
-  humanReview: z15.boolean(),
-  trigger: triggerSchema,
-  performance: contentPerformancePolicySchema.optional(),
-  requires: z15.array(prerequisiteSchema).max(30).default([]),
-  completion: completionPolicySchema,
-  visibility: z15.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: z15.array(budgetSchema).max(20).default([])
-}).strict();
-var artifactSchema = z15.object({ code: z15.string().min(1).max(1e6) }).strict();
-var releaseSchema = artifactSchema.extend({
-  settings: settingsValuesSchema,
-  provider: reviewModeSchema,
-  expectedRelease: identifier.nullable().optional(),
-  settingRenames: z15.record(z15.string(), z15.string()).optional()
-}).strict();
-var batchReleaseSchema = z15.object({ releases: z15.array(releaseSchema).min(1).max(50) }).strict();
-var questSettingsInputSchema = z15.object({
-  quest: identifier,
-  expectedRelease: identifier,
-  set: settingsValuesSchema,
-  reset: z15.array(z15.string())
-}).strict();
-var storedReleaseSchema = questDescriptionSchema.extend({
-  key: identifier.optional(),
-  code: z15.string(),
-  provider: storedReviewModeSchema,
-  id: identifier,
-  createdAt: z15.number(),
-  legacy: z15.boolean().default(false),
-  origin: z15.object({ typeVersion: identifier }).strict().optional(),
-  lifecycle: z15.enum(["active", "paused", "archived"]).default("active"),
-  configuration: z15.object({
-    defaults: settingsValuesSchema,
-    overrides: settingsValuesSchema,
-    preserved: z15.array(z15.string())
-  }).strict().optional()
-});
-var legacyReleaseSchema = z15.object({
-  quest: identifier,
-  title: z15.string(),
-  criteria: z15.string(),
-  humanReview: z15.boolean(),
-  rewards: rewardBundleSchema,
-  code: z15.string(),
-  provider: storedReviewModeSchema,
-  id: identifier,
-  createdAt: z15.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 = z15.union([
-  storedReleaseSchema,
-  legacyReleaseSchema
-]);
-var templateSchema = z15.object({
-  code: z15.string(),
-  definition: questDescriptionSchema
-});
-var quizAnswersSchema = z15.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 = z15.object({
-  kind: z15.literal("quiz"),
-  release: identifier.optional(),
-  answers: quizAnswersSchema
-}).strict();
-var submissionEvidenceSchema = z15.union([
-  quizEvidenceSchema,
-  textEvidenceSchema,
-  urlEvidenceSchema
-]);
-var submitSchema = z15.object({
-  actionId: identifier,
-  quest: identifier,
-  member: identifier,
-  evidence: identifier.optional(),
-  input: submissionEvidenceSchema.optional(),
-  release: identifier.optional(),
-  faultAfterReview: z15.boolean().optional()
-}).strict();
-var attemptSchema = z15.object({
-  id: identifier,
-  release: identifier,
-  quest: identifier,
-  member: identifier,
-  evidence: identifier.nullable(),
-  input: submissionEvidenceSchema.optional(),
-  status: z15.enum([
-    "queued",
-    "evaluating",
-    "accepted",
-    "progressed",
-    "rejected",
-    "needs-review",
-    "failed"
-  ]),
-  reason: z15.string().nullable(),
-  retries: z15.number(),
-  generation: z15.number(),
-  completion: z15.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: z15.boolean().default(false),
-  createdAt: z15.number()
-});
-var eventSchema = z15.object({
-  id: z15.number(),
-  attempt: z15.string().nullable(),
-  kind: z15.string(),
-  detail: z15.string(),
-  actor: z15.string().nullable().default(null),
-  at: z15.number()
-});
-var pickupSelectionSchema = z15.object({
-  item: identifier,
-  revision: z15.number().int().nonnegative()
-}).strict();
-var pickupAllocationSchema = z15.object({
-  item: identifier,
-  label: z15.string().min(1).max(80)
-}).strict();
-var pickupPolicySchema = z15.discriminatedUnion("kind", [
-  z15.object({ kind: z15.literal("untracked") }).strict(),
-  z15.object({
-    kind: z15.literal("at-pickup"),
-    tiers: z15.array(
-      z15.object({
-        tier: identifier,
-        variants: z15.array(pickupAllocationSchema).min(1).max(100)
-      }).strict()
-    ).min(1).max(100)
-  }).strict()
-]);
-var pickupCatalogSchema = z15.object({
-  reward: tieredRewardDefinitionSchema,
-  revision: z15.number().int().nonnegative(),
-  policy: pickupPolicySchema
-});
-var pickupAvailabilitySchema = z15.discriminatedUnion("kind", [
-  z15.object({ kind: z15.literal("untracked") }).strict(),
-  z15.object({
-    kind: z15.literal("at-pickup"),
-    revision: z15.number().int().nonnegative(),
-    variants: z15.array(
-      pickupAllocationSchema.extend({
-        available: z15.number().int().nonnegative()
-      })
-    )
-  }).strict()
-]);
-var configurePickupSchema = z15.object({
-  reward: identifier,
-  revision: z15.number().int().nonnegative(),
-  actionId: identifier,
-  policy: z15.discriminatedUnion("kind", [
-    z15.object({ kind: z15.literal("untracked") }).strict(),
-    z15.object({
-      kind: z15.literal("at-pickup"),
-      tiers: z15.array(
-        z15.object({
-          tier: identifier,
-          variants: z15.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: z15.number().int().positive()
-};
-var entitlementSchema = z15.discriminatedUnion("status", [
-  z15.object({ ...entitlementBase, status: z15.literal("available") }).strict(),
-  z15.object({
-    ...entitlementBase,
-    status: z15.literal("handing-over"),
-    handover: identifier,
-    startedAt: z15.number(),
-    allocation: pickupAllocationSchema.optional()
-  }).strict(),
-  z15.object({
-    ...entitlementBase,
-    status: z15.literal("collected"),
-    handover: identifier,
-    startedAt: z15.number(),
-    allocation: pickupAllocationSchema.optional(),
-    collectedAt: z15.number()
-  }).strict()
-]);
-var beginHandoverSchema = z15.object({
-  actionId: identifier,
-  revision: z15.number().int().positive(),
-  selection: pickupSelectionSchema.optional()
-}).strict();
-var confirmHandoverSchema = z15.object({ actionId: identifier, handover: identifier }).strict();
-var completionRecordSchema = z15.object({
-  key: z15.string().default("once"),
-  id: identifier,
-  quest: identifier,
-  member: identifier
-});
-var questAvailabilitySchema = z15.discriminatedUnion("kind", [
-  z15.object({
-    kind: z15.literal("available"),
-    input: z15.enum(["photo", "quiz", "none", "text", "url"])
-  }).strict(),
-  z15.object({ kind: z15.literal("completed") }).strict(),
-  z15.object({
-    kind: z15.literal("locked"),
-    missing: z15.array(z15.object({ quest: identifier, title: z15.string() })).min(1)
-  }).strict(),
-  z15.object({ kind: z15.literal("staff-required") }).strict(),
-  z15.object({
-    kind: z15.literal("automatic"),
-    observation: observationTriggerSchema.optional()
-  }).strict(),
-  z15.object({ kind: z15.literal("checking"), attempt: identifier }).strict(),
-  z15.object({ kind: z15.literal("needs-review"), attempt: identifier }).strict(),
-  z15.object({ kind: z15.literal("retryable"), attempt: identifier }).strict()
-]);
-var memberProgressSchema = z15.object({
-  member: identifier,
-  quests: z15.array(
-    z15.object({
-      quest: identifier,
-      key: identifier.optional(),
-      release: identifier.optional(),
-      title: z15.string(),
-      presentation: questPresentationSchema.default({}),
-      connections: z15.array(authProviderSchema).default([]),
-      trigger: triggerSchema,
-      availability: questAvailabilitySchema,
-      completed: z15.boolean(),
-      completion: completionPolicySchema.default({ kind: "once" }),
-      streak: streakProgressSchema.nullable().optional(),
-      completionCount: z15.number().int().nonnegative().default(0),
-      visibility: z15.enum(["visible", "hidden"]).default("visible"),
-      missing: z15.array(z15.object({ quest: identifier, title: z15.string() })),
-      attempt: attemptSchema.nullable()
-    })
-  ),
-  entitlements: z15.array(entitlementSchema)
-});
-var snapshotSchema = z15.object({
-  releases: z15.array(publishedReleaseSchema),
-  completions: z15.array(completionRecordSchema),
-  entitlements: z15.array(entitlementSchema),
-  attempts: z15.array(attemptSchema),
-  balances: z15.array(
-    z15.object({
-      member: z15.string(),
-      balance: z15.string(),
-      earned: z15.number(),
-      held: z15.number(),
-      available: z15.number()
-    })
-  ),
-  events: z15.array(eventSchema)
-});
-var evidenceSchema = z15.object({
-  id: identifier,
-  member: identifier,
-  type: z15.enum(["image/jpeg", "image/png"]),
-  size: z15.number()
-});
-var errorSchema = z15.object({
-  error: z15.string(),
-  code: z15.string().optional(),
-  missing: z15.array(z15.object({ quest: identifier, title: z15.string() })).optional()
-});
-var staffDecisionSchema = z15.object({
-  actionId: identifier,
-  generation: z15.number().int().nonnegative(),
-  decision: z15.enum(["accept", "reject"]),
-  reason: z15.string().trim().min(1).max(2e3)
-}).strict();
-var stockSchema = z15.object({ item: identifier, quantity: z15.number().int().min(0).max(1e4) }).strict();
-var reservationSchema = z15.object({
-  actionId: identifier,
-  member: identifier,
-  item: identifier,
-  balance: identifier,
-  price: z15.number().int().positive().max(1e4)
-}).strict();
-var pageOptions = {
-  limit: z15.number().int().min(1).max(100).default(25),
-  cursor: z15.string().min(1).max(4096).optional()
-};
-var reviewListSchema = z15.object({
-  ...pageOptions,
-  member: identifier.optional(),
-  quest: identifier.optional()
-}).strict();
-var memberListSchema = z15.object({
-  ...pageOptions,
-  prefix: identifier.optional()
-}).strict();
-var reviewItemSchema = z15.object({
-  attempt: attemptSchema,
-  title: z15.string(),
-  checks: z15.array(
-    z15.object({ criteria: z15.string(), result: photoResultSchema })
-  )
-});
-var reviewPageSchema = z15.object({
-  items: z15.array(reviewItemSchema).max(100),
-  nextCursor: z15.string().nullable()
-});
-var memberPageSchema = z15.object({
-  items: z15.array(z15.object({ member: identifier })).max(100),
-  nextCursor: z15.string().nullable()
-});
-var createStockItemSchema = z15.object({ actionId: identifier, name: z15.string().trim().min(1).max(80) }).strict();
-var stockItemSchema = z15.object({ id: identifier, name: z15.string() });
-var contentPerformanceSnapshotSchema = z15.strictObject({
-  contentAttempt: identifier,
-  observation: identifier,
-  observedAt: z15.number().int().safe().nonnegative(),
-  metrics: contentMetricsSchema,
-  rewards: rewardBundleSchema
-});
-var contentPerformanceQuerySchema = contentQualificationQuerySchema.extend({
-  content: z15.string().min(1).max(256)
-});
-var contentPerformancePageSchema = z15.strictObject({
-  current: z15.strictObject({
-    state: z15.enum([
-      "content-pending",
-      "content-unqualified",
-      "waiting",
-      "pending",
-      "qualified",
-      "unqualified",
-      "needs-review",
-      "failed",
-      "superseded"
-    ]),
-    reason: z15.string().nullable(),
-    contentAttempt: identifier,
-    attempt: identifier.nullable(),
-    reward: contentQualificationSchema.shape.reward
-  }),
-  items: z15.array(
-    z15.strictObject({
-      attempt: identifier,
-      contentAttempt: identifier,
-      observation: identifier,
-      observedAt: z15.number(),
-      metrics: contentMetricsSchema,
-      state: z15.enum([
-        "pending",
-        "qualified",
-        "unqualified",
-        "needs-review",
-        "failed",
-        "superseded"
-      ]),
-      reason: z15.string().nullable()
-    })
-  ),
-  nextCursor: pageCursorSchema.nullable()
-});
-
-export {
-  authProviderSchema,
-  accountConnectionSchema,
-  discordMemberInputSchema,
-  discordMessageInputSchema,
-  discordMemberSchema,
-  identifier,
-  pageCursorSchema,
-  pageQuerySchema,
-  xTweetSchema,
-  xContentBodySchema,
-  trackerContentQuerySchema,
-  trackerContentReadSchema,
-  trackerEvidenceSchema,
-  trackerContentSchema,
-  identityKindSchema,
-  accountRoleSchema,
-  xAccountRoles,
-  xSearchSourceSchema,
-  customSourceSchema,
-  trackerSourceSchema,
-  sourceIdentities,
-  trackerDefinitionSchema,
-  trackerArtifactSchema,
-  publishedTrackerSchema,
-  trackerStatusSchema,
-  trackerControlSchema,
-  trackerAccountSchema,
-  trackerRecordInputSchema,
-  trackerRecordSchema,
-  trackerIngestSchema,
-  trackerIngestResultSchema,
-  trackerSkipCodes,
-  trackerOutcomeSchema,
-  trackerOutcomeQuerySchema,
-  trackerOutcomePageSchema,
-  trackerOutcomeRetrySchema,
-  trackerQuerySchema,
-  trackerPageSchema,
-  trackerSummarySchema,
-  trackerPreviewLimits,
-  trackerPreviewInputSchema,
-  trackerPreviewSchema,
-  contentPolicySchema,
-  admittedContentSchema,
-  contentEnrollmentInputSchema,
-  contentEnrollmentSchema,
-  contentReleaseInputSchema,
-  contentAdmissionSchema,
-  contentAdmissionQuerySchema,
-  contentAdmissionPageSchema,
-  contentQualificationDecisionSchema,
-  contentQualificationQuerySchema,
-  contentQualificationSchema,
-  contentQualificationPageSchema,
-  contentMetricSchema,
-  contentMetricsSchema,
-  contentPerformancePolicySchema,
-  communityTimeZoneSchema,
-  streakPolicySchema,
-  streakProgressSchema,
-  trackerTriggerModeSchema,
-  defaultTriggerMode,
-  trackerBoundSchema,
-  trackerWhereSchema,
-  trackerTriggerPolicySchema,
-  triggerMode,
-  beneficiaryRole,
-  trackerAttributionSchema,
-  trackerTriggerRecordSchema,
-  trackerTriggerContextSchema,
-  observationInputSchema,
-  observationSchema,
-  observationTriggerSchema,
-  completionPolicySchema,
-  completionKeySchema,
-  budgetSchema,
-  observationReceiptSchema,
-  discordReactionSchema,
-  discordMessageSchema,
-  integrationProviderSchema,
-  discordServerSchema,
-  projectIntegrationSchema,
-  textOptionsSchema,
-  urlOptionsSchema,
-  textEvidenceSchema,
-  urlEvidenceSchema,
-  valueEvidenceSchema,
-  validateSubmissionValue,
-  xPostId,
-  quizChoiceSchema,
-  quizQuestionSchema,
-  quizQuestionsSchema,
-  quizContentSchema,
-  resourceSourceSchema,
-  resourceRequestSchema,
-  resourceOptionsSchema,
-  settingInstant,
-  settingResourceId,
-  settingFieldSchema,
-  settingsFieldsSchema,
-  settingsValuesSchema,
-  parseSettings,
-  missingResourceSettings,
-  compatibleSettingKinds,
-  pointsRewardSchema,
-  tieredRewardDefinitionSchema,
-  tieredRewardReferenceSchema,
-  tierRewardSchema,
-  integrationRewardSchema,
-  rewardSchema,
-  rewardKey,
-  triggerSchema,
-  prerequisiteSchema,
-  photoResultSchema,
-  textReviewInputSchema,
-  textResultSchema,
-  decisionSchema,
-  reviewModeSchema,
-  storedReviewModeSchema,
-  rewardBundleSchema,
-  mediaUrlSchema,
-  questPresentationSchema,
-  questProfileSchema,
-  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
-};