@domino-sdk/relay 1.0.0-next.1 → 1.0.0-next.12

package/README.md

@@ -6,6 +6,18 @@ Author quests and connect an application to Domino Relay.
 pnpm add @domino-sdk/relay
 ```
 
-Use `@domino-sdk/relay/authoring` for quest definitions, `/browser` for browser integrations, `/portal-proxy` for server proxies, and `/build` for bundling authored modules.
+| Import                           | For                                                                                        |
+| -------------------------------- | ------------------------------------------------------------------------------------------ |
+| `@domino-sdk/relay`              | The participant client (`createRelayClient`), `RelayError`, and the types it returns       |
+| `@domino-sdk/relay/browser`      | The browser client with durable submission recovery, wallet signers and sign-in options    |
+| `@domino-sdk/relay/react`        | React hooks over the browser client                                                        |
+| `@domino-sdk/relay/avatar`       | Generated default avatars (`avatarSrc`, `defaultAvatar`)                                   |
+| `@domino-sdk/relay/authoring`    | Quest, tracker, leaderboard, referral and engagement definitions, and evaluator types     |
+| `@domino-sdk/relay/schema`       | Zod schemas of Relay's API bodies, deployments, tracker records and observations           |
+| `@domino-sdk/relay/build`        | Bundling authored modules; needs `esbuild` installed                                       |
+| `@domino-sdk/relay/portal-proxy` | Server proxies and hosted app Workers                                                      |
+| `@domino-sdk/relay/vite`         | The Vite plugin that keeps server code out of the browser build                            |
+
+`@domino-sdk/relay/internal` is shared by Relay's own services and Console. It is not a supported API and can change in any release.
 
 Requires Node.js 24 for tooling. Proprietary software; `UNLICENSED`.

package/build.mjs

@@ -1,5 +1,21 @@
 import { resolve, dirname } from "node:path"
-import { build } from "esbuild"
+
+// esbuild is an optional peer dependency: only quest builds need it, so apps that use the runtime
+// client do not install its native binary. `@domino-sdk/relay-cli` depends on it.
+async function esbuild() {
+  try {
+    return await import("esbuild")
+  } catch (error) {
+    if (error?.code === "ERR_MODULE_NOT_FOUND") {
+      throw new Error(
+        "@domino-sdk/relay/build needs esbuild. Install it next to @domino-sdk/relay, or build with the domino CLI (@domino-sdk/relay-cli).",
+        { cause: error }
+      )
+    }
+
+    throw error
+  }
+}
 
 /** Bundle an authored quest without evaluating developer code in the build process. */
 export async function buildQuest(entry, options = {}) {
@@ -10,6 +26,7 @@ export async function buildQuest(entry, options = {}) {
     throw new Error("Invalid quest export name")
   }
 
+  const { build } = await esbuild()
   const result = await build({
     ...(options.exportName
       ? {

package/dist/authoring.d.ts

@@ -1,7 +1,312 @@
-import { A as AdmittedContent, O as Observation, T as TrackerTriggerContext, a as TrackerReader, X as XReader, I as ImageReader, D as DiscordMember, b as DiscordMessage, W as WalletConnection, S as SolanaBalance, L as LinkedWallet, c as WalletBalanceQuery, d as WalletBalance, e as TrackerDefinition, f as TrackerTriggerMode, g as TrackerWhere, o as observationTriggerSchema, h as TrackerTriggerPolicy, B as Budget, i as AuthoringIdentity, C as ContentMetric, j as IntegrationProvider, k as StreakPolicy, l as TextEvidence, U as UrlEvidence, m as TextOptions, n as UrlOptions } from './submission-input-JDwq3EVK.js';
-export { E as EvmChainId, p as content, q as customSource, r as defineEngagementReward, s as defineLeaderboard, t as defineReferral, u as defineTracker, v as discord, w as formatUnits, x as isEvmChainId, y as parseUnits, z as perContent, F as pointLedgers, G as settings, H as streak, J as trackerTriggerContextSchema, K as x } from './submission-input-JDwq3EVK.js';
 import { z } from 'zod';
-import { TextReviewInput, TextResult, PhotoResult, rewardSchema, triggerSchema, QuestPresentation, QuestProfile, QuizEvidence, Decision, TieredRewardDefinition } from './schema.js';
+export { z } from 'zod';
+import { e as ContentPolicy, C as ContentMetric, E as EngagementDefinition, P as leaderboardAuthoringSchema, a7 as referralAuthoringSchema, A as AdmittedContent } from './referrals-CvSmxvjm.js';
+import { Q as QuizContent, a as StreakPolicy } from './streaks-CwGReWGt.js';
+import { b as ResourceSource, S as Setting, g as XReader, I as IntegerSettings, a as IntegrationProvider } from './integrations-EjQzIApL.js';
+import { j as TrackerDefinition, I as IdentityKind, J as customSourceSchema, F as WithRecordData, t as TrackerSource, a1 as trackerDefinitionSchema, a as Tracker, h as TrackerData, au as xSearchSourceSchema, X as XTweet, v as TrackerTriggerContext, x as TrackerTriggerPolicy, q as TrackerReader, W as Where, w as TrackerTriggerMode, E as WhereSetting } from './trackers-BsUh5Ky0.js';
+export { T as TrackerDataSchema, m as TrackerPage, aw as trackerDataSchema, ak as trackerTriggerContextSchema } from './trackers-BsUh5Ky0.js';
+import { e as ImageReader } from './images-D0Txfte6.js';
+import { O as Observation, D as DiscordMessage, h as observationTriggerSchema, B as Budget } from './observations-bFY4yv2K.js';
+import { D as DiscordMember, T as TextEvidence, U as UrlEvidence, b as TextOptions, c as UrlOptions } from './submission-input-CccwAl5Z.js';
+import { n as TextReviewInput, m as TextResult, P as PhotoResult, ag as rewardSchema, au as triggerSchema, Q as QuestPresentation, a as QuestProfile, b as QuizEvidence, D as Decision, o as TieredRewardDefinition } from './schema-ZfjL-d1N.js';
+import { k as WalletConnection, S as SolanaBalance, L as LinkedWallet, j as WalletBalanceQuery, i as WalletBalance } from './wallet-BtiG0Xhr.js';
+export { E as EvmChainId, r as isEvmChainId } from './wallet-BtiG0Xhr.js';
+export { f as formatUnits, p as parseUnits } from './units-CwgsPB_r.js';
+
+/** Legacy `id` names an authoring key, never a server resource ID. */
+type AuthoringIdentity = {
+    key: string;
+    id?: string;
+} | {
+    key?: never; /** @deprecated Use key. */
+    id: string;
+};
+
+/** Discover posts automatically; historical release remains an explicit policy. */
+declare function content(tracker: TrackerDefinition, policy?: Partial<Pick<ContentPolicy, "enrollment" | "posts" | "historical">>): {
+    kind: "automatic";
+    content: {
+        tracker: string;
+        window: {
+            start: number;
+            end?: number | undefined;
+        };
+        enrollment: "required" | "none";
+        posts: "after-enrollment" | "since-start";
+        historical: "staff" | "automatic" | "claim";
+    };
+};
+declare function perContent(): {
+    kind: "keyed";
+    perContent: true;
+    key: (ctx: {
+        content?: AdmittedContent | null;
+    }) => string;
+};
+/** One independent cumulative formula; management changes capture a new scoring boundary. */
+declare function defineEngagementReward<const M extends readonly [ContentMetric, ...ContentMetric[]]>(input: {
+    key: string;
+    qualifiedBy: string | {
+        key: string;
+    };
+    balance: string;
+    metrics: M;
+    baseline: "historical";
+    maxAgeMs?: number;
+    budget?: EngagementDefinition["budget"];
+    target: (input: {
+        metrics: Record<M[number], number>;
+    }) => number;
+}): {
+    key: string;
+    describe: () => {
+        key: string;
+        qualifiedBy: string;
+        balance: string;
+        metrics: ("likes" | "replies" | "reposts" | "quotes" | "views" | "bookmarks")[];
+        baseline: "historical";
+        maxAgeMs: number;
+        budget: {
+            projectDaily?: number | undefined;
+            memberDaily?: number | undefined;
+            projectLifetime?: number | undefined;
+        };
+    };
+    score(raw: unknown): {
+        target: number;
+        baseline: number;
+    };
+};
+/**
+ * One milestone per quest, after `days` consecutive community days with an accepted attempt.
+ * Multiple accepted attempts occupy one day. The day comes from the attempt's trusted occurrence
+ * time: a tracker record's (or observation's) `occurredAt` for `automatic({ tracker })`, and the
+ * submission's admission time for `manual()`, so a manual streak counts the days a member
+ * submitted. Not available on content quests or prerequisite-only `automatic()`.
+ */
+declare const streak: (options: Omit<StreakPolicy, "kind">) => StreakPolicy;
+declare function defineReferral(input: Omit<z.input<typeof referralAuthoringSchema>, "key" | "id"> & AuthoringIdentity): {
+    id: string;
+    title: string;
+    rewards: {
+        inviter: ({
+            kind: "tier";
+            reward: {
+                id: string;
+                title: string;
+                tiers: {
+                    id: string;
+                    title: string;
+                }[];
+                inventory: {
+                    kind: "untracked";
+                };
+                fulfillment: {
+                    kind: "staff-handover";
+                };
+            };
+            tier: string;
+        } | {
+            kind: "points";
+            balance: string;
+            amount: number;
+        })[];
+        invitee: ({
+            kind: "tier";
+            reward: {
+                id: string;
+                title: string;
+                tiers: {
+                    id: string;
+                    title: string;
+                }[];
+                inventory: {
+                    kind: "untracked";
+                };
+                fulfillment: {
+                    kind: "staff-handover";
+                };
+            };
+            tier: string;
+        } | {
+            kind: "points";
+            balance: string;
+            amount: number;
+        })[];
+    };
+    qualification: {
+        kind: "signup";
+    } | {
+        kind: "quest";
+        quest: string;
+    } | {
+        kind: "external";
+    };
+    enabled: boolean;
+    inviterGroup?: string | undefined;
+    milestones: {
+        id: string;
+        count: number;
+        rewards: ({
+            kind: "tier";
+            reward: {
+                id: string;
+                title: string;
+                tiers: {
+                    id: string;
+                    title: string;
+                }[];
+                inventory: {
+                    kind: "untracked";
+                };
+                fulfillment: {
+                    kind: "staff-handover";
+                };
+            };
+            tier: string;
+        } | {
+            kind: "points";
+            balance: string;
+            amount: number;
+        })[];
+    }[];
+    bonuses: {
+        id: string;
+        balance: string;
+        basisPoints: number;
+        external: boolean;
+        quests?: string[] | undefined;
+        durationDays?: number | undefined;
+        maxPoints?: number | undefined;
+    }[];
+    key: string;
+};
+declare function defineLeaderboard(input: Omit<z.input<typeof leaderboardAuthoringSchema>, "key" | "id"> & AuthoringIdentity): {
+    id: string;
+    balance: string;
+    title: string;
+    group?: string | undefined;
+    score: {
+        kind: "balance";
+    } | {
+        window: {
+            kind: "fixed";
+            start: number;
+            end: number;
+        } | {
+            kind: "all-time";
+        } | {
+            kind: "rolling";
+            days: number;
+        } | {
+            kind: "calendar";
+            period: "day" | "week" | "month";
+            timeZone: string;
+        };
+        kind: "earned";
+        quests?: string[] | undefined;
+    } | {
+        kind: "net";
+        window: {
+            kind: "fixed";
+            start: number;
+            end: number;
+        } | {
+            kind: "all-time";
+        } | {
+            kind: "rolling";
+            days: number;
+        } | {
+            kind: "calendar";
+            period: "day" | "week" | "month";
+            timeZone: string;
+        };
+    };
+    access: "participants" | "public";
+    key: string;
+};
+declare const x: {
+    /** Posts matching an X search. Each record's `data` is the provider's post payload. */
+    search: (input: {
+        query: string;
+    }) => z.output<typeof xSearchSourceSchema> & WithRecordData<XTweet>;
+};
+/**
+ * Records your own code sends with `trackers.ingest`. `data` is a zod object schema that every
+ * record's `data` must match: Relay stores its JSON Schema form with the tracker and rejects
+ * records that do not match it, and quests read each record's data with its type. With
+ * `identities`, each record's author, and each named account in `accounts`, is a verified identity
+ * of one of those kinds, which Relay attributes to the member who verified it, so quests can
+ * trigger from the tracker. A record states each account's `kind` unless the source names exactly
+ * one.
+ */
+declare function customSource<S extends z.ZodObject>(namespace: string, options: {
+    identities?: IdentityKind[];
+    accounts?: string[];
+    data: S;
+}): z.output<typeof customSourceSchema> & WithRecordData<z.input<S>>;
+declare function defineTracker<S extends TrackerSource>(input: Omit<z.input<typeof trackerDefinitionSchema>, "source"> & {
+    source: S;
+}): Tracker<TrackerData<S>>;
+type ChannelTypes = Extract<ResourceSource, {
+    resource: "channel";
+}>["types"];
+declare const discord: {
+    roles(options?: {
+        assignable?: boolean;
+    }): ResourceSource;
+    channels(options?: {
+        types?: ChannelTypes;
+    }): ResourceSource;
+};
+declare const pointLedgers: () => ResourceSource;
+type Label = {
+    label: string;
+    description?: string;
+};
+declare const settings: {
+    pointLedger(options: Label & {
+        default: string;
+    }): Setting<"point-ledger", z.ZodDefault<z.ZodString>>;
+    datetime(options: Label & {
+        default: string;
+    }): Setting<"datetime", z.ZodDefault<z.ZodPipe<z.ZodISODateTime, z.ZodTransform<string, string>>>>;
+    resource(options: Label & {
+        source: ResourceSource;
+        default?: string;
+    }): Setting<"resource", z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>>;
+    quiz(options: Label & {
+        default: QuizContent;
+    }): Setting<"quiz", z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        prompt: z.ZodString;
+        choices: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+        correct: z.ZodString;
+    }, z.core.$strict>>>>;
+    text(options: Label & {
+        default: string;
+        minLength?: number;
+        maxLength?: number;
+        multiline?: boolean;
+    }): Setting<"text", z.ZodDefault<z.ZodString>>;
+    integer(options: Label & {
+        default: number;
+        min: number;
+        max: number;
+    }): Setting<"integer", z.ZodDefault<z.ZodNumber>>;
+    boolean(options: Label & {
+        default: boolean;
+    }): Setting<"boolean", z.ZodDefault<z.ZodBoolean>>;
+    choice<const T extends readonly [string, ...string[]]>(options: Label & {
+        options: T;
+        default: T[number];
+    }): Setting<"choice", z.ZodDefault<z.ZodEnum<{ [k_1 in T[number]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never>>>;
+    /** A quest's settings: every field is built with one of the builders above. */
+    object<T extends Record<string, Setting>>(shape: T): z.ZodObject<{ -readonly [P in keyof T]: T[P]; }, z.core.$strict>;
+};
 
 type Reward = z.infer<typeof rewardSchema>;
 declare const points: (balance: string, amount: number) => {
@@ -59,8 +364,9 @@ declare function manual(options: {
     actor: "staff";
 };
 /** A tracker trigger: which observations of which tracker run the quest, and for whom. */
-type TrackerTriggerInput = {
-    tracker: TrackerDefinition;
+type TrackerTriggerInput<T extends Tracker = Tracker, W extends Where<TrackerData<T>> | undefined = Where<TrackerData<T>> | undefined> = {
+    /** The tracker handle `defineTracker` returns. */
+    tracker: T;
     /**
      * Which observations fire. `"new-record"`: each record's first observation (the default for X
      * trackers, where it means each newly collected post). `"new-observation"`: each observation
@@ -70,9 +376,11 @@ type TrackerTriggerInput = {
     on?: TrackerTriggerMode;
     /**
      * Admit only observations whose `data` matches, such as `{ path: "amount", gte: 1000 }` or
-     * `{ path: "amount", gte: { setting: "threshold" } }`. Others record no outcome.
+     * `{ path: "amount", gte: { setting: "threshold" } }`, or a list of at most 10 such conditions
+     * that must all hold. Paths and values are checked against the tracker's data type, and a
+     * `setting` must name one of the quest's integer settings. Others record no outcome.
      */
-    where?: TrackerWhere;
+    where?: W;
     /**
      * The record account whose member the quest pays: `"author"` (the default), `"inReplyTo"` on
      * an X tracker, or a named account a custom source declares in `accounts`. Skipped when that
@@ -80,6 +388,24 @@ type TrackerTriggerInput = {
      */
     beneficiary?: string;
 };
+/** Type-only markers a tracker trigger carries into `defineQuest`. They never exist at runtime. */
+declare const triggerData: unique symbol;
+declare const triggerSettings: unique symbol;
+/**
+ * A tracker trigger whose records carry `data` of type `D` and whose filter compares with the
+ * settings `S`. `defineQuest` types `ctx.tracker` from `D` and checks `S` against its integer
+ * settings.
+ */
+type TrackerTrigger<D = unknown, S extends string = never> = {
+    kind: "automatic";
+    tracker: TrackerTriggerPolicy;
+    readonly [triggerData]?: D;
+    readonly [triggerSettings]?: S;
+};
+type TriggerData<G> = G extends TrackerTrigger<infer D, string> ? unknown extends D ? unknown : D : unknown;
+type TriggerSettings<G> = G extends {
+    readonly [triggerSettings]?: infer S;
+} ? unknown extends S ? never : Exclude<S, undefined> : never;
 /**
  * An automatic quest. With no argument it runs once its prerequisites are complete; with an
  * observation it runs for each matching observation; with a tracker it runs for each observation
@@ -92,9 +418,33 @@ declare function automatic(observation: z.infer<typeof observationTriggerSchema>
     kind: "automatic";
     observation: z.infer<typeof observationTriggerSchema>;
 };
-declare function automatic(input: TrackerTriggerInput): {
-    kind: "automatic";
-    tracker: TrackerTriggerPolicy;
+declare function automatic<T extends Tracker, const W extends Where<TrackerData<T>> | undefined = undefined>(input: TrackerTriggerInput<T, W>): TrackerTrigger<TrackerData<T>, WhereSetting<W>>;
+/**
+ * What a trigger `G` supplies under key `K`: `Present` when the trigger has it, null when it cannot,
+ * and `Present | null` when `G` is not known.
+ */
+type Supplied<G, K extends string, Present, Base> = unknown extends G ? Base | null : G extends unknown ? K extends keyof G ? [G[K]] extends [object] ? Present : Base | null : null : never;
+/** `ctx.tracker` for a trigger: non-null and typed for a tracker trigger, null for others. */
+type ContextTracker<G> = Supplied<G, "tracker", TrackerTriggerContext<TriggerData<G>>, TrackerTriggerContext>;
+/** `ctx.content` for a trigger: the admitted post for a content trigger, null for others. */
+type ContextContent<G> = Supplied<G, "content", AdmittedContent, AdmittedContent>;
+/** `ctx.observation` for a trigger: the observation for an observation trigger, null for others. */
+type ContextObservation<G> = Supplied<G, "observation", Observation, Observation>;
+/**
+ * What a `keyed()` completion key reads. TypeScript cannot carry the trigger into a completion
+ * built inline, so `tracker` stays nullable here; the evaluator's `ctx.tracker` is typed.
+ */
+type KeyedContext = {
+    member: {
+        id: string;
+    };
+    content?: AdmittedContent | null;
+    observation: Observation | null;
+    /** The pinned tracker observation of a tracker-triggered quest; null for other triggers. */
+    tracker: TrackerTriggerContext | null;
+    eligibleAt: number;
+    /** The attempt's evaluation time; see {@link EvaluationContext.now}. */
+    now: number;
 };
 declare const budget: (definition: Budget) => {
     id: string;
@@ -105,31 +455,12 @@ declare const budget: (definition: Budget) => {
         balance: string;
     };
 };
-declare const keyed: (key: (ctx: {
-    member: {
-        id: string;
-    };
-    content?: AdmittedContent | null;
-    observation: Observation | null;
-    /** The pinned tracker observation of a tracker-triggered quest. */
-    tracker?: TrackerTriggerContext | null;
-    eligibleAt: number;
-}) => string) => {
+declare const keyed: (key: (ctx: KeyedContext) => string) => {
     kind: "keyed";
-    key: (ctx: {
-        member: {
-            id: string;
-        };
-        content?: AdmittedContent | null;
-        observation: Observation | null;
-        /** The pinned tracker observation of a tracker-triggered quest. */
-        tracker?: TrackerTriggerContext | null;
-        eligibleAt: number;
-    }) => string;
+    key: (ctx: KeyedContext) => string;
 };
 declare const completed: (quest: AuthoringIdentity | string) => {
     quest: string;
-    scope: "ever";
 };
 declare const untracked: () => {
     kind: "untracked";
@@ -174,34 +505,82 @@ type Outcome = {
     kind: "reject";
     reason: string;
 };
+/**
+ * A performance evaluator's answer. It gates the rewards content evaluation already selected, so
+ * it carries none: a `rewards` value fails the evaluation.
+ */
+type PerformanceOutcome = {
+    kind: "accept";
+    rewards?: never;
+} | {
+    kind: "review";
+    reason: string;
+    rewards?: never;
+} | {
+    kind: "reject";
+    reason: string;
+};
+declare function accept(): {
+    kind: "accept";
+};
+declare function accept(options: {
+    rewards?: Reward[];
+}): Outcome;
+declare function review(options: {
+    reason: string;
+    rewards?: undefined;
+}): {
+    kind: "review";
+    reason: string;
+};
+declare function review(options: {
+    reason: string;
+    rewards?: Reward[];
+}): Outcome;
 declare const decision: {
-    accept: (options?: {
-        rewards?: Reward[];
-    }) => Outcome;
+    accept: typeof accept;
     reject: (options: {
         reason: string;
-    }) => Outcome;
-    review: (options: {
+    }) => {
+        kind: "reject";
         reason: string;
-        rewards?: Reward[];
-    }) => Outcome;
+    };
+    review: typeof review;
 };
+/**
+ * What an evaluator reads. `G` is the quest's trigger: `tracker`, `content` and `observation` are
+ * non-null for the trigger that supplies them and null otherwise. `G` defaults to `any`, which
+ * leaves them nullable and lets a shared evaluator, such as `evaluators.photo()`, fit every quest.
+ */
 type EvaluationContext<T, I = {
     photo: string;
-}> = {
+}, G = any> = {
     settings: T;
     member: {
         id: string;
     };
     input: I;
-    content: AdmittedContent | null;
-    observation: Observation | null;
+    /** The admitted post of a content quest. */
+    content: ContextContent<G>;
+    /** The observation of an observation-triggered quest. */
+    observation: ContextObservation<G>;
     /**
      * The tracker observation that admitted this attempt, and the member and verified account it
-     * was attributed to. Null unless the quest has a tracker trigger.
+     * was attributed to. Present for a tracker trigger, with `record.data` of the tracker's type.
+     */
+    tracker: ContextTracker<G>;
+    /**
+     * When the activity happened, in epoch milliseconds: the observation's or tracker record's
+     * occurrence time, else when the attempt was admitted. Budgets and daily keys use it.
      */
-    tracker: TrackerTriggerContext | null;
     eligibleAt: number;
+    /**
+     * The attempt's evaluation time, in epoch milliseconds: when its first evaluation started.
+     * Every retry and replay of the attempt receives the same value, and the sandbox freezes
+     * `Date.now()` and `new Date()` at it. Use `eligibleAt` for when the activity
+     * happened.
+     */
+    now: number;
     trackers: TrackerReader;
     x: XReader;
     images: ImageReader;
@@ -236,7 +615,7 @@ type EvaluationContext<T, I = {
 };
 type Evaluator<T, I = {
     photo: string;
-}> = (ctx: EvaluationContext<T, I>) => Promise<Outcome>;
+}, G = any> = (ctx: EvaluationContext<T, I, G>) => Promise<Outcome>;
 declare const evaluators: {
     quiz(answerKey: QuizEvidence["answers"], options?: {
         minimumCorrect?: number;
@@ -260,7 +639,16 @@ type QuestInput<T extends Trigger> = T extends {
 } ? TextEvidence : T extends {
     input: "url";
 } ? UrlEvidence : Record<string, never>;
-declare function defineQuest<T extends Record<string, z.ZodType>, const G extends Trigger, const M extends readonly [ContentMetric, ...ContentMetric[]] = readonly [
+/**
+ * Rejects a trigger whose filter compares with settings that are not integer settings of the
+ * quest, naming them.
+ */
+type IntegerSettingBounds<G, T> = [
+    Exclude<TriggerSettings<G>, IntegerSettings<T>>
+] extends [never] ? unknown : {
+    readonly "The tracker filter compares with settings that are not integer settings of this quest": Exclude<TriggerSettings<G>, IntegerSettings<T>>;
+};
+declare function defineQuest<T extends Record<string, Setting>, const G extends Trigger, const M extends readonly [ContentMetric, ...ContentMetric[]] = readonly [
     ContentMetric,
     ...ContentMetric[]
 ]>(definition: AuthoringIdentity & {
@@ -271,7 +659,7 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
     presentation?: (ctx: {
         settings: z.output<z.ZodObject<T>>;
     }) => QuestPresentation;
-    trigger: G;
+    trigger: G & NoInfer<IntegerSettingBounds<G, T>>;
     integrations?: IntegrationProvider[];
     requires?: ReturnType<typeof completed>[];
     completion: ReturnType<typeof once> | ReturnType<typeof keyed> | StreakPolicy;
@@ -282,6 +670,12 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
      */
     profile?: QuestProfile;
     budgets?: Budget[];
+    /**
+     * Whether staff can review this quest's attempts. Human review is on unless this returns
+     * `{ enabled: false }`. With it off, `decision.review(...)` becomes a reject that keeps the
+     * review reason, and the attempt records `requestedReview: true`; Console shows "Would have
+     * gone to review; human review is off".
+     */
     review?: (ctx: {
         settings: z.output<z.ZodObject<T>>;
     }) => {
@@ -290,7 +684,7 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
     rewards: Reward[] | ((ctx: {
         settings: z.output<z.ZodObject<T>>;
     }) => Reward[]);
-    evaluate?: Evaluator<z.output<z.ZodObject<T>>, QuestInput<G>>;
+    evaluate?: Evaluator<z.output<z.ZodObject<T>>, QuestInput<G>, NoInfer<G>>;
     performance?: G extends {
         content: unknown;
     } ? {
@@ -304,7 +698,7 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
             content: AdmittedContent;
             metrics: Record<M[number], number>;
             observedAt: number;
-        }) => Outcome | Promise<Outcome>;
+        }) => PerformanceOutcome | Promise<PerformanceOutcome>;
     } : never;
 }): {
     key: string;
@@ -477,7 +871,24 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
                 } | {
                     path: string;
                     equals: string | number | boolean;
-                } | undefined;
+                } | ({
+                    path: string;
+                    gt?: number | {
+                        setting: string;
+                    } | undefined;
+                    gte?: number | {
+                        setting: string;
+                    } | undefined;
+                    lt?: number | {
+                        setting: string;
+                    } | undefined;
+                    lte?: number | {
+                        setting: string;
+                    } | undefined;
+                } | {
+                    path: string;
+                    equals: string | number | boolean;
+                })[] | undefined;
             } | undefined;
         } | {
             kind: "manual";
@@ -503,7 +914,6 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
         };
         requires: {
             quest: string;
-            scope: "ever";
         }[];
         completion: {
             kind: "streak";
@@ -542,4 +952,4 @@ declare function defineQuest<T extends Record<string, z.ZodType>, const G extend
  * Console instances receive independent quest identities and pinned versions. */
 declare const defineQuestType: typeof defineQuest;
 
-export { type EvaluationContext, TrackerTriggerContext, type TrackerTriggerInput, WalletBalance, WalletBalanceQuery, automatic, budget, completed, decision, defineQuest, defineQuestType, defineTieredReward, discordRole, evaluators, evidence, keyed, manual, once, points, staffHandover, untracked };
+export { type EvaluationContext, ImageReader, type KeyedContext, type PerformanceOutcome, Setting, Tracker, TrackerData, TrackerReader, type TrackerTrigger, TrackerTriggerContext, type TrackerTriggerInput, WalletBalance, WalletBalanceQuery, Where, XReader, automatic, budget, completed, content, customSource, decision, defineEngagementReward, defineLeaderboard, defineQuest, defineQuestType, defineReferral, defineTieredReward, defineTracker, discord, discordRole, evaluators, evidence, keyed, manual, once, perContent, pointLedgers, points, settings, staffHandover, streak, untracked, x };