@domino-sdk/relay 1.61.0 → 1.62.0

package/dist/testing.d.ts

@@ -1,11 +1,18 @@
-import { ar as memberIdentitySchema, as as pointBalanceSchema, at as trackerQuerySchema, au as trackerPageSchema, av as trackerSummarySchema, aw as TrackerContentQuery, ax as trackerContentSchema, ay as photoResultSchema, a7 as TextReviewInput, R as Reward, a9 as Decision, az as TrackerAttribution, U as Tracker, V as TrackerData, ae as ContentBody, a5 as TrackerTriggerContext, ak as TrackerPage } from './schema-CZ6Rj0ZF.js';
+import { d3 as pointBalanceSchema, bD as discordMemberSchema, bG as discordMessageSchema, cZ as photoResultSchema, a8 as TextReviewInput, H as Reward, ac as Decision, P as PointBalance, y as PointLedgerReference, u as PointEntry, o as LeaderboardPage } from './accounts-CCqCKCVx.js';
 import * as z from 'zod';
-import { m as discordMemberSchema, n as discordMessageSchema, t as telegramChatMemberSchema } from './accounts-DoabriBX.js';
-import { b as CapabilityFailure, m as memberCompletionSchema } from './capability-error-DufwG3G0.js';
-export { C as CapabilityError } from './capability-error-DufwG3G0.js';
-import { x as xConnectionSchema, a as xProfileSchema, b as xPostSchema, c as ImageReference, i as imageInspectionSchema, d as imageComparisonSchema, e as imageSightingsSchema } from './x-D1PGi8Sq.js';
-import { aj as profileReferralSchema, ak as linkedWalletSchema, al as walletBalanceSchema, am as walletNftsSchema, K as WalletCallArgument, an as walletCallSchema, ao as walletDelegationsSchema, T as WalletEventCondition, ap as walletEventsSchema, aq as walletTransactionsSchema } from './wallet-CIqFoxdm.js';
-export { A as AttemptCapture, C as CapturedFact } from './attempt-captures-DYnJVkfg.js';
+import { k as CapabilityFailure, _ as memberCompletionSchema } from './capability-error-DFMwSuSf.js';
+export { C as CapabilityError } from './capability-error-DFMwSuSf.js';
+import { z as xConnectionSchema, C as xProfileSchema, B as xPostSchema, f as ImageReference, s as imageInspectionSchema, o as imageComparisonSchema, v as imageSightingsSchema } from './analytics-BwAKLi7O.js';
+import { aI as memberIdentitySchema, bc as trackerQuerySchema, b7 as trackerPageSchema, bl as trackerSummarySchema, a8 as TrackerContentQuery, aU as trackerContentSchema, a4 as TrackerAttribution, l as Tracker, m as TrackerData, C as ContentBody, v as TrackerTriggerContext, H as TrackerPage } from './tracker-data-Hb1uQnk5.js';
+import { aO as profileReferralSchema, aE as linkedWalletSchema, aY as walletBalanceSchema, b2 as walletNftsSchema, M as WalletCallArgument, aZ as walletCallSchema, a$ as walletDelegationsSchema, U as WalletEventCondition, b0 as walletEventsSchema, b7 as walletTransactionsSchema } from './wallet-DTO7SXj7.js';
+import { C as telegramConnectionSchema, y as telegramChatMemberSchema } from './submission-input-DHGKhXfp.js';
+import { EvaluationMember } from './authoring.js';
+export { A as AttemptCapture, C as CapturedFact } from './attempt-captures-Cm-5G0PC.js';
+import { b as ParticipantSession, R as RelayEvent } from './participant-activity-D-Drp24G.js';
+import { B as Badge } from './offers-DhAtss4_.js';
+import { b as QuestView, q as questExperienceSchema } from './catalog--ZIlskAo.js';
+import './streaks-0YuipsUQ.js';
+import './units-CwgsPB_r.js';
 
 /** One project time-zone change: from `effectiveAt` on, days are counted in `timeZone`. */
 type CalendarSegment = {
@@ -257,7 +264,7 @@ type WalletDelegationsQueryRequest = {
 };
 /**
  * An event query as Relay receives it: `afterActivation` false, and `where` and `address` null,
- * when the quest leaves them out.
+ * when the quest leaves them out; `newest` only when the quest sets it.
  */
 type WalletEventsQueryRequest = {
     event: string;
@@ -266,6 +273,7 @@ type WalletEventsQueryRequest = {
     afterActivation: boolean;
     where: Record<string, WalletEventCondition> | null;
     address: string | null;
+    newest?: number;
 };
 /**
  * A transaction query as Relay receives it: `afterActivation` false, and `mint` and `address`
@@ -301,7 +309,7 @@ type TrackerFacts = {
  * Reads of the member's own accounts default to a member who has linked nothing:
  * `member.identities()`, `wallet.list()`, `wallet.balance()`, `wallet.nfts()`, `wallet.call()`,
  * `wallet.delegations()`, `x.connection()`, `x.profile()`,
- * `x.follows()`, `x.reposted()`, `discord.member()` and `telegram.member()` resolve to null. Once the test links an
+ * `x.follows()`, `x.reposted()`, `discord.member()`, `telegram.connection()` and `telegram.member()` resolve to null. Once the test links an
  * account (`wallet.list` or `x.connection` set to a value), supply every read of it the quest
  * makes. Every other read (the member's balances, completions, groups, campaigns and referrals, an
  * X post, a Discord message, trackers, images and AI review) needs an answer: a call without one
@@ -373,8 +381,9 @@ type TestFacts = {
         ], Result<typeof walletDelegationsSchema> | null>;
         /**
          * `ctx.wallet.events({ event, account, since })`. Like `balance`, it reads null while the
-         * member has no linked EVM wallet. The kit does not apply `where` or `since`: answer with the
-         * logs Relay would return. A run's `calls` does not list event reads.
+         * member has no linked EVM wallet. The kit does not apply `where`, `since` or `newest`: answer
+         * with the logs Relay would return, and `complete: false` for a `newest` read that left older
+         * events out. A run's `calls` does not list event reads.
          */
         events?: FakeAnswer<[
             query: WalletEventsQueryRequest
@@ -414,11 +423,14 @@ type TestFacts = {
         ], Result<typeof discordMessageSchema> | null>;
     };
     /**
-     * `ctx.telegram.member({ chat })`, which the testing kit supplies to every quest as Relay does.
-     * Throw `new CapabilityError("integration-required", …)` to act out a chat the project has not
-     * connected. A run's `calls` does not list Telegram calls: its request type is closed in SDK 1.x.
+     * `ctx.telegram.connection()` and `ctx.telegram.member({ chat })`, which the testing kit supplies
+     * to every quest as Relay does. `connection` is answered once per run, as Relay pins the account.
+     * Throw `new CapabilityError("integration-required", …)` from `member` to act out a chat the
+     * project has not connected. A run's `calls` does not list Telegram calls: its request type is
+     * closed in SDK 1.x.
      */
     telegram?: {
+        connection?: FakeAnswer<[], Result<typeof telegramConnectionSchema> | null>;
         member?: FakeAnswer<[
             input: {
                 chat: string;
@@ -658,6 +670,16 @@ declare function createTestContext<Q extends TestableQuest>(quest: Q, options?:
  */
 declare function runQuest<Q extends TestableQuest>(quest: Q, options?: RunQuestOptions<Q>): Promise<DiagnosedRun>;
 
+/**
+ * An `EvaluationMember` for a test that builds its own evaluation context, such as one that calls
+ * `quest.evaluate` with readers of its own. Pass the methods the code under test reads; the rest
+ * answer for a member with no linked accounts, completions, groups or enrollments, and `balance`
+ * and `referrals` fail as Relay does for an unknown ledger or program. A minor release can give
+ * `EvaluationMember` a method; this helper gives it a default, so a test that uses it keeps
+ * compiling. `createTestContext` and `runQuest` create the member themselves.
+ */
+declare function fakeEvaluationMember(member?: Partial<EvaluationMember>): EvaluationMember;
+
 type Kind = Decision["kind"];
 type DecisionOf<K extends Kind> = Extract<Decision, {
     kind: K;
@@ -803,4 +825,79 @@ type AttemptReplay = {
  */
 declare function replayAttempt<Q extends TestableQuest>(quest: Q, capture: unknown, options?: ReplayOptions): Promise<AttemptReplay>;
 
-export { type AttemptReplay, type CalendarSegment, type CapabilityCall, type CapabilityOutcome, type CapabilityRequest, Decision, DecisionAssertionError, EvaluatorError, type FakeAnswer, type QuestDiagnostic, type QuestHostContext, type QuestInputOf, type QuestRun, type ReplayDivergence, type ReplayOptions, type RunQuestOptions, type TestContext, type TestFacts, type TestRelease, TestSetupError, type TestableQuest, type TrackerFacts, type TrackerObservationInput, type TrackerReadRequest, type TrackerRecordInput, type WalletBalanceRequest, createTestContext, defaultMember, defaultNow, defaultSeed, expectAccept, expectDefer, expectProgress, expectReject, expectReview, maxCapabilityCalls, replayAttempt, runQuest, trackerObservation, trackerPage };
+type Experience = z.output<typeof questExperienceSchema>;
+/**
+ * What `createFakeRelay` answers with. Every seed is optional; an omitted one answers empty.
+ *
+ * @experimental A minor release can change it, like `createFakeRelay`.
+ */
+type FakeRelayOptions = {
+    /** The signed-in member's ID, or null (the default) for a signed-out visitor. */
+    member?: string | null;
+    /** The session's project scope. Defaults to `org_test`, `project_test` and `test`. */
+    scope?: Pick<ParticipantSession, "organization" | "project" | "environment">;
+    /** The member's quests, as `GET /v1/me/experience` lists them. */
+    quests?: QuestView[];
+    /** The experience's collections. */
+    collections?: Experience["collections"];
+    /** The experience's entitlements. */
+    entitlements?: Experience["entitlements"];
+    /**
+     * The member's balance in each ledger (`GET /v1/me/points`). `GET /v1/point-ledgers` lists these
+     * ledgers unless `ledgers` is given.
+     */
+    balances?: PointBalance[];
+    /** The project's ledgers (`GET /v1/point-ledgers`). */
+    ledgers?: PointLedgerReference[];
+    /** Each ledger's history (`GET /v1/me/points/:ledger/history`), keyed by ledger key or ID. */
+    pointHistory?: Record<string, PointEntry[]>;
+    /** The member's activity feed (`GET /v1/me/activity`), oldest event first. */
+    activity?: RelayEvent[];
+    /** The project's active badge catalog (`GET /v1/badges/catalog` and `GET /v1/badges`). */
+    badges?: Badge[];
+    /** Each board's standings (`GET /v1/leaderboards/:board`), keyed by the board's key or ID. */
+    leaderboards?: Record<string, LeaderboardPage>;
+    /**
+     * Answers for routes the fake does not cover, or replacements for ones it does, keyed
+     * `"METHOD /v1/path"`. A `:name` path segment matches any one segment, as in
+     * `"POST /v1/me/submissions/:submission/submit"`.
+     */
+    routes?: Record<string, (request: Request) => Response | Promise<Response>>;
+};
+/**
+ * One request the fake answered: its method and `/v1/...` path, without the query.
+ *
+ * @experimental A minor release can change it, like `createFakeRelay`.
+ */
+type FakeRelayRequest = {
+    method: string;
+    path: string;
+};
+/**
+ * The fake `createFakeRelay` returns.
+ *
+ * @experimental A minor release can change it, like `createFakeRelay`.
+ */
+type FakeRelay = {
+    /** Answers one request. Use it from a Playwright `page.route` handler or an MSW handler. */
+    handle(request: Request): Promise<Response>;
+    /** A `fetch` that answers from the fake, for `createRelayClient({ fetch })`. */
+    fetch: typeof fetch;
+    /** Every request answered so far, in order. */
+    readonly requests: FakeRelayRequest[];
+};
+/**
+ * An in-memory participant API for UI tests: it answers what `RelayProvider` and the hooks read
+ * from the seeds, as Relay would, under `/v1/...` and the hosted proxy's `/relay/v1/...`.
+ *
+ * Every answer is checked against the schema the SDK reads it with, so a seed Relay could never
+ * send throws a `TestSetupError` naming the route. A participant route the fake does not cover
+ * answers 501 with code `not-faked`, so a test cannot pass on an empty answer; `routes` answers
+ * it instead. Any other path answers 404 with code `route-not-found`, as the proxy does.
+ *
+ * @experimental Outside the 1.x compatibility promise: a minor release can change its options,
+ * the routes it fakes and its answers, as the participant API it imitates grows.
+ */
+declare function createFakeRelay(options?: FakeRelayOptions): FakeRelay;
+
+export { type AttemptReplay, type CalendarSegment, type CapabilityCall, type CapabilityOutcome, type CapabilityRequest, Decision, DecisionAssertionError, EvaluatorError, type FakeAnswer, type FakeRelay, type FakeRelayOptions, type FakeRelayRequest, type QuestDiagnostic, type QuestHostContext, type QuestInputOf, type QuestRun, type ReplayDivergence, type ReplayOptions, type RunQuestOptions, type TestContext, type TestFacts, type TestRelease, TestSetupError, type TestableQuest, type TrackerFacts, type TrackerObservationInput, type TrackerReadRequest, type TrackerRecordInput, type WalletBalanceRequest, createFakeRelay, createTestContext, defaultMember, defaultNow, defaultSeed, expectAccept, expectDefer, expectProgress, expectReject, expectReview, fakeEvaluationMember, maxCapabilityCalls, replayAttempt, runQuest, trackerObservation, trackerPage };

package/dist/testing.js

@@ -1,23 +1,40 @@
 import {
   attemptCaptureSchema
-} from "./chunk-7A4J67ZL.js";
+} from "./chunk-XNKSSE32.js";
 import {
   CapabilityError
 } from "./chunk-4OC7REYX.js";
 import {
   parseImageResult
-} from "./chunk-5I54XBK2.js";
+} from "./chunk-E6IKQHTX.js";
 import {
   imageRequestSchema,
   xConnectionSchema,
   xPostSchema,
   xProfileSchema,
   xRequestSchema
-} from "./chunk-L77O64I4.js";
+} from "./chunk-QYPMPWVX.js";
 import {
+  isParticipantRoute
+} from "./chunk-CZFXGGEK.js";
+import {
+  participantActivitySchema,
+  questExperienceSchema
+} from "./chunk-D26YNACF.js";
+import {
+  badgeCatalogSchema,
+  badgeSchema,
+  leaderboardPageSchema,
   pointBalanceSchema,
+  pointBalancesSchema,
+  pointHistoryPageSchema,
+  pointLedgerReferenceSchema,
   profileReferralSchema
-} from "./chunk-SE4PFJPT.js";
+} from "./chunk-WSBYWVTZ.js";
+import {
+  exchangeResultSchema,
+  participantSessionSchema
+} from "./chunk-XJFYAXET.js";
 import {
   contentPerformanceSnapshotSchema,
   cosmosAddressSchema,
@@ -32,8 +49,10 @@ import {
   isContractEvent,
   isNftCollection,
   isSolanaProgram,
+  knownResponse,
   linkedWalletSchema,
   maxMemberCompletions,
+  maxWalletEventLogs,
   memberCompletionSchema,
   memberIdentitySchema,
   photoResultSchema,
@@ -42,6 +61,8 @@ import {
   solanaAddressSchema,
   solanaMainnet,
   telegramChatMemberSchema,
+  telegramConnectionInputSchema,
+  telegramConnectionSchema,
   telegramMemberInputSchema,
   textEvidenceSchema,
   textResultSchema,
@@ -61,7 +82,10 @@ import {
   walletEventsSchema,
   walletNftsSchema,
   walletTransactionsSchema
-} from "./chunk-ZDJLPN4L.js";
+} from "./chunk-MK425RXJ.js";
+import {
+  RelayErrorCode
+} from "./chunk-K2KS3JLY.js";
 
 // src/testing/run.ts
 import * as z3 from "zod";
@@ -202,7 +226,7 @@ var capabilityRequestSchemas = {
 };
 var telegramRequestSchema = z.strictObject({
   kind: z.literal("telegram"),
-  input: telegramMemberInputSchema
+  input: z.union([telegramMemberInputSchema, telegramConnectionInputSchema])
 });
 var walletNftsRequestSchema = z.strictObject({
   kind: z.literal("wallet-nfts"),
@@ -221,7 +245,8 @@ var walletEventsRequestSchema = z.strictObject({
   since: z.number().int().nonnegative().safe(),
   afterActivation: z.boolean(),
   where: z.record(z.string().min(1).max(100), walletEventConditionSchema).refine((where) => Object.keys(where).length <= 10).nullable(),
-  address: z.string().min(1).max(100).nullable()
+  address: z.string().min(1).max(100).nullable(),
+  newest: z.number().int().min(1).max(maxWalletEventLogs).optional()
 });
 var walletTransactionsRequestSchema = z.strictObject({
   kind: z.literal("wallet-transactions"),
@@ -342,7 +367,7 @@ function parseCapabilityResult(request, value) {
     case "member-identities":
       return z.array(memberIdentitySchema).min(1).nullable().parse(value);
     case "telegram":
-      return telegramChatMemberSchema.nullable().parse(value);
+      return ("chat" in request.input ? telegramChatMemberSchema : telegramConnectionSchema).nullable().parse(value);
     case "wallet-nfts":
       return walletNftsSchema.nullable().parse(value);
     case "wallet-call":
@@ -414,6 +439,7 @@ var readerFactories = {
     message: (input) => call({ kind: "discord", input })
   }),
   telegram: (call) => ({
+    connection: () => call({ kind: "telegram", input: { operation: "connection" } }),
     member: (input) => call({ kind: "telegram", input })
   }),
   x: (call) => ({
@@ -493,7 +519,9 @@ var readerFactories = {
       since: query.since,
       afterActivation: query.afterActivation ?? false,
       where: query.where ?? null,
-      address: query.address ?? null
+      address: query.address ?? null,
+      // Only when set, so a call without it sends the request it always did.
+      ...query.newest === void 0 ? {} : { newest: query.newest }
     }),
     transactions: (query) => call({
       kind: "wallet-transactions",
@@ -641,21 +669,21 @@ function install(now, seed, restores) {
   const crypto = globalThis.crypto;
   if (crypto) {
     restores.push(
-      replace(crypto, "getRandomValues", (array3) => {
-        if (!integerArrays.some((type) => array3 instanceof type)) {
+      replace(crypto, "getRandomValues", (array4) => {
+        if (!integerArrays.some((type) => array4 instanceof type)) {
           throw new DOMException(
             "getRandomValues takes an integer typed array",
             "TypeMismatchError"
           );
         }
-        if (array3.byteLength > 65536) {
+        if (array4.byteLength > 65536) {
           throw new DOMException(
             "getRandomValues takes at most 65536 bytes",
             "QuotaExceededError"
           );
         }
-        fill(new Uint8Array(array3.buffer, array3.byteOffset, array3.byteLength));
-        return array3;
+        fill(new Uint8Array(array4.buffer, array4.byteOffset, array4.byteLength));
+        return array4;
       })
     );
     restores.push(
@@ -796,10 +824,14 @@ function fakeFor(facts, request) {
       };
     }
     case "telegram":
-      return {
+      return "chat" in request.input ? {
         name: "telegram.member",
         answer: facts.telegram?.member,
         args: [request.input]
+      } : {
+        name: "telegram.connection",
+        answer: facts.telegram?.connection,
+        args: []
       };
     case "tracker-records":
     case "tracker-summary": {
@@ -1082,6 +1114,9 @@ function factsAnswerer(facts) {
         return "channelId" in request.input || fake.answer !== void 0 ? ask(fake) : { value: null };
       // Without an answer, the member has not linked Telegram.
       case "telegram":
+        if (!("chat" in request.input)) {
+          return pin(request);
+        }
         return fake.answer !== void 0 ? ask(fake) : { value: null };
       case "image": {
         if (imageReferences(request.input).some(
@@ -1518,6 +1553,33 @@ async function runQuest(quest, options = {}) {
   );
 }
 
+// src/testing/member.ts
+var keyOf = (resource) => typeof resource === "string" ? resource : resource.key;
+function fakeEvaluationMember(member = {}) {
+  return {
+    id: defaultMember,
+    identities: async () => null,
+    balance: async (ledger) => {
+      throw new CapabilityError(
+        "author-error",
+        `The fake member has no balance in point ledger ${keyOf(ledger)}; pass balance to fakeEvaluationMember`,
+        { retryable: false }
+      );
+    },
+    completions: async () => [],
+    groups: async () => [],
+    enrolled: async () => false,
+    referrals: async (program) => {
+      throw new CapabilityError(
+        "author-error",
+        `The fake member has no progress in referral program ${keyOf(program)}; pass referrals to fakeEvaluationMember`,
+        { retryable: false }
+      );
+    },
+    ...member
+  };
+}
+
 // src/testing/assertions.ts
 var DecisionAssertionError = class extends Error {
   decision;
@@ -1685,7 +1747,7 @@ function captureAnswerer(facts, fallback, diverged) {
     if (unlistedRequest(request)) {
       if (!answerFallback) {
         const [reader, fact2] = {
-          telegram: ["ctx.telegram.member()", "facts.telegram"],
+          telegram: request.kind === "telegram" && !("chat" in request.input) ? ["ctx.telegram.connection()", "facts.telegram.connection"] : ["ctx.telegram.member()", "facts.telegram"],
           "wallet-nfts": ["ctx.wallet.nfts()", "facts.wallet.nfts"],
           "wallet-call": ["ctx.wallet.call()", "facts.wallet.call"],
           "wallet-delegations": [
@@ -1782,11 +1844,253 @@ async function replayAttempt(quest, capture, options = {}) {
     calls: host.calls
   };
 }
+
+// src/testing/participant-api.ts
+import * as z5 from "zod";
+var defaultScope = {
+  organization: "org_test",
+  project: "project_test",
+  environment: "test"
+};
+var sessionLifetimeMs = 24 * 60 * 60 * 1e3;
+var refuse = (status, code, error) => Response.json({ error, code }, { status });
+function createFakeRelay(options = {}) {
+  let member = options.member ?? null;
+  const scope = options.scope ?? defaultScope;
+  const requests = [];
+  const activity = options.activity ?? [];
+  const balances = options.balances ?? [];
+  const badges = options.badges ?? [];
+  const ledgers = options.ledgers ?? balances.map((balance) => balance.ledger).filter(
+    (ledger, index, all) => all.findIndex((other) => other.id === ledger.id) === index
+  );
+  const overrides = Object.entries(options.routes ?? {}).map(
+    ([key, answer2]) => {
+      const [method, path, ...rest] = key.trim().split(/\s+/);
+      if (!method || !path?.startsWith("/v1/") || rest.length > 0) {
+        throw new TestSetupError(
+          `routes["${key}"]: name a route as "METHOD /v1/path"`
+        );
+      }
+      const source = path.split("/").map(
+        (segment) => segment.startsWith(":") ? "[^/]+" : segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+      ).join("/");
+      return {
+        method: method.toUpperCase(),
+        pattern: new RegExp(`^${source}$`),
+        answer: answer2
+      };
+    }
+  );
+  const session = (current) => ({
+    ...scope,
+    id: `session_${current}`,
+    principal: { kind: "member", member: current },
+    expiresAt: Date.now() + sessionLifetimeMs
+  });
+  const answer = (route, schema, value) => {
+    const wire = JSON.parse(JSON.stringify(value));
+    const parsed = knownResponse(schema).safeParse(wire);
+    if (!parsed.success) {
+      const issue = parsed.error.issues[0];
+      const at = issue?.path.length ? ` at ${issue.path.join(".")}` : "";
+      throw new TestSetupError(
+        `createFakeRelay: the answer to ${route} is not one Relay sends${at}: ${issue?.message ?? parsed.error.message}`
+      );
+    }
+    return Response.json(wire);
+  };
+  const experience = (current) => answer("GET /v1/me/experience", questExperienceSchema, {
+    member: current,
+    quests: options.quests ?? [],
+    collections: options.collections ?? [],
+    entitlements: options.entitlements ?? []
+  });
+  const activityPage = (current, query) => {
+    const cursor = query.get("cursor");
+    const limit = Number(query.get("limit") ?? 50);
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+      return refuse(400, "invalid-request", "limit must be 1 to 100");
+    }
+    const start = query.get("start") === "latest" ? activity.length : cursor === null ? 0 : Number(cursor.replace(/^fake-/, ""));
+    if (!Number.isInteger(start) || start < 0 || start > activity.length) {
+      return refuse(400, "invalid-request", "Invalid activity cursor");
+    }
+    const items = activity.slice(start, start + limit);
+    return answer("GET /v1/me/activity", participantActivitySchema, {
+      member: current,
+      items,
+      nextCursor: `fake-${start + items.length}`
+    });
+  };
+  const leaderboard = (board) => {
+    const page = options.leaderboards?.[board] ?? Object.values(options.leaderboards ?? {}).find(
+      (seed) => seed.leaderboard === board
+    );
+    return page ? answer("GET /v1/leaderboards/:board", leaderboardPageSchema, page) : refuse(404, RelayErrorCode.NotFound, "Leaderboard not found");
+  };
+  const pointHistory = (ledger) => {
+    const known = ledgers.find(
+      (reference) => reference.id === ledger || reference.key === ledger
+    );
+    const entries = options.pointHistory?.[ledger] ?? (known && (options.pointHistory?.[known.id] ?? (known.key ? options.pointHistory?.[known.key] : void 0)));
+    if (!known && !entries) {
+      return refuse(404, RelayErrorCode.NotFound, "Point ledger not found");
+    }
+    return answer("GET /v1/me/points/:ledger/history", pointHistoryPageSchema, {
+      items: entries ?? [],
+      nextCursor: null
+    });
+  };
+  const exchange = async (request) => {
+    const credential = request.headers.get("Authorization") ?? "";
+    if (!/^Bearer di_\S+$/.test(credential)) {
+      return Response.json(
+        {
+          error: "Use a valid identity integration server key from Console Settings. CLI and management credentials cannot issue participant sessions."
+        },
+        { status: 401 }
+      );
+    }
+    const body = await request.json().catch(() => null);
+    const subject = typeof body === "object" && body && "subject" in body ? body.subject : void 0;
+    if (typeof subject !== "string" || subject.length === 0) {
+      return refuse(400, "invalid-request", "subject is required");
+    }
+    if (member === null && !identifier.safeParse(subject).success) {
+      throw new TestSetupError(
+        `createFakeRelay: POST /v1/auth/exchange signs in subject "${subject}", which is not a member ID; seed options.member`
+      );
+    }
+    member ??= subject;
+    return answer("POST /v1/auth/exchange", exchangeResultSchema, {
+      token: `fake_${member}`,
+      session: session(member)
+    });
+  };
+  const builtIn = (request, method, path, query) => {
+    if (method === "GET" && path === "/v1/auth/session") {
+      return member === null ? Response.json(null) : answer(
+        "GET /v1/auth/session",
+        participantSessionSchema,
+        session(member)
+      );
+    }
+    if (method === "POST" && path === "/v1/auth/logout") {
+      member = null;
+      return answer("POST /v1/auth/logout", z5.object({ ok: z5.boolean() }), {
+        ok: true
+      });
+    }
+    if (method === "POST" && path === "/v1/auth/exchange") {
+      return exchange(request);
+    }
+    if (method === "GET" && path === "/v1/point-ledgers") {
+      return answer(
+        "GET /v1/point-ledgers",
+        z5.array(pointLedgerReferenceSchema),
+        ledgers
+      );
+    }
+    if (method === "GET" && path === "/v1/badges/catalog") {
+      return answer("GET /v1/badges/catalog", badgeCatalogSchema, {
+        items: badges
+      });
+    }
+    if (method === "GET" && path === "/v1/badges") {
+      return answer("GET /v1/badges", z5.array(badgeSchema), badges);
+    }
+    const board = method === "GET" && /^\/v1\/leaderboards\/([\w-]+)$/.exec(path);
+    if (board) {
+      return leaderboard(board[1]);
+    }
+    if (method !== "GET" || !path.startsWith("/v1/me/")) {
+      return void 0;
+    }
+    const history = /^\/v1\/me\/points\/([\w-]+)\/history$/.exec(path);
+    const covered = path === "/v1/me/experience" || path === "/v1/me/points" || path === "/v1/me/activity" || history;
+    if (!covered) {
+      return void 0;
+    }
+    if (member === null) {
+      return refuse(401, RelayErrorCode.NotSignedIn, "Sign in to continue");
+    }
+    if (history) {
+      return pointHistory(history[1]);
+    }
+    switch (path) {
+      case "/v1/me/experience":
+        return experience(member);
+      case "/v1/me/points":
+        return answer("GET /v1/me/points", pointBalancesSchema, {
+          items: balances
+        });
+      default:
+        return activityPage(member, query);
+    }
+  };
+  const handle = async (request) => {
+    const url = new URL(request.url);
+    const path = url.pathname.startsWith("/relay/v1/") ? url.pathname.slice("/relay".length) : url.pathname;
+    const method = request.method.toUpperCase();
+    requests.push({ method, path });
+    const override = overrides.find(
+      (route) => route.method === method && route.pattern.test(path)
+    );
+    if (override) {
+      return override.answer(request);
+    }
+    const response = builtIn(request, method, path, url.searchParams);
+    if (response) {
+      return response;
+    }
+    if (isParticipantRoute(path, method)) {
+      return refuse(
+        501,
+        "not-faked",
+        `createFakeRelay does not answer ${method} ${path}: answer it with options.routes["${method} ${path}"]`
+      );
+    }
+    return refuse(404, "route-not-found", "Route not found");
+  };
+  experience(member ?? "member_test");
+  answer("GET /v1/me/points", pointBalancesSchema, { items: balances });
+  answer("GET /v1/point-ledgers", z5.array(pointLedgerReferenceSchema), ledgers);
+  answer("GET /v1/badges/catalog", badgeCatalogSchema, { items: badges });
+  answer("GET /v1/me/activity", participantActivitySchema, {
+    member: member ?? "member_test",
+    items: activity,
+    nextCursor: "fake-0"
+  });
+  for (const ledger of Object.keys(options.pointHistory ?? {})) {
+    pointHistory(ledger);
+  }
+  for (const board of Object.keys(options.leaderboards ?? {})) {
+    leaderboard(board);
+  }
+  if (member !== null) {
+    answer("GET /v1/auth/session", participantSessionSchema, session(member));
+  }
+  return {
+    handle,
+    fetch: (input, init) => handle(
+      new Request(
+        input instanceof Request ? input : new URL(
+          String(input),
+          globalThis.location?.href ?? "http://localhost"
+        ),
+        init
+      )
+    ),
+    requests
+  };
+}
 export {
   CapabilityError,
   DecisionAssertionError,
   EvaluatorError,
   TestSetupError,
+  createFakeRelay,
   createTestContext,
   defaultMember,
   defaultNow,
@@ -1796,6 +2100,7 @@ export {
   expectProgress,
   expectReject,
   expectReview,
+  fakeEvaluationMember,
   maxCapabilityCalls,
   replayAttempt,
   runQuest,