@domino-sdk/relay 1.62.0 → 1.65.0

package/dist/testing.js

@@ -1,41 +1,31 @@
 import {
   attemptCaptureSchema
-} from "./chunk-XNKSSE32.js";
-import {
-  CapabilityError
-} from "./chunk-4OC7REYX.js";
+} from "./chunk-4NIV4NPV.js";
 import {
   parseImageResult
-} from "./chunk-E6IKQHTX.js";
+} from "./chunk-EDNKKVGU.js";
+import {
+  isParticipantRoute
+} from "./chunk-U66GUVSG.js";
 import {
   imageRequestSchema,
   xConnectionSchema,
   xPostSchema,
   xProfileSchema,
   xRequestSchema
-} from "./chunk-QYPMPWVX.js";
+} from "./chunk-XVZ4YOF2.js";
 import {
-  isParticipantRoute
-} from "./chunk-CZFXGGEK.js";
+  CapabilityError
+} from "./chunk-MWMCQLCG.js";
 import {
+  exchangeResultSchema,
   participantActivitySchema,
+  participantSessionSchema,
   questExperienceSchema
-} from "./chunk-D26YNACF.js";
+} from "./chunk-R2KZFX6E.js";
 import {
   badgeCatalogSchema,
   badgeSchema,
-  leaderboardPageSchema,
-  pointBalanceSchema,
-  pointBalancesSchema,
-  pointHistoryPageSchema,
-  pointLedgerReferenceSchema,
-  profileReferralSchema
-} from "./chunk-WSBYWVTZ.js";
-import {
-  exchangeResultSchema,
-  participantSessionSchema
-} from "./chunk-XJFYAXET.js";
-import {
   contentPerformanceSnapshotSchema,
   cosmosAddressSchema,
   cosmosNetworkSchema,
@@ -50,12 +40,17 @@ import {
   isNftCollection,
   isSolanaProgram,
   knownResponse,
+  leaderboardPageSchema,
+  limits,
   linkedWalletSchema,
-  maxMemberCompletions,
-  maxWalletEventLogs,
   memberCompletionSchema,
   memberIdentitySchema,
   photoResultSchema,
+  pointBalanceSchema,
+  pointBalancesSchema,
+  pointHistoryPageSchema,
+  pointLedgerReferenceSchema,
+  profileReferralSchema,
   quizEvidenceSchema,
   rewardKey,
   solanaAddressSchema,
@@ -82,10 +77,10 @@ import {
   walletEventsSchema,
   walletNftsSchema,
   walletTransactionsSchema
-} from "./chunk-MK425RXJ.js";
+} from "./chunk-HNR6G3GV.js";
 import {
   RelayErrorCode
-} from "./chunk-K2KS3JLY.js";
+} from "./chunk-EOUEAOWJ.js";
 
 // src/testing/run.ts
 import * as z3 from "zod";
@@ -175,12 +170,12 @@ function evaluationCalendar(snapshot, eligibleAt) {
 
 // src/testing/capabilities.ts
 import * as z from "zod";
-var trackerInput = {
+var trackerInput = /* @__PURE__ */ (() => ({
   reference: identifier,
   query: trackerQuerySchema,
   asOf: z.number().int().nonnegative().safe()
-};
-var capabilityRequestSchemas = {
+}))();
+var capabilityRequestSchemas = /* @__PURE__ */ (() => ({
   "wallet-balance": z.strictObject({
     kind: z.literal("wallet-balance"),
     chain: z.union([
@@ -223,22 +218,22 @@ var capabilityRequestSchemas = {
   "member-identities": z.strictObject({
     kind: z.literal("member-identities")
   })
-};
-var telegramRequestSchema = z.strictObject({
+}))();
+var telegramRequestSchema = /* @__PURE__ */ (() => z.strictObject({
   kind: z.literal("telegram"),
   input: z.union([telegramMemberInputSchema, telegramConnectionInputSchema])
-});
-var walletNftsRequestSchema = z.strictObject({
+}))();
+var walletNftsRequestSchema = /* @__PURE__ */ (() => z.strictObject({
   kind: z.literal("wallet-nfts"),
   collection: z.string().max(200).refine(isNftCollection),
   address: z.string().min(1).max(100).nullable()
-});
-var walletEventConditionSchema = z.union([
+}))();
+var walletEventConditionSchema = /* @__PURE__ */ (() => z.union([
   z.string().min(1).max(200),
   z.boolean(),
   z.strictObject({ gte: z.string().regex(/^-?(0|[1-9][0-9]{0,77})$/) })
-]);
-var walletEventsRequestSchema = z.strictObject({
+]))();
+var walletEventsRequestSchema = /* @__PURE__ */ (() => z.strictObject({
   kind: z.literal("wallet-events"),
   event: z.string().max(1e3).refine(isContractEvent),
   account: z.string().min(1).max(100),
@@ -246,17 +241,17 @@ var walletEventsRequestSchema = z.strictObject({
   afterActivation: z.boolean(),
   where: z.record(z.string().min(1).max(100), walletEventConditionSchema).refine((where) => Object.keys(where).length <= 10).nullable(),
   address: z.string().min(1).max(100).nullable(),
-  newest: z.number().int().min(1).max(maxWalletEventLogs).optional()
-});
-var walletTransactionsRequestSchema = z.strictObject({
+  newest: z.number().int().min(1).max(limits.walletEventLogs).optional()
+}))();
+var walletTransactionsRequestSchema = /* @__PURE__ */ (() => z.strictObject({
   kind: z.literal("wallet-transactions"),
   program: z.string().max(44).refine(isSolanaProgram),
   since: z.number().int().nonnegative().safe(),
   afterActivation: z.boolean(),
   mint: solanaAddressSchema.nullable(),
   address: z.string().min(1).max(100).nullable()
-});
-var walletCallRequestSchema = z.strictObject({
+}))();
+var walletCallRequestSchema = /* @__PURE__ */ (() => z.strictObject({
   kind: z.literal("wallet-call"),
   call: z.string().max(400).refine(isContractCall),
   args: z.array(
@@ -271,14 +266,14 @@ var walletCallRequestSchema = z.strictObject({
     "Pass the member's wallet ({ wallet: true }) at most once"
   ),
   address: z.string().min(1).max(100).nullable()
-});
-var walletDelegationsRequestSchema = z.strictObject({
+}))();
+var walletDelegationsRequestSchema = /* @__PURE__ */ (() => z.strictObject({
   kind: z.literal("wallet-delegations"),
   chain: cosmosNetworkSchema,
   validator: cosmosAddressSchema.nullable(),
   address: z.string().min(1).max(100).nullable()
-});
-var memberStateRequestSchemas = {
+}))();
+var memberStateRequestSchemas = /* @__PURE__ */ (() => ({
   "member-balance": z.strictObject({
     kind: z.literal("member-balance"),
     ledger: identifier
@@ -287,7 +282,7 @@ var memberStateRequestSchemas = {
     kind: z.literal("member-completions"),
     quest: identifier.nullable(),
     since: z.number().int().nonnegative().safe().nullable(),
-    limit: z.number().int().min(1).max(maxMemberCompletions)
+    limit: z.number().int().min(1).max(limits.memberCompletions)
   }),
   "member-groups": z.strictObject({ kind: z.literal("member-groups") }),
   "member-enrolled": z.strictObject({
@@ -298,11 +293,11 @@ var memberStateRequestSchemas = {
     kind: z.literal("member-referrals"),
     program: identifier
   })
-};
+}))();
 function unlistedRequest(request) {
   return request.kind === "telegram" || request.kind === "wallet-nfts" || request.kind === "wallet-call" || request.kind === "wallet-delegations" || request.kind === "wallet-events" || request.kind === "wallet-transactions" || request.kind === "member-balance" || request.kind === "member-completions" || request.kind === "member-groups" || request.kind === "member-enrolled" || request.kind === "member-referrals";
 }
-var capabilityRequestSchema = z.discriminatedUnion("kind", [
+var capabilityRequestSchema = /* @__PURE__ */ (() => z.discriminatedUnion("kind", [
   capabilityRequestSchemas["wallet-balance"],
   capabilityRequestSchemas["tracker-content"],
   capabilityRequestSchemas.x,
@@ -325,7 +320,7 @@ var capabilityRequestSchema = z.discriminatedUnion("kind", [
   memberStateRequestSchemas["member-groups"],
   memberStateRequestSchemas["member-enrolled"],
   memberStateRequestSchemas["member-referrals"]
-]);
+]))();
 function parseCapabilityRequest(raw) {
   return capabilityRequestSchema.safeParse(raw);
 }
@@ -390,6 +385,24 @@ function parseCapabilityResult(request, value) {
       return profileReferralSchema.parse(value);
   }
 }
+function newerResultIssue(issue) {
+  if (issue.code === "unrecognized_keys" || issue.code === "invalid_value") {
+    return true;
+  }
+  return issue.code === "invalid_union" && issue.errors.some(
+    (branch) => branch.length > 0 && branch.every(newerResultIssue)
+  );
+}
+function parseCapturedResult(request, value) {
+  try {
+    return parseCapabilityResult(request, value);
+  } catch (error) {
+    if (error instanceof z.ZodError && error.issues.every(newerResultIssue)) {
+      return value;
+    }
+    throw error;
+  }
+}
 function imageReferences(input) {
   return input.operation === "compare" || input.operation === "review" ? input.images : [input.image];
 }
@@ -703,10 +716,10 @@ function install(now, seed, restores) {
 
 // src/testing/facts.ts
 import * as z2 from "zod";
-var campaignFactSchema = z2.strictObject({
+var campaignFactSchema = /* @__PURE__ */ (() => z2.strictObject({
   key: identifier,
   enrolled: z2.boolean()
-});
+}))();
 var TestSetupError = class extends Error {
   constructor(message) {
     super(message);
@@ -1193,7 +1206,7 @@ function rewardSelectionIssue(selected, published) {
 }
 
 // src/testing/run.ts
-var defaultNow = Date.UTC(2026, 0, 1);
+var defaultNow = /* @__PURE__ */ (() => Date.UTC(2026, 0, 1))();
 var defaultMember = "member_test";
 var defaultSeed = "attempt_test";
 var maxCapabilityCalls = 8;
@@ -1301,6 +1314,7 @@ function hostContext(run, answer) {
   const evidence = typeof input.evidence === "string" ? input.evidence : void 0;
   const calendar = evaluationCalendar({ segments: run.segments }, eligibleAt);
   const calls = [];
+  const capabilityCalls = [];
   const diagnostics = [];
   const problems = [];
   const delivered = /* @__PURE__ */ new WeakSet();
@@ -1321,12 +1335,17 @@ function hostContext(run, answer) {
         request.kind === "photo" ? "Photo capability cannot access another attempt\u2019s evidence" : "Image capability cannot access another attempt\u2019s evidence"
       );
     }
-    const outcome = await answer(request, sequence2);
+    const { captured, ...outcome } = await answer(request, sequence2);
     if ("error" in outcome) {
       return outcome;
     }
     try {
-      const value = z3.json().parse(parseCapabilityResult(request, outcome.value));
+      const value = z3.json().parse(
+        (captured ? parseCapturedResult : parseCapabilityResult)(
+          request,
+          outcome.value
+        )
+      );
       return { value: JSON.parse(JSON.stringify(value)) };
     } catch (error) {
       throw new TestSetupError(
@@ -1336,7 +1355,7 @@ function hostContext(run, answer) {
   }
   const call = async (raw) => {
     const current = sequence++;
-    if (current >= maxCapabilityCalls) {
+    if (current >= limits.capabilityCalls) {
       throw capabilityLimitError();
     }
     const parsed = parseCapabilityRequest(raw);
@@ -1356,6 +1375,8 @@ function hostContext(run, answer) {
       problems.push(error instanceof Error ? error : new Error(String(error)));
       throw error;
     }
+    capabilityCalls.push({ sequence: current, request: parsed.data, outcome });
+    capabilityCalls.sort((a, b) => a.sequence - b.sequence);
     if (!unlistedRequest(parsed.data)) {
       calls.push({ sequence: current, request: parsed.data, outcome });
       calls.sort((a, b) => a.sequence - b.sequence);
@@ -1397,6 +1418,7 @@ function hostContext(run, answer) {
   return {
     context,
     calls,
+    capabilityCalls,
     diagnostics,
     problems,
     delivered,
@@ -1430,7 +1452,7 @@ function thrownMessage(error) {
 function capabilityLimitError() {
   return new CapabilityError(
     "capability-limit",
-    `An evaluation run makes at most ${maxCapabilityCalls} capability calls, shared by all capabilities`,
+    `An evaluation run makes at most ${limits.capabilityCalls} capability calls, shared by all capabilities`,
     { retryable: false }
   );
 }
@@ -1538,6 +1560,7 @@ function evaluateHosted(quest, host) {
     return {
       decision,
       calls: host.calls,
+      capabilityCalls: host.capabilityCalls,
       release: host.release,
       diagnostics: host.diagnostics
     };
@@ -1580,6 +1603,41 @@ function fakeEvaluationMember(member = {}) {
   };
 }
 
+// src/testing/readers.ts
+import * as z4 from "zod";
+function factsCall(facts) {
+  const answer = factsAnswerer(facts);
+  return async (raw) => {
+    const request = parseCapabilityRequest(raw);
+    if (!request.success) {
+      throw new CapabilityError(
+        "author-error",
+        z4.prettifyError(request.error),
+        { retryable: false }
+      );
+    }
+    const outcome = await answer(request.data);
+    if ("error" in outcome) {
+      throw CapabilityError.from(outcome.error);
+    }
+    try {
+      return JSON.parse(
+        JSON.stringify(parseCapabilityResult(request.data, outcome.value))
+      );
+    } catch (error) {
+      throw new TestSetupError(
+        `The answer to ${request.data.kind} is not a result Relay delivers: ${error instanceof z4.ZodError ? z4.prettifyError(error) : String(error)}`
+      );
+    }
+  };
+}
+function fakeWalletReader(facts = {}) {
+  return readerFactories.wallet(factsCall(facts));
+}
+function fakeTelegramReader(facts = {}) {
+  return readerFactories.telegram(factsCall(facts));
+}
+
 // src/testing/assertions.ts
 var DecisionAssertionError = class extends Error {
   decision;
@@ -1706,7 +1764,7 @@ function trackerPage(tracker, records, options = {}) {
 }
 
 // src/testing/replay.ts
-import * as z4 from "zod";
+import * as z5 from "zod";
 var ReplayStopped = class extends Error {
   constructor(divergence) {
     super(
@@ -1742,43 +1800,7 @@ function captureAnswerer(facts, fallback, diverged) {
     const fact = facts.find((candidate) => candidate.sequence === sequence);
     const reason = !fact ? "new" : !sameJson(fact.request, request) ? "changed" : !fact.captured || !fact.outcome ? "uncaptured" : null;
     if (fact?.outcome && !reason) {
-      return fact.outcome;
-    }
-    if (unlistedRequest(request)) {
-      if (!answerFallback) {
-        const [reader, fact2] = {
-          telegram: request.kind === "telegram" && !("chat" in request.input) ? ["ctx.telegram.connection()", "facts.telegram.connection"] : ["ctx.telegram.member()", "facts.telegram"],
-          "wallet-nfts": ["ctx.wallet.nfts()", "facts.wallet.nfts"],
-          "wallet-call": ["ctx.wallet.call()", "facts.wallet.call"],
-          "wallet-delegations": [
-            "ctx.wallet.delegations()",
-            "facts.wallet.delegations"
-          ],
-          "wallet-events": ["ctx.wallet.events()", "facts.wallet.events"],
-          "wallet-transactions": [
-            "ctx.wallet.transactions()",
-            "facts.wallet.transactions"
-          ],
-          "member-balance": ["ctx.member.balance()", "facts.member.balances"],
-          "member-completions": [
-            "ctx.member.completions()",
-            "facts.member.completions"
-          ],
-          "member-groups": ["ctx.member.groups()", "facts.member.groups"],
-          "member-enrolled": [
-            "ctx.member.enrolled()",
-            "facts.member.campaigns"
-          ],
-          "member-referrals": [
-            "ctx.member.referrals()",
-            "facts.member.referrals"
-          ]
-        }[request.kind];
-        throw new TestSetupError(
-          `Capability call ${sequence}, ${reader}, is not in the capture (${reason ?? "new"}): pass ${fact2} to answer it`
-        );
-      }
-      return answerFallback(request);
+      return { ...fact.outcome, captured: true };
     }
     const divergence = {
       sequence,
@@ -1786,7 +1808,7 @@ function captureAnswerer(facts, fallback, diverged) {
       recorded: fact?.request ?? null,
       replayed: request
     };
-    diverged(divergence);
+    diverged(divergence, !unlistedRequest(request));
     if (!answerFallback) {
       throw new ReplayStopped(divergence);
     }
@@ -1797,7 +1819,7 @@ async function replayAttempt(quest, capture, options = {}) {
   const parsed = attemptCaptureSchema.safeParse(capture);
   if (!parsed.success) {
     throw new TestSetupError(
-      `Not an attempt capture: ${z4.prettifyError(parsed.error)}`
+      `Not an attempt capture: ${z5.prettifyError(parsed.error)}`
     );
   }
   const { quest: captured, context, facts, recorded } = parsed.data;
@@ -1807,6 +1829,7 @@ async function replayAttempt(quest, capture, options = {}) {
     );
   }
   let divergence = null;
+  let capabilityDivergence = null;
   const host = hostContext(
     {
       release: {
@@ -1824,8 +1847,17 @@ async function replayAttempt(quest, capture, options = {}) {
       now: parsed.data.now,
       seed: parsed.data.seed
     },
-    captureAnswerer(facts, options.facts, (found) => {
-      divergence ??= found;
+    captureAnswerer(facts, options.facts, (found, listed) => {
+      if (capabilityDivergence) {
+        return;
+      }
+      capabilityDivergence = found;
+      divergence = listed ? {
+        sequence: found.sequence,
+        reason: found.reason,
+        recorded: found.recorded,
+        replayed: found.replayed
+      } : null;
     })
   );
   let decision = null;
@@ -1841,12 +1873,14 @@ async function replayAttempt(quest, capture, options = {}) {
     recorded,
     changed: decision && recorded ? !sameJson(decision, recorded) : null,
     divergence,
-    calls: host.calls
+    capabilityDivergence,
+    calls: host.calls,
+    capabilityCalls: host.capabilityCalls
   };
 }
 
 // src/testing/participant-api.ts
-import * as z5 from "zod";
+import * as z6 from "zod";
 var defaultScope = {
   organization: "org_test",
   project: "project_test",
@@ -1914,7 +1948,11 @@ function createFakeRelay(options = {}) {
     }
     const start = query.get("start") === "latest" ? activity.length : cursor === null ? 0 : Number(cursor.replace(/^fake-/, ""));
     if (!Number.isInteger(start) || start < 0 || start > activity.length) {
-      return refuse(400, "invalid-request", "Invalid activity cursor");
+      return refuse(
+        400,
+        "invalid-cursor",
+        "Invalid cursor. Start from the first page."
+      );
     }
     const items = activity.slice(start, start + limit);
     return answer("GET /v1/me/activity", participantActivitySchema, {
@@ -1978,7 +2016,7 @@ function createFakeRelay(options = {}) {
     }
     if (method === "POST" && path === "/v1/auth/logout") {
       member = null;
-      return answer("POST /v1/auth/logout", z5.object({ ok: z5.boolean() }), {
+      return answer("POST /v1/auth/logout", z6.object({ ok: z6.boolean() }), {
         ok: true
       });
     }
@@ -1988,7 +2026,7 @@ function createFakeRelay(options = {}) {
     if (method === "GET" && path === "/v1/point-ledgers") {
       return answer(
         "GET /v1/point-ledgers",
-        z5.array(pointLedgerReferenceSchema),
+        z6.array(pointLedgerReferenceSchema),
         ledgers
       );
     }
@@ -1998,7 +2036,7 @@ function createFakeRelay(options = {}) {
       });
     }
     if (method === "GET" && path === "/v1/badges") {
-      return answer("GET /v1/badges", z5.array(badgeSchema), badges);
+      return answer("GET /v1/badges", z6.array(badgeSchema), badges);
     }
     const board = method === "GET" && /^\/v1\/leaderboards\/([\w-]+)$/.exec(path);
     if (board) {
@@ -2055,7 +2093,7 @@ function createFakeRelay(options = {}) {
   };
   experience(member ?? "member_test");
   answer("GET /v1/me/points", pointBalancesSchema, { items: balances });
-  answer("GET /v1/point-ledgers", z5.array(pointLedgerReferenceSchema), ledgers);
+  answer("GET /v1/point-ledgers", z6.array(pointLedgerReferenceSchema), ledgers);
   answer("GET /v1/badges/catalog", badgeCatalogSchema, { items: badges });
   answer("GET /v1/me/activity", participantActivitySchema, {
     member: member ?? "member_test",
@@ -2101,6 +2139,9 @@ export {
   expectReject,
   expectReview,
   fakeEvaluationMember,
+  fakeTelegramReader,
+  fakeWalletReader,
+  limits,
   maxCapabilityCalls,
   replayAttempt,
   runQuest,

package/dist/{tracker-data-Hb1uQnk5.d.ts → tracker-data-Bl-qPIvZ.d.ts}

@@ -141,7 +141,7 @@ declare const knownIdentityKinds: readonly ["wallet", "x", "discord", "member"];
 type KnownIdentityKind = (typeof knownIdentityKinds)[number];
 /**
  * An identity kind your app owns: `app:` and a name of lowercase letters, digits, `_` or `-`
- * (at most 40), such as `app:telegram` or `app:acme`. The identity integration created with this
+ * (at most 40), such as `app:game` or `app:acme`. The identity integration created with this
  * kind is the only one that can link it: each member it signs in gets the app's subject as an
  * identity of this kind in the project.
  */
@@ -887,8 +887,10 @@ declare const trackerIngestResultSchema: z.ZodObject<{
  * is removed, `not-joined` when the member joins, `not-enrolled` when the member enrolls. Every
  * other skip is final unless a reviewer retries it, or, for `historical` under
  * `historical: "claim"`, the member claims it.
+ *
+ * @compat open
  */
-declare const trackerSkipCodes: readonly ["quest-paused", "before-activation", "outside-window", "future-record", "record-removed", "invalid-record-data", "content-unavailable", "no-account", "beneficiary-is-author", "unlinked-account", "ambiguous-account", "not-joined", "already-completed", "not-enrolled", "before-enrollment", "historical", "prerequisites-incomplete"];
+declare const trackerSkipCodes: readonly ["quest-paused", "before-activation", "outside-window", "future-record", "record-removed", "invalid-record-data", "content-unavailable", "no-account", "beneficiary-is-author", "unlinked-account", "ambiguous-account", "not-joined", "member-banned", "already-completed", "not-enrolled", "before-enrollment", "historical", "prerequisites-incomplete"];
 /**
  * A skip code this SDK knows.
  *
@@ -897,6 +899,15 @@ declare const trackerSkipCodes: readonly ["quest-paused", "before-activation", "
 type KnownTrackerSkipCode = (typeof trackerSkipCodes)[number];
 /** A known skip code, or one a newer Relay sends. */
 type TrackerSkipCode = KnownTrackerSkipCode | (string & {});
+/**
+ * Which enrollment a `not-enrolled` skip lacks: `"quest"`, the quest's own (`enrollment:
+ * "required"` on its trigger), or `"campaign"`, the campaign the quest belongs to.
+ *
+ * @compat open
+ */
+type KnownSkipEnrollment = "quest" | "campaign";
+/** A known enrollment, or one a newer Relay sends. */
+type SkipEnrollment = KnownSkipEnrollment | (string & {});
 /**
  * One tracker-trigger decision: a quest admitted an attempt for a record observation, or skipped
  * it with a code and reason. Operators read these to see why a quest did or did not run.
@@ -924,6 +935,7 @@ declare const trackerOutcomeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         quest: "quest";
         tracker: "tracker";
     }>>;
+    enrollment: z.ZodOptional<z.ZodType<SkipEnrollment, unknown, z.core.$ZodTypeInternals<SkipEnrollment, unknown>>>;
     member: z.ZodNullable<z.ZodString>;
     attempt: z.ZodNullable<z.ZodString>;
     quest: z.ZodString;
@@ -976,6 +988,7 @@ declare const trackerTriggerOutcomePageSchema: z.ZodObject<{
             quest: "quest";
             tracker: "tracker";
         }>>;
+        enrollment: z.ZodOptional<z.ZodType<SkipEnrollment, unknown, z.core.$ZodTypeInternals<SkipEnrollment, unknown>>>;
         member: z.ZodNullable<z.ZodString>;
         attempt: z.ZodNullable<z.ZodString>;
         quest: z.ZodString;
@@ -1032,6 +1045,7 @@ declare const trackerOutcomePageSchema: z.ZodObject<{
             quest: "quest";
             tracker: "tracker";
         }>>;
+        enrollment: z.ZodOptional<z.ZodType<SkipEnrollment, unknown, z.core.$ZodTypeInternals<SkipEnrollment, unknown>>>;
         member: z.ZodNullable<z.ZodString>;
         attempt: z.ZodNullable<z.ZodString>;
         quest: z.ZodString;
@@ -1267,7 +1281,11 @@ type TrackerPage<D = unknown> = Omit<z.infer<typeof trackerPageSchema>, "items">
     items: TypedTrackerRecord<D>[];
     excluded: number;
 });
-/** Preview bounds: one sample, never stored, never a tracker. */
+/**
+ * Preview bounds: one sample, never stored, never a tracker.
+ *
+ * @deprecated Use `limits.trackerPreview`, which a 1.x release can raise.
+ */
 declare const trackerPreviewLimits: {
     readonly pages: 3;
     readonly posts: 100;
@@ -1348,10 +1366,12 @@ declare const trackerTriggerModeSchema: z.ZodEnum<{
 }>;
 type TrackerTriggerMode = z.infer<typeof trackerTriggerModeSchema>;
 /**
- * Custom trackers fire on every new sample; X and Discord trackers on each record they collect,
- * since a post, message or reaction is one event.
+ * Custom trackers fire on every new sample; X, Discord and Telegram trackers on each record they
+ * collect, since a post, message or reaction is one event. Telegram's sources are custom sources
+ * on reserved namespaces in SDK 1.x, so `namespace` names them. A published policy keeps the mode
+ * it was published with.
  */
-declare function defaultTriggerMode(source: string): TrackerTriggerMode;
+declare function defaultTriggerMode(source: string, namespace?: string): TrackerTriggerMode;
 /**
  * A bound in a tracker trigger filter: a number, or the quest's integer or amount setting of that
  * name. An amount setting (`settings.amount()`) holds a base-unit integer string, compared exactly.
@@ -1783,9 +1803,17 @@ type TrackerDataSchema = {
     oneOf?: TrackerDataSchema[];
     allOf?: TrackerDataSchema[];
 };
-/** The most branches one union may list. */
+/**
+ * The most branches one union may list.
+ *
+ * @deprecated Use `limits.trackerData.branches`, which a 1.x release can raise.
+ */
 declare const trackerDataMaxBranches = 16;
-/** The most properties, `required` keys, enum values or allowed key names one schema node lists. */
+/**
+ * The most properties, `required` keys, enum values or allowed key names one schema node lists.
+ *
+ * @deprecated Use `limits.trackerData.entries`, which a 1.x release can raise.
+ */
 declare const trackerDataMaxEntries = 256;
 /**
  * A stored tracker data schema: an object schema in the supported subset, at most 32 KB and
@@ -1852,4 +1880,4 @@ declare function schemaCheckedReader(reader: TrackerReader): TrackerReader;
  */
 declare function whereSchemaIssue(schema: TrackerDataSchema, where: TrackerWhere | undefined): string | null;
 
-export { type KnownIdentityKind as $, type RoleOf as A, type WhereSetting as B, type ContentBody as C, type BadgeHandle as D, type ContentMetricName as E, type LedgerSetting as F, type GroupHandle as G, type TrackerPage as H, type IdentityKind as I, type TrackerReadQuery as J, type KnownTrackerSkipCode as K, type LedgerReference as L, type MemberIdentity as M, trackerDataSchema as N, type OpenIdentityKind as O, trackerTriggerContextSchema as P, type QuestHandle as Q, type ResourceHandle as R, type SourceRoles as S, type TrackerSkipCode as T, type AccountRole as U, type AppIdentityKind as V, type WithRecordData as W, type XTweet as X, type Bound as Y, type Condition as Z, type DataLeaves as _, type TrackerDataBudget as a, trackerDefinitionResponseSchema as a$, type ManagedTrackerCreateInput as a0, type ManagedTrackerSource as a1, type ManagedTrackerSourceKind as a2, type TrackerAccount as a3, type TrackerAttribution as a4, type TrackerBound as a5, type TrackerCondition as a6, type TrackerContent as a7, type TrackerContentQuery as a8, type TrackerCreateInput as a9, identityKindSchema as aA, isAppIdentityKind as aB, isKnownTrackerSource as aC, knownIdentityKinds as aD, managedTrackerCreateSchema as aE, managedTrackerSource as aF, managedTrackerSourceKinds as aG, managedTrackerSourceSchema as aH, memberIdentitySchema as aI, openIdentityKindSchema as aJ, publishedTrackerSchema as aK, sourceContent as aL, sourceIdentities as aM, trackerAccountSchema as aN, trackerArtifactSchema as aO, trackerAttributionSchema as aP, trackerBoundSchema as aQ, trackerConditionSchema as aR, trackerContentQuerySchema as aS, trackerContentReadSchema as aT, trackerContentSchema as aU, trackerContentStageSchema as aV, trackerControlSchema as aW, trackerCreateSchema as aX, trackerDataMaxBranches as aY, trackerDataMaxEntries as aZ, trackerDataSchemaSchema as a_, type TrackerDataIssue as aa, type TrackerDefinition as ab, type TrackerDefinitionResponse as ac, type TrackerOutcome as ad, type TrackerOutcomeQuery as ae, type TrackerPreview as af, type TrackerPreviewInput as ag, type TrackerQuery as ah, type TrackerRecord as ai, type TrackerSourceKind as aj, type TrackerSourceResponse as ak, type TrackerStatus as al, type TrackerTriggerOutcomePage as am, type TrackerTriggerOutcomeQuery as an, type TrackerUpdateInput as ao, type TrackerWhere as ap, type TriggerEnrollment as aq, type TriggerHistorical as ar, type TriggerSince as as, type TypedTrackerRecord as at, accountRoleSchema as au, appIdentityKindSchema as av, beneficiaryRole as aw, contentMetricNameSchema as ax, customContentSchema as ay, defaultTriggerMode as az, trackerDataIssue as b, trackerEvidenceSchema as b0, trackerIngestResultSchema as b1, trackerIngestSchema as b2, trackerOutcomePageSchema as b3, trackerOutcomeQuerySchema as b4, trackerOutcomeRetrySchema as b5, trackerOutcomeSchema as b6, trackerPageSchema as b7, trackerPreviewInputSchema as b8, trackerPreviewLimits as b9, whereSettings as bA, xAccountRoles as bB, xContentMetrics as bC, xTweetSchema as bD, trackerPreviewSchema as ba, trackerPropertiesSchema as bb, trackerQuerySchema as bc, trackerRecordAccountSchema as bd, trackerRecordInputSchema as be, trackerRecordSchema as bf, trackerSkipCodes as bg, trackerSourceKinds as bh, trackerSourceResponseSchema as bi, trackerSourceSchema as bj, trackerStatusSchema as bk, trackerSummarySchema as bl, trackerTriggerModeSchema as bm, trackerTriggerOutcomePageSchema as bn, trackerTriggerOutcomeQuerySchema as bo, trackerTriggerPolicySchema as bp, trackerTriggerRecordSchema as bq, trackerUpdateSchema as br, trackerWhereSchema as bs, triggerAdmission as bt, triggerEnrollmentSchema as bu, triggerHistoricalSchema as bv, triggerMode as bw, triggerSinceSchema as bx, walletBalanceSourceSchema as by, whereConditions as bz, trackerDataIssues as c, trackerDataPathTypes as d, trackerDataRecordSteps as e, type TrackerDataSchema as f, customSourceSchema as g, type WithContent as h, type WithAccountRoles as i, type TrackerSource as j, trackerDefinitionSchema as k, type Tracker as l, type TrackerData as m, type LedgerHandle as n, xSearchSourceSchema as o, type XContentMetric as p, type TrackerTriggerPolicy as q, type Where as r, schemaCheckedReader as s, trackerDataBatchSteps as t, type ReferralHandle as u, type TrackerTriggerContext as v, whereSchemaIssue as w, xContentBodySchema as x, type TrackerReader as y, type TrackerTriggerMode as z };
+export { type AppIdentityKind as $, type ReferralHandle as A, type TrackerTriggerContext as B, type TrackerReader as C, type TrackerTriggerMode as D, type RoleOf as E, type WhereSetting as F, type GroupHandle as G, type ContentBody as H, type IdentityKind as I, type BadgeHandle as J, type KnownSkipEnrollment as K, type LedgerReference as L, type MemberIdentity as M, type ContentMetricName as N, type OpenIdentityKind as O, type LedgerSetting as P, type QuestHandle as Q, type ResourceHandle as R, type SkipEnrollment as S, type TrackerSkipCode as T, type TrackerPage as U, type TrackerReadQuery as V, type WithRecordData as W, type XTweet as X, trackerDataSchema as Y, trackerTriggerContextSchema as Z, type AccountRole as _, type KnownTrackerSkipCode as a, trackerDataMaxBranches as a$, type Bound as a0, type Condition as a1, type DataLeaves as a2, type KnownIdentityKind as a3, type ManagedTrackerCreateInput as a4, type ManagedTrackerSource as a5, type ManagedTrackerSourceKind as a6, type TrackerAccount as a7, type TrackerAttribution as a8, type TrackerBound as a9, beneficiaryRole as aA, contentMetricNameSchema as aB, customContentSchema as aC, defaultTriggerMode as aD, identityKindSchema as aE, isAppIdentityKind as aF, isKnownTrackerSource as aG, knownIdentityKinds as aH, managedTrackerCreateSchema as aI, managedTrackerSource as aJ, managedTrackerSourceKinds as aK, managedTrackerSourceSchema as aL, memberIdentitySchema as aM, openIdentityKindSchema as aN, publishedTrackerSchema as aO, sourceIdentities as aP, trackerAccountSchema as aQ, trackerArtifactSchema as aR, trackerAttributionSchema as aS, trackerBoundSchema as aT, trackerConditionSchema as aU, trackerContentQuerySchema as aV, trackerContentReadSchema as aW, trackerContentSchema as aX, trackerContentStageSchema as aY, trackerControlSchema as aZ, trackerCreateSchema as a_, type TrackerCondition as aa, type TrackerContent as ab, type TrackerContentQuery as ac, type TrackerCreateInput as ad, type TrackerDataIssue as ae, type TrackerDefinition as af, type TrackerDefinitionResponse as ag, type TrackerOutcome as ah, type TrackerOutcomeQuery as ai, type TrackerPreview as aj, type TrackerPreviewInput as ak, type TrackerQuery as al, type TrackerRecord as am, type TrackerSourceKind as an, type TrackerSourceResponse as ao, type TrackerStatus as ap, type TrackerTriggerOutcomePage as aq, type TrackerTriggerOutcomeQuery as ar, type TrackerUpdateInput as as, type TrackerWhere as at, type TriggerEnrollment as au, type TriggerHistorical as av, type TriggerSince as aw, type TypedTrackerRecord as ax, accountRoleSchema as ay, appIdentityKindSchema as az, type TrackerDataBudget as b, trackerDataMaxEntries as b0, trackerDataSchemaSchema as b1, trackerDefinitionResponseSchema as b2, trackerEvidenceSchema as b3, trackerIngestResultSchema as b4, trackerIngestSchema as b5, trackerOutcomePageSchema as b6, trackerOutcomeQuerySchema as b7, trackerOutcomeRetrySchema as b8, trackerOutcomeSchema as b9, triggerSinceSchema as bA, walletBalanceSourceSchema as bB, whereConditions as bC, xAccountRoles as bD, xContentMetrics as bE, xTweetSchema as bF, trackerPageSchema as ba, trackerPreviewInputSchema as bb, trackerPreviewLimits as bc, trackerPreviewSchema as bd, trackerPropertiesSchema as be, trackerQuerySchema as bf, trackerRecordAccountSchema as bg, trackerRecordInputSchema as bh, trackerRecordSchema as bi, trackerSkipCodes as bj, trackerSourceKinds as bk, trackerSourceResponseSchema as bl, trackerSourceSchema as bm, trackerStatusSchema as bn, trackerSummarySchema as bo, trackerTriggerModeSchema as bp, trackerTriggerOutcomePageSchema as bq, trackerTriggerOutcomeQuerySchema as br, trackerTriggerPolicySchema as bs, trackerTriggerRecordSchema as bt, trackerUpdateSchema as bu, trackerWhereSchema as bv, triggerAdmission as bw, triggerEnrollmentSchema as bx, triggerHistoricalSchema as by, triggerMode as bz, sourceContent as c, trackerDataIssue as d, trackerDataIssues as e, trackerDataPathTypes as f, trackerDataRecordSteps as g, whereSettings as h, type TrackerDataSchema as i, customSourceSchema as j, type WithContent as k, type WithAccountRoles as l, type TrackerSource as m, trackerDefinitionSchema as n, type Tracker as o, type TrackerData as p, type SourceRoles as q, type LedgerHandle as r, schemaCheckedReader as s, trackerDataBatchSteps as t, xSearchSourceSchema as u, type XContentMetric as v, whereSchemaIssue as w, xContentBodySchema as x, type TrackerTriggerPolicy as y, type Where as z };