@domino-sdk/relay 1.66.1 → 1.68.0

package/dist/chunk-4JSPMFO2.js

@@ -0,0 +1,427 @@
+import {
+  activityTypeSchema
+} from "./chunk-DNPDR4Z7.js";
+import {
+  completionRecordSchema,
+  completionSourceSchema,
+  identifier,
+  isSolanaNetwork,
+  pageCursorSchema,
+  pageLimit,
+  solanaAddressSchema,
+  solanaSignatureSchema
+} from "./chunk-6YTSRWRB.js";
+
+// src/server/webhooks.ts
+import * as z from "zod";
+var PayoutSourceKind = {
+  Quest: "quest",
+  Leaderboard: "leaderboard",
+  Engagement: "engagement",
+  Manual: "manual"
+};
+var webhookEventSchema = /* @__PURE__ */ (() => z.object({
+  id: z.string().uuid(),
+  version: z.literal(1),
+  type: activityTypeSchema,
+  createdAt: z.number().int().nonnegative(),
+  organization: z.string(),
+  project: z.string(),
+  environment: z.enum(["test", "live"]),
+  data: z.record(z.string(), z.json())
+}))();
+var walletLinkedEventDataSchema = /* @__PURE__ */ (() => z.object({
+  member: z.string(),
+  chain: z.string(),
+  network: z.string().nullable(),
+  address: z.string()
+}))();
+var webhookControlInputSchema = /* @__PURE__ */ (() => z.object({ actionId: z.string().uuid().optional() }).strict())();
+var webhookInputSchema = /* @__PURE__ */ (() => z.object({
+  url: z.url().max(2048).refine((value) => {
+    const url2 = new URL(value);
+    return url2.protocol === "https:" && !url2.username && !url2.password && !url2.hash;
+  }, "Use an HTTPS URL without credentials or a fragment"),
+  types: z.array(activityTypeSchema).min(1).max(100).refine((v) => new Set(v).size === v.length)
+}).strict())();
+var webhookCreateInputSchema = /* @__PURE__ */ (() => webhookInputSchema.extend({ actionId: z.string().uuid().optional() }).strict())();
+var webhookRotateInputSchema = /* @__PURE__ */ (() => z.object({ actionId: z.string().uuid().optional() }).strict())();
+var webhookUpdateSchema = /* @__PURE__ */ (() => webhookInputSchema.partial().extend({ enabled: z.boolean().optional() }).strict())();
+var webhookEndpointSchema = /* @__PURE__ */ (() => z.object({
+  ...webhookInputSchema.shape,
+  id: z.string().uuid(),
+  enabled: z.boolean(),
+  disabledReason: z.string().nullable(),
+  consecutiveFailures: z.number().int().nonnegative(),
+  createdAt: z.number(),
+  updatedAt: z.number()
+}))();
+var webhookEndpointStateSchema = /* @__PURE__ */ (() => webhookEndpointSchema.extend({
+  revision: z.number().int().nonnegative(),
+  deletedAt: z.number().int().safe().nonnegative().nullable()
+}))();
+var webhookDeleteInputSchema = /* @__PURE__ */ (() => z.strictObject({
+  actionId: z.string().uuid().default(() => crypto.randomUUID()),
+  expectedRevision: z.number().int().nonnegative(),
+  reason: z.string().trim().min(1).max(500)
+}))();
+var webhookStateQuerySchema = /* @__PURE__ */ (() => z.strictObject({
+  cursor: pageCursorSchema.optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(50)
+}))();
+var webhookStatePageSchema = /* @__PURE__ */ (() => z.object({
+  items: z.array(webhookEndpointStateSchema),
+  nextCursor: pageCursorSchema.nullable()
+}))();
+var webhookSecretSchema = /* @__PURE__ */ (() => z.object({
+  endpoint: webhookEndpointSchema,
+  secret: z.string(),
+  previousValidUntil: z.number().nullable()
+}))();
+var webhookDeliverySchema = /* @__PURE__ */ (() => z.object({
+  id: z.string().uuid(),
+  endpoint: z.string().uuid(),
+  event: webhookEventSchema,
+  status: z.enum(["pending", "delivered", "failed", "skipped"]),
+  attempts: z.number().int().nonnegative(),
+  responseStatus: z.number().nullable(),
+  lastError: z.string().nullable(),
+  createdAt: z.number(),
+  deliveredAt: z.number().nullable(),
+  replayOf: z.string().uuid().nullable()
+}))();
+var webhookQuerySchema = /* @__PURE__ */ (() => z.object({
+  /** A page's `nextCursor`: the deliveries after it, newest first. */
+  cursor: pageCursorSchema.optional(),
+  /** @deprecated Use `cursor`. Removed in 2.0.0. */
+  before: z.string().uuid().optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(50)
+}).strict())();
+var webhookDeliveryPageSchema = /* @__PURE__ */ (() => z.object({
+  items: z.array(webhookDeliverySchema),
+  nextCursor: pageCursorSchema.nullable().default(null),
+  /** @deprecated Use `nextCursor`, passed back as `cursor`. Removed in 2.0.0. */
+  next: z.string().uuid().nullable()
+}))();
+var WEBHOOK_MAX_BYTES = 64 * 1024;
+async function verifyWebhook(input) {
+  const bytes = new TextEncoder().encode(input.body);
+  const tolerance = input.toleranceSeconds ?? 300;
+  const now = input.now ?? Date.now();
+  if (bytes.length > WEBHOOK_MAX_BYTES || !Number.isFinite(now) || !Number.isFinite(tolerance) || tolerance < 0 || tolerance > 300) {
+    throw new Error("Invalid webhook verification input");
+  }
+  const parts = input.signature.split(",");
+  const timestamps = parts.filter((part) => part.startsWith("t="));
+  const timestamp = timestamps[0]?.slice(2) ?? "";
+  const signatures = parts.filter((part) => /^v1=[a-f0-9]{64}$/.test(part)).map((part) => part.slice(3));
+  if (timestamps.length !== 1 || !/^\d{1,12}$/.test(timestamp) || Math.abs(now / 1e3 - Number(timestamp)) > tolerance || signatures.length < 1 || signatures.length > 2) {
+    throw new Error("Invalid or expired webhook signature");
+  }
+  const secrets = typeof input.secret === "string" ? [input.secret] : input.secret;
+  const message = new TextEncoder().encode(`${timestamp}.${input.body}`);
+  for (const secret of secrets) {
+    if (!secret) {
+      continue;
+    }
+    const key = await crypto.subtle.importKey(
+      "raw",
+      new TextEncoder().encode(secret),
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["verify"]
+    );
+    for (const signature of signatures) {
+      const digest = Uint8Array.from(
+        signature.match(/../g) ?? [],
+        (byte) => Number.parseInt(byte, 16)
+      );
+      if (await crypto.subtle.verify("HMAC", key, digest, message)) {
+        return webhookEventSchema.parse(JSON.parse(input.body));
+      }
+    }
+  }
+  throw new Error("Invalid webhook signature");
+}
+
+// src/server/completions.ts
+import * as z2 from "zod";
+var completionRevokeSchema = /* @__PURE__ */ (() => z2.object({
+  actionId: identifier,
+  reason: z2.string().trim().min(1).max(500),
+  freeOccurrence: z2.boolean().default(false)
+}).strict())();
+var RevokedEntitlementOutcome = {
+  /** No other completion grants the reward: it is void, after cancelling a handover in progress. */
+  Voided: "voided",
+  /** Lowered to the best tier another completion grants, after cancelling a handover in progress. */
+  Downgraded: "downgraded",
+  /** Another completion grants the same tier, or it was already void. */
+  Kept: "kept",
+  /** Already collected: its earned tier follows the other completions, and the item stays handed over. */
+  Flagged: "flagged"
+};
+var RevokedDeliveryOutcome = {
+  /** The role was delivered and stays: remove it in Discord if appropriate. */
+  Flagged: "flagged",
+  /** The grant was stopped before any call to Discord. */
+  Cancelled: "cancelled",
+  /** The grant was stopped, but a call to Discord may already have been sent and can still land. */
+  InFlight: "in-flight",
+  /** The grant had failed, so Discord never received the role. */
+  NotDelivered: "not-delivered"
+};
+var RevokedReferralOutcome = {
+  /** The inviter's rewards for this member are reversed. */
+  Unqualified: "unqualified",
+  /** Qualified on another accepted completion of the program's quest instead. */
+  Requalified: "requalified"
+};
+var entitlementOutcomeSchema = /* @__PURE__ */ (() => z2.string().min(1).max(64))();
+var deliveryOutcomeSchema = /* @__PURE__ */ (() => z2.string().min(1).max(64))();
+var referralOutcomeSchema = /* @__PURE__ */ (() => z2.string().min(1).max(64))();
+var completionRevocationSchema = /* @__PURE__ */ (() => z2.object({
+  completion: identifier,
+  /** The quest ID, or the board ID when `source.kind` is `leaderboard`. */
+  quest: identifier,
+  member: identifier,
+  /** What paid the revoked completion. `source.id` repeats `quest`. */
+  source: completionSourceSchema.optional(),
+  revokedAt: z2.number(),
+  occurrenceFreed: z2.boolean(),
+  badges: z2.array(z2.object({ badge: identifier, stillAwarded: z2.boolean() })).optional(),
+  groups: z2.array(z2.object({ group: identifier, stillMember: z2.boolean() })).optional(),
+  points: z2.array(
+    z2.object({
+      entry: identifier,
+      balance: identifier,
+      reversal: identifier.nullable(),
+      reversed: z2.number().int(),
+      unreversed: z2.number().int()
+    })
+  ),
+  entitlements: z2.array(
+    z2.object({
+      entitlement: identifier,
+      reward: identifier,
+      outcome: entitlementOutcomeSchema,
+      status: z2.string()
+    })
+  ),
+  deliveries: z2.array(
+    z2.object({
+      delivery: z2.string(),
+      roleId: z2.string(),
+      outcome: deliveryOutcomeSchema,
+      /**
+       * By Relay's records, another accepted, unrevoked completion of the member also granted this
+       * role to the same Discord account and server. Relay does not read Discord's membership.
+       */
+      stillGranted: z2.boolean()
+    })
+  ),
+  referrals: z2.array(
+    z2.object({
+      program: identifier,
+      outcome: referralOutcomeSchema
+    })
+  ),
+  streakMilestone: z2.boolean(),
+  budgets: z2.array(
+    z2.object({ budget: identifier, released: z2.number().int().nonnegative() })
+  ).optional()
+}))();
+var completionRestoreSchema = /* @__PURE__ */ (() => z2.object({
+  actionId: identifier,
+  reason: z2.string().trim().min(1).max(500)
+}).strict())();
+var RestoredEntitlementOutcome = {
+  /** The revocation voided it, and it is available again. */
+  Restored: "restored",
+  /** The revocation lowered or flagged it: its earned tier is the completion's again. */
+  Raised: "raised",
+  /** It changed since the revocation (an operator restored, voided or corrected it), so it stays. */
+  Kept: "kept"
+};
+var RestoredDeliveryOutcome = {
+  /** The grant had not reached Discord, and it is queued again. */
+  Requeued: "requeued",
+  /** The grant counts again for reconciliation, and its delivery status stays. */
+  Kept: "kept"
+};
+var RestoredReferralOutcome = {
+  /** The member qualifies on this completion again. */
+  Qualified: "qualified",
+  /** The program is disabled or gone, or the referral is suspended, so nothing changed. */
+  Kept: "kept"
+};
+var openOutcome = /* @__PURE__ */ (() => z2.string().min(1).max(64))();
+var completionRestorationSchema = /* @__PURE__ */ (() => z2.object({
+  completion: identifier,
+  /** The quest ID, or the board ID when `source.kind` is `leaderboard`. */
+  quest: identifier,
+  member: identifier,
+  source: completionSourceSchema.optional(),
+  restoredAt: z2.number(),
+  points: z2.array(
+    z2.object({
+      entry: identifier,
+      balance: identifier,
+      reversal: identifier,
+      amount: z2.number().int()
+    })
+  ),
+  badges: z2.array(z2.object({ badge: identifier })),
+  groups: z2.array(z2.object({ group: identifier, added: z2.boolean() })),
+  entitlements: z2.array(
+    z2.object({
+      entitlement: identifier,
+      reward: identifier,
+      outcome: openOutcome,
+      status: z2.string()
+    })
+  ),
+  deliveries: z2.array(
+    z2.object({
+      delivery: z2.string(),
+      roleId: z2.string(),
+      outcome: openOutcome
+    })
+  ),
+  referrals: z2.array(
+    z2.object({
+      program: identifier,
+      outcome: openOutcome
+    })
+  ),
+  streakMilestone: z2.boolean(),
+  budgets: z2.array(
+    z2.object({ budget: identifier, charged: z2.number().int().nonnegative() })
+  ).optional()
+}))();
+var completionRevocationShortfallSchema = /* @__PURE__ */ (() => z2.object({
+  completion: identifier,
+  quest: identifier,
+  revokedAt: z2.number().int().nonnegative().safe(),
+  unreversedPoints: z2.record(identifier, z2.number().int().positive().safe())
+}))();
+var revokedCompletionSchema = /* @__PURE__ */ (() => z2.object({
+  completion: identifier,
+  quest: identifier,
+  /** The completion key: its occurrence, such as `once` or a day. */
+  key: z2.string(),
+  revokedAt: z2.number().int().nonnegative().safe(),
+  /** Why it was revoked, and what the revoke did, which a restore re-applies. */
+  reason: z2.string().optional(),
+  revocation: completionRevocationSchema.optional()
+}))();
+var maxCompletionReceipts = 20;
+var receiptNetworkPattern = /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}$/;
+var receiptValue = /* @__PURE__ */ (() => z2.string().min(1).max(256).regex(/^[\x21-\x7e]+$/, "Use printable characters without spaces"))();
+var completionReceiptInputSchema = /* @__PURE__ */ (() => z2.object({
+  actionId: identifier,
+  key: z2.string().regex(
+    /^[a-z0-9][a-z0-9._-]{0,63}$/,
+    "Use 1 to 64 lowercase letters, digits, dots, hyphens or underscores"
+  ),
+  network: z2.string().regex(
+    receiptNetworkPattern,
+    "Use a CAIP-2 chain ID such as solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"
+  ),
+  signature: receiptValue,
+  asset: receiptValue.optional(),
+  recipient: receiptValue.optional(),
+  label: z2.string().trim().min(1).max(120).optional()
+}).strict().superRefine((receipt, context) => {
+  if (!isSolanaNetwork(receipt.network)) {
+    return;
+  }
+  if (!solanaSignatureSchema.safeParse(receipt.signature).success) {
+    context.addIssue({
+      code: "custom",
+      path: ["signature"],
+      message: "Use a Solana transaction signature: base58, 64 bytes"
+    });
+  }
+  for (const field of ["asset", "recipient"]) {
+    const value = receipt[field];
+    if (value !== void 0 && !solanaAddressSchema.safeParse(value).success) {
+      context.addIssue({
+        code: "custom",
+        path: [field],
+        message: "Use a base58 Solana address"
+      });
+    }
+  }
+}))();
+var completionReceiptSchema = /* @__PURE__ */ (() => z2.object({
+  completion: identifier,
+  /** The quest ID, or the board ID for a leaderboard prize's completion. */
+  quest: identifier,
+  member: identifier,
+  key: z2.string(),
+  network: z2.string(),
+  signature: z2.string(),
+  asset: z2.string().nullable(),
+  recipient: z2.string().nullable(),
+  label: z2.string().nullable(),
+  recordedAt: z2.number().int().nonnegative().safe(),
+  /** The operator or key that recorded it. */
+  recordedBy: z2.string().nullable(),
+  completionRevokedAt: z2.number().int().nonnegative().safe().nullable()
+}))();
+var completionReceiptListSchema = /* @__PURE__ */ (() => z2.array(completionReceiptSchema))();
+var memberCompletionQuerySchema = /* @__PURE__ */ (() => z2.strictObject({
+  member: identifier,
+  quest: identifier.optional(),
+  cursor: pageCursorSchema.optional(),
+  limit: pageLimit
+}))();
+var memberCompletionSchema = /* @__PURE__ */ (() => completionRecordSchema.extend({
+  completedAt: z2.number().int().nonnegative().safe().nullable()
+}))();
+var memberCompletionPageSchema = /* @__PURE__ */ (() => z2.object({
+  items: z2.array(memberCompletionSchema),
+  nextCursor: pageCursorSchema.nullable()
+}))();
+
+export {
+  PayoutSourceKind,
+  webhookEventSchema,
+  walletLinkedEventDataSchema,
+  webhookControlInputSchema,
+  webhookInputSchema,
+  webhookCreateInputSchema,
+  webhookRotateInputSchema,
+  webhookUpdateSchema,
+  webhookEndpointSchema,
+  webhookEndpointStateSchema,
+  webhookDeleteInputSchema,
+  webhookStateQuerySchema,
+  webhookStatePageSchema,
+  webhookSecretSchema,
+  webhookDeliverySchema,
+  webhookQuerySchema,
+  webhookDeliveryPageSchema,
+  WEBHOOK_MAX_BYTES,
+  verifyWebhook,
+  completionRevokeSchema,
+  RevokedEntitlementOutcome,
+  RevokedDeliveryOutcome,
+  RevokedReferralOutcome,
+  completionRevocationSchema,
+  completionRestoreSchema,
+  RestoredEntitlementOutcome,
+  RestoredDeliveryOutcome,
+  RestoredReferralOutcome,
+  completionRestorationSchema,
+  completionRevocationShortfallSchema,
+  revokedCompletionSchema,
+  maxCompletionReceipts,
+  completionReceiptInputSchema,
+  completionReceiptSchema,
+  completionReceiptListSchema,
+  memberCompletionQuerySchema,
+  memberCompletionSchema,
+  memberCompletionPageSchema
+};

package/dist/{chunk-5LD5DKOM.js → chunk-55WJVFWC.js}

@@ -12,10 +12,10 @@ import {
   resourceHandle,
   responseShape,
   tierRewardSchema
-} from "./chunk-XCEGNKGH.js";
+} from "./chunk-6YTSRWRB.js";
 import {
   parseDefinition
-} from "./chunk-FGXLXENM.js";
+} from "./chunk-IW46TW3A.js";
 
 // src/engagement.ts
 import * as z from "zod";

package/dist/{chunk-CJDB6W6I.js → chunk-5AKD4ZF3.js}

@@ -1,10 +1,10 @@
 import {
   imageAssetArtifactSchema
-} from "./chunk-ANVAUOJP.js";
+} from "./chunk-DDJN2T5A.js";
 import {
   authScopeSchema,
   exchangeResultSchema
-} from "./chunk-7MQCQYEE.js";
+} from "./chunk-6UBFSMCM.js";
 import {
   appIdentityKindSchema,
   cosmosAddressSchema,
@@ -17,7 +17,7 @@ import {
   openIdentityKindSchema,
   pageCursorSchema,
   solanaAddressSchema
-} from "./chunk-XCEGNKGH.js";
+} from "./chunk-6YTSRWRB.js";
 
 // src/credential-secrets.ts
 import * as z from "zod";
@@ -418,6 +418,34 @@ var memberImportListQuerySchema = /* @__PURE__ */ (() => z2.object({
 // src/server/schedules.ts
 import * as z3 from "zod";
 import { Cron } from "croner";
+
+// src/server/request-body.ts
+async function boundedBodyText(body, limit) {
+  const reader = body.getReader();
+  let text = "";
+  let size = 0;
+  const decoder = new TextDecoder();
+  try {
+    for (; ; ) {
+      const chunk = await reader.read();
+      if (chunk.done) {
+        break;
+      }
+      size += chunk.value.byteLength;
+      if (size > limit) {
+        void reader.cancel().catch(() => {
+        });
+        return null;
+      }
+      text += decoder.decode(chunk.value, { stream: true });
+    }
+    return text + decoder.decode();
+  } catch {
+    return null;
+  }
+}
+
+// src/server/schedules.ts
 var APP_SCHEDULE_LIMIT = 10;
 var APP_SCHEDULE_MIN_INTERVAL = 3e5;
 var APP_SCHEDULE_TIMEOUT = 3e4;
@@ -564,29 +592,12 @@ async function verifyScheduledRequest(request, key) {
   if (request.method !== "POST" || url.search !== "" || url.hash !== "" || !key || !signature || !/^[a-f0-9]{64}$/.test(signature)) {
     return null;
   }
-  const reader = request.clone().body?.getReader();
-  if (!reader) {
+  const stream = request.clone().body;
+  if (!stream) {
     return null;
   }
-  let body = "";
-  let size = 0;
-  const decoder = new TextDecoder();
-  try {
-    for (; ; ) {
-      const chunk = await reader.read();
-      if (chunk.done) {
-        break;
-      }
-      size += chunk.value.byteLength;
-      if (size > 4096) {
-        void reader.cancel().catch(() => {
-        });
-        return null;
-      }
-      body += decoder.decode(chunk.value, { stream: true });
-    }
-    body += decoder.decode();
-  } catch {
+  const body = await boundedBodyText(stream, 4096);
+  if (body === null) {
     return null;
   }
   const secret = await crypto.subtle.importKey(
@@ -626,7 +637,7 @@ var starters = [
   {
     id: "campaign",
     title: "Campaign tour",
-    summary: "A neutral quest app with a guided tour of every quest kind. The blank canvas for anything."
+    summary: "A quest app with a guided tour of every quest kind, in a clean default look to rebrand. The blank canvas for anything."
   },
   {
     id: "classic",
@@ -1241,21 +1252,43 @@ var buildArtifactsSchema = /* @__PURE__ */ (() => z5.discriminatedUnion("format"
   }
 }))();
 
+// src/origins.ts
+var loopbackHosts = [
+  "localhost",
+  "127.0.0.1",
+  "[::1]"
+];
+function secureOrLoopbackOrigin(url, options = {}) {
+  return url.protocol === "https:" || url.protocol === "http:" && (loopbackHosts.includes(url.hostname) || (options.localHosts ?? []).includes(url.hostname));
+}
+function bareOrigin(url) {
+  return !url.username && !url.password && !url.search && !url.hash && url.pathname === "/";
+}
+
 // src/identity-integration.ts
 import * as z6 from "zod";
+var exactOrigin = (allowed, message) => z6.string().url().superRefine((value, context) => {
+  const url = new URL(value);
+  if (!allowed(url)) {
+    context.addIssue({ code: "custom", message });
+  } else if (url.origin !== value) {
+    context.addIssue({
+      code: "custom",
+      message: `Use the exact origin ${url.origin}, without a path, query or trailing slash.`
+    });
+  }
+});
+var httpsOriginSchema = /* @__PURE__ */ (() => exactOrigin(
+  (url) => url.protocol === "https:",
+  "Use an HTTPS origin."
+))();
+var appLoginOriginSchema = /* @__PURE__ */ (() => exactOrigin(
+  (url) => secureOrLoopbackOrigin(url),
+  "Use an HTTPS origin, or a loopback origin such as http://localhost:3000 for a Test key."
+))();
 var identityIntegrationInputSchema = /* @__PURE__ */ (() => z6.object({
   name: z6.string().trim().min(1).max(80),
-  origin: z6.string().url().superRefine((value, context) => {
-    const url = new URL(value);
-    if (url.protocol !== "https:") {
-      context.addIssue({ code: "custom", message: "Use an HTTPS origin." });
-    } else if (url.origin !== value) {
-      context.addIssue({
-        code: "custom",
-        message: `Use the exact origin ${url.origin}, without a path, query or trailing slash.`
-      });
-    }
-  }),
+  origin: appLoginOriginSchema,
   /**
    * The identity kind this integration owns in the project and environment, such as
    * `app:game`. Each member it signs in gets the exchanged subject as an identity of this
@@ -1408,6 +1441,7 @@ export {
   memberImportSchema,
   memberImportPageSchema,
   memberImportListQuerySchema,
+  boundedBodyText,
   APP_SCHEDULE_LIMIT,
   APP_SCHEDULE_MIN_INTERVAL,
   APP_SCHEDULE_TIMEOUT,
@@ -1495,6 +1529,11 @@ export {
   stagedDeploymentContentSchema,
   stagedDeploymentKey,
   buildArtifactsSchema,
+  loopbackHosts,
+  secureOrLoopbackOrigin,
+  bareOrigin,
+  httpsOriginSchema,
+  appLoginOriginSchema,
   identityIntegrationInputSchema,
   identityIntegrationSchema,
   identityIntegrationSecretSchema,

package/dist/{chunk-7MQCQYEE.js → chunk-6UBFSMCM.js}

@@ -19,7 +19,7 @@ import {
   storedQuestDescriptionSchema,
   storedReviewModeSchema,
   tieredRewardReferenceSchema
-} from "./chunk-XCEGNKGH.js";
+} from "./chunk-6YTSRWRB.js";
 
 // src/participant-activity.ts
 import * as z from "zod";