@domino-sdk/relay 1.60.0 → 1.62.0

package/dist/{chunk-N3LJ6GFK.js → chunk-3KLC4AMA.js}

@@ -1,8 +1,11 @@
+import {
+  parseDefinition
+} from "./chunk-GTDW453U.js";
 import {
   identifier,
   resourceHandle,
   responseShape
-} from "./chunk-GBSDAD3N.js";
+} from "./chunk-MK425RXJ.js";
 
 // src/youtube.ts
 import * as z from "zod";
@@ -60,20 +63,25 @@ var analyticsRanges = ["7d", "30d", "90d", "all"];
 var amount = once(() => z3.number().int().safe());
 var amounts = once(() => z3.array(amount()));
 var instant = once(() => z3.iso.datetime({ offset: true }));
+var instantMs = once(() => amount().optional());
 var bucket = once(
   () => z3.object({
     /** The period's label in its time zone, such as `2026-10-08@Europe/Budapest` or `2026-W41@UTC`. */
     key: z3.string(),
     start: instant(),
-    end: instant()
+    startMs: instantMs(),
+    end: instant(),
+    endMs: instantMs()
   })
 );
 var range = once(
   () => z3.object({
     key: z3.enum(analyticsRanges),
     from: instant(),
+    fromMs: instantMs(),
     /** Now, by the database's clock, when the read ran. */
     to: instant(),
+    toMs: instantMs(),
     bucket: z3.enum(["day", "week"]),
     /** The project calendar's time zone now. Buckets before a time zone change follow the old one. */
     timeZone: z3.string(),
@@ -81,7 +89,12 @@ var range = once(
   })
 );
 var previousRange = once(
-  () => z3.object({ from: instant(), to: instant() }).optional()
+  () => z3.object({
+    from: instant(),
+    fromMs: instantMs(),
+    to: instant(),
+    toMs: instantMs()
+  }).optional()
 );
 var analyticsQuerySchema = z3.strictObject(
   lazyShape({
@@ -116,29 +129,40 @@ var quest = once(
     rejectionRate: z3.number().min(0).max(1).nullable(),
     /**
      * The 5 most common rejections, most frequent first. Rejections with a code (an evaluator's
-     * reject code or one Relay writes, such as `budget-exhausted`) group by it, and `reason` is the
-     * latest rejection's reason; rejections without one group by their exact reason.
+     * reject code or one Relay writes, such as `budget-exhausted`) group by it and by who wrote it,
+     * so Relay's `key-used` and an evaluator's own `key-used` are separate rows; `reason` is the
+     * latest rejection's reason. Rejections without one group by their exact reason.
      */
     topReasons: z3.array(
       z3.object({
         reason: z3.string(),
         code: z3.string().nullable(),
+        /**
+         * Who wrote `code`: `relay` or `evaluator`, null for a rejection without one. Relay always
+         * sends it; servers before it was added did not.
+         */
+        codeSource: z3.string().nullish(),
         count: amount()
       })
     ),
-    /** Rejections by who made them: the evaluator, staff, an exhausted budget, an expired deferral. */
+    /**
+     * Rejections by who made them: the evaluator, staff, an exhausted budget, an expired deferral,
+     * or Relay because another member's completion holds the attempt's shared key (`keyUsed`, which
+     * Relay always sends; servers before it was added counted those as `evaluator`).
+     */
     rejectionsBySource: z3.object({
       evaluator: amount(),
       staff: amount(),
       budget: amount(),
-      expired: amount()
+      expired: amount(),
+      keyUsed: amount().optional()
     }),
     /** Attempts and completions per bucket. */
     series: z3.object({ attempts: amounts(), completions: amounts() })
   })
 );
-var analyticsReadSchema = z3.object(
-  lazyShape({
+var analyticsReadSchema = /* @__PURE__ */ z3.object(
+  /* @__PURE__ */ lazyShape({
     range,
     previous: previousRange,
     members: () => z3.object({
@@ -207,6 +231,8 @@ var analyticsReadSchema = z3.object(
     testEnvironment: () => z3.object({
       /** When a test member was last reset, deleting their history, or null. */
       lastResetAt: instant().nullable(),
+      /** `lastResetAt` in epoch milliseconds. Servers before it was added did not send it. */
+      lastResetAtMs: amount().nullish(),
       /** Test members whose clock is advanced, so their activity can be dated in the future. */
       shiftedClockMembers: amount()
     }).optional()
@@ -455,7 +481,10 @@ var analyticsMetricResultSchema = z3.object(
        */
       rows: z3.array(
         z3.object({
-          /** The resource's key (its ID when it has none), the source, the outcome, or the reason's code or text. */
+          /**
+           * The resource's key (its ID when it has none), the source, the outcome, or the reason's
+           * code or text; Relay's `key-used` is `relay:key-used`, apart from an evaluator's `key-used`.
+           */
           key: z3.string(),
           title: z3.string(),
           archived: z3.boolean(),
@@ -648,7 +677,7 @@ var dashboardPreviewSchema = responseShape(
 );
 var keyOf = (reference) => typeof reference === "string" ? reference : reference.key;
 function defineDashboard(input) {
-  const authored = dashboardAuthoringSchema.parse({
+  const authored = parseDefinition("Dashboard", dashboardAuthoringSchema, {
     ...input,
     sections: input.sections.map((section) => ({
       ...section,

package/dist/{chunk-6ZG7WNYX.js → chunk-3PYYGFSB.js}

@@ -1,6 +1,16 @@
 import {
   isRequestError
-} from "./chunk-GBSDAD3N.js";
+} from "./chunk-K2KS3JLY.js";
+
+// package.json
+var name = "@domino-sdk/relay";
+var version = "1.62.0";
+
+// src/client-identity.ts
+function clientIdentity() {
+  const runtime = typeof document === "undefined" ? "server" : "browser";
+  return `${name}/${version} (${runtime})`;
+}
 
 // src/request-lifetime.ts
 var PARTICIPANT_TIMEOUT = 15e3;
@@ -46,7 +56,8 @@ function backoff(retry) {
 function retryDelay(failure, context) {
   const transient = failure.kind === "network" && (failure.status === void 0 || failure.status < 400) || (failure.kind === "http" || failure.kind === "network") && transientStatuses.has(failure.status ?? 0) && // Domino's rate limits run for minutes or hours: a 429 waits only when told how long.
   (failure.status !== 429 || failure.retryAfter !== void 0);
-  if (!transient || !context.replaySafe || context.attempt >= MAX_ATTEMPTS) {
+  const repeatable = context.replaySafe || failure.status === 503 && failure.retryAfter !== void 0;
+  if (!transient || !repeatable || context.attempt >= MAX_ATTEMPTS) {
     return void 0;
   }
   const wait = failure.retryAfter ?? backoff(context.attempt);
@@ -103,6 +114,7 @@ function markUncertain(error) {
 }
 
 export {
+  clientIdentity,
   PARTICIPANT_TIMEOUT,
   MANAGEMENT_TIMEOUT,
   validTimeout,

package/dist/{chunk-VWMIA2TT.js → chunk-5TEYFX6X.js}

@@ -5,7 +5,7 @@ import {
   isKnownTrackerSource,
   trackerDataSchema,
   xAccountRoles
-} from "./chunk-GBSDAD3N.js";
+} from "./chunk-MK425RXJ.js";
 
 // src/quest-shape.ts
 function validateQuestShape(description, options = {}) {
@@ -29,7 +29,7 @@ function validateQuestShape(description, options = {}) {
     );
   }
   if (content) {
-    if (completion.kind !== "keyed") {
+    if (completion.kind !== "keyed" || completion.across) {
       throw new Error("Content quests complete once per content item");
     }
     if (tracker.beneficiary !== "author" || tracker.on !== "new-record") {

package/dist/chunk-6WCIWXUV.js

@@ -0,0 +1,31 @@
+import {
+  RelayErrorCode,
+  clientError
+} from "./chunk-K2KS3JLY.js";
+
+// src/plugin-client.ts
+var transportKey = /* @__PURE__ */ Symbol.for("@domino-sdk/relay:plugin-transport");
+function setPluginTransport(client, transport) {
+  Object.defineProperty(client, transportKey, { value: transport });
+}
+function withPluginNamespace(client, name, build) {
+  if (!Object.hasOwn(client, name)) {
+    const transport = client[transportKey];
+    if (!transport) {
+      throw clientError(
+        "Pass a client that createRelayClient or createBrowserRelayClient made",
+        RelayErrorCode.InvalidInput
+      );
+    }
+    Object.defineProperty(client, name, {
+      value: build(transport),
+      enumerable: true
+    });
+  }
+  return client;
+}
+
+export {
+  setPluginTransport,
+  withPluginNamespace
+};

package/dist/chunk-CICDIBOF.js

@@ -0,0 +1,373 @@
+import {
+  pointLedgerReferenceSchema
+} from "./chunk-WSBYWVTZ.js";
+import {
+  authProviderSchema,
+  entitlementSchema,
+  identifier,
+  pageCursorSchema,
+  pickupAvailabilitySchema,
+  pickupSelectionSchema,
+  signInProviderOptionSchema,
+  telegramSignInMethodsSchema,
+  walletSignInNetworksSchema
+} from "./chunk-MK425RXJ.js";
+
+// src/sign-in-providers.ts
+import * as z from "zod";
+var authProvidersSchema = z.object({
+  providers: z.array(
+    z.object({
+      provider: authProviderSchema,
+      configured: z.boolean()
+    })
+  ),
+  email: z.boolean(),
+  /** The wallet sign-in this project enabled. */
+  wallets: walletSignInNetworksSchema,
+  demo: z.boolean(),
+  /**
+   * Telegram's sign-in, which is not one of `providers` in SDK 1.x. Absent from Relay versions
+   * without Telegram. `login` is deprecated in favour of `signInProviders`; `miniApp` is not.
+   */
+  telegram: telegramSignInMethodsSchema.optional(),
+  /**
+   * Every sign-in provider the platform has, Telegram included, and whether Domino configured it:
+   * the open sibling of `providers`, which SDK 1.x keeps to `AuthProvider`. A newer Relay may list
+   * providers this SDK does not know. Absent from older Relay versions.
+   */
+  signInProviders: z.array(signInProviderOptionSchema).optional()
+});
+
+// src/creator-accounts.ts
+import * as z2 from "zod";
+var knownCreatorAccountProviders = ["youtube", "tiktok"];
+var creatorAccountProviderSchema = z2.custom(
+  (value) => typeof value === "string" && /^[a-z][a-z0-9-]{0,39}$/.test(value)
+);
+var creatorAccountSchema = z2.object({
+  provider: creatorAccountProviderSchema,
+  configured: z2.boolean(),
+  status: z2.enum(["disconnected", "connected", "reconnect"]),
+  subject: z2.string().nullable(),
+  revision: z2.number().int().nonnegative(),
+  profile: z2.object({
+    name: z2.string().optional(),
+    username: z2.string().optional(),
+    imageUrl: z2.string().optional()
+  }).nullable()
+});
+var creatorAccountsSchema = z2.object({
+  accounts: z2.array(creatorAccountSchema)
+});
+
+// src/consent.ts
+import * as z3 from "zod";
+var consentWordingMaxLength = 2e3;
+var knownConsentChannels = ["email"];
+var openValue = z3.string().min(1).max(64);
+var memberConsentSchema = z3.object({
+  member: identifier,
+  channel: openValue,
+  state: openValue,
+  at: z3.number().int().safe().nonnegative(),
+  wording: z3.string().nullable(),
+  source: openValue
+});
+var memberConsentListSchema = z3.array(memberConsentSchema);
+var consentInputSchema = z3.object({
+  actionId: identifier,
+  channel: z3.custom(
+    (value) => typeof value === "string" && value.length <= 64
+  ),
+  granted: z3.boolean(),
+  wording: z3.string().optional()
+}).strict();
+var memberConsentInputSchema = z3.object({
+  actionId: identifier,
+  member: identifier,
+  channel: z3.string().max(64),
+  granted: z3.boolean(),
+  wording: z3.string().optional()
+}).strict();
+var memberConsentHistorySchema = z3.object({
+  items: z3.array(memberConsentSchema),
+  nextCursor: z3.string().nullable()
+});
+var memberConsentHistoryQuerySchema = z3.object({
+  cursor: z3.string().max(2e3).optional(),
+  limit: z3.coerce.number().int().min(1).max(100).optional()
+}).strict();
+
+// src/collection.ts
+import * as z4 from "zod";
+var collectionCodeSchema = z4.string().regex(/^relay:collect:[a-f0-9]{64}$/);
+var collectionPassSchema = z4.object({
+  code: collectionCodeSchema,
+  expiresAt: z4.number(),
+  entitlement: identifier
+});
+var collectionResolveSchema = z4.object({ code: collectionCodeSchema }).strict();
+var collectionBeginSchema = collectionResolveSchema.extend({
+  actionId: identifier,
+  revision: z4.number().int().positive(),
+  selection: pickupSelectionSchema.optional()
+});
+var collectionPreviewSchema = z4.object({
+  entitlement: entitlementSchema,
+  inventory: pickupAvailabilitySchema,
+  expiresAt: z4.number()
+});
+
+// src/outcomes.ts
+import * as z5 from "zod";
+var timestamp = z5.number().int().safe().nonnegative();
+var questEnrollmentInputSchema = z5.strictObject({
+  actionId: identifier,
+  /** Quest key or ID. */
+  quest: identifier
+});
+var memberEnrollmentInputSchema = questEnrollmentInputSchema.extend({
+  member: identifier
+});
+var questEnrollmentSchema = z5.object({
+  /** Stable quest ID. */
+  quest: identifier,
+  member: identifier,
+  enrolledAt: timestamp
+});
+var questClaimInputSchema = z5.strictObject({
+  actionId: identifier,
+  /** Quest key or ID. */
+  quest: identifier,
+  /** The outcome's tracker, as `QuestOutcome.tracker` names it. */
+  tracker: identifier,
+  record: z5.string().min(1).max(256),
+  observedAt: timestamp
+});
+var QuestOutcomeState = {
+  Admitted: "admitted",
+  Skipped: "skipped"
+};
+var questOutcomeSchema = z5.object({
+  /** Prerequisite transition identity; absent on older tracker responses. */
+  automatic: identifier.optional(),
+  /** Stable quest ID. */
+  quest: identifier,
+  /** Stable tracker ID of the record decided. */
+  tracker: identifier.nullable(),
+  /** The record's ID in its tracker. */
+  record: z5.string().nullable(),
+  /** Which observation of the record was decided. */
+  observedAt: timestamp.nullable(),
+  state: z5.enum(["admitted", "skipped"]),
+  /**
+   * Why it was skipped, one of `trackerSkipCodes` or a code a newer Relay sends; null when
+   * admitted. Show an unknown code by its `reason`.
+   */
+  code: z5.string().nullable(),
+  /** Why it was skipped, for people; null when admitted. */
+  reason: z5.string().nullable(),
+  /** Which window refused admission when `code` is `outside-window`. */
+  window: z5.enum(["tracker", "quest"]).optional(),
+  /** The admitted attempt. */
+  attempt: identifier.nullable(),
+  /** The member can claim it with `relay.quests.claim()`. */
+  claimable: z5.boolean(),
+  createdAt: timestamp,
+  updatedAt: timestamp
+});
+var questOutcomeQuerySchema = z5.strictObject({
+  /** Quest key or ID. */
+  quest: identifier.optional(),
+  state: z5.enum(["admitted", "skipped"]).optional(),
+  /** Only skips with this code, such as `historical`. */
+  code: z5.string().min(1).max(100).optional(),
+  cursor: pageCursorSchema.optional()
+});
+var questOutcomePageSchema = z5.object({
+  items: z5.array(questOutcomeSchema),
+  nextCursor: pageCursorSchema.nullable()
+});
+
+// src/participant-rewards.ts
+import * as z6 from "zod";
+var participantEntitlementsSchema = z6.object({
+  items: z6.array(entitlementSchema)
+});
+var base = {
+  id: z6.string(),
+  status: z6.string(),
+  at: z6.number().nullable(),
+  quest: z6.string().nullable(),
+  completion: z6.string().nullable()
+};
+var known = z6.discriminatedUnion("kind", [
+  z6.object({
+    ...base,
+    kind: z6.literal("points"),
+    ledger: pointLedgerReferenceSchema,
+    amount: z6.number(),
+    reversed: z6.number()
+  }).catchall(z6.json()),
+  z6.object({
+    ...base,
+    kind: z6.literal("tier"),
+    entitlement: entitlementSchema
+  }).catchall(z6.json().transform((value) => value)),
+  z6.object({
+    ...base,
+    kind: z6.literal("integration"),
+    provider: z6.string(),
+    action: z6.string(),
+    roleId: z6.string().optional(),
+    deliveredAt: z6.number().nullable(),
+    revokedAt: z6.number().nullable(),
+    reconciliation: z6.object({ status: z6.string(), ownership: z6.string(), at: z6.number() }).catchall(z6.json()).nullable()
+  }).catchall(z6.json().optional())
+]);
+var participantDeliverySchema = z6.union([
+  known,
+  z6.object({
+    ...base,
+    kind: z6.string().refine((kind) => !["points", "tier", "integration"].includes(kind))
+  }).catchall(z6.json()).transform(({ kind, ...item }) => ({
+    ...item,
+    kind: "unknown",
+    reportedKind: kind
+  }))
+]);
+var participantDeliveriesSchema = z6.object({
+  items: z6.array(participantDeliverySchema)
+});
+
+// src/reward-deliveries.ts
+import * as z7 from "zod";
+var RewardDeliveryAction = {
+  /** Delivers a quest's Discord role reward. */
+  GrantRole: "grant-role",
+  /**
+   * Posts a quest's announcement in a Telegram chat or Discord channel. Its `provider` is
+   * `telegram` or `discord`, and its `roleId` is empty.
+   */
+  PostMessage: "post-message"
+};
+var rewardDeliveryActionSchema = z7.string().min(1).max(64);
+var roleReconciliationSchema = z7.object({
+  status: z7.enum(["pending", "granted", "removed", "preserved", "failed"]),
+  ownership: z7.enum(["unclaimed", "relay", "external"]),
+  at: z7.number(),
+  reason: z7.string().nullable()
+});
+var knownRewardDeliverySchema = z7.object({
+  id: z7.string(),
+  quest: z7.string(),
+  completion: z7.string(),
+  member: z7.string(),
+  provider: z7.literal("discord"),
+  /** `RewardDeliveryAction`, such as `grant-role`. */
+  action: rewardDeliveryActionSchema,
+  roleId: z7.string(),
+  /**
+   * `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, unless revokedAt is set.
+   * Revoke stops pending grants; a late success records deliveredAt but leaves status failed.
+   */
+  status: z7.enum(["pending", "delivered", "failed"]),
+  /** Provider attempts in the current round; an operator retry starts a new round at zero. */
+  attempts: z7.number().int(),
+  /** While pending with a `lastError`, when the next attempt is scheduled. */
+  nextAt: z7.number(),
+  lastError: z7.string().nullable(),
+  createdAt: z7.number(),
+  deliveredAt: z7.number().nullable(),
+  /** First dispatch attempt, retained across retries. Legacy rows use creation time when dispatch timing is unknown. */
+  dispatchedAt: z7.number().nullable().optional(),
+  /** Completion revocation stops retries, including deliveries that had already failed. */
+  revokedAt: z7.number().nullable().optional(),
+  /** Current reconciliation of the pinned Discord membership; original delivery and revoke history stay intact. */
+  reconciliation: roleReconciliationSchema.nullable().optional()
+});
+var futureRewardDeliverySchema = knownRewardDeliverySchema.extend({
+  provider: z7.string(),
+  status: z7.string(),
+  roleId: z7.string().optional(),
+  reconciliation: z7.object({
+    status: z7.string(),
+    ownership: z7.string(),
+    at: z7.number(),
+    reason: z7.string().nullable()
+  }).catchall(z7.json()).nullable().optional()
+}).catchall(z7.json().optional()).refine(
+  (delivery) => delivery.provider !== "discord" || !["pending", "delivered", "failed"].includes(delivery.status) || delivery.reconciliation && (!["pending", "granted", "removed", "preserved", "failed"].includes(
+    delivery.reconciliation.status
+  ) || !["unclaimed", "relay", "external"].includes(
+    delivery.reconciliation.ownership
+  ))
+);
+var rewardDeliverySchema = z7.union([
+  knownRewardDeliverySchema.catchall(z7.json().optional()),
+  futureRewardDeliverySchema
+]);
+var rewardDeliveriesSchema = z7.object({
+  deliveries: z7.array(rewardDeliverySchema),
+  nextCursor: pageCursorSchema.nullable().default(null)
+});
+var rewardDeliveryQuerySchema = z7.strictObject({
+  cursor: pageCursorSchema.optional(),
+  limit: z7.coerce.number().int().min(1).max(500).optional()
+});
+var discordRoleRewardSchema = z7.object({
+  roleId: z7.string(),
+  quests: z7.array(z7.string()),
+  /** Delivery records of this role by `RewardDelivery.status`. */
+  deliveries: z7.object({
+    pending: z7.number().int(),
+    delivered: z7.number().int(),
+    failed: z7.number().int()
+  })
+});
+var discordRoleRewardsSchema = z7.object({
+  roles: z7.array(discordRoleRewardSchema)
+});
+
+export {
+  authProvidersSchema,
+  knownCreatorAccountProviders,
+  creatorAccountProviderSchema,
+  creatorAccountSchema,
+  creatorAccountsSchema,
+  consentWordingMaxLength,
+  knownConsentChannels,
+  memberConsentSchema,
+  memberConsentListSchema,
+  consentInputSchema,
+  memberConsentInputSchema,
+  memberConsentHistorySchema,
+  memberConsentHistoryQuerySchema,
+  collectionCodeSchema,
+  collectionPassSchema,
+  collectionResolveSchema,
+  collectionBeginSchema,
+  collectionPreviewSchema,
+  questEnrollmentInputSchema,
+  memberEnrollmentInputSchema,
+  questEnrollmentSchema,
+  questClaimInputSchema,
+  QuestOutcomeState,
+  questOutcomeSchema,
+  questOutcomeQuerySchema,
+  questOutcomePageSchema,
+  participantEntitlementsSchema,
+  participantDeliverySchema,
+  participantDeliveriesSchema,
+  RewardDeliveryAction,
+  roleReconciliationSchema,
+  knownRewardDeliverySchema,
+  rewardDeliverySchema,
+  rewardDeliveriesSchema,
+  rewardDeliveryQuerySchema,
+  discordRoleRewardSchema,
+  discordRoleRewardsSchema
+};

package/dist/{chunk-MHPKEVEW.js → chunk-CZFXGGEK.js}

@@ -20,6 +20,7 @@ var participantRoutes = [
   { method: "POST", path: "/v1/auth/logout" },
   { method: "GET", path: "/v1/auth/accounts" },
   { method: "GET", path: "/v1/auth/accounts/telegram" },
+  { method: "GET", path: "/v1/auth/sign-in-accounts" },
   { method: "GET", path: "/v1/auth/creator-accounts" },
   { method: "POST", path: "/v1/auth/accounts/disconnect" },
   { method: "POST", path: "/v1/auth/telegram/mini-app" },
@@ -52,6 +53,9 @@ var participantRoutes = [
   { method: "GET", path: "/v1/me/profile" },
   { method: "POST", path: "/v1/me/profile" },
   { method: "POST", path: "/v1/me/profile/avatar" },
+  // The member's marketing consent per channel.
+  { method: "GET", path: "/v1/me/consent" },
+  { method: "POST", path: "/v1/me/consent" },
   { method: "GET", path: `/v1/profiles/:profile${id}` },
   { method: "GET", path: `/v1/profiles/:profile${id}/completions` },
   {
@@ -85,6 +89,7 @@ var participantRoutes = [
   { method: "GET", path: `/v1/leaderboards/:board${id}` },
   { method: "GET", path: "/v1/point-ledgers" },
   { method: "GET", path: "/v1/badges" },
+  { method: "GET", path: "/v1/badges/catalog" },
   { method: "GET", path: "/v1/me/badges" },
   { method: "GET", path: "/v1/profiles/:profile{[\\w-]+}/badges" },
   { method: "GET", path: "/v1/tiered-rewards" }