@domino-sdk/relay 0.15.0 → 0.17.0

package/dist/{chunk-FUQYKTOJ.js → chunk-YUAE6PFY.js}

@@ -160,23 +160,112 @@ var discordMemberSchema = z5.object({
   pending: z5.boolean()
 });
 
-// src/quiz.ts
+// src/submission-input.ts
 import { z as z6 } from "zod";
-var quizId = z6.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
-var quizChoiceSchema = z6.object({ id: quizId, label: z6.string().trim().min(1).max(500) }).strict();
-var quizQuestionSchema = z6.object({
+var textOptionsSchema = z6.object({
+  required: z6.boolean().default(true),
+  minLength: z6.number().int().min(0).max(1e4).default(1),
+  maxLength: z6.number().int().min(1).max(1e4).default(1e4)
+}).strict().refine(
+  (v) => v.minLength <= v.maxLength,
+  "minLength must not exceed maxLength"
+);
+var hostSchema = z6.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 = z6.object({
+  required: z6.boolean().default(true),
+  allowedHosts: z6.array(hostSchema).min(1).max(100).optional()
+}).strict();
+var textEvidenceSchema = z6.object({ kind: z6.literal("text"), value: z6.string().max(1e4) }).strict();
+var urlEvidenceSchema = z6.object({ kind: z6.literal("url"), value: z6.string().max(2048) }).strict();
+var valueEvidenceSchema = z6.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 z7 } from "zod";
+var quizId = z7.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
+var quizChoiceSchema = z7.object({ id: quizId, label: z7.string().trim().min(1).max(500) }).strict();
+var quizQuestionSchema = z7.object({
   id: quizId,
-  prompt: z6.string().trim().min(1).max(1e3),
-  choices: z6.array(quizChoiceSchema).min(2).max(8).refine(
+  prompt: z7.string().trim().min(1).max(1e3),
+  choices: z7.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 = z6.array(quizQuestionSchema).min(1).max(20).refine(
+var quizQuestionsSchema = z7.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 = z6.array(
+var quizContentSchema = z7.array(
   quizQuestionSchema.extend({ correct: quizId }).refine(
     (question) => question.choices.some((choice) => choice.id === question.correct),
     "Choose a correct answer from the available choices"
@@ -187,48 +276,48 @@ var quizContentSchema = z6.array(
 );
 
 // src/schema.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/settings.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/resources.ts
-import { z as z7 } from "zod";
-var channelSourceSchema = z7.object({
-  provider: z7.literal("discord"),
-  resource: z7.literal("channel"),
-  types: z7.array(z7.enum(["text", "announcement"])).min(1)
+import { z as z8 } from "zod";
+var channelSourceSchema = z8.object({
+  provider: z8.literal("discord"),
+  resource: z8.literal("channel"),
+  types: z8.array(z8.enum(["text", "announcement"])).min(1)
 }).strict();
-var resourceSourceSchema = z7.union([
-  z7.object({
-    provider: z7.literal("domino"),
-    resource: z7.literal("point-ledger")
+var resourceSourceSchema = z8.union([
+  z8.object({
+    provider: z8.literal("domino"),
+    resource: z8.literal("point-ledger")
   }).strict(),
   channelSourceSchema,
-  z7.object({
-    provider: z7.literal("discord"),
-    resource: z7.literal("role"),
-    assignable: z7.boolean().default(false)
+  z8.object({
+    provider: z8.literal("discord"),
+    resource: z8.literal("role"),
+    assignable: z8.boolean().default(false)
   }).strict()
 ]);
-var resourceRequestSchema = z7.object({
+var resourceRequestSchema = z8.object({
   source: resourceSourceSchema,
-  query: z7.string().max(100).optional(),
-  cursor: z7.string().regex(/^\d{1,6}$/).optional(),
-  ids: z7.array(z7.string().min(1).max(100)).max(50).optional()
+  query: z8.string().max(100).optional(),
+  cursor: z8.string().regex(/^\d{1,6}$/).optional(),
+  ids: z8.array(z8.string().min(1).max(100)).max(50).optional()
 }).strict();
-var resourceOptionsSchema = z7.object({
-  revision: z7.number().int(),
-  options: z7.array(
-    z7.object({
-      id: z7.string(),
-      label: z7.string(),
-      description: z7.string().optional(),
-      group: z7.string().optional(),
-      disabledReason: z7.string().optional()
+var resourceOptionsSchema = z8.object({
+  revision: z8.number().int(),
+  options: z8.array(
+    z8.object({
+      id: z8.string(),
+      label: z8.string(),
+      description: z8.string().optional(),
+      group: z8.string().optional(),
+      disabledReason: z8.string().optional()
     })
   ),
-  cursor: z7.string().nullable()
+  cursor: z8.string().nullable()
 });
 var discord = {
   roles(options = {}) {
@@ -252,49 +341,49 @@ var pointLedgers = () => ({
 });
 
 // src/settings.ts
-var instant = z8.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
-var resourceId = z8.union([z8.literal(""), z8.string().regex(/^\S{1,200}$/)]);
-var base = { label: z8.string().min(1), description: z8.string().optional() };
-var settingFieldSchema = z8.discriminatedUnion("kind", [
-  z8.object({ ...base, kind: z8.literal("point-ledger"), default: identifier }).strict(),
-  z8.object({ ...base, kind: z8.literal("datetime"), default: instant }).strict(),
-  z8.object({
+var instant = z9.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
+var resourceId = z9.union([z9.literal(""), z9.string().regex(/^\S{1,200}$/)]);
+var base = { label: z9.string().min(1), description: z9.string().optional() };
+var settingFieldSchema = z9.discriminatedUnion("kind", [
+  z9.object({ ...base, kind: z9.literal("point-ledger"), default: identifier }).strict(),
+  z9.object({ ...base, kind: z9.literal("datetime"), default: instant }).strict(),
+  z9.object({
     ...base,
-    kind: z8.literal("resource"),
+    kind: z9.literal("resource"),
     default: resourceId,
     source: resourceSourceSchema
   }).strict(),
-  z8.object({ ...base, kind: z8.literal("quiz"), default: quizContentSchema }).strict(),
-  z8.object({
+  z9.object({ ...base, kind: z9.literal("quiz"), default: quizContentSchema }).strict(),
+  z9.object({
     ...base,
-    kind: z8.literal("text"),
-    default: z8.string(),
-    minLength: z8.number().int().nonnegative(),
-    maxLength: z8.number().int().positive(),
-    multiline: z8.boolean()
+    kind: z9.literal("text"),
+    default: z9.string(),
+    minLength: z9.number().int().nonnegative(),
+    maxLength: z9.number().int().positive(),
+    multiline: z9.boolean()
   }).strict(),
-  z8.object({
+  z9.object({
     ...base,
-    kind: z8.literal("integer"),
-    default: z8.number().int(),
-    min: z8.number().int(),
-    max: z8.number().int()
+    kind: z9.literal("integer"),
+    default: z9.number().int(),
+    min: z9.number().int(),
+    max: z9.number().int()
   }).strict(),
-  z8.object({ ...base, kind: z8.literal("boolean"), default: z8.boolean() }).strict(),
-  z8.object({
+  z9.object({ ...base, kind: z9.literal("boolean"), default: z9.boolean() }).strict(),
+  z9.object({
     ...base,
-    kind: z8.literal("choice"),
-    default: z8.string(),
-    options: z8.array(z8.string().min(1)).min(1)
+    kind: z9.literal("choice"),
+    default: z9.string(),
+    options: z9.array(z9.string().min(1)).min(1)
   }).strict()
 ]);
-var settingsFieldsSchema = z8.record(
-  z8.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
+var settingsFieldsSchema = z9.record(
+  z9.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
   settingFieldSchema
 );
-var settingsValuesSchema = z8.record(
-  z8.string(),
-  z8.union([z8.string(), z8.number().finite(), z8.boolean(), quizContentSchema])
+var settingsValuesSchema = z9.record(
+  z9.string(),
+  z9.union([z9.string(), z9.number().finite(), z9.boolean(), quizContentSchema])
 );
 var settings = {
   pointLedger(options) {
@@ -334,19 +423,19 @@ var settings = {
       maxLength: options.maxLength ?? 2e3,
       multiline: options.multiline ?? false
     };
-    return z8.string().min(field.minLength).max(field.maxLength).default(field.default).meta(field);
+    return z9.string().min(field.minLength).max(field.maxLength).default(field.default).meta(field);
   },
   integer(options) {
-    return z8.number().int().min(options.min).max(options.max).default(options.default).meta({ ...options, kind: "integer" });
+    return z9.number().int().min(options.min).max(options.max).default(options.default).meta({ ...options, kind: "integer" });
   },
   boolean(options) {
-    return z8.boolean().default(options.default).meta({ ...options, kind: "boolean" });
+    return z9.boolean().default(options.default).meta({ ...options, kind: "boolean" });
   },
   choice(options) {
-    return z8.enum(options.options).default(options.default).meta({ ...options, kind: "choice" });
+    return z9.enum(options.options).default(options.default).meta({ ...options, kind: "choice" });
   },
   object(shape) {
-    return z8.object(shape).strict();
+    return z9.object(shape).strict();
   }
 };
 function parseSettings(fields, input) {
@@ -366,20 +455,20 @@ function parseSettings(fields, input) {
         shape[key] = quizContentSchema.default(field.default);
         break;
       case "text":
-        shape[key] = z8.string().min(field.minLength).max(field.maxLength).default(field.default);
+        shape[key] = z9.string().min(field.minLength).max(field.maxLength).default(field.default);
         break;
       case "integer":
-        shape[key] = z8.number().int().min(field.min).max(field.max).default(field.default);
+        shape[key] = z9.number().int().min(field.min).max(field.max).default(field.default);
         break;
       case "boolean":
-        shape[key] = z8.boolean().default(field.default);
+        shape[key] = z9.boolean().default(field.default);
         break;
       case "choice":
-        shape[key] = z8.enum(field.options).default(field.default);
+        shape[key] = z9.enum(field.options).default(field.default);
         break;
     }
   }
-  return settingsValuesSchema.parse(z8.object(shape).strict().parse(input));
+  return settingsValuesSchema.parse(z9.object(shape).strict().parse(input));
 }
 function missingResourceSettings(fields, values) {
   return Object.entries(fields).filter(([key, field]) => field.kind === "resource" && !values[key]).map(([key]) => key);
@@ -389,38 +478,38 @@ function compatibleSettingKinds(previous, next) {
 }
 
 // src/schema.ts
-var pointsRewardSchema = z9.object({
-  kind: z9.literal("points").default("points"),
+var pointsRewardSchema = z10.object({
+  kind: z10.literal("points").default("points"),
   balance: identifier,
-  amount: z9.number().int().min(0).max(1e4)
+  amount: z10.number().int().min(0).max(1e4)
 }).strict();
-var tieredRewardDefinitionSchema = z9.object({
+var tieredRewardDefinitionSchema = z10.object({
   id: identifier,
-  title: z9.string().min(1).max(120),
-  tiers: z9.array(
-    z9.object({ id: identifier, title: z9.string().min(1).max(120) }).strict()
+  title: z10.string().min(1).max(120),
+  tiers: z10.array(
+    z10.object({ id: identifier, title: z10.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: z9.object({ kind: z9.literal("untracked") }).strict(),
-  fulfillment: z9.object({ kind: z9.literal("staff-handover") }).strict()
+  inventory: z10.object({ kind: z10.literal("untracked") }).strict(),
+  fulfillment: z10.object({ kind: z10.literal("staff-handover") }).strict()
 }).strict();
-var tierRewardSchema = z9.object({
-  kind: z9.literal("tier"),
+var tierRewardSchema = z10.object({
+  kind: z10.literal("tier"),
   reward: tieredRewardDefinitionSchema,
   tier: identifier
 }).strict().refine(
   (value) => value.reward.tiers.some((t) => t.id === value.tier),
   "Unknown reward tier"
 );
-var integrationRewardSchema = z9.object({
-  kind: z9.literal("integration"),
-  provider: z9.literal("discord"),
-  action: z9.literal("grant-role"),
-  roleId: z9.string().regex(/^[0-9]{1,20}$/)
+var integrationRewardSchema = z10.object({
+  kind: z10.literal("integration"),
+  provider: z10.literal("discord"),
+  action: z10.literal("grant-role"),
+  roleId: z10.string().regex(/^[0-9]{1,20}$/)
 }).strict();
-var rewardSchema = z9.union([
+var rewardSchema = z10.union([
   pointsRewardSchema,
   tierRewardSchema,
   integrationRewardSchema
@@ -431,49 +520,66 @@ function rewardKey(reward) {
   }
   return reward.kind === "points" ? "points:" + reward.balance : "tier:" + reward.reward.id;
 }
-var triggerSchema = z9.union([
-  z9.object({
-    kind: z9.literal("manual"),
-    input: z9.enum(["photo", "quiz", "none"]),
-    actor: z9.enum(["member", "staff"]).optional()
+var triggerSchema = z10.union([
+  z10.object({
+    kind: z10.literal("manual"),
+    input: z10.literal("text"),
+    constraints: textOptionsSchema,
+    actor: z10.enum(["member", "staff"]).optional()
   }).strict(),
-  z9.object({
-    kind: z9.literal("automatic"),
+  z10.object({
+    kind: z10.literal("manual"),
+    input: z10.literal("url"),
+    constraints: urlOptionsSchema,
+    actor: z10.enum(["member", "staff"]).optional()
+  }).strict(),
+  z10.object({
+    kind: z10.literal("manual"),
+    input: z10.enum(["photo", "quiz", "none"]),
+    actor: z10.enum(["member", "staff"]).optional()
+  }).strict(),
+  z10.object({
+    kind: z10.literal("automatic"),
     observation: observationTriggerSchema.optional()
   }).strict()
 ]);
-var prerequisiteSchema = z9.object({ quest: identifier, scope: z9.literal("ever") }).strict();
-var photoResultSchema = z9.object({
-  kind: z9.enum(["pass", "fail", "unclear"]),
-  reason: z9.string().min(1).max(2e3)
+var prerequisiteSchema = z10.object({ quest: identifier, scope: z10.literal("ever") }).strict();
+var photoResultSchema = z10.object({
+  kind: z10.enum(["pass", "fail", "unclear"]),
+  reason: z10.string().min(1).max(2e3)
 }).strict();
-var decisionSchema = z9.discriminatedUnion("kind", [
-  z9.object({
-    kind: z9.literal("accept"),
-    rewards: z9.array(rewardSchema).max(10),
+var textReviewInputSchema = z10.object({
+  text: z10.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
+  criteria: z10.string().trim().min(1).max(2e3)
+}).strict();
+var textResultSchema = photoResultSchema;
+var decisionSchema = z10.discriminatedUnion("kind", [
+  z10.object({
+    kind: z10.literal("accept"),
+    rewards: z10.array(rewardSchema).max(10),
     completionKey: completionKeySchema.optional()
   }).strict(),
-  z9.object({ kind: z9.literal("reject"), reason: z9.string().min(1).max(2e3) }).strict(),
-  z9.object({
-    kind: z9.literal("review"),
-    reason: z9.string().min(1).max(2e3),
-    rewards: z9.array(rewardSchema).max(10).optional(),
+  z10.object({ kind: z10.literal("reject"), reason: z10.string().min(1).max(2e3) }).strict(),
+  z10.object({
+    kind: z10.literal("review"),
+    reason: z10.string().min(1).max(2e3),
+    rewards: z10.array(rewardSchema).max(10).optional(),
     completionKey: completionKeySchema.optional()
   }).strict()
 ]);
-var reviewModeSchema = z9.enum(["workers-ai"]);
-var storedReviewModeSchema = z9.enum([
+var reviewModeSchema = z10.enum(["workers-ai"]);
+var storedReviewModeSchema = z10.enum([
   "fixture-pass",
   "fixture-fail",
   "fixture-unclear",
   "fixture-error",
   "workers-ai"
 ]);
-var rewardBundleSchema = z9.array(rewardSchema).max(10).refine(
+var rewardBundleSchema = z10.array(rewardSchema).max(10).refine(
   (rewards) => new Set(rewards.map(rewardKey)).size === rewards.length,
   "Use one entry per balance or shared reward"
 );
-var mediaUrlSchema = z9.string().max(2e3).refine((value) => {
+var mediaUrlSchema = z10.string().max(2e3).refine((value) => {
   if (/^\/(?!\/)[^\\\s]*$/.test(value)) {
     return true;
   }
@@ -483,74 +589,74 @@ var mediaUrlSchema = z9.string().max(2e3).refine((value) => {
     return false;
   }
 }, "Use an HTTPS URL or a same-site path beginning with /");
-var questPresentationSchema = z9.object({
+var questPresentationSchema = z10.object({
   quiz: quizQuestionsSchema.optional(),
-  instructions: z9.string().max(4e3).optional(),
-  video: z9.object({
+  instructions: z10.string().max(4e3).optional(),
+  video: z10.object({
     url: mediaUrlSchema,
     poster: mediaUrlSchema.optional(),
-    captions: z9.object({
+    captions: z10.object({
       url: mediaUrlSchema,
-      language: z9.string().min(2).max(20),
-      label: z9.string().min(1).max(80)
+      language: z10.string().min(2).max(20),
+      label: z10.string().min(1).max(80)
     }).strict().optional()
   }).strict().optional()
 }).strict();
-var questDescriptionSchema = z9.object({
+var questDescriptionSchema = z10.object({
   quest: identifier,
-  runtimeVersion: z9.union([z9.literal(1), z9.literal(2)]).default(1),
-  title: z9.string().min(1).max(120),
+  runtimeVersion: z10.union([z10.literal(1), z10.literal(2)]).default(1),
+  title: z10.string().min(1).max(120),
   presentation: questPresentationSchema.default({}),
-  integrations: z9.array(integrationProviderSchema).max(10).default([]),
+  integrations: z10.array(integrationProviderSchema).max(10).default([]),
   fields: settingsFieldsSchema,
   values: settingsValuesSchema,
   rewards: rewardBundleSchema,
-  humanReview: z9.boolean(),
+  humanReview: z10.boolean(),
   trigger: triggerSchema,
-  requires: z9.array(prerequisiteSchema).max(30).default([]),
+  requires: z10.array(prerequisiteSchema).max(30).default([]),
   completion: completionPolicySchema,
-  visibility: z9.enum(["visible", "hidden"]).default("visible"),
-  budgets: z9.array(budgetSchema).max(20).default([])
+  visibility: z10.enum(["visible", "hidden"]).default("visible"),
+  budgets: z10.array(budgetSchema).max(20).default([])
 }).strict();
-var artifactSchema = z9.object({ code: z9.string().min(1).max(1e6) }).strict();
+var artifactSchema = z10.object({ code: z10.string().min(1).max(1e6) }).strict();
 var releaseSchema = artifactSchema.extend({
   settings: settingsValuesSchema,
   provider: reviewModeSchema,
   expectedRelease: identifier.nullable().optional(),
-  settingRenames: z9.record(z9.string(), z9.string()).optional()
+  settingRenames: z10.record(z10.string(), z10.string()).optional()
 }).strict();
-var batchReleaseSchema = z9.object({ releases: z9.array(releaseSchema).min(1).max(50) }).strict();
-var questSettingsInputSchema = z9.object({
+var batchReleaseSchema = z10.object({ releases: z10.array(releaseSchema).min(1).max(50) }).strict();
+var questSettingsInputSchema = z10.object({
   quest: identifier,
   expectedRelease: identifier,
   set: settingsValuesSchema,
-  reset: z9.array(z9.string())
+  reset: z10.array(z10.string())
 }).strict();
 var storedReleaseSchema = questDescriptionSchema.extend({
   key: identifier.optional(),
-  code: z9.string(),
+  code: z10.string(),
   provider: storedReviewModeSchema,
   id: identifier,
-  createdAt: z9.number(),
-  legacy: z9.boolean().default(false),
-  origin: z9.object({ typeVersion: identifier }).strict().optional(),
-  lifecycle: z9.enum(["active", "paused", "archived"]).default("active"),
-  configuration: z9.object({
+  createdAt: z10.number(),
+  legacy: z10.boolean().default(false),
+  origin: z10.object({ typeVersion: identifier }).strict().optional(),
+  lifecycle: z10.enum(["active", "paused", "archived"]).default("active"),
+  configuration: z10.object({
     defaults: settingsValuesSchema,
     overrides: settingsValuesSchema,
-    preserved: z9.array(z9.string())
+    preserved: z10.array(z10.string())
   }).strict().optional()
 });
-var legacyReleaseSchema = z9.object({
+var legacyReleaseSchema = z10.object({
   quest: identifier,
-  title: z9.string(),
-  criteria: z9.string(),
-  humanReview: z9.boolean(),
+  title: z10.string(),
+  criteria: z10.string(),
+  humanReview: z10.boolean(),
   rewards: rewardBundleSchema,
-  code: z9.string(),
+  code: z10.string(),
   provider: storedReviewModeSchema,
   id: identifier,
-  createdAt: z9.number()
+  createdAt: z10.number()
 }).transform((r) => {
   const { criteria, ...stored } = r;
   return storedReleaseSchema.parse({
@@ -562,15 +668,15 @@ var legacyReleaseSchema = z9.object({
     legacy: true
   });
 });
-var publishedReleaseSchema = z9.union([
+var publishedReleaseSchema = z10.union([
   storedReleaseSchema,
   legacyReleaseSchema
 ]);
-var templateSchema = z9.object({
-  code: z9.string(),
+var templateSchema = z10.object({
+  code: z10.string(),
   definition: questDescriptionSchema
 });
-var quizAnswersSchema = z9.record(identifier, identifier).refine(
+var quizAnswersSchema = z10.record(identifier, identifier).refine(
   (answers) => Object.keys(answers).length > 0 && Object.keys(answers).length <= 50,
   "Provide between 1 and 50 answers"
 ).transform(
@@ -578,28 +684,33 @@ var quizAnswersSchema = z9.record(identifier, identifier).refine(
     Object.entries(answers).sort(([a], [b]) => a.localeCompare(b))
   )
 );
-var quizEvidenceSchema = z9.object({
-  kind: z9.literal("quiz"),
+var quizEvidenceSchema = z10.object({
+  kind: z10.literal("quiz"),
   release: identifier.optional(),
   answers: quizAnswersSchema
 }).strict();
-var submitSchema = z9.object({
+var submissionEvidenceSchema = z10.union([
+  quizEvidenceSchema,
+  textEvidenceSchema,
+  urlEvidenceSchema
+]);
+var submitSchema = z10.object({
   actionId: identifier,
   quest: identifier,
   member: identifier,
   evidence: identifier.optional(),
-  input: quizEvidenceSchema.optional(),
+  input: submissionEvidenceSchema.optional(),
   release: identifier.optional(),
-  faultAfterReview: z9.boolean().optional()
+  faultAfterReview: z10.boolean().optional()
 }).strict();
-var attemptSchema = z9.object({
+var attemptSchema = z10.object({
   id: identifier,
   release: identifier,
   quest: identifier,
   member: identifier,
   evidence: identifier.nullable(),
-  input: quizEvidenceSchema.optional(),
-  status: z9.enum([
+  input: submissionEvidenceSchema.optional(),
+  status: z10.enum([
     "queued",
     "evaluating",
     "accepted",
@@ -608,70 +719,70 @@ var attemptSchema = z9.object({
     "needs-review",
     "failed"
   ]),
-  reason: z9.string().nullable(),
-  retries: z9.number(),
-  generation: z9.number(),
-  completion: z9.string().nullable(),
+  reason: z10.string().nullable(),
+  retries: z10.number(),
+  generation: z10.number(),
+  completion: z10.string().nullable(),
   reviewRewards: rewardBundleSchema.nullable().default(null),
-  createdAt: z9.number()
+  createdAt: z10.number()
 });
-var eventSchema = z9.object({
-  id: z9.number(),
-  attempt: z9.string().nullable(),
-  kind: z9.string(),
-  detail: z9.string(),
-  actor: z9.string().nullable().default(null),
-  at: z9.number()
+var eventSchema = z10.object({
+  id: z10.number(),
+  attempt: z10.string().nullable(),
+  kind: z10.string(),
+  detail: z10.string(),
+  actor: z10.string().nullable().default(null),
+  at: z10.number()
 });
-var pickupSelectionSchema = z9.object({
+var pickupSelectionSchema = z10.object({
   item: identifier,
-  revision: z9.number().int().nonnegative()
+  revision: z10.number().int().nonnegative()
 }).strict();
-var pickupAllocationSchema = z9.object({
+var pickupAllocationSchema = z10.object({
   item: identifier,
-  label: z9.string().min(1).max(80)
+  label: z10.string().min(1).max(80)
 }).strict();
-var pickupPolicySchema = z9.discriminatedUnion("kind", [
-  z9.object({ kind: z9.literal("untracked") }).strict(),
-  z9.object({
-    kind: z9.literal("at-pickup"),
-    tiers: z9.array(
-      z9.object({
+var pickupPolicySchema = z10.discriminatedUnion("kind", [
+  z10.object({ kind: z10.literal("untracked") }).strict(),
+  z10.object({
+    kind: z10.literal("at-pickup"),
+    tiers: z10.array(
+      z10.object({
         tier: identifier,
-        variants: z9.array(pickupAllocationSchema).min(1).max(100)
+        variants: z10.array(pickupAllocationSchema).min(1).max(100)
       }).strict()
     ).min(1).max(100)
   }).strict()
 ]);
-var pickupCatalogSchema = z9.object({
+var pickupCatalogSchema = z10.object({
   reward: tieredRewardDefinitionSchema,
-  revision: z9.number().int().nonnegative(),
+  revision: z10.number().int().nonnegative(),
   policy: pickupPolicySchema
 });
-var pickupAvailabilitySchema = z9.discriminatedUnion("kind", [
-  z9.object({ kind: z9.literal("untracked") }).strict(),
-  z9.object({
-    kind: z9.literal("at-pickup"),
-    revision: z9.number().int().nonnegative(),
-    variants: z9.array(
+var pickupAvailabilitySchema = z10.discriminatedUnion("kind", [
+  z10.object({ kind: z10.literal("untracked") }).strict(),
+  z10.object({
+    kind: z10.literal("at-pickup"),
+    revision: z10.number().int().nonnegative(),
+    variants: z10.array(
       pickupAllocationSchema.extend({
-        available: z9.number().int().nonnegative()
+        available: z10.number().int().nonnegative()
       })
     )
   }).strict()
 ]);
-var configurePickupSchema = z9.object({
+var configurePickupSchema = z10.object({
   reward: identifier,
-  revision: z9.number().int().nonnegative(),
+  revision: z10.number().int().nonnegative(),
   actionId: identifier,
-  policy: z9.discriminatedUnion("kind", [
-    z9.object({ kind: z9.literal("untracked") }).strict(),
-    z9.object({
-      kind: z9.literal("at-pickup"),
-      tiers: z9.array(
-        z9.object({
+  policy: z10.discriminatedUnion("kind", [
+    z10.object({ kind: z10.literal("untracked") }).strict(),
+    z10.object({
+      kind: z10.literal("at-pickup"),
+      tiers: z10.array(
+        z10.object({
           tier: identifier,
-          variants: z9.array(
+          variants: z10.array(
             pickupAllocationSchema.extend({
               item: identifier.optional()
             })
@@ -687,151 +798,151 @@ var entitlementBase = {
   reward: tieredRewardDefinitionSchema,
   earnedTier: identifier,
   tier: identifier,
-  revision: z9.number().int().positive()
+  revision: z10.number().int().positive()
 };
-var entitlementSchema = z9.discriminatedUnion("status", [
-  z9.object({ ...entitlementBase, status: z9.literal("available") }).strict(),
-  z9.object({
+var entitlementSchema = z10.discriminatedUnion("status", [
+  z10.object({ ...entitlementBase, status: z10.literal("available") }).strict(),
+  z10.object({
     ...entitlementBase,
-    status: z9.literal("handing-over"),
+    status: z10.literal("handing-over"),
     handover: identifier,
-    startedAt: z9.number(),
+    startedAt: z10.number(),
     allocation: pickupAllocationSchema.optional()
   }).strict(),
-  z9.object({
+  z10.object({
     ...entitlementBase,
-    status: z9.literal("collected"),
+    status: z10.literal("collected"),
     handover: identifier,
-    startedAt: z9.number(),
+    startedAt: z10.number(),
     allocation: pickupAllocationSchema.optional(),
-    collectedAt: z9.number()
+    collectedAt: z10.number()
   }).strict()
 ]);
-var beginHandoverSchema = z9.object({
+var beginHandoverSchema = z10.object({
   actionId: identifier,
-  revision: z9.number().int().positive(),
+  revision: z10.number().int().positive(),
   selection: pickupSelectionSchema.optional()
 }).strict();
-var confirmHandoverSchema = z9.object({ actionId: identifier, handover: identifier }).strict();
-var completionRecordSchema = z9.object({
-  key: z9.string().default("once"),
+var confirmHandoverSchema = z10.object({ actionId: identifier, handover: identifier }).strict();
+var completionRecordSchema = z10.object({
+  key: z10.string().default("once"),
   id: identifier,
   quest: identifier,
   member: identifier
 });
-var questAvailabilitySchema = z9.discriminatedUnion("kind", [
-  z9.object({
-    kind: z9.literal("available"),
-    input: z9.enum(["photo", "quiz", "none"])
+var questAvailabilitySchema = z10.discriminatedUnion("kind", [
+  z10.object({
+    kind: z10.literal("available"),
+    input: z10.enum(["photo", "quiz", "none", "text", "url"])
   }).strict(),
-  z9.object({ kind: z9.literal("completed") }).strict(),
-  z9.object({
-    kind: z9.literal("locked"),
-    missing: z9.array(z9.object({ quest: identifier, title: z9.string() })).min(1)
+  z10.object({ kind: z10.literal("completed") }).strict(),
+  z10.object({
+    kind: z10.literal("locked"),
+    missing: z10.array(z10.object({ quest: identifier, title: z10.string() })).min(1)
   }).strict(),
-  z9.object({ kind: z9.literal("staff-required") }).strict(),
-  z9.object({
-    kind: z9.literal("automatic"),
+  z10.object({ kind: z10.literal("staff-required") }).strict(),
+  z10.object({
+    kind: z10.literal("automatic"),
     observation: observationTriggerSchema.optional()
   }).strict(),
-  z9.object({ kind: z9.literal("checking"), attempt: identifier }).strict(),
-  z9.object({ kind: z9.literal("needs-review"), attempt: identifier }).strict(),
-  z9.object({ kind: z9.literal("retryable"), attempt: identifier }).strict()
+  z10.object({ kind: z10.literal("checking"), attempt: identifier }).strict(),
+  z10.object({ kind: z10.literal("needs-review"), attempt: identifier }).strict(),
+  z10.object({ kind: z10.literal("retryable"), attempt: identifier }).strict()
 ]);
-var memberProgressSchema = z9.object({
+var memberProgressSchema = z10.object({
   member: identifier,
-  quests: z9.array(
-    z9.object({
+  quests: z10.array(
+    z10.object({
       quest: identifier,
       key: identifier.optional(),
       release: identifier.optional(),
-      title: z9.string(),
+      title: z10.string(),
       presentation: questPresentationSchema.default({}),
-      connections: z9.array(authProviderSchema).default([]),
+      connections: z10.array(authProviderSchema).default([]),
       trigger: triggerSchema,
       availability: questAvailabilitySchema,
-      completed: z9.boolean(),
+      completed: z10.boolean(),
       completion: completionPolicySchema.default({ kind: "once" }),
       streak: streakProgressSchema.nullable().optional(),
-      completionCount: z9.number().int().nonnegative().default(0),
-      visibility: z9.enum(["visible", "hidden"]).default("visible"),
-      missing: z9.array(z9.object({ quest: identifier, title: z9.string() })),
+      completionCount: z10.number().int().nonnegative().default(0),
+      visibility: z10.enum(["visible", "hidden"]).default("visible"),
+      missing: z10.array(z10.object({ quest: identifier, title: z10.string() })),
       attempt: attemptSchema.nullable()
     })
   ),
-  entitlements: z9.array(entitlementSchema)
+  entitlements: z10.array(entitlementSchema)
 });
-var snapshotSchema = z9.object({
-  releases: z9.array(publishedReleaseSchema),
-  completions: z9.array(completionRecordSchema),
-  entitlements: z9.array(entitlementSchema),
-  attempts: z9.array(attemptSchema),
-  balances: z9.array(
-    z9.object({
-      member: z9.string(),
-      balance: z9.string(),
-      earned: z9.number(),
-      held: z9.number(),
-      available: z9.number()
+var snapshotSchema = z10.object({
+  releases: z10.array(publishedReleaseSchema),
+  completions: z10.array(completionRecordSchema),
+  entitlements: z10.array(entitlementSchema),
+  attempts: z10.array(attemptSchema),
+  balances: z10.array(
+    z10.object({
+      member: z10.string(),
+      balance: z10.string(),
+      earned: z10.number(),
+      held: z10.number(),
+      available: z10.number()
     })
   ),
-  events: z9.array(eventSchema)
+  events: z10.array(eventSchema)
 });
-var evidenceSchema = z9.object({
+var evidenceSchema = z10.object({
   id: identifier,
   member: identifier,
-  type: z9.enum(["image/jpeg", "image/png"]),
-  size: z9.number()
+  type: z10.enum(["image/jpeg", "image/png"]),
+  size: z10.number()
 });
-var errorSchema = z9.object({
-  error: z9.string(),
-  code: z9.enum(["stale-quiz", "quest-updated"]).optional(),
-  missing: z9.array(z9.object({ quest: identifier, title: z9.string() })).optional()
+var errorSchema = z10.object({
+  error: z10.string(),
+  code: z10.enum(["stale-quiz", "quest-updated", "invalid-submission"]).optional(),
+  missing: z10.array(z10.object({ quest: identifier, title: z10.string() })).optional()
 });
-var staffDecisionSchema = z9.object({
+var staffDecisionSchema = z10.object({
   actionId: identifier,
-  generation: z9.number().int().nonnegative(),
-  decision: z9.enum(["accept", "reject"]),
-  reason: z9.string().trim().min(1).max(2e3)
+  generation: z10.number().int().nonnegative(),
+  decision: z10.enum(["accept", "reject"]),
+  reason: z10.string().trim().min(1).max(2e3)
 }).strict();
-var stockSchema = z9.object({ item: identifier, quantity: z9.number().int().min(0).max(1e4) }).strict();
-var reservationSchema = z9.object({
+var stockSchema = z10.object({ item: identifier, quantity: z10.number().int().min(0).max(1e4) }).strict();
+var reservationSchema = z10.object({
   actionId: identifier,
   member: identifier,
   item: identifier,
   balance: identifier,
-  price: z9.number().int().positive().max(1e4)
+  price: z10.number().int().positive().max(1e4)
 }).strict();
 var pageOptions = {
-  limit: z9.number().int().min(1).max(100).default(25),
-  cursor: z9.string().min(1).max(4096).optional()
+  limit: z10.number().int().min(1).max(100).default(25),
+  cursor: z10.string().min(1).max(4096).optional()
 };
-var reviewListSchema = z9.object({
+var reviewListSchema = z10.object({
   ...pageOptions,
   member: identifier.optional(),
   quest: identifier.optional()
 }).strict();
-var memberListSchema = z9.object({
+var memberListSchema = z10.object({
   ...pageOptions,
   prefix: identifier.optional()
 }).strict();
-var reviewItemSchema = z9.object({
+var reviewItemSchema = z10.object({
   attempt: attemptSchema,
-  title: z9.string(),
-  checks: z9.array(
-    z9.object({ criteria: z9.string(), result: photoResultSchema })
+  title: z10.string(),
+  checks: z10.array(
+    z10.object({ criteria: z10.string(), result: photoResultSchema })
   )
 });
-var reviewPageSchema = z9.object({
-  items: z9.array(reviewItemSchema).max(100),
-  nextCursor: z9.string().nullable()
+var reviewPageSchema = z10.object({
+  items: z10.array(reviewItemSchema).max(100),
+  nextCursor: z10.string().nullable()
 });
-var memberPageSchema = z9.object({
-  items: z9.array(z9.object({ member: identifier })).max(100),
-  nextCursor: z9.string().nullable()
+var memberPageSchema = z10.object({
+  items: z10.array(z10.object({ member: identifier })).max(100),
+  nextCursor: z10.string().nullable()
 });
-var createStockItemSchema = z9.object({ actionId: identifier, name: z9.string().trim().min(1).max(80) }).strict();
-var stockItemSchema = z9.object({ id: identifier, name: z9.string() });
+var createStockItemSchema = z10.object({ actionId: identifier, name: z10.string().trim().min(1).max(80) }).strict();
+var stockItemSchema = z10.object({ id: identifier, name: z10.string() });
 
 export {
   communityTimeZoneSchema,
@@ -856,6 +967,13 @@ export {
   discordMemberInputSchema,
   discordMessageInputSchema,
   discordMemberSchema,
+  textOptionsSchema,
+  urlOptionsSchema,
+  textEvidenceSchema,
+  urlEvidenceSchema,
+  valueEvidenceSchema,
+  validateSubmissionValue,
+  xPostId,
   quizChoiceSchema,
   quizQuestionSchema,
   quizQuestionsSchema,
@@ -881,6 +999,8 @@ export {
   triggerSchema,
   prerequisiteSchema,
   photoResultSchema,
+  textReviewInputSchema,
+  textResultSchema,
   decisionSchema,
   reviewModeSchema,
   storedReviewModeSchema,
@@ -896,6 +1016,7 @@ export {
   templateSchema,
   quizAnswersSchema,
   quizEvidenceSchema,
+  submissionEvidenceSchema,
   submitSchema,
   attemptSchema,
   eventSchema,