@domino-sdk/relay 1.0.0-next.6 → 1.0.0-next.8

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