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

package/dist/authoring.js

@@ -1,55 +1,352 @@
 import {
-  authoringKey,
-  defineEngagementReward,
-  defineLeaderboard,
-  defineReferral,
   formatUnits,
   parseUnits
-} from "./chunk-B76BAJ25.js";
+} from "./chunk-V7UKZLHA.js";
+import {
+  CapabilityError,
+  capabilityErrorCodes
+} from "./chunk-MC6V6VMG.js";
+import {
+  sourceDataSchema,
+  sourceRoles,
+  validateQuestShape
+} from "./chunk-GQKYAQM6.js";
 import {
-  isEvmChainId
-} from "./chunk-ONDBQSMU.js";
+  cosmosDenomSchema,
+  cosmosNetworkSchema,
+  defineOffer,
+  engagementDefinitionSchema,
+  engagementScoreInputSchema,
+  engagementScoreSchema,
+  isEvmChainId,
+  leaderboardAuthoringSchema,
+  pointLedgerDeclarationSchema,
+  referralAuthoringSchema
+} from "./chunk-36HTX2BM.js";
+import "./chunk-NPGENI7K.js";
 import {
-  admittedContentSchema,
+  authoringKey,
+  balanceAtLeast,
   budgetSchema,
-  content,
+  completed,
+  contentMetricNameSchema,
   contentPerformancePolicySchema,
   contentPerformanceSnapshotSchema,
-  customSource,
+  counterGoalSchema,
+  counterPolicySchema,
+  counterWindowSchema,
+  customSourceSchema,
   decisionSchema,
   defaultTriggerMode,
-  defineTracker,
-  discord,
-  integrationRewardSchema,
+  defineCampaign,
+  defineGroup,
+  discordMessagesSourceSchema,
+  discordReactionsSourceSchema,
+  discordRewardSchema,
+  evaluatorIntegrationProviderSchema,
+  evaluatorProtocol,
+  identifier,
+  inGroup,
+  ledgerKey,
+  ledgerSettingSchema,
   parseSettings,
-  perContent,
-  pointLedgers,
   pointsRewardSchema,
   questDescriptionSchema,
   quizAnswersSchema,
+  quizContentSchema,
+  resourceHandle,
+  resourceSourceSchema,
   rewardBundleSchema,
+  schemaCheckedReader,
   settingFieldSchema,
-  settings,
+  settingInstant,
+  settingResourceId,
+  sourceContent,
   sourceIdentities,
-  streak,
+  streakPolicySchema,
   textOptionsSchema,
   tierRewardSchema,
   tieredRewardDefinitionSchema,
+  trackerDataIssue,
+  trackerDataSchema,
+  trackerDefinitionSchema,
   trackerTriggerContextSchema,
   trackerTriggerPolicySchema,
   urlOptionsSchema,
-  x,
-  xAccountRoles
-} from "./chunk-NKGJEYZM.js";
+  whereSchemaIssue,
+  whereSettings,
+  xSearchSourceSchema
+} from "./chunk-JON5SESL.js";
 
-// src/authoring.ts
+// src/builders.ts
 import { z } from "zod";
-var points = (balance, amount) => pointsRewardSchema.parse({ kind: "points", balance, amount });
-var discordRole = (roleId) => integrationRewardSchema.parse({
-  kind: "integration",
+function defineLedger(input) {
+  return resourceHandle("ledger", pointLedgerDeclarationSchema.parse(input));
+}
+function defineEngagementReward(input) {
+  const { target, ledger, ...config } = input;
+  const definition = engagementDefinitionSchema.parse({
+    ...config,
+    qualifiedBy: input.qualifiedBy.key,
+    balance: ledgerKey(ledger)
+  });
+  const selected = z.record(
+    z.enum(input.metrics),
+    engagementScoreSchema.shape.target
+  );
+  return {
+    key: definition.key,
+    describe: () => definition,
+    score(raw) {
+      const sample = engagementScoreInputSchema.parse(raw);
+      return engagementScoreSchema.parse({
+        target: target({ metrics: selected.parse(sample.metrics) }),
+        baseline: target({ metrics: selected.parse(sample.baseline) })
+      });
+    }
+  };
+}
+var streak = (options) => {
+  if ("timeZone" in options) {
+    throw new Error(
+      "streak() no longer takes a timeZone. Set the project timezone with calendar.timeZone in relay.json or in Console settings."
+    );
+  }
+  return streakPolicySchema.strict().parse({ kind: "streak", ...options });
+};
+var count = (count2) => counterGoalSchema.brand().parse({ kind: "count", count: count2 });
+var calendar = (period, options = {}) => counterWindowSchema.brand().parse({ kind: "calendar", period, ...options });
+var rolling = ({ days }) => counterWindowSchema.brand().parse({ kind: "rolling", durationMs: days * 864e5 });
+var questCompleted = (quest) => ({
+  kind: "quest",
+  quest
+});
+function defineReferral(input) {
+  const { qualification, inviterGroup, milestones, bonuses, ...properties } = input;
+  const definition = referralAuthoringSchema.parse({
+    ...properties,
+    qualification: qualification.kind === "quest" ? { kind: "quest", quest: qualification.quest.key } : qualification,
+    ...inviterGroup ? { inviterGroup: identifier.parse(inviterGroup.key) } : {},
+    milestones: milestones?.map(({ key, ...rule }) => ({
+      ...rule,
+      id: authoringKey({ key, ...rule })
+    })),
+    bonuses: bonuses?.map(({ key, ledger, quests, ...rule }) => ({
+      ...rule,
+      id: authoringKey({ key, ...rule }),
+      balance: ledgerKey(ledger),
+      quests: quests?.map((quest) => quest.key)
+    }))
+  });
+  return resourceHandle("referral", definition);
+}
+function earned(options = {}) {
+  return { kind: "earned", ...options };
+}
+function defineLeaderboard(input) {
+  const { ledger, group, score, ...properties } = input;
+  const definition = leaderboardAuthoringSchema.parse({
+    ...properties,
+    balance: ledgerKey(ledger),
+    ...group ? { group: identifier.parse(group.key) } : {},
+    score: score?.kind === "earned" ? { ...score, quests: score.quests?.map((quest) => quest.key) } : score
+  });
+  return resourceHandle("leaderboard", definition);
+}
+var x = {
+  provider: "x",
+  /**
+   * Posts matching an X search. Each record's `data` is the provider's post payload. Its content
+   * is the post's normalized body (`XContentBody`), measured by the six X counters, so `content()`
+   * quests can use it.
+   */
+  search: (input) => xSearchSourceSchema.parse({ kind: "x-search", ...input })
+};
+function customSource(namespace, options) {
+  const { data, content: content2, ...rest } = options ?? {};
+  if (content2 !== void 0) {
+    if (data !== void 0) {
+      throw new Error(
+        `customSource("${namespace}") takes data or content, not both: a content source's records carry { body, metrics }`
+      );
+    }
+    if (!isZodSchema(content2.body)) {
+      throw new Error(
+        `customSource("${namespace}") needs a content body schema: customSource(namespace, { content: { body: z.object({ ... }), metrics: ["likes"] } })`
+      );
+    }
+    const metrics = [...content2.metrics ?? []];
+    for (const metric of metrics) {
+      contentMetricNameSchema.parse(metric);
+    }
+    return customSourceSchema.parse({
+      kind: "custom",
+      namespace,
+      ...rest,
+      data: trackerDataSchema(
+        z.object({
+          body: content2.body,
+          metrics: z.strictObject(
+            Object.fromEntries(
+              metrics.map((metric) => [
+                metric,
+                z.number().int().safe().nonnegative().optional()
+              ])
+            )
+          ).optional()
+        })
+      ),
+      content: { metrics }
+    });
+  }
+  if (!isZodSchema(data)) {
+    throw new Error(
+      `customSource("${namespace}") needs a data schema: customSource(namespace, { data: z.object({ ... }) }) describes each record's data`
+    );
+  }
+  return customSourceSchema.parse({
+    kind: "custom",
+    namespace,
+    ...rest,
+    data: trackerDataSchema(data)
+  });
+}
+function isZodSchema(value) {
+  return typeof value === "object" && value !== null && "_zod" in value;
+}
+function defineTracker(input) {
+  return resourceHandle(
+    "tracker",
+    trackerDefinitionSchema.parse(input)
+  );
+}
+function messages(options = {}) {
+  return discordMessagesSourceSchema.parse({
+    kind: "discord-messages",
+    ...options.text ? { text: true } : {}
+  });
+}
+function reactions() {
+  return discordReactionsSourceSchema.parse({ kind: "discord-reactions" });
+}
+var discord = {
   provider: "discord",
-  action: "grant-role",
-  roleId
+  grantRole: (roleId) => discordRewardSchema.parse({
+    kind: "integration",
+    provider: "discord",
+    action: "grant-role",
+    roleId
+  }),
+  messages,
+  reactions,
+  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"
+});
+function setting(_kind, schema) {
+  return schema;
+}
+var settings = {
+  pointLedger(options) {
+    const field = {
+      ...options,
+      kind: "point-ledger",
+      default: options.default ? identifier.parse(options.default.key) : ""
+    };
+    return setting(
+      "point-ledger",
+      ledgerSettingSchema.prefault(field.default).meta(field)
+    );
+  },
+  datetime(options) {
+    const field = {
+      ...options,
+      kind: "datetime",
+      default: settingInstant.parse(options.default)
+    };
+    return setting(
+      "datetime",
+      settingInstant.default(field.default).meta(field)
+    );
+  },
+  resource(options) {
+    const field = {
+      ...options,
+      source: resourceSourceSchema.parse(options.source),
+      kind: "resource",
+      default: settingResourceId.parse(options.default ?? "")
+    };
+    return setting(
+      "resource",
+      settingResourceId.default(field.default).meta(field)
+    );
+  },
+  quiz(options) {
+    const value = quizContentSchema.parse(options.default);
+    return setting(
+      "quiz",
+      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 setting(
+      "text",
+      z.string().min(field.minLength).max(field.maxLength).default(field.default).meta(field)
+    );
+  },
+  integer(options) {
+    return setting(
+      "integer",
+      z.number().int().min(options.min).max(options.max).default(options.default).meta({ ...options, kind: "integer" })
+    );
+  },
+  boolean(options) {
+    return setting(
+      "boolean",
+      z.boolean().default(options.default).meta({ ...options, kind: "boolean" })
+    );
+  },
+  choice(options) {
+    return setting(
+      "choice",
+      z.enum(options.options).default(options.default).meta({ ...options, kind: "choice" })
+    );
+  },
+  /** A quest's settings: every field is built with one of the builders above. */
+  object(shape) {
+    return z.object(shape).strict();
+  }
+};
+
+// src/authoring.ts
+import { z as z2 } from "zod";
+import { z as z3 } from "zod";
+var points = (ledger, amount) => pointsRewardSchema.parse({
+  kind: "points",
+  balance: ledgerKey(ledger),
+  amount
 });
 var evidence = {
   text: (options = {}) => ({
@@ -78,60 +375,129 @@ function manual(options) {
     ...options?.actor ? { actor: options.actor } : {}
   };
 }
+var triggerDataSchemas = /* @__PURE__ */ new WeakMap();
+var triggerContentMetrics = /* @__PURE__ */ new WeakMap();
+function trackerTrigger(input, constructor) {
+  const {
+    tracker,
+    beneficiary = "author",
+    on,
+    where,
+    enrollment,
+    since,
+    historical,
+    content: content2
+  } = input;
+  if (!tracker?.source) {
+    throw new Error(
+      constructor === "automatic" ? "automatic() takes no argument, or { tracker } with a tracker handle from defineTracker" : "content() takes { tracker } with a tracker handle from defineTracker"
+    );
+  }
+  const { source } = tracker;
+  if (!sourceIdentities(source)) {
+    throw new Error(
+      'Tracker triggers need attributable records: declare customSource(namespace, { identities: ["wallet"] }) or other identity kinds'
+    );
+  }
+  if (content2 && !sourceContent(source)) {
+    throw new Error(
+      `content() needs a tracker whose source has content: x.search(), or customSource(namespace, { content: { body, metrics } }). Tracker "${tracker.key}" has none; use automatic({ tracker }) instead.`
+    );
+  }
+  if (since === "enrollment" && enrollment !== "required") {
+    throw new Error(
+      `${constructor}() counts from enrollment only on a quest that requires it: add enrollment: "required"`
+    );
+  }
+  const roles = sourceRoles(source);
+  if (!roles.includes(beneficiary)) {
+    throw new Error(
+      source.kind === "custom" ? `Tracker "${tracker.key}" has no "${beneficiary}" account: declare it in customSource(namespace, { accounts: ["${beneficiary}"] })` : `Tracker "${tracker.key}" pays ${roles.map((role) => `"${role}"`).join(" or ")}, not "${beneficiary}"`
+    );
+  }
+  const policy = trackerTriggerPolicySchema.parse({
+    tracker: tracker.key,
+    source: source.kind,
+    // A content item is decided by its first observation; later observations run its stage.
+    on: content2 ? "new-record" : on ?? defaultTriggerMode(source.kind),
+    ...where ? { where } : {},
+    beneficiary,
+    // Defaults are left out too: "none", "activation", and "staff" ("claim" on content).
+    ...enrollment === "required" ? { enrollment } : {},
+    ...since && since !== "activation" ? { since } : {},
+    ...historical && historical !== (content2 ? "claim" : "staff") ? { historical } : {},
+    ...content2 ? { content: content2 } : {}
+  });
+  const schema = sourceDataSchema(source);
+  const issue = schema ? whereSchemaIssue(schema, policy.where) : null;
+  if (issue) {
+    throw new Error(issue);
+  }
+  const trigger = { kind: "automatic", tracker: policy };
+  if (schema) {
+    triggerDataSchemas.set(trigger, schema);
+  }
+  const declared = sourceContent(source);
+  if (declared) {
+    triggerContentMetrics.set(trigger, declared.metrics);
+  }
+  return trigger;
+}
 function automatic(input) {
   if (!input) {
     return { kind: "automatic" };
   }
-  if ("tracker" in input) {
-    const { tracker, beneficiary = "author", on, where } = input;
-    const { source } = tracker;
-    if (source.kind === "x-search" && !xAccountRoles.includes(beneficiary)) {
-      throw new Error(
-        `X trackers pay "author" or "inReplyTo", not "${beneficiary}"`
-      );
-    }
-    if (!sourceIdentities(source)) {
-      throw new Error(
-        'Tracker triggers need attributable records: declare customSource(namespace, { identities: ["wallet"] }) or other identity kinds'
-      );
-    }
-    if (source.kind === "custom" && beneficiary !== "author" && !source.accounts?.includes(beneficiary)) {
-      throw new Error(
-        `Tracker "${tracker.key}" has no "${beneficiary}" account: declare it in customSource(namespace, { accounts: ["${beneficiary}"] })`
-      );
-    }
-    return {
-      kind: "automatic",
-      tracker: trackerTriggerPolicySchema.parse({
-        tracker: tracker.key,
-        source: source.kind,
-        // The source's default mode is left out, so default quests keep the policy shape
-        // earlier SDKs and servers read.
-        ...on && on !== defaultTriggerMode(source.kind) ? { on } : {},
-        ...where ? { where } : {},
-        beneficiary
-      })
-    };
+  return trackerTrigger(input, "automatic");
+}
+function content(input) {
+  if (input && typeof input === "object" && "source" in input && "key" in input && !("tracker" in input)) {
+    throw new Error(
+      "content() takes { tracker }: write content({ tracker: posts }) instead of content(posts)"
+    );
   }
-  return { kind: "automatic", observation: input };
+  return trackerTrigger({ ...input, content: true }, "content");
 }
-var budget = (definition) => budgetSchema.parse(definition);
-var keyed = (key) => ({ kind: "keyed", key });
-var completed = (quest) => ({
-  quest: typeof quest === "string" ? quest : authoringKey(quest)
+var budget = (definition) => {
+  const { key: _, cost, ...properties } = definition;
+  return budgetSchema.parse({
+    ...properties,
+    id: authoringKey(definition),
+    cost: typeof cost === "number" ? cost : { balance: ledgerKey(cost.ledger) }
+  });
+};
+var keyed = (key) => ({
+  kind: "keyed",
+  key
 });
+var progress = (definition) => {
+  const { distinct, ...policy } = definition;
+  return {
+    ...counterPolicySchema.parse({
+      kind: "progress",
+      window: { kind: "lifetime" },
+      ...policy
+    }),
+    distinct
+  };
+};
 var untracked = () => ({ kind: "untracked" });
 var staffHandover = () => ({ kind: "staff-handover" });
+var automaticFulfillment = () => ({ kind: "automatic" });
 function defineTieredReward(input) {
-  const { key: _, id: __, ...properties } = input;
+  const { key: _, tiers, ...properties } = input;
   const key = authoringKey(input);
-  const reward = tieredRewardDefinitionSchema.parse({ id: key, ...properties });
-  return {
+  const reward = tieredRewardDefinitionSchema.parse({
+    id: key,
+    ...properties,
+    tiers: tiers.map(({ key: key2, ...tier }) => ({
+      ...tier,
+      id: authoringKey({ key: key2, ...tier })
+    }))
+  });
+  return resourceHandle("tiered-reward", {
     key: reward.id,
-    /** @deprecated Authoring key alias. Use key. */
-    id: reward.id,
     tier: (tier) => tierRewardSchema.parse({ kind: "tier", reward, tier })
-  };
+  });
 }
 var once = () => ({ kind: "once" });
 function accept(options = {}) {
@@ -142,6 +508,11 @@ function review(options) {
 }
 var decision = {
   accept,
+  defer: (options) => ({ kind: "defer", ...options }),
+  progress: (options) => ({
+    kind: "progress",
+    ...options
+  }),
   reject: (options) => ({
     kind: "reject",
     ...options
@@ -152,7 +523,7 @@ var evaluators = {
   quiz(answerKey, options = {}) {
     const expected = quizAnswersSchema.parse(answerKey);
     const questions = Object.keys(expected);
-    const minimum = z.number().int().min(1).max(questions.length).parse(options.minimumCorrect ?? questions.length);
+    const minimum = z3.number().int().min(1).max(questions.length).parse(options.minimumCorrect ?? questions.length);
     return async ({ input }) => {
       const complete = Object.keys(input.answers).length === questions.length && questions.every((question) => Object.hasOwn(input.answers, question));
       const correct = questions.filter(
@@ -175,206 +546,268 @@ var evaluators = {
     };
   }
 };
-function defineQuest(definition) {
-  const key = authoringKey(definition);
-  const contentTrigger = definition.trigger.kind === "automatic" && definition.trigger.content !== void 0;
-  if (definition.performance && !contentTrigger) {
-    throw new Error("Performance requires a content trigger");
-  }
-  const trackerTrigger = definition.trigger.kind === "automatic" && definition.trigger.tracker !== void 0;
-  if (trackerTrigger && definition.completion.kind === "streak") {
-    throw new Error("Tracker triggers complete once() or keyed()");
-  }
-  const contentCompletion = "perContent" in definition.completion;
-  if (contentTrigger !== contentCompletion) {
-    throw new Error(
-      "Content triggers require perContent completion, and perContent requires a content trigger"
-    );
-  }
-  if (definition.completion.kind === "streak" && (definition.trigger.kind !== "automatic" || !definition.trigger.observation)) {
-    throw new Error("Streaks require an automatic observation trigger");
-  }
-  const bareAutomatic = definition.trigger.kind === "automatic" && !definition.trigger.observation && !definition.trigger.content && !definition.trigger.tracker;
-  if (bareAutomatic && !definition.requires?.length) {
-    throw new Error(
-      "A bare automatic() quest needs at least one requires entry, such as requires: [completed(quest)]. Give it an observation, content or tracker trigger, or a prerequisite."
-    );
-  }
-  if (bareAutomatic && definition.completion.kind === "keyed") {
-    throw new Error(
-      "A bare automatic() quest cannot use keyed() completion. Give it an observation, content or tracker trigger, or use once()."
-    );
-  }
-  if (definition.trigger.kind === "manual" && definition.trigger.input !== "none" && !definition.evaluate) {
-    throw new Error("Evidence quests require an evaluator");
-  }
-  const fields = Object.fromEntries(
-    Object.entries(definition.settings.shape).map(([key2, schema]) => [
-      key2,
-      settingFieldSchema.parse(schema.meta())
-    ])
-  );
-  const where = definition.trigger.kind === "automatic" ? definition.trigger.tracker?.where : void 0;
-  for (const bound of where && !("equals" in where) ? [where.gt, where.gte, where.lt, where.lte] : []) {
-    if (typeof bound === "object" && fields[bound.setting]?.kind !== "integer") {
+function questBuilder(template) {
+  return function defineQuest2(definition) {
+    const key = authoringKey(definition);
+    const integrations = [
+      ...new Set(
+        (definition.integrations ?? []).map(
+          (module) => evaluatorIntegrationProviderSchema.parse(module.provider)
+        )
+      )
+    ];
+    const contentTrigger = definition.trigger.kind === "automatic" && definition.trigger.tracker?.content === true;
+    const trackerTrigger2 = definition.trigger.kind === "automatic" && definition.trigger.tracker !== void 0;
+    const completion = definition.completion;
+    if (contentTrigger && completion !== void 0) {
       throw new Error(
-        `The tracker filter compares with setting "${bound.setting}", which is not an integer setting`
+        "A content quest completes once per content item: remove its completion"
       );
     }
-  }
-  function describe(input) {
-    const settings2 = definition.settings.parse(input);
-    const values = parseSettings(fields, settings2);
-    const rewards = rewardBundleSchema.parse(
-      typeof definition.rewards === "function" ? definition.rewards({ settings: settings2 }) : definition.rewards
-    );
-    return questDescriptionSchema.parse({
-      quest: key,
-      runtimeVersion: 2,
-      title: typeof definition.title === "function" ? definition.title({ settings: settings2 }) : definition.title,
-      presentation: definition.presentation?.({ settings: settings2 }) ?? {},
-      fields,
-      values,
-      rewards,
-      humanReview: definition.review?.({ settings: settings2 })?.enabled ?? true,
-      trigger: definition.trigger,
-      ...definition.performance ? {
-        performance: contentPerformancePolicySchema.parse({
+    if (!contentTrigger && completion === void 0) {
+      throw new Error(
+        "A quest needs a completion, such as once(), keyed(...), streak(...) or progress(...)"
+      );
+    }
+    validateQuestShape(
+      {
+        trigger: definition.trigger,
+        completion: completion ?? { kind: "keyed" },
+        requires: definition.requires ?? [],
+        performance: definition.performance ? contentPerformancePolicySchema.parse({
           metrics: definition.performance.metrics,
           maxAgeMs: definition.performance.maxAgeMs
-        })
-      } : {},
-      integrations: [
-        .../* @__PURE__ */ new Set([
-          ...definition.integrations ?? [],
-          ...rewards.flatMap(
-            (reward) => reward.kind === "integration" ? [reward.provider] : []
-          ),
-          ...Object.values(fields).flatMap(
-            (field) => field.kind === "resource" && field.source.provider !== "domino" ? [field.source.provider] : []
-          )
-        ])
-      ],
-      completion: definition.completion.kind === "streak" ? definition.completion : { kind: definition.completion.kind },
-      visibility: definition.visibility ?? "visible",
-      // Only when set: a release without the key is hidden and stays readable by older clients.
-      ...definition.profile ? { profile: definition.profile } : {},
-      budgets: definition.budgets ?? [],
-      requires: definition.requires ?? []
-    });
-  }
-  return {
-    key,
-    /** @deprecated Authoring key alias. Use key. */
-    id: key,
-    describe,
-    async evaluate(ctx) {
-      const settings2 = definition.settings.parse(ctx.settings);
-      const tracker = trackerTrigger ? trackerTriggerContextSchema.parse(ctx.tracker) : null;
-      if (ctx.performance) {
-        if (!definition.performance) {
-          throw new Error("Quest has no performance evaluator");
+        }) : void 0
+      },
+      { template }
+    );
+    if (definition.performance) {
+      const declared = triggerContentMetrics.get(definition.trigger) ?? [];
+      const unknown = definition.performance.metrics.filter(
+        (metric) => !declared.includes(metric)
+      );
+      if (unknown.length) {
+        throw new Error(
+          `The tracker's source does not measure ${unknown.join(", ")}`
+        );
+      }
+    }
+    if (definition.trigger.kind === "manual" && definition.trigger.input !== "none" && !definition.evaluate) {
+      throw new Error("Evidence quests require an evaluator");
+    }
+    const fields = Object.fromEntries(
+      Object.entries(definition.settings.shape).map(([key2, schema]) => {
+        const field = settingFieldSchema.safeParse(schema.meta());
+        if (!field.success) {
+          throw new Error(
+            `Setting "${key2}" is not a quest setting: build it with a settings builder, such as settings.integer({ label, default, min, max })`
+          );
         }
-        const sample = contentPerformanceSnapshotSchema.parse(ctx.performance);
-        const metrics = z.record(
-          z.enum(definition.performance.metrics),
-          z.number().int().safe().nonnegative()
-        ).parse(sample.metrics);
-        const result2 = await definition.performance.evaluate({
+        return [key2, field.data];
+      })
+    );
+    for (const setting2 of whereSettings(
+      definition.trigger.kind === "automatic" ? definition.trigger.tracker?.where : void 0
+    )) {
+      if (fields[setting2]?.kind !== "integer") {
+        throw new Error(
+          `The tracker filter compares with setting "${setting2}", which is not an integer setting`
+        );
+      }
+    }
+    function describe(input) {
+      const settings2 = definition.settings.parse(input);
+      const values = parseSettings(fields, settings2);
+      const rewards = rewardBundleSchema.parse(
+        typeof definition.rewards === "function" ? definition.rewards({ settings: settings2 }) : definition.rewards
+      );
+      const required = [
+        ...rewards.flatMap(
+          (reward) => reward.kind === "integration" ? [reward.provider] : []
+        ),
+        ...Object.values(fields).flatMap(
+          (field) => field.kind === "resource" && field.source.provider !== "domino" ? [field.source.provider] : []
+        )
+      ];
+      for (const provider of required) {
+        if (!integrations.includes(provider)) {
+          throw new Error(`Declare the ${provider} integration on this quest`);
+        }
+      }
+      return questDescriptionSchema.parse({
+        quest: key,
+        evaluatorProtocol,
+        title: typeof definition.title === "function" ? definition.title({ settings: settings2 }) : definition.title,
+        presentation: definition.presentation?.({ settings: settings2 }) ?? {},
+        fields,
+        values,
+        rewards,
+        humanReview: definition.review?.({ settings: settings2 })?.enabled ?? true,
+        trigger: definition.trigger,
+        ...definition.performance ? {
+          performance: contentPerformancePolicySchema.parse({
+            metrics: definition.performance.metrics,
+            maxAgeMs: definition.performance.maxAgeMs
+          })
+        } : {},
+        integrations,
+        // A content quest's completion is keyed by its content item, with a key Relay owns.
+        completion: !completion ? { kind: "keyed" } : completion.kind === "progress" ? {
+          kind: completion.kind,
+          goal: completion.goal,
+          window: completion.window,
+          repeat: completion.repeat
+        } : completion.kind === "streak" ? completion : { kind: completion.kind },
+        visibility: definition.visibility ?? "visible",
+        profile: definition.profile ?? { visible: false },
+        budgets: definition.budgets ?? [],
+        requires: definition.requires ?? [],
+        ...definition.campaign ? { campaign: definition.campaign } : {},
+        ...definition.availability ? { availability: definition.availability } : {}
+      });
+    }
+    return resourceHandle("quest", {
+      protocol: evaluatorProtocol,
+      key,
+      describe,
+      async evaluate(ctx) {
+        const settings2 = definition.settings.parse(ctx.settings);
+        const pinned = trackerTrigger2 ? trackerTriggerContextSchema.parse(ctx.tracker) : null;
+        const schema = triggerDataSchemas.get(definition.trigger);
+        const dataIssue = pinned && schema ? trackerDataIssue(schema, pinned.record.data) : null;
+        if (dataIssue) {
+          return decisionSchema.parse({
+            kind: "reject",
+            reason: `The record's data does not match the data schema this quest was built with: ${dataIssue.path} ${dataIssue.reason}`
+          });
+        }
+        const tracker = pinned;
+        if (ctx.performance) {
+          if (!definition.performance) {
+            throw new Error("Quest has no performance evaluator");
+          }
+          const sample = contentPerformanceSnapshotSchema.parse(ctx.performance);
+          const metrics = z3.record(
+            z3.enum(definition.performance.metrics),
+            z3.number().int().safe().nonnegative()
+          ).parse(sample.metrics);
+          const result2 = await definition.performance.evaluate({
+            settings: settings2,
+            member: ctx.member,
+            tracker,
+            metrics,
+            observedAt: sample.observedAt
+          });
+          if (!result2) {
+            throw new Error("Performance evaluator returned no decision");
+          }
+          if (result2.rewards !== void 0) {
+            throw new Error(
+              "A performance evaluator cannot select rewards. It gates the rewards content evaluation selected: return accept, review or reject with a reason only."
+            );
+          }
+          return decisionSchema.parse(
+            result2.kind === "accept" ? { kind: "accept", rewards: sample.rewards } : result2.kind === "review" && ctx.humanReview ? {
+              kind: "review",
+              reason: result2.reason,
+              rewards: sample.rewards
+            } : {
+              kind: "reject",
+              reason: result2.reason,
+              ...result2.kind === "review" ? { requestedReview: true } : {}
+            }
+          );
+        }
+        const result = definition.evaluate ? await definition.evaluate({
           settings: settings2,
           member: ctx.member,
-          content: admittedContentSchema.parse(ctx.content),
-          metrics,
-          observedAt: sample.observedAt
-        });
-        if (!result2) {
-          throw new Error("Performance evaluator returned no decision");
+          input: ctx.input,
+          tracker,
+          eligibleAt: ctx.eligibleAt,
+          calendar: ctx.calendar,
+          now: ctx.now,
+          review: ctx.review,
+          trackers: schemaCheckedReader(ctx.trackers),
+          wallet: ctx.wallet,
+          images: ctx.images,
+          // The declared module providers select these keys; unrelated host readers are omitted.
+          ...Object.fromEntries(
+            integrations.map((provider) => [provider, ctx[provider]])
+          )
+        }) : decision.accept();
+        if (!result) {
+          throw new Error("Evaluator returned no decision");
         }
-        if (result2.rewards !== void 0) {
-          throw new Error(
-            "A performance evaluator cannot select rewards. It gates the rewards content evaluation selected: return accept, review or reject with a reason only."
-          );
+        if (result.kind === "review" && !ctx.humanReview) {
+          return decisionSchema.parse({
+            kind: "reject",
+            reason: result.reason,
+            requestedReview: true
+          });
         }
         return decisionSchema.parse(
-          result2.kind === "accept" ? {
-            kind: "accept",
-            rewards: sample.rewards,
-            completionKey: admittedContentSchema.parse(ctx.content).completionKey
-          } : result2.kind === "review" && ctx.humanReview ? {
-            kind: "review",
-            reason: result2.reason,
-            rewards: sample.rewards
-          } : { kind: "reject", reason: result2.reason }
+          result.kind === "accept" || result.kind === "review" ? {
+            ...result,
+            rewards: result.rewards ?? ctx.rewards,
+            ...completion?.kind === "keyed" || completion?.kind === "progress" ? {
+              completionKey: completion.kind === "progress" ? completion.distinct({ ...ctx, tracker: pinned }) : result.completionKey ?? completion.key({ ...ctx, tracker: pinned })
+            } : {}
+          } : result
         );
       }
-      const result = definition.evaluate ? await definition.evaluate({
-        settings: settings2,
-        member: ctx.member,
-        input: ctx.input,
-        content: contentTrigger ? admittedContentSchema.parse(ctx.content) : null,
-        observation: ctx.observation ?? null,
-        tracker,
-        eligibleAt: ctx.eligibleAt,
-        review: ctx.review,
-        trackers: ctx.trackers,
-        wallet: ctx.wallet,
-        x: ctx.x,
-        images: ctx.images,
-        discord: ctx.discord
-      }) : decision.accept();
-      if (!result) {
-        throw new Error("Evaluator returned no decision");
-      }
-      if (result.kind === "review" && !ctx.humanReview) {
-        return decisionSchema.parse({ kind: "reject", reason: result.reason });
-      }
-      return decisionSchema.parse(
-        result.kind === "accept" || result.kind === "review" ? {
-          ...result,
-          rewards: result.rewards ?? ctx.rewards,
-          ...definition.completion.kind === "keyed" ? {
-            completionKey: definition.completion.key({
-              ...ctx,
-              tracker
-            })
-          } : {}
-        } : result
-      );
-    }
+    });
   };
 }
-var defineQuestType = defineQuest;
+var defineQuest = questBuilder(false);
+var defineQuestType = questBuilder(true);
 export {
+  CapabilityError,
   automatic,
+  automaticFulfillment,
+  balanceAtLeast,
   budget,
+  calendar,
+  capabilityErrorCodes,
   completed,
   content,
+  cosmosDenomSchema,
+  cosmosNetworkSchema,
+  count,
   customSource,
   decision,
+  defineCampaign,
   defineEngagementReward,
+  defineGroup,
   defineLeaderboard,
+  defineLedger,
+  defineOffer,
   defineQuest,
   defineQuestType,
   defineReferral,
   defineTieredReward,
   defineTracker,
   discord,
-  discordRole,
+  earned,
   evaluators,
   evidence,
   formatUnits,
+  inGroup,
   isEvmChainId,
   keyed,
   manual,
   once,
   parseUnits,
-  perContent,
   pointLedgers,
   points,
+  progress,
+  questCompleted,
+  rolling,
   settings,
   staffHandover,
   streak,
+  trackerDataSchema,
   trackerTriggerContextSchema,
   untracked,
-  x
+  x,
+  z2 as z
 };