@domino-sdk/relay 1.61.0 → 1.63.0

package/dist/testing.d.ts

@@ -1,11 +1,20 @@
-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-nz3mzfRQ.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 { N as NftCollection, 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, v as WalletReader } from './wallet-B7e06v4m.js';
+import { f as CapabilityFailure, q as memberCompletionSchema } from './capability-error-CuI_F7yM.js';
+export { C as CapabilityError } from './capability-error-CuI_F7yM.js';
+import { C as xConnectionSchema, G as xProfileSchema, F as xPostSchema, g as ImageReference, u as imageInspectionSchema, q as imageComparisonSchema, x as imageSightingsSchema } from './limits-kNzYdZ00.js';
+export { L as Limits, l as limits } from './limits-kNzYdZ00.js';
+import { aM as memberIdentitySchema, bf as trackerQuerySchema, ba as trackerPageSchema, bo as trackerSummarySchema, ac as TrackerContentQuery, aX as trackerContentSchema, a8 as TrackerAttribution, o as Tracker, p as TrackerData, H as ContentBody, B as TrackerTriggerContext, U as TrackerPage } from './tracker-data-esm3WG8R.js';
+import { C as telegramConnectionSchema, y as telegramChatMemberSchema, e as TelegramReader } from './submission-input-DZCbjQUH.js';
+import { EvaluationMember } from './authoring.js';
+export { A as AttemptCapture, C as CapturedFact } from './attempt-captures-DMi8oR9T.js';
+import { b as ParticipantSession, R as RelayEvent } from './participant-activity-D-Drp24G.js';
+import { B as Badge } from './offers-CYeN_I0Y.js';
+import { b as QuestView, q as questExperienceSchema } from './catalog-BaTOKpNw.js';
+import './streaks-0YuipsUQ.js';
+import './dashboards-CLemT6kj.js';
+import './units-CwgsPB_r.js';
 
 /** One project time-zone change: from `effectiveAt` on, days are counted in `timeZone`. */
 type CalendarSegment = {
@@ -217,6 +226,123 @@ type CapabilityKind = keyof typeof capabilityRequestSchemas;
 type CapabilityRequest = {
     [K in CapabilityKind]: z.output<(typeof capabilityRequestSchemas)[K]>;
 }[CapabilityKind];
+/**
+ * `ctx.telegram.connection()` and `member()`'s request. It stays out of `CapabilityRequest`: that union is closed in
+ * SDK 1.x's public `CapabilityCall` and `ReplayDivergence`, and gaining a member would break code
+ * that switches over it (docs/adr/0011-telegram.md). The kit answers and numbers Telegram calls as
+ * Relay does, but lists them only in a run's `capabilityCalls`, not in the deprecated `calls`.
+ */
+declare const telegramRequestSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"telegram">;
+    input: z.ZodUnion<readonly [z.ZodObject<{
+        chat: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        operation: z.ZodLiteral<"connection">;
+    }, z.core.$strict>]>;
+}, z.core.$strict>;
+type TelegramRequest = z.output<typeof telegramRequestSchema>;
+/**
+ * `ctx.wallet.nfts()`'s request. Like Telegram's, it stays out of the closed `CapabilityRequest`:
+ * the kit answers and numbers NFT reads, but lists them only in a run's `capabilityCalls`, not in the deprecated `calls`.
+ */
+declare const walletNftsRequestSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"wallet-nfts">;
+    collection: z.ZodString & z.ZodType<NftCollection, string, z.core.$ZodTypeInternals<NftCollection, string>>;
+    address: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+type WalletNftsRequest = z.output<typeof walletNftsRequestSchema>;
+declare const walletEventsRequestSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"wallet-events">;
+    event: z.ZodString & z.ZodType<`eip155:${number}:0x${string} ${string}`, string, z.core.$ZodTypeInternals<`eip155:${number}:0x${string} ${string}`, string>>;
+    account: z.ZodString;
+    since: z.ZodNumber;
+    afterActivation: z.ZodBoolean;
+    where: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodObject<{
+        gte: z.ZodString;
+    }, z.core.$strict>]>>>;
+    address: z.ZodNullable<z.ZodString>;
+    newest: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type WalletEventsRequest = z.output<typeof walletEventsRequestSchema>;
+/** `ctx.wallet.transactions()`'s request: answered and numbered like event reads, and unlisted the same way. */
+declare const walletTransactionsRequestSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"wallet-transactions">;
+    program: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+    since: z.ZodNumber;
+    afterActivation: z.ZodBoolean;
+    mint: z.ZodNullable<z.ZodString>;
+    address: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+type WalletTransactionsRequest = z.output<typeof walletTransactionsRequestSchema>;
+/**
+ * `ctx.wallet.call()`'s and `ctx.wallet.delegations()`'s requests. Like NFT reads, they stay out of
+ * the closed `CapabilityRequest`: the kit answers and numbers them, but lists them only in a run's `capabilityCalls`, not in the deprecated `calls`.
+ */
+declare const walletCallRequestSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"wallet-call">;
+    call: z.ZodString & z.ZodType<`eip155:${number}:0x${string} function ${string}`, string, z.core.$ZodTypeInternals<`eip155:${number}:0x${string} function ${string}`, string>>;
+    args: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        wallet: z.ZodLiteral<true>;
+    }, z.core.$strict>, z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    address: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+type WalletCallRequest = z.output<typeof walletCallRequestSchema>;
+declare const walletDelegationsRequestSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"wallet-delegations">;
+    chain: z.ZodCustom<`cosmos:${string}`, `cosmos:${string}`>;
+    validator: z.ZodNullable<z.ZodString>;
+    address: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+type WalletDelegationsRequest = z.output<typeof walletDelegationsRequestSchema>;
+/**
+ * `ctx.member.balance()`, `completions()`, `groups()`, `enrolled()` and `referrals()`, which read
+ * Relay's own state of the member. Like Telegram's, they stay out of the closed `CapabilityRequest`: the kit answers and
+ * numbers them, but lists them only in a run's `capabilityCalls`, not in the deprecated `calls`.
+ */
+declare const memberStateRequestSchemas: {
+    "member-balance": z.ZodObject<{
+        kind: z.ZodLiteral<"member-balance">;
+        ledger: z.ZodString;
+    }, z.core.$strict>;
+    "member-completions": z.ZodObject<{
+        kind: z.ZodLiteral<"member-completions">;
+        quest: z.ZodNullable<z.ZodString>;
+        since: z.ZodNullable<z.ZodNumber>;
+        limit: z.ZodNumber;
+    }, z.core.$strict>;
+    "member-groups": z.ZodObject<{
+        kind: z.ZodLiteral<"member-groups">;
+    }, z.core.$strict>;
+    "member-enrolled": z.ZodObject<{
+        kind: z.ZodLiteral<"member-enrolled">;
+        campaign: z.ZodString;
+    }, z.core.$strict>;
+    "member-referrals": z.ZodObject<{
+        kind: z.ZodLiteral<"member-referrals">;
+        program: z.ZodString;
+    }, z.core.$strict>;
+};
+type MemberStateRequest = z.output<(typeof memberStateRequestSchemas)[keyof typeof memberStateRequestSchemas]>;
+/** Every request the kit answers: the public `CapabilityRequest` kinds, Telegram's, NFT, contract call and delegation reads, and the member's state. */
+type KitRequest = CapabilityRequest | TelegramRequest | WalletNftsRequest | WalletCallRequest | WalletDelegationsRequest | WalletEventsRequest | WalletTransactionsRequest | MemberStateRequest;
+/**
+ * The capability kinds this release of the kit knows, one per reader method family.
+ *
+ * @compat open
+ */
+type KnownCapabilityKind = KitRequest["kind"];
+/**
+ * One capability request quest code sent, as Relay validated it: `kind` names the reader, and the
+ * other fields are the wire request's, such as `{ kind: "wallet-events", event, account, since }`.
+ * Open: a later release adds kinds, and a request of a kind this release does not know keeps its
+ * fields. Compare it whole, or narrow on `kind` and read the fields you expect.
+ *
+ * @compat output
+ */
+type CapabilityCallRequest = {
+    kind: KnownCapabilityKind | (string & {});
+    [field: string]: unknown;
+};
 
 /** A result as a fake writes it: Relay's result schema fills defaults before quest code reads it. */
 type Result<S extends z.ZodType> = z.input<S>;
@@ -257,7 +383,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 +392,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 +428,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
@@ -350,31 +477,30 @@ type TestFacts = {
         ], Result<typeof walletBalanceSchema> | null>;
         /**
          * `ctx.wallet.nfts({ collection })`. Like `balance`, it reads null while the member has no
-         * linked wallet of the collection's family (EVM or Solana). A run's `calls` does not list NFT reads: its request type is closed in
-         * SDK 1.x.
+         * linked wallet of the collection's family (EVM or Solana). A run's `capabilityCalls` lists these calls; the deprecated `calls` does not.
          */
         nfts?: FakeAnswer<[
             query: WalletNftsQueryRequest
         ], Result<typeof walletNftsSchema> | null>;
         /**
          * `ctx.wallet.call({ call, args })`. Like `balance`, it reads null while the member has no
-         * linked EVM wallet. A run's `calls` does not list contract calls: its request type is closed
-         * in SDK 1.x.
+         * linked EVM wallet. A run's `capabilityCalls` lists these calls; the deprecated `calls` does not.
          */
         call?: FakeAnswer<[
             query: WalletCallQueryRequest
         ], Result<typeof walletCallSchema> | null>;
         /**
          * `ctx.wallet.delegations({ chain, validator })`. Like `balance`, it reads null while the member
-         * has no wallet linked on that Cosmos network. A run's `calls` does not list delegation reads.
+         * has no wallet linked on that Cosmos network. A run's `capabilityCalls` lists these calls; the deprecated `calls` does not.
          */
         delegations?: FakeAnswer<[
             query: WalletDelegationsQueryRequest
         ], 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 `capabilityCalls` lists these calls; the deprecated `calls` does not.
          */
         events?: FakeAnswer<[
             query: WalletEventsQueryRequest
@@ -383,7 +509,7 @@ type TestFacts = {
          * `ctx.wallet.transactions({ program, since })`. Like `balance`, it reads null while the
          * member has no linked Solana wallet. The kit does not apply `program`, `since` or `mint`:
          * answer with the transactions Relay would return, with `instructions` when the program's
-         * setting has an Anchor IDL. A run's `calls` does not list transaction reads.
+         * setting has an Anchor IDL. A run's `capabilityCalls` lists these calls; the deprecated `calls` does not.
          */
         transactions?: FakeAnswer<[
             query: WalletTransactionsQueryRequest
@@ -414,11 +540,13 @@ 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 `capabilityCalls` lists these calls; the deprecated `calls` does not.
      */
     telegram?: {
+        connection?: FakeAnswer<[], Result<typeof telegramConnectionSchema> | null>;
         member?: FakeAnswer<[
             input: {
                 chat: string;
@@ -488,6 +616,8 @@ declare const defaultSeed = "attempt_test";
 /**
  * The most capability calls one hosted evaluation run can make, shared by all capabilities. The
  * next call throws a `CapabilityError` with code `capability-limit`.
+ *
+ * @deprecated Use `limits.capabilityCalls`, which a 1.x release can raise.
  */
 declare const maxCapabilityCalls = 8;
 /**
@@ -570,7 +700,8 @@ type RunQuestOptions<Q extends TestableQuest = TestableQuest> = {
     facts?: TestFacts;
 };
 /**
- * One capability call, as Relay captures it for replay.
+ * One capability call, as Relay captures it for replay. Its request type is closed in SDK 1.x, so
+ * lists of it leave out the kinds it cannot name; use `CapabilityCallRecord`.
  *
  * @compat output
  */
@@ -579,6 +710,17 @@ type CapabilityCall = {
     request: CapabilityRequest;
     outcome: CapabilityOutcome;
 };
+/**
+ * One capability call of any kind, as Relay captures it for replay: its position in the run, the
+ * request quest code sent, and the value or failure quest code received.
+ *
+ * @compat output
+ */
+type CapabilityCallRecord = {
+    sequence: number;
+    request: CapabilityCallRequest;
+    outcome: CapabilityOutcome;
+};
 /**
  * The published release a run used: what `describe` returned for the settings.
  *
@@ -604,8 +746,15 @@ type QuestDiagnostic = {
 type TestContext<Q extends TestableQuest = TestableQuest> = {
     /** The host context to pass to `quest.evaluate`. */
     context: QuestHostContext<Q>;
-    /** The capability calls quest code has made so far, in order. */
+    /**
+     * The capability calls of the kinds `CapabilityRequest` names, in order.
+     *
+     * @deprecated Use `capabilityCalls`, which lists every kind: Telegram, NFT, contract call,
+     * delegation, wallet event and transaction reads and the member's state are missing here.
+     */
     calls: CapabilityCall[];
+    /** Every capability call quest code has made so far, of any kind, in order. */
+    capabilityCalls: CapabilityCallRecord[];
     /** What `quest.evaluate` has reported so far that had no effect. */
     diagnostics: QuestDiagnostic[];
     release: TestRelease;
@@ -616,7 +765,15 @@ type TestContext<Q extends TestableQuest = TestableQuest> = {
 /** @compat output */
 type QuestRun = {
     decision: Decision;
+    /**
+     * The capability calls of the kinds `CapabilityRequest` names, in order.
+     *
+     * @deprecated Use `capabilityCalls`, which lists every kind: Telegram, NFT, contract call,
+     * delegation, wallet event and transaction reads and the member's state are missing here.
+     */
     calls: CapabilityCall[];
+    /** Every capability call the run made, of any kind, in order. `runQuest` always sets it. */
+    capabilityCalls?: CapabilityCallRecord[];
     release: TestRelease;
     /**
      * What the run did that had no effect; Relay records none of it for hosted attempts. `runQuest`
@@ -626,6 +783,8 @@ type QuestRun = {
 };
 /** What `runQuest` resolves with. */
 type DiagnosedRun = QuestRun & {
+    /** Every capability call the run made, of any kind, in order. */
+    capabilityCalls: CapabilityCallRecord[];
     /** What the run did that had no effect; Relay records none of it for hosted attempts. */
     diagnostics: QuestDiagnostic[];
 };
@@ -651,13 +810,36 @@ declare function createTestContext<Q extends TestableQuest>(quest: Q, options?:
  * capability readers answered from `facts` and checked against Relay's capability contracts, and
  * the decision's rewards checked against the published bundle.
  *
- * Resolves with the decision and every capability call. Rejects with a capability failure that
+ * Resolves with the decision and every capability call, in `capabilityCalls`. Rejects with a capability failure that
  * escaped quest code, as thrown or wrapped (Relay retries a retryable one); with an
  * `EvaluatorError` for anything else quest code threw, which Relay fails the attempt with once;
  * or with a `TestSetupError` for a call the facts cannot answer.
  */
 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;
+
+/**
+ * A `WalletReader` with every method Relay supplies, answered from `facts.wallet` as `runQuest`
+ * answers it: a member with no linked wallet unless `facts.wallet.list` links one. Use it in a
+ * test that builds its own evaluation context; a minor release that adds a reader method gives it
+ * here too, so the test keeps compiling and the new method keeps working.
+ */
+declare function fakeWalletReader(facts?: Pick<TestFacts, "wallet">): Required<WalletReader>;
+/**
+ * A `TelegramReader` with every method Relay supplies, answered from `facts.telegram` as
+ * `runQuest` answers it: a member who has not linked Telegram unless the facts say otherwise.
+ */
+declare function fakeTelegramReader(facts?: Pick<TestFacts, "telegram">): Required<TelegramReader>;
+
 type Kind = Decision["kind"];
 type DecisionOf<K extends Kind> = Extract<Decision, {
     kind: K;
@@ -760,7 +942,8 @@ type ReplayOptions = {
     facts?: TestFacts;
 };
 /**
- * The first call the capture could not answer.
+ * The first call the capture could not answer, when its kind is one `CapabilityRequest` names.
+ * Use `CapabilityDivergence`, which reports every kind.
  *
  * @compat output
  */
@@ -775,6 +958,27 @@ type ReplayDivergence = {
     recorded: Record<string, unknown> | null;
     replayed: CapabilityRequest;
 };
+/**
+ * Why the capture could not answer a call. `"new"`: the captured run made no such call.
+ * `"changed"`: it sent another request. `"uncaptured"`: its answer was a retryable failure Relay
+ * did not keep.
+ *
+ * @compat open
+ */
+type KnownDivergenceReason = "new" | "changed" | "uncaptured";
+/**
+ * The first call the capture could not answer, of any capability kind.
+ *
+ * @compat output
+ */
+type CapabilityDivergence = {
+    sequence: number;
+    reason: KnownDivergenceReason | (string & {});
+    /** The request the captured run sent at this position; null for a new call. */
+    recorded: Record<string, unknown> | null;
+    /** The request current quest code sent. */
+    replayed: CapabilityCallRequest;
+};
 /** @compat output */
 type AttemptReplay = {
     /** What the current quest code decides; null when the replay stopped at a divergence. */
@@ -786,9 +990,26 @@ type AttemptReplay = {
      * key. Null when either is missing.
      */
     changed: boolean | null;
-    /** The first call the capture could not answer, or null when it answered every call. */
+    /**
+     * The first call the capture could not answer, or null when it answered every call or the
+     * first such call is of a kind `CapabilityRequest` does not name.
+     *
+     * @deprecated Use `capabilityDivergence`, which reports every kind.
+     */
     divergence: ReplayDivergence | null;
+    /**
+     * The first call the capture could not answer, of any kind, or null when it answered every
+     * call. `replayAttempt` always sets it.
+     */
+    capabilityDivergence?: CapabilityDivergence | null;
+    /**
+     * The capability calls of the kinds `CapabilityRequest` names, in order.
+     *
+     * @deprecated Use `capabilityCalls`, which lists every kind.
+     */
     calls: CapabilityCall[];
+    /** Every capability call the replay made, of any kind, in order. `replayAttempt` always sets it. */
+    capabilityCalls?: CapabilityCallRecord[];
 };
 /**
  * Evaluates current quest code against a captured attempt: the release's settings and rewards,
@@ -801,6 +1022,84 @@ type AttemptReplay = {
  * alters a past outcome. A call the capture cannot answer stops the replay unless `facts`
  * answers it; the result names the first one.
  */
-declare function replayAttempt<Q extends TestableQuest>(quest: Q, capture: unknown, options?: ReplayOptions): Promise<AttemptReplay>;
+declare function replayAttempt<Q extends TestableQuest>(quest: Q, capture: unknown, options?: ReplayOptions): Promise<AttemptReplay & {
+    capabilityDivergence: CapabilityDivergence | null;
+    capabilityCalls: CapabilityCallRecord[];
+}>;
+
+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 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 };
+export { type AttemptReplay, type CalendarSegment, type CapabilityCall, type CapabilityCallRecord, type CapabilityCallRequest, type CapabilityDivergence, type CapabilityOutcome, type CapabilityRequest, Decision, DecisionAssertionError, EvaluatorError, type FakeAnswer, type FakeRelay, type FakeRelayOptions, type FakeRelayRequest, type KnownCapabilityKind, type KnownDivergenceReason, 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, fakeTelegramReader, fakeWalletReader, maxCapabilityCalls, replayAttempt, runQuest, trackerObservation, trackerPage };