@domino-sdk/relay 1.11.1 → 1.14.0

package/dist/testing.d.ts

@@ -0,0 +1,641 @@
+import { bv as memberIdentitySchema, cC as trackerQuerySchema, cy as trackerPageSchema, cL as trackerSummarySchema, aD as TrackerContentQuery, ck as trackerContentSchema, bA as photoResultSchema, C as TextReviewInput, R as Reward, F as Decision, az as TrackerAttribution, o as Tracker, p as TrackerData, V as ContentBody, z as TrackerTriggerContext, a1 as TrackerPage } from './schema-K-Pg5lPz.js';
+import { z } from 'zod';
+import { l as discordMemberSchema, o as discordMessageSchema } from './accounts-5ciAkCMP.js';
+import { b as CapabilityFailure, x as xConnectionSchema, j as xProfileSchema, i as xPostSchema } from './capability-error-oTd3eYFH.js';
+export { C as CapabilityError } from './capability-error-oTd3eYFH.js';
+import { f as ImageReference, n as imageInspectionSchema, j as imageComparisonSchema, q as imageSightingsSchema } from './images-D5kpqHxv.js';
+import { u as linkedWalletSchema, z as walletBalanceSchema } from './wallet-CDyo-U4n.js';
+export { A as AttemptCapture, C as CapturedFact } from './attempt-captures-DZldPZJc.js';
+
+/** One project time-zone change: from `effectiveAt` on, days are counted in `timeZone`. */
+type CalendarSegment = {
+    effectiveAt: number;
+    timeZone: string;
+};
+
+/** Every capability wire request, validated as the API Worker validates it before answering. */
+declare const capabilityRequestSchemas: {
+    "wallet-balance": z.ZodObject<{
+        kind: z.ZodLiteral<"wallet-balance">;
+        chain: z.ZodUnion<readonly [z.ZodLiteral<"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp">, z.ZodCustom<`eip155:${number}`, `eip155:${number}`>, z.ZodCustom<`cosmos:${string}`, `cosmos:${string}`>]>;
+        token: z.ZodNullable<z.ZodString>;
+        address: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    "tracker-content": z.ZodObject<{
+        kind: z.ZodLiteral<"tracker-content">;
+        reference: z.ZodString;
+        query: z.ZodObject<{
+            id: z.ZodString;
+            observation: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    x: z.ZodObject<{
+        kind: z.ZodLiteral<"x">;
+        input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            operation: z.ZodLiteral<"connection">;
+        }, z.core.$strict>, z.ZodObject<{
+            operation: z.ZodLiteral<"profile">;
+        }, z.core.$strict>, z.ZodObject<{
+            operation: z.ZodLiteral<"post">;
+            postId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            operation: z.ZodLiteral<"follows">;
+            userId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            operation: z.ZodLiteral<"reposted">;
+            postId: z.ZodString;
+        }, z.core.$strict>], "operation">;
+    }, z.core.$strict>;
+    image: z.ZodObject<{
+        kind: z.ZodLiteral<"image">;
+        input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            operation: z.ZodLiteral<"inspect">;
+            image: z.ZodUnion<readonly [z.ZodObject<{
+                evidence: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                x: z.ZodLiteral<"profile">;
+            }, z.core.$strict>, z.ZodObject<{
+                x: z.ZodLiteral<"post">;
+                postId: z.ZodString;
+                index: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodObject<{
+                asset: z.ZodString;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>, z.ZodObject<{
+            operation: z.ZodLiteral<"compare">;
+            images: z.ZodTuple<[z.ZodUnion<readonly [z.ZodObject<{
+                evidence: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                x: z.ZodLiteral<"profile">;
+            }, z.core.$strict>, z.ZodObject<{
+                x: z.ZodLiteral<"post">;
+                postId: z.ZodString;
+                index: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodObject<{
+                asset: z.ZodString;
+            }, z.core.$strict>]>, z.ZodUnion<readonly [z.ZodObject<{
+                evidence: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                x: z.ZodLiteral<"profile">;
+            }, z.core.$strict>, z.ZodObject<{
+                x: z.ZodLiteral<"post">;
+                postId: z.ZodString;
+                index: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodObject<{
+                asset: z.ZodString;
+            }, z.core.$strict>]>], null>;
+        }, z.core.$strict>, z.ZodObject<{
+            operation: z.ZodLiteral<"review">;
+            images: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                evidence: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                x: z.ZodLiteral<"profile">;
+            }, z.core.$strict>, z.ZodObject<{
+                x: z.ZodLiteral<"post">;
+                postId: z.ZodString;
+                index: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodObject<{
+                asset: z.ZodString;
+            }, z.core.$strict>]>>;
+            criteria: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            operation: z.ZodLiteral<"extract">;
+            image: z.ZodUnion<readonly [z.ZodObject<{
+                evidence: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                x: z.ZodLiteral<"profile">;
+            }, z.core.$strict>, z.ZodObject<{
+                x: z.ZodLiteral<"post">;
+                postId: z.ZodString;
+                index: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodObject<{
+                asset: z.ZodString;
+            }, z.core.$strict>]>;
+            fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                }>;
+                description: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            operation: z.ZodLiteral<"seen">;
+            image: z.ZodUnion<readonly [z.ZodObject<{
+                evidence: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                x: z.ZodLiteral<"profile">;
+            }, z.core.$strict>, z.ZodObject<{
+                x: z.ZodLiteral<"post">;
+                postId: z.ZodString;
+                index: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodObject<{
+                asset: z.ZodString;
+            }, z.core.$strict>]>;
+            maxDistance: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>], "operation">;
+    }, z.core.$strict>;
+    text: z.ZodObject<{
+        text: z.ZodString;
+        criteria: z.ZodString;
+        kind: z.ZodLiteral<"text">;
+    }, z.core.$strict>;
+    "tracker-records": z.ZodObject<{
+        reference: z.ZodString;
+        query: z.ZodObject<{
+            author: z.ZodOptional<z.ZodString>;
+            member: z.ZodOptional<z.ZodString>;
+            verified: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+                true: "true";
+                false: "false";
+            }>, z.ZodTransform<boolean, "true" | "false">>]>>;
+            since: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            until: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            removed: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+                true: "true";
+                false: "false";
+            }>, z.ZodTransform<boolean, "true" | "false">>]>>;
+            minLikes: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            minViews: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+            cursor: z.ZodOptional<z.ZodString>;
+            includeEvidence: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+                true: "true";
+                false: "false";
+            }>, z.ZodTransform<boolean, "true" | "false">>]>>;
+        }, z.core.$strict>;
+        asOf: z.ZodNumber;
+        kind: z.ZodLiteral<"tracker-records">;
+    }, z.core.$strict>;
+    "tracker-summary": z.ZodObject<{
+        reference: z.ZodString;
+        query: z.ZodObject<{
+            author: z.ZodOptional<z.ZodString>;
+            member: z.ZodOptional<z.ZodString>;
+            verified: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+                true: "true";
+                false: "false";
+            }>, z.ZodTransform<boolean, "true" | "false">>]>>;
+            since: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            until: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            removed: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+                true: "true";
+                false: "false";
+            }>, z.ZodTransform<boolean, "true" | "false">>]>>;
+            minLikes: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            minViews: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+            cursor: z.ZodOptional<z.ZodString>;
+            includeEvidence: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodEnum<{
+                true: "true";
+                false: "false";
+            }>, z.ZodTransform<boolean, "true" | "false">>]>>;
+        }, z.core.$strict>;
+        asOf: z.ZodNumber;
+        kind: z.ZodLiteral<"tracker-summary">;
+    }, z.core.$strict>;
+    photo: z.ZodObject<{
+        kind: z.ZodLiteral<"photo">;
+        criteria: z.ZodString;
+        image: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    discord: z.ZodObject<{
+        kind: z.ZodLiteral<"discord">;
+        input: z.ZodUnion<readonly [z.ZodObject<{}, z.core.$strict>, z.ZodObject<{
+            channelId: z.ZodString;
+            messageId: z.ZodString;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>;
+    "wallet-list": z.ZodObject<{
+        kind: z.ZodLiteral<"wallet-list">;
+    }, z.core.$strict>;
+    "member-identities": z.ZodObject<{
+        kind: z.ZodLiteral<"member-identities">;
+    }, z.core.$strict>;
+};
+type CapabilityKind = keyof typeof capabilityRequestSchemas;
+type CapabilityRequest = {
+    [K in CapabilityKind]: z.output<(typeof capabilityRequestSchemas)[K]>;
+}[CapabilityKind];
+
+/** 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>;
+/**
+ * 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
+ * Relay would, such as `new CapabilityError("provider-unavailable", "X is unavailable")`.
+ */
+type FakeAnswer<A extends unknown[], R> = R | ((...args: A) => R | Promise<R>);
+/** A wallet balance query as Relay receives it: the chain is canonical CAIP-2. */
+type WalletBalanceRequest = {
+    chain: string;
+    token: string | null;
+    address: string | null;
+};
+/** A tracker read as Relay receives it: defaults applied, and `asOf` set (`eligibleAt` unless given). */
+type TrackerReadRequest = z.output<typeof trackerQuerySchema> & {
+    asOf: number;
+};
+/** The fake answers of one tracker, by reader method. */
+type TrackerFacts = {
+    records?: FakeAnswer<[
+        query: TrackerReadRequest
+    ], Result<typeof trackerPageSchema>>;
+    summary?: FakeAnswer<[
+        query: TrackerReadRequest
+    ], Result<typeof trackerSummarySchema>>;
+    content?: FakeAnswer<[
+        query: TrackerContentQuery
+    ], Result<typeof trackerContentSchema> | null>;
+};
+/**
+ * Fake answers for the evaluator's capabilities, keyed like the evaluation context: `member`,
+ * `wallet`, `x`, `discord`, `trackers` (by tracker key), `images` and `review`.
+ *
+ * Reads of the member's own accounts default to a member who has linked nothing:
+ * `member.identities()`, `wallet.list()`, `wallet.balance()`, `x.connection()`, `x.profile()`,
+ * `x.follows()`, `x.reposted()` and `discord.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.
+ *
+ * Answers pass the result schemas Relay applies before quest code sees them, and arrive as JSON,
+ * as in a hosted run.
+ *
+ * @compat input
+ */
+type TestFacts = {
+    member?: {
+        identities?: FakeAnswer<[], Result<typeof memberIdentitySchema>[] | null>;
+    };
+    wallet?: {
+        list?: FakeAnswer<[], Result<typeof linkedWalletSchema>[] | null>;
+        balance?: FakeAnswer<[
+            query: WalletBalanceRequest
+        ], Result<typeof walletBalanceSchema> | null>;
+    };
+    x?: {
+        connection?: FakeAnswer<[], Result<typeof xConnectionSchema> | null>;
+        profile?: FakeAnswer<[], Result<typeof xProfileSchema> | null>;
+        post?: FakeAnswer<[
+            input: {
+                postId: string;
+            }
+        ], Result<typeof xPostSchema> | null>;
+        follows?: FakeAnswer<[input: {
+            userId: string;
+        }], boolean | null>;
+        reposted?: FakeAnswer<[input: {
+            postId: string;
+        }], boolean | null>;
+    };
+    discord?: {
+        member?: FakeAnswer<[], Result<typeof discordMemberSchema> | null>;
+        message?: FakeAnswer<[
+            input: {
+                channelId: string;
+                messageId: string;
+            }
+        ], Result<typeof discordMessageSchema> | null>;
+    };
+    trackers?: Record<string, TrackerFacts>;
+    images?: {
+        inspect?: FakeAnswer<[
+            image: ImageReference
+        ], Result<typeof imageInspectionSchema>>;
+        compare?: FakeAnswer<[
+            a: ImageReference,
+            b: ImageReference
+        ], Result<typeof imageComparisonSchema>>;
+        review?: FakeAnswer<[
+            options: {
+                images: ImageReference[];
+                criteria: string;
+            }
+        ], Result<typeof photoResultSchema>>;
+        extract?: FakeAnswer<[
+            options: {
+                image: ImageReference;
+                fields: Record<string, unknown>;
+            }
+        ], {
+            values: Record<string, unknown>;
+            reason: string;
+        }>;
+        seen?: FakeAnswer<[
+            image: ImageReference,
+            options: {
+                maxDistance?: number;
+            }
+        ], Result<typeof imageSightingsSchema>>;
+    };
+    review?: {
+        text?: FakeAnswer<[
+            options: TextReviewInput
+        ], Result<typeof photoResultSchema>>;
+        photo?: FakeAnswer<[
+            options: {
+                image?: string;
+                criteria: string;
+            }
+        ], Result<typeof photoResultSchema>>;
+    };
+};
+/** A capability outcome as Relay captures it: the value, or the failure quest code receives. */
+type CapabilityOutcome = {
+    value: unknown;
+} | {
+    error: CapabilityFailure;
+};
+/** A mistake in the test's setup, not in quest code. `runQuest` reports it even when quest code catches it. */
+declare class TestSetupError extends Error {
+    constructor(message: string);
+}
+
+/** The time a run starts at unless the test sets `now`: 2026-01-01T00:00:00Z. */
+declare const defaultNow: number;
+/** The member a run evaluates unless the test or its tracker observation names one. */
+declare const defaultMember = "member_test";
+/** The attempt ID that seeds a run's randomness unless the test sets `seed`. */
+declare const defaultSeed = "attempt_test";
+/**
+ * A quest handle from `defineQuest` or `defineQuestType`, as the testing kit uses it.
+ *
+ * @compat input
+ */
+type TestableQuest = {
+    readonly key: string;
+    describe(settings: unknown): {
+        values: unknown;
+        rewards: Reward[];
+        humanReview: boolean;
+        integrations: readonly string[];
+        trigger: unknown;
+    };
+    evaluate(context: never): Promise<Decision>;
+};
+/** The host context `quest.evaluate` takes: what Relay's evaluator runtime passes it. */
+type QuestHostContext<Q extends TestableQuest> = Q["evaluate"] extends (context: infer C) => unknown ? C : never;
+/**
+ * The evidence a quest's trigger takes, as a test passes it: `{ value }` for text and URL quests,
+ * `{ photo }` (an evidence ID) for photo quests, `{ answers }` for quizzes. `kind` is optional:
+ * the kit fills it from the trigger.
+ */
+type QuestInputOf<Q extends TestableQuest> = QuestHostContext<Q> extends {
+    input: infer I;
+} ? I extends {
+    kind: infer K;
+} ? Omit<I, "kind"> & {
+    kind?: K;
+} : I : never;
+/** @compat input */
+type RunQuestOptions<Q extends TestableQuest = TestableQuest> = {
+    /** Setting values, as an operator enters them in Console. Omitted settings take their defaults. */
+    settings?: Record<string, unknown>;
+    /**
+     * The evaluated member's ID. Defaults to the member a `tracker` observation is attributed to,
+     * else `member_test`.
+     */
+    member?: string;
+    /**
+     * The submitted evidence of a manual quest: `{ value }`, `{ photo }` or `{ answers }`. Relay's
+     * submission checks apply, such as a text quest's `minLength`.
+     */
+    input?: QuestInputOf<Q>;
+    /**
+     * The pinned tracker observation of a tracker-triggered quest. Build it with
+     * `trackerObservation(tracker, { data })`.
+     */
+    tracker?: unknown;
+    /** A content quest's performance stage: the metric sample to evaluate. */
+    performance?: {
+        metrics: Record<string, number>;
+        /** When the sample was observed. Defaults to `now`. */
+        observedAt?: number;
+        /** The rewards content evaluation selected. Defaults to the published rewards. */
+        rewards?: Reward[];
+    };
+    /**
+     * The run's start time, `ctx.now`; `Date.now()` and `new Date()` return it during the evaluation.
+     * Defaults to 2026-01-01T00:00:00Z.
+     */
+    now?: number | Date;
+    /**
+     * When a manual quest's attempt was admitted, `ctx.eligibleAt`. Defaults to `now`. A
+     * tracker-triggered attempt takes its observation's `occurredAt`.
+     */
+    eligibleAt?: number | Date;
+    /** The project time zone `ctx.calendar` counts days in. Defaults to UTC. */
+    timeZone?: string;
+    /** Project time-zone changes, oldest first; overrides `timeZone`. */
+    calendar?: readonly CalendarSegment[];
+    /**
+     * Seeds `Math.random()`, `crypto.getRandomValues()` and `crypto.randomUUID()`; a hosted run uses
+     * the attempt ID.
+     */
+    seed?: string;
+    /** Fake answers for the capabilities the quest reads. */
+    facts?: TestFacts;
+};
+/**
+ * One capability call, as Relay captures it for replay.
+ *
+ * @compat output
+ */
+type CapabilityCall = {
+    sequence: number;
+    request: CapabilityRequest;
+    outcome: CapabilityOutcome;
+};
+/**
+ * The published release a run used: what `describe` returned for the settings.
+ *
+ * @compat output
+ */
+type TestRelease = {
+    values: unknown;
+    rewards: Reward[];
+    humanReview: boolean;
+    integrations: readonly 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[];
+    release: TestRelease;
+    /** The run's start time and seed. */
+    now: number;
+    seed: string;
+};
+/** @compat output */
+type QuestRun = {
+    decision: Decision;
+    calls: CapabilityCall[];
+    release: TestRelease;
+};
+/**
+ * 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
+ * checks the decision as Relay does.
+ */
+declare function createTestContext<Q extends TestableQuest>(quest: Q, options?: RunQuestOptions<Q>): TestContext<Q>;
+/**
+ * Evaluates a quest locally the way Relay's hosted runtime does: the quest's published settings,
+ * rewards and review setting, `ctx.now` and `Date` frozen at `now`, randomness seeded by `seed`,
+ * 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.
+ */
+declare function runQuest<Q extends TestableQuest>(quest: Q, options?: RunQuestOptions<Q>): Promise<QuestRun>;
+
+type Kind = Decision["kind"];
+type DecisionOf<K extends Kind> = Extract<Decision, {
+    kind: K;
+}>;
+/** Thrown by `expectAccept` and its siblings when a decision is not the expected one. */
+declare class DecisionAssertionError extends Error {
+    readonly decision: Decision;
+    constructor(message: string, decision: Decision);
+}
+/** Asserts the run accepted and returns the accept decision, with its rewards and completion key. */
+declare function expectAccept(run: QuestRun | Decision): DecisionOf<"accept">;
+/** Asserts the run rejected, optionally with a reason equal to a string or matching a pattern. */
+declare function expectReject(run: QuestRun | Decision, reason?: string | RegExp): DecisionOf<"reject">;
+/** Asserts the run went to human review, optionally with a reason equal to a string or matching a pattern. */
+declare function expectReview(run: QuestRun | Decision, reason?: string | RegExp): DecisionOf<"review">;
+/** Asserts the run deferred, optionally with a reason equal to a string or matching a pattern. */
+declare function expectDefer(run: QuestRun | Decision, reason?: string | RegExp): DecisionOf<"defer">;
+/** Asserts the run recorded progress, optionally with a reason equal to a string or matching a pattern. */
+declare function expectProgress(run: QuestRun | Decision, reason?: string | RegExp): DecisionOf<"progress">;
+
+/**
+ * One observation of a tracker record, as a tracker-triggered quest's attempt pins it.
+ *
+ * @compat input
+ */
+type TrackerObservationInput<D, B> = {
+    /** The record's data, of the tracker's data type. */
+    data: D;
+    /** The member Relay attributed the record to. Defaults to `member_test`. */
+    member?: string;
+    /** The record's ID in its source. Defaults to `record_test`. */
+    id?: string;
+    /** When the activity happened; the attempt's `eligibleAt`. Defaults to 2026-01-01. */
+    occurredAt?: number | Date;
+    /** When Relay observed this version of the record. Defaults to `occurredAt`. */
+    observedAt?: number | Date;
+    /** The record's author account. Defaults to an unverified `author_test`. */
+    author?: {
+        id: string;
+        verified: boolean | null;
+        kind?: string;
+    } | null;
+    /** The record account the attempt pays. Defaults to `"author"`. */
+    beneficiary?: string;
+    /** The verified link Relay attributed the record through. Defaults to the member itself. */
+    account?: TrackerAttribution["account"];
+    /** On a content source: the content body this observation carries. */
+    body?: B;
+    /** On a quest that requires enrollment: when the member enrolled. */
+    enrolledAt?: number | Date;
+    /** Whether the source reported the record removed. */
+    removed?: boolean;
+};
+/**
+ * Builds the pinned observation a tracker-triggered quest evaluates: `runQuest(quest, { tracker:
+ * trackerObservation(messages, { data: { channelId: "123", ... } }) })`. `data` has the tracker's
+ * data type, and the result is checked against the shape Relay pins.
+ */
+declare function trackerObservation<T extends Tracker>(tracker: T, observation: TrackerObservationInput<TrackerData<T>, ContentBody<T>>): TrackerTriggerContext<TrackerData<T>>;
+/**
+ * One stored record of a tracker, as `ctx.trackers.records()` returns it.
+ *
+ * @compat input
+ */
+type TrackerRecordInput<D> = {
+    /** The record's data, of the tracker's data type. */
+    data: D;
+    /** The record's ID in its source. Defaults to `record_<position>`. */
+    id?: string;
+    /** When the activity happened. Defaults to 2026-01-01. */
+    occurredAt?: number | Date;
+    /** When Relay observed this version of the record. Defaults to `occurredAt`. */
+    observedAt?: number | Date;
+    /** The record's author account. Defaults to an unverified `author_test`. */
+    author?: {
+        id: string;
+        verified: boolean | null;
+        kind?: string;
+    } | null;
+    /** Whether the source reported the record removed. */
+    removed?: boolean;
+};
+/**
+ * Builds a page of tracker records, as a `facts.trackers[key].records` answer: `trackerPage(posts,
+ * [{ data: { amount: 5 } }])`. `data` has the tracker's data type; the tracker's status says it is
+ * published, idle and fully synced. The page is checked against the shape Relay returns.
+ */
+declare function trackerPage<T extends Tracker>(tracker: T, records: readonly TrackerRecordInput<TrackerData<T>>[], options?: {
+    nextCursor?: string | null;
+    total?: number;
+}): TrackerPage<TrackerData<T>>;
+
+/** @compat input */
+type ReplayOptions = {
+    /**
+     * Answers for calls the capture cannot answer: a call the captured run did not make, one whose
+     * request changed, or a retryable failure Relay did not keep. Without them, the replay stops at
+     * the first such call.
+     */
+    facts?: TestFacts;
+};
+/**
+ * The first call the capture could not answer.
+ *
+ * @compat output
+ */
+type ReplayDivergence = {
+    sequence: number;
+    /**
+     * `"new"`: the captured run made no such call. `"changed"`: it sent another request.
+     * `"uncaptured"`: its answer was a retryable failure Relay did not keep.
+     */
+    reason: "new" | "changed" | "uncaptured";
+    /** The request the captured run sent at this position; null for a new call. */
+    recorded: Record<string, unknown> | null;
+    replayed: CapabilityRequest;
+};
+/** @compat output */
+type AttemptReplay = {
+    /** What the current quest code decides; null when the replay stopped at a divergence. */
+    decision: Decision | null;
+    /** What quest code decided in the captured run; null when it had decided nothing. */
+    recorded: Decision | null;
+    /**
+     * Whether the decision differs from the recorded one: its kind, reason, rewards or completion
+     * key. Null when either is missing.
+     */
+    changed: boolean | null;
+    /** The first call the capture could not answer, or null when it answered every call. */
+    divergence: ReplayDivergence | null;
+    calls: CapabilityCall[];
+};
+/**
+ * Evaluates current quest code against a captured attempt: the release's settings and rewards,
+ * the attempt's input, clock, seed and calendar, and the captured capability answers, as a retry
+ * of that evaluation run would. Get the capture with `management.attempts.capture(attempt)` or
+ * `domino quests replay <attempt> --out <file>`; Relay serves captures from the test environment
+ * only.
+ *
+ * Resolves with the decision beside the recorded one, so a test can show whether a code change
+ * 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>;
+
+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 };