@domino-sdk/relay 0.11.0 → 0.13.0

package/dist/authoring.d.ts

@@ -1,5 +1,5 @@
-import { O as Observation, D as DiscordMember, a as DiscordMessage, W as WalletConnection, S as SolanaBalance, o as observationTriggerSchema, B as Budget, A as AuthoringIdentity, I as IntegrationProvider, b as StreakPolicy } from './settings-B61jIDDA.js';
-export { d as defineLeaderboard, c as defineReferral, e as discord, p as pointLedgers, s as settings, f as streak } from './settings-B61jIDDA.js';
+import { O as Observation, T as TrackerReader, D as DiscordMember, a as DiscordMessage, W as WalletConnection, S as SolanaBalance, o as observationTriggerSchema, B as Budget, A as AuthoringIdentity, I as IntegrationProvider, b as StreakPolicy } from './settings-CgI5nDQr.js';
+export { c as customSource, d as defineLeaderboard, e as defineReferral, f as defineTracker, g as discord, p as pointLedgers, s as settings, h as streak, x } from './settings-CgI5nDQr.js';
 import { z } from 'zod';
 import { PhotoResult, rewardSchema, triggerSchema, QuestPresentation, QuizEvidence, Decision, TieredRewardDefinition } from './schema.js';
 
@@ -137,6 +137,7 @@ type EvaluationContext<T, I = {
     input: I;
     observation: Observation | null;
     eligibleAt: number;
+    trackers: TrackerReader;
     review: {
         photo(options: {
             image: string;

package/dist/authoring.js

@@ -1,8 +1,11 @@
 import {
   authoringKey,
+  customSource,
   defineLeaderboard,
-  defineReferral
-} from "./chunk-CE5XVIJQ.js";
+  defineReferral,
+  defineTracker,
+  x
+} from "./chunk-XOEREIXI.js";
 import {
   budgetSchema,
   decisionSchema,
@@ -164,6 +167,7 @@ function defineQuest(definition) {
         observation: ctx.observation ?? null,
         eligibleAt: ctx.eligibleAt,
         review: ctx.review,
+        trackers: ctx.trackers,
         wallet: ctx.wallet,
         discord: ctx.discord
       }) : decision.accept();
@@ -185,12 +189,14 @@ export {
   automatic,
   budget,
   completed,
+  customSource,
   decision,
   defineLeaderboard,
   defineQuest,
   defineQuestType,
   defineReferral,
   defineTieredReward,
+  defineTracker,
   discord,
   discordRole,
   evaluators,
@@ -203,5 +209,6 @@ export {
   settings,
   staffHandover,
   streak,
-  untracked
+  untracked,
+  x
 };

package/dist/browser.d.ts

@@ -1,6 +1,6 @@
 import { SubmitInput, ReviewListOptions, MemberListOptions, ReleaseInput, beginHandoverSchema } from './schema.js';
 import { SubmissionStore, createRelayClient, QuestView, QuestController, ProgressObservation, questExperienceSchema, ProgressObserver, ExchangeInput, PhotoSubmission, QuizSubmission, ClaimSubmission } from './index.js';
-import { r as referralAcceptSchema, L as LeaderboardQuery, w as walletChallengeInputSchema, g as walletProofSchema, h as AuthProvider } from './settings-B61jIDDA.js';
+import { r as referralAcceptSchema, L as LeaderboardQuery, w as walletChallengeInputSchema, i as walletProofSchema, j as AuthProvider } from './settings-CgI5nDQr.js';
 import * as zod from 'zod';
 
 /** Browser client with durable submission recovery; safe to construct during SSR. */
@@ -1477,7 +1477,7 @@ declare function createBrowserRelayClient(options: Parameters<typeof createRelay
                 provider: "discord";
                 action: "grant-role";
                 roleId: string;
-                status: "pending" | "delivered";
+                status: "pending" | "failed" | "delivered";
                 attempts: number;
                 nextAt: number;
                 lastError: string | null;

package/dist/browser.js

@@ -1,7 +1,7 @@
 import {
   createRelayClient
-} from "./chunk-ONDPW77O.js";
-import "./chunk-CE5XVIJQ.js";
+} from "./chunk-Y7FVHF65.js";
+import "./chunk-XOEREIXI.js";
 import "./chunk-VDWQL6HV.js";
 import "./chunk-3UOTI4IU.js";
 

package/dist/{chunk-CE5XVIJQ.js → chunk-XOEREIXI.js}

@@ -187,18 +187,133 @@ var referralManagementSchema = z2.object({
   next: amount.nullable()
 });
 
-// src/leaderboards.ts
+// src/trackers.ts
 import { z as z3 } from "zod";
-var integer = z3.number().int().safe();
-var timestamp = integer.nonnegative().max(864e13);
-var leaderboardWindowSchema = z3.discriminatedUnion("kind", [
-  z3.object({ kind: z3.literal("all-time") }).strict(),
-  z3.object({ kind: z3.literal("fixed"), start: timestamp, end: timestamp }).strict().refine((w) => w.end > w.start, "Window end must follow its start"),
-  z3.object({ kind: z3.literal("rolling"), days: integer.min(1).max(3660) }).strict(),
-  z3.object({
-    kind: z3.literal("calendar"),
-    period: z3.enum(["day", "week", "month"]),
-    timeZone: z3.string().min(1).max(100).refine((zone) => {
+var timestamp = z3.number().int().safe().nonnegative().max(864e13);
+var count = z3.number().int().safe().nonnegative();
+var externalId = z3.string().min(1).max(256);
+var metric = count.nullable().default(null);
+var xTweetSchema = z3.looseObject({
+  id: externalId,
+  userId: externalId,
+  content: z3.string(),
+  createdAt: z3.iso.datetime({ offset: true }),
+  author: z3.looseObject({
+    id: externalId,
+    username: z3.string(),
+    name: z3.string(),
+    verified: z3.boolean().nullable().default(null)
+  }),
+  likeCount: metric,
+  replyCount: metric,
+  retweetCount: metric,
+  quoteCount: metric,
+  viewCount: metric,
+  bookmarkCount: metric,
+  isReply: z3.boolean(),
+  isRetweet: z3.boolean(),
+  isQuoteTweet: z3.boolean()
+});
+var trackerSourceSchema = z3.discriminatedUnion("kind", [
+  z3.object({ kind: z3.literal("x-search"), query: z3.string().trim().min(1).max(2e3) }).strict(),
+  z3.object({ kind: z3.literal("custom"), namespace: identifier }).strict()
+]);
+var x = {
+  search: (input) => trackerSourceSchema.options[0].parse({ kind: "x-search", ...input })
+};
+var customSource = (namespace) => trackerSourceSchema.options[1].parse({ kind: "custom", namespace });
+var windowSchema = z3.object({ start: timestamp, end: timestamp.optional() }).strict().refine((w) => w.end === void 0 || w.end > w.start, "End must follow start");
+var trackerDefinitionSchema = z3.object({
+  key: identifier,
+  title: z3.string().trim().min(1).max(120),
+  source: trackerSourceSchema,
+  window: windowSchema,
+  refreshSeconds: z3.number().int().min(300).max(86400).default(21600),
+  maxPages: z3.number().int().min(1).max(1e3).default(60)
+}).strict();
+var trackerArtifactSchema = z3.union([trackerDefinitionSchema, z3.object({ code: z3.string().min(1).max(2e6) }).strict()]);
+function defineTracker(input) {
+  return trackerDefinitionSchema.parse(input);
+}
+var publishedTrackerSchema = z3.object({
+  id: identifier,
+  version: identifier,
+  definition: trackerDefinitionSchema,
+  publishedAt: timestamp,
+  actor: z3.string().nullable()
+});
+var trackerStatusSchema = z3.object({
+  published: publishedTrackerSchema,
+  paused: z3.boolean(),
+  state: z3.enum(["idle", "syncing", "error", "complete"]),
+  lastStartedAt: timestamp.nullable(),
+  lastCompletedAt: timestamp.nullable(),
+  nextSyncAt: timestamp.nullable(),
+  coverage: z3.enum(["unknown", "partial", "complete"]),
+  error: z3.string().nullable(),
+  records: count
+});
+var trackerControlSchema = z3.object({
+  actionId: identifier,
+  action: z3.enum(["pause", "resume", "refresh"])
+}).strict();
+var trackerRecordInputSchema = z3.object({
+  id: externalId,
+  occurredAt: timestamp,
+  observedAt: timestamp,
+  author: z3.object({ id: externalId, verified: z3.boolean().nullable().default(null) }).strict().nullable().default(null),
+  data: z3.record(z3.string(), z3.json()),
+  removed: z3.boolean().default(false)
+}).strict().refine((v) => new TextEncoder().encode(JSON.stringify(v.data)).byteLength <= 131072, "Record exceeds 128 KB");
+var trackerRecordSchema = trackerRecordInputSchema.safeExtend({
+  source: z3.string(),
+  firstSeenAt: timestamp
+});
+var trackerIngestSchema = z3.object({
+  actionId: identifier,
+  records: z3.array(trackerRecordInputSchema).min(1).max(100)
+}).strict();
+var trackerIngestResultSchema = z3.object({ stored: count });
+var booleanQuery = z3.union([z3.boolean(), z3.enum(["true", "false"]).transform((v) => v === "true")]);
+var trackerQuerySchema = z3.object({
+  author: externalId.optional(),
+  member: identifier.optional(),
+  verified: booleanQuery.optional(),
+  since: z3.coerce.number().int().safe().nonnegative().optional(),
+  until: z3.coerce.number().int().safe().nonnegative().optional(),
+  removed: booleanQuery.default(false),
+  minLikes: z3.coerce.number().int().safe().nonnegative().optional(),
+  minViews: z3.coerce.number().int().safe().nonnegative().optional(),
+  limit: z3.coerce.number().int().min(1).max(100).default(25),
+  cursor: z3.string().max(2048).optional()
+}).strict().refine((q) => q.since === void 0 || q.until === void 0 || q.until > q.since, "Until must follow since");
+var trackerPageSchema = z3.object({
+  tracker: identifier,
+  items: z3.array(trackerRecordSchema),
+  nextCursor: z3.string().nullable(),
+  total: count,
+  status: trackerStatusSchema
+});
+var trackerSummarySchema = z3.object({
+  records: count,
+  authors: count,
+  metrics: z3.object({ likes: count, replies: count, reposts: count, quotes: count, views: count, bookmarks: count }),
+  missingMetrics: count,
+  status: trackerStatusSchema
+});
+
+// src/leaderboards.ts
+import { z as z4 } from "zod";
+var integer = z4.number().int().safe();
+var timestamp2 = integer.nonnegative().max(864e13);
+var leaderboardWindowSchema = z4.discriminatedUnion("kind", [
+  z4.object({ kind: z4.literal("all-time") }).strict(),
+  z4.object({ kind: z4.literal("fixed"), start: timestamp2, end: timestamp2 }).strict().refine((w) => w.end > w.start, "Window end must follow its start"),
+  z4.object({ kind: z4.literal("rolling"), days: integer.min(1).max(3660) }).strict(),
+  z4.object({
+    kind: z4.literal("calendar"),
+    period: z4.enum(["day", "week", "month"]),
+    timeZone: z4.string().min(1).max(100).refine((zone) => {
       try {
         new Intl.DateTimeFormat("en", { timeZone: zone });
         return true;
@@ -210,22 +325,22 @@ var leaderboardWindowSchema = z3.discriminatedUnion("kind", [
 ]);
 var periodScore = {
   window: leaderboardWindowSchema.default({ kind: "all-time" }),
-  quests: z3.array(identifier).min(1).max(100).optional()
+  quests: z4.array(identifier).min(1).max(100).optional()
 };
-var leaderboardDefinitionSchema = z3.object({
+var leaderboardDefinitionSchema = z4.object({
   id: identifier,
   key: identifier.optional(),
-  title: z3.string().trim().min(1).max(120),
+  title: z4.string().trim().min(1).max(120),
   balance: identifier,
-  score: z3.discriminatedUnion("kind", [
-    z3.object({ kind: z3.literal("balance") }).strict(),
-    z3.object({ kind: z3.literal("earned"), ...periodScore }).strict(),
-    z3.object({
-      kind: z3.literal("net"),
+  score: z4.discriminatedUnion("kind", [
+    z4.object({ kind: z4.literal("balance") }).strict(),
+    z4.object({ kind: z4.literal("earned"), ...periodScore }).strict(),
+    z4.object({
+      kind: z4.literal("net"),
       window: leaderboardWindowSchema.default({ kind: "all-time" })
     }).strict()
   ]).default({ kind: "balance" }),
-  access: z3.enum(["participants", "public"]).default("participants"),
+  access: z4.enum(["participants", "public"]).default("participants"),
   group: identifier.optional()
 }).strict();
 var leaderboardAuthoringSchema = leaderboardDefinitionSchema.omit({ id: true }).extend(authoringIdentityShape).strict().superRefine(validateAuthoringIdentity).transform(normalizeAuthoringIdentity);
@@ -237,42 +352,42 @@ function defineLeaderboard(input) {
     id: definition.key
   };
 }
-var leaderboardArtifactSchema = z3.union([
+var leaderboardArtifactSchema = z4.union([
   leaderboardAuthoringSchema,
-  z3.object({ code: z3.string().min(1).max(2e6) }).strict()
+  z4.object({ code: z4.string().min(1).max(2e6) }).strict()
 ]);
-var publishedLeaderboardSchema = z3.object({
+var publishedLeaderboardSchema = z4.object({
   version: identifier,
   definition: leaderboardDefinitionSchema,
-  publishedAt: timestamp,
-  actor: z3.string().nullable()
+  publishedAt: timestamp2,
+  actor: z4.string().nullable()
 });
-var leaderboardQuerySchema = z3.object({
-  limit: z3.coerce.number().int().min(1).max(100).default(25),
-  cursor: z3.string().max(4096).optional()
+var leaderboardQuerySchema = z4.object({
+  limit: z4.coerce.number().int().min(1).max(100).default(25),
+  cursor: z4.string().max(4096).optional()
 }).strict();
-var leaderboardRowSchema = z3.object({
+var leaderboardRowSchema = z4.object({
   participant: identifier,
   member: identifier.optional(),
-  name: z3.string(),
+  name: z4.string(),
   score: integer,
   rank: integer.positive()
 });
-var leaderboardPageSchema = z3.object({
+var leaderboardPageSchema = z4.object({
   leaderboard: identifier,
-  title: z3.string(),
+  title: z4.string(),
   version: identifier,
-  calculation: z3.enum(["balance", "earned", "net"]),
-  period: z3.object({ start: timestamp.nullable(), end: timestamp.nullable() }),
-  calculatedAt: timestamp,
-  lastEntryAt: timestamp.nullable(),
+  calculation: z4.enum(["balance", "earned", "net"]),
+  period: z4.object({ start: timestamp2.nullable(), end: timestamp2.nullable() }),
+  calculatedAt: timestamp2,
+  lastEntryAt: timestamp2.nullable(),
   total: integer.nonnegative(),
-  items: z3.array(leaderboardRowSchema),
+  items: z4.array(leaderboardRowSchema),
   me: leaderboardRowSchema.nullable(),
-  nearby: z3.array(leaderboardRowSchema),
-  nextCursor: z3.string().nullable()
+  nearby: z4.array(leaderboardRowSchema),
+  nextCursor: z4.string().nullable()
 });
-var leaderboardPreviewSchema = z3.object({
+var leaderboardPreviewSchema = z4.object({
   published: publishedLeaderboardSchema,
   before: leaderboardPageSchema.nullable(),
   after: leaderboardPageSchema
@@ -281,75 +396,75 @@ var mutationBase = {
   actionId: identifier,
   member: identifier,
   balance: identifier,
-  reason: z3.string().trim().min(1).max(1e3)
+  reason: z4.string().trim().min(1).max(1e3)
 };
-var datedMutation = { ...mutationBase, effectiveAt: timestamp.optional() };
-var pointsMutationSchema = z3.discriminatedUnion("kind", [
-  z3.object({
+var datedMutation = { ...mutationBase, effectiveAt: timestamp2.optional() };
+var pointsMutationSchema = z4.discriminatedUnion("kind", [
+  z4.object({
     ...datedMutation,
-    kind: z3.literal("award"),
-    referralEligible: z3.boolean().optional(),
+    kind: z4.literal("award"),
+    referralEligible: z4.boolean().optional(),
     amount: integer.positive()
   }).strict(),
-  z3.object({
+  z4.object({
     ...datedMutation,
-    kind: z3.literal("spend"),
+    kind: z4.literal("spend"),
     amount: integer.positive()
   }).strict(),
-  z3.object({
+  z4.object({
     ...datedMutation,
-    kind: z3.literal("adjust"),
+    kind: z4.literal("adjust"),
     amount: integer.refine((n) => n !== 0)
   }).strict(),
-  z3.object({
+  z4.object({
     ...datedMutation,
-    kind: z3.literal("set"),
+    kind: z4.literal("set"),
     total: integer.nonnegative(),
     expectedTotal: integer.nonnegative(),
-    classification: z3.enum(["earned", "spend"])
+    classification: z4.enum(["earned", "spend"])
   }).strict(),
-  z3.object({
+  z4.object({
     ...mutationBase,
-    kind: z3.literal("reverse"),
+    kind: z4.literal("reverse"),
     entry: identifier,
     amount: integer.positive()
   }).strict()
 ]);
-var pointsEntrySchema = z3.object({
+var pointsEntrySchema = z4.object({
   id: identifier,
-  completion: z3.string().nullable(),
+  completion: z4.string().nullable(),
   member: identifier,
   balance: identifier,
   amount: integer,
-  kind: z3.enum(["award", "spend", "adjust", "reverse"]),
-  effectiveAt: timestamp,
-  receivedAt: timestamp,
+  kind: z4.enum(["award", "spend", "adjust", "reverse"]),
+  effectiveAt: timestamp2,
+  receivedAt: timestamp2,
   quest: identifier.nullable(),
   original: identifier.nullable(),
-  reason: z3.string(),
-  actor: z3.string().nullable()
+  reason: z4.string(),
+  actor: z4.string().nullable()
 });
-var pointsResultSchema = z3.object({
+var pointsResultSchema = z4.object({
   entry: pointsEntrySchema,
   total: integer.nonnegative()
 });
-var pointsAccountSchema = z3.object({
+var pointsAccountSchema = z4.object({
   member: identifier,
   balance: identifier,
   total: integer.nonnegative(),
   held: integer.nonnegative()
 });
-var leaderboardExclusionSchema = z3.object({
+var leaderboardExclusionSchema = z4.object({
   actionId: identifier,
   member: identifier,
-  excluded: z3.boolean(),
-  reason: z3.string().trim().min(1).max(1e3)
+  excluded: z4.boolean(),
+  reason: z4.string().trim().min(1).max(1e3)
 }).strict();
-var leaderboardGroupSchema = z3.object({
+var leaderboardGroupSchema = z4.object({
   actionId: identifier,
   member: identifier,
-  included: z3.boolean(),
-  reason: z3.string().trim().min(1).max(1e3)
+  included: z4.boolean(),
+  reason: z4.string().trim().min(1).max(1e3)
 }).strict();
 
 export {
@@ -369,6 +484,23 @@ export {
   referralSummarySchema,
   referralHistorySchema,
   referralManagementSchema,
+  xTweetSchema,
+  trackerSourceSchema,
+  x,
+  customSource,
+  trackerDefinitionSchema,
+  trackerArtifactSchema,
+  defineTracker,
+  publishedTrackerSchema,
+  trackerStatusSchema,
+  trackerControlSchema,
+  trackerRecordInputSchema,
+  trackerRecordSchema,
+  trackerIngestSchema,
+  trackerIngestResultSchema,
+  trackerQuerySchema,
+  trackerPageSchema,
+  trackerSummarySchema,
   leaderboardWindowSchema,
   leaderboardDefinitionSchema,
   leaderboardAuthoringSchema,

package/dist/{chunk-ONDPW77O.js → chunk-Y7FVHF65.js}

@@ -7,13 +7,15 @@ import {
   leaderboardQuerySchema,
   normalizeAuthoringIdentity,
   publishedReferralSchema,
+  publishedTrackerSchema,
   referralAcceptSchema,
   referralArtifactSchema,
   referralDefinitionSchema,
   referralHistorySchema,
   referralSummarySchema,
+  trackerArtifactSchema,
   validateAuthoringIdentity
-} from "./chunk-CE5XVIJQ.js";
+} from "./chunk-XOEREIXI.js";
 import {
   authScopeSchema,
   exchangeResultSchema,
@@ -67,8 +69,15 @@ var rewardDeliverySchema = z2.object({
   provider: z2.literal("discord"),
   action: z2.literal("grant-role"),
   roleId: z2.string(),
-  status: z2.enum(["pending", "delivered"]),
+  /**
+   * `failed` is terminal: Discord rejected the grant permanently (unknown role,
+   * member left the server, missing permissions) or retries ran out after
+   * about a day. An operator can retry it once the cause is fixed.
+   */
+  status: z2.enum(["pending", "delivered", "failed"]),
+  /** Provider attempts in the current round; an operator retry starts a new round at zero. */
   attempts: z2.number().int(),
+  /** While pending with a `lastError`, when the next attempt is scheduled. */
   nextAt: z2.number(),
   lastError: z2.string().nullable(),
   createdAt: z2.number(),
@@ -732,16 +741,18 @@ function questConfiguration(release) {
 // src/deployments.ts
 import { z as z7 } from "zod";
 var projectCatalogArtifactSchema = catalogDeploymentSchema.omit({ expectedRevision: true }).extend({
+  trackers: z7.array(trackerArtifactSchema).max(50).default([]),
   pointLedgers: z7.array(pointLedgerDeclarationSchema).max(50).default([]),
   referrals: z7.array(referralArtifactSchema).max(50).default([]),
   leaderboards: z7.array(leaderboardArtifactSchema).max(50).default([])
 });
 var projectDeploymentSchema = projectCatalogArtifactSchema.extend({ releases: z7.array(releaseSchema).max(50).default([]) }).refine(
-  (value) => value.pointLedgers.length > 0 || value.releases.length > 0 || value.leaderboards.length > 0 || value.referrals.length > 0 || value.types.length > 0 || value.collections.length > 0 || value.supportedInteractions !== void 0,
-  "No resources configured. Add quests, questTypes, pointLedgers, leaderboards, referrals, collections, or supportedInteractions to relay.json."
+  (value) => value.trackers.length > 0 || value.pointLedgers.length > 0 || value.releases.length > 0 || value.leaderboards.length > 0 || value.referrals.length > 0 || value.types.length > 0 || value.collections.length > 0 || value.supportedInteractions !== void 0,
+  "No resources configured. Add trackers, quests, questTypes, pointLedgers, leaderboards, referrals, collections, or supportedInteractions to relay.json."
 );
 var deploymentPreviewSchema = z7.object({
   id: identifier,
+  trackers: z7.array(publishedTrackerSchema).default([]),
   baseRevision: z7.number().int().nonnegative(),
   pointLedgers: z7.array(pointLedgerSchema).default([]),
   releases: z7.array(publishedReleaseSchema),

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 import { errorSchema, QuizEvidence, Attempt, SubmitInput, MemberProgress, questDescriptionSchema, PublishedRelease, ReviewListOptions, MemberListOptions, ReleaseInput, beginHandoverSchema } from './schema.js';
 export { Decision, Entitlement, MemberPage, PhotoResult, PickupAvailability, QuestAvailability, QuestDescription, QuestPresentation, QuestSettingsInput, ReviewPage, Reward, Snapshot, TieredRewardDefinition, artifactSchema, attemptSchema, batchReleaseSchema, completionRecordSchema, configurePickupSchema, confirmHandoverSchema, createStockItemSchema, decisionSchema, entitlementSchema, eventSchema, evidenceSchema, identifier, integrationRewardSchema, mediaUrlSchema, memberListSchema, memberPageSchema, memberProgressSchema, photoResultSchema, pickupAllocationSchema, pickupAvailabilitySchema, pickupCatalogSchema, pickupPolicySchema, pickupSelectionSchema, pointsRewardSchema, prerequisiteSchema, publishedReleaseSchema, questAvailabilitySchema, questPresentationSchema, questSettingsInputSchema, quizAnswersSchema, quizEvidenceSchema, releaseSchema, reservationSchema, reviewItemSchema, reviewListSchema, reviewModeSchema, reviewPageSchema, rewardBundleSchema, rewardKey, rewardSchema, snapshotSchema, staffDecisionSchema, stockItemSchema, stockSchema, storedReviewModeSchema, submitSchema, templateSchema, tierRewardSchema, tieredRewardDefinitionSchema, triggerSchema } from './schema.js';
-import { r as referralAcceptSchema, L as LeaderboardQuery, w as walletChallengeInputSchema, g as walletProofSchema, h as AuthProvider } from './settings-B61jIDDA.js';
-export { i as AccountConnection, B as Budget, D as DiscordMember, a as DiscordMessage, I as IntegrationProvider, j as LeaderboardDefinition, k as LeaderboardPage, O as Observation, P as ProjectIntegration, Q as QuizContent, R as ReferralDefinition, l as ResourceOption, m as ResourceSource, n as SettingField, q as SettingsValues, S as SolanaBalance, b as StreakPolicy, t as StreakProgress, W as WalletConnection, u as accountConnectionSchema, v as authProviderSchema, x as budgetSchema, y as communityTimeZoneSchema, z as compatibleSettingKinds, C as completionKeySchema, E as completionPolicySchema, d as defineLeaderboard, c as defineReferral, e as discord, F as discordMemberInputSchema, G as discordMemberSchema, H as discordMessageInputSchema, J as discordMessageSchema, K as discordReactionSchema, M as discordServerSchema, N as integrationProviderSchema, T as leaderboardArtifactSchema, U as leaderboardAuthoringSchema, V as leaderboardDefinitionSchema, X as leaderboardExclusionSchema, Y as leaderboardGroupSchema, Z as leaderboardPageSchema, _ as leaderboardPreviewSchema, $ as leaderboardQuerySchema, a0 as leaderboardRowSchema, a1 as leaderboardWindowSchema, a2 as missingResourceSettings, a3 as observationInputSchema, a4 as observationReceiptSchema, a5 as observationSchema, o as observationTriggerSchema, a6 as parseSettings, p as pointLedgers, a7 as pointsAccountSchema, a8 as pointsEntrySchema, a9 as pointsMutationSchema, aa as pointsResultSchema, ab as projectIntegrationSchema, ac as publishedLeaderboardSchema, ad as publishedReferralSchema, ae as quizChoiceSchema, af as quizContentSchema, ag as quizQuestionSchema, ah as quizQuestionsSchema, ai as referralAccountSchema, aj as referralArtifactSchema, ak as referralAuthoringSchema, al as referralControlSchema, am as referralDefinitionSchema, an as referralHistorySchema, ao as referralManagementSchema, ap as referralRelationshipSchema, aq as referralSummarySchema, ar as resourceOptionsSchema, as as resourceRequestSchema, at as resourceSourceSchema, au as settingFieldSchema, s as settings, av as settingsFieldsSchema, aw as settingsValuesSchema, ax as solanaAddressSchema, ay as solanaBalanceSchema, f as streak, az as streakPolicySchema, aA as streakProgressSchema, aB as walletChallengeSchema, aC as walletConnectionSchema } from './settings-B61jIDDA.js';
+import { r as referralAcceptSchema, L as LeaderboardQuery, w as walletChallengeInputSchema, i as walletProofSchema, j as AuthProvider } from './settings-CgI5nDQr.js';
+export { k as AccountConnection, B as Budget, D as DiscordMember, a as DiscordMessage, I as IntegrationProvider, l as LeaderboardDefinition, m as LeaderboardPage, O as Observation, P as ProjectIntegration, Q as QuizContent, R as ReferralDefinition, n as ResourceOption, q as ResourceSource, t as SettingField, u as SettingsValues, S as SolanaBalance, b as StreakPolicy, v as StreakProgress, y as TrackerDefinition, z as TrackerQuery, T as TrackerReader, C as TrackerRecord, E as TrackerStatus, W as WalletConnection, X as XTweet, F as accountConnectionSchema, G as authProviderSchema, H as budgetSchema, J as communityTimeZoneSchema, K as compatibleSettingKinds, M as completionKeySchema, N as completionPolicySchema, c as customSource, d as defineLeaderboard, e as defineReferral, f as defineTracker, g as discord, U as discordMemberInputSchema, V as discordMemberSchema, Y as discordMessageInputSchema, Z as discordMessageSchema, _ as discordReactionSchema, $ as discordServerSchema, a0 as integrationProviderSchema, a1 as leaderboardArtifactSchema, a2 as leaderboardAuthoringSchema, a3 as leaderboardDefinitionSchema, a4 as leaderboardExclusionSchema, a5 as leaderboardGroupSchema, a6 as leaderboardPageSchema, a7 as leaderboardPreviewSchema, a8 as leaderboardQuerySchema, a9 as leaderboardRowSchema, aa as leaderboardWindowSchema, ab as missingResourceSettings, ac as observationInputSchema, ad as observationReceiptSchema, ae as observationSchema, o as observationTriggerSchema, af as parseSettings, p as pointLedgers, ag as pointsAccountSchema, ah as pointsEntrySchema, ai as pointsMutationSchema, aj as pointsResultSchema, ak as projectIntegrationSchema, al as publishedLeaderboardSchema, am as publishedReferralSchema, an as publishedTrackerSchema, ao as quizChoiceSchema, ap as quizContentSchema, aq as quizQuestionSchema, ar as quizQuestionsSchema, as as referralAccountSchema, at as referralArtifactSchema, au as referralAuthoringSchema, av as referralControlSchema, aw as referralDefinitionSchema, ax as referralHistorySchema, ay as referralManagementSchema, az as referralRelationshipSchema, aA as referralSummarySchema, aB as resourceOptionsSchema, aC as resourceRequestSchema, aD as resourceSourceSchema, aE as settingFieldSchema, s as settings, aF as settingsFieldsSchema, aG as settingsValuesSchema, aH as solanaAddressSchema, aI as solanaBalanceSchema, h as streak, aJ as streakPolicySchema, aK as streakProgressSchema, aL as trackerArtifactSchema, aM as trackerControlSchema, aN as trackerDefinitionSchema, aO as trackerIngestResultSchema, aP as trackerIngestSchema, aQ as trackerPageSchema, aR as trackerQuerySchema, aS as trackerRecordInputSchema, aT as trackerRecordSchema, aU as trackerSourceSchema, aV as trackerStatusSchema, aW as trackerSummarySchema, aX as walletChallengeSchema, aY as walletConnectionSchema, x, aZ as xTweetSchema } from './settings-CgI5nDQr.js';
 
 declare class RelayError extends Error {
     readonly status: number;
@@ -3100,6 +3100,7 @@ declare const rewardDeliverySchema: z.ZodObject<{
     roleId: z.ZodString;
     status: z.ZodEnum<{
         pending: "pending";
+        failed: "failed";
         delivered: "delivered";
     }>;
     attempts: z.ZodNumber;
@@ -3119,6 +3120,7 @@ declare const rewardDeliveriesSchema: z.ZodObject<{
         roleId: z.ZodString;
         status: z.ZodEnum<{
             pending: "pending";
+            failed: "failed";
             delivered: "delivered";
         }>;
         attempts: z.ZodNumber;
@@ -3293,6 +3295,25 @@ declare const projectCatalogArtifactSchema: z.ZodObject<{
         automatic: "automatic";
         claim: "claim";
     }>>>;
+    trackers: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        key: z.ZodString;
+        title: z.ZodString;
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"x-search">;
+            query: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"custom">;
+            namespace: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        window: z.ZodObject<{
+            start: z.ZodNumber;
+            end: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        refreshSeconds: z.ZodDefault<z.ZodNumber>;
+        maxPages: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        code: z.ZodString;
+    }, z.core.$strict>]>>>;
     pointLedgers: z.ZodDefault<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         description: z.ZodDefault<z.ZodString>;
@@ -3764,6 +3785,25 @@ declare const projectDeploymentSchema: z.ZodObject<{
         automatic: "automatic";
         claim: "claim";
     }>>>;
+    trackers: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        key: z.ZodString;
+        title: z.ZodString;
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"x-search">;
+            query: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"custom">;
+            namespace: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        window: z.ZodObject<{
+            start: z.ZodNumber;
+            end: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        refreshSeconds: z.ZodDefault<z.ZodNumber>;
+        maxPages: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        code: z.ZodString;
+    }, z.core.$strict>]>>>;
     pointLedgers: z.ZodDefault<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         description: z.ZodDefault<z.ZodString>;
@@ -4224,6 +4264,29 @@ declare const projectDeploymentSchema: z.ZodObject<{
 }, z.core.$strict>;
 declare const deploymentPreviewSchema: z.ZodObject<{
     id: z.ZodString;
+    trackers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        definition: z.ZodObject<{
+            key: z.ZodString;
+            title: z.ZodString;
+            source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"x-search">;
+                query: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"custom">;
+                namespace: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            window: z.ZodObject<{
+                start: z.ZodNumber;
+                end: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+            refreshSeconds: z.ZodDefault<z.ZodNumber>;
+            maxPages: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>;
+        publishedAt: z.ZodNumber;
+        actor: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
     baseRevision: z.ZodNumber;
     pointLedgers: z.ZodDefault<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -5187,6 +5250,29 @@ declare const publishDeploymentSchema: z.ZodObject<{
 }, z.core.$strict>;
 declare const deploymentResultSchema: z.ZodObject<{
     id: z.ZodString;
+    trackers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        definition: z.ZodObject<{
+            key: z.ZodString;
+            title: z.ZodString;
+            source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"x-search">;
+                query: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"custom">;
+                namespace: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            window: z.ZodObject<{
+                start: z.ZodNumber;
+                end: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+            refreshSeconds: z.ZodDefault<z.ZodNumber>;
+            maxPages: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>;
+        publishedAt: z.ZodNumber;
+        actor: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
     baseRevision: z.ZodNumber;
     pointLedgers: z.ZodDefault<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -7664,7 +7750,7 @@ declare function createRelayClient(options: {
                 provider: "discord";
                 action: "grant-role";
                 roleId: string;
-                status: "pending" | "delivered";
+                status: "pending" | "failed" | "delivered";
                 attempts: number;
                 nextAt: number;
                 lastError: string | null;

package/dist/index.js

@@ -51,10 +51,12 @@ import {
   walletChallengeSchema,
   walletConnectionSchema,
   walletProofSchema
-} from "./chunk-ONDPW77O.js";
+} from "./chunk-Y7FVHF65.js";
 import {
+  customSource,
   defineLeaderboard,
   defineReferral,
+  defineTracker,
   leaderboardArtifactSchema,
   leaderboardAuthoringSchema,
   leaderboardDefinitionSchema,
@@ -71,6 +73,7 @@ import {
   pointsResultSchema,
   publishedLeaderboardSchema,
   publishedReferralSchema,
+  publishedTrackerSchema,
   referralAcceptSchema,
   referralAccountSchema,
   referralArtifactSchema,
@@ -80,8 +83,22 @@ import {
   referralHistorySchema,
   referralManagementSchema,
   referralRelationshipSchema,
-  referralSummarySchema
-} from "./chunk-CE5XVIJQ.js";
+  referralSummarySchema,
+  trackerArtifactSchema,
+  trackerControlSchema,
+  trackerDefinitionSchema,
+  trackerIngestResultSchema,
+  trackerIngestSchema,
+  trackerPageSchema,
+  trackerQuerySchema,
+  trackerRecordInputSchema,
+  trackerRecordSchema,
+  trackerSourceSchema,
+  trackerStatusSchema,
+  trackerSummarySchema,
+  x,
+  xTweetSchema
+} from "./chunk-XOEREIXI.js";
 import {
   authScopeSchema,
   exchangeResultSchema,
@@ -214,9 +231,11 @@ export {
   createPointLedgerSchema,
   createRelayClient,
   createStockItemSchema,
+  customSource,
   decisionSchema,
   defineLeaderboard,
   defineReferral,
+  defineTracker,
   deploymentPreviewSchema,
   deploymentResultSchema,
   discord,
@@ -285,6 +304,7 @@ export {
   publishedLeaderboardSchema,
   publishedReferralSchema,
   publishedReleaseSchema,
+  publishedTrackerSchema,
   questActions,
   questAvailabilitySchema,
   questCatalogSchema,
@@ -352,9 +372,23 @@ export {
   templateSchema,
   tierRewardSchema,
   tieredRewardDefinitionSchema,
+  trackerArtifactSchema,
+  trackerControlSchema,
+  trackerDefinitionSchema,
+  trackerIngestResultSchema,
+  trackerIngestSchema,
+  trackerPageSchema,
+  trackerQuerySchema,
+  trackerRecordInputSchema,
+  trackerRecordSchema,
+  trackerSourceSchema,
+  trackerStatusSchema,
+  trackerSummarySchema,
   triggerSchema,
   walletChallengeInputSchema,
   walletChallengeSchema,
   walletConnectionSchema,
-  walletProofSchema
+  walletProofSchema,
+  x,
+  xTweetSchema
 };

package/dist/{settings-B61jIDDA.d.ts → settings-CgI5nDQr.d.ts}

@@ -1,5 +1,345 @@
 import { z } from 'zod';
 
+/** Keep provider fields, including verification details, rather than projecting them away. */
+declare const xTweetSchema: z.ZodObject<{
+    id: z.ZodString;
+    userId: z.ZodString;
+    content: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    author: z.ZodObject<{
+        id: z.ZodString;
+        username: z.ZodString;
+        name: z.ZodString;
+        verified: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$loose>;
+    likeCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    replyCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    retweetCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    quoteCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    viewCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    bookmarkCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    isReply: z.ZodBoolean;
+    isRetweet: z.ZodBoolean;
+    isQuoteTweet: z.ZodBoolean;
+}, z.core.$loose>;
+type XTweet = z.infer<typeof xTweetSchema>;
+declare const trackerSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"x-search">;
+    query: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"custom">;
+    namespace: z.ZodString;
+}, z.core.$strict>], "kind">;
+declare const x: {
+    search: (input: {
+        query: string;
+    }) => {
+        kind: "x-search";
+        query: string;
+    };
+};
+declare const customSource: (namespace: string) => {
+    kind: "custom";
+    namespace: string;
+};
+declare const trackerDefinitionSchema: z.ZodObject<{
+    key: z.ZodString;
+    title: z.ZodString;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"x-search">;
+        query: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"custom">;
+        namespace: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    window: z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    refreshSeconds: z.ZodDefault<z.ZodNumber>;
+    maxPages: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+declare const trackerArtifactSchema: z.ZodUnion<readonly [z.ZodObject<{
+    key: z.ZodString;
+    title: z.ZodString;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"x-search">;
+        query: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"custom">;
+        namespace: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    window: z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    refreshSeconds: z.ZodDefault<z.ZodNumber>;
+    maxPages: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    code: z.ZodString;
+}, z.core.$strict>]>;
+type TrackerDefinition = z.infer<typeof trackerDefinitionSchema>;
+declare function defineTracker(input: z.input<typeof trackerDefinitionSchema>): TrackerDefinition;
+declare const publishedTrackerSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    definition: z.ZodObject<{
+        key: z.ZodString;
+        title: z.ZodString;
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"x-search">;
+            query: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"custom">;
+            namespace: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        window: z.ZodObject<{
+            start: z.ZodNumber;
+            end: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        refreshSeconds: z.ZodDefault<z.ZodNumber>;
+        maxPages: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    publishedAt: z.ZodNumber;
+    actor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const trackerStatusSchema: z.ZodObject<{
+    published: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        definition: z.ZodObject<{
+            key: z.ZodString;
+            title: z.ZodString;
+            source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"x-search">;
+                query: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"custom">;
+                namespace: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            window: z.ZodObject<{
+                start: z.ZodNumber;
+                end: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+            refreshSeconds: z.ZodDefault<z.ZodNumber>;
+            maxPages: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>;
+        publishedAt: z.ZodNumber;
+        actor: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    paused: z.ZodBoolean;
+    state: z.ZodEnum<{
+        error: "error";
+        idle: "idle";
+        syncing: "syncing";
+        complete: "complete";
+    }>;
+    lastStartedAt: z.ZodNullable<z.ZodNumber>;
+    lastCompletedAt: z.ZodNullable<z.ZodNumber>;
+    nextSyncAt: z.ZodNullable<z.ZodNumber>;
+    coverage: z.ZodEnum<{
+        unknown: "unknown";
+        complete: "complete";
+        partial: "partial";
+    }>;
+    error: z.ZodNullable<z.ZodString>;
+    records: z.ZodNumber;
+}, z.core.$strip>;
+type TrackerStatus = z.infer<typeof trackerStatusSchema>;
+declare const trackerControlSchema: z.ZodObject<{
+    actionId: z.ZodString;
+    action: z.ZodEnum<{
+        pause: "pause";
+        resume: "resume";
+        refresh: "refresh";
+    }>;
+}, z.core.$strict>;
+declare const trackerRecordInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    occurredAt: z.ZodNumber;
+    observedAt: z.ZodNumber;
+    author: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        verified: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strict>>>;
+    data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    removed: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+declare const trackerRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    occurredAt: z.ZodNumber;
+    observedAt: z.ZodNumber;
+    author: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        verified: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strict>>>;
+    data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    removed: z.ZodDefault<z.ZodBoolean>;
+    source: z.ZodString;
+    firstSeenAt: z.ZodNumber;
+}, z.core.$strict>;
+type TrackerRecord = z.infer<typeof trackerRecordSchema>;
+declare const trackerIngestSchema: z.ZodObject<{
+    actionId: z.ZodString;
+    records: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        occurredAt: z.ZodNumber;
+        observedAt: z.ZodNumber;
+        author: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            verified: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$strict>>>;
+        data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        removed: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const trackerIngestResultSchema: z.ZodObject<{
+    stored: z.ZodNumber;
+}, z.core.$strip>;
+declare const trackerQuerySchema: 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>;
+}, z.core.$strict>;
+type TrackerQuery = z.input<typeof trackerQuerySchema>;
+declare const trackerPageSchema: z.ZodObject<{
+    tracker: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        occurredAt: z.ZodNumber;
+        observedAt: z.ZodNumber;
+        author: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            verified: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$strict>>>;
+        data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        removed: z.ZodDefault<z.ZodBoolean>;
+        source: z.ZodString;
+        firstSeenAt: z.ZodNumber;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    total: z.ZodNumber;
+    status: z.ZodObject<{
+        published: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            definition: z.ZodObject<{
+                key: z.ZodString;
+                title: z.ZodString;
+                source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"x-search">;
+                    query: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"custom">;
+                    namespace: z.ZodString;
+                }, z.core.$strict>], "kind">;
+                window: z.ZodObject<{
+                    start: z.ZodNumber;
+                    end: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>;
+                refreshSeconds: z.ZodDefault<z.ZodNumber>;
+                maxPages: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>;
+            publishedAt: z.ZodNumber;
+            actor: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        paused: z.ZodBoolean;
+        state: z.ZodEnum<{
+            error: "error";
+            idle: "idle";
+            syncing: "syncing";
+            complete: "complete";
+        }>;
+        lastStartedAt: z.ZodNullable<z.ZodNumber>;
+        lastCompletedAt: z.ZodNullable<z.ZodNumber>;
+        nextSyncAt: z.ZodNullable<z.ZodNumber>;
+        coverage: z.ZodEnum<{
+            unknown: "unknown";
+            complete: "complete";
+            partial: "partial";
+        }>;
+        error: z.ZodNullable<z.ZodString>;
+        records: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const trackerSummarySchema: z.ZodObject<{
+    records: z.ZodNumber;
+    authors: z.ZodNumber;
+    metrics: z.ZodObject<{
+        likes: z.ZodNumber;
+        replies: z.ZodNumber;
+        reposts: z.ZodNumber;
+        quotes: z.ZodNumber;
+        views: z.ZodNumber;
+        bookmarks: z.ZodNumber;
+    }, z.core.$strip>;
+    missingMetrics: z.ZodNumber;
+    status: z.ZodObject<{
+        published: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            definition: z.ZodObject<{
+                key: z.ZodString;
+                title: z.ZodString;
+                source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"x-search">;
+                    query: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"custom">;
+                    namespace: z.ZodString;
+                }, z.core.$strict>], "kind">;
+                window: z.ZodObject<{
+                    start: z.ZodNumber;
+                    end: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>;
+                refreshSeconds: z.ZodDefault<z.ZodNumber>;
+                maxPages: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>;
+            publishedAt: z.ZodNumber;
+            actor: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        paused: z.ZodBoolean;
+        state: z.ZodEnum<{
+            error: "error";
+            idle: "idle";
+            syncing: "syncing";
+            complete: "complete";
+        }>;
+        lastStartedAt: z.ZodNullable<z.ZodNumber>;
+        lastCompletedAt: z.ZodNullable<z.ZodNumber>;
+        nextSyncAt: z.ZodNullable<z.ZodNumber>;
+        coverage: z.ZodEnum<{
+            unknown: "unknown";
+            complete: "complete";
+            partial: "partial";
+        }>;
+        error: z.ZodNullable<z.ZodString>;
+        records: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** Read-only capabilities in hosted quest evaluation; results are captured for replay. */
+type TrackerReader = {
+    records(reference: string | {
+        key: string;
+    }, query?: TrackerQuery): Promise<z.infer<typeof trackerPageSchema>>;
+    summary(reference: string | {
+        key: string;
+    }, query?: TrackerQuery): Promise<z.infer<typeof trackerSummarySchema>>;
+};
+
 declare const communityTimeZoneSchema: z.ZodString;
 declare const streakPolicySchema: z.ZodObject<{
     kind: z.ZodLiteral<"streak">;
@@ -2384,4 +2724,4 @@ declare function parseSettings(fields: Record<string, SettingField>, input: unkn
 declare function missingResourceSettings(fields: Record<string, SettingField>, values: SettingsValues): string[];
 declare function compatibleSettingKinds(previous: SettingField, next: SettingField): boolean;
 
-export { leaderboardQuerySchema as $, type AuthoringIdentity as A, type Budget as B, completionKeySchema as C, type DiscordMember as D, completionPolicySchema as E, discordMemberInputSchema as F, discordMemberSchema as G, discordMessageInputSchema as H, type IntegrationProvider as I, discordMessageSchema as J, discordReactionSchema as K, type LeaderboardQuery as L, discordServerSchema as M, integrationProviderSchema as N, type Observation as O, type ProjectIntegration as P, type QuizContent as Q, type ReferralDefinition as R, type SolanaBalance as S, leaderboardArtifactSchema as T, leaderboardAuthoringSchema as U, leaderboardDefinitionSchema as V, type WalletConnection as W, leaderboardExclusionSchema as X, leaderboardGroupSchema as Y, leaderboardPageSchema as Z, leaderboardPreviewSchema as _, type DiscordMessage as a, leaderboardRowSchema as a0, leaderboardWindowSchema as a1, missingResourceSettings as a2, observationInputSchema as a3, observationReceiptSchema as a4, observationSchema as a5, parseSettings as a6, pointsAccountSchema as a7, pointsEntrySchema as a8, pointsMutationSchema as a9, streakProgressSchema as aA, walletChallengeSchema as aB, walletConnectionSchema as aC, pointsResultSchema as aa, projectIntegrationSchema as ab, publishedLeaderboardSchema as ac, publishedReferralSchema as ad, quizChoiceSchema as ae, quizContentSchema as af, quizQuestionSchema as ag, quizQuestionsSchema as ah, referralAccountSchema as ai, referralArtifactSchema as aj, referralAuthoringSchema as ak, referralControlSchema as al, referralDefinitionSchema as am, referralHistorySchema as an, referralManagementSchema as ao, referralRelationshipSchema as ap, referralSummarySchema as aq, resourceOptionsSchema as ar, resourceRequestSchema as as, resourceSourceSchema as at, settingFieldSchema as au, settingsFieldsSchema as av, settingsValuesSchema as aw, solanaAddressSchema as ax, solanaBalanceSchema as ay, streakPolicySchema as az, type StreakPolicy as b, defineReferral as c, defineLeaderboard as d, discord as e, streak as f, walletProofSchema as g, type AuthProvider as h, type AccountConnection as i, type LeaderboardDefinition as j, type LeaderboardPage as k, type ResourceOption as l, type ResourceSource as m, type SettingField as n, observationTriggerSchema as o, pointLedgers as p, type SettingsValues as q, referralAcceptSchema as r, settings as s, type StreakProgress as t, accountConnectionSchema as u, authProviderSchema as v, walletChallengeInputSchema as w, budgetSchema as x, communityTimeZoneSchema as y, compatibleSettingKinds as z };
+export { discordServerSchema as $, type AuthoringIdentity as A, type Budget as B, type TrackerRecord as C, type DiscordMember as D, type TrackerStatus as E, accountConnectionSchema as F, authProviderSchema as G, budgetSchema as H, type IntegrationProvider as I, communityTimeZoneSchema as J, compatibleSettingKinds as K, type LeaderboardQuery as L, completionKeySchema as M, completionPolicySchema as N, type Observation as O, type ProjectIntegration as P, type QuizContent as Q, type ReferralDefinition as R, type SolanaBalance as S, type TrackerReader as T, discordMemberInputSchema as U, discordMemberSchema as V, type WalletConnection as W, type XTweet as X, discordMessageInputSchema as Y, discordMessageSchema as Z, discordReactionSchema as _, type DiscordMessage as a, integrationProviderSchema as a0, leaderboardArtifactSchema as a1, leaderboardAuthoringSchema as a2, leaderboardDefinitionSchema as a3, leaderboardExclusionSchema as a4, leaderboardGroupSchema as a5, leaderboardPageSchema as a6, leaderboardPreviewSchema as a7, leaderboardQuerySchema as a8, leaderboardRowSchema as a9, referralSummarySchema as aA, resourceOptionsSchema as aB, resourceRequestSchema as aC, resourceSourceSchema as aD, settingFieldSchema as aE, settingsFieldsSchema as aF, settingsValuesSchema as aG, solanaAddressSchema as aH, solanaBalanceSchema as aI, streakPolicySchema as aJ, streakProgressSchema as aK, trackerArtifactSchema as aL, trackerControlSchema as aM, trackerDefinitionSchema as aN, trackerIngestResultSchema as aO, trackerIngestSchema as aP, trackerPageSchema as aQ, trackerQuerySchema as aR, trackerRecordInputSchema as aS, trackerRecordSchema as aT, trackerSourceSchema as aU, trackerStatusSchema as aV, trackerSummarySchema as aW, walletChallengeSchema as aX, walletConnectionSchema as aY, xTweetSchema as aZ, leaderboardWindowSchema as aa, missingResourceSettings as ab, observationInputSchema as ac, observationReceiptSchema as ad, observationSchema as ae, parseSettings as af, pointsAccountSchema as ag, pointsEntrySchema as ah, pointsMutationSchema as ai, pointsResultSchema as aj, projectIntegrationSchema as ak, publishedLeaderboardSchema as al, publishedReferralSchema as am, publishedTrackerSchema as an, quizChoiceSchema as ao, quizContentSchema as ap, quizQuestionSchema as aq, quizQuestionsSchema as ar, referralAccountSchema as as, referralArtifactSchema as at, referralAuthoringSchema as au, referralControlSchema as av, referralDefinitionSchema as aw, referralHistorySchema as ax, referralManagementSchema as ay, referralRelationshipSchema as az, type StreakPolicy as b, customSource as c, defineLeaderboard as d, defineReferral as e, defineTracker as f, discord as g, streak as h, walletProofSchema as i, type AuthProvider as j, type AccountConnection as k, type LeaderboardDefinition as l, type LeaderboardPage as m, type ResourceOption as n, observationTriggerSchema as o, pointLedgers as p, type ResourceSource as q, referralAcceptSchema as r, settings as s, type SettingField as t, type SettingsValues as u, type StreakProgress as v, walletChallengeInputSchema as w, x, type TrackerDefinition as y, type TrackerQuery as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domino-sdk/relay",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "type": "module",
   "exports": {
     ".": {