@domino-sdk/relay 1.11.1 → 1.15.0

package/dist/testing.js

@@ -0,0 +1,1282 @@
+import {
+  attemptCaptureSchema
+} from "./chunk-NIYCAW2I.js";
+import {
+  CapabilityError
+} from "./chunk-MC6V6VMG.js";
+import {
+  parseImageResult
+} from "./chunk-W335CWYJ.js";
+import {
+  imageRequestSchema,
+  xConnectionSchema,
+  xPostSchema,
+  xProfileSchema,
+  xRequestSchema
+} from "./chunk-ZGH6NEG6.js";
+import {
+  cosmosNetworkSchema,
+  evmChainIdSchema,
+  linkedWalletSchema,
+  solanaMainnet,
+  walletBalanceSchema
+} from "./chunk-2UAVZCMH.js";
+import "./chunk-NPGENI7K.js";
+import {
+  contentPerformanceSnapshotSchema,
+  discordMemberInputSchema,
+  discordMemberSchema,
+  discordMessageInputSchema,
+  discordMessageSchema,
+  identifier,
+  memberIdentitySchema,
+  photoResultSchema,
+  quizEvidenceSchema,
+  rewardKey,
+  textEvidenceSchema,
+  textResultSchema,
+  textReviewInputSchema,
+  trackerContentQuerySchema,
+  trackerContentSchema,
+  trackerPageSchema,
+  trackerQuerySchema,
+  trackerSummarySchema,
+  trackerTriggerContextSchema,
+  triggerSchema,
+  urlEvidenceSchema,
+  validateSubmissionValue
+} from "./chunk-46C33ASD.js";
+
+// src/testing/run.ts
+import { z as z3 } from "zod";
+
+// src/testing/calendar.ts
+var dayMilliseconds = 24 * 60 * 60 * 1e3;
+function evaluationCalendar(snapshot, eligibleAt) {
+  const formatters = /* @__PURE__ */ new Map();
+  const dateAt = (at, timeZone) => {
+    let formatter = formatters.get(timeZone);
+    if (!formatter) {
+      formatter = new Intl.DateTimeFormat("en", {
+        calendar: "iso8601",
+        numberingSystem: "latn",
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit"
+      });
+      formatters.set(timeZone, formatter);
+    }
+    const parts = Object.fromEntries(
+      formatter.formatToParts(at).filter(
+        ({ type }) => type === "year" || type === "month" || type === "day"
+      ).map(({ type, value }) => [type, value])
+    );
+    return `${parts.year}-${parts.month}-${parts.day}`;
+  };
+  const firstInstantOfDate = (at, date, timeZone) => {
+    let low = Math.max(0, at - 2 * dayMilliseconds);
+    let high = at;
+    while (low < high) {
+      const middle = Math.floor((low + high) / 2);
+      if (dateAt(middle, timeZone) < date) {
+        low = middle + 1;
+      } else {
+        high = middle;
+      }
+    }
+    return low;
+  };
+  const firstInstantAfterDate = (at, date, timeZone) => {
+    let low = at;
+    let high = at + 2 * dayMilliseconds;
+    while (dateAt(high, timeZone) <= date) {
+      high += dayMilliseconds;
+    }
+    while (low < high) {
+      const middle = Math.floor((low + high) / 2);
+      if (dateAt(middle, timeZone) <= date) {
+        low = middle + 1;
+      } else {
+        high = middle;
+      }
+    }
+    return low;
+  };
+  return {
+    day(at = eligibleAt) {
+      if (!Number.isSafeInteger(at) || at < 0) {
+        throw new TypeError("Calendar time must be a non-negative integer");
+      }
+      let index = snapshot.segments.length - 1;
+      while (index >= 0 && snapshot.segments[index].effectiveAt > at) {
+        index--;
+      }
+      const segment = snapshot.segments[index];
+      const timeZone = segment?.timeZone ?? "UTC";
+      const date = dateAt(at, timeZone);
+      const next = snapshot.segments[index + 1];
+      return {
+        key: `${date}@${timeZone}`,
+        date,
+        timeZone,
+        start: Math.max(
+          firstInstantOfDate(at, date, timeZone),
+          segment?.effectiveAt ?? 0
+        ),
+        end: Math.min(
+          firstInstantAfterDate(at, date, timeZone),
+          next?.effectiveAt ?? Number.POSITIVE_INFINITY
+        )
+      };
+    }
+  };
+}
+
+// src/testing/capabilities.ts
+import { z } from "zod";
+var trackerInput = {
+  reference: identifier,
+  query: trackerQuerySchema,
+  asOf: z.number().int().nonnegative().safe()
+};
+var capabilityRequestSchemas = {
+  "wallet-balance": z.strictObject({
+    kind: z.literal("wallet-balance"),
+    chain: z.union([
+      z.literal(solanaMainnet),
+      evmChainIdSchema,
+      cosmosNetworkSchema
+    ]),
+    token: z.string().min(1).max(128).nullable(),
+    address: z.string().min(1).max(100).nullable()
+  }),
+  "tracker-content": z.strictObject({
+    kind: z.literal("tracker-content"),
+    reference: identifier,
+    query: trackerContentQuerySchema
+  }),
+  x: z.strictObject({ kind: z.literal("x"), input: xRequestSchema }),
+  image: z.strictObject({
+    kind: z.literal("image"),
+    input: imageRequestSchema
+  }),
+  text: textReviewInputSchema.extend({ kind: z.literal("text") }).strict(),
+  "tracker-records": z.strictObject({
+    kind: z.literal("tracker-records"),
+    ...trackerInput
+  }),
+  "tracker-summary": z.strictObject({
+    kind: z.literal("tracker-summary"),
+    ...trackerInput
+  }),
+  photo: z.strictObject({
+    kind: z.literal("photo"),
+    criteria: z.string().min(1).max(2e3),
+    image: z.string().optional()
+  }),
+  discord: z.strictObject({
+    kind: z.literal("discord"),
+    input: z.union([discordMemberInputSchema, discordMessageInputSchema])
+  }),
+  "wallet-list": z.strictObject({ kind: z.literal("wallet-list") }),
+  "member-identities": z.strictObject({
+    kind: z.literal("member-identities")
+  })
+};
+var capabilityRequestSchema = z.discriminatedUnion("kind", [
+  capabilityRequestSchemas["wallet-balance"],
+  capabilityRequestSchemas["tracker-content"],
+  capabilityRequestSchemas.x,
+  capabilityRequestSchemas.image,
+  capabilityRequestSchemas.text,
+  capabilityRequestSchemas["tracker-records"],
+  capabilityRequestSchemas["tracker-summary"],
+  capabilityRequestSchemas.photo,
+  capabilityRequestSchemas.discord,
+  capabilityRequestSchemas["wallet-list"],
+  capabilityRequestSchemas["member-identities"]
+]);
+function parseCapabilityRequest(raw) {
+  return capabilityRequestSchema.safeParse(raw);
+}
+function xResult(request, value) {
+  switch (request.input.operation) {
+    case "connection":
+      return xConnectionSchema.nullable().parse(value);
+    case "profile":
+      return xProfileSchema.nullable().parse(value);
+    case "post":
+      return xPostSchema.nullable().parse(value);
+    case "follows":
+    case "reposted":
+      return z.boolean().nullable().parse(value);
+  }
+}
+function parseCapabilityResult(request, value) {
+  switch (request.kind) {
+    case "wallet-balance":
+      return walletBalanceSchema.nullable().parse(value);
+    case "tracker-content":
+      return trackerContentSchema.nullable().parse(value);
+    case "x":
+      return xResult(request, value);
+    case "image":
+      return parseImageResult(request.input, value);
+    case "text":
+      return textResultSchema.strip().parse(value);
+    case "tracker-records":
+      return trackerPageSchema.parse(value);
+    case "tracker-summary":
+      return trackerSummarySchema.parse(value);
+    case "photo":
+      return photoResultSchema.strip().parse(value);
+    case "discord":
+      return ("channelId" in request.input ? discordMessageSchema : discordMemberSchema).nullable().parse(value);
+    case "wallet-list":
+      return z.array(linkedWalletSchema).min(1).nullable().parse(value);
+    case "member-identities":
+      return z.array(memberIdentitySchema).min(1).nullable().parse(value);
+  }
+}
+function imageReferences(input) {
+  return input.operation === "compare" || input.operation === "review" ? input.images : [input.image];
+}
+function capabilityIntegrations(request) {
+  switch (request.kind) {
+    case "x":
+      return ["x"];
+    case "discord":
+      return ["discord"];
+    case "image":
+      return imageReferences(request.input).some((image) => "x" in image) ? ["x"] : [];
+    default:
+      return [];
+  }
+}
+function capabilityEvidence(request) {
+  if (request.kind === "photo") {
+    return request.image === void 0 ? [] : [request.image];
+  }
+  if (request.kind !== "image") {
+    return [];
+  }
+  return imageReferences(request.input).flatMap(
+    (image) => "evidence" in image ? [image.evidence] : []
+  );
+}
+var readerFactories = {
+  member: (call, input) => ({
+    ...input.member,
+    identities: () => call({ kind: "member-identities" })
+  }),
+  discord: (call) => ({
+    member: () => call({ kind: "discord", input: {} }),
+    message: (input) => call({ kind: "discord", input })
+  }),
+  x: (call) => ({
+    connection: () => call({ kind: "x", input: { operation: "connection" } }),
+    profile: () => call({ kind: "x", input: { operation: "profile" } }),
+    post: (input) => call({ kind: "x", input: { ...input, operation: "post" } }),
+    follows: (input) => call({ kind: "x", input: { ...input, operation: "follows" } }),
+    reposted: (input) => call({ kind: "x", input: { ...input, operation: "reposted" } })
+  }),
+  trackers: (call, input) => {
+    const key = (reference) => typeof reference === "string" ? reference : reference.key;
+    return {
+      records: (reference, query = {}) => {
+        const { asOf = input.eligibleAt, ...rest } = query;
+        return call({
+          kind: "tracker-records",
+          reference: key(reference),
+          query: rest,
+          asOf
+        });
+      },
+      summary: (reference, query = {}) => {
+        const { asOf = input.eligibleAt, ...rest } = query;
+        return call({
+          kind: "tracker-summary",
+          reference: key(reference),
+          query: rest,
+          asOf
+        });
+      },
+      content: (reference, query) => call({ kind: "tracker-content", reference: key(reference), query })
+    };
+  },
+  images: (call) => ({
+    inspect: (image) => call({ kind: "image", input: { operation: "inspect", image } }),
+    compare: (a, b) => call({ kind: "image", input: { operation: "compare", images: [a, b] } }),
+    review: (options) => call({ kind: "image", input: { ...options, operation: "review" } }),
+    extract: (options) => call({
+      kind: "image",
+      input: { ...options, operation: "extract" }
+    }),
+    seen: (image, options = {}) => call({ kind: "image", input: { ...options, operation: "seen", image } })
+  }),
+  review: (call) => ({
+    text: (options) => call({ kind: "text", ...options }),
+    photo: (options) => call({ kind: "photo", ...options })
+  }),
+  wallet: (call) => ({
+    list: () => call({ kind: "wallet-list" }),
+    balance: (query) => call({
+      kind: "wallet-balance",
+      chain: query.chain === "solana" ? solanaMainnet : query.chain,
+      token: query.token ?? null,
+      address: query.address ?? null
+    })
+  })
+};
+
+// src/testing/determinism.ts
+function seededStream(text) {
+  let h1 = 1779033703;
+  let h2 = 3144134277;
+  let h3 = 1013904242;
+  let h4 = 2773480762;
+  for (let i = 0; i < text.length; i++) {
+    const k = text.charCodeAt(i);
+    h1 = h2 ^ Math.imul(h1 ^ k, 597399067);
+    h2 = h3 ^ Math.imul(h2 ^ k, 2869860233);
+    h3 = h4 ^ Math.imul(h3 ^ k, 951274213);
+    h4 = h1 ^ Math.imul(h4 ^ k, 2716044597);
+  }
+  h1 = Math.imul(h3 ^ h1 >>> 18, 597399067);
+  h2 = Math.imul(h4 ^ h2 >>> 22, 2869860233);
+  h3 = Math.imul(h1 ^ h3 >>> 17, 951274213);
+  h4 = Math.imul(h2 ^ h4 >>> 19, 2716044597);
+  h1 ^= h2 ^ h3 ^ h4;
+  h2 ^= h1;
+  h3 ^= h1;
+  h4 ^= h1;
+  let a = h1 | 0;
+  let b = h2 | 0;
+  let c = h3 | 0;
+  let d = h4 | 0;
+  return () => {
+    const t = (a + b | 0) + d | 0;
+    d = d + 1 | 0;
+    a = b ^ b >>> 9;
+    b = c + (c << 3) | 0;
+    c = c << 21 | c >>> 11;
+    c = c + t | 0;
+    return t >>> 0;
+  };
+}
+function replace(target, key, value) {
+  const original = Object.getOwnPropertyDescriptor(target, key);
+  Object.defineProperty(target, key, {
+    value,
+    writable: true,
+    configurable: true
+  });
+  return () => {
+    if (original) {
+      Object.defineProperty(target, key, original);
+    } else {
+      Reflect.deleteProperty(target, key);
+    }
+  };
+}
+var integerArrays = [
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  BigInt64Array,
+  BigUint64Array
+];
+function installDeterminism(now, seed) {
+  const restores = [];
+  const restore = () => {
+    for (const undo of restores.reverse()) {
+      undo();
+    }
+  };
+  try {
+    install(now, seed, restores);
+  } catch (error) {
+    restore();
+    throw error;
+  }
+  return restore;
+}
+function install(now, seed, restores) {
+  const RealDate = Date;
+  function FrozenDate(...args) {
+    return new.target ? Reflect.construct(
+      RealDate,
+      args.length === 0 ? [now] : args,
+      new.target
+    ) : new RealDate(now).toString();
+  }
+  Object.defineProperty(FrozenDate, "prototype", { value: RealDate.prototype });
+  Object.defineProperty(FrozenDate, "length", { value: 7 });
+  replace(FrozenDate, "now", () => now);
+  replace(FrozenDate, "parse", RealDate.parse);
+  replace(FrozenDate, "UTC", RealDate.UTC);
+  restores.push(replace(RealDate.prototype, "constructor", FrozenDate));
+  restores.push(replace(globalThis, "Date", FrozenDate));
+  if (globalThis.performance) {
+    restores.push(replace(globalThis.performance, "now", () => 0));
+  }
+  const temporal = globalThis.Temporal;
+  if (temporal?.Now) {
+    const instant = () => temporal.Instant.fromEpochMilliseconds(now);
+    const zoned = (zone = "UTC") => instant().toZonedDateTimeISO(zone);
+    restores.push(
+      replace(
+        temporal,
+        "Now",
+        Object.freeze({
+          instant,
+          timeZoneId: () => "UTC",
+          zonedDateTimeISO: zoned,
+          plainDateTimeISO: (zone) => zoned(zone).toPlainDateTime(),
+          plainDateISO: (zone) => zoned(zone).toPlainDate(),
+          plainTimeISO: (zone) => zoned(zone).toPlainTime()
+        })
+      )
+    );
+  }
+  const math = seededStream("math:" + seed);
+  restores.push(
+    replace(
+      Math,
+      "random",
+      () => ((math() >>> 5) * 67108864 + (math() >>> 6)) / 9007199254740992
+    )
+  );
+  const bytes = seededStream("crypto:" + seed);
+  const fill = (view) => {
+    for (let i = 0; i < view.length; i += 4) {
+      const word = bytes();
+      for (let j = 0; j < 4 && i + j < view.length; j++) {
+        view[i + j] = word >>> j * 8 & 255;
+      }
+    }
+    return view;
+  };
+  const crypto = globalThis.crypto;
+  if (crypto) {
+    restores.push(
+      replace(crypto, "getRandomValues", (array) => {
+        if (!integerArrays.some((type) => array instanceof type)) {
+          throw new DOMException(
+            "getRandomValues takes an integer typed array",
+            "TypeMismatchError"
+          );
+        }
+        if (array.byteLength > 65536) {
+          throw new DOMException(
+            "getRandomValues takes at most 65536 bytes",
+            "QuotaExceededError"
+          );
+        }
+        fill(new Uint8Array(array.buffer, array.byteOffset, array.byteLength));
+        return array;
+      })
+    );
+    restores.push(
+      replace(crypto, "randomUUID", () => {
+        const b = fill(new Uint8Array(16));
+        b[6] = b[6] & 15 | 64;
+        b[8] = b[8] & 63 | 128;
+        const hex = Array.from(
+          b,
+          (value) => value.toString(16).padStart(2, "0")
+        ).join("");
+        return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+      })
+    );
+  }
+}
+
+// src/testing/facts.ts
+import { z as z2 } from "zod";
+var TestSetupError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TestSetupError";
+  }
+};
+function fakeFor(facts, request) {
+  switch (request.kind) {
+    case "member-identities":
+      return {
+        name: "member.identities",
+        answer: facts.member?.identities,
+        args: []
+      };
+    case "wallet-list":
+      return {
+        name: "wallet.list",
+        answer: facts.wallet?.list,
+        args: []
+      };
+    case "wallet-balance": {
+      const { chain, token, address } = request;
+      return {
+        name: "wallet.balance",
+        answer: facts.wallet?.balance,
+        args: [{ chain, token, address }]
+      };
+    }
+    case "x": {
+      const { operation, ...input } = request.input;
+      return {
+        name: `x.${operation}`,
+        answer: facts.x?.[operation],
+        args: operation === "connection" || operation === "profile" ? [] : [input]
+      };
+    }
+    case "discord": {
+      const message = "channelId" in request.input;
+      return {
+        name: message ? "discord.message" : "discord.member",
+        answer: message ? facts.discord?.message : facts.discord?.member,
+        args: message ? [request.input] : []
+      };
+    }
+    case "tracker-records":
+    case "tracker-summary": {
+      const method = request.kind === "tracker-records" ? "records" : "summary";
+      return {
+        name: `trackers["${request.reference}"].${method}`,
+        answer: facts.trackers?.[request.reference]?.[method],
+        args: [{ ...request.query, asOf: request.asOf }]
+      };
+    }
+    case "tracker-content":
+      return {
+        name: `trackers["${request.reference}"].content`,
+        answer: facts.trackers?.[request.reference]?.content,
+        args: [request.query]
+      };
+    case "image": {
+      const { input } = request;
+      const args = input.operation === "inspect" ? [input.image] : input.operation === "compare" ? [...input.images] : input.operation === "seen" ? [
+        input.image,
+        input.maxDistance === void 0 ? {} : { maxDistance: input.maxDistance }
+      ] : [
+        Object.fromEntries(
+          Object.entries(input).filter(([key]) => key !== "operation")
+        )
+      ];
+      return {
+        name: `images.${input.operation}`,
+        answer: facts.images?.[input.operation],
+        args
+      };
+    }
+    case "text": {
+      const { kind: _, ...options } = request;
+      return {
+        name: "review.text",
+        answer: facts.review?.text,
+        args: [options]
+      };
+    }
+    case "photo": {
+      const { kind: _, ...options } = request;
+      return {
+        name: "review.photo",
+        answer: facts.review?.photo,
+        args: [options]
+      };
+    }
+  }
+}
+var failure = (code, message) => ({
+  error: { code, message, retryable: false }
+});
+function covers(wallet, chain) {
+  if (chain.startsWith("solana:")) {
+    return wallet.chain === "solana";
+  }
+  if (chain.startsWith("eip155:")) {
+    return wallet.chain === "eip155";
+  }
+  return wallet.chain === "cosmos" && wallet.network === chain;
+}
+var sameAddress = (a, b, chain) => chain.startsWith("eip155:") ? a.toLowerCase() === b.toLowerCase() : a === b;
+function factsAnswerer(facts) {
+  const pins = /* @__PURE__ */ new Map();
+  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}`
+      );
+    }
+    try {
+      return {
+        value: typeof fake.answer === "function" ? await fake.answer(
+          ...fake.args
+        ) : fake.answer
+      };
+    } catch (error) {
+      if (error instanceof CapabilityError) {
+        return {
+          error: {
+            code: error.code,
+            message: error.message,
+            retryable: error.retryable
+          }
+        };
+      }
+      throw error;
+    }
+  }
+  function pin(request) {
+    const key = JSON.stringify(request);
+    let outcome = pins.get(key);
+    if (!outcome) {
+      const fake = fakeFor(facts, request);
+      outcome = fake.answer === void 0 ? Promise.resolve({ value: null }) : ask(fake).then(
+        (answered) => "error" in answered ? answered : {
+          value: checked(request, answered.value, fake.name)
+        }
+      );
+      pins.set(key, outcome);
+    }
+    return outcome;
+  }
+  function own(fake, account, link) {
+    if (account !== null) {
+      return ask(fake);
+    }
+    if (fake.answer !== void 0) {
+      throw new TestSetupError(
+        `facts.${fake.name} answers a read of the member's own account, which the test did not link: set facts.${link}`
+      );
+    }
+    return Promise.resolve({ value: null });
+  }
+  return async (request) => {
+    const fake = fakeFor(facts, request);
+    switch (request.kind) {
+      case "member-identities":
+      case "wallet-list":
+        return pin(request);
+      case "x": {
+        const { operation } = request.input;
+        if (operation === "connection") {
+          return pin(request);
+        }
+        if (operation === "post") {
+          return ask(fake);
+        }
+        const x = await pin(xConnection);
+        return "error" in x ? x : own(fake, x.value, "x.connection");
+      }
+      case "wallet-balance": {
+        const pinned = await pin(walletList);
+        if ("error" in pinned) {
+          return pinned;
+        }
+        const wallets = (pinned.value ?? []).filter(
+          (wallet) => covers(wallet, request.chain)
+        );
+        const { address } = request;
+        if (address !== null && !wallets.some(
+          (wallet) => sameAddress(wallet.address, address, request.chain)
+        )) {
+          return failure(
+            "author-error",
+            "Read only the member's linked wallets"
+          );
+        }
+        if (pinned.value === null) {
+          return own(fake, null, "wallet.list");
+        }
+        return wallets.length ? ask(fake) : { value: null };
+      }
+      case "discord":
+        return "channelId" in request.input || fake.answer !== void 0 ? ask(fake) : { value: null };
+      case "image": {
+        if (imageReferences(request.input).some(
+          (image) => "x" in image && image.x === "profile"
+        )) {
+          const x = await pin(xConnection);
+          if ("error" in x) {
+            return x;
+          }
+          if (x.value === null) {
+            return failure(
+              "not-linked",
+              "Link an X account to check its profile picture."
+            );
+          }
+        }
+        return ask(fake);
+      }
+      default:
+        return ask(fake);
+    }
+  };
+}
+var xConnection = {
+  kind: "x",
+  input: { operation: "connection" }
+};
+var walletList = { kind: "wallet-list" };
+function checked(request, value, name) {
+  try {
+    return parseCapabilityResult(request, value);
+  } catch (error) {
+    throw new TestSetupError(
+      `facts.${name} is not a result Relay delivers: ${error instanceof z2.ZodError ? z2.prettifyError(error) : String(error)}`
+    );
+  }
+}
+
+// src/testing/rewards.ts
+function kindOf(reward) {
+  if (reward.kind === "integration") {
+    return `integration:${reward.provider}:${reward.action}`;
+  }
+  return reward.kind;
+}
+function within(selected, published) {
+  if (selected.kind === "points" && published.kind === "points") {
+    return selected.amount > published.amount ? "Evaluator exceeded published reward bounds" : null;
+  }
+  if (selected.kind === "tier" && published.kind === "tier") {
+    const rank = (reward) => reward.reward.tiers.findIndex((tier) => tier.id === reward.tier);
+    return JSON.stringify(selected.reward) !== JSON.stringify(published.reward) || rank(selected) > rank(published) ? "Evaluator exceeded published reward tier" : null;
+  }
+  return null;
+}
+function rewardSelectionIssue(selected, published) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const reward of selected) {
+    const key = rewardKey(reward);
+    if (seen.has(key)) {
+      return "Duplicate reward selection";
+    }
+    seen.add(key);
+    const match = published.find((candidate) => rewardKey(candidate) === key);
+    if (!match || kindOf(match) !== kindOf(reward)) {
+      return "Evaluator selected an unapproved reward";
+    }
+    const refusal = within(reward, match);
+    if (refusal) {
+      return refusal;
+    }
+  }
+  return null;
+}
+
+// src/testing/run.ts
+var defaultNow = Date.UTC(2026, 0, 1);
+var defaultMember = "member_test";
+var defaultSeed = "attempt_test";
+var maxCapabilityCalls = 8;
+var evaluationTimeoutMs = 15e3;
+var time = (value) => value instanceof Date ? value.getTime() : value;
+function submission(trigger, raw) {
+  if (trigger.kind !== "manual" || trigger.input === "none") {
+    if (raw !== void 0 && Object.keys(raw).length) {
+      throw new TestSetupError(
+        "This quest takes no evidence: Relay admits its attempts without input"
+      );
+    }
+    return {};
+  }
+  if (trigger.input === "photo") {
+    const photo = z3.object({ photo: z3.string().min(1) }).safeParse(raw);
+    if (!photo.success) {
+      throw new TestSetupError(
+        "This quest takes a photo: pass input: { photo: <evidence ID> }"
+      );
+    }
+    return { ...raw, evidence: photo.data.photo };
+  }
+  const refused = (issue2) => new TestSetupError(
+    `Relay refuses this ${trigger.input} submission: ${issue2}`
+  );
+  if (trigger.input === "quiz") {
+    const parsed2 = quizEvidenceSchema.safeParse({ kind: "quiz", ...raw });
+    if (!parsed2.success) {
+      throw refused(z3.prettifyError(parsed2.error));
+    }
+    return parsed2.data;
+  }
+  const parsed = (trigger.input === "text" ? textEvidenceSchema : urlEvidenceSchema).safeParse({ kind: trigger.input, ...raw });
+  if (!parsed.success) {
+    throw refused(z3.prettifyError(parsed.error));
+  }
+  const issue = validateSubmissionValue(
+    parsed.data,
+    trigger
+  );
+  if (issue) {
+    throw refused(issue);
+  }
+  return parsed.data;
+}
+function hostedRun(quest, options) {
+  const release = quest.describe(options.settings ?? {});
+  const trigger = triggerSchema.parse(release.trigger);
+  const tracked = trigger.kind === "automatic" && trigger.tracker !== void 0;
+  const now = time(options.now ?? defaultNow);
+  if (!Number.isSafeInteger(now) || now < 0) {
+    throw new TestSetupError("now must be a time at or after 1970-01-01");
+  }
+  if (tracked && options.tracker === void 0) {
+    throw new TestSetupError(
+      `Quest "${quest.key}" runs on tracker observations: pass tracker: trackerObservation(tracker, { data })`
+    );
+  }
+  if (!tracked && options.tracker !== void 0) {
+    throw new TestSetupError(
+      `Quest "${quest.key}" has no tracker trigger, so it reads no tracker observation`
+    );
+  }
+  const tracker = options.tracker === void 0 ? null : trackerTriggerContextSchema.parse(options.tracker);
+  const member = options.member ?? tracker?.attribution.member ?? defaultMember;
+  if (tracker && options.eligibleAt !== void 0) {
+    throw new TestSetupError(
+      "A tracker-triggered attempt is eligible when its record occurred: set occurredAt on the observation instead of eligibleAt"
+    );
+  }
+  const eligibleAt = time(
+    tracker?.record.occurredAt ?? options.eligibleAt ?? now
+  );
+  const input = submission(
+    trigger,
+    options.input
+  );
+  const performance = options.performance ? contentPerformanceSnapshotSchema.parse({
+    contentAttempt: "attempt_content",
+    observation: "observation_test",
+    observedAt: options.performance.observedAt ?? now,
+    metrics: options.performance.metrics,
+    rewards: options.performance.rewards ?? release.rewards
+  }) : void 0;
+  return {
+    release: {
+      values: release.values,
+      rewards: release.rewards,
+      humanReview: release.humanReview,
+      integrations: release.integrations
+    },
+    member,
+    input,
+    tracker,
+    eligibleAt,
+    segments: options.calendar ?? (options.timeZone ? [{ effectiveAt: 0, timeZone: options.timeZone }] : []),
+    ...performance ? { performance } : {},
+    now,
+    seed: options.seed ?? defaultSeed
+  };
+}
+function hostContext(run, answer) {
+  const { release, member, input, tracker, eligibleAt, performance, now } = run;
+  const evidence = typeof input.evidence === "string" ? input.evidence : void 0;
+  const calendar = evaluationCalendar({ segments: run.segments }, eligibleAt);
+  const calls = [];
+  const problems = [];
+  let sequence = 0;
+  async function deliver(request, sequence2) {
+    for (const provider of capabilityIntegrations(request)) {
+      if (!release.integrations.includes(provider)) {
+        return failure2(`Declare the ${provider} integration on this quest`);
+      }
+    }
+    const evidenceReads = capabilityEvidence(request);
+    if (request.kind === "photo" && !evidence || evidenceReads.some((read) => read !== evidence)) {
+      return failure2(
+        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);
+    if ("error" in outcome) {
+      return outcome;
+    }
+    try {
+      const value = z3.json().parse(parseCapabilityResult(request, outcome.value));
+      return { value: JSON.parse(JSON.stringify(value)) };
+    } catch (error) {
+      throw new TestSetupError(
+        `The answer to ${request.kind} call ${sequence2} is not a result Relay delivers: ${error instanceof z3.ZodError ? z3.prettifyError(error) : String(error)}`
+      );
+    }
+  }
+  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;
+    }
+    const parsed = parseCapabilityRequest(raw);
+    if (!parsed.success) {
+      throw CapabilityError.from({
+        code: "author-error",
+        message: z3.prettifyError(parsed.error),
+        retryable: false
+      });
+    }
+    let outcome;
+    try {
+      outcome = await deliver(parsed.data, current);
+    } catch (error) {
+      problems.push(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    }
+    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);
+    }
+    return outcome.value;
+  };
+  const readerInput = { eligibleAt, member: { id: member } };
+  const readers = {
+    member: readerFactories.member(call, readerInput),
+    trackers: readerFactories.trackers(call, readerInput),
+    images: readerFactories.images(call),
+    review: readerFactories.review(call),
+    wallet: readerFactories.wallet(call),
+    // Relay gives quest code the X and Discord readers only for declared integrations.
+    ...release.integrations.includes("x") ? { x: readerFactories.x(call) } : {},
+    ...release.integrations.includes("discord") ? { discord: readerFactories.discord(call) } : {}
+  };
+  const context = {
+    settings: release.values,
+    rewards: release.rewards,
+    humanReview: release.humanReview,
+    input,
+    tracker,
+    eligibleAt,
+    calendar,
+    now,
+    ...performance ? { performance } : {},
+    ...readers
+  };
+  return { context, calls, problems, release, now, seed: run.seed };
+}
+function failure2(message) {
+  return { error: { code: "author-error", message, retryable: false } };
+}
+function createTestContext(quest, options = {}) {
+  const { problems: _, ...context } = hostContext(
+    hostedRun(quest, options),
+    factsAnswerer(options.facts ?? {})
+  );
+  return context;
+}
+var running = Promise.resolve();
+function exclusive(run) {
+  const result = running.then(run, run);
+  running = result.catch(() => void 0);
+  return result;
+}
+function evaluateHosted(quest, host) {
+  return exclusive(async () => {
+    let restore = () => {
+    };
+    let timer;
+    let decision;
+    try {
+      restore = installDeterminism(host.now, host.seed);
+      decision = await Promise.race([
+        quest.evaluate(
+          host.context
+        ),
+        new Promise((_, reject) => {
+          timer = setTimeout(
+            () => reject(
+              new Error(
+                `The evaluation did not finish within ${evaluationTimeoutMs / 1e3} seconds, Relay's limit`
+              )
+            ),
+            evaluationTimeoutMs
+          );
+        })
+      ]);
+    } catch (error) {
+      throw host.problems[0] ?? error;
+    } finally {
+      clearTimeout(timer);
+      restore();
+    }
+    if (host.problems[0]) {
+      throw host.problems[0];
+    }
+    if (decision.kind === "accept" || decision.kind === "review") {
+      const issue = rewardSelectionIssue(
+        decision.rewards ?? [],
+        host.release.rewards
+      );
+      if (issue) {
+        throw new Error(issue);
+      }
+    }
+    return { decision, calls: host.calls, release: host.release };
+  });
+}
+async function runQuest(quest, options = {}) {
+  return evaluateHosted(
+    quest,
+    hostContext(
+      hostedRun(quest, options),
+      factsAnswerer(options.facts ?? {})
+    )
+  );
+}
+
+// src/testing/assertions.ts
+var DecisionAssertionError = class extends Error {
+  decision;
+  constructor(message, decision) {
+    super(message);
+    this.name = "DecisionAssertionError";
+    this.decision = decision;
+  }
+};
+var verbs = {
+  accept: "accepted",
+  reject: "rejected",
+  review: "sent it to review",
+  defer: "deferred",
+  progress: "recorded progress"
+};
+function expectKind(run, kind, reason) {
+  const decision = "decision" in run ? run.decision : run;
+  const detail = "reason" in decision && decision.reason ? `: "${decision.reason}"` : "";
+  if (decision.kind !== kind) {
+    throw new DecisionAssertionError(
+      `Expected the quest to ${kind}, but it ${verbs[decision.kind]}${detail}`,
+      decision
+    );
+  }
+  if (reason !== void 0) {
+    const actual = "reason" in decision ? decision.reason : "";
+    const matches = typeof reason === "string" ? actual === reason : reason.test(actual);
+    if (!matches) {
+      throw new DecisionAssertionError(
+        `Expected the ${kind} reason to ${typeof reason === "string" ? "be" : "match"} ${String(
+          typeof reason === "string" ? `"${reason}"` : reason
+        )}, but it was "${actual}"`,
+        decision
+      );
+    }
+  }
+  return decision;
+}
+function expectAccept(run) {
+  return expectKind(run, "accept");
+}
+function expectReject(run, reason) {
+  return expectKind(run, "reject", reason);
+}
+function expectReview(run, reason) {
+  return expectKind(run, "review", reason);
+}
+function expectDefer(run, reason) {
+  return expectKind(run, "defer", reason);
+}
+function expectProgress(run, reason) {
+  return expectKind(run, "progress", reason);
+}
+
+// src/testing/trackers.ts
+function record(input, source) {
+  const occurredAt = time(input.occurredAt ?? defaultNow);
+  const observedAt = time(input.observedAt ?? occurredAt);
+  return {
+    id: input.id,
+    source,
+    occurredAt,
+    observedAt,
+    firstSeenAt: observedAt,
+    author: input.author === void 0 ? { id: "author_test", verified: null } : input.author,
+    data: input.data,
+    removed: input.removed ?? false
+  };
+}
+function trackerObservation(tracker, observation) {
+  const member = observation.member ?? defaultMember;
+  const pinned = record(
+    { ...observation, id: observation.id ?? "record_test" },
+    tracker.source.kind
+  );
+  return trackerTriggerContextSchema.parse({
+    tracker: tracker.key,
+    key: tracker.key,
+    beneficiary: observation.beneficiary ?? "author",
+    record: pinned,
+    ...observation.body === void 0 ? {} : {
+      content: {
+        revision: "revision_test",
+        observation: "observation_test",
+        body: observation.body
+      }
+    },
+    attribution: {
+      member,
+      capturedAt: pinned.observedAt,
+      account: observation.account ?? { provider: "member", id: member }
+    },
+    ...observation.enrolledAt === void 0 ? {} : { enrolledAt: time(observation.enrolledAt) }
+  });
+}
+function trackerPage(tracker, records, options = {}) {
+  const { key, title, source, window, refreshSeconds, maxPages } = tracker;
+  return trackerPageSchema.parse({
+    tracker: key,
+    items: records.map(
+      (item, index) => record({ ...item, id: item.id ?? `record_${index + 1}` }, source.kind)
+    ),
+    nextCursor: options.nextCursor ?? null,
+    total: options.total ?? records.length,
+    status: {
+      published: {
+        id: key,
+        version: "version_test",
+        definition: { key, title, source, window, refreshSeconds, maxPages },
+        publishedAt: 0,
+        actor: null
+      },
+      paused: false,
+      state: "idle",
+      lastStartedAt: null,
+      lastCompletedAt: null,
+      nextSyncAt: null,
+      coverage: "complete",
+      error: null,
+      records: options.total ?? records.length
+    }
+  });
+}
+
+// src/testing/replay.ts
+import { z as z4 } from "zod";
+var ReplayStopped = class extends Error {
+  constructor(divergence) {
+    super(
+      `Capability call ${divergence.sequence} is not in the capture (${divergence.reason}): pass facts to answer it`
+    );
+    this.divergence = divergence;
+    this.name = "ReplayStopped";
+  }
+  divergence;
+};
+function sameJson(a, b) {
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, index) => sameJson(item, b[index]));
+  }
+  if (a && b && typeof a === "object" && typeof b === "object") {
+    const keys = Object.keys(a).filter(
+      (key) => a[key] !== void 0
+    );
+    return keys.length === Object.keys(b).filter(
+      (key) => b[key] !== void 0
+    ).length && keys.every(
+      (key) => sameJson(
+        a[key],
+        b[key]
+      )
+    );
+  }
+  return a === b;
+}
+function captureAnswerer(facts, fallback, diverged) {
+  const answerFallback = fallback ? factsAnswerer(fallback) : null;
+  return async (request, sequence) => {
+    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;
+    }
+    const divergence = {
+      sequence,
+      reason: reason ?? "new",
+      recorded: fact?.request ?? null,
+      replayed: request
+    };
+    diverged(divergence);
+    if (!answerFallback) {
+      throw new ReplayStopped(divergence);
+    }
+    return answerFallback(request);
+  };
+}
+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)}`
+    );
+  }
+  const { quest: captured, context, facts, recorded } = parsed.data;
+  if (captured.key !== null && captured.key !== quest.key) {
+    throw new TestSetupError(
+      `This capture is of quest "${captured.key}", not "${quest.key}"`
+    );
+  }
+  let divergence = null;
+  const host = hostContext(
+    {
+      release: {
+        values: context.settings,
+        rewards: context.rewards,
+        humanReview: context.humanReview,
+        integrations: context.integrations
+      },
+      member: context.member,
+      input: context.input,
+      tracker: context.tracker,
+      eligibleAt: context.eligibleAt,
+      segments: context.calendar.segments,
+      ...context.performance ? { performance: context.performance } : {},
+      now: parsed.data.now,
+      seed: parsed.data.seed
+    },
+    captureAnswerer(facts, options.facts, (found) => {
+      divergence ??= found;
+    })
+  );
+  let decision = null;
+  try {
+    decision = (await evaluateHosted(quest, host)).decision;
+  } catch (error) {
+    if (!(error instanceof ReplayStopped)) {
+      throw error;
+    }
+  }
+  return {
+    decision,
+    recorded,
+    changed: decision && recorded ? !sameJson(decision, recorded) : null,
+    divergence,
+    calls: host.calls
+  };
+}
+export {
+  CapabilityError,
+  DecisionAssertionError,
+  TestSetupError,
+  createTestContext,
+  defaultMember,
+  defaultNow,
+  defaultSeed,
+  expectAccept,
+  expectDefer,
+  expectProgress,
+  expectReject,
+  expectReview,
+  replayAttempt,
+  runQuest,
+  trackerObservation,
+  trackerPage
+};