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

package/README.md

@@ -6,6 +6,18 @@ Author quests and connect an application to Domino Relay.
 pnpm add @domino-sdk/relay
 ```
 
-Use `@domino-sdk/relay/authoring` for quest definitions, `/browser` for browser integrations, `/portal-proxy` for server proxies, and `/build` for bundling authored modules.
+| Import                           | For                                                                                        |
+| -------------------------------- | ------------------------------------------------------------------------------------------ |
+| `@domino-sdk/relay`              | The participant client (`createRelayClient`), `RelayError`, and the types it returns       |
+| `@domino-sdk/relay/browser`      | The browser client with durable submission recovery, wallet signers and sign-in options    |
+| `@domino-sdk/relay/react`        | React hooks over the browser client                                                        |
+| `@domino-sdk/relay/avatar`       | Generated default avatars (`avatarSrc`, `defaultAvatar`)                                   |
+| `@domino-sdk/relay/authoring`    | Quest, tracker, leaderboard, referral and engagement definitions, and evaluator types     |
+| `@domino-sdk/relay/schema`       | Zod schemas of Relay's API bodies, deployments, tracker records and observations           |
+| `@domino-sdk/relay/build`        | Bundling authored modules; needs `esbuild` installed                                       |
+| `@domino-sdk/relay/portal-proxy` | Server proxies and hosted app Workers                                                      |
+| `@domino-sdk/relay/vite`         | The Vite plugin that keeps server code out of the browser build                            |
+
+`@domino-sdk/relay/internal` is shared by Relay's own services and Console. It is not a supported API and can change in any release.
 
 Requires Node.js 24 for tooling. Proprietary software; `UNLICENSED`.

package/build.mjs

@@ -1,5 +1,21 @@
 import { resolve, dirname } from "node:path"
-import { build } from "esbuild"
+
+// esbuild is an optional peer dependency: only quest builds need it, so apps that use the runtime
+// client do not install its native binary. `@domino-sdk/relay-cli` depends on it.
+async function esbuild() {
+  try {
+    return await import("esbuild")
+  } catch (error) {
+    if (error?.code === "ERR_MODULE_NOT_FOUND") {
+      throw new Error(
+        "@domino-sdk/relay/build needs esbuild. Install it next to @domino-sdk/relay, or build with the domino CLI (@domino-sdk/relay-cli).",
+        { cause: error }
+      )
+    }
+
+    throw error
+  }
+}
 
 /** Bundle an authored quest without evaluating developer code in the build process. */
 export async function buildQuest(entry, options = {}) {
@@ -10,6 +26,7 @@ export async function buildQuest(entry, options = {}) {
     throw new Error("Invalid quest export name")
   }
 
+  const { build } = await esbuild()
   const result = await build({
     ...(options.exportName
       ? {

package/dist/authoring.d.ts

@@ -1,7 +1,309 @@
-import { A as AdmittedContent, O as Observation, T as TrackerTriggerContext, a as TrackerReader, X as XReader, I as ImageReader, D as DiscordMember, b as DiscordMessage, W as WalletConnection, S as SolanaBalance, L as LinkedWallet, c as WalletBalanceQuery, d as WalletBalance, e as TrackerDefinition, f as TrackerTriggerMode, g as TrackerWhere, o as observationTriggerSchema, h as TrackerTriggerPolicy, B as Budget, i as AuthoringIdentity, C as ContentMetric, j as IntegrationProvider, k as StreakPolicy, l as TextEvidence, U as UrlEvidence, m as TextOptions, n as UrlOptions } from './submission-input-CZDukyb3.js';
-export { E as EvmChainId, p as content, q as customSource, r as defineEngagementReward, s as defineLeaderboard, t as defineReferral, u as defineTracker, v as discord, w as formatUnits, x as isEvmChainId, y as parseUnits, z as perContent, F as pointLedgers, G as settings, H as streak, J as trackerTriggerContextSchema, K as x } from './submission-input-CZDukyb3.js';
 import { z } from 'zod';
-import { TextReviewInput, TextResult, PhotoResult, rewardSchema, triggerSchema, QuestPresentation, QuestProfile, QuizEvidence, Decision, TieredRewardDefinition } from './schema.js';
+import { C as ContentPolicy, g as ContentMetric, E as EngagementDefinition, l as leaderboardAuthoringSchema, r as referralAuthoringSchema, h as AdmittedContent, D as DiscordMember, T as TextEvidence, U as UrlEvidence, e as TextOptions, f as UrlOptions } from './submission-input-C9qm9ixd.js';
+import { Q as QuizContent, a as StreakPolicy } from './streaks-CwGReWGt.js';
+import { T as TrackerDefinition, I as IdentityKind, t as trackerDefinitionSchema, R as ResourceSource, O as Observation, a as TrackerTriggerContext, b as TrackerReader, X as XReader, D as DiscordMessage, c as TrackerTriggerMode, d as TrackerWhere, o as observationTriggerSchema, e as TrackerTriggerPolicy, B as Budget, f as IntegrationProvider } from './integrations-C3Sp558f.js';
+export { g as trackerTriggerContextSchema } from './integrations-C3Sp558f.js';
+import { I as ImageReader } from './images--vZ9U0kr.js';
+import { d as TextReviewInput, e as TextResult, P as PhotoResult, r as rewardSchema, t as triggerSchema, Q as QuestPresentation, a as QuestProfile, b as QuizEvidence, D as Decision, f as TieredRewardDefinition } from './schema-pnuWqvGn.js';
+import { h as WalletConnection, S as SolanaBalance, L as LinkedWallet, i as WalletBalanceQuery, j as WalletBalance } from './wallet-BGOfFkG9.js';
+export { E as EvmChainId, k as isEvmChainId } from './wallet-BGOfFkG9.js';
+export { f as formatUnits, p as parseUnits } from './units-CwgsPB_r.js';
+
+/** Legacy `id` names an authoring key, never a server resource ID. */
+type AuthoringIdentity = {
+    key: string;
+    id?: string;
+} | {
+    key?: never; /** @deprecated Use key. */
+    id: string;
+};
+
+/** Discover posts automatically; historical release remains an explicit policy. */
+declare function content(tracker: TrackerDefinition, policy?: Partial<Pick<ContentPolicy, "enrollment" | "posts" | "historical">>): {
+    kind: "automatic";
+    content: {
+        tracker: string;
+        window: {
+            start: number;
+            end?: number | undefined;
+        };
+        enrollment: "none" | "required";
+        posts: "after-enrollment" | "since-start";
+        historical: "automatic" | "claim" | "staff";
+    };
+};
+declare function perContent(): {
+    kind: "keyed";
+    perContent: true;
+    key: (ctx: {
+        content?: AdmittedContent | null;
+    }) => string;
+};
+/** One independent cumulative formula; management changes capture a new scoring boundary. */
+declare function defineEngagementReward<const M extends readonly [ContentMetric, ...ContentMetric[]]>(input: {
+    key: string;
+    qualifiedBy: string | {
+        key: string;
+    };
+    balance: string;
+    metrics: M;
+    baseline: "historical";
+    maxAgeMs?: number;
+    budget?: EngagementDefinition["budget"];
+    target: (input: {
+        metrics: Record<M[number], number>;
+    }) => number;
+}): {
+    key: string;
+    describe: () => {
+        key: string;
+        qualifiedBy: string;
+        balance: string;
+        metrics: ("likes" | "replies" | "reposts" | "quotes" | "views" | "bookmarks")[];
+        baseline: "historical";
+        maxAgeMs: number;
+        budget: {
+            projectDaily?: number | undefined;
+            memberDaily?: number | undefined;
+            projectLifetime?: number | undefined;
+        };
+    };
+    score(raw: unknown): {
+        target: number;
+        baseline: number;
+    };
+};
+/**
+ * One milestone per quest, after `days` consecutive community days with an accepted attempt.
+ * Multiple accepted attempts occupy one day. The day comes from the attempt's trusted occurrence
+ * time: a tracker record's (or observation's) `occurredAt` for `automatic({ tracker })`, and the
+ * submission's admission time for `manual()`, so a manual streak counts the days a member
+ * submitted. Not available on content quests or prerequisite-only `automatic()`.
+ */
+declare const streak: (options: Omit<StreakPolicy, "kind">) => StreakPolicy;
+declare function defineReferral(input: Omit<z.input<typeof referralAuthoringSchema>, "key" | "id"> & AuthoringIdentity): {
+    id: string;
+    title: string;
+    rewards: {
+        inviter: ({
+            kind: "tier";
+            reward: {
+                id: string;
+                title: string;
+                tiers: {
+                    id: string;
+                    title: string;
+                }[];
+                inventory: {
+                    kind: "untracked";
+                };
+                fulfillment: {
+                    kind: "staff-handover";
+                };
+            };
+            tier: string;
+        } | {
+            kind: "points";
+            balance: string;
+            amount: number;
+        })[];
+        invitee: ({
+            kind: "tier";
+            reward: {
+                id: string;
+                title: string;
+                tiers: {
+                    id: string;
+                    title: string;
+                }[];
+                inventory: {
+                    kind: "untracked";
+                };
+                fulfillment: {
+                    kind: "staff-handover";
+                };
+            };
+            tier: string;
+        } | {
+            kind: "points";
+            balance: string;
+            amount: number;
+        })[];
+    };
+    qualification: {
+        kind: "signup";
+    } | {
+        kind: "quest";
+        quest: string;
+    } | {
+        kind: "external";
+    };
+    enabled: boolean;
+    inviterGroup?: string | undefined;
+    milestones: {
+        id: string;
+        count: number;
+        rewards: ({
+            kind: "tier";
+            reward: {
+                id: string;
+                title: string;
+                tiers: {
+                    id: string;
+                    title: string;
+                }[];
+                inventory: {
+                    kind: "untracked";
+                };
+                fulfillment: {
+                    kind: "staff-handover";
+                };
+            };
+            tier: string;
+        } | {
+            kind: "points";
+            balance: string;
+            amount: number;
+        })[];
+    }[];
+    bonuses: {
+        id: string;
+        balance: string;
+        basisPoints: number;
+        external: boolean;
+        quests?: string[] | undefined;
+        durationDays?: number | undefined;
+        maxPoints?: number | undefined;
+    }[];
+    key: string;
+};
+declare function defineLeaderboard(input: Omit<z.input<typeof leaderboardAuthoringSchema>, "key" | "id"> & AuthoringIdentity): {
+    id: string;
+    title: string;
+    balance: string;
+    group?: string | undefined;
+    score: {
+        kind: "balance";
+    } | {
+        window: {
+            kind: "fixed";
+            start: number;
+            end: number;
+        } | {
+            kind: "all-time";
+        } | {
+            kind: "rolling";
+            days: number;
+        } | {
+            kind: "calendar";
+            period: "day" | "week" | "month";
+            timeZone: string;
+        };
+        kind: "earned";
+        quests?: string[] | undefined;
+    } | {
+        kind: "net";
+        window: {
+            kind: "fixed";
+            start: number;
+            end: number;
+        } | {
+            kind: "all-time";
+        } | {
+            kind: "rolling";
+            days: number;
+        } | {
+            kind: "calendar";
+            period: "day" | "week" | "month";
+            timeZone: string;
+        };
+    };
+    access: "participants" | "public";
+    key: string;
+};
+declare const x: {
+    search: (input: {
+        query: string;
+    }) => {
+        kind: "x-search";
+        query: string;
+    };
+};
+/**
+ * Records your own code sends with `trackers.ingest`. With `identities`, each record's author, and
+ * each named account in `accounts`, is a verified identity of one of those kinds, which Relay
+ * attributes to the member who verified it, so quests can trigger from the tracker. A record states
+ * each account's `kind` unless the source names exactly one.
+ */
+declare const customSource: (namespace: string, options?: {
+    identities?: IdentityKind[];
+    accounts?: string[];
+}) => {
+    kind: "custom";
+    namespace: string;
+    identities?: ("x" | "discord" | "member" | "wallet")[] | undefined;
+    accounts?: string[] | undefined;
+    authors?: "wallet" | undefined;
+};
+declare function defineTracker(input: z.input<typeof trackerDefinitionSchema>): TrackerDefinition;
+type ChannelTypes = Extract<ResourceSource, {
+    resource: "channel";
+}>["types"];
+declare const discord: {
+    roles(options?: {
+        assignable?: boolean;
+    }): ResourceSource;
+    channels(options?: {
+        types?: ChannelTypes;
+    }): ResourceSource;
+};
+declare const pointLedgers: () => ResourceSource;
+type Label = {
+    label: string;
+    description?: string;
+};
+declare const settings: {
+    pointLedger(options: Label & {
+        default: string;
+    }): z.ZodDefault<z.ZodString>;
+    datetime(options: Label & {
+        default: string;
+    }): z.ZodDefault<z.ZodPipe<z.ZodISODateTime, z.ZodTransform<string, string>>>;
+    resource(options: Label & {
+        source: ResourceSource;
+        default?: string;
+    }): z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>;
+    quiz(options: Label & {
+        default: QuizContent;
+    }): z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        prompt: z.ZodString;
+        choices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+        correct: z.ZodString;
+    }, z.core.$strict>>>;
+    text(options: Label & {
+        default: string;
+        minLength?: number;
+        maxLength?: number;
+        multiline?: boolean;
+    }): z.ZodDefault<z.ZodString>;
+    integer(options: Label & {
+        default: number;
+        min: number;
+        max: number;
+    }): z.ZodDefault<z.ZodNumber>;
+    boolean(options: Label & {
+        default: boolean;
+    }): z.ZodDefault<z.ZodBoolean>;
+    choice<const T extends readonly [string, ...string[]]>(options: Label & {
+        options: T;
+        default: T[number];
+    }): z.ZodDefault<z.ZodEnum<{ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never>>;
+    object<T extends Record<string, z.ZodType>>(shape: T): z.ZodObject<{ -readonly [P in keyof T]: T[P]; }, z.core.$strict>;
+};
 
 type Reward = z.infer<typeof rewardSchema>;
 declare const points: (balance: string, amount: number) => {
@@ -99,7 +401,7 @@ declare function automatic(input: TrackerTriggerInput): {
 declare const budget: (definition: Budget) => {
     id: string;
     scope: "member" | "project";
-    period: "lifetime" | "day" | "week";
+    period: "day" | "lifetime" | "week";
     limit: number;
     cost: number | {
         balance: string;
@@ -399,12 +701,12 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
             kind: "resource";
             default: string;
             source: {
-                provider: "domino";
-                resource: "point-ledger";
-            } | {
                 provider: "discord";
                 resource: "channel";
                 types: ("text" | "announcement")[];
+            } | {
+                provider: "domino";
+                resource: "point-ledger";
             } | {
                 provider: "discord";
                 resource: "role";
@@ -501,9 +803,9 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
                     start: number;
                     end?: number | undefined;
                 };
-                enrollment: "required" | "none";
+                enrollment: "none" | "required";
                 posts: "after-enrollment" | "since-start";
-                historical: "staff" | "automatic" | "claim";
+                historical: "automatic" | "claim" | "staff";
             } | undefined;
             tracker?: {
                 tracker: string;
@@ -537,7 +839,7 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
                 minLength: number;
                 maxLength: number;
             };
-            actor?: "staff" | "member" | undefined;
+            actor?: "member" | "staff" | undefined;
         } | {
             kind: "manual";
             input: "url";
@@ -545,11 +847,11 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
                 required: boolean;
                 allowedHosts?: string[] | undefined;
             };
-            actor?: "staff" | "member" | undefined;
+            actor?: "member" | "staff" | undefined;
         } | {
             kind: "manual";
-            input: "photo" | "quiz" | "none";
-            actor?: "staff" | "member" | undefined;
+            input: "none" | "quiz" | "photo";
+            actor?: "member" | "staff" | undefined;
         };
         requires: {
             quest: string;
@@ -567,7 +869,7 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
         budgets: {
             id: string;
             scope: "member" | "project";
-            period: "lifetime" | "day" | "week";
+            period: "day" | "lifetime" | "week";
             limit: number;
             cost: number | {
                 balance: string;
@@ -591,4 +893,4 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
  * Console instances receive independent quest identities and pinned versions. */
 declare const defineQuestType: typeof defineQuest;
 
-export { type EvaluationContext, type PerformanceOutcome, TrackerTriggerContext, type TrackerTriggerInput, WalletBalance, WalletBalanceQuery, automatic, budget, completed, decision, defineQuest, defineQuestType, defineTieredReward, discordRole, evaluators, evidence, keyed, manual, once, points, staffHandover, untracked };
+export { type EvaluationContext, ImageReader, type PerformanceOutcome, TrackerReader, TrackerTriggerContext, type TrackerTriggerInput, WalletBalance, WalletBalanceQuery, XReader, automatic, budget, completed, content, customSource, decision, defineEngagementReward, defineLeaderboard, defineQuest, defineQuestType, defineReferral, defineTieredReward, defineTracker, discord, discordRole, evaluators, evidence, keyed, manual, once, perContent, pointLedgers, points, settings, staffHandover, streak, untracked, x };

package/dist/authoring.js

@@ -1,49 +1,203 @@
 import {
-  authoringKey,
-  defineEngagementReward,
-  defineLeaderboard,
-  defineReferral,
   formatUnits,
   parseUnits
-} from "./chunk-ZKJBCQNI.js";
+} from "./chunk-V7UKZLHA.js";
 import {
-  isEvmChainId
-} from "./chunk-XEQDW7FM.js";
+  authoringKey,
+  engagementDefinitionSchema,
+  engagementScoreInputSchema,
+  engagementScoreSchema,
+  isEvmChainId,
+  leaderboardAuthoringSchema,
+  referralAuthoringSchema
+} from "./chunk-V7EZUZ3Z.js";
 import {
   admittedContentSchema,
   budgetSchema,
-  content,
   contentPerformancePolicySchema,
   contentPerformanceSnapshotSchema,
-  customSource,
+  contentPolicySchema,
+  customSourceSchema,
   decisionSchema,
   defaultTriggerMode,
-  defineTracker,
-  discord,
+  identifier,
   integrationRewardSchema,
   parseSettings,
-  perContent,
-  pointLedgers,
   pointsRewardSchema,
   questDescriptionSchema,
   quizAnswersSchema,
+  quizContentSchema,
+  resourceSourceSchema,
   rewardBundleSchema,
   settingFieldSchema,
-  settings,
+  settingInstant,
+  settingResourceId,
   sourceIdentities,
-  streak,
+  streakPolicySchema,
   textOptionsSchema,
   tierRewardSchema,
   tieredRewardDefinitionSchema,
+  trackerDefinitionSchema,
   trackerTriggerContextSchema,
   trackerTriggerPolicySchema,
   urlOptionsSchema,
-  x,
-  xAccountRoles
-} from "./chunk-BRESOTKV.js";
+  xAccountRoles,
+  xSearchSourceSchema
+} from "./chunk-VARGF4JS.js";
 
-// src/authoring.ts
+// src/builders.ts
 import { z } from "zod";
+function content(tracker, policy = {}) {
+  if (tracker.source.kind !== "x-search") {
+    throw new Error("Content quests require an X tracker");
+  }
+  return {
+    kind: "automatic",
+    content: contentPolicySchema.parse({
+      tracker: tracker.key,
+      window: tracker.window,
+      ...policy
+    })
+  };
+}
+function perContent() {
+  return {
+    kind: "keyed",
+    perContent: true,
+    key: (ctx) => {
+      if (!ctx.content) {
+        throw new Error("perContent requires an admitted content item");
+      }
+      return ctx.content.completionKey;
+    }
+  };
+}
+function defineEngagementReward(input) {
+  const { target, ...config } = input;
+  const definition = engagementDefinitionSchema.parse({
+    ...config,
+    qualifiedBy: typeof input.qualifiedBy === "string" ? input.qualifiedBy : input.qualifiedBy.key
+  });
+  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) => streakPolicySchema.parse({ kind: "streak", ...options });
+function defineReferral(input) {
+  const definition = referralAuthoringSchema.parse(input);
+  return {
+    ...definition,
+    /** @deprecated Use key. */
+    id: definition.key
+  };
+}
+function defineLeaderboard(input) {
+  const definition = leaderboardAuthoringSchema.parse(input);
+  return {
+    ...definition,
+    /** @deprecated Use key. */
+    id: definition.key
+  };
+}
+var x = {
+  search: (input) => xSearchSourceSchema.parse({ kind: "x-search", ...input })
+};
+var customSource = (namespace, options = {}) => customSourceSchema.parse({
+  kind: "custom",
+  namespace,
+  ...options
+});
+function defineTracker(input) {
+  return trackerDefinitionSchema.parse(input);
+}
+var discord = {
+  roles(options = {}) {
+    return resourceSourceSchema.parse({
+      provider: "discord",
+      resource: "role",
+      assignable: options.assignable ?? false
+    });
+  },
+  channels(options = {}) {
+    return resourceSourceSchema.parse({
+      provider: "discord",
+      resource: "channel",
+      types: options.types ?? ["text", "announcement"]
+    });
+  }
+};
+var pointLedgers = () => ({
+  provider: "domino",
+  resource: "point-ledger"
+});
+var settings = {
+  pointLedger(options) {
+    const field = {
+      ...options,
+      kind: "point-ledger",
+      default: identifier.parse(options.default)
+    };
+    return identifier.default(field.default).meta(field);
+  },
+  datetime(options) {
+    const field = {
+      ...options,
+      kind: "datetime",
+      default: settingInstant.parse(options.default)
+    };
+    return settingInstant.default(field.default).meta(field);
+  },
+  resource(options) {
+    const field = {
+      ...options,
+      source: resourceSourceSchema.parse(options.source),
+      kind: "resource",
+      default: settingResourceId.parse(options.default ?? "")
+    };
+    return settingResourceId.default(field.default).meta(field);
+  },
+  quiz(options) {
+    const value = quizContentSchema.parse(options.default);
+    return quizContentSchema.default(value).meta({ ...options, default: value, kind: "quiz" });
+  },
+  text(options) {
+    const field = {
+      ...options,
+      kind: "text",
+      minLength: options.minLength ?? 1,
+      maxLength: options.maxLength ?? 2e3,
+      multiline: options.multiline ?? false
+    };
+    return z.string().min(field.minLength).max(field.maxLength).default(field.default).meta(field);
+  },
+  integer(options) {
+    return z.number().int().min(options.min).max(options.max).default(options.default).meta({ ...options, kind: "integer" });
+  },
+  boolean(options) {
+    return z.boolean().default(options.default).meta({ ...options, kind: "boolean" });
+  },
+  choice(options) {
+    return z.enum(options.options).default(options.default).meta({ ...options, kind: "choice" });
+  },
+  object(shape) {
+    return z.object(shape).strict();
+  }
+};
+
+// src/authoring.ts
+import { z as z2 } from "zod";
 var points = (balance, amount) => pointsRewardSchema.parse({ kind: "points", balance, amount });
 var discordRole = (roleId) => integrationRewardSchema.parse({
   kind: "integration",
@@ -152,7 +306,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 = z2.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(
@@ -270,9 +424,9 @@ function defineQuest(definition) {
           throw new Error("Quest has no performance evaluator");
         }
         const sample = contentPerformanceSnapshotSchema.parse(ctx.performance);
-        const metrics = z.record(
-          z.enum(definition.performance.metrics),
-          z.number().int().safe().nonnegative()
+        const metrics = z2.record(
+          z2.enum(definition.performance.metrics),
+          z2.number().int().safe().nonnegative()
         ).parse(sample.metrics);
         const result2 = await definition.performance.evaluate({
           settings: settings2,