@domino-sdk/relay 0.12.0 → 0.13.0

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-NLMEK77N.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,
@@ -739,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),