@domino-sdk/relay 1.53.1 → 1.55.0

package/dist/{submission-input-BNah53go.d.ts → submission-input-BbdawqVy.d.ts}

@@ -1,6 +1,6 @@
 import * as z from 'zod';
-import { L as LedgerReference, r as QuestHandle } from './schema-BJ9bOgpN.js';
-import { r as ProjectGroupReference } from './groups-B5R1RCsl.js';
+import { L as LedgerReference, D as QuestHandle } from './schema-C4m9RhCR.js';
+import { k as ProjectGroupReference } from './groups-O6onGPmC.js';
 
 declare const completionPrerequisiteSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"completion">;

package/dist/{telegram-browser-C36j_6v-.d.ts → telegram-browser-CwaxROAZ.d.ts}

@@ -1,5 +1,5 @@
 import { a as AuthProvider, b as TelegramSignInMethods } from './accounts-DRPENuZe.js';
-import { p as createRelayClient, k as RelayRequestOptions, g as RelayError } from './client-CzNtl8UO.js';
+import { p as createRelayClient, k as RelayRequestOptions, g as RelayError } from './client-C4zUZKpj.js';
 import { b as ParticipantSession } from './participant-activity-iciCEs_8.js';
 import { C as CosmosChain, a as CosmosNetwork, f as WalletSigner, d as WalletSignInNetwork } from './wallet-Ac7OFpOr.js';
 

package/dist/testing.d.ts

@@ -1,11 +1,12 @@
-import { bL as memberIdentitySchema, d0 as trackerQuerySchema, cX as trackerPageSchema, d9 as trackerSummarySchema, aO as TrackerContentQuery, cI as trackerContentSchema, bQ as photoResultSchema, Y as TextReviewInput, R as Reward, $ as Decision, aK as TrackerAttribution, y as Tracker, z as TrackerData, a4 as ContentBody, U as TrackerTriggerContext, aa as TrackerPage } from './schema-BJ9bOgpN.js';
+import { bZ as memberIdentitySchema, c8 as pointBalanceSchema, dn as trackerQuerySchema, di as trackerPageSchema, dx as trackerSummarySchema, a_ as TrackerContentQuery, d3 as trackerContentSchema, c2 as photoResultSchema, a6 as TextReviewInput, R as Reward, a9 as Decision, aW as TrackerAttribution, N as Tracker, U as TrackerData, ae as ContentBody, a4 as TrackerTriggerContext, ak as TrackerPage } from './schema-C4m9RhCR.js';
 import * as z from 'zod';
 import { t as discordMemberSchema, w as discordMessageSchema, G as telegramChatMemberSchema } from './accounts-DRPENuZe.js';
-import { b as CapabilityFailure } from './capability-error-FQGGb5xS.js';
-export { C as CapabilityError } from './capability-error-FQGGb5xS.js';
-import { z as xConnectionSchema, C as xProfileSchema, B as xPostSchema, f as ImageReference, s as imageInspectionSchema, o as imageComparisonSchema, v as imageSightingsSchema } from './x-BfQcsDp0.js';
+import { b as CapabilityFailure, h as memberCompletionSchema } from './capability-error-DSd8EMQC.js';
+export { C as CapabilityError } from './capability-error-DSd8EMQC.js';
+import { z as xConnectionSchema, C as xProfileSchema, B as xPostSchema, f as ImageReference, s as imageInspectionSchema, o as imageComparisonSchema, v as imageSightingsSchema } from './x-1czZFVUW.js';
 import { v as linkedWalletSchema, A as walletBalanceSchema } from './wallet-Ac7OFpOr.js';
-export { A as AttemptCapture, C as CapturedFact } from './attempt-captures-QC4kTA44.js';
+import { C as profileReferralSchema } from './profiles-BoOK03cR.js';
+export { A as AttemptCapture, C as CapturedFact } from './attempt-captures-CxxO7DeD.js';
 
 /** One project time-zone change: from `effectiveAt` on, days are counted in `timeZone`. */
 type CalendarSegment = {
@@ -220,6 +221,12 @@ type CapabilityRequest = {
 
 /** 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>;
+/** One campaign the member's enrollment state is known for, as `facts.member.campaigns` lists it. */
+declare const campaignFactSchema: z.ZodObject<{
+    key: z.ZodString;
+    enrolled: z.ZodBoolean;
+}, z.core.$strict>;
+type CampaignFact = z.output<typeof campaignFactSchema>;
 /**
  * A fake capability answer: the value the reader resolves with, or a function of the call's
  * arguments that returns it. Throw a `CapabilityError` from the function to fail the call as
@@ -256,8 +263,9 @@ type TrackerFacts = {
  * `member.identities()`, `wallet.list()`, `wallet.balance()`, `x.connection()`, `x.profile()`,
  * `x.follows()`, `x.reposted()`, `discord.member()` 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 (an X post, a Discord message, trackers, images and AI review) needs an
- * answer: a call without one fails the run.
+ * 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
+ * fails the run.
  *
  * Answers pass the result schemas Relay applies before quest code sees them, and arrive as JSON,
  * as in a hosted run.
@@ -267,6 +275,33 @@ type TrackerFacts = {
 type TestFacts = {
     member?: {
         identities?: FakeAnswer<[], Result<typeof memberIdentitySchema>[] | null>;
+        /**
+         * The member's balance in each of the project's ledgers, as `relay.me.balances()` lists them,
+         * read once per run as Relay pins them. `ctx.member.balance(ledger)` returns the one whose
+         * ledger key or ID it names, and fails with `author-error` for a ledger not listed.
+         */
+        balances?: FakeAnswer<[], Result<typeof pointBalanceSchema>[]>;
+        /**
+         * The member's accepted, unrevoked quest completions, each naming its quest by key, read once
+         * per run as Relay pins them. `ctx.member.completions()` filters, orders and limits them as Relay
+         * does.
+         */
+        completions?: FakeAnswer<[], Result<typeof memberCompletionSchema>[]>;
+        /** Keys of the unarchived groups the member belongs to, read once per run as Relay pins them. */
+        groups?: FakeAnswer<[], string[]>;
+        /**
+         * The campaigns the project knows, each with whether the member's enrollment is active, read
+         * once per run as Relay pins them. `ctx.member.enrolled(campaign)` fails with `author-error`
+         * for a campaign not listed.
+         */
+        campaigns?: FakeAnswer<[], CampaignFact[]>;
+        /**
+         * The member's progress as inviter in each of the project's referral programs, as
+         * `relay.profiles.referral()` returns it, read once per run as Relay pins them.
+         * `ctx.member.referrals(program)` returns the one whose key or program ID it names, and fails
+         * with `author-error` for a program not listed.
+         */
+        referrals?: FakeAnswer<[], Result<typeof profileReferralSchema>[]>;
     };
     wallet?: {
         list?: FakeAnswer<[], Result<typeof linkedWalletSchema>[] | null>;
@@ -370,6 +405,11 @@ declare const defaultNow: number;
 declare const defaultMember = "member_test";
 /** The attempt ID that seeds a run's randomness unless the test sets `seed`. */
 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`.
+ */
+declare const maxCapabilityCalls = 8;
 /**
  * A quest handle from `defineQuest` or `defineQuestType`, as the testing kit uses it.
  *
@@ -470,12 +510,24 @@ type TestRelease = {
     humanReview: boolean;
     integrations: readonly string[];
 };
+/**
+ * Something a run did that had no effect, reported without failing the run. `code` is
+ * `completion-key-ignored`: the evaluator returned a `completionKey` its completion policy ignores.
+ *
+ * @compat output
+ */
+type QuestDiagnostic = {
+    code: string;
+    message: string;
+};
 /** @compat output */
 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. */
     calls: CapabilityCall[];
+    /** What `quest.evaluate` has reported so far that had no effect. */
+    diagnostics: QuestDiagnostic[];
     release: TestRelease;
     /** The run's start time and seed. */
     now: number;
@@ -486,7 +538,27 @@ type QuestRun = {
     decision: Decision;
     calls: CapabilityCall[];
     release: TestRelease;
+    /**
+     * What the run did that had no effect; Relay records none of it for hosted attempts. `runQuest`
+     * always sets it.
+     */
+    diagnostics?: QuestDiagnostic[];
+};
+/** What `runQuest` resolves with. */
+type DiagnosedRun = QuestRun & {
+    /** What the run did that had no effect; Relay records none of it for hosted attempts. */
+    diagnostics: QuestDiagnostic[];
 };
+/**
+ * Quest code failed on its own: `evaluate` threw something other than a capability failure it
+ * received, or returned no decision. Relay fails the attempt at once, without retrying, with code
+ * `evaluator-error` and this message; `cause` is what quest code threw.
+ */
+declare class EvaluatorError extends Error {
+    readonly code = "evaluator-error";
+    readonly retryable = false;
+    constructor(thrown: unknown);
+}
 /**
  * Builds the host context `quest.evaluate` takes, with fake readers that answer from `facts`. Use
  * it to call `quest.evaluate` yourself; `runQuest` also freezes the clock, seeds randomness and
@@ -499,11 +571,12 @@ 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 what quest code threw, such
- * as an uncaught `CapabilityError` (Relay retries a retryable one), or with a `TestSetupError` for
- * a call the facts cannot answer.
+ * Resolves with the decision and every capability call. 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<QuestRun>;
+declare function runQuest<Q extends TestableQuest>(quest: Q, options?: RunQuestOptions<Q>): Promise<DiagnosedRun>;
 
 type Kind = Decision["kind"];
 type DecisionOf<K extends Kind> = Extract<Decision, {
@@ -650,4 +723,4 @@ 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, type FakeAnswer, 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, replayAttempt, runQuest, trackerObservation, trackerPage };
+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 };