@domino-sdk/relay 1.53.1 → 1.55.0

package/dist/testing.js

@@ -1,23 +1,25 @@
 import {
   attemptCaptureSchema
-} from "./chunk-7BNCLWAO.js";
+} from "./chunk-XALIFNMD.js";
 import {
   CapabilityError
 } from "./chunk-4OC7REYX.js";
 import {
   parseImageResult
-} from "./chunk-LPHXTZDA.js";
+} from "./chunk-YE3XYB2F.js";
 import {
   imageRequestSchema,
   xConnectionSchema,
   xPostSchema,
   xProfileSchema,
   xRequestSchema
-} from "./chunk-K6TVMNU4.js";
+} from "./chunk-YEVD4A5X.js";
 import {
+  pointBalanceSchema,
+  profileReferralSchema,
   telegramChatMemberSchema,
   telegramMemberInputSchema
-} from "./chunk-2NUD237O.js";
+} from "./chunk-WHMXXHPX.js";
 import {
   contentPerformanceSnapshotSchema,
   cosmosNetworkSchema,
@@ -28,6 +30,8 @@ import {
   evmChainIdSchema,
   identifier,
   linkedWalletSchema,
+  maxMemberCompletions,
+  memberCompletionSchema,
   memberIdentitySchema,
   photoResultSchema,
   quizEvidenceSchema,
@@ -46,7 +50,7 @@ import {
   urlEvidenceSchema,
   validateSubmissionValue,
   walletBalanceSchema
-} from "./chunk-IELNFM3V.js";
+} from "./chunk-YCOKTQ4E.js";
 
 // src/testing/run.ts
 import * as z3 from "zod";
@@ -189,6 +193,30 @@ var telegramRequestSchema = z.strictObject({
   kind: z.literal("telegram"),
   input: telegramMemberInputSchema
 });
+var memberStateRequestSchemas = {
+  "member-balance": z.strictObject({
+    kind: z.literal("member-balance"),
+    ledger: identifier
+  }),
+  "member-completions": z.strictObject({
+    kind: z.literal("member-completions"),
+    quest: identifier.nullable(),
+    since: z.number().int().nonnegative().safe().nullable(),
+    limit: z.number().int().min(1).max(maxMemberCompletions)
+  }),
+  "member-groups": z.strictObject({ kind: z.literal("member-groups") }),
+  "member-enrolled": z.strictObject({
+    kind: z.literal("member-enrolled"),
+    campaign: identifier
+  }),
+  "member-referrals": z.strictObject({
+    kind: z.literal("member-referrals"),
+    program: identifier
+  })
+};
+function unlistedRequest(request) {
+  return request.kind === "telegram" || 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", [
   capabilityRequestSchemas["wallet-balance"],
   capabilityRequestSchemas["tracker-content"],
@@ -201,7 +229,12 @@ var capabilityRequestSchema = z.discriminatedUnion("kind", [
   capabilityRequestSchemas.discord,
   capabilityRequestSchemas["wallet-list"],
   capabilityRequestSchemas["member-identities"],
-  telegramRequestSchema
+  telegramRequestSchema,
+  memberStateRequestSchemas["member-balance"],
+  memberStateRequestSchemas["member-completions"],
+  memberStateRequestSchemas["member-groups"],
+  memberStateRequestSchemas["member-enrolled"],
+  memberStateRequestSchemas["member-referrals"]
 ]);
 function parseCapabilityRequest(raw) {
   return capabilityRequestSchema.safeParse(raw);
@@ -245,6 +278,16 @@ function parseCapabilityResult(request, value) {
       return z.array(memberIdentitySchema).min(1).nullable().parse(value);
     case "telegram":
       return telegramChatMemberSchema.nullable().parse(value);
+    case "member-balance":
+      return pointBalanceSchema.parse(value);
+    case "member-completions":
+      return z.array(memberCompletionSchema).max(request.limit).parse(value);
+    case "member-groups":
+      return z.array(identifier).parse(value);
+    case "member-enrolled":
+      return z.boolean().parse(value);
+    case "member-referrals":
+      return profileReferralSchema.parse(value);
   }
 }
 function imageReferences(input) {
@@ -274,10 +317,23 @@ function capabilityEvidence(request) {
   );
 }
 var readerFactories = {
-  member: (call, input) => ({
-    ...input.member,
-    identities: () => call({ kind: "member-identities" })
-  }),
+  member: (call, input) => {
+    const key = (reference) => typeof reference === "string" ? reference : reference.key;
+    return {
+      ...input.member,
+      identities: () => call({ kind: "member-identities" }),
+      balance: (ledger) => call({ kind: "member-balance", ledger: key(ledger) }),
+      completions: ({ quest, since, limit = 100 } = {}) => call({
+        kind: "member-completions",
+        quest: quest === void 0 ? null : key(quest),
+        since: since ?? null,
+        limit: limit > 100 ? 100 : limit
+      }),
+      groups: () => call({ kind: "member-groups" }),
+      enrolled: (campaign) => call({ kind: "member-enrolled", campaign: key(campaign) }),
+      referrals: (program) => call({ kind: "member-referrals", program: key(program) })
+    };
+  },
   discord: (call) => ({
     member: () => call({ kind: "discord", input: {} }),
     message: (input) => call({ kind: "discord", input })
@@ -476,21 +532,21 @@ function install(now, seed, restores) {
   const crypto = globalThis.crypto;
   if (crypto) {
     restores.push(
-      replace(crypto, "getRandomValues", (array2) => {
-        if (!integerArrays.some((type) => array2 instanceof type)) {
+      replace(crypto, "getRandomValues", (array3) => {
+        if (!integerArrays.some((type) => array3 instanceof type)) {
           throw new DOMException(
             "getRandomValues takes an integer typed array",
             "TypeMismatchError"
           );
         }
-        if (array2.byteLength > 65536) {
+        if (array3.byteLength > 65536) {
           throw new DOMException(
             "getRandomValues takes at most 65536 bytes",
             "QuotaExceededError"
           );
         }
-        fill(new Uint8Array(array2.buffer, array2.byteOffset, array2.byteLength));
-        return array2;
+        fill(new Uint8Array(array3.buffer, array3.byteOffset, array3.byteLength));
+        return array3;
       })
     );
     restores.push(
@@ -510,6 +566,10 @@ function install(now, seed, restores) {
 
 // src/testing/facts.ts
 import * as z2 from "zod";
+var campaignFactSchema = z2.strictObject({
+  key: identifier,
+  enrolled: z2.boolean()
+});
 var TestSetupError = class extends Error {
   constructor(message) {
     super(message);
@@ -524,6 +584,38 @@ function fakeFor(facts, request) {
         answer: facts.member?.identities,
         args: []
       };
+    case "member-balance":
+      return {
+        name: "member.balances",
+        reader: "member.balance",
+        answer: facts.member?.balances,
+        args: []
+      };
+    case "member-completions":
+      return {
+        name: "member.completions",
+        answer: facts.member?.completions,
+        args: []
+      };
+    case "member-groups":
+      return {
+        name: "member.groups",
+        answer: facts.member?.groups,
+        args: []
+      };
+    case "member-enrolled":
+      return {
+        name: "member.campaigns",
+        reader: "member.enrolled",
+        answer: facts.member?.campaigns,
+        args: []
+      };
+    case "member-referrals":
+      return {
+        name: "member.referrals",
+        answer: facts.member?.referrals,
+        args: []
+      };
     case "wallet-list":
       return {
         name: "wallet.list",
@@ -627,7 +719,7 @@ function factsAnswerer(facts) {
   async function ask(fake) {
     if (fake.answer === void 0) {
       throw new TestSetupError(
-        `The quest called ctx.${fake.name}, but the test gave no answer: set facts.${fake.name}`
+        `The quest called ctx.${fake.reader ?? fake.name}, but the test gave no answer: set facts.${fake.name}`
       );
     }
     try {
@@ -663,6 +755,79 @@ function factsAnswerer(facts) {
     }
     return outcome;
   }
+  function state(fake, schema) {
+    let outcome = pins.get(fake.name);
+    if (!outcome) {
+      outcome = ask(fake).then((answered) => {
+        if ("error" in answered) {
+          return answered;
+        }
+        const parsed = z2.array(schema).safeParse(answered.value);
+        if (!parsed.success) {
+          throw new TestSetupError(
+            `facts.${fake.name} is not a list Relay reads: ${z2.prettifyError(parsed.error)}`
+          );
+        }
+        return { value: parsed.data };
+      });
+      pins.set(fake.name, outcome);
+    }
+    return outcome;
+  }
+  async function memberState(request, fake) {
+    if (request.kind === "member-balance") {
+      const pinned2 = await state(fake, pointBalanceSchema);
+      if ("error" in pinned2) {
+        return pinned2;
+      }
+      const balance = pinned2.value.find(
+        ({ ledger }) => ledger.key === request.ledger || ledger.id === request.ledger
+      );
+      return balance ? { value: balance } : failure("author-error", `Point ledger not found: ${request.ledger}`);
+    }
+    if (request.kind === "member-groups") {
+      const pinned2 = await state(fake, identifier);
+      return "error" in pinned2 ? pinned2 : {
+        value: [...new Set(pinned2.value)].sort(
+          (a, b) => a < b ? -1 : a > b ? 1 : 0
+        )
+      };
+    }
+    if (request.kind === "member-enrolled") {
+      const pinned2 = await state(fake, campaignFactSchema);
+      if ("error" in pinned2) {
+        return pinned2;
+      }
+      const campaign = pinned2.value.find(
+        ({ key }) => key === request.campaign
+      );
+      return campaign ? { value: campaign.enrolled } : failure("author-error", `Campaign not found: ${request.campaign}`);
+    }
+    if (request.kind === "member-referrals") {
+      const pinned2 = await state(fake, profileReferralSchema);
+      if ("error" in pinned2) {
+        return pinned2;
+      }
+      const progress = pinned2.value.find(
+        ({ key, program }) => key === request.program || program === request.program
+      );
+      return progress ? { value: progress } : failure(
+        "author-error",
+        `Referral program not found: ${request.program}`
+      );
+    }
+    const pinned = await state(fake, memberCompletionSchema);
+    if ("error" in pinned) {
+      return pinned;
+    }
+    const { quest, since, limit } = request;
+    const order = (completion) => completion.completedAt ?? -1;
+    return {
+      value: pinned.value.filter(
+        (completion) => (quest === null || completion.quest === quest) && (since === null || completion.completedAt !== null && completion.completedAt >= since)
+      ).sort((a, b) => order(b) - order(a)).slice(0, limit)
+    };
+  }
   function own(fake, account, link) {
     if (account !== null) {
       return ask(fake);
@@ -680,6 +845,12 @@ function factsAnswerer(facts) {
       case "member-identities":
       case "wallet-list":
         return pin(request);
+      case "member-balance":
+      case "member-completions":
+      case "member-groups":
+      case "member-enrolled":
+      case "member-referrals":
+        return memberState(request, fake);
       case "x": {
         const { operation } = request.input;
         if (operation === "connection") {
@@ -901,7 +1072,13 @@ function hostContext(run, answer) {
   const evidence = typeof input.evidence === "string" ? input.evidence : void 0;
   const calendar = evaluationCalendar({ segments: run.segments }, eligibleAt);
   const calls = [];
+  const diagnostics = [];
   const problems = [];
+  const delivered = /* @__PURE__ */ new WeakSet();
+  const delivering = (error) => {
+    delivered.add(error);
+    return error;
+  };
   let sequence = 0;
   async function deliver(request, sequence2) {
     for (const provider of capabilityIntegrations(request)) {
@@ -931,19 +1108,17 @@ function hostContext(run, answer) {
   const call = async (raw) => {
     const current = sequence++;
     if (current >= maxCapabilityCalls) {
-      const error = new TestSetupError(
-        `An evaluation run makes at most ${maxCapabilityCalls} capability calls; the quest made more`
-      );
-      problems.push(error);
-      throw error;
+      throw capabilityLimitError();
     }
     const parsed = parseCapabilityRequest(raw);
     if (!parsed.success) {
-      throw CapabilityError.from({
-        code: "author-error",
-        message: z3.prettifyError(parsed.error),
-        retryable: false
-      });
+      throw delivering(
+        CapabilityError.from({
+          code: "author-error",
+          message: z3.prettifyError(parsed.error),
+          retryable: false
+        })
+      );
     }
     let outcome;
     try {
@@ -952,12 +1127,12 @@ function hostContext(run, answer) {
       problems.push(error instanceof Error ? error : new Error(String(error)));
       throw error;
     }
-    if (parsed.data.kind !== "telegram") {
+    if (!unlistedRequest(parsed.data)) {
       calls.push({ sequence: current, request: parsed.data, outcome });
       calls.sort((a, b) => a.sequence - b.sequence);
     }
     if ("error" in outcome) {
-      throw CapabilityError.from(outcome.error);
+      throw delivering(CapabilityError.from(outcome.error));
     }
     return outcome.value;
   };
@@ -984,15 +1159,98 @@ function hostContext(run, answer) {
     calendar,
     now,
     ...performance ? { performance } : {},
-    ...readers
+    ...readers,
+    // Relay's hosted runtime passes no `diagnose`, so it records none of this.
+    diagnose: ({ code, message }) => {
+      diagnostics.push({ code, message });
+    }
+  };
+  return {
+    context,
+    calls,
+    diagnostics,
+    problems,
+    delivered,
+    release,
+    now,
+    seed: run.seed
   };
-  return { context, calls, problems, release, now, seed: run.seed };
+}
+var EvaluatorError = class extends Error {
+  code = "evaluator-error";
+  retryable = false;
+  constructor(thrown) {
+    super(thrownMessage(thrown), { cause: thrown });
+    this.name = "EvaluatorError";
+  }
+};
+function thrownMessage(error) {
+  let message = "";
+  try {
+    if (error !== null && typeof error === "object" && typeof error.message === "string") {
+      const { name, message: text } = error;
+      const label = typeof name === "string" && name.trim() ? name.trim() : "Error";
+      message = text.trim() ? label + ": " + text.trim() : label;
+    } else {
+      message = typeof error === "string" ? error : String(error);
+    }
+  } catch {
+  }
+  return message.trim().slice(0, 1e3) || "The evaluator threw without a message";
+}
+function capabilityLimitError() {
+  return new CapabilityError(
+    "capability-limit",
+    `An evaluation run makes at most ${maxCapabilityCalls} capability calls, shared by all capabilities`,
+    { retryable: false }
+  );
+}
+function uncaught(error, delivered) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const queue = [error];
+  const push = (value) => {
+    if (queue.length < 200) {
+      queue.push(value);
+    }
+  };
+  for (let next = 0; next < queue.length && next < 100; next++) {
+    const value = queue[next];
+    if (value === null || typeof value !== "object" && typeof value !== "function" || seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    if (delivered.has(value)) {
+      return error;
+    }
+    const read = (key) => {
+      try {
+        return value[key];
+      } catch {
+        return void 0;
+      }
+    };
+    for (const key of ["cause", "errors", "error", "suppressed"]) {
+      const field = read(key);
+      if (key === "errors") {
+        if (Array.isArray(field)) {
+          field.slice(0, 100).forEach(push);
+        }
+      } else if (field !== void 0) {
+        push(field);
+      }
+    }
+  }
+  return new EvaluatorError(error);
 }
 function failure2(message) {
   return { error: { code: "author-error", message, retryable: false } };
 }
 function createTestContext(quest, options = {}) {
-  const { problems: _, ...context } = hostContext(
+  const {
+    problems: _,
+    delivered: __,
+    ...context
+  } = hostContext(
     hostedRun(quest, options),
     factsAnswerer(options.facts ?? {})
   );
@@ -1013,9 +1271,9 @@ function evaluateHosted(quest, host) {
     try {
       restore = installDeterminism(host.now, host.seed);
       decision = await Promise.race([
-        quest.evaluate(
-          host.context
-        ),
+        (async () => quest.evaluate(host.context))().catch((error) => {
+          throw uncaught(error, host.delivered);
+        }),
         new Promise((_, reject) => {
           timer = setTimeout(
             () => reject(
@@ -1036,6 +1294,9 @@ function evaluateHosted(quest, host) {
     if (host.problems[0]) {
       throw host.problems[0];
     }
+    if (decision === void 0) {
+      throw new EvaluatorError(new Error("Evaluator returned no decision"));
+    }
     if (decision.kind === "accept" || decision.kind === "review") {
       const issue = rewardSelectionIssue(
         decision.rewards ?? [],
@@ -1045,7 +1306,12 @@ function evaluateHosted(quest, host) {
         throw new Error(issue);
       }
     }
-    return { decision, calls: host.calls, release: host.release };
+    return {
+      decision,
+      calls: host.calls,
+      release: host.release,
+      diagnostics: host.diagnostics
+    };
   });
 }
 async function runQuest(quest, options = {}) {
@@ -1222,10 +1488,27 @@ function captureAnswerer(facts, fallback, diverged) {
     if (fact?.outcome && !reason) {
       return fact.outcome;
     }
-    if (request.kind === "telegram") {
+    if (unlistedRequest(request)) {
       if (!answerFallback) {
+        const [reader, fact2] = {
+          telegram: ["ctx.telegram.member()", "facts.telegram"],
+          "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}, ctx.telegram.member(), is not in the capture (${reason ?? "new"}): pass facts.telegram to answer it`
+          `Capability call ${sequence}, ${reader}, is not in the capture (${reason ?? "new"}): pass ${fact2} to answer it`
         );
       }
       return answerFallback(request);
@@ -1297,6 +1580,7 @@ async function replayAttempt(quest, capture, options = {}) {
 export {
   CapabilityError,
   DecisionAssertionError,
+  EvaluatorError,
   TestSetupError,
   createTestContext,
   defaultMember,
@@ -1307,6 +1591,7 @@ export {
   expectProgress,
   expectReject,
   expectReview,
+  maxCapabilityCalls,
   replayAttempt,
   runQuest,
   trackerObservation,