@domino-sdk/relay 1.0.0-next.2 → 1.0.0-next.34

package/dist/chunk-NKGJEYZM.js

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