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

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