@domino-sdk/relay 0.17.2 → 0.18.0

package/dist/{chunk-GEJK7LMK.js → chunk-6GH4NC2T.js}

@@ -1,6 +1,6 @@
 import {
   identifier
-} from "./chunk-YUAE6PFY.js";
+} from "./chunk-23ZZTCDK.js";
 
 // src/auth.ts
 import { z } from "zod";

package/dist/{chunk-XNS25KST.js → chunk-FBOW2TLN.js}

@@ -1,11 +1,170 @@
 import {
+  contentMetricSchema,
+  contentMetricsSchema,
   identifier,
   pointsRewardSchema,
   tierRewardSchema
-} from "./chunk-YUAE6PFY.js";
+} from "./chunk-23ZZTCDK.js";
 
-// src/authoring-identity.ts
+// src/engagement.ts
 import { z } from "zod";
+var amount = z.number().int().safe().nonnegative();
+var engagementDefinitionSchema = z.strictObject({
+  key: identifier,
+  qualifiedBy: identifier,
+  balance: identifier,
+  metrics: z.array(contentMetricSchema).min(1).max(6).refine(
+    (metrics) => new Set(metrics).size === metrics.length,
+    "Metrics must be unique"
+  ),
+  baseline: z.literal("historical"),
+  maxAgeMs: z.number().int().positive().max(864e5).default(36e5),
+  budget: z.strictObject({
+    projectDaily: amount.optional(),
+    memberDaily: amount.optional(),
+    projectLifetime: amount.optional()
+  }).default({})
+});
+var engagementScoreInputSchema = z.strictObject({
+  metrics: contentMetricsSchema,
+  baseline: contentMetricsSchema
+});
+var engagementScoreSchema = z.strictObject({
+  target: amount,
+  baseline: amount
+});
+var engagementPublishSchema = z.strictObject({
+  actionId: identifier,
+  code: z.string().min(1).max(1e6)
+});
+var engagementRuleSchema = z.strictObject({
+  version: identifier,
+  definition: engagementDefinitionSchema,
+  publishedAt: amount
+});
+var engagementPageQuerySchema = z.strictObject({
+  rule: identifier,
+  content: z.string().min(1).max(256),
+  member: identifier.optional(),
+  before: z.coerce.number().int().positive().safe().optional()
+});
+var engagementSettlementSchema = z.strictObject({
+  id: identifier,
+  day: z.string(),
+  observation: identifier,
+  qualification: identifier,
+  earned: amount,
+  growth: amount,
+  paid: amount,
+  excluded: amount,
+  entry: identifier.nullable(),
+  createdAt: amount
+});
+var engagementPageSchema = z.strictObject({
+  rule: engagementRuleSchema,
+  account: z.strictObject({
+    member: identifier,
+    earned: amount,
+    accounted: amount,
+    paid: amount,
+    excluded: amount,
+    pending: amount,
+    counters: contentMetricsSchema,
+    baseline: contentMetricsSchema,
+    observation: identifier.nullable(),
+    nextSettlementAt: amount.nullable(),
+    reason: z.string().nullable()
+  }).nullable(),
+  items: z.array(engagementSettlementSchema),
+  next: amount.nullable()
+});
+function defineEngagementReward(input) {
+  const { target, ...config } = input;
+  const definition = engagementDefinitionSchema.parse({
+    ...config,
+    qualifiedBy: typeof input.qualifiedBy === "string" ? input.qualifiedBy : input.qualifiedBy.key
+  });
+  const selected = z.record(z.enum(input.metrics), amount);
+  return {
+    key: definition.key,
+    describe: () => definition,
+    score(raw) {
+      const sample = engagementScoreInputSchema.parse(raw);
+      return engagementScoreSchema.parse({
+        target: target({ metrics: selected.parse(sample.metrics) }),
+        baseline: target({ metrics: selected.parse(sample.baseline) })
+      });
+    }
+  };
+}
+var engagementChangePreviewInputSchema = z.strictObject({
+  code: z.string().min(1).max(1e6)
+});
+var engagementChangeSchema = engagementPublishSchema.extend({
+  expectedVersion: identifier,
+  previewHash: identifier
+});
+var total = z.string().regex(/^(0|[1-9][0-9]*)$/);
+var engagementChangePreviewSchema = z.strictObject({
+  rule: identifier,
+  fromVersion: identifier,
+  toVersion: identifier,
+  previewHash: identifier,
+  definition: engagementDefinitionSchema,
+  boundary: z.literal("available-eligible-observation"),
+  settlement: z.literal("deferred"),
+  summary: z.strictObject({
+    knownAdmissions: amount,
+    accounts: amount,
+    uninitialized: amount,
+    pendingTransitions: amount,
+    earned: total,
+    paid: total,
+    excluded: total,
+    pending: total
+  })
+});
+var engagementVersionPageSchema = z.strictObject({
+  items: z.array(
+    engagementRuleSchema.extend({ previousVersion: identifier.nullable() })
+  ),
+  next: amount.nullable()
+});
+var engagementVersionQuerySchema = z.strictObject({
+  rule: identifier,
+  before: z.coerce.number().int().positive().safe().optional()
+});
+var engagementBoundaryPageSchema = z.strictObject({
+  current: engagementRuleSchema.nullable(),
+  requested: engagementRuleSchema,
+  items: z.array(
+    z.strictObject({
+      from: identifier,
+      to: identifier,
+      baseline: contentMetricsSchema,
+      observedAt: amount,
+      settlement: engagementSettlementSchema
+    })
+  ),
+  next: amount.nullable()
+});
+var engagementArtifactSchema = engagementPublishSchema.omit({
+  actionId: true
+});
+var deploymentEntry = engagementArtifactSchema.extend({
+  rule: engagementRuleSchema
+});
+var engagementDeploymentEntrySchema = z.discriminatedUnion("kind", [
+  deploymentEntry.extend({ kind: z.literal("create") }),
+  deploymentEntry.extend({ kind: z.literal("unchanged") }),
+  deploymentEntry.extend({
+    kind: z.literal("change"),
+    change: engagementChangePreviewSchema
+  })
+]);
+
+// src/authoring-identity.ts
+import { z as z2 } from "zod";
 var authoringIdentityShape = {
   key: identifier.optional(),
   id: identifier.optional()
@@ -30,45 +189,45 @@ function normalizeAuthoringIdentity(value) {
   const { id, key, ...properties } = value;
   return { ...properties, key: identifier.parse(key ?? id) };
 }
-var identitySchema = z.object(authoringIdentityShape).superRefine(validateAuthoringIdentity).transform(normalizeAuthoringIdentity);
+var identitySchema = z2.object(authoringIdentityShape).superRefine(validateAuthoringIdentity).transform(normalizeAuthoringIdentity);
 var authoringKey = (input) => identitySchema.parse(input).key;
 
 // src/referrals.ts
-import { z as z2 } from "zod";
-var rewardSchema = z2.union([pointsRewardSchema, tierRewardSchema]);
-var amount = z2.number().int().safe().nonnegative();
-var reason = z2.string().trim().min(1).max(1e3);
-var referralDefinitionSchema = z2.object({
+import { z as z3 } from "zod";
+var rewardSchema = z3.union([pointsRewardSchema, tierRewardSchema]);
+var amount2 = z3.number().int().safe().nonnegative();
+var reason = z3.string().trim().min(1).max(1e3);
+var referralDefinitionSchema = z3.object({
   id: identifier,
   key: identifier.optional(),
-  title: z2.string().trim().min(1).max(120),
-  enabled: z2.boolean().default(true),
-  qualification: z2.discriminatedUnion("kind", [
-    z2.object({ kind: z2.literal("signup") }).strict(),
-    z2.object({ kind: z2.literal("quest"), quest: identifier }).strict(),
-    z2.object({ kind: z2.literal("external") }).strict()
+  title: z3.string().trim().min(1).max(120),
+  enabled: z3.boolean().default(true),
+  qualification: z3.discriminatedUnion("kind", [
+    z3.object({ kind: z3.literal("signup") }).strict(),
+    z3.object({ kind: z3.literal("quest"), quest: identifier }).strict(),
+    z3.object({ kind: z3.literal("external") }).strict()
   ]),
   inviterGroup: identifier.optional(),
-  rewards: z2.object({
-    inviter: z2.array(rewardSchema).max(10).default([]),
-    invitee: z2.array(rewardSchema).max(10).default([])
+  rewards: z3.object({
+    inviter: z3.array(rewardSchema).max(10).default([]),
+    invitee: z3.array(rewardSchema).max(10).default([])
   }).strict().default({ inviter: [], invitee: [] }),
-  milestones: z2.array(
-    z2.object({
+  milestones: z3.array(
+    z3.object({
       id: identifier,
-      count: amount.min(1),
-      rewards: z2.array(rewardSchema).min(1).max(10)
+      count: amount2.min(1),
+      rewards: z3.array(rewardSchema).min(1).max(10)
     }).strict()
   ).max(30).default([]),
-  bonuses: z2.array(
-    z2.object({
+  bonuses: z3.array(
+    z3.object({
       id: identifier,
       balance: identifier,
-      basisPoints: amount.min(1).max(1e4),
-      quests: z2.array(identifier).min(1).max(100).optional(),
-      external: z2.boolean().default(false),
-      durationDays: amount.min(1).max(36500).optional(),
-      maxPoints: amount.min(1).optional()
+      basisPoints: amount2.min(1).max(1e4),
+      quests: z3.array(identifier).min(1).max(100).optional(),
+      external: z3.boolean().default(false),
+      durationDays: amount2.min(1).max(36500).optional(),
+      maxPoints: amount2.min(1).optional()
     }).strict()
   ).max(20).default([])
 }).strict().superRefine((value, ctx) => {
@@ -78,7 +237,7 @@ var referralDefinitionSchema = z2.object({
     }
   }
 });
-var referralAuthoringSchema = z2.object(referralDefinitionSchema.shape).omit({ id: true }).extend(authoringIdentityShape).strict().superRefine(validateAuthoringIdentity).superRefine((value, ctx) => {
+var referralAuthoringSchema = z3.object(referralDefinitionSchema.shape).omit({ id: true }).extend(authoringIdentityShape).strict().superRefine(validateAuthoringIdentity).superRefine((value, ctx) => {
   for (const entries of [value.milestones, value.bonuses]) {
     if (new Set(entries.map((entry) => entry.id)).size !== entries.length) {
       ctx.addIssue({ code: "custom", message: "Rule keys must be unique" });
@@ -93,276 +252,113 @@ function defineReferral(input) {
     id: definition.key
   };
 }
-var referralArtifactSchema = z2.union([
+var referralArtifactSchema = z3.union([
   referralAuthoringSchema,
-  z2.object({ code: z2.string().min(1).max(2e6) }).strict()
+  z3.object({ code: z3.string().min(1).max(2e6) }).strict()
 ]);
-var publishedReferralSchema = z2.object({
+var publishedReferralSchema = z3.object({
   version: identifier,
   definition: referralDefinitionSchema,
-  publishedAt: amount,
-  actor: z2.string().nullable()
+  publishedAt: amount2,
+  actor: z3.string().nullable()
 });
-var referralAcceptSchema = z2.object({ actionId: identifier, code: identifier }).strict();
-var referralControlSchema = z2.discriminatedUnion("kind", [
-  z2.object({
-    kind: z2.literal("suspend"),
+var referralAcceptSchema = z3.object({ actionId: identifier, code: identifier }).strict();
+var referralControlSchema = z3.discriminatedUnion("kind", [
+  z3.object({
+    kind: z3.literal("suspend"),
     actionId: identifier,
     member: identifier,
-    suspended: z2.boolean(),
+    suspended: z3.boolean(),
     reason
   }).strict(),
-  z2.object({
-    kind: z2.literal("qualify"),
+  z3.object({
+    kind: z3.literal("qualify"),
     actionId: identifier,
     member: identifier,
     program: identifier,
-    qualified: z2.boolean(),
+    qualified: z3.boolean(),
     reason
   }).strict(),
-  z2.object({
-    kind: z2.literal("resolve-reward"),
+  z3.object({
+    kind: z3.literal("resolve-reward"),
     actionId: identifier,
     entitlement: identifier,
     reason
   }).strict()
 ]);
-var referralRelationshipSchema = z2.object({
+var referralRelationshipSchema = z3.object({
   member: identifier,
   inviter: identifier,
-  acceptedAt: amount,
-  suspended: z2.boolean()
+  acceptedAt: amount2,
+  suspended: z3.boolean()
 });
-var referralAccountSchema = z2.object({
+var referralAccountSchema = z3.object({
   id: identifier,
   program: identifier,
-  kind: z2.enum(["bonus", "fixed", "milestone"]),
+  kind: z3.enum(["bonus", "fixed", "milestone"]),
   balance: identifier,
-  earned: amount,
-  settled: amount,
-  outstanding: amount
+  earned: amount2,
+  settled: amount2,
+  outstanding: amount2
 });
-var referralSummarySchema = z2.object({
+var referralSummarySchema = z3.object({
   code: identifier,
-  attributed: amount,
-  programs: z2.array(
-    z2.object({
+  attributed: amount2,
+  programs: z3.array(
+    z3.object({
       definition: referralDefinitionSchema,
-      qualified: amount,
-      milestones: z2.array(
-        z2.object({ id: identifier, count: amount, reached: z2.boolean() })
+      qualified: amount2,
+      milestones: z3.array(
+        z3.object({ id: identifier, count: amount2, reached: z3.boolean() })
       )
     })
   ),
-  accounts: z2.array(referralAccountSchema)
+  accounts: z3.array(referralAccountSchema)
 });
-var referralHistorySchema = z2.object({
-  items: z2.array(
-    z2.object({
-      id: amount,
+var referralHistorySchema = z3.object({
+  items: z3.array(
+    z3.object({
+      id: amount2,
       program: identifier,
       balance: identifier,
-      amount: z2.number().int().safe(),
-      at: amount,
-      reason: z2.string()
+      amount: z3.number().int().safe(),
+      at: amount2,
+      reason: z3.string()
     })
   ),
-  next: amount.nullable()
+  next: amount2.nullable()
 });
-var referralManagementSchema = z2.object({
-  relationships: z2.array(referralRelationshipSchema),
-  qualifications: z2.array(
-    z2.object({
+var referralManagementSchema = z3.object({
+  relationships: z3.array(referralRelationshipSchema),
+  qualifications: z3.array(
+    z3.object({
       member: identifier,
       program: identifier,
-      qualified: z2.boolean(),
-      qualifiedAt: amount
+      qualified: z3.boolean(),
+      qualifiedAt: amount2
     })
   ),
-  accounts: z2.array(
-    referralAccountSchema.extend({ member: identifier, invitee: z2.string() })
+  accounts: z3.array(
+    referralAccountSchema.extend({ member: identifier, invitee: z3.string() })
   ),
-  reviews: z2.array(
-    z2.object({
+  reviews: z3.array(
+    z3.object({
       entitlement: identifier,
       member: identifier,
       program: identifier,
-      reason: z2.string()
+      reason: z3.string()
     })
   ),
-  next: amount.nullable()
-});
-
-// src/trackers.ts
-import { z as z3 } from "zod";
-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
-});
-var trackerPreviewLimits = {
-  pages: 3,
-  posts: 100,
-  days: 30
-};
-var trackerPreviewInputSchema = z3.object({
-  query: trackerSourceSchema.options[0].shape.query,
-  /** Start of the searched window. The window ends when the sample is fetched. */
-  since: timestamp
-}).strict();
-var trackerPreviewSchema = z3.object({
-  query: z3.string(),
-  since: timestamp,
-  fetchedAt: timestamp,
-  pages: count,
-  /** Every match in the sample, newest first, verified or not. */
-  posts: z3.array(xTweetSchema).max(trackerPreviewLimits.posts),
-  /** X had more matches than the sample holds. */
-  more: z3.boolean()
+  next: amount2.nullable()
 });
 
 // src/leaderboards.ts
 import { z as z4 } from "zod";
 var integer = z4.number().int().safe();
-var timestamp2 = integer.nonnegative().max(864e13);
+var timestamp = 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("fixed"), start: timestamp, end: timestamp }).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"),
@@ -413,7 +409,7 @@ var leaderboardArtifactSchema = z4.union([
 var publishedLeaderboardSchema = z4.object({
   version: identifier,
   definition: leaderboardDefinitionSchema,
-  publishedAt: timestamp2,
+  publishedAt: timestamp,
   actor: z4.string().nullable()
 });
 var leaderboardQuerySchema = z4.object({
@@ -432,9 +428,9 @@ var leaderboardPageSchema = z4.object({
   title: z4.string(),
   version: identifier,
   calculation: z4.enum(["balance", "earned", "net"]),
-  period: z4.object({ start: timestamp2.nullable(), end: timestamp2.nullable() }),
-  calculatedAt: timestamp2,
-  lastEntryAt: timestamp2.nullable(),
+  period: z4.object({ start: timestamp.nullable(), end: timestamp.nullable() }),
+  calculatedAt: timestamp,
+  lastEntryAt: timestamp.nullable(),
   total: integer.nonnegative(),
   items: z4.array(leaderboardRowSchema),
   me: leaderboardRowSchema.nullable(),
@@ -452,7 +448,7 @@ var mutationBase = {
   balance: identifier,
   reason: z4.string().trim().min(1).max(1e3)
 };
-var datedMutation = { ...mutationBase, effectiveAt: timestamp2.optional() };
+var datedMutation = { ...mutationBase, effectiveAt: timestamp.optional() };
 var pointsMutationSchema = z4.discriminatedUnion("kind", [
   z4.object({
     ...datedMutation,
@@ -491,8 +487,8 @@ var pointsEntrySchema = z4.object({
   balance: identifier,
   amount: integer,
   kind: z4.enum(["award", "spend", "adjust", "reverse"]),
-  effectiveAt: timestamp2,
-  receivedAt: timestamp2,
+  effectiveAt: timestamp,
+  receivedAt: timestamp,
   quest: identifier.nullable(),
   original: identifier.nullable(),
   reason: z4.string(),
@@ -522,6 +518,23 @@ var leaderboardGroupSchema = z4.object({
 }).strict();
 
 export {
+  engagementDefinitionSchema,
+  engagementScoreInputSchema,
+  engagementScoreSchema,
+  engagementPublishSchema,
+  engagementRuleSchema,
+  engagementPageQuerySchema,
+  engagementSettlementSchema,
+  engagementPageSchema,
+  defineEngagementReward,
+  engagementChangePreviewInputSchema,
+  engagementChangeSchema,
+  engagementChangePreviewSchema,
+  engagementVersionPageSchema,
+  engagementVersionQuerySchema,
+  engagementBoundaryPageSchema,
+  engagementArtifactSchema,
+  engagementDeploymentEntrySchema,
   authoringIdentityShape,
   validateAuthoringIdentity,
   normalizeAuthoringIdentity,
@@ -538,26 +551,6 @@ export {
   referralSummarySchema,
   referralHistorySchema,
   referralManagementSchema,
-  xTweetSchema,
-  trackerSourceSchema,
-  x,
-  customSource,
-  trackerDefinitionSchema,
-  trackerArtifactSchema,
-  defineTracker,
-  publishedTrackerSchema,
-  trackerStatusSchema,
-  trackerControlSchema,
-  trackerRecordInputSchema,
-  trackerRecordSchema,
-  trackerIngestSchema,
-  trackerIngestResultSchema,
-  trackerQuerySchema,
-  trackerPageSchema,
-  trackerSummarySchema,
-  trackerPreviewLimits,
-  trackerPreviewInputSchema,
-  trackerPreviewSchema,
   leaderboardWindowSchema,
   leaderboardDefinitionSchema,
   leaderboardAuthoringSchema,

package/dist/{chunk-MK2E36HR.js → chunk-MVDIVWR5.js}

@@ -1,6 +1,6 @@
 import {
   createRelayClient
-} from "./chunk-TI22MU2X.js";
+} from "./chunk-TQUK4DIW.js";
 
 // src/browser.ts
 function createBrowserRelayClient(options) {