@domino-sdk/relay 1.61.0 → 1.63.0

package/dist/testing.js

@@ -1,23 +1,40 @@
 import {
   attemptCaptureSchema
-} from "./chunk-7A4J67ZL.js";
+} from "./chunk-VWQGWGCH.js";
 import {
   CapabilityError
-} from "./chunk-4OC7REYX.js";
+} from "./chunk-MWMCQLCG.js";
 import {
   parseImageResult
-} from "./chunk-5I54XBK2.js";
+} from "./chunk-N4LNEGQX.js";
 import {
   imageRequestSchema,
   xConnectionSchema,
   xPostSchema,
   xProfileSchema,
   xRequestSchema
-} from "./chunk-L77O64I4.js";
+} from "./chunk-7X67QLPB.js";
 import {
+  isParticipantRoute
+} from "./chunk-U66GUVSG.js";
+import {
+  participantActivitySchema,
+  questExperienceSchema
+} from "./chunk-4NOFSGAL.js";
+import {
+  badgeCatalogSchema,
+  badgeSchema,
+  leaderboardPageSchema,
   pointBalanceSchema,
+  pointBalancesSchema,
+  pointHistoryPageSchema,
+  pointLedgerReferenceSchema,
   profileReferralSchema
-} from "./chunk-SE4PFJPT.js";
+} from "./chunk-W7YSMSGC.js";
+import {
+  exchangeResultSchema,
+  participantSessionSchema
+} from "./chunk-N4BDKS6Y.js";
 import {
   contentPerformanceSnapshotSchema,
   cosmosAddressSchema,
@@ -32,8 +49,9 @@ import {
   isContractEvent,
   isNftCollection,
   isSolanaProgram,
+  knownResponse,
+  limits,
   linkedWalletSchema,
-  maxMemberCompletions,
   memberCompletionSchema,
   memberIdentitySchema,
   photoResultSchema,
@@ -42,6 +60,8 @@ import {
   solanaAddressSchema,
   solanaMainnet,
   telegramChatMemberSchema,
+  telegramConnectionInputSchema,
+  telegramConnectionSchema,
   telegramMemberInputSchema,
   textEvidenceSchema,
   textResultSchema,
@@ -61,7 +81,10 @@ import {
   walletEventsSchema,
   walletNftsSchema,
   walletTransactionsSchema
-} from "./chunk-ZDJLPN4L.js";
+} from "./chunk-ID3BZXFZ.js";
+import {
+  RelayErrorCode
+} from "./chunk-GLH6MEI2.js";
 
 // src/testing/run.ts
 import * as z3 from "zod";
@@ -151,12 +174,12 @@ function evaluationCalendar(snapshot, eligibleAt) {
 
 // src/testing/capabilities.ts
 import * as z from "zod";
-var trackerInput = {
+var trackerInput = /* @__PURE__ */ (() => ({
   reference: identifier,
   query: trackerQuerySchema,
   asOf: z.number().int().nonnegative().safe()
-};
-var capabilityRequestSchemas = {
+}))();
+var capabilityRequestSchemas = /* @__PURE__ */ (() => ({
   "wallet-balance": z.strictObject({
     kind: z.literal("wallet-balance"),
     chain: z.union([
@@ -199,39 +222,40 @@ var capabilityRequestSchemas = {
   "member-identities": z.strictObject({
     kind: z.literal("member-identities")
   })
-};
-var telegramRequestSchema = z.strictObject({
+}))();
+var telegramRequestSchema = /* @__PURE__ */ (() => z.strictObject({
   kind: z.literal("telegram"),
-  input: telegramMemberInputSchema
-});
-var walletNftsRequestSchema = z.strictObject({
+  input: z.union([telegramMemberInputSchema, telegramConnectionInputSchema])
+}))();
+var walletNftsRequestSchema = /* @__PURE__ */ (() => z.strictObject({
   kind: z.literal("wallet-nfts"),
   collection: z.string().max(200).refine(isNftCollection),
   address: z.string().min(1).max(100).nullable()
-});
-var walletEventConditionSchema = z.union([
+}))();
+var walletEventConditionSchema = /* @__PURE__ */ (() => z.union([
   z.string().min(1).max(200),
   z.boolean(),
   z.strictObject({ gte: z.string().regex(/^-?(0|[1-9][0-9]{0,77})$/) })
-]);
-var walletEventsRequestSchema = z.strictObject({
+]))();
+var walletEventsRequestSchema = /* @__PURE__ */ (() => z.strictObject({
   kind: z.literal("wallet-events"),
   event: z.string().max(1e3).refine(isContractEvent),
   account: z.string().min(1).max(100),
   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()
-});
-var walletTransactionsRequestSchema = z.strictObject({
+  address: z.string().min(1).max(100).nullable(),
+  newest: z.number().int().min(1).max(limits.walletEventLogs).optional()
+}))();
+var walletTransactionsRequestSchema = /* @__PURE__ */ (() => z.strictObject({
   kind: z.literal("wallet-transactions"),
   program: z.string().max(44).refine(isSolanaProgram),
   since: z.number().int().nonnegative().safe(),
   afterActivation: z.boolean(),
   mint: solanaAddressSchema.nullable(),
   address: z.string().min(1).max(100).nullable()
-});
-var walletCallRequestSchema = z.strictObject({
+}))();
+var walletCallRequestSchema = /* @__PURE__ */ (() => z.strictObject({
   kind: z.literal("wallet-call"),
   call: z.string().max(400).refine(isContractCall),
   args: z.array(
@@ -246,14 +270,14 @@ var walletCallRequestSchema = z.strictObject({
     "Pass the member's wallet ({ wallet: true }) at most once"
   ),
   address: z.string().min(1).max(100).nullable()
-});
-var walletDelegationsRequestSchema = z.strictObject({
+}))();
+var walletDelegationsRequestSchema = /* @__PURE__ */ (() => z.strictObject({
   kind: z.literal("wallet-delegations"),
   chain: cosmosNetworkSchema,
   validator: cosmosAddressSchema.nullable(),
   address: z.string().min(1).max(100).nullable()
-});
-var memberStateRequestSchemas = {
+}))();
+var memberStateRequestSchemas = /* @__PURE__ */ (() => ({
   "member-balance": z.strictObject({
     kind: z.literal("member-balance"),
     ledger: identifier
@@ -262,7 +286,7 @@ var memberStateRequestSchemas = {
     kind: z.literal("member-completions"),
     quest: identifier.nullable(),
     since: z.number().int().nonnegative().safe().nullable(),
-    limit: z.number().int().min(1).max(maxMemberCompletions)
+    limit: z.number().int().min(1).max(limits.memberCompletions)
   }),
   "member-groups": z.strictObject({ kind: z.literal("member-groups") }),
   "member-enrolled": z.strictObject({
@@ -273,11 +297,11 @@ var memberStateRequestSchemas = {
     kind: z.literal("member-referrals"),
     program: identifier
   })
-};
+}))();
 function unlistedRequest(request) {
   return request.kind === "telegram" || request.kind === "wallet-nfts" || request.kind === "wallet-call" || request.kind === "wallet-delegations" || request.kind === "wallet-events" || request.kind === "wallet-transactions" || request.kind === "member-balance" || request.kind === "member-completions" || request.kind === "member-groups" || request.kind === "member-enrolled" || request.kind === "member-referrals";
 }
-var capabilityRequestSchema = z.discriminatedUnion("kind", [
+var capabilityRequestSchema = /* @__PURE__ */ (() => z.discriminatedUnion("kind", [
   capabilityRequestSchemas["wallet-balance"],
   capabilityRequestSchemas["tracker-content"],
   capabilityRequestSchemas.x,
@@ -300,7 +324,7 @@ var capabilityRequestSchema = z.discriminatedUnion("kind", [
   memberStateRequestSchemas["member-groups"],
   memberStateRequestSchemas["member-enrolled"],
   memberStateRequestSchemas["member-referrals"]
-]);
+]))();
 function parseCapabilityRequest(raw) {
   return capabilityRequestSchema.safeParse(raw);
 }
@@ -342,7 +366,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":
@@ -365,6 +389,24 @@ function parseCapabilityResult(request, value) {
       return profileReferralSchema.parse(value);
   }
 }
+function newerResultIssue(issue) {
+  if (issue.code === "unrecognized_keys" || issue.code === "invalid_value") {
+    return true;
+  }
+  return issue.code === "invalid_union" && issue.errors.some(
+    (branch) => branch.length > 0 && branch.every(newerResultIssue)
+  );
+}
+function parseCapturedResult(request, value) {
+  try {
+    return parseCapabilityResult(request, value);
+  } catch (error) {
+    if (error instanceof z.ZodError && error.issues.every(newerResultIssue)) {
+      return value;
+    }
+    throw error;
+  }
+}
 function imageReferences(input) {
   return input.operation === "compare" || input.operation === "review" ? input.images : [input.image];
 }
@@ -414,6 +456,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 +536,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 +686,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(
@@ -675,10 +720,10 @@ function install(now, seed, restores) {
 
 // src/testing/facts.ts
 import * as z2 from "zod";
-var campaignFactSchema = z2.strictObject({
+var campaignFactSchema = /* @__PURE__ */ (() => z2.strictObject({
   key: identifier,
   enrolled: z2.boolean()
-});
+}))();
 var TestSetupError = class extends Error {
   constructor(message) {
     super(message);
@@ -796,10 +841,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 +1131,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(
@@ -1158,7 +1210,7 @@ function rewardSelectionIssue(selected, published) {
 }
 
 // src/testing/run.ts
-var defaultNow = Date.UTC(2026, 0, 1);
+var defaultNow = /* @__PURE__ */ (() => Date.UTC(2026, 0, 1))();
 var defaultMember = "member_test";
 var defaultSeed = "attempt_test";
 var maxCapabilityCalls = 8;
@@ -1266,6 +1318,7 @@ function hostContext(run, answer) {
   const evidence = typeof input.evidence === "string" ? input.evidence : void 0;
   const calendar = evaluationCalendar({ segments: run.segments }, eligibleAt);
   const calls = [];
+  const capabilityCalls = [];
   const diagnostics = [];
   const problems = [];
   const delivered = /* @__PURE__ */ new WeakSet();
@@ -1286,12 +1339,17 @@ function hostContext(run, answer) {
         request.kind === "photo" ? "Photo capability cannot access another attempt\u2019s evidence" : "Image capability cannot access another attempt\u2019s evidence"
       );
     }
-    const outcome = await answer(request, sequence2);
+    const { captured, ...outcome } = await answer(request, sequence2);
     if ("error" in outcome) {
       return outcome;
     }
     try {
-      const value = z3.json().parse(parseCapabilityResult(request, outcome.value));
+      const value = z3.json().parse(
+        (captured ? parseCapturedResult : parseCapabilityResult)(
+          request,
+          outcome.value
+        )
+      );
       return { value: JSON.parse(JSON.stringify(value)) };
     } catch (error) {
       throw new TestSetupError(
@@ -1301,7 +1359,7 @@ function hostContext(run, answer) {
   }
   const call = async (raw) => {
     const current = sequence++;
-    if (current >= maxCapabilityCalls) {
+    if (current >= limits.capabilityCalls) {
       throw capabilityLimitError();
     }
     const parsed = parseCapabilityRequest(raw);
@@ -1321,6 +1379,8 @@ function hostContext(run, answer) {
       problems.push(error instanceof Error ? error : new Error(String(error)));
       throw error;
     }
+    capabilityCalls.push({ sequence: current, request: parsed.data, outcome });
+    capabilityCalls.sort((a, b) => a.sequence - b.sequence);
     if (!unlistedRequest(parsed.data)) {
       calls.push({ sequence: current, request: parsed.data, outcome });
       calls.sort((a, b) => a.sequence - b.sequence);
@@ -1362,6 +1422,7 @@ function hostContext(run, answer) {
   return {
     context,
     calls,
+    capabilityCalls,
     diagnostics,
     problems,
     delivered,
@@ -1395,7 +1456,7 @@ function thrownMessage(error) {
 function capabilityLimitError() {
   return new CapabilityError(
     "capability-limit",
-    `An evaluation run makes at most ${maxCapabilityCalls} capability calls, shared by all capabilities`,
+    `An evaluation run makes at most ${limits.capabilityCalls} capability calls, shared by all capabilities`,
     { retryable: false }
   );
 }
@@ -1503,6 +1564,7 @@ function evaluateHosted(quest, host) {
     return {
       decision,
       calls: host.calls,
+      capabilityCalls: host.capabilityCalls,
       release: host.release,
       diagnostics: host.diagnostics
     };
@@ -1518,6 +1580,68 @@ 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/readers.ts
+import * as z4 from "zod";
+function factsCall(facts) {
+  const answer = factsAnswerer(facts);
+  return async (raw) => {
+    const request = parseCapabilityRequest(raw);
+    if (!request.success) {
+      throw new CapabilityError(
+        "author-error",
+        z4.prettifyError(request.error),
+        { retryable: false }
+      );
+    }
+    const outcome = await answer(request.data);
+    if ("error" in outcome) {
+      throw CapabilityError.from(outcome.error);
+    }
+    try {
+      return JSON.parse(
+        JSON.stringify(parseCapabilityResult(request.data, outcome.value))
+      );
+    } catch (error) {
+      throw new TestSetupError(
+        `The answer to ${request.data.kind} is not a result Relay delivers: ${error instanceof z4.ZodError ? z4.prettifyError(error) : String(error)}`
+      );
+    }
+  };
+}
+function fakeWalletReader(facts = {}) {
+  return readerFactories.wallet(factsCall(facts));
+}
+function fakeTelegramReader(facts = {}) {
+  return readerFactories.telegram(factsCall(facts));
+}
+
 // src/testing/assertions.ts
 var DecisionAssertionError = class extends Error {
   decision;
@@ -1644,7 +1768,7 @@ function trackerPage(tracker, records, options = {}) {
 }
 
 // src/testing/replay.ts
-import * as z4 from "zod";
+import * as z5 from "zod";
 var ReplayStopped = class extends Error {
   constructor(divergence) {
     super(
@@ -1680,43 +1804,7 @@ function captureAnswerer(facts, fallback, diverged) {
     const fact = facts.find((candidate) => candidate.sequence === sequence);
     const reason = !fact ? "new" : !sameJson(fact.request, request) ? "changed" : !fact.captured || !fact.outcome ? "uncaptured" : null;
     if (fact?.outcome && !reason) {
-      return fact.outcome;
-    }
-    if (unlistedRequest(request)) {
-      if (!answerFallback) {
-        const [reader, fact2] = {
-          telegram: ["ctx.telegram.member()", "facts.telegram"],
-          "wallet-nfts": ["ctx.wallet.nfts()", "facts.wallet.nfts"],
-          "wallet-call": ["ctx.wallet.call()", "facts.wallet.call"],
-          "wallet-delegations": [
-            "ctx.wallet.delegations()",
-            "facts.wallet.delegations"
-          ],
-          "wallet-events": ["ctx.wallet.events()", "facts.wallet.events"],
-          "wallet-transactions": [
-            "ctx.wallet.transactions()",
-            "facts.wallet.transactions"
-          ],
-          "member-balance": ["ctx.member.balance()", "facts.member.balances"],
-          "member-completions": [
-            "ctx.member.completions()",
-            "facts.member.completions"
-          ],
-          "member-groups": ["ctx.member.groups()", "facts.member.groups"],
-          "member-enrolled": [
-            "ctx.member.enrolled()",
-            "facts.member.campaigns"
-          ],
-          "member-referrals": [
-            "ctx.member.referrals()",
-            "facts.member.referrals"
-          ]
-        }[request.kind];
-        throw new TestSetupError(
-          `Capability call ${sequence}, ${reader}, is not in the capture (${reason ?? "new"}): pass ${fact2} to answer it`
-        );
-      }
-      return answerFallback(request);
+      return { ...fact.outcome, captured: true };
     }
     const divergence = {
       sequence,
@@ -1724,7 +1812,7 @@ function captureAnswerer(facts, fallback, diverged) {
       recorded: fact?.request ?? null,
       replayed: request
     };
-    diverged(divergence);
+    diverged(divergence, !unlistedRequest(request));
     if (!answerFallback) {
       throw new ReplayStopped(divergence);
     }
@@ -1735,7 +1823,7 @@ async function replayAttempt(quest, capture, options = {}) {
   const parsed = attemptCaptureSchema.safeParse(capture);
   if (!parsed.success) {
     throw new TestSetupError(
-      `Not an attempt capture: ${z4.prettifyError(parsed.error)}`
+      `Not an attempt capture: ${z5.prettifyError(parsed.error)}`
     );
   }
   const { quest: captured, context, facts, recorded } = parsed.data;
@@ -1745,6 +1833,7 @@ async function replayAttempt(quest, capture, options = {}) {
     );
   }
   let divergence = null;
+  let capabilityDivergence = null;
   const host = hostContext(
     {
       release: {
@@ -1762,8 +1851,17 @@ async function replayAttempt(quest, capture, options = {}) {
       now: parsed.data.now,
       seed: parsed.data.seed
     },
-    captureAnswerer(facts, options.facts, (found) => {
-      divergence ??= found;
+    captureAnswerer(facts, options.facts, (found, listed) => {
+      if (capabilityDivergence) {
+        return;
+      }
+      capabilityDivergence = found;
+      divergence = listed ? {
+        sequence: found.sequence,
+        reason: found.reason,
+        recorded: found.recorded,
+        replayed: found.replayed
+      } : null;
     })
   );
   let decision = null;
@@ -1779,7 +1877,254 @@ async function replayAttempt(quest, capture, options = {}) {
     recorded,
     changed: decision && recorded ? !sameJson(decision, recorded) : null,
     divergence,
-    calls: host.calls
+    capabilityDivergence,
+    calls: host.calls,
+    capabilityCalls: host.capabilityCalls
+  };
+}
+
+// src/testing/participant-api.ts
+import * as z6 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-cursor",
+        "Invalid cursor. Start from the first page."
+      );
+    }
+    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", z6.object({ ok: z6.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",
+        z6.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", z6.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", z6.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 {
@@ -1787,6 +2132,7 @@ export {
   DecisionAssertionError,
   EvaluatorError,
   TestSetupError,
+  createFakeRelay,
   createTestContext,
   defaultMember,
   defaultNow,
@@ -1796,6 +2142,10 @@ export {
   expectProgress,
   expectReject,
   expectReview,
+  fakeEvaluationMember,
+  fakeTelegramReader,
+  fakeWalletReader,
+  limits,
   maxCapabilityCalls,
   replayAttempt,
   runQuest,