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

package/dist/chunk-6QJ3LADK.js

@@ -0,0 +1,112 @@
+import {
+  isRequestError
+} from "./chunk-NPGENI7K.js";
+
+// src/request-lifetime.ts
+var PARTICIPANT_TIMEOUT = 15e3;
+var MANAGEMENT_TIMEOUT = 3e4;
+var MAX_ATTEMPTS = 3;
+var transientStatuses = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+function validTimeout(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function lifetime(timeout, caller) {
+  const deadline = new AbortController();
+  const expiresAt = Date.now() + timeout;
+  const timer = setTimeout(
+    () => deadline.abort(
+      new DOMException(`No answer within ${timeout} ms`, "TimeoutError")
+    ),
+    timeout
+  );
+  const signal = caller ? AbortSignal.any([caller, deadline.signal]) : deadline.signal;
+  return {
+    signal,
+    timeout,
+    ended: () => caller?.aborted ? "aborted" : deadline.signal.aborted ? "timeout" : void 0,
+    remaining: () => Math.max(0, expiresAt - Date.now()),
+    reason: () => caller?.aborted ? caller.reason : deadline.signal.reason,
+    end: () => clearTimeout(timer)
+  };
+}
+function retryAfter(headers, now = Date.now()) {
+  const value = headers.get("Retry-After")?.trim();
+  if (!value) {
+    return void 0;
+  }
+  if (/^\d+$/.test(value)) {
+    return Number(value) * 1e3;
+  }
+  const date = Date.parse(value);
+  return Number.isNaN(date) ? void 0 : Math.max(0, date - now);
+}
+function backoff(retry) {
+  return Math.round(250 * 4 ** (retry - 1) * (0.5 + Math.random() / 2));
+}
+function retryDelay(failure, context) {
+  const transient = failure.kind === "network" && (failure.status === void 0 || failure.status < 400) || (failure.kind === "http" || failure.kind === "network") && transientStatuses.has(failure.status ?? 0) && // Domino's rate limits run for minutes or hours: a 429 waits only when told how long.
+  (failure.status !== 429 || failure.retryAfter !== void 0);
+  if (!transient || !context.replaySafe || context.attempt >= MAX_ATTEMPTS) {
+    return void 0;
+  }
+  const wait = failure.retryAfter ?? backoff(context.attempt);
+  return wait < context.remaining ? wait : void 0;
+}
+function pause(ms, signal) {
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
+async function retrying(life, rules, attempt) {
+  const describe = rules.describe ?? describeRequestError;
+  const uncertain = rules.uncertain ?? markUncertain;
+  let earlierUncertain = false;
+  for (let number = 1; ; number++) {
+    try {
+      return await attempt();
+    } catch (error) {
+      const failure = describe(error);
+      const wait = failure && !life.ended() ? retryDelay(failure, {
+        attempt: number,
+        replaySafe: rules.replaySafe,
+        remaining: life.remaining()
+      }) : void 0;
+      if (wait === void 0) {
+        throw earlierUncertain && !failure?.uncertain ? uncertain(error) : error;
+      }
+      earlierUncertain ||= failure?.uncertain ?? false;
+      await pause(wait, life.signal);
+    }
+  }
+}
+function describeRequestError(error) {
+  return isRequestError(error) ? {
+    kind: error.kind,
+    status: error.status,
+    uncertain: error.uncertain,
+    retryAfter: error.retryAfter
+  } : void 0;
+}
+function markUncertain(error) {
+  if (isRequestError(error)) {
+    const target = error;
+    target.uncertain = true;
+    target.recovery = error.operationId ? "replay" : "reconcile";
+  }
+  return error;
+}
+
+export {
+  PARTICIPANT_TIMEOUT,
+  MANAGEMENT_TIMEOUT,
+  validTimeout,
+  lifetime,
+  retryAfter,
+  retrying
+};

package/dist/{chunk-77H7APVD.js → chunk-BGGKNIRP.js}

@@ -1,7 +1,7 @@
 import {
   identifier,
   xTweetSchema
-} from "./chunk-VARGF4JS.js";
+} from "./chunk-JON5SESL.js";
 
 // src/x.ts
 import { z } from "zod";

package/dist/chunk-EYH5RDIE.js

@@ -0,0 +1,496 @@
+import {
+  pointLedgerReferenceSchema
+} from "./chunk-36HTX2BM.js";
+import {
+  authoringIdentityShape,
+  entitlementSchema,
+  identifier,
+  memberProgressSchema,
+  pageCursorSchema,
+  pickupAvailabilitySchema,
+  pickupSelectionSchema,
+  prerequisiteSchema,
+  publishedReleaseSchema,
+  reviewModeSchema,
+  settingsValuesSchema,
+  storedQuestDescriptionSchema,
+  storedReviewModeSchema,
+  tieredRewardReferenceSchema
+} from "./chunk-JON5SESL.js";
+
+// src/participant-activity.ts
+import { z } from "zod";
+var base = { id: z.string(), at: z.number() };
+var attempt = {
+  ...base,
+  quest: z.string(),
+  attempt: z.string(),
+  completion: z.string().nullable()
+};
+var kinds = [
+  "attempt.accepted",
+  "attempt.rejected",
+  "attempt.review",
+  "points.awarded",
+  "entitlement.granted",
+  "entitlement.collected",
+  "delivery.updated",
+  "referral.qualified"
+];
+var knownRelayEventSchema = z.discriminatedUnion("kind", [
+  z.object({ ...attempt, kind: z.literal("attempt.accepted") }),
+  z.object({ ...attempt, kind: z.literal("attempt.rejected") }),
+  z.object({ ...attempt, kind: z.literal("attempt.review") }),
+  z.object({
+    ...base,
+    kind: z.literal("points.awarded"),
+    entry: z.string(),
+    ledger: z.string(),
+    amount: z.number(),
+    quest: z.string().nullable(),
+    completion: z.string().nullable()
+  }),
+  z.object({
+    ...base,
+    kind: z.literal("entitlement.granted"),
+    entitlement: z.string(),
+    tier: z.string(),
+    status: z.string()
+  }),
+  z.object({
+    ...base,
+    kind: z.literal("entitlement.collected"),
+    entitlement: z.string()
+  }),
+  z.object({
+    ...base,
+    kind: z.literal("delivery.updated"),
+    delivery: z.string(),
+    quest: z.string(),
+    completion: z.string(),
+    status: z.string()
+  }),
+  z.object({
+    ...base,
+    kind: z.literal("referral.qualified"),
+    program: z.string()
+  })
+]);
+var relayEventSchema = z.union([
+  knownRelayEventSchema,
+  z.object({
+    ...base,
+    kind: z.string().refine((kind) => !kinds.includes(kind))
+  }).catchall(z.json()).transform(({ kind, ...event }) => ({
+    ...event,
+    kind: "unknown",
+    reportedKind: kind
+  }))
+]);
+var participantActivityQuerySchema = z.object({
+  cursor: pageCursorSchema.optional(),
+  limit: z.number().int().min(1).max(100).default(50)
+}).strict();
+var participantActivitySchema = z.object({
+  member: z.string(),
+  items: z.array(relayEventSchema),
+  nextCursor: pageCursorSchema
+});
+
+// src/catalog.ts
+import { z as z2 } from "zod";
+var interactionSchema = z2.enum([
+  "photo",
+  "text",
+  "url",
+  "quiz",
+  "claim",
+  "staff",
+  "automatic"
+]);
+function questInteraction(trigger) {
+  return trigger.kind === "automatic" ? "automatic" : trigger.actor === "staff" ? "staff" : trigger.input === "none" ? "claim" : trigger.input;
+}
+var questTypeVersionSchema = z2.object({
+  archivedAt: z2.number().int().nonnegative().nullable().optional(),
+  key: identifier.optional(),
+  id: identifier,
+  version: identifier,
+  code: z2.string(),
+  definition: storedQuestDescriptionSchema,
+  provider: storedReviewModeSchema,
+  createdAt: z2.number()
+});
+var collectionSlotSchema = z2.object({
+  archivedAt: z2.number().int().nonnegative().nullable().optional(),
+  id: identifier,
+  key: identifier.optional(),
+  title: z2.string().trim().min(1).max(120)
+}).strict();
+var collectionSlotDeclarationSchema = collectionSlotSchema.omit({ id: true, archivedAt: true }).extend(authoringIdentityShape).strict();
+var questCollectionSchema = collectionSlotSchema.extend({
+  quests: z2.array(identifier).max(100).refine(
+    (v) => new Set(v).size === v.length,
+    "A collection can contain a quest only once"
+  )
+});
+var questInstanceSchema = z2.object({
+  id: identifier,
+  title: z2.string().trim().min(1).max(120),
+  typeVersion: identifier,
+  settings: settingsValuesSchema,
+  requires: z2.array(prerequisiteSchema).max(30),
+  status: z2.enum(["active", "paused", "archived"])
+}).strict();
+var questDraftChangesSchema = z2.object({
+  quests: z2.array(
+    questInstanceSchema.extend({ expectedRelease: identifier.nullable() })
+  ).max(50),
+  collections: z2.array(questCollectionSchema.omit({ archivedAt: true })).max(50)
+}).strict();
+var draftBase = z2.object({
+  id: identifier,
+  revision: z2.number().int().positive(),
+  baseRevision: z2.number().int().nonnegative(),
+  changes: questDraftChangesSchema
+});
+var questDraftSchema = z2.discriminatedUnion("status", [
+  draftBase.extend({ status: z2.literal("draft") }),
+  draftBase.extend({
+    status: z2.literal("published"),
+    releaseIds: z2.array(identifier)
+  })
+]);
+var questCatalogSchema = z2.object({
+  revision: z2.number().int().nonnegative(),
+  types: z2.array(questTypeVersionSchema),
+  collections: z2.array(questCollectionSchema),
+  quests: z2.array(questInstanceSchema),
+  drafts: z2.array(questDraftSchema),
+  releases: z2.array(publishedReleaseSchema).default([]),
+  supportedInteractions: z2.array(interactionSchema)
+});
+var catalogDeploymentSchema = z2.object({
+  expectedRevision: z2.number().int().nonnegative(),
+  types: z2.array(
+    z2.object({
+      code: z2.string().min(1).max(1e6),
+      provider: reviewModeSchema
+    })
+  ).max(50).default([]),
+  collections: z2.array(collectionSlotDeclarationSchema).max(50).default([]),
+  supportedInteractions: z2.array(interactionSchema).min(1).optional()
+}).strict();
+var catalogDeploymentPreviewSchema = z2.object({
+  revision: z2.number().int().nonnegative(),
+  types: z2.array(questTypeVersionSchema),
+  collections: z2.array(collectionSlotSchema),
+  supportedInteractions: z2.array(interactionSchema)
+});
+var saveQuestDraftSchema = z2.object({
+  id: identifier.optional(),
+  actionId: identifier,
+  expectedRevision: z2.number().int().nonnegative(),
+  baseRevision: z2.number().int().nonnegative(),
+  changes: questDraftChangesSchema
+}).strict();
+var publishQuestDraftSchema = z2.object({ id: identifier, expectedRevision: z2.number().int().positive() }).strict();
+var questRewardViewSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("points"),
+    label: z2.string(),
+    amount: z2.number().int().nonnegative(),
+    ledger: pointLedgerReferenceSchema
+  }),
+  z2.object({
+    kind: z2.literal("tier"),
+    label: z2.string(),
+    reward: tieredRewardReferenceSchema.extend({ title: z2.string() }),
+    tier: identifier
+  }),
+  z2.object({ kind: z2.literal("integration"), label: z2.string() })
+]);
+var questViewSchema = memberProgressSchema.shape.quests.element.extend(
+  {
+    release: identifier,
+    interaction: interactionSchema,
+    lifecycle: z2.enum(["active", "paused", "archived"]),
+    rewards: z2.array(questRewardViewSchema)
+  }
+);
+var collectionViewSchema = z2.object({
+  key: identifier.optional(),
+  id: identifier,
+  title: z2.string(),
+  quests: z2.array(questViewSchema)
+});
+var questExperienceSchema = z2.object({
+  entitlements: z2.array(entitlementSchema).default([]),
+  member: identifier,
+  quests: z2.array(questViewSchema),
+  collections: z2.array(collectionViewSchema)
+});
+var questPublicationPreviewSchema = z2.object({
+  draft: questDraftSchema,
+  releases: z2.array(publishedReleaseSchema),
+  affectedCollections: z2.array(questCollectionSchema)
+});
+var allocateQuestSchema = z2.object({ actionId: identifier }).strict();
+var allocatedQuestSchema = z2.object({ id: identifier });
+
+// src/collection.ts
+import { z as z3 } from "zod";
+var collectionCodeSchema = z3.string().regex(/^relay:collect:[a-f0-9]{64}$/);
+var collectionPassSchema = z3.object({
+  code: collectionCodeSchema,
+  expiresAt: z3.number(),
+  entitlement: identifier
+});
+var collectionResolveSchema = z3.object({ code: collectionCodeSchema }).strict();
+var collectionBeginSchema = collectionResolveSchema.extend({
+  actionId: identifier,
+  revision: z3.number().int().positive(),
+  selection: pickupSelectionSchema.optional()
+});
+var collectionPreviewSchema = z3.object({
+  entitlement: entitlementSchema,
+  inventory: pickupAvailabilitySchema,
+  expiresAt: z3.number()
+});
+
+// src/outcomes.ts
+import { z as z4 } from "zod";
+var timestamp = z4.number().int().safe().nonnegative();
+var questEnrollmentInputSchema = z4.strictObject({
+  actionId: identifier,
+  /** Quest key or ID. */
+  quest: identifier
+});
+var memberEnrollmentInputSchema = questEnrollmentInputSchema.extend({
+  member: identifier
+});
+var questEnrollmentSchema = z4.object({
+  /** Stable quest ID. */
+  quest: identifier,
+  member: identifier,
+  enrolledAt: timestamp
+});
+var questClaimInputSchema = z4.strictObject({
+  actionId: identifier,
+  /** Quest key or ID. */
+  quest: identifier,
+  /** The outcome's tracker, as `QuestOutcome.tracker` names it. */
+  tracker: identifier,
+  record: z4.string().min(1).max(256),
+  observedAt: timestamp
+});
+var QuestOutcomeState = {
+  Admitted: "admitted",
+  Skipped: "skipped"
+};
+var questOutcomeSchema = z4.object({
+  /** Prerequisite transition identity; absent on older tracker responses. */
+  automatic: identifier.optional(),
+  /** Stable quest ID. */
+  quest: identifier,
+  /** Stable tracker ID of the record decided. */
+  tracker: identifier.nullable(),
+  /** The record's ID in its tracker. */
+  record: z4.string().nullable(),
+  /** Which observation of the record was decided. */
+  observedAt: timestamp.nullable(),
+  state: z4.enum(["admitted", "skipped"]),
+  /**
+   * Why it was skipped, one of `trackerSkipCodes` or a code a newer Relay sends; null when
+   * admitted. Show an unknown code by its `reason`.
+   */
+  code: z4.string().nullable(),
+  /** Why it was skipped, for people; null when admitted. */
+  reason: z4.string().nullable(),
+  /** The admitted attempt. */
+  attempt: identifier.nullable(),
+  /** The member can claim it with `relay.quests.claim()`. */
+  claimable: z4.boolean(),
+  createdAt: timestamp,
+  updatedAt: timestamp
+});
+var questOutcomeQuerySchema = z4.strictObject({
+  /** Quest key or ID. */
+  quest: identifier.optional(),
+  state: z4.enum(["admitted", "skipped"]).optional(),
+  /** Only skips with this code, such as `historical`. */
+  code: z4.string().min(1).max(100).optional(),
+  cursor: pageCursorSchema.optional()
+});
+var questOutcomePageSchema = z4.object({
+  items: z4.array(questOutcomeSchema),
+  nextCursor: pageCursorSchema.nullable()
+});
+
+// src/participant-rewards.ts
+import { z as z5 } from "zod";
+var participantEntitlementsSchema = z5.object({
+  items: z5.array(entitlementSchema)
+});
+var base2 = {
+  id: z5.string(),
+  status: z5.string(),
+  at: z5.number().nullable(),
+  quest: z5.string().nullable(),
+  completion: z5.string().nullable()
+};
+var known = z5.discriminatedUnion("kind", [
+  z5.object({
+    ...base2,
+    kind: z5.literal("points"),
+    ledger: pointLedgerReferenceSchema,
+    amount: z5.number(),
+    reversed: z5.number()
+  }).catchall(z5.json()),
+  z5.object({
+    ...base2,
+    kind: z5.literal("tier"),
+    entitlement: entitlementSchema
+  }).catchall(z5.json().transform((value) => value)),
+  z5.object({
+    ...base2,
+    kind: z5.literal("integration"),
+    provider: z5.string(),
+    action: z5.string(),
+    roleId: z5.string().optional(),
+    deliveredAt: z5.number().nullable(),
+    revokedAt: z5.number().nullable(),
+    reconciliation: z5.object({ status: z5.string(), ownership: z5.string(), at: z5.number() }).catchall(z5.json()).nullable()
+  }).catchall(z5.json().optional())
+]);
+var participantDeliverySchema = z5.union([
+  known,
+  z5.object({
+    ...base2,
+    kind: z5.string().refine((kind) => !["points", "tier", "integration"].includes(kind))
+  }).catchall(z5.json()).transform(({ kind, ...item }) => ({
+    ...item,
+    kind: "unknown",
+    reportedKind: kind
+  }))
+]);
+var participantDeliveriesSchema = z5.object({
+  items: z5.array(participantDeliverySchema)
+});
+
+// src/reward-deliveries.ts
+import { z as z6 } from "zod";
+var RewardDeliveryAction = {
+  /** Delivers a quest's Discord role reward. */
+  GrantRole: "grant-role"
+};
+var rewardDeliveryActionSchema = z6.string().min(1).max(64);
+var roleReconciliationSchema = z6.object({
+  status: z6.enum(["pending", "granted", "removed", "preserved", "failed"]),
+  ownership: z6.enum(["unclaimed", "relay", "external"]),
+  at: z6.number(),
+  reason: z6.string().nullable()
+});
+var knownRewardDeliverySchema = z6.object({
+  id: z6.string(),
+  quest: z6.string(),
+  completion: z6.string(),
+  member: z6.string(),
+  provider: z6.literal("discord"),
+  /** `RewardDeliveryAction`, such as `grant-role`. */
+  action: rewardDeliveryActionSchema,
+  roleId: z6.string(),
+  /**
+   * `failed` is terminal: Discord rejected the grant permanently (unknown role,
+   * member left the server, missing permissions) or retries ran out after about
+   * a day. An operator can retry it once the cause is fixed, unless revokedAt is set.
+   * Revoke stops pending grants; a late success records deliveredAt but leaves status failed.
+   */
+  status: z6.enum(["pending", "delivered", "failed"]),
+  /** Provider attempts in the current round; an operator retry starts a new round at zero. */
+  attempts: z6.number().int(),
+  /** While pending with a `lastError`, when the next attempt is scheduled. */
+  nextAt: z6.number(),
+  lastError: z6.string().nullable(),
+  createdAt: z6.number(),
+  deliveredAt: z6.number().nullable(),
+  /** First dispatch attempt, retained across retries. Legacy rows use creation time when dispatch timing is unknown. */
+  dispatchedAt: z6.number().nullable().optional(),
+  /** Completion revocation stops retries, including deliveries that had already failed. */
+  revokedAt: z6.number().nullable().optional(),
+  /** Current reconciliation of the pinned Discord membership; original delivery and revoke history stay intact. */
+  reconciliation: roleReconciliationSchema.nullable().optional()
+});
+var futureRewardDeliverySchema = knownRewardDeliverySchema.extend({
+  provider: z6.string(),
+  status: z6.string(),
+  roleId: z6.string().optional(),
+  reconciliation: z6.object({
+    status: z6.string(),
+    ownership: z6.string(),
+    at: z6.number(),
+    reason: z6.string().nullable()
+  }).catchall(z6.json()).nullable().optional()
+}).catchall(z6.json().optional()).refine(
+  (delivery) => delivery.provider !== "discord" || !["pending", "delivered", "failed"].includes(delivery.status) || delivery.reconciliation && (!["pending", "granted", "removed", "preserved", "failed"].includes(
+    delivery.reconciliation.status
+  ) || !["unclaimed", "relay", "external"].includes(
+    delivery.reconciliation.ownership
+  ))
+);
+var rewardDeliverySchema = z6.union([
+  knownRewardDeliverySchema.catchall(z6.json().optional()),
+  futureRewardDeliverySchema
+]);
+var rewardDeliveriesSchema = z6.object({
+  deliveries: z6.array(rewardDeliverySchema)
+});
+
+export {
+  knownRelayEventSchema,
+  relayEventSchema,
+  participantActivityQuerySchema,
+  participantActivitySchema,
+  interactionSchema,
+  questInteraction,
+  questTypeVersionSchema,
+  collectionSlotSchema,
+  collectionSlotDeclarationSchema,
+  questCollectionSchema,
+  questInstanceSchema,
+  questDraftChangesSchema,
+  questDraftSchema,
+  questCatalogSchema,
+  catalogDeploymentSchema,
+  catalogDeploymentPreviewSchema,
+  saveQuestDraftSchema,
+  publishQuestDraftSchema,
+  questRewardViewSchema,
+  questViewSchema,
+  collectionViewSchema,
+  questExperienceSchema,
+  questPublicationPreviewSchema,
+  allocateQuestSchema,
+  allocatedQuestSchema,
+  collectionCodeSchema,
+  collectionPassSchema,
+  collectionResolveSchema,
+  collectionBeginSchema,
+  collectionPreviewSchema,
+  questEnrollmentInputSchema,
+  memberEnrollmentInputSchema,
+  questEnrollmentSchema,
+  questClaimInputSchema,
+  QuestOutcomeState,
+  questOutcomeSchema,
+  questOutcomeQuerySchema,
+  questOutcomePageSchema,
+  participantEntitlementsSchema,
+  participantDeliverySchema,
+  participantDeliveriesSchema,
+  RewardDeliveryAction,
+  roleReconciliationSchema,
+  knownRewardDeliverySchema,
+  rewardDeliverySchema,
+  rewardDeliveriesSchema
+};

package/dist/chunk-GQKYAQM6.js

@@ -0,0 +1,84 @@
+import {
+  discordMessageDataSchema,
+  discordMessageTextDataSchema,
+  discordReactionDataSchema,
+  isKnownTrackerSource,
+  trackerDataSchema,
+  xAccountRoles
+} from "./chunk-JON5SESL.js";
+
+// src/quest-shape.ts
+function validateQuestShape(description, options = {}) {
+  const { trigger, completion, requires, performance } = description;
+  const tracker = trigger.kind === "automatic" ? trigger.tracker : void 0;
+  const content = tracker?.content === true;
+  if (performance && !content) {
+    throw new Error("Performance requires a content quest");
+  }
+  if (content) {
+    if (completion.kind !== "keyed") {
+      throw new Error("Content quests complete once per content item");
+    }
+    if (tracker.beneficiary !== "author" || tracker.on !== "new-record") {
+      throw new Error(
+        "A content quest pays each content item's author and fires on its first observation"
+      );
+    }
+  }
+  if (trigger.kind === "automatic" && !tracker) {
+    if (!options.template && requires.length === 0) {
+      throw new Error("Automatic quests need at least one prerequisite");
+    }
+    if (completion.kind !== "once") {
+      throw new Error("Prerequisite-only automatic quests complete once");
+    }
+  }
+}
+
+// src/tracker-sources.ts
+var discordMessageRoles = ["author"];
+var discordReactionRoles = ["author", "messageAuthor"];
+function sourceRoles(source) {
+  if (!isKnownTrackerSource(source)) {
+    return [];
+  }
+  switch (source.kind) {
+    case "x-search":
+      return xAccountRoles;
+    case "discord-messages":
+      return discordMessageRoles;
+    case "discord-reactions":
+      return discordReactionRoles;
+    case "custom":
+      return ["author", ...source.accounts ?? []];
+  }
+}
+var discordSchemas = /* @__PURE__ */ new Map();
+function discordDataSchema(source) {
+  const key = source.kind === "discord-messages" && source.text ? "messages-text" : source.kind;
+  let schema = discordSchemas.get(key);
+  if (!schema) {
+    schema = trackerDataSchema(
+      key === "messages-text" ? discordMessageTextDataSchema : key === "discord-messages" ? discordMessageDataSchema : discordReactionDataSchema
+    );
+    discordSchemas.set(key, schema);
+  }
+  return schema;
+}
+function sourceDataSchema(source) {
+  switch (source.kind) {
+    case "x-search":
+      return void 0;
+    case "discord-messages":
+    case "discord-reactions":
+      return discordDataSchema(source);
+    case "custom":
+      return source.data;
+  }
+}
+
+export {
+  validateQuestShape,
+  sourceRoles,
+  sourceDataSchema
+};