@domino-sdk/relay 1.0.0-next.5 → 1.0.0-next.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (42) hide show
  1. package/README.md +13 -1
  2. package/build.mjs +18 -1
  3. package/dist/authoring.d.ts +322 -14
  4. package/dist/authoring.js +187 -25
  5. package/dist/avatar.d.ts +29 -0
  6. package/dist/avatar.js +21 -0
  7. package/dist/browser.d.ts +19 -3
  8. package/dist/browser.js +6 -6
  9. package/dist/catalog-C09gnPYT.d.ts +3948 -0
  10. package/dist/chunk-7HSTFBMO.js +24 -0
  11. package/dist/{chunk-VH4OQ5VX.js → chunk-ADSP377G.js} +1 -1
  12. package/dist/{chunk-FDWRBMB3.js → chunk-AWLLGCKU.js} +2 -2
  13. package/dist/chunk-DJZB5RY5.js +901 -0
  14. package/dist/chunk-SKETUPST.js +171 -0
  15. package/dist/chunk-UFXBQ6FN.js +257 -0
  16. package/dist/{chunk-NKGJEYZM.js → chunk-UW6R2QGT.js} +610 -719
  17. package/dist/chunk-V7UKZLHA.js +35 -0
  18. package/dist/{chunk-4KNTMNXA.js → chunk-X6FJIPXR.js} +166 -724
  19. package/dist/client-BufGakEt.d.ts +4577 -0
  20. package/dist/collection-BGneJ6Bk.d.ts +114 -0
  21. package/dist/images-e6FW9QSx.d.ts +234 -0
  22. package/dist/index.d.ts +11 -13115
  23. package/dist/index.js +11 -693
  24. package/dist/integrations-C3Sp558f.d.ts +1297 -0
  25. package/dist/internal.d.ts +109 -0
  26. package/dist/internal.js +104 -0
  27. package/dist/point-ledgers-iS00Z_v0.d.ts +37 -0
  28. package/dist/portal-proxy.js +5 -6
  29. package/dist/profiles-BtOXMGcC.d.ts +297 -0
  30. package/dist/react/index.d.ts +51 -34
  31. package/dist/react/index.js +7 -13
  32. package/dist/schema-DCapSPHz.d.ts +3396 -0
  33. package/dist/schema.d.ts +3194 -2366
  34. package/dist/schema.js +539 -3
  35. package/dist/streaks-CwGReWGt.d.ts +73 -0
  36. package/dist/submission-input-Bter6XiI.d.ts +2672 -0
  37. package/dist/units-CwgsPB_r.d.ts +9 -0
  38. package/dist/wallet-Bu6sqJvQ.d.ts +231 -0
  39. package/package.json +17 -4
  40. package/dist/chunk-B76BAJ25.js +0 -624
  41. package/dist/chunk-ONDBQSMU.js +0 -373
  42. package/dist/submission-input-CZDukyb3.d.ts +0 -4998
@@ -1,26 +1,48 @@
1
- // src/content.ts
2
- import { z as z3 } from "zod";
1
+ // src/accounts.ts
2
+ import { z } from "zod";
3
+ var authProviderSchema = z.enum(["google", "apple", "x", "discord"]);
4
+ var accountConnectionSchema = z.object({
5
+ provider: authProviderSchema,
6
+ configured: z.boolean(),
7
+ status: z.enum(["disconnected", "connected", "reconnect"]),
8
+ subject: z.string().nullable(),
9
+ revision: z.number().int().nonnegative()
10
+ });
11
+ var discordMemberInputSchema = z.object({}).strict();
12
+ var discordMessageInputSchema = z.object({
13
+ channelId: z.string().regex(/^[0-9]{1,20}$/),
14
+ messageId: z.string().regex(/^[0-9]{1,20}$/)
15
+ }).strict();
16
+ var discordMemberSchema = z.object({
17
+ userId: z.string().regex(/^[0-9]{1,20}$/).nullable().default(null),
18
+ nickname: z.string().nullable().default(null),
19
+ displayName: z.string().nullable().default(null),
20
+ boostingSince: z.string().datetime({ offset: true }).nullable().default(null),
21
+ roles: z.array(z.string().regex(/^[0-9]{1,20}$/)),
22
+ joinedAt: z.string().datetime({ offset: true }).nullable(),
23
+ pending: z.boolean()
24
+ });
3
25
 
4
26
  // src/identifier.ts
5
- import { z } from "zod";
6
- var identifier = z.string().min(1).max(100).regex(/^[a-zA-Z0-9_-]+$/);
27
+ import { z as z2 } from "zod";
28
+ var identifier = z2.string().min(1).max(100).regex(/^[a-zA-Z0-9_-]+$/);
7
29
 
8
30
  // src/trackers.ts
9
- import { z as z2 } from "zod";
10
- var timestamp = z2.number().int().safe().nonnegative().max(864e13);
11
- var count = z2.number().int().safe().nonnegative();
12
- var externalId = z2.string().min(1).max(256);
31
+ import { z as z3 } from "zod";
32
+ var timestamp = z3.number().int().safe().nonnegative().max(864e13);
33
+ var count = z3.number().int().safe().nonnegative();
34
+ var externalId = z3.string().min(1).max(256);
13
35
  var metric = count.nullable().default(null);
14
- var xTweetSchema = z2.looseObject({
36
+ var xTweetSchema = z3.looseObject({
15
37
  id: externalId,
16
38
  userId: externalId,
17
- content: z2.string(),
18
- createdAt: z2.iso.datetime({ offset: true }),
19
- author: z2.looseObject({
39
+ content: z3.string(),
40
+ createdAt: z3.iso.datetime({ offset: true }),
41
+ author: z3.looseObject({
20
42
  id: externalId,
21
- username: z2.string(),
22
- name: z2.string(),
23
- verified: z2.boolean().nullable().default(null)
43
+ username: z3.string(),
44
+ name: z3.string(),
45
+ verified: z3.boolean().nullable().default(null)
24
46
  }),
25
47
  likeCount: metric,
26
48
  replyCount: metric,
@@ -28,90 +50,90 @@ var xTweetSchema = z2.looseObject({
28
50
  quoteCount: metric,
29
51
  viewCount: metric,
30
52
  bookmarkCount: metric,
31
- isReply: z2.boolean(),
32
- isRetweet: z2.boolean(),
33
- isQuoteTweet: z2.boolean()
53
+ isReply: z3.boolean(),
54
+ isRetweet: z3.boolean(),
55
+ isQuoteTweet: z3.boolean()
34
56
  });
35
- var xContentBodySchema = z2.strictObject({
36
- version: z2.literal(1),
37
- id: z2.string().min(1),
38
- authorId: z2.string().min(1),
57
+ var xContentBodySchema = z3.strictObject({
58
+ version: z3.literal(1),
59
+ id: z3.string().min(1),
60
+ authorId: z3.string().min(1),
39
61
  publishedAt: timestamp,
40
- text: z2.string(),
41
- isReply: z2.boolean(),
42
- isRetweet: z2.boolean(),
43
- isQuoteTweet: z2.boolean(),
44
- media: z2.array(z2.strictObject({ type: z2.string(), url: z2.string() })).nullable(),
45
- mentionedAuthorIds: z2.array(z2.string().min(1)).nullable(),
46
- videoLengthSeconds: z2.number().nonnegative().nullable(),
47
- references: z2.strictObject({
48
- replyId: z2.string().nullable(),
49
- replyAuthorId: z2.string().nullable(),
50
- quoteId: z2.string().nullable(),
51
- quoteAuthorId: z2.string().nullable(),
52
- repostId: z2.string().nullable(),
53
- repostAuthorId: z2.string().nullable()
62
+ text: z3.string(),
63
+ isReply: z3.boolean(),
64
+ isRetweet: z3.boolean(),
65
+ isQuoteTweet: z3.boolean(),
66
+ media: z3.array(z3.strictObject({ type: z3.string(), url: z3.string() })).nullable(),
67
+ mentionedAuthorIds: z3.array(z3.string().min(1)).nullable(),
68
+ videoLengthSeconds: z3.number().nonnegative().nullable(),
69
+ references: z3.strictObject({
70
+ replyId: z3.string().nullable(),
71
+ replyAuthorId: z3.string().nullable(),
72
+ quoteId: z3.string().nullable(),
73
+ quoteAuthorId: z3.string().nullable(),
74
+ repostId: z3.string().nullable(),
75
+ repostAuthorId: z3.string().nullable()
54
76
  })
55
77
  });
56
- var trackerContentQuerySchema = z2.strictObject({
78
+ var trackerContentQuerySchema = z3.strictObject({
57
79
  id: externalId,
58
- observation: z2.string().regex(/^observation_[a-f0-9]{64}$/)
80
+ observation: z3.string().regex(/^observation_[a-f0-9]{64}$/)
59
81
  });
60
82
  var trackerContentReadSchema = trackerContentQuerySchema.extend({
61
83
  member: identifier
62
84
  });
63
85
  var attributionContext = { member: identifier, capturedAt: timestamp };
64
- var trackerEvidenceSchema = z2.strictObject({
86
+ var trackerEvidenceSchema = z3.strictObject({
65
87
  contentRevision: identifier,
66
88
  observation: identifier
67
89
  });
68
- var trackerContentSchema = z2.strictObject({
90
+ var trackerContentSchema = z3.strictObject({
69
91
  tracker: identifier,
70
- source: z2.literal("x"),
92
+ source: z3.literal("x"),
71
93
  evidence: trackerEvidenceSchema,
72
94
  content: xContentBodySchema,
73
95
  observedAt: timestamp,
74
- removed: z2.boolean(),
75
- attribution: z2.discriminatedUnion("kind", [
76
- z2.strictObject({
96
+ removed: z3.boolean(),
97
+ attribution: z3.discriminatedUnion("kind", [
98
+ z3.strictObject({
77
99
  ...attributionContext,
78
- kind: z2.literal("linked"),
79
- account: z2.strictObject({
80
- provider: z2.literal("x"),
81
- issuer: z2.string().min(1),
100
+ kind: z3.literal("linked"),
101
+ account: z3.strictObject({
102
+ provider: z3.literal("x"),
103
+ issuer: z3.string().min(1),
82
104
  subject: externalId,
83
105
  revision: count,
84
106
  linkedAt: timestamp.nullable()
85
107
  })
86
108
  }),
87
- z2.strictObject({ ...attributionContext, kind: z2.literal("unlinked") }),
88
- z2.strictObject({
109
+ z3.strictObject({ ...attributionContext, kind: z3.literal("unlinked") }),
110
+ z3.strictObject({
89
111
  ...attributionContext,
90
- kind: z2.literal("different-author")
112
+ kind: z3.literal("different-author")
91
113
  })
92
114
  ])
93
115
  });
94
- var identityKindSchema = z2.enum(["wallet", "x", "discord", "member"]);
95
- var accountRoleSchema = z2.string().regex(
116
+ var identityKindSchema = z3.enum(["wallet", "x", "discord", "member"]);
117
+ var accountRoleSchema = z3.string().regex(
96
118
  /^[a-zA-Z][a-zA-Z0-9_]{0,39}$/,
97
119
  "Name roles like author or recipient: a letter, then letters, digits or underscores"
98
120
  );
99
121
  var xAccountRoles = ["author", "inReplyTo"];
100
122
  var distinct = (values) => new Set(values).size === values.length;
101
- var xSearchSourceSchema = z2.object({
102
- kind: z2.literal("x-search"),
103
- query: z2.string().trim().min(1).max(2e3)
123
+ var xSearchSourceSchema = z3.object({
124
+ kind: z3.literal("x-search"),
125
+ query: z3.string().trim().min(1).max(2e3)
104
126
  }).strict();
105
- var customSourceSchema = z2.object({
106
- kind: z2.literal("custom"),
127
+ var customSourceSchema = z3.object({
128
+ kind: z3.literal("custom"),
107
129
  namespace: identifier,
108
130
  /**
109
131
  * The identity kinds a record's author and named accounts can be, attributed to members
110
132
  * through verified links. Omitted when authors are opaque IDs, which no quest can pay.
111
133
  */
112
- identities: z2.array(identityKindSchema).min(1).max(4).refine(distinct, "List each identity kind once").optional(),
134
+ identities: z3.array(identityKindSchema).min(1).max(4).refine(distinct, "List each identity kind once").optional(),
113
135
  /** Roles of the named accounts records can carry besides their author, such as `recipient`. */
114
- accounts: z2.array(accountRoleSchema).min(1).max(10).refine(distinct, "List each account role once").refine(
136
+ accounts: z3.array(accountRoleSchema).min(1).max(10).refine(distinct, "List each account role once").refine(
115
137
  (roles) => !roles.includes("author"),
116
138
  "author is every record's own role; name other accounts"
117
139
  ).optional(),
@@ -121,7 +143,7 @@ var customSourceSchema = z2.object({
121
143
  *
122
144
  * @deprecated Use `identities: ["wallet"]`.
123
145
  */
124
- authors: z2.literal("wallet").optional()
146
+ authors: z3.literal("wallet").optional()
125
147
  }).strict().refine(
126
148
  (source) => !(source.authors && source.identities),
127
149
  "Use identities, not authors"
@@ -129,7 +151,7 @@ var customSourceSchema = z2.object({
129
151
  (source) => !source.accounts || source.identities,
130
152
  "Named accounts need identities"
131
153
  );
132
- var trackerSourceSchema = z2.discriminatedUnion("kind", [
154
+ var trackerSourceSchema = z3.discriminatedUnion("kind", [
133
155
  xSearchSourceSchema,
134
156
  customSourceSchema
135
157
  ]);
@@ -139,94 +161,83 @@ function sourceIdentities(source) {
139
161
  }
140
162
  return source.identities ?? (source.authors === "wallet" ? ["wallet"] : void 0);
141
163
  }
142
- var x = {
143
- search: (input) => xSearchSourceSchema.parse({ kind: "x-search", ...input })
144
- };
145
- var customSource = (namespace, options = {}) => customSourceSchema.parse({
146
- kind: "custom",
147
- namespace,
148
- ...options
149
- });
150
- var windowSchema = z2.object({ start: timestamp, end: timestamp.optional() }).strict().refine(
164
+ var windowSchema = z3.object({ start: timestamp, end: timestamp.optional() }).strict().refine(
151
165
  (w) => w.end === void 0 || w.end > w.start,
152
166
  "End must follow start"
153
167
  );
154
- var trackerDefinitionSchema = z2.object({
168
+ var trackerDefinitionSchema = z3.object({
155
169
  key: identifier,
156
- title: z2.string().trim().min(1).max(120),
170
+ title: z3.string().trim().min(1).max(120),
157
171
  source: trackerSourceSchema,
158
172
  window: windowSchema,
159
- refreshSeconds: z2.number().int().min(300).max(86400).default(21600),
160
- maxPages: z2.number().int().min(1).max(1e3).default(60)
173
+ refreshSeconds: z3.number().int().min(300).max(86400).default(21600),
174
+ maxPages: z3.number().int().min(1).max(1e3).default(60)
161
175
  }).strict();
162
- var trackerArtifactSchema = z2.union([
176
+ var trackerArtifactSchema = z3.union([
163
177
  trackerDefinitionSchema,
164
- z2.object({ code: z2.string().min(1).max(2e6) }).strict()
178
+ z3.object({ code: z3.string().min(1).max(2e6) }).strict()
165
179
  ]);
166
- function defineTracker(input) {
167
- return trackerDefinitionSchema.parse(input);
168
- }
169
- var publishedTrackerSchema = z2.object({
180
+ var publishedTrackerSchema = z3.object({
170
181
  id: identifier,
171
182
  version: identifier,
172
183
  definition: trackerDefinitionSchema,
173
184
  publishedAt: timestamp,
174
- actor: z2.string().nullable()
185
+ actor: z3.string().nullable()
175
186
  });
176
- var trackerStatusSchema = z2.object({
187
+ var trackerStatusSchema = z3.object({
177
188
  published: publishedTrackerSchema,
178
- paused: z2.boolean(),
179
- state: z2.enum(["idle", "syncing", "error", "complete"]),
189
+ paused: z3.boolean(),
190
+ state: z3.enum(["idle", "syncing", "error", "complete"]),
180
191
  lastStartedAt: timestamp.nullable(),
181
192
  lastCompletedAt: timestamp.nullable(),
182
193
  nextSyncAt: timestamp.nullable(),
183
- coverage: z2.enum(["unknown", "partial", "complete"]),
184
- error: z2.string().nullable(),
194
+ coverage: z3.enum(["unknown", "partial", "complete"]),
195
+ error: z3.string().nullable(),
185
196
  records: count
186
197
  });
187
- var trackerControlSchema = z2.object({
198
+ var trackerControlSchema = z3.object({
188
199
  actionId: identifier,
189
- action: z2.enum(["pause", "resume", "refresh"])
200
+ action: z3.enum(["pause", "resume", "refresh"])
190
201
  }).strict();
191
- var trackerAccountSchema = z2.strictObject({
202
+ var trackerAccountSchema = z3.strictObject({
192
203
  kind: identityKindSchema.optional(),
193
204
  id: externalId
194
205
  });
195
- var trackerRecordInputSchema = z2.object({
206
+ var trackerRecordInputSchema = z3.object({
196
207
  id: externalId,
197
208
  occurredAt: timestamp,
198
209
  observedAt: timestamp,
199
- author: z2.object({
210
+ author: z3.object({
200
211
  id: externalId,
201
- verified: z2.boolean().nullable().default(null),
212
+ verified: z3.boolean().nullable().default(null),
202
213
  /** The author's identity kind; needed when the source names more than one. */
203
214
  kind: identityKindSchema.optional()
204
215
  }).strict().nullable().default(null),
205
216
  /** Named accounts besides the author, by the roles the custom source declares. */
206
- accounts: z2.record(accountRoleSchema, trackerAccountSchema).refine(
217
+ accounts: z3.record(accountRoleSchema, trackerAccountSchema).refine(
207
218
  (accounts) => Object.keys(accounts).length <= 10,
208
219
  "At most 10 accounts"
209
220
  ).optional(),
210
- data: z2.record(z2.string(), z2.json()),
211
- removed: z2.boolean().default(false)
221
+ data: z3.record(z3.string(), z3.json()),
222
+ removed: z3.boolean().default(false)
212
223
  }).strict().refine(
213
224
  (v) => new TextEncoder().encode(JSON.stringify(v.data)).byteLength <= 131072,
214
225
  "Record exceeds 128 KB"
215
226
  );
216
227
  var trackerRecordSchema = trackerRecordInputSchema.safeExtend({
217
- source: z2.string(),
228
+ source: z3.string(),
218
229
  firstSeenAt: timestamp,
219
230
  /** Present only when includeEvidence is true; custom sources have no X evidence. */
220
231
  evidence: trackerEvidenceSchema.nullable().optional()
221
232
  });
222
- var trackerIngestSchema = z2.object({
233
+ var trackerIngestSchema = z3.object({
223
234
  actionId: identifier,
224
- records: z2.array(trackerRecordInputSchema).min(1).max(100)
235
+ records: z3.array(trackerRecordInputSchema).min(1).max(100)
225
236
  }).strict();
226
- var trackerIngestResultSchema = z2.object({
237
+ var trackerIngestResultSchema = z3.object({
227
238
  stored: count,
228
239
  /** Tracker-trigger decisions this ingest caused. Absent from servers without tracker triggers. */
229
- admissions: z2.object({
240
+ admissions: z3.object({
230
241
  admitted: count,
231
242
  skipped: count,
232
243
  /**
@@ -247,11 +258,11 @@ var trackerOutcomeFields = {
247
258
  /** The release admitted, or the one active when the observation was skipped. */
248
259
  release: identifier,
249
260
  /** The account attribution resolved or failed to resolve, such as a CAIP-10 wallet ID. */
250
- account: z2.string().nullable(),
261
+ account: z3.string().nullable(),
251
262
  createdAt: timestamp,
252
263
  updatedAt: timestamp,
253
264
  /** Null for automatic decisions; the staff actor after a retry. */
254
- actor: z2.string().nullable()
265
+ actor: z3.string().nullable()
255
266
  };
256
267
  var trackerSkipCodes = [
257
268
  /** The quest is paused or no longer active. */
@@ -279,84 +290,84 @@ var trackerSkipCodes = [
279
290
  /** The attributed member has not completed the quest's prerequisites. */
280
291
  "prerequisites-incomplete"
281
292
  ];
282
- var trackerOutcomeSchema = z2.discriminatedUnion("state", [
283
- z2.strictObject({
293
+ var trackerOutcomeSchema = z3.discriminatedUnion("state", [
294
+ z3.strictObject({
284
295
  ...trackerOutcomeFields,
285
- state: z2.literal("admitted"),
286
- code: z2.null(),
287
- reason: z2.null(),
296
+ state: z3.literal("admitted"),
297
+ code: z3.null(),
298
+ reason: z3.null(),
288
299
  /** The attributed member. */
289
300
  member: identifier,
290
301
  /** The admitted attempt. Its evaluation, decision and rewards live on the attempt. */
291
302
  attempt: identifier
292
303
  }),
293
- z2.strictObject({
304
+ z3.strictObject({
294
305
  ...trackerOutcomeFields,
295
- state: z2.literal("skipped"),
306
+ state: z3.literal("skipped"),
296
307
  /** Why the observation was skipped, as one of `trackerSkipCodes`. */
297
- code: z2.string().min(1),
308
+ code: z3.string().min(1),
298
309
  /** Why the observation was skipped, for people. */
299
- reason: z2.string(),
310
+ reason: z3.string(),
300
311
  /** The attributed member, when attribution got that far. */
301
312
  member: identifier.nullable(),
302
313
  attempt: identifier.nullable()
303
314
  })
304
315
  ]);
305
- var trackerOutcomeQuerySchema = z2.strictObject({
316
+ var trackerOutcomeQuerySchema = z3.strictObject({
306
317
  /** Quest key or ID. */
307
318
  quest: identifier.optional(),
308
319
  record: externalId.optional(),
309
320
  member: identifier.optional(),
310
- state: z2.enum(["admitted", "skipped"]).optional(),
321
+ state: z3.enum(["admitted", "skipped"]).optional(),
311
322
  /** Only skips with this code, such as `unlinked-account`. */
312
- code: z2.string().min(1).max(100).optional(),
313
- limit: z2.coerce.number().int().min(1).max(100).default(25),
323
+ code: z3.string().min(1).max(100).optional(),
324
+ limit: z3.coerce.number().int().min(1).max(100).default(25),
314
325
  /** Opaque cursor from `next`: older outcomes. */
315
- before: z2.string().max(512).optional()
326
+ before: z3.string().max(512).optional()
316
327
  });
317
- var trackerOutcomePageSchema = z2.strictObject({
328
+ var trackerOutcomePageSchema = z3.strictObject({
318
329
  /** Newest first. */
319
- items: z2.array(trackerOutcomeSchema).max(100),
320
- next: z2.string().nullable()
330
+ items: z3.array(trackerOutcomeSchema).max(100),
331
+ next: z3.string().nullable()
321
332
  });
322
- var trackerOutcomeRetrySchema = z2.strictObject({
333
+ var trackerOutcomeRetrySchema = z3.strictObject({
323
334
  actionId: identifier,
324
335
  /** Quest key or ID. */
325
336
  quest: identifier,
326
337
  record: externalId,
327
338
  observedAt: timestamp
328
339
  });
329
- var booleanQuery = z2.union([
330
- z2.boolean(),
331
- z2.enum(["true", "false"]).transform((v) => v === "true")
340
+ var booleanQuery = z3.union([
341
+ z3.boolean(),
342
+ z3.enum(["true", "false"]).transform((v) => v === "true")
332
343
  ]);
333
- var trackerQuerySchema = z2.object({
344
+ var trackerQuerySchema = z3.object({
334
345
  author: externalId.optional(),
335
346
  member: identifier.optional(),
336
347
  verified: booleanQuery.optional(),
337
- since: z2.coerce.number().int().safe().nonnegative().optional(),
338
- until: z2.coerce.number().int().safe().nonnegative().optional(),
348
+ since: z3.coerce.number().int().safe().nonnegative().optional(),
349
+ until: z3.coerce.number().int().safe().nonnegative().optional(),
339
350
  removed: booleanQuery.default(false),
340
- minLikes: z2.coerce.number().int().safe().nonnegative().optional(),
341
- minViews: z2.coerce.number().int().safe().nonnegative().optional(),
342
- limit: z2.coerce.number().int().min(1).max(100).default(25),
343
- cursor: z2.string().max(2048).optional(),
351
+ minLikes: z3.coerce.number().int().safe().nonnegative().optional(),
352
+ minViews: z3.coerce.number().int().safe().nonnegative().optional(),
353
+ limit: z3.coerce.number().int().min(1).max(100).default(25),
354
+ cursor: z3.string().max(2048).optional(),
344
355
  includeEvidence: booleanQuery.optional()
345
356
  }).strict().refine(
346
357
  (q) => q.since === void 0 || q.until === void 0 || q.until > q.since,
347
358
  "Until must follow since"
348
359
  );
349
- var trackerPageSchema = z2.object({
360
+ var trackerPageSchema = z3.object({
350
361
  tracker: identifier,
351
- items: z2.array(trackerRecordSchema),
352
- nextCursor: z2.string().nullable(),
362
+ items: z3.array(trackerRecordSchema),
363
+ nextCursor: z3.string().nullable(),
353
364
  total: count,
354
365
  status: trackerStatusSchema
355
366
  });
356
- var trackerSummarySchema = z2.object({
367
+ var trackerSummarySchema = z3.object({
357
368
  records: count,
358
369
  authors: count,
359
- metrics: z2.object({
370
+ metrics: z3.object({
360
371
  likes: count,
361
372
  replies: count,
362
373
  reposts: count,
@@ -372,118 +383,91 @@ var trackerPreviewLimits = {
372
383
  posts: 100,
373
384
  days: 30
374
385
  };
375
- var trackerPreviewInputSchema = z2.object({
386
+ var trackerPreviewInputSchema = z3.object({
376
387
  query: xSearchSourceSchema.shape.query,
377
388
  /** Start of the searched window. The window ends when the sample is fetched. */
378
389
  since: timestamp
379
390
  }).strict();
380
- var trackerPreviewSchema = z2.object({
381
- query: z2.string(),
391
+ var trackerPreviewSchema = z3.object({
392
+ query: z3.string(),
382
393
  since: timestamp,
383
394
  fetchedAt: timestamp,
384
395
  pages: count,
385
396
  /** Every match in the sample, newest first, verified or not. */
386
- posts: z2.array(xTweetSchema).max(trackerPreviewLimits.posts),
397
+ posts: z3.array(xTweetSchema).max(trackerPreviewLimits.posts),
387
398
  /** X had more matches than the sample holds. */
388
- more: z2.boolean()
399
+ more: z3.boolean()
389
400
  });
390
401
 
391
402
  // src/content.ts
392
- var timestamp2 = z3.number().int().safe().nonnegative().max(864e13);
393
- var contentPolicySchema = z3.strictObject({
403
+ import { z as z4 } from "zod";
404
+ var timestamp2 = z4.number().int().safe().nonnegative().max(864e13);
405
+ var contentPolicySchema = z4.strictObject({
394
406
  tracker: identifier,
395
407
  window: trackerDefinitionSchema.shape.window,
396
- enrollment: z3.enum(["none", "required"]).default("none"),
397
- posts: z3.enum(["after-enrollment", "since-start"]).default("after-enrollment"),
398
- historical: z3.enum(["automatic", "claim", "staff"]).default("claim")
408
+ enrollment: z4.enum(["none", "required"]).default("none"),
409
+ posts: z4.enum(["after-enrollment", "since-start"]).default("after-enrollment"),
410
+ historical: z4.enum(["automatic", "claim", "staff"]).default("claim")
399
411
  });
400
- function content(tracker, policy = {}) {
401
- if (tracker.source.kind !== "x-search") {
402
- throw new Error("Content quests require an X tracker");
403
- }
404
- return {
405
- kind: "automatic",
406
- content: contentPolicySchema.parse({
407
- tracker: tracker.key,
408
- window: tracker.window,
409
- ...policy
410
- })
411
- };
412
- }
413
412
  var admittedContentSchema = xContentBodySchema.extend({
414
413
  tracker: identifier,
415
414
  revision: identifier,
416
415
  observation: identifier,
417
416
  attribution: trackerContentSchema.shape.attribution.options[0],
418
417
  enrolledAt: timestamp2.nullable(),
419
- completionKey: z3.string().min(1).max(200)
418
+ completionKey: z4.string().min(1).max(200)
420
419
  });
421
- function perContent() {
422
- return {
423
- kind: "keyed",
424
- perContent: true,
425
- key: (ctx) => {
426
- if (!ctx.content) {
427
- throw new Error("perContent requires an admitted content item");
428
- }
429
- return ctx.content.completionKey;
430
- }
431
- };
432
- }
433
- var contentEnrollmentInputSchema = z3.strictObject({
420
+ var contentEnrollmentInputSchema = z4.strictObject({
434
421
  actionId: identifier,
435
422
  quest: identifier,
436
423
  member: identifier
437
424
  });
438
- var contentEnrollmentSchema = z3.strictObject({
425
+ var contentEnrollmentSchema = z4.strictObject({
439
426
  quest: identifier,
440
427
  member: identifier,
441
428
  enrolledAt: timestamp2
442
429
  });
443
430
  var contentReleaseInputSchema = contentEnrollmentInputSchema.extend({
444
- content: z3.string().min(1).max(256)
431
+ content: z4.string().min(1).max(256)
445
432
  });
446
- var contentAdmissionSchema = z3.strictObject({
433
+ var contentAdmissionSchema = z4.strictObject({
447
434
  quest: identifier,
448
- content: z3.string().min(1).max(256),
435
+ content: z4.string().min(1).max(256),
449
436
  release: identifier,
450
- state: z3.enum(["pending", "admitted", "excluded"]),
451
- reason: z3.string().nullable(),
437
+ state: z4.enum(["pending", "admitted", "excluded"]),
438
+ reason: z4.string().nullable(),
452
439
  attempt: identifier.nullable()
453
440
  });
454
- var contentAdmissionQuerySchema = z3.strictObject({
441
+ var contentAdmissionQuerySchema = z4.strictObject({
455
442
  quest: identifier,
456
443
  member: identifier.optional(),
457
- content: z3.string().min(1).max(256).optional(),
458
- after: z3.string().min(1).max(256).optional()
444
+ content: z4.string().min(1).max(256).optional(),
445
+ after: z4.string().min(1).max(256).optional()
459
446
  });
460
- var contentAdmissionPageSchema = z3.strictObject({
461
- items: z3.array(contentAdmissionSchema),
462
- next: z3.string().nullable()
447
+ var contentAdmissionPageSchema = z4.strictObject({
448
+ items: z4.array(contentAdmissionSchema),
449
+ next: z4.string().nullable()
463
450
  });
464
- function isContentParticipantRoute(path, method) {
465
- return method === "GET" && (path === "/v1/content/admissions" || path === "/v1/content/qualifications" || path === "/v1/content/performance" || path === "/v1/engagement/history" || path === "/v1/engagement/boundaries") || method === "POST" && (path === "/v1/content/enrollments" || path === "/v1/content/claims");
466
- }
467
- var contentQualificationDecisionSchema = z3.strictObject({
468
- kind: z3.enum(["accept", "reject", "review", "superseded"]),
469
- reason: z3.string().nullable()
451
+ var contentQualificationDecisionSchema = z4.strictObject({
452
+ kind: z4.enum(["accept", "reject", "review", "superseded"]),
453
+ reason: z4.string().nullable()
470
454
  });
471
- var contentQualificationQuerySchema = z3.strictObject({
455
+ var contentQualificationQuerySchema = z4.strictObject({
472
456
  quest: identifier,
473
457
  member: identifier.optional(),
474
- content: z3.string().min(1).max(256).optional(),
475
- before: z3.coerce.number().int().positive().safe().optional()
458
+ content: z4.string().min(1).max(256).optional(),
459
+ before: z4.coerce.number().int().positive().safe().optional()
476
460
  });
477
- var contentQualificationSchema = z3.strictObject({
461
+ var contentQualificationSchema = z4.strictObject({
478
462
  quest: identifier,
479
- content: z3.string(),
463
+ content: z4.string(),
480
464
  member: identifier,
481
465
  release: identifier,
482
466
  attempt: identifier,
483
467
  revision: identifier,
484
468
  observation: identifier,
485
- current: z3.boolean(),
486
- state: z3.enum([
469
+ current: z4.boolean(),
470
+ state: z4.enum([
487
471
  "pending",
488
472
  "qualified",
489
473
  "unqualified",
@@ -494,18 +478,18 @@ var contentQualificationSchema = z3.strictObject({
494
478
  "blocked",
495
479
  "unavailable"
496
480
  ]),
497
- reason: z3.string().nullable(),
498
- reward: z3.strictObject({
481
+ reason: z4.string().nullable(),
482
+ reward: z4.strictObject({
499
483
  attempt: identifier.nullable(),
500
484
  completion: identifier.nullable(),
501
- state: z3.enum(["unresolved", "awarded", "excluded"])
485
+ state: z4.enum(["unresolved", "awarded", "excluded"])
502
486
  })
503
487
  });
504
- var contentQualificationPageSchema = z3.strictObject({
505
- items: z3.array(contentQualificationSchema),
506
- next: z3.number().int().positive().safe().nullable()
488
+ var contentQualificationPageSchema = z4.strictObject({
489
+ items: z4.array(contentQualificationSchema),
490
+ next: z4.number().int().positive().safe().nullable()
507
491
  });
508
- var contentMetricSchema = z3.enum([
492
+ var contentMetricSchema = z4.enum([
509
493
  "likes",
510
494
  "replies",
511
495
  "reposts",
@@ -513,21 +497,21 @@ var contentMetricSchema = z3.enum([
513
497
  "views",
514
498
  "bookmarks"
515
499
  ]);
516
- var contentMetricsSchema = z3.partialRecord(
500
+ var contentMetricsSchema = z4.partialRecord(
517
501
  contentMetricSchema,
518
- z3.number().int().safe().nonnegative()
502
+ z4.number().int().safe().nonnegative()
519
503
  );
520
- var contentPerformancePolicySchema = z3.strictObject({
521
- metrics: z3.array(contentMetricSchema).min(1).max(6).refine(
504
+ var contentPerformancePolicySchema = z4.strictObject({
505
+ metrics: z4.array(contentMetricSchema).min(1).max(6).refine(
522
506
  (values) => new Set(values).size === values.length,
523
507
  "Metrics must be unique"
524
508
  ),
525
- maxAgeMs: z3.number().int().positive().max(864e5).default(36e5)
509
+ maxAgeMs: z4.number().int().positive().max(864e5).default(36e5)
526
510
  });
527
511
 
528
512
  // src/streaks.ts
529
- import { z as z4 } from "zod";
530
- var communityTimeZoneSchema = z4.string().min(1).max(100).refine((zone) => {
513
+ import { z as z5 } from "zod";
514
+ var communityTimeZoneSchema = z5.string().min(1).max(100).refine((zone) => {
531
515
  try {
532
516
  if (/^[+-]/.test(zone)) {
533
517
  return false;
@@ -538,52 +522,51 @@ var communityTimeZoneSchema = z4.string().min(1).max(100).refine((zone) => {
538
522
  return false;
539
523
  }
540
524
  }, "Use an IANA community timezone, such as Europe/Budapest");
541
- var streakPolicySchema = z4.object({
542
- kind: z4.literal("streak"),
543
- days: z4.number().int().min(1).max(3650),
525
+ var streakPolicySchema = z5.object({
526
+ kind: z5.literal("streak"),
527
+ days: z5.number().int().min(1).max(3650),
544
528
  timeZone: communityTimeZoneSchema
545
529
  }).strict();
546
- var streak = (options) => streakPolicySchema.parse({ kind: "streak", ...options });
547
- var streakProgressSchema = z4.object({
548
- goal: z4.number().int().positive(),
549
- current: z4.number().int().nonnegative(),
550
- best: z4.number().int().nonnegative(),
551
- today: z4.string(),
552
- todayQualified: z4.boolean(),
530
+ var streakProgressSchema = z5.object({
531
+ goal: z5.number().int().positive(),
532
+ current: z5.number().int().nonnegative(),
533
+ best: z5.number().int().nonnegative(),
534
+ today: z5.string(),
535
+ todayQualified: z5.boolean(),
553
536
  timeZone: communityTimeZoneSchema,
554
- nextBoundary: z4.number().int(),
555
- pendingTimeZone: z4.object({
537
+ nextBoundary: z5.number().int(),
538
+ pendingTimeZone: z5.object({
556
539
  timeZone: communityTimeZoneSchema,
557
- effectiveAt: z4.number().int()
540
+ effectiveAt: z5.number().int()
558
541
  }).nullable(),
559
- days: z4.array(
560
- z4.object({
561
- day: z4.number().int(),
562
- date: z4.string(),
542
+ days: z5.array(
543
+ z5.object({
544
+ day: z5.number().int(),
545
+ date: z5.string(),
563
546
  timeZone: communityTimeZoneSchema,
564
- occurredAt: z4.number().int()
547
+ occurredAt: z5.number().int()
565
548
  })
566
549
  ),
567
- milestone: z4.discriminatedUnion("status", [
568
- z4.object({ status: z4.literal("pending") }),
569
- z4.object({
570
- status: z4.literal("awarded"),
571
- completion: z4.string(),
572
- achievedAt: z4.number().int()
550
+ milestone: z5.discriminatedUnion("status", [
551
+ z5.object({ status: z5.literal("pending") }),
552
+ z5.object({
553
+ status: z5.literal("awarded"),
554
+ completion: z5.string(),
555
+ achievedAt: z5.number().int()
573
556
  }),
574
- z4.object({
575
- status: z4.literal("budget-exhausted"),
576
- budget: z4.string(),
577
- achievedAt: z4.number().int()
557
+ z5.object({
558
+ status: z5.literal("budget-exhausted"),
559
+ budget: z5.string(),
560
+ achievedAt: z5.number().int()
578
561
  })
579
562
  ])
580
563
  });
581
564
 
582
565
  // src/tracker-triggers.ts
583
- import { z as z5 } from "zod";
584
- var timestamp3 = z5.number().int().safe().nonnegative().max(864e13);
585
- var count2 = z5.number().int().safe().nonnegative();
586
- var trackerTriggerModeSchema = z5.enum([
566
+ import { z as z6 } from "zod";
567
+ var timestamp3 = z6.number().int().safe().nonnegative().max(864e13);
568
+ var count2 = z6.number().int().safe().nonnegative();
569
+ var trackerTriggerModeSchema = z6.enum([
587
570
  "new-record",
588
571
  "new-observation",
589
572
  "data-changed"
@@ -591,20 +574,20 @@ var trackerTriggerModeSchema = z5.enum([
591
574
  function defaultTriggerMode(source) {
592
575
  return source === "x-search" ? "new-record" : "new-observation";
593
576
  }
594
- var trackerBoundSchema = z5.union([
595
- z5.number().finite(),
596
- z5.strictObject({ setting: z5.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/) })
577
+ var trackerBoundSchema = z6.union([
578
+ z6.number().finite(),
579
+ z6.strictObject({ setting: z6.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/) })
597
580
  ]);
598
- var dataPath = z5.string().max(200).regex(
581
+ var dataPath = z6.string().max(200).regex(
599
582
  /^[^.\s]+(\.[^.\s]+)*$/,
600
583
  "Use dot-separated keys, such as metrics.likes"
601
584
  );
602
- var trackerWhereSchema = z5.union([
603
- z5.strictObject({
585
+ var trackerWhereSchema = z6.union([
586
+ z6.strictObject({
604
587
  path: dataPath,
605
- equals: z5.union([z5.string().max(1e3), z5.number().finite(), z5.boolean()])
588
+ equals: z6.union([z6.string().max(1e3), z6.number().finite(), z6.boolean()])
606
589
  }),
607
- z5.strictObject({
590
+ z6.strictObject({
608
591
  path: dataPath,
609
592
  gt: trackerBoundSchema.optional(),
610
593
  gte: trackerBoundSchema.optional(),
@@ -617,10 +600,10 @@ var trackerWhereSchema = z5.union([
617
600
  "Compare with equals, gt, gte, lt or lte"
618
601
  )
619
602
  ]);
620
- var trackerTriggerPolicySchema = z5.strictObject({
603
+ var trackerTriggerPolicySchema = z6.strictObject({
621
604
  /** The tracker's authoring key; publication binds it to the tracker's stable ID. */
622
605
  tracker: identifier,
623
- source: z5.enum(["x-search", "custom"]),
606
+ source: z6.enum(["x-search", "custom"]),
624
607
  /** Which observations fire; absent means the source's default (`defaultTriggerMode`). */
625
608
  on: trackerTriggerModeSchema.optional(),
626
609
  where: trackerWhereSchema.optional(),
@@ -629,7 +612,7 @@ var trackerTriggerPolicySchema = z5.strictObject({
629
612
  * a custom record. Relay attributes it through verified links; evaluators cannot redirect it.
630
613
  * Releases published before account roles store `"replied-to"` for `inReplyTo`.
631
614
  */
632
- beneficiary: z5.union([accountRoleSchema, z5.literal("replied-to")])
615
+ beneficiary: z6.union([accountRoleSchema, z6.literal("replied-to")])
633
616
  });
634
617
  function triggerMode(policy) {
635
618
  return policy.on ?? defaultTriggerMode(policy.source);
@@ -638,52 +621,52 @@ function beneficiaryRole(policy) {
638
621
  return policy.beneficiary === "replied-to" ? "inReplyTo" : policy.beneficiary;
639
622
  }
640
623
  var xLink = {
641
- issuer: z5.string().min(1),
624
+ issuer: z6.string().min(1),
642
625
  /** The account's stable user ID. */
643
- subject: z5.string().min(1).max(256),
626
+ subject: z6.string().min(1).max(256),
644
627
  /** The member's account selection revision. */
645
628
  revision: count2,
646
629
  /** When the member linked the account; null when unknown. */
647
630
  linkedAt: timestamp3.nullable()
648
631
  };
649
- var trackerAttributionSchema = z5.strictObject({
632
+ var trackerAttributionSchema = z6.strictObject({
650
633
  member: identifier,
651
634
  capturedAt: timestamp3,
652
- account: z5.discriminatedUnion("provider", [
653
- z5.strictObject({
654
- provider: z5.literal("wallet"),
635
+ account: z6.discriminatedUnion("provider", [
636
+ z6.strictObject({
637
+ provider: z6.literal("wallet"),
655
638
  /** Canonical CAIP-10 account ID, as the record names it. */
656
- id: z5.string().min(5).max(256),
639
+ id: z6.string().min(5).max(256),
657
640
  /** The wallet link's revision. */
658
641
  revision: count2,
659
642
  /** When the member verified the wallet. */
660
643
  linkedAt: timestamp3.nullable()
661
644
  }),
662
- z5.strictObject({ provider: z5.literal("x"), ...xLink }),
663
- z5.strictObject({ provider: z5.literal("discord"), ...xLink }),
664
- z5.strictObject({
665
- provider: z5.literal("member"),
645
+ z6.strictObject({ provider: z6.literal("x"), ...xLink }),
646
+ z6.strictObject({ provider: z6.literal("discord"), ...xLink }),
647
+ z6.strictObject({
648
+ provider: z6.literal("member"),
666
649
  /** The member ID the record names. */
667
650
  id: identifier
668
651
  })
669
652
  ])
670
653
  });
671
- var trackerTriggerRecordSchema = z5.strictObject({
672
- id: z5.string().min(1).max(256),
673
- source: z5.string(),
654
+ var trackerTriggerRecordSchema = z6.strictObject({
655
+ id: z6.string().min(1).max(256),
656
+ source: z6.string(),
674
657
  occurredAt: timestamp3,
675
658
  observedAt: timestamp3,
676
659
  firstSeenAt: timestamp3,
677
- author: z5.strictObject({
678
- id: z5.string().min(1).max(256),
679
- verified: z5.boolean().nullable(),
660
+ author: z6.strictObject({
661
+ id: z6.string().min(1).max(256),
662
+ verified: z6.boolean().nullable(),
680
663
  kind: identityKindSchema.optional()
681
664
  }).nullable(),
682
- accounts: z5.record(accountRoleSchema, trackerAccountSchema).optional(),
683
- data: z5.record(z5.string(), z5.json()),
684
- removed: z5.boolean()
665
+ accounts: z6.record(accountRoleSchema, trackerAccountSchema).optional(),
666
+ data: z6.record(z6.string(), z6.json()),
667
+ removed: z6.boolean()
685
668
  });
686
- var trackerTriggerContextSchema = z5.strictObject({
669
+ var trackerTriggerContextSchema = z6.strictObject({
687
670
  /** The tracker's stable ID. */
688
671
  tracker: identifier,
689
672
  /** The tracker's authoring key. */
@@ -692,10 +675,10 @@ var trackerTriggerContextSchema = z5.strictObject({
692
675
  * The record account the attempt pays, as the quest's release names it. Releases published
693
676
  * before account roles name `inReplyTo` `"replied-to"`, which their bundled evaluators expect.
694
677
  */
695
- beneficiary: z5.union([accountRoleSchema, z5.literal("replied-to")]),
678
+ beneficiary: z6.union([accountRoleSchema, z6.literal("replied-to")]),
696
679
  record: trackerTriggerRecordSchema,
697
680
  /** The captured X post of this observation; null for custom trackers. */
698
- x: z5.strictObject({
681
+ x: z6.strictObject({
699
682
  evidence: trackerEvidenceSchema,
700
683
  content: xContentBodySchema
701
684
  }).nullable(),
@@ -703,111 +686,86 @@ var trackerTriggerContextSchema = z5.strictObject({
703
686
  });
704
687
 
705
688
  // src/observations.ts
706
- import { z as z6 } from "zod";
707
- var name = z6.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
708
- var observationInputSchema = z6.object({
689
+ import { z as z7 } from "zod";
690
+ var name = z7.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
691
+ var observationInputSchema = z7.object({
709
692
  id: name,
710
693
  source: name,
711
694
  type: name,
712
695
  member: identifier,
713
- actor: z6.object({ provider: identifier, subject: z6.string().min(1).max(200) }).strict().optional(),
714
- occurredAt: z6.number().int().nonnegative().max(864e13),
715
- data: z6.record(z6.string(), z6.json())
696
+ actor: z7.object({ provider: identifier, subject: z7.string().min(1).max(200) }).strict().optional(),
697
+ occurredAt: z7.number().int().nonnegative().max(864e13),
698
+ data: z7.record(z7.string(), z7.json())
716
699
  }).strict().refine(
717
700
  (value) => JSON.stringify(value.data).length <= 32768,
718
701
  "Observation data exceeds 32 KB"
719
702
  );
720
703
  var observationSchema = observationInputSchema.safeExtend({
721
- receivedAt: z6.number().int().nonnegative()
704
+ receivedAt: z7.number().int().nonnegative()
722
705
  });
723
- var observationTriggerSchema = z6.object({ source: name, type: name }).strict();
724
- var completionPolicySchema = z6.discriminatedUnion("kind", [
706
+ var observationTriggerSchema = z7.object({ source: name, type: name }).strict();
707
+ var completionPolicySchema = z7.discriminatedUnion("kind", [
725
708
  streakPolicySchema,
726
- z6.object({ kind: z6.literal("once") }).strict(),
727
- z6.object({ kind: z6.literal("keyed") }).strict()
709
+ z7.object({ kind: z7.literal("once") }).strict(),
710
+ z7.object({ kind: z7.literal("keyed") }).strict()
728
711
  ]);
729
- var completionKeySchema = z6.string().min(1).max(500);
730
- var budgetSchema = z6.object({
712
+ var completionKeySchema = z7.string().min(1).max(500);
713
+ var budgetSchema = z7.object({
731
714
  id: name,
732
- scope: z6.enum(["member", "project"]),
715
+ scope: z7.enum(["member", "project"]),
733
716
  /**
734
717
  * `"day"` buckets by UTC date and `"week"` by ISO week (UTC, weeks start on Monday), both of
735
718
  * the attempt's eligibility time; `"lifetime"` never resets.
736
719
  */
737
- period: z6.enum(["lifetime", "day", "week"]),
738
- limit: z6.number().int().positive().max(Number.MAX_SAFE_INTEGER),
739
- cost: z6.union([
740
- z6.number().int().positive().max(Number.MAX_SAFE_INTEGER),
741
- z6.object({ balance: name }).strict()
720
+ period: z7.enum(["lifetime", "day", "week"]),
721
+ limit: z7.number().int().positive().max(Number.MAX_SAFE_INTEGER),
722
+ cost: z7.union([
723
+ z7.number().int().positive().max(Number.MAX_SAFE_INTEGER),
724
+ z7.object({ balance: name }).strict()
742
725
  ])
743
726
  }).strict();
744
- var observationReceiptSchema = z6.object({
727
+ var observationReceiptSchema = z7.object({
745
728
  id: name,
746
729
  source: name,
747
- attempts: z6.array(z6.string()),
748
- receivedAt: z6.number()
730
+ attempts: z7.array(z7.string()),
731
+ receivedAt: z7.number()
749
732
  });
750
- var discordReactionSchema = z6.object({
751
- guildId: z6.string(),
752
- channelId: z6.string(),
753
- messageId: z6.string(),
754
- userId: z6.string(),
755
- messageAuthorId: z6.string().nullable().default(null),
756
- actorRoles: z6.array(z6.string()).default([]),
757
- emoji: z6.object({ id: z6.string().nullable(), name: z6.string() }),
758
- messagePublishedAt: z6.number()
733
+ var discordReactionSchema = z7.object({
734
+ guildId: z7.string(),
735
+ channelId: z7.string(),
736
+ messageId: z7.string(),
737
+ userId: z7.string(),
738
+ messageAuthorId: z7.string().nullable().default(null),
739
+ actorRoles: z7.array(z7.string()).default([]),
740
+ emoji: z7.object({ id: z7.string().nullable(), name: z7.string() }),
741
+ messagePublishedAt: z7.number()
759
742
  }).strict();
760
- var discordMessageSchema = z6.object({
761
- guildId: z6.string(),
762
- channelId: z6.string(),
763
- messageId: z6.string(),
764
- userId: z6.string(),
765
- content: z6.string().nullable(),
766
- replyTo: z6.string().nullable(),
767
- publishedAt: z6.number()
743
+ var discordMessageSchema = z7.object({
744
+ guildId: z7.string(),
745
+ channelId: z7.string(),
746
+ messageId: z7.string(),
747
+ userId: z7.string(),
748
+ content: z7.string().nullable(),
749
+ replyTo: z7.string().nullable(),
750
+ publishedAt: z7.number()
768
751
  }).strict();
769
752
 
770
753
  // src/integrations.ts
771
- import { z as z7 } from "zod";
772
- var integrationProviderSchema = z7.enum(["discord"]);
773
- var discordServerSchema = z7.object({
774
- id: z7.string().regex(/^[0-9]{1,20}$/),
775
- name: z7.string().min(1),
776
- icon: z7.string().nullable()
754
+ import { z as z8 } from "zod";
755
+ var integrationProviderSchema = z8.enum(["discord"]);
756
+ var discordServerSchema = z8.object({
757
+ id: z8.string().regex(/^[0-9]{1,20}$/),
758
+ name: z8.string().min(1),
759
+ icon: z8.string().nullable()
777
760
  });
778
- var projectIntegrationSchema = z7.object({
761
+ var projectIntegrationSchema = z8.object({
779
762
  provider: integrationProviderSchema,
780
- configured: z7.boolean(),
781
- status: z7.enum(["disconnected", "ready", "attention"]),
782
- revision: z7.number().int().nonnegative(),
783
- server: discordServerSchema.nullable(),
784
- issue: z7.string().nullable(),
785
- connectedAt: z7.number().default(0)
786
- });
787
-
788
- // src/accounts.ts
789
- import { z as z8 } from "zod";
790
- var authProviderSchema = z8.enum(["google", "apple", "x", "discord"]);
791
- var accountConnectionSchema = z8.object({
792
- provider: authProviderSchema,
793
763
  configured: z8.boolean(),
794
- status: z8.enum(["disconnected", "connected", "reconnect"]),
795
- subject: z8.string().nullable(),
796
- revision: z8.number().int().nonnegative()
797
- });
798
- var discordMemberInputSchema = z8.object({}).strict();
799
- var discordMessageInputSchema = z8.object({
800
- channelId: z8.string().regex(/^[0-9]{1,20}$/),
801
- messageId: z8.string().regex(/^[0-9]{1,20}$/)
802
- }).strict();
803
- var discordMemberSchema = z8.object({
804
- userId: z8.string().regex(/^[0-9]{1,20}$/).nullable().default(null),
805
- nickname: z8.string().nullable().default(null),
806
- displayName: z8.string().nullable().default(null),
807
- boostingSince: z8.string().datetime({ offset: true }).nullable().default(null),
808
- roles: z8.array(z8.string().regex(/^[0-9]{1,20}$/)),
809
- joinedAt: z8.string().datetime({ offset: true }).nullable(),
810
- pending: z8.boolean()
764
+ status: z8.enum(["disconnected", "ready", "attention"]),
765
+ revision: z8.number().int().nonnegative(),
766
+ server: discordServerSchema.nullable(),
767
+ issue: z8.string().nullable(),
768
+ connectedAt: z8.number().default(0)
811
769
  });
812
770
 
813
771
  // src/submission-input.ts
@@ -925,12 +883,6 @@ var quizContentSchema = z10.array(
925
883
  "Question IDs must be unique"
926
884
  );
927
885
 
928
- // src/schema.ts
929
- import { z as z13 } from "zod";
930
-
931
- // src/settings.ts
932
- import { z as z12 } from "zod";
933
-
934
886
  // src/resources.ts
935
887
  import { z as z11 } from "zod";
936
888
  var channelSourceSchema = z11.object({
@@ -969,125 +921,61 @@ var resourceOptionsSchema = z11.object({
969
921
  ),
970
922
  cursor: z11.string().nullable()
971
923
  });
972
- var discord = {
973
- roles(options = {}) {
974
- return resourceSourceSchema.parse({
975
- provider: "discord",
976
- resource: "role",
977
- assignable: options.assignable ?? false
978
- });
979
- },
980
- channels(options = {}) {
981
- return resourceSourceSchema.parse({
982
- provider: "discord",
983
- resource: "channel",
984
- types: options.types ?? ["text", "announcement"]
985
- });
986
- }
987
- };
988
- var pointLedgers = () => ({
989
- provider: "domino",
990
- resource: "point-ledger"
991
- });
992
924
 
993
925
  // src/settings.ts
994
- var instant = z12.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
995
- var resourceId = z12.union([z12.literal(""), z12.string().regex(/^\S{1,200}$/)]);
996
- var base = { label: z12.string().min(1), description: z12.string().optional() };
997
- var settingFieldSchema = z12.discriminatedUnion("kind", [
998
- z12.object({ ...base, kind: z12.literal("point-ledger"), default: identifier }).strict(),
999
- z12.object({ ...base, kind: z12.literal("datetime"), default: instant }).strict(),
1000
- z12.object({
926
+ import { z as z13 } from "zod";
927
+
928
+ // src/setting-values.ts
929
+ import { z as z12 } from "zod";
930
+ var settingInstant = z12.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
931
+ var settingResourceId = z12.union([
932
+ z12.literal(""),
933
+ z12.string().regex(/^\S{1,200}$/)
934
+ ]);
935
+
936
+ // src/settings.ts
937
+ var base = { label: z13.string().min(1), description: z13.string().optional() };
938
+ var settingFieldSchema = z13.discriminatedUnion("kind", [
939
+ z13.object({ ...base, kind: z13.literal("point-ledger"), default: identifier }).strict(),
940
+ z13.object({ ...base, kind: z13.literal("datetime"), default: settingInstant }).strict(),
941
+ z13.object({
1001
942
  ...base,
1002
- kind: z12.literal("resource"),
1003
- default: resourceId,
943
+ kind: z13.literal("resource"),
944
+ default: settingResourceId,
1004
945
  source: resourceSourceSchema
1005
946
  }).strict(),
1006
- z12.object({ ...base, kind: z12.literal("quiz"), default: quizContentSchema }).strict(),
1007
- z12.object({
947
+ z13.object({ ...base, kind: z13.literal("quiz"), default: quizContentSchema }).strict(),
948
+ z13.object({
1008
949
  ...base,
1009
- kind: z12.literal("text"),
1010
- default: z12.string(),
1011
- minLength: z12.number().int().nonnegative(),
1012
- maxLength: z12.number().int().positive(),
1013
- multiline: z12.boolean()
950
+ kind: z13.literal("text"),
951
+ default: z13.string(),
952
+ minLength: z13.number().int().nonnegative(),
953
+ maxLength: z13.number().int().positive(),
954
+ multiline: z13.boolean()
1014
955
  }).strict(),
1015
- z12.object({
956
+ z13.object({
1016
957
  ...base,
1017
- kind: z12.literal("integer"),
1018
- default: z12.number().int(),
1019
- min: z12.number().int(),
1020
- max: z12.number().int()
958
+ kind: z13.literal("integer"),
959
+ default: z13.number().int(),
960
+ min: z13.number().int(),
961
+ max: z13.number().int()
1021
962
  }).strict(),
1022
- z12.object({ ...base, kind: z12.literal("boolean"), default: z12.boolean() }).strict(),
1023
- z12.object({
963
+ z13.object({ ...base, kind: z13.literal("boolean"), default: z13.boolean() }).strict(),
964
+ z13.object({
1024
965
  ...base,
1025
- kind: z12.literal("choice"),
1026
- default: z12.string(),
1027
- options: z12.array(z12.string().min(1)).min(1)
966
+ kind: z13.literal("choice"),
967
+ default: z13.string(),
968
+ options: z13.array(z13.string().min(1)).min(1)
1028
969
  }).strict()
1029
970
  ]);
1030
- var settingsFieldsSchema = z12.record(
1031
- z12.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
971
+ var settingsFieldsSchema = z13.record(
972
+ z13.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
1032
973
  settingFieldSchema
1033
974
  );
1034
- var settingsValuesSchema = z12.record(
1035
- z12.string(),
1036
- z12.union([z12.string(), z12.number().finite(), z12.boolean(), quizContentSchema])
975
+ var settingsValuesSchema = z13.record(
976
+ z13.string(),
977
+ z13.union([z13.string(), z13.number().finite(), z13.boolean(), quizContentSchema])
1037
978
  );
1038
- var settings = {
1039
- pointLedger(options) {
1040
- const field = {
1041
- ...options,
1042
- kind: "point-ledger",
1043
- default: identifier.parse(options.default)
1044
- };
1045
- return identifier.default(field.default).meta(field);
1046
- },
1047
- datetime(options) {
1048
- const field = {
1049
- ...options,
1050
- kind: "datetime",
1051
- default: instant.parse(options.default)
1052
- };
1053
- return instant.default(field.default).meta(field);
1054
- },
1055
- resource(options) {
1056
- const field = {
1057
- ...options,
1058
- source: resourceSourceSchema.parse(options.source),
1059
- kind: "resource",
1060
- default: resourceId.parse(options.default ?? "")
1061
- };
1062
- return resourceId.default(field.default).meta(field);
1063
- },
1064
- quiz(options) {
1065
- const value = quizContentSchema.parse(options.default);
1066
- return quizContentSchema.default(value).meta({ ...options, default: value, kind: "quiz" });
1067
- },
1068
- text(options) {
1069
- const field = {
1070
- ...options,
1071
- kind: "text",
1072
- minLength: options.minLength ?? 1,
1073
- maxLength: options.maxLength ?? 2e3,
1074
- multiline: options.multiline ?? false
1075
- };
1076
- return z12.string().min(field.minLength).max(field.maxLength).default(field.default).meta(field);
1077
- },
1078
- integer(options) {
1079
- return z12.number().int().min(options.min).max(options.max).default(options.default).meta({ ...options, kind: "integer" });
1080
- },
1081
- boolean(options) {
1082
- return z12.boolean().default(options.default).meta({ ...options, kind: "boolean" });
1083
- },
1084
- choice(options) {
1085
- return z12.enum(options.options).default(options.default).meta({ ...options, kind: "choice" });
1086
- },
1087
- object(shape) {
1088
- return z12.object(shape).strict();
1089
- }
1090
- };
1091
979
  function parseSettings(fields, input) {
1092
980
  const shape = {};
1093
981
  for (const [key, field] of Object.entries(fields)) {
@@ -1096,29 +984,29 @@ function parseSettings(fields, input) {
1096
984
  shape[key] = identifier.default(field.default);
1097
985
  break;
1098
986
  case "datetime":
1099
- shape[key] = instant.default(field.default);
987
+ shape[key] = settingInstant.default(field.default);
1100
988
  break;
1101
989
  case "resource":
1102
- shape[key] = resourceId.default(field.default);
990
+ shape[key] = settingResourceId.default(field.default);
1103
991
  break;
1104
992
  case "quiz":
1105
993
  shape[key] = quizContentSchema.default(field.default);
1106
994
  break;
1107
995
  case "text":
1108
- shape[key] = z12.string().min(field.minLength).max(field.maxLength).default(field.default);
996
+ shape[key] = z13.string().min(field.minLength).max(field.maxLength).default(field.default);
1109
997
  break;
1110
998
  case "integer":
1111
- shape[key] = z12.number().int().min(field.min).max(field.max).default(field.default);
999
+ shape[key] = z13.number().int().min(field.min).max(field.max).default(field.default);
1112
1000
  break;
1113
1001
  case "boolean":
1114
- shape[key] = z12.boolean().default(field.default);
1002
+ shape[key] = z13.boolean().default(field.default);
1115
1003
  break;
1116
1004
  case "choice":
1117
- shape[key] = z12.enum(field.options).default(field.default);
1005
+ shape[key] = z13.enum(field.options).default(field.default);
1118
1006
  break;
1119
1007
  }
1120
1008
  }
1121
- return settingsValuesSchema.parse(z12.object(shape).strict().parse(input));
1009
+ return settingsValuesSchema.parse(z13.object(shape).strict().parse(input));
1122
1010
  }
1123
1011
  function missingResourceSettings(fields, values) {
1124
1012
  return Object.entries(fields).filter(([key, field]) => field.kind === "resource" && !values[key]).map(([key]) => key);
@@ -1128,42 +1016,43 @@ function compatibleSettingKinds(previous, next) {
1128
1016
  }
1129
1017
 
1130
1018
  // src/schema.ts
1131
- var pointsRewardSchema = z13.object({
1132
- kind: z13.literal("points").default("points"),
1019
+ import { z as z14 } from "zod";
1020
+ var pointsRewardSchema = z14.object({
1021
+ kind: z14.literal("points").default("points"),
1133
1022
  balance: identifier,
1134
- amount: z13.number().int().min(0).max(1e4)
1023
+ amount: z14.number().int().min(0).max(1e4)
1135
1024
  }).strict();
1136
- var tieredRewardDefinitionSchema = z13.object({
1025
+ var tieredRewardDefinitionSchema = z14.object({
1137
1026
  id: identifier,
1138
- title: z13.string().min(1).max(120),
1139
- tiers: z13.array(
1140
- z13.object({ id: identifier, title: z13.string().min(1).max(120) }).strict()
1027
+ title: z14.string().min(1).max(120),
1028
+ tiers: z14.array(
1029
+ z14.object({ id: identifier, title: z14.string().min(1).max(120) }).strict()
1141
1030
  ).min(1).max(20).refine(
1142
1031
  (tiers) => new Set(tiers.map((t) => t.id)).size === tiers.length,
1143
1032
  "Tier IDs must be unique"
1144
1033
  ),
1145
- inventory: z13.object({ kind: z13.literal("untracked") }).strict(),
1146
- fulfillment: z13.object({ kind: z13.literal("staff-handover") }).strict()
1034
+ inventory: z14.object({ kind: z14.literal("untracked") }).strict(),
1035
+ fulfillment: z14.object({ kind: z14.literal("staff-handover") }).strict()
1147
1036
  }).strict();
1148
- var tieredRewardReferenceSchema = z13.object({
1037
+ var tieredRewardReferenceSchema = z14.object({
1149
1038
  id: identifier,
1150
1039
  key: identifier.nullable()
1151
1040
  });
1152
- var tierRewardSchema = z13.object({
1153
- kind: z13.literal("tier"),
1041
+ var tierRewardSchema = z14.object({
1042
+ kind: z14.literal("tier"),
1154
1043
  reward: tieredRewardDefinitionSchema,
1155
1044
  tier: identifier
1156
1045
  }).strict().refine(
1157
1046
  (value) => value.reward.tiers.some((t) => t.id === value.tier),
1158
1047
  "Unknown reward tier"
1159
1048
  );
1160
- var integrationRewardSchema = z13.object({
1161
- kind: z13.literal("integration"),
1162
- provider: z13.literal("discord"),
1163
- action: z13.literal("grant-role"),
1164
- roleId: z13.string().regex(/^[0-9]{1,20}$/)
1049
+ var integrationRewardSchema = z14.object({
1050
+ kind: z14.literal("integration"),
1051
+ provider: z14.literal("discord"),
1052
+ action: z14.literal("grant-role"),
1053
+ roleId: z14.string().regex(/^[0-9]{1,20}$/)
1165
1054
  }).strict();
1166
- var rewardSchema = z13.union([
1055
+ var rewardSchema = z14.union([
1167
1056
  pointsRewardSchema,
1168
1057
  tierRewardSchema,
1169
1058
  integrationRewardSchema
@@ -1174,26 +1063,26 @@ function rewardKey(reward) {
1174
1063
  }
1175
1064
  return reward.kind === "points" ? "points:" + reward.balance : "tier:" + reward.reward.id;
1176
1065
  }
1177
- var triggerSchema = z13.union([
1178
- z13.object({
1179
- kind: z13.literal("manual"),
1180
- input: z13.literal("text"),
1066
+ var triggerSchema = z14.union([
1067
+ z14.object({
1068
+ kind: z14.literal("manual"),
1069
+ input: z14.literal("text"),
1181
1070
  constraints: textOptionsSchema,
1182
- actor: z13.enum(["member", "staff"]).optional()
1071
+ actor: z14.enum(["member", "staff"]).optional()
1183
1072
  }).strict(),
1184
- z13.object({
1185
- kind: z13.literal("manual"),
1186
- input: z13.literal("url"),
1073
+ z14.object({
1074
+ kind: z14.literal("manual"),
1075
+ input: z14.literal("url"),
1187
1076
  constraints: urlOptionsSchema,
1188
- actor: z13.enum(["member", "staff"]).optional()
1077
+ actor: z14.enum(["member", "staff"]).optional()
1189
1078
  }).strict(),
1190
- z13.object({
1191
- kind: z13.literal("manual"),
1192
- input: z13.enum(["photo", "quiz", "none"]),
1193
- actor: z13.enum(["member", "staff"]).optional()
1079
+ z14.object({
1080
+ kind: z14.literal("manual"),
1081
+ input: z14.enum(["photo", "quiz", "none"]),
1082
+ actor: z14.enum(["member", "staff"]).optional()
1194
1083
  }).strict(),
1195
- z13.object({
1196
- kind: z13.literal("automatic"),
1084
+ z14.object({
1085
+ kind: z14.literal("automatic"),
1197
1086
  observation: observationTriggerSchema.optional(),
1198
1087
  content: contentPolicySchema.optional(),
1199
1088
  tracker: trackerTriggerPolicySchema.optional()
@@ -1202,43 +1091,48 @@ var triggerSchema = z13.union([
1202
1091
  "Choose one automatic trigger source"
1203
1092
  )
1204
1093
  ]);
1205
- var prerequisiteSchema = z13.object({ quest: identifier });
1206
- var photoResultSchema = z13.object({
1207
- kind: z13.enum(["pass", "fail", "unclear"]),
1208
- reason: z13.string().min(1).max(2e3)
1094
+ var prerequisiteSchema = z14.object({ quest: identifier });
1095
+ var photoResultSchema = z14.object({
1096
+ kind: z14.enum(["pass", "fail", "unclear"]),
1097
+ reason: z14.string().min(1).max(2e3)
1209
1098
  }).strict();
1210
- var textReviewInputSchema = z13.object({
1211
- text: z13.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
1212
- criteria: z13.string().trim().min(1).max(2e3)
1099
+ var textReviewInputSchema = z14.object({
1100
+ text: z14.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
1101
+ criteria: z14.string().trim().min(1).max(2e3)
1213
1102
  }).strict();
1214
1103
  var textResultSchema = photoResultSchema;
1215
- var decisionSchema = z13.discriminatedUnion("kind", [
1216
- z13.object({
1217
- kind: z13.literal("accept"),
1218
- rewards: z13.array(rewardSchema).max(10),
1104
+ var decisionSchema = z14.discriminatedUnion("kind", [
1105
+ z14.object({
1106
+ kind: z14.literal("accept"),
1107
+ rewards: z14.array(rewardSchema).max(10),
1219
1108
  completionKey: completionKeySchema.optional()
1220
1109
  }).strict(),
1221
- z13.object({ kind: z13.literal("reject"), reason: z13.string().min(1).max(2e3) }).strict(),
1222
- z13.object({
1223
- kind: z13.literal("review"),
1224
- reason: z13.string().min(1).max(2e3),
1225
- rewards: z13.array(rewardSchema).max(10).optional(),
1110
+ z14.object({
1111
+ kind: z14.literal("reject"),
1112
+ reason: z14.string().min(1).max(2e3),
1113
+ /** The evaluator asked for human review, but review is off for the quest, so this is a reject. */
1114
+ requestedReview: z14.literal(true).optional()
1115
+ }).strict(),
1116
+ z14.object({
1117
+ kind: z14.literal("review"),
1118
+ reason: z14.string().min(1).max(2e3),
1119
+ rewards: z14.array(rewardSchema).max(10).optional(),
1226
1120
  completionKey: completionKeySchema.optional()
1227
1121
  }).strict()
1228
1122
  ]);
1229
- var reviewModeSchema = z13.enum(["workers-ai"]);
1230
- var storedReviewModeSchema = z13.enum([
1123
+ var reviewModeSchema = z14.enum(["workers-ai"]);
1124
+ var storedReviewModeSchema = z14.enum([
1231
1125
  "fixture-pass",
1232
1126
  "fixture-fail",
1233
1127
  "fixture-unclear",
1234
1128
  "fixture-error",
1235
1129
  "workers-ai"
1236
1130
  ]);
1237
- var rewardBundleSchema = z13.array(rewardSchema).max(10).refine(
1131
+ var rewardBundleSchema = z14.array(rewardSchema).max(10).refine(
1238
1132
  (rewards) => new Set(rewards.map(rewardKey)).size === rewards.length,
1239
1133
  "Use one entry per balance or shared reward"
1240
1134
  );
1241
- var mediaUrlSchema = z13.string().max(2e3).refine((value) => {
1135
+ var mediaUrlSchema = z14.string().max(2e3).refine((value) => {
1242
1136
  if (/^\/(?!\/)[^\\\s]*$/.test(value)) {
1243
1137
  return true;
1244
1138
  }
@@ -1248,82 +1142,82 @@ var mediaUrlSchema = z13.string().max(2e3).refine((value) => {
1248
1142
  return false;
1249
1143
  }
1250
1144
  }, "Use an HTTPS URL or a same-site path beginning with /");
1251
- var questPresentationSchema = z13.object({
1145
+ var questPresentationSchema = z14.object({
1252
1146
  quiz: quizQuestionsSchema.optional(),
1253
- instructions: z13.string().max(4e3).optional(),
1254
- video: z13.object({
1147
+ instructions: z14.string().max(4e3).optional(),
1148
+ video: z14.object({
1255
1149
  url: mediaUrlSchema,
1256
1150
  poster: mediaUrlSchema.optional(),
1257
- captions: z13.object({
1151
+ captions: z14.object({
1258
1152
  url: mediaUrlSchema,
1259
- language: z13.string().min(2).max(20),
1260
- label: z13.string().min(1).max(80)
1153
+ language: z14.string().min(2).max(20),
1154
+ label: z14.string().min(1).max(80)
1261
1155
  }).strict().optional()
1262
1156
  }).strict().optional()
1263
1157
  }).strict();
1264
- var questProfileSchema = z13.object({ visible: z13.boolean() }).strict();
1265
- var questDescriptionSchema = z13.object({
1158
+ var questProfileSchema = z14.object({ visible: z14.boolean() }).strict();
1159
+ var questDescriptionSchema = z14.object({
1266
1160
  quest: identifier,
1267
- runtimeVersion: z13.union([z13.literal(1), z13.literal(2)]).default(1),
1268
- title: z13.string().min(1).max(120),
1161
+ runtimeVersion: z14.union([z14.literal(1), z14.literal(2)]).default(1),
1162
+ title: z14.string().min(1).max(120),
1269
1163
  presentation: questPresentationSchema.default({}),
1270
- integrations: z13.array(integrationProviderSchema).max(10).default([]),
1164
+ integrations: z14.array(integrationProviderSchema).max(10).default([]),
1271
1165
  fields: settingsFieldsSchema,
1272
1166
  values: settingsValuesSchema,
1273
1167
  rewards: rewardBundleSchema,
1274
- humanReview: z13.boolean(),
1168
+ humanReview: z14.boolean(),
1275
1169
  trigger: triggerSchema,
1276
1170
  performance: contentPerformancePolicySchema.optional(),
1277
- requires: z13.array(prerequisiteSchema).max(30).default([]),
1171
+ requires: z14.array(prerequisiteSchema).max(30).default([]),
1278
1172
  completion: completionPolicySchema,
1279
- visibility: z13.enum(["visible", "hidden"]).default("visible"),
1173
+ visibility: z14.enum(["visible", "hidden"]).default("visible"),
1280
1174
  /**
1281
1175
  * Whether completions show on participant profiles (`/v1/profiles/:id/completions`). Absent
1282
1176
  * is hidden. Optional, not defaulted: releases carry the key only when the author sets it, so
1283
1177
  * clients and pods that predate it (strict release schemas) still read every other release.
1284
1178
  */
1285
1179
  profile: questProfileSchema.optional(),
1286
- budgets: z13.array(budgetSchema).max(20).default([])
1180
+ budgets: z14.array(budgetSchema).max(20).default([])
1287
1181
  }).strict();
1288
- var artifactSchema = z13.object({ code: z13.string().min(1).max(1e6) }).strict();
1182
+ var artifactSchema = z14.object({ code: z14.string().min(1).max(1e6) }).strict();
1289
1183
  var releaseSchema = artifactSchema.extend({
1290
1184
  settings: settingsValuesSchema,
1291
1185
  provider: reviewModeSchema,
1292
1186
  expectedRelease: identifier.nullable().optional(),
1293
- settingRenames: z13.record(z13.string(), z13.string()).optional()
1187
+ settingRenames: z14.record(z14.string(), z14.string()).optional()
1294
1188
  }).strict();
1295
- var batchReleaseSchema = z13.object({ releases: z13.array(releaseSchema).min(1).max(50) }).strict();
1296
- var questSettingsInputSchema = z13.object({
1189
+ var batchReleaseSchema = z14.object({ releases: z14.array(releaseSchema).min(1).max(50) }).strict();
1190
+ var questSettingsInputSchema = z14.object({
1297
1191
  quest: identifier,
1298
1192
  expectedRelease: identifier,
1299
1193
  set: settingsValuesSchema,
1300
- reset: z13.array(z13.string())
1194
+ reset: z14.array(z14.string())
1301
1195
  }).strict();
1302
1196
  var storedReleaseSchema = questDescriptionSchema.extend({
1303
1197
  key: identifier.optional(),
1304
- code: z13.string(),
1198
+ code: z14.string(),
1305
1199
  provider: storedReviewModeSchema,
1306
1200
  id: identifier,
1307
- createdAt: z13.number(),
1308
- legacy: z13.boolean().default(false),
1309
- origin: z13.object({ typeVersion: identifier }).strict().optional(),
1310
- lifecycle: z13.enum(["active", "paused", "archived"]).default("active"),
1311
- configuration: z13.object({
1201
+ createdAt: z14.number(),
1202
+ legacy: z14.boolean().default(false),
1203
+ origin: z14.object({ typeVersion: identifier }).strict().optional(),
1204
+ lifecycle: z14.enum(["active", "paused", "archived"]).default("active"),
1205
+ configuration: z14.object({
1312
1206
  defaults: settingsValuesSchema,
1313
1207
  overrides: settingsValuesSchema,
1314
- preserved: z13.array(z13.string())
1208
+ preserved: z14.array(z14.string())
1315
1209
  }).strict().optional()
1316
1210
  });
1317
- var legacyReleaseSchema = z13.object({
1211
+ var legacyReleaseSchema = z14.object({
1318
1212
  quest: identifier,
1319
- title: z13.string(),
1320
- criteria: z13.string(),
1321
- humanReview: z13.boolean(),
1213
+ title: z14.string(),
1214
+ criteria: z14.string(),
1215
+ humanReview: z14.boolean(),
1322
1216
  rewards: rewardBundleSchema,
1323
- code: z13.string(),
1217
+ code: z14.string(),
1324
1218
  provider: storedReviewModeSchema,
1325
1219
  id: identifier,
1326
- createdAt: z13.number()
1220
+ createdAt: z14.number()
1327
1221
  }).transform((r) => {
1328
1222
  const { criteria, ...stored } = r;
1329
1223
  return storedReleaseSchema.parse({
@@ -1335,15 +1229,15 @@ var legacyReleaseSchema = z13.object({
1335
1229
  legacy: true
1336
1230
  });
1337
1231
  });
1338
- var publishedReleaseSchema = z13.union([
1232
+ var publishedReleaseSchema = z14.union([
1339
1233
  storedReleaseSchema,
1340
1234
  legacyReleaseSchema
1341
1235
  ]);
1342
- var templateSchema = z13.object({
1343
- code: z13.string(),
1236
+ var templateSchema = z14.object({
1237
+ code: z14.string(),
1344
1238
  definition: questDescriptionSchema
1345
1239
  });
1346
- var quizAnswersSchema = z13.record(identifier, identifier).refine(
1240
+ var quizAnswersSchema = z14.record(identifier, identifier).refine(
1347
1241
  (answers) => Object.keys(answers).length > 0 && Object.keys(answers).length <= 50,
1348
1242
  "Provide between 1 and 50 answers"
1349
1243
  ).transform(
@@ -1351,33 +1245,33 @@ var quizAnswersSchema = z13.record(identifier, identifier).refine(
1351
1245
  Object.entries(answers).sort(([a], [b]) => a.localeCompare(b))
1352
1246
  )
1353
1247
  );
1354
- var quizEvidenceSchema = z13.object({
1355
- kind: z13.literal("quiz"),
1248
+ var quizEvidenceSchema = z14.object({
1249
+ kind: z14.literal("quiz"),
1356
1250
  release: identifier.optional(),
1357
1251
  answers: quizAnswersSchema
1358
1252
  }).strict();
1359
- var submissionEvidenceSchema = z13.union([
1253
+ var submissionEvidenceSchema = z14.union([
1360
1254
  quizEvidenceSchema,
1361
1255
  textEvidenceSchema,
1362
1256
  urlEvidenceSchema
1363
1257
  ]);
1364
- var submitSchema = z13.object({
1258
+ var submitSchema = z14.object({
1365
1259
  actionId: identifier,
1366
1260
  quest: identifier,
1367
1261
  member: identifier,
1368
1262
  evidence: identifier.optional(),
1369
1263
  input: submissionEvidenceSchema.optional(),
1370
1264
  release: identifier.optional(),
1371
- faultAfterReview: z13.boolean().optional()
1265
+ faultAfterReview: z14.boolean().optional()
1372
1266
  }).strict();
1373
- var attemptSchema = z13.object({
1267
+ var attemptSchema = z14.object({
1374
1268
  id: identifier,
1375
1269
  release: identifier,
1376
1270
  quest: identifier,
1377
1271
  member: identifier,
1378
1272
  evidence: identifier.nullable(),
1379
1273
  input: submissionEvidenceSchema.optional(),
1380
- status: z13.enum([
1274
+ status: z14.enum([
1381
1275
  "queued",
1382
1276
  "evaluating",
1383
1277
  "accepted",
@@ -1386,70 +1280,75 @@ var attemptSchema = z13.object({
1386
1280
  "needs-review",
1387
1281
  "failed"
1388
1282
  ]),
1389
- reason: z13.string().nullable(),
1390
- retries: z13.number(),
1391
- generation: z13.number(),
1392
- completion: z13.string().nullable(),
1283
+ reason: z14.string().nullable(),
1284
+ retries: z14.number(),
1285
+ generation: z14.number(),
1286
+ completion: z14.string().nullable(),
1393
1287
  reviewRewards: rewardBundleSchema.nullable().default(null),
1394
- createdAt: z13.number()
1288
+ /**
1289
+ * The evaluator asked for human review of a quest with review off, so Domino rejected the attempt
1290
+ * with the evaluator's reason. Only set on a rejected attempt.
1291
+ */
1292
+ requestedReview: z14.boolean().default(false),
1293
+ createdAt: z14.number()
1395
1294
  });
1396
- var eventSchema = z13.object({
1397
- id: z13.number(),
1398
- attempt: z13.string().nullable(),
1399
- kind: z13.string(),
1400
- detail: z13.string(),
1401
- actor: z13.string().nullable().default(null),
1402
- at: z13.number()
1295
+ var eventSchema = z14.object({
1296
+ id: z14.number(),
1297
+ attempt: z14.string().nullable(),
1298
+ kind: z14.string(),
1299
+ detail: z14.string(),
1300
+ actor: z14.string().nullable().default(null),
1301
+ at: z14.number()
1403
1302
  });
1404
- var pickupSelectionSchema = z13.object({
1303
+ var pickupSelectionSchema = z14.object({
1405
1304
  item: identifier,
1406
- revision: z13.number().int().nonnegative()
1305
+ revision: z14.number().int().nonnegative()
1407
1306
  }).strict();
1408
- var pickupAllocationSchema = z13.object({
1307
+ var pickupAllocationSchema = z14.object({
1409
1308
  item: identifier,
1410
- label: z13.string().min(1).max(80)
1309
+ label: z14.string().min(1).max(80)
1411
1310
  }).strict();
1412
- var pickupPolicySchema = z13.discriminatedUnion("kind", [
1413
- z13.object({ kind: z13.literal("untracked") }).strict(),
1414
- z13.object({
1415
- kind: z13.literal("at-pickup"),
1416
- tiers: z13.array(
1417
- z13.object({
1311
+ var pickupPolicySchema = z14.discriminatedUnion("kind", [
1312
+ z14.object({ kind: z14.literal("untracked") }).strict(),
1313
+ z14.object({
1314
+ kind: z14.literal("at-pickup"),
1315
+ tiers: z14.array(
1316
+ z14.object({
1418
1317
  tier: identifier,
1419
- variants: z13.array(pickupAllocationSchema).min(1).max(100)
1318
+ variants: z14.array(pickupAllocationSchema).min(1).max(100)
1420
1319
  }).strict()
1421
1320
  ).min(1).max(100)
1422
1321
  }).strict()
1423
1322
  ]);
1424
- var pickupCatalogSchema = z13.object({
1323
+ var pickupCatalogSchema = z14.object({
1425
1324
  reward: tieredRewardDefinitionSchema,
1426
- revision: z13.number().int().nonnegative(),
1325
+ revision: z14.number().int().nonnegative(),
1427
1326
  policy: pickupPolicySchema
1428
1327
  });
1429
- var pickupAvailabilitySchema = z13.discriminatedUnion("kind", [
1430
- z13.object({ kind: z13.literal("untracked") }).strict(),
1431
- z13.object({
1432
- kind: z13.literal("at-pickup"),
1433
- revision: z13.number().int().nonnegative(),
1434
- variants: z13.array(
1328
+ var pickupAvailabilitySchema = z14.discriminatedUnion("kind", [
1329
+ z14.object({ kind: z14.literal("untracked") }).strict(),
1330
+ z14.object({
1331
+ kind: z14.literal("at-pickup"),
1332
+ revision: z14.number().int().nonnegative(),
1333
+ variants: z14.array(
1435
1334
  pickupAllocationSchema.extend({
1436
- available: z13.number().int().nonnegative()
1335
+ available: z14.number().int().nonnegative()
1437
1336
  })
1438
1337
  )
1439
1338
  }).strict()
1440
1339
  ]);
1441
- var configurePickupSchema = z13.object({
1340
+ var configurePickupSchema = z14.object({
1442
1341
  reward: identifier,
1443
- revision: z13.number().int().nonnegative(),
1342
+ revision: z14.number().int().nonnegative(),
1444
1343
  actionId: identifier,
1445
- policy: z13.discriminatedUnion("kind", [
1446
- z13.object({ kind: z13.literal("untracked") }).strict(),
1447
- z13.object({
1448
- kind: z13.literal("at-pickup"),
1449
- tiers: z13.array(
1450
- z13.object({
1344
+ policy: z14.discriminatedUnion("kind", [
1345
+ z14.object({ kind: z14.literal("untracked") }).strict(),
1346
+ z14.object({
1347
+ kind: z14.literal("at-pickup"),
1348
+ tiers: z14.array(
1349
+ z14.object({
1451
1350
  tier: identifier,
1452
- variants: z13.array(
1351
+ variants: z14.array(
1453
1352
  pickupAllocationSchema.extend({
1454
1353
  item: identifier.optional()
1455
1354
  })
@@ -1465,164 +1364,164 @@ var entitlementBase = {
1465
1364
  reward: tieredRewardDefinitionSchema,
1466
1365
  earnedTier: identifier,
1467
1366
  tier: identifier,
1468
- revision: z13.number().int().positive()
1367
+ revision: z14.number().int().positive()
1469
1368
  };
1470
- var entitlementSchema = z13.discriminatedUnion("status", [
1471
- z13.object({ ...entitlementBase, status: z13.literal("available") }).strict(),
1472
- z13.object({
1369
+ var entitlementSchema = z14.discriminatedUnion("status", [
1370
+ z14.object({ ...entitlementBase, status: z14.literal("available") }).strict(),
1371
+ z14.object({
1473
1372
  ...entitlementBase,
1474
- status: z13.literal("handing-over"),
1373
+ status: z14.literal("handing-over"),
1475
1374
  handover: identifier,
1476
- startedAt: z13.number(),
1375
+ startedAt: z14.number(),
1477
1376
  allocation: pickupAllocationSchema.optional()
1478
1377
  }).strict(),
1479
- z13.object({
1378
+ z14.object({
1480
1379
  ...entitlementBase,
1481
- status: z13.literal("collected"),
1380
+ status: z14.literal("collected"),
1482
1381
  handover: identifier,
1483
- startedAt: z13.number(),
1382
+ startedAt: z14.number(),
1484
1383
  allocation: pickupAllocationSchema.optional(),
1485
- collectedAt: z13.number()
1384
+ collectedAt: z14.number()
1486
1385
  }).strict()
1487
1386
  ]);
1488
- var beginHandoverSchema = z13.object({
1387
+ var beginHandoverSchema = z14.object({
1489
1388
  actionId: identifier,
1490
- revision: z13.number().int().positive(),
1389
+ revision: z14.number().int().positive(),
1491
1390
  selection: pickupSelectionSchema.optional()
1492
1391
  }).strict();
1493
- var confirmHandoverSchema = z13.object({ actionId: identifier, handover: identifier }).strict();
1494
- var completionRecordSchema = z13.object({
1495
- key: z13.string().default("once"),
1392
+ var confirmHandoverSchema = z14.object({ actionId: identifier, handover: identifier }).strict();
1393
+ var completionRecordSchema = z14.object({
1394
+ key: z14.string().default("once"),
1496
1395
  id: identifier,
1497
1396
  quest: identifier,
1498
1397
  member: identifier
1499
1398
  });
1500
- var questAvailabilitySchema = z13.discriminatedUnion("kind", [
1501
- z13.object({
1502
- kind: z13.literal("available"),
1503
- input: z13.enum(["photo", "quiz", "none", "text", "url"])
1399
+ var questAvailabilitySchema = z14.discriminatedUnion("kind", [
1400
+ z14.object({
1401
+ kind: z14.literal("available"),
1402
+ input: z14.enum(["photo", "quiz", "none", "text", "url"])
1504
1403
  }).strict(),
1505
- z13.object({ kind: z13.literal("completed") }).strict(),
1506
- z13.object({
1507
- kind: z13.literal("locked"),
1508
- missing: z13.array(z13.object({ quest: identifier, title: z13.string() })).min(1)
1404
+ z14.object({ kind: z14.literal("completed") }).strict(),
1405
+ z14.object({
1406
+ kind: z14.literal("locked"),
1407
+ missing: z14.array(z14.object({ quest: identifier, title: z14.string() })).min(1)
1509
1408
  }).strict(),
1510
- z13.object({ kind: z13.literal("staff-required") }).strict(),
1511
- z13.object({
1512
- kind: z13.literal("automatic"),
1409
+ z14.object({ kind: z14.literal("staff-required") }).strict(),
1410
+ z14.object({
1411
+ kind: z14.literal("automatic"),
1513
1412
  observation: observationTriggerSchema.optional()
1514
1413
  }).strict(),
1515
- z13.object({ kind: z13.literal("checking"), attempt: identifier }).strict(),
1516
- z13.object({ kind: z13.literal("needs-review"), attempt: identifier }).strict(),
1517
- z13.object({ kind: z13.literal("retryable"), attempt: identifier }).strict()
1414
+ z14.object({ kind: z14.literal("checking"), attempt: identifier }).strict(),
1415
+ z14.object({ kind: z14.literal("needs-review"), attempt: identifier }).strict(),
1416
+ z14.object({ kind: z14.literal("retryable"), attempt: identifier }).strict()
1518
1417
  ]);
1519
- var memberProgressSchema = z13.object({
1418
+ var memberProgressSchema = z14.object({
1520
1419
  member: identifier,
1521
- quests: z13.array(
1522
- z13.object({
1420
+ quests: z14.array(
1421
+ z14.object({
1523
1422
  quest: identifier,
1524
1423
  key: identifier.optional(),
1525
1424
  release: identifier.optional(),
1526
- title: z13.string(),
1425
+ title: z14.string(),
1527
1426
  presentation: questPresentationSchema.default({}),
1528
- connections: z13.array(authProviderSchema).default([]),
1427
+ connections: z14.array(authProviderSchema).default([]),
1529
1428
  trigger: triggerSchema,
1530
1429
  availability: questAvailabilitySchema,
1531
- completed: z13.boolean(),
1430
+ completed: z14.boolean(),
1532
1431
  completion: completionPolicySchema.default({ kind: "once" }),
1533
1432
  streak: streakProgressSchema.nullable().optional(),
1534
- completionCount: z13.number().int().nonnegative().default(0),
1535
- visibility: z13.enum(["visible", "hidden"]).default("visible"),
1536
- missing: z13.array(z13.object({ quest: identifier, title: z13.string() })),
1433
+ completionCount: z14.number().int().nonnegative().default(0),
1434
+ visibility: z14.enum(["visible", "hidden"]).default("visible"),
1435
+ missing: z14.array(z14.object({ quest: identifier, title: z14.string() })),
1537
1436
  attempt: attemptSchema.nullable()
1538
1437
  })
1539
1438
  ),
1540
- entitlements: z13.array(entitlementSchema)
1439
+ entitlements: z14.array(entitlementSchema)
1541
1440
  });
1542
- var snapshotSchema = z13.object({
1543
- releases: z13.array(publishedReleaseSchema),
1544
- completions: z13.array(completionRecordSchema),
1545
- entitlements: z13.array(entitlementSchema),
1546
- attempts: z13.array(attemptSchema),
1547
- balances: z13.array(
1548
- z13.object({
1549
- member: z13.string(),
1550
- balance: z13.string(),
1551
- earned: z13.number(),
1552
- held: z13.number(),
1553
- available: z13.number()
1441
+ var snapshotSchema = z14.object({
1442
+ releases: z14.array(publishedReleaseSchema),
1443
+ completions: z14.array(completionRecordSchema),
1444
+ entitlements: z14.array(entitlementSchema),
1445
+ attempts: z14.array(attemptSchema),
1446
+ balances: z14.array(
1447
+ z14.object({
1448
+ member: z14.string(),
1449
+ balance: z14.string(),
1450
+ earned: z14.number(),
1451
+ held: z14.number(),
1452
+ available: z14.number()
1554
1453
  })
1555
1454
  ),
1556
- events: z13.array(eventSchema)
1455
+ events: z14.array(eventSchema)
1557
1456
  });
1558
- var evidenceSchema = z13.object({
1457
+ var evidenceSchema = z14.object({
1559
1458
  id: identifier,
1560
1459
  member: identifier,
1561
- type: z13.enum(["image/jpeg", "image/png"]),
1562
- size: z13.number()
1460
+ type: z14.enum(["image/jpeg", "image/png"]),
1461
+ size: z14.number()
1563
1462
  });
1564
- var errorSchema = z13.object({
1565
- error: z13.string(),
1566
- code: z13.enum(["stale-quiz", "quest-updated", "invalid-submission"]).optional(),
1567
- missing: z13.array(z13.object({ quest: identifier, title: z13.string() })).optional()
1463
+ var errorSchema = z14.object({
1464
+ error: z14.string(),
1465
+ code: z14.enum(["stale-quiz", "quest-updated", "invalid-submission"]).optional(),
1466
+ missing: z14.array(z14.object({ quest: identifier, title: z14.string() })).optional()
1568
1467
  });
1569
- var staffDecisionSchema = z13.object({
1468
+ var staffDecisionSchema = z14.object({
1570
1469
  actionId: identifier,
1571
- generation: z13.number().int().nonnegative(),
1572
- decision: z13.enum(["accept", "reject"]),
1573
- reason: z13.string().trim().min(1).max(2e3)
1470
+ generation: z14.number().int().nonnegative(),
1471
+ decision: z14.enum(["accept", "reject"]),
1472
+ reason: z14.string().trim().min(1).max(2e3)
1574
1473
  }).strict();
1575
- var stockSchema = z13.object({ item: identifier, quantity: z13.number().int().min(0).max(1e4) }).strict();
1576
- var reservationSchema = z13.object({
1474
+ var stockSchema = z14.object({ item: identifier, quantity: z14.number().int().min(0).max(1e4) }).strict();
1475
+ var reservationSchema = z14.object({
1577
1476
  actionId: identifier,
1578
1477
  member: identifier,
1579
1478
  item: identifier,
1580
1479
  balance: identifier,
1581
- price: z13.number().int().positive().max(1e4)
1480
+ price: z14.number().int().positive().max(1e4)
1582
1481
  }).strict();
1583
1482
  var pageOptions = {
1584
- limit: z13.number().int().min(1).max(100).default(25),
1585
- cursor: z13.string().min(1).max(4096).optional()
1483
+ limit: z14.number().int().min(1).max(100).default(25),
1484
+ cursor: z14.string().min(1).max(4096).optional()
1586
1485
  };
1587
- var reviewListSchema = z13.object({
1486
+ var reviewListSchema = z14.object({
1588
1487
  ...pageOptions,
1589
1488
  member: identifier.optional(),
1590
1489
  quest: identifier.optional()
1591
1490
  }).strict();
1592
- var memberListSchema = z13.object({
1491
+ var memberListSchema = z14.object({
1593
1492
  ...pageOptions,
1594
1493
  prefix: identifier.optional()
1595
1494
  }).strict();
1596
- var reviewItemSchema = z13.object({
1495
+ var reviewItemSchema = z14.object({
1597
1496
  attempt: attemptSchema,
1598
- title: z13.string(),
1599
- checks: z13.array(
1600
- z13.object({ criteria: z13.string(), result: photoResultSchema })
1497
+ title: z14.string(),
1498
+ checks: z14.array(
1499
+ z14.object({ criteria: z14.string(), result: photoResultSchema })
1601
1500
  )
1602
1501
  });
1603
- var reviewPageSchema = z13.object({
1604
- items: z13.array(reviewItemSchema).max(100),
1605
- nextCursor: z13.string().nullable()
1502
+ var reviewPageSchema = z14.object({
1503
+ items: z14.array(reviewItemSchema).max(100),
1504
+ nextCursor: z14.string().nullable()
1606
1505
  });
1607
- var memberPageSchema = z13.object({
1608
- items: z13.array(z13.object({ member: identifier })).max(100),
1609
- nextCursor: z13.string().nullable()
1506
+ var memberPageSchema = z14.object({
1507
+ items: z14.array(z14.object({ member: identifier })).max(100),
1508
+ nextCursor: z14.string().nullable()
1610
1509
  });
1611
- var createStockItemSchema = z13.object({ actionId: identifier, name: z13.string().trim().min(1).max(80) }).strict();
1612
- var stockItemSchema = z13.object({ id: identifier, name: z13.string() });
1613
- var contentPerformanceSnapshotSchema = z13.strictObject({
1510
+ var createStockItemSchema = z14.object({ actionId: identifier, name: z14.string().trim().min(1).max(80) }).strict();
1511
+ var stockItemSchema = z14.object({ id: identifier, name: z14.string() });
1512
+ var contentPerformanceSnapshotSchema = z14.strictObject({
1614
1513
  contentAttempt: identifier,
1615
1514
  observation: identifier,
1616
- observedAt: z13.number().int().safe().nonnegative(),
1515
+ observedAt: z14.number().int().safe().nonnegative(),
1617
1516
  metrics: contentMetricsSchema,
1618
1517
  rewards: rewardBundleSchema
1619
1518
  });
1620
1519
  var contentPerformanceQuerySchema = contentQualificationQuerySchema.extend({
1621
- content: z13.string().min(1).max(256)
1520
+ content: z14.string().min(1).max(256)
1622
1521
  });
1623
- var contentPerformancePageSchema = z13.strictObject({
1624
- current: z13.strictObject({
1625
- state: z13.enum([
1522
+ var contentPerformancePageSchema = z14.strictObject({
1523
+ current: z14.strictObject({
1524
+ state: z14.enum([
1626
1525
  "content-pending",
1627
1526
  "content-unqualified",
1628
1527
  "waiting",
@@ -1633,19 +1532,19 @@ var contentPerformancePageSchema = z13.strictObject({
1633
1532
  "failed",
1634
1533
  "superseded"
1635
1534
  ]),
1636
- reason: z13.string().nullable(),
1535
+ reason: z14.string().nullable(),
1637
1536
  contentAttempt: identifier,
1638
1537
  attempt: identifier.nullable(),
1639
1538
  reward: contentQualificationSchema.shape.reward
1640
1539
  }),
1641
- items: z13.array(
1642
- z13.strictObject({
1540
+ items: z14.array(
1541
+ z14.strictObject({
1643
1542
  attempt: identifier,
1644
1543
  contentAttempt: identifier,
1645
1544
  observation: identifier,
1646
- observedAt: z13.number(),
1545
+ observedAt: z14.number(),
1647
1546
  metrics: contentMetricsSchema,
1648
- state: z13.enum([
1547
+ state: z14.enum([
1649
1548
  "pending",
1650
1549
  "qualified",
1651
1550
  "unqualified",
@@ -1653,13 +1552,18 @@ var contentPerformancePageSchema = z13.strictObject({
1653
1552
  "failed",
1654
1553
  "superseded"
1655
1554
  ]),
1656
- reason: z13.string().nullable()
1555
+ reason: z14.string().nullable()
1657
1556
  })
1658
1557
  ),
1659
- next: z13.number().int().positive().safe().nullable()
1558
+ next: z14.number().int().positive().safe().nullable()
1660
1559
  });
1661
1560
 
1662
1561
  export {
1562
+ authProviderSchema,
1563
+ accountConnectionSchema,
1564
+ discordMemberInputSchema,
1565
+ discordMessageInputSchema,
1566
+ discordMemberSchema,
1663
1567
  identifier,
1664
1568
  xTweetSchema,
1665
1569
  xContentBodySchema,
@@ -1674,11 +1578,8 @@ export {
1674
1578
  customSourceSchema,
1675
1579
  trackerSourceSchema,
1676
1580
  sourceIdentities,
1677
- x,
1678
- customSource,
1679
1581
  trackerDefinitionSchema,
1680
1582
  trackerArtifactSchema,
1681
- defineTracker,
1682
1583
  publishedTrackerSchema,
1683
1584
  trackerStatusSchema,
1684
1585
  trackerControlSchema,
@@ -1699,16 +1600,13 @@ export {
1699
1600
  trackerPreviewInputSchema,
1700
1601
  trackerPreviewSchema,
1701
1602
  contentPolicySchema,
1702
- content,
1703
1603
  admittedContentSchema,
1704
- perContent,
1705
1604
  contentEnrollmentInputSchema,
1706
1605
  contentEnrollmentSchema,
1707
1606
  contentReleaseInputSchema,
1708
1607
  contentAdmissionSchema,
1709
1608
  contentAdmissionQuerySchema,
1710
1609
  contentAdmissionPageSchema,
1711
- isContentParticipantRoute,
1712
1610
  contentQualificationDecisionSchema,
1713
1611
  contentQualificationQuerySchema,
1714
1612
  contentQualificationSchema,
@@ -1718,7 +1616,6 @@ export {
1718
1616
  contentPerformancePolicySchema,
1719
1617
  communityTimeZoneSchema,
1720
1618
  streakPolicySchema,
1721
- streak,
1722
1619
  streakProgressSchema,
1723
1620
  trackerTriggerModeSchema,
1724
1621
  defaultTriggerMode,
@@ -1742,11 +1639,6 @@ export {
1742
1639
  integrationProviderSchema,
1743
1640
  discordServerSchema,
1744
1641
  projectIntegrationSchema,
1745
- authProviderSchema,
1746
- accountConnectionSchema,
1747
- discordMemberInputSchema,
1748
- discordMessageInputSchema,
1749
- discordMemberSchema,
1750
1642
  textOptionsSchema,
1751
1643
  urlOptionsSchema,
1752
1644
  textEvidenceSchema,
@@ -1761,12 +1653,11 @@ export {
1761
1653
  resourceSourceSchema,
1762
1654
  resourceRequestSchema,
1763
1655
  resourceOptionsSchema,
1764
- discord,
1765
- pointLedgers,
1656
+ settingInstant,
1657
+ settingResourceId,
1766
1658
  settingFieldSchema,
1767
1659
  settingsFieldsSchema,
1768
1660
  settingsValuesSchema,
1769
- settings,
1770
1661
  parseSettings,
1771
1662
  missingResourceSettings,
1772
1663
  compatibleSettingKinds,