@domino-sdk/relay 1.55.0 → 1.56.0

package/dist/{chunk-F6HECAXA.js → chunk-ULQU7KC4.js}

@@ -2,10 +2,47 @@ import {
   identifier,
   resourceHandle,
   responseShape
-} from "./chunk-YCOKTQ4E.js";
+} from "./chunk-BHHUSBSD.js";
 
-// src/server/analytics.ts
+// src/youtube.ts
 import * as z from "zod";
+var youtubeShortsNamespace = "youtube-shorts";
+var youtubeShortBodySchema = z.object({
+  title: z.string(),
+  description: z.string(),
+  tags: z.array(z.string()),
+  durationSeconds: z.number().int().nonnegative(),
+  /** When the video was published, epoch milliseconds. */
+  publishedAt: z.number().int().nonnegative()
+});
+var youtubeShortMetrics = ["views", "likes", "comments"];
+
+// src/tiktok.ts
+import * as z2 from "zod";
+var tiktokVideosNamespace = "tiktok-videos";
+var tiktokVideoBodySchema = z2.object({
+  title: z2.string(),
+  /** The creator's caption, `video_description` in TikTok's API. */
+  description: z2.string(),
+  durationSeconds: z2.number().int().nonnegative(),
+  width: z2.number().int().nonnegative(),
+  height: z2.number().int().nonnegative(),
+  /** When the video was posted, epoch milliseconds. */
+  createdAt: z2.number().int().nonnegative(),
+  /** TikTok's shareable link to the video. */
+  shareUrl: z2.string(),
+  /** Whether the creator labelled the video as AI-generated content. */
+  isAigc: z2.boolean()
+});
+var tiktokVideoMetrics = [
+  "views",
+  "likes",
+  "comments",
+  "shares"
+];
+
+// src/server/analytics.ts
+import * as z3 from "zod";
 function once(build) {
   let built;
   return () => built ??= build();
@@ -22,41 +59,41 @@ function lazyShape(builders) {
   return shape;
 }
 var analyticsRanges = ["7d", "30d", "90d", "all"];
-var amount = once(() => z.number().int().safe());
-var amounts = once(() => z.array(amount()));
-var instant = once(() => z.iso.datetime({ offset: true }));
+var amount = once(() => z3.number().int().safe());
+var amounts = once(() => z3.array(amount()));
+var instant = once(() => z3.iso.datetime({ offset: true }));
 var bucket = once(
-  () => z.object({
+  () => z3.object({
     /** The period's label in its time zone, such as `2026-10-08@Europe/Budapest` or `2026-W41@UTC`. */
-    key: z.string(),
+    key: z3.string(),
     start: instant(),
     end: instant()
   })
 );
 var range = once(
-  () => z.object({
-    key: z.enum(analyticsRanges),
+  () => z3.object({
+    key: z3.enum(analyticsRanges),
     from: instant(),
     /** Now, by the database's clock, when the read ran. */
     to: instant(),
-    bucket: z.enum(["day", "week"]),
+    bucket: z3.enum(["day", "week"]),
     /** The project calendar's time zone now. Buckets before a time zone change follow the old one. */
-    timeZone: z.string(),
-    buckets: z.array(bucket())
+    timeZone: z3.string(),
+    buckets: z3.array(bucket())
   })
 );
 var previousRange = once(
-  () => z.object({ from: instant(), to: instant() }).optional()
+  () => z3.object({ from: instant(), to: instant() }).optional()
 );
-var analyticsQuerySchema = z.strictObject(
+var analyticsQuerySchema = z3.strictObject(
   lazyShape({
-    range: () => z.enum(analyticsRanges),
+    range: () => z3.enum(analyticsRanges),
     /** A point ledger's key or ID. Defaults to the first ledger that is not archived. */
     ledger: () => identifier.optional()
   })
 );
 var metric = once(
-  () => z.object({
+  () => z3.object({
     total: amount(),
     previousTotal: amount().optional(),
     series: amounts()
@@ -64,9 +101,9 @@ var metric = once(
 );
 var optionalMetric = once(() => metric().optional());
 var quest = once(
-  () => z.object({
+  () => z3.object({
     quest: identifier,
-    title: z.string(),
+    title: z3.string(),
     /** Attempts created in the range. */
     attempts: amount(),
     /** Completions in the range that were never revoked. */
@@ -78,57 +115,57 @@ var quest = once(
     /** Attempts created in the range that went to staff review. */
     needsReview: amount(),
     /** `rejected ÷ decided`, or null below 10 decided attempts. */
-    rejectionRate: z.number().min(0).max(1).nullable(),
+    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.
      */
-    topReasons: z.array(
-      z.object({
-        reason: z.string(),
-        code: z.string().nullable(),
+    topReasons: z3.array(
+      z3.object({
+        reason: z3.string(),
+        code: z3.string().nullable(),
         count: amount()
       })
     ),
     /** Rejections by who made them: the evaluator, staff, an exhausted budget, an expired deferral. */
-    rejectionsBySource: z.object({
+    rejectionsBySource: z3.object({
       evaluator: amount(),
       staff: amount(),
       budget: amount(),
       expired: amount()
     }),
     /** Attempts and completions per bucket. */
-    series: z.object({ attempts: amounts(), completions: amounts() })
+    series: z3.object({ attempts: amounts(), completions: amounts() })
   })
 );
-var analyticsReadSchema = z.object(
+var analyticsReadSchema = z3.object(
   lazyShape({
     range,
     previous: previousRange,
-    members: () => z.object({
+    members: () => z3.object({
       /** Members who joined the project. */
       signUps: metric(),
       /** Distinct members with an attempt; the total counts each member once over the range. */
       active: metric()
     }),
-    quests: () => z.object({
+    quests: () => z3.object({
       attempts: metric(),
       completions: metric(),
       rejections: metric(),
       needsReview: metric(),
       /** Quests with activity in the range, most attempted first. */
-      byQuest: z.array(quest())
+      byQuest: z3.array(quest())
     }),
-    points: () => z.object({
+    points: () => z3.object({
       /** The project's point ledgers, oldest first. */
-      ledgers: z.array(
-        z.object({ key: identifier, name: z.string(), archived: z.boolean() })
+      ledgers: z3.array(
+        z3.object({ key: identifier, name: z3.string(), archived: z3.boolean() })
       ),
       /** The ledger this section reads, or null when the project has none to read. */
       ledger: identifier.nullable(),
       /** Whether the ledger has a spend entry. `spent` and `net` are present only when it does. */
-      hasSpending: z.boolean(),
+      hasSpending: z3.boolean(),
       /** Points in award entries. */
       awarded: metric(),
       /** Points in spend entries, as a positive number. */
@@ -139,20 +176,20 @@ var analyticsReadSchema = z.object(
       membersEarning: metric()
     }),
     /** Fulfilled offer redemptions. Present only when the project has an offer. */
-    offers: () => z.object({
+    offers: () => z3.object({
       redemptions: metric(),
       /** Every offer, most redeemed first. */
-      byOffer: z.array(
-        z.object({
+      byOffer: z3.array(
+        z3.object({
           offer: identifier,
-          title: z.string(),
+          title: z3.string(),
           redemptions: amount(),
           series: amounts()
         })
       )
     }).optional(),
     /** Present only when the project has a referral program. */
-    referrals: () => z.object({
+    referrals: () => z3.object({
       /** Referrals accepted. */
       accepted: metric(),
       /** Active qualifications, by when they first qualified; suspended referrals still count. */
@@ -163,13 +200,13 @@ var analyticsReadSchema = z.object(
        * `acceptedQualified.total ÷ accepted.total` is the share of the range's friends who have
        * qualified since, never above 1.
        */
-      acceptedQualified: z.object({
+      acceptedQualified: z3.object({
         total: amount(),
         previousTotal: amount().optional()
       })
     }).optional(),
     /** Present only in the test environment. */
-    testEnvironment: () => z.object({
+    testEnvironment: () => z3.object({
       /** When a test member was last reset, deleting their history, or null. */
       lastResetAt: instant().nullable(),
       /** Test members whose clock is advanced, so their activity can be dated in the future. */
@@ -360,17 +397,17 @@ var analyticsCatalog = {
 var analyticsMetricIds = Object.keys(
   analyticsCatalog
 );
-var analyticsCatalogSchema = z.object(
+var analyticsCatalogSchema = z3.object(
   lazyShape({
-    metrics: () => z.array(
-      z.object({
-        id: z.string(),
-        definition: z.string(),
-        kind: z.enum(["count", "distinct", "rate"]),
-        breakdowns: z.array(z.string()),
-        filters: z.array(z.string()),
-        charts: z.array(z.string()),
-        ledger: z.boolean(),
+    metrics: () => z3.array(
+      z3.object({
+        id: z3.string(),
+        definition: z3.string(),
+        kind: z3.enum(["count", "distinct", "rate"]),
+        breakdowns: z3.array(z3.string()),
+        filters: z3.array(z3.string()),
+        charts: z3.array(z3.string()),
+        ledger: z3.boolean(),
         /** For a rate, the denominator below which a value is empty. */
         minimumDenominator: amount().optional()
       })
@@ -378,63 +415,63 @@ var analyticsCatalogSchema = z.object(
   })
 );
 var analyticsQueryLimit = 100;
-var analyticsMetricQuerySchema = z.strictObject(
+var analyticsMetricQuerySchema = z3.strictObject(
   lazyShape({
-    metric: () => z.string().min(1).max(100),
-    range: () => z.enum(analyticsRanges),
-    breakdown: () => z.string().min(1).max(100).optional(),
+    metric: () => z3.string().min(1).max(100),
+    range: () => z3.enum(analyticsRanges),
+    breakdown: () => z3.string().min(1).max(100).optional(),
     /** Each filter names one key or a list of keys; a list matches any of them. */
-    filter: () => z.record(
-      z.string().min(1).max(100),
-      z.union([identifier, z.array(identifier).min(1).max(100)])
+    filter: () => z3.record(
+      z3.string().min(1).max(100),
+      z3.union([identifier, z3.array(identifier).min(1).max(100)])
     ).optional(),
     /** A point ledger's key or ID, archived ledgers included. Points metrics need one. */
     ledger: () => identifier.optional(),
     /** Breakdown rows to return, 1 to 100 (default 100); the rest are summed into `other`. */
-    limit: () => z.number().int().optional()
+    limit: () => z3.number().int().optional()
   })
 );
-var measureNumber = once(() => z.number().nullable());
+var measureNumber = once(() => z3.number().nullable());
 var measure = once(() => ({
   total: measureNumber(),
   previousTotal: measureNumber().optional(),
-  series: z.array(measureNumber())
+  series: z3.array(measureNumber())
 }));
-var analyticsMetricResultSchema = z.object(
+var analyticsMetricResultSchema = z3.object(
   lazyShape({
-    metric: () => z.string(),
+    metric: () => z3.string(),
     /** How the value reads: a `count`, a `distinct` count of members, or a `rate` from 0 to 1. */
-    kind: () => z.enum(["count", "distinct", "rate"]),
+    kind: () => z3.enum(["count", "distinct", "rate"]),
     range,
     previous: previousRange,
     /** The point ledger a points metric read, by key. */
     ledger: () => identifier.optional(),
     /** The metric over everything the filters match, every breakdown row included. */
-    value: () => z.object(measure()),
-    breakdown: () => z.object({
-      dimension: z.string(),
+    value: () => z3.object(measure()),
+    breakdown: () => z3.object({
+      dimension: z3.string(),
       /**
        * Sorted by total, largest first (an empty rate last), at most `limit`. Every matching
        * quest, offer, program, group, tracker or leaderboard that is not archived has a row, and an archived one has a row
        * when it has activity in the range or the range before.
        */
-      rows: z.array(
-        z.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. */
-          key: z.string(),
-          title: z.string(),
-          archived: z.boolean(),
+          key: z3.string(),
+          title: z3.string(),
+          archived: z3.boolean(),
           ...measure()
         })
       ),
       /** The rows past `limit`, summed; for a rate, their summed numerators over denominators. */
-      other: z.object({ rows: amount(), ...measure() }).optional()
+      other: z3.object({ rows: amount(), ...measure() }).optional()
     }).optional()
   })
 );
 
 // src/dashboards.ts
-import * as z2 from "zod";
+import * as z4 from "zod";
 var dashboardLimits = { panels: 24, dashboards: 20 };
 var defaultPanelWidths = {
   number: 1,
@@ -442,63 +479,63 @@ var defaultPanelWidths = {
   bar: 2,
   table: 4
 };
-var title = z2.string().trim().min(1).max(120);
-var description = z2.string().trim().min(1).max(500);
-var filterValue = z2.union([identifier, z2.array(identifier).min(1).max(100)]);
-var filter = z2.record(z2.string().min(1).max(100), filterValue);
+var title = z4.string().trim().min(1).max(120);
+var description = z4.string().trim().min(1).max(500);
+var filterValue = z4.union([identifier, z4.array(identifier).min(1).max(100)]);
+var filter = z4.record(z4.string().min(1).max(100), filterValue);
 var panelFields = {
   key: identifier,
   title,
   description: description.optional(),
   /** A metric ID from the catalog (`analytics.catalog`). */
-  metric: z2.string().min(1).max(100),
-  breakdown: z2.string().min(1).max(100).optional(),
+  metric: z4.string().min(1).max(100),
+  breakdown: z4.string().min(1).max(100).optional(),
   /** Each filter names one key or a list of keys; a list matches any of them. */
   filter: filter.optional(),
   /** The point ledger a points metric reads, by key. */
   ledger: identifier.optional(),
-  chart: z2.enum(analyticsCharts)
+  chart: z4.enum(analyticsCharts)
 };
-var dashboardPanelAuthoringSchema = z2.strictObject({
+var dashboardPanelAuthoringSchema = z4.strictObject({
   ...panelFields,
-  width: z2.number().int().min(1).max(4).optional()
+  width: z4.number().int().min(1).max(4).optional()
 });
-var dashboardAuthoringSchema = z2.strictObject({
+var dashboardAuthoringSchema = z4.strictObject({
   key: identifier,
   title,
   description: description.optional(),
   /** The range the dashboard opens with. Defaults to `30d`. */
-  defaultRange: z2.enum(analyticsRanges).optional(),
+  defaultRange: z4.enum(analyticsRanges).optional(),
   /** Orders dashboards in lists: by position, those without one last, then by title. */
-  position: z2.number().int().min(0).max(1e3).optional(),
-  sections: z2.array(
-    z2.strictObject({
+  position: z4.number().int().min(0).max(1e3).optional(),
+  sections: z4.array(
+    z4.strictObject({
       title: title.optional(),
-      panels: z2.array(dashboardPanelAuthoringSchema).min(1).max(100)
+      panels: z4.array(dashboardPanelAuthoringSchema).min(1).max(100)
     })
   ).min(1).max(100)
 });
-var dashboardDefinitionSchema = z2.strictObject({
+var dashboardDefinitionSchema = z4.strictObject({
   key: identifier,
   title,
   description: description.optional(),
-  defaultRange: z2.enum(analyticsRanges),
-  position: z2.number().int().min(0).max(1e3).optional(),
-  sections: z2.array(
-    z2.strictObject({
+  defaultRange: z4.enum(analyticsRanges),
+  position: z4.number().int().min(0).max(1e3).optional(),
+  sections: z4.array(
+    z4.strictObject({
       title: title.optional(),
-      panels: z2.array(
-        z2.strictObject({
+      panels: z4.array(
+        z4.strictObject({
           ...panelFields,
-          width: z2.number().int().min(1).max(4)
+          width: z4.number().int().min(1).max(4)
         })
       )
     })
   )
 });
-var dashboardArtifactSchema = z2.union([
+var dashboardArtifactSchema = z4.union([
   dashboardAuthoringSchema,
-  z2.object({ code: z2.string().min(1).max(2e6) }).strict()
+  z4.object({ code: z4.string().min(1).max(2e6) }).strict()
 ]);
 function normalizeDashboard(input) {
   const dashboard = dashboardAuthoringSchema.parse(input);
@@ -603,11 +640,11 @@ function dashboardIssue(dashboard) {
   return null;
 }
 var dashboardPreviewSchema = responseShape(
-  z2.object({
+  z4.object({
     key: identifier,
-    title: z2.string(),
+    title: z4.string(),
     /** `unchanged`: the definition equals the published one, and publishing writes no version. */
-    change: z2.enum(["created", "updated", "unchanged"]),
+    change: z4.enum(["created", "updated", "unchanged"]),
     definition: dashboardDefinitionSchema
   })
 );
@@ -635,6 +672,12 @@ function defineDashboard(input) {
 }
 
 export {
+  youtubeShortsNamespace,
+  youtubeShortBodySchema,
+  youtubeShortMetrics,
+  tiktokVideosNamespace,
+  tiktokVideoBodySchema,
+  tiktokVideoMetrics,
   analyticsRanges,
   analyticsQuerySchema,
   analyticsReadSchema,

package/dist/{chunk-WHMXXHPX.js → chunk-VSHV7FEA.js}

@@ -2,7 +2,7 @@ import {
   accountConnectionSchema,
   identifier,
   pageCursorSchema
-} from "./chunk-YCOKTQ4E.js";
+} from "./chunk-BHHUSBSD.js";
 
 // src/point-ledgers.ts
 import * as z from "zod";

package/dist/{chunk-YE3XYB2F.js → chunk-W5U2WXG3.js}

@@ -4,10 +4,10 @@ import {
   imageFieldsSchema,
   imageInspectionSchema,
   imageSightingsSchema
-} from "./chunk-YEVD4A5X.js";
+} from "./chunk-CK7HO32Z.js";
 import {
   photoResultSchema
-} from "./chunk-YCOKTQ4E.js";
+} from "./chunk-BHHUSBSD.js";
 
 // src/image-results.ts
 import * as z from "zod";

package/dist/{client-C4zUZKpj.d.ts → client-bX3oTpRu.d.ts}

@@ -1,11 +1,11 @@
 import { m as QuizEvidence, A as Attempt, M as MemberProgress, a as AttemptStatus, o as TrackerSkipCode, i as PointHistoryQuery, g as PointEntryKind, ao as submitSchema, ap as contentPerformanceQuerySchema } from './schema-C4m9RhCR.js';
-import { j as QuestView, k as ResponseSchema, a as PageQuery, c as QuestEnrollmentInput, Q as QuestClaimInput, g as QuestOutcomeQuery, q as questExperienceSchema, l as RewardDeliveryQuery, m as RewardDeliveryAction, n as contentQualificationQuerySchema } from './pages-BFloMpyQ.js';
-import { M as MissingPrerequisite, V as ValueEvidence } from './submission-input-BbdawqVy.js';
+import { l as QuestView, m as ResponseSchema, c as PageQuery, e as QuestEnrollmentInput, Q as QuestClaimInput, i as QuestOutcomeQuery, q as questExperienceSchema, a as CreatorAccountProvider, n as RewardDeliveryQuery, o as RewardDeliveryAction, r as contentQualificationQuerySchema } from './pages-BlLqB8ZQ.js';
+import { M as MissingPrerequisite, V as ValueEvidence } from './submission-input-wTiYGdgA.js';
 import { a as RequestError, b as RequestErrorDetails, c as RequestErrorKind, e as createRelayAction, O as OptionalActionId } from './action-DBzILFx9.js';
 import { b as ParticipantSession, e as exchangeSchema, R as RelayEvent, P as ParticipantActivity } from './participant-activity-iciCEs_8.js';
 import * as z from 'zod';
 import { a as AuthProvider } from './accounts-DRPENuZe.js';
-import { p as referralAcceptSchema, i as LeaderboardQuery, b as CampaignEnrollmentInput, d as CampaignWithdrawalInput, f as LeaderboardHistoryQuery, q as engagementPageQuerySchema } from './groups-O6onGPmC.js';
+import { p as referralAcceptSchema, i as LeaderboardQuery, b as CampaignEnrollmentInput, d as CampaignWithdrawalInput, f as LeaderboardHistoryQuery, q as engagementPageQuerySchema } from './groups-DPE004_V.js';
 import { p as profileUpdateSchema, c as ProfileCompletionQuery } from './profiles-BoOK03cR.js';
 import { w as walletAddressInputSchema, o as walletSignatureSchema, L as LinkedWallet, f as WalletSigner } from './wallet-Ac7OFpOr.js';
 
@@ -94,7 +94,7 @@ declare const RelayErrorCode: {
     readonly Credential: "credential";
     /** A wallet signer failed or the member refused to sign; `cause` is the wallet's own error. */
     readonly WalletSigner: "wallet-signer";
-    /** The member has not met the quest's prerequisites; `missing` lists them. */
+    /** The member has not met the quest's or offer's prerequisites; `missing` lists them. */
     readonly PrerequisitesIncomplete: "prerequisites-incomplete";
     /** The quest is archived or retired: it takes no new participation. */
     readonly QuestClosed: "quest-closed";
@@ -423,7 +423,48 @@ declare function relayClient(options: RelayClientOptions): {
             } | {
                 kind: "paused";
             };
+            missing: ({
+                kind: "completion";
+                quest: string;
+                title: string;
+                scope: "ever";
+            } | {
+                kind: "completion";
+                quest: string;
+                title: string;
+                scope: "period";
+                period: "day" | "week" | "month";
+                resetsAt: number;
+            } | {
+                kind: "balance";
+                balance: string;
+                title: string;
+                minimum: number;
+                current: number;
+            } | {
+                kind: "group";
+                group: string;
+                title: string;
+            })[];
             key?: string | undefined;
+            requires?: ({
+                kind: "completion";
+                quest: string;
+                scope: "ever";
+            } | {
+                kind: "completion";
+                quest: string;
+                scope: "period";
+                period: "day" | "week" | "month";
+            } | {
+                kind: "balance";
+                balance: string;
+                minimum: number;
+            } | {
+                kind: "group";
+                group: string;
+                title: string;
+            })[] | undefined;
         }[]>;
         /** Redeems one offer. Persist `actionId` to retry after an uncertain result. */
         redeem: (offer: string, value?: {
@@ -3667,6 +3708,40 @@ declare function relayClient(options: RelayClientOptions): {
                 }>;
             };
         };
+        /**
+         * The member's creator accounts: the platform accounts they publish from, such as a YouTube
+         * channel, which managed tracker sources read. A creator account is linked only to a
+         * signed-in member, never used to sign in, and linking another one on the same platform
+         * replaces it.
+         */
+        creatorAccounts: {
+            /** One entry per creator-account provider the platform configured. */
+            list: (requestOptions?: RelayRequestOptions) => Promise<{
+                accounts: {
+                    provider: CreatorAccountProvider;
+                    configured: boolean;
+                    status: "disconnected" | "connected" | "reconnect";
+                    subject: string | null;
+                    revision: number;
+                    profile: {
+                        name?: string | undefined;
+                        username?: string | undefined;
+                        imageUrl?: string | undefined;
+                    } | null;
+                }[];
+            }>;
+            /**
+             * Leaves for the provider's consent screen to link an account to the signed-in member.
+             * Answers the URL to open; the browser comes back to the app linked.
+             */
+            connect: (provider: CreatorAccountProvider, requestOptions?: RelayRequestOptions) => Promise<{
+                url: string;
+            }>;
+            /** Unlinks the member's account on `provider`. Records it authored stay. */
+            disconnect: (provider: CreatorAccountProvider, requestOptions?: RelayRequestOptions) => Promise<{
+                ok: boolean;
+            }>;
+        };
         /** The member's connected sign-in accounts, one per provider. */
         accounts: (requestOptions?: RelayRequestOptions) => Promise<{
             provider: "discord" | "google" | "apple" | "x";