@domino-sdk/relay 1.62.0 → 1.63.0

package/dist/{sign-in-providers-BkjcDsFF.d.ts → sign-in-providers-B1Q9eDRm.d.ts}

@@ -1,7 +1,12 @@
-import { J as SignInProvider } from './accounts-CCqCKCVx.js';
+import { J as SignInProvider } from './accounts-nz3mzfRQ.js';
 import * as z from 'zod';
-import { a as TelegramSignInMethods } from './submission-input-DHGKhXfp.js';
+import { a as TelegramSignInMethods } from './submission-input-DZCbjQUH.js';
 
+/**
+ * `GET /v1/auth/providers`, as `relay.auth.providers()` reads it. Exported as a schema only, for the
+ * wire fixtures that pin its released shape (compat/wire/participant/auth-providers-*.json):
+ * `providers` keeps SDK 1.x's closed `AuthProvider`, and `signInProviders` is its open sibling.
+ */
 declare const authProvidersSchema: z.ZodObject<{
     providers: z.ZodArray<z.ZodObject<{
         provider: z.ZodEnum<{

package/dist/{submission-input-DHGKhXfp.d.ts → submission-input-DZCbjQUH.d.ts}

@@ -1,6 +1,6 @@
 import * as z from 'zod';
-import { L as LedgerReference, Q as QuestHandle } from './tracker-data-Hb1uQnk5.js';
-import { B as ProjectGroupReference } from './accounts-CCqCKCVx.js';
+import { L as LedgerReference, Q as QuestHandle } from './tracker-data-esm3WG8R.js';
+import { B as ProjectGroupReference } from './accounts-nz3mzfRQ.js';
 
 declare const completionPrerequisiteSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"completion">;
@@ -227,6 +227,7 @@ declare const telegramConnectionInputSchema: z.ZodObject<{
 declare const telegramConnectionSchema: z.ZodObject<{
     userId: z.ZodString;
 }, z.core.$strip>;
+/** The member's linked Telegram account, as `ctx.telegram.connection()` reads it. */
 type TelegramConnection = z.infer<typeof telegramConnectionSchema>;
 /** A member's status in a chat as Telegram reports it; a later Telegram may add others. */
 type TelegramChatMemberStatus = "creator" | "administrator" | "member" | "restricted" | (string & {});

package/dist/{telegram-browser-BCE7zdOb.d.ts → telegram-browser-NL0Asmsi.d.ts}

@@ -1,8 +1,8 @@
-import { c as AuthProvider, J as SignInProvider } from './accounts-CCqCKCVx.js';
-import { p as createRelayClient, k as RelayRequestOptions, g as RelayError } from './client-B-hbHX30.js';
-import { a as TelegramSignInMethods } from './submission-input-DHGKhXfp.js';
+import { c as AuthProvider, J as SignInProvider } from './accounts-nz3mzfRQ.js';
+import { p as createRelayClient, k as RelayRequestOptions, g as RelayError } from './client-DHmG7rn6.js';
+import { a as TelegramSignInMethods } from './submission-input-DZCbjQUH.js';
 import { b as ParticipantSession } from './participant-activity-D-Drp24G.js';
-import { C as CosmosChain, a as CosmosNetwork, m as WalletSigner, k as WalletSignInNetwork } from './wallet-DTO7SXj7.js';
+import { C as CosmosChain, a as CosmosNetwork, m as WalletSigner, k as WalletSignInNetwork } from './wallet-B7e06v4m.js';
 
 /** An EIP-1193 provider, such as `window.ethereum` or an EIP-6963 announcement's provider. */
 type Eip1193Provider = {

package/dist/telegram.d.ts

@@ -1,15 +1,15 @@
-import { k as RelayRequestOptions, R as RelayClient } from './client-B-hbHX30.js';
+import { k as RelayRequestOptions, R as RelayClient } from './client-DHmG7rn6.js';
 import { b as ParticipantSession } from './participant-activity-D-Drp24G.js';
-import './accounts-CCqCKCVx.js';
+import './accounts-nz3mzfRQ.js';
 import 'zod';
-import './tracker-data-Hb1uQnk5.js';
-import './wallet-DTO7SXj7.js';
-import './pages-B8q8Y_dQ.js';
-import './submission-input-DHGKhXfp.js';
+import './tracker-data-esm3WG8R.js';
+import './wallet-B7e06v4m.js';
+import './submission-input-DZCbjQUH.js';
 import './request-error-D_dUPLwo.js';
-import './catalog--ZIlskAo.js';
+import './reward-deliveries-drp-x1G-.js';
+import './catalog-BaTOKpNw.js';
 import './action-9Xl0StBg.js';
-import './sign-in-providers-BkjcDsFF.js';
+import './sign-in-providers-B1Q9eDRm.js';
 
 /**
  * A plugin's own sign-in method, such as Telegram's Mini App sign-in: the app passes the vendor's

package/dist/telegram.js

@@ -3,8 +3,8 @@ import {
 } from "./chunk-FWLQ5XCS.js";
 import {
   withPluginNamespace
-} from "./chunk-6WCIWXUV.js";
-import "./chunk-K2KS3JLY.js";
+} from "./chunk-MTKRIQEU.js";
+import "./chunk-GLH6MEI2.js";
 
 // src/plugins/telegram.generated.ts
 function withTelegram(relay) {

package/dist/testing.d.ts

@@ -1,17 +1,19 @@
-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 { 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 { 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 { 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-Cm-5G0PC.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-DhAtss4_.js';
-import { b as QuestView, q as questExperienceSchema } from './catalog--ZIlskAo.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`. */
@@ -224,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>;
@@ -358,23 +477,21 @@ 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
@@ -383,7 +500,7 @@ type TestFacts = {
          * `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`, `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 out. A run's `capabilityCalls` lists these calls; the deprecated `calls` does not.
          */
         events?: FakeAnswer<[
             query: WalletEventsQueryRequest
@@ -392,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
@@ -426,8 +543,7 @@ type TestFacts = {
      * `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.
+     * project has not connected. A run's `capabilityCalls` lists these calls; the deprecated `calls` does not.
      */
     telegram?: {
         connection?: FakeAnswer<[], Result<typeof telegramConnectionSchema> | null>;
@@ -500,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;
 /**
@@ -582,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
  */
@@ -591,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.
  *
@@ -616,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;
@@ -628,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`
@@ -638,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[];
 };
@@ -663,7 +810,7 @@ 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.
@@ -680,6 +827,19 @@ declare function runQuest<Q extends TestableQuest>(quest: Q, options?: RunQuestO
  */
 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;
@@ -782,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
  */
@@ -797,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. */
@@ -808,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,
@@ -823,7 +1022,10 @@ 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>;
 /**
@@ -900,4 +1102,4 @@ type FakeRelay = {
  */
 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 };
+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 };