@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.
- package/README.md +13 -1
- package/build.mjs +18 -1
- package/dist/authoring.d.ts +317 -15
- package/dist/authoring.js +177 -23
- package/dist/avatar.d.ts +29 -0
- package/dist/avatar.js +21 -0
- package/dist/browser.d.ts +174 -2239
- package/dist/browser.js +6 -6
- package/dist/{chunk-RTHN22KO.js → chunk-6A6K5RUD.js} +22 -8
- package/dist/chunk-77H7APVD.js +171 -0
- package/dist/chunk-MRIURJE3.js +257 -0
- package/dist/{chunk-5IIWKDFX.js → chunk-QBOHLT7M.js} +26 -5
- package/dist/chunk-V5R2DMGY.js +1407 -0
- package/dist/chunk-V7EZUZ3Z.js +1003 -0
- package/dist/chunk-V7UKZLHA.js +35 -0
- package/dist/{chunk-BRESOTKV.js → chunk-VARGF4JS.js} +660 -770
- package/dist/chunk-ZWY3R6B3.js +26 -0
- package/dist/client-CK4nwt7V.d.ts +2631 -0
- package/dist/collection-BGneJ6Bk.d.ts +114 -0
- package/dist/images--vZ9U0kr.d.ts +234 -0
- package/dist/index.d.ts +11 -13132
- package/dist/index.js +20 -690
- package/dist/integrations-C3Sp558f.d.ts +1297 -0
- package/dist/internal.d.ts +120 -0
- package/dist/internal.js +111 -0
- package/dist/pages-BzqJuI69.d.ts +4006 -0
- package/dist/point-ledgers-iS00Z_v0.d.ts +37 -0
- package/dist/portal-proxy.js +8 -9
- package/dist/profiles-DDMFBRKe.d.ts +297 -0
- package/dist/react/index.d.ts +186 -2251
- package/dist/react/index.js +11 -15
- package/dist/schema-pnuWqvGn.d.ts +3396 -0
- package/dist/schema.d.ts +3196 -2374
- package/dist/schema.js +549 -3
- package/dist/streaks-CwGReWGt.d.ts +73 -0
- package/dist/submission-input-C9qm9ixd.d.ts +2672 -0
- package/dist/units-CwgsPB_r.d.ts +9 -0
- package/dist/wallet-BGOfFkG9.d.ts +231 -0
- package/package.json +17 -4
- package/dist/chunk-ERBVT7GE.js +0 -1847
- package/dist/chunk-XEQDW7FM.js +0 -373
- package/dist/chunk-ZKJBCQNI.js +0 -624
- package/dist/submission-input-CZDukyb3.d.ts +0 -4998
|
@@ -1,26 +1,55 @@
|
|
|
1
|
-
// src/
|
|
2
|
-
import { z
|
|
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 =
|
|
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
|
|
10
|
-
var timestamp =
|
|
11
|
-
var count =
|
|
12
|
-
var externalId =
|
|
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 =
|
|
43
|
+
var xTweetSchema = z4.looseObject({
|
|
15
44
|
id: externalId,
|
|
16
45
|
userId: externalId,
|
|
17
|
-
content:
|
|
18
|
-
createdAt:
|
|
19
|
-
author:
|
|
46
|
+
content: z4.string(),
|
|
47
|
+
createdAt: z4.iso.datetime({ offset: true }),
|
|
48
|
+
author: z4.looseObject({
|
|
20
49
|
id: externalId,
|
|
21
|
-
username:
|
|
22
|
-
name:
|
|
23
|
-
verified:
|
|
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:
|
|
32
|
-
isRetweet:
|
|
33
|
-
isQuoteTweet:
|
|
60
|
+
isReply: z4.boolean(),
|
|
61
|
+
isRetweet: z4.boolean(),
|
|
62
|
+
isQuoteTweet: z4.boolean()
|
|
34
63
|
});
|
|
35
|
-
var xContentBodySchema =
|
|
36
|
-
version:
|
|
37
|
-
id:
|
|
38
|
-
authorId:
|
|
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:
|
|
41
|
-
isReply:
|
|
42
|
-
isRetweet:
|
|
43
|
-
isQuoteTweet:
|
|
44
|
-
media:
|
|
45
|
-
mentionedAuthorIds:
|
|
46
|
-
videoLengthSeconds:
|
|
47
|
-
references:
|
|
48
|
-
replyId:
|
|
49
|
-
replyAuthorId:
|
|
50
|
-
quoteId:
|
|
51
|
-
quoteAuthorId:
|
|
52
|
-
repostId:
|
|
53
|
-
repostAuthorId:
|
|
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 =
|
|
85
|
+
var trackerContentQuerySchema = z4.strictObject({
|
|
57
86
|
id: externalId,
|
|
58
|
-
observation:
|
|
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 =
|
|
93
|
+
var trackerEvidenceSchema = z4.strictObject({
|
|
65
94
|
contentRevision: identifier,
|
|
66
95
|
observation: identifier
|
|
67
96
|
});
|
|
68
|
-
var trackerContentSchema =
|
|
97
|
+
var trackerContentSchema = z4.strictObject({
|
|
69
98
|
tracker: identifier,
|
|
70
|
-
source:
|
|
99
|
+
source: z4.literal("x"),
|
|
71
100
|
evidence: trackerEvidenceSchema,
|
|
72
101
|
content: xContentBodySchema,
|
|
73
102
|
observedAt: timestamp,
|
|
74
|
-
removed:
|
|
75
|
-
attribution:
|
|
76
|
-
|
|
103
|
+
removed: z4.boolean(),
|
|
104
|
+
attribution: z4.discriminatedUnion("kind", [
|
|
105
|
+
z4.strictObject({
|
|
77
106
|
...attributionContext,
|
|
78
|
-
kind:
|
|
79
|
-
account:
|
|
80
|
-
provider:
|
|
81
|
-
issuer:
|
|
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
|
-
|
|
88
|
-
|
|
116
|
+
z4.strictObject({ ...attributionContext, kind: z4.literal("unlinked") }),
|
|
117
|
+
z4.strictObject({
|
|
89
118
|
...attributionContext,
|
|
90
|
-
kind:
|
|
119
|
+
kind: z4.literal("different-author")
|
|
91
120
|
})
|
|
92
121
|
])
|
|
93
122
|
});
|
|
94
|
-
var identityKindSchema =
|
|
95
|
-
var accountRoleSchema =
|
|
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 =
|
|
102
|
-
kind:
|
|
103
|
-
query:
|
|
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 =
|
|
106
|
-
kind:
|
|
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:
|
|
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:
|
|
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:
|
|
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 =
|
|
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
|
|
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 =
|
|
175
|
+
var trackerDefinitionSchema = z4.object({
|
|
155
176
|
key: identifier,
|
|
156
|
-
title:
|
|
177
|
+
title: z4.string().trim().min(1).max(120),
|
|
157
178
|
source: trackerSourceSchema,
|
|
158
179
|
window: windowSchema,
|
|
159
|
-
refreshSeconds:
|
|
160
|
-
maxPages:
|
|
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 =
|
|
183
|
+
var trackerArtifactSchema = z4.union([
|
|
163
184
|
trackerDefinitionSchema,
|
|
164
|
-
|
|
185
|
+
z4.object({ code: z4.string().min(1).max(2e6) }).strict()
|
|
165
186
|
]);
|
|
166
|
-
|
|
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:
|
|
192
|
+
actor: z4.string().nullable()
|
|
175
193
|
});
|
|
176
|
-
var trackerStatusSchema =
|
|
194
|
+
var trackerStatusSchema = z4.object({
|
|
177
195
|
published: publishedTrackerSchema,
|
|
178
|
-
paused:
|
|
179
|
-
state:
|
|
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:
|
|
184
|
-
error:
|
|
201
|
+
coverage: z4.enum(["unknown", "partial", "complete"]),
|
|
202
|
+
error: z4.string().nullable(),
|
|
185
203
|
records: count
|
|
186
204
|
});
|
|
187
|
-
var trackerControlSchema =
|
|
205
|
+
var trackerControlSchema = z4.object({
|
|
188
206
|
actionId: identifier,
|
|
189
|
-
action:
|
|
207
|
+
action: z4.enum(["pause", "resume", "refresh"])
|
|
190
208
|
}).strict();
|
|
191
|
-
var trackerAccountSchema =
|
|
209
|
+
var trackerAccountSchema = z4.strictObject({
|
|
192
210
|
kind: identityKindSchema.optional(),
|
|
193
211
|
id: externalId
|
|
194
212
|
});
|
|
195
|
-
var trackerRecordInputSchema =
|
|
213
|
+
var trackerRecordInputSchema = z4.object({
|
|
196
214
|
id: externalId,
|
|
197
215
|
occurredAt: timestamp,
|
|
198
216
|
observedAt: timestamp,
|
|
199
|
-
author:
|
|
217
|
+
author: z4.object({
|
|
200
218
|
id: externalId,
|
|
201
|
-
verified:
|
|
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:
|
|
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:
|
|
211
|
-
removed:
|
|
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:
|
|
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 =
|
|
240
|
+
var trackerIngestSchema = z4.object({
|
|
223
241
|
actionId: identifier,
|
|
224
|
-
records:
|
|
242
|
+
records: z4.array(trackerRecordInputSchema).min(1).max(100)
|
|
225
243
|
}).strict();
|
|
226
|
-
var trackerIngestResultSchema =
|
|
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:
|
|
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:
|
|
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:
|
|
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 =
|
|
283
|
-
|
|
300
|
+
var trackerOutcomeSchema = z4.discriminatedUnion("state", [
|
|
301
|
+
z4.strictObject({
|
|
284
302
|
...trackerOutcomeFields,
|
|
285
|
-
state:
|
|
286
|
-
code:
|
|
287
|
-
reason:
|
|
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
|
-
|
|
311
|
+
z4.strictObject({
|
|
294
312
|
...trackerOutcomeFields,
|
|
295
|
-
state:
|
|
313
|
+
state: z4.literal("skipped"),
|
|
296
314
|
/** Why the observation was skipped, as one of `trackerSkipCodes`. */
|
|
297
|
-
code:
|
|
315
|
+
code: z4.string().min(1),
|
|
298
316
|
/** Why the observation was skipped, for people. */
|
|
299
|
-
reason:
|
|
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 =
|
|
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:
|
|
328
|
+
state: z4.enum(["admitted", "skipped"]).optional(),
|
|
311
329
|
/** Only skips with this code, such as `unlinked-account`. */
|
|
312
|
-
code:
|
|
313
|
-
limit:
|
|
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:
|
|
333
|
+
before: z4.string().max(512).optional()
|
|
316
334
|
});
|
|
317
|
-
var trackerOutcomePageSchema =
|
|
335
|
+
var trackerOutcomePageSchema = z4.strictObject({
|
|
318
336
|
/** Newest first. */
|
|
319
|
-
items:
|
|
320
|
-
next:
|
|
337
|
+
items: z4.array(trackerOutcomeSchema).max(100),
|
|
338
|
+
next: z4.string().nullable()
|
|
321
339
|
});
|
|
322
|
-
var trackerOutcomeRetrySchema =
|
|
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 =
|
|
330
|
-
|
|
331
|
-
|
|
347
|
+
var booleanQuery = z4.union([
|
|
348
|
+
z4.boolean(),
|
|
349
|
+
z4.enum(["true", "false"]).transform((v) => v === "true")
|
|
332
350
|
]);
|
|
333
|
-
var trackerQuerySchema =
|
|
351
|
+
var trackerQuerySchema = z4.object({
|
|
334
352
|
author: externalId.optional(),
|
|
335
353
|
member: identifier.optional(),
|
|
336
354
|
verified: booleanQuery.optional(),
|
|
337
|
-
since:
|
|
338
|
-
until:
|
|
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:
|
|
341
|
-
minViews:
|
|
342
|
-
limit:
|
|
343
|
-
cursor:
|
|
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 =
|
|
367
|
+
var trackerPageSchema = z4.object({
|
|
350
368
|
tracker: identifier,
|
|
351
|
-
items:
|
|
352
|
-
nextCursor:
|
|
369
|
+
items: z4.array(trackerRecordSchema),
|
|
370
|
+
nextCursor: z4.string().nullable(),
|
|
353
371
|
total: count,
|
|
354
372
|
status: trackerStatusSchema
|
|
355
373
|
});
|
|
356
|
-
var trackerSummarySchema =
|
|
374
|
+
var trackerSummarySchema = z4.object({
|
|
357
375
|
records: count,
|
|
358
376
|
authors: count,
|
|
359
|
-
metrics:
|
|
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 =
|
|
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 =
|
|
381
|
-
query:
|
|
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:
|
|
404
|
+
posts: z4.array(xTweetSchema).max(trackerPreviewLimits.posts),
|
|
387
405
|
/** X had more matches than the sample holds. */
|
|
388
|
-
more:
|
|
406
|
+
more: z4.boolean()
|
|
389
407
|
});
|
|
390
408
|
|
|
391
409
|
// src/content.ts
|
|
392
|
-
|
|
393
|
-
var
|
|
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:
|
|
397
|
-
posts:
|
|
398
|
-
historical:
|
|
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:
|
|
425
|
+
completionKey: z5.string().min(1).max(200)
|
|
420
426
|
});
|
|
421
|
-
|
|
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 =
|
|
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:
|
|
438
|
+
content: z5.string().min(1).max(256)
|
|
445
439
|
});
|
|
446
|
-
var contentAdmissionSchema =
|
|
440
|
+
var contentAdmissionSchema = z5.strictObject({
|
|
447
441
|
quest: identifier,
|
|
448
|
-
content:
|
|
442
|
+
content: z5.string().min(1).max(256),
|
|
449
443
|
release: identifier,
|
|
450
|
-
state:
|
|
451
|
-
reason:
|
|
444
|
+
state: z5.enum(["pending", "admitted", "excluded"]),
|
|
445
|
+
reason: z5.string().nullable(),
|
|
452
446
|
attempt: identifier.nullable()
|
|
453
447
|
});
|
|
454
|
-
var contentAdmissionQuerySchema =
|
|
448
|
+
var contentAdmissionQuerySchema = z5.strictObject({
|
|
455
449
|
quest: identifier,
|
|
456
450
|
member: identifier.optional(),
|
|
457
|
-
content:
|
|
458
|
-
|
|
451
|
+
content: z5.string().min(1).max(256).optional(),
|
|
452
|
+
cursor: pageCursorSchema.optional()
|
|
459
453
|
});
|
|
460
|
-
var contentAdmissionPageSchema =
|
|
461
|
-
items:
|
|
462
|
-
|
|
454
|
+
var contentAdmissionPageSchema = z5.strictObject({
|
|
455
|
+
items: z5.array(contentAdmissionSchema),
|
|
456
|
+
nextCursor: pageCursorSchema.nullable()
|
|
463
457
|
});
|
|
464
|
-
|
|
465
|
-
|
|
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 =
|
|
462
|
+
var contentQualificationQuerySchema = z5.strictObject({
|
|
472
463
|
quest: identifier,
|
|
473
464
|
member: identifier.optional(),
|
|
474
|
-
content:
|
|
475
|
-
|
|
465
|
+
content: z5.string().min(1).max(256).optional(),
|
|
466
|
+
cursor: pageCursorSchema.optional()
|
|
476
467
|
});
|
|
477
|
-
var contentQualificationSchema =
|
|
468
|
+
var contentQualificationSchema = z5.strictObject({
|
|
478
469
|
quest: identifier,
|
|
479
|
-
content:
|
|
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:
|
|
486
|
-
state:
|
|
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:
|
|
498
|
-
reward:
|
|
488
|
+
reason: z5.string().nullable(),
|
|
489
|
+
reward: z5.strictObject({
|
|
499
490
|
attempt: identifier.nullable(),
|
|
500
491
|
completion: identifier.nullable(),
|
|
501
|
-
state:
|
|
492
|
+
state: z5.enum(["unresolved", "awarded", "excluded"])
|
|
502
493
|
})
|
|
503
494
|
});
|
|
504
|
-
var contentQualificationPageSchema =
|
|
505
|
-
items:
|
|
506
|
-
|
|
495
|
+
var contentQualificationPageSchema = z5.strictObject({
|
|
496
|
+
items: z5.array(contentQualificationSchema),
|
|
497
|
+
nextCursor: pageCursorSchema.nullable()
|
|
507
498
|
});
|
|
508
|
-
var contentMetricSchema =
|
|
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 =
|
|
507
|
+
var contentMetricsSchema = z5.partialRecord(
|
|
517
508
|
contentMetricSchema,
|
|
518
|
-
|
|
509
|
+
z5.number().int().safe().nonnegative()
|
|
519
510
|
);
|
|
520
|
-
var contentPerformancePolicySchema =
|
|
521
|
-
metrics:
|
|
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:
|
|
516
|
+
maxAgeMs: z5.number().int().positive().max(864e5).default(36e5)
|
|
526
517
|
});
|
|
527
518
|
|
|
528
519
|
// src/streaks.ts
|
|
529
|
-
import { z as
|
|
530
|
-
var communityTimeZoneSchema =
|
|
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 =
|
|
542
|
-
kind:
|
|
543
|
-
days:
|
|
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
|
|
547
|
-
|
|
548
|
-
|
|
549
|
-
|
|
550
|
-
|
|
551
|
-
|
|
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:
|
|
555
|
-
pendingTimeZone:
|
|
544
|
+
nextBoundary: z6.number().int(),
|
|
545
|
+
pendingTimeZone: z6.object({
|
|
556
546
|
timeZone: communityTimeZoneSchema,
|
|
557
|
-
effectiveAt:
|
|
547
|
+
effectiveAt: z6.number().int()
|
|
558
548
|
}).nullable(),
|
|
559
|
-
days:
|
|
560
|
-
|
|
561
|
-
day:
|
|
562
|
-
date:
|
|
549
|
+
days: z6.array(
|
|
550
|
+
z6.object({
|
|
551
|
+
day: z6.number().int(),
|
|
552
|
+
date: z6.string(),
|
|
563
553
|
timeZone: communityTimeZoneSchema,
|
|
564
|
-
occurredAt:
|
|
554
|
+
occurredAt: z6.number().int()
|
|
565
555
|
})
|
|
566
556
|
),
|
|
567
|
-
milestone:
|
|
568
|
-
|
|
569
|
-
|
|
570
|
-
status:
|
|
571
|
-
completion:
|
|
572
|
-
achievedAt:
|
|
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
|
-
|
|
575
|
-
status:
|
|
576
|
-
budget:
|
|
577
|
-
achievedAt:
|
|
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
|
|
584
|
-
var timestamp3 =
|
|
585
|
-
var count2 =
|
|
586
|
-
var trackerTriggerModeSchema =
|
|
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 =
|
|
595
|
-
|
|
596
|
-
|
|
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 =
|
|
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 =
|
|
603
|
-
|
|
592
|
+
var trackerWhereSchema = z7.union([
|
|
593
|
+
z7.strictObject({
|
|
604
594
|
path: dataPath,
|
|
605
|
-
equals:
|
|
595
|
+
equals: z7.union([z7.string().max(1e3), z7.number().finite(), z7.boolean()])
|
|
606
596
|
}),
|
|
607
|
-
|
|
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 =
|
|
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:
|
|
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:
|
|
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:
|
|
631
|
+
issuer: z7.string().min(1),
|
|
642
632
|
/** The account's stable user ID. */
|
|
643
|
-
subject:
|
|
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 =
|
|
639
|
+
var trackerAttributionSchema = z7.strictObject({
|
|
650
640
|
member: identifier,
|
|
651
641
|
capturedAt: timestamp3,
|
|
652
|
-
account:
|
|
653
|
-
|
|
654
|
-
provider:
|
|
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:
|
|
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
|
-
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
provider:
|
|
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 =
|
|
672
|
-
id:
|
|
673
|
-
source:
|
|
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:
|
|
678
|
-
id:
|
|
679
|
-
verified:
|
|
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:
|
|
683
|
-
data:
|
|
684
|
-
removed:
|
|
672
|
+
accounts: z7.record(accountRoleSchema, trackerAccountSchema).optional(),
|
|
673
|
+
data: z7.record(z7.string(), z7.json()),
|
|
674
|
+
removed: z7.boolean()
|
|
685
675
|
});
|
|
686
|
-
var trackerTriggerContextSchema =
|
|
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:
|
|
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:
|
|
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
|
|
707
|
-
var name =
|
|
708
|
-
var observationInputSchema =
|
|
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:
|
|
714
|
-
occurredAt:
|
|
715
|
-
data:
|
|
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:
|
|
711
|
+
receivedAt: z8.number().int().nonnegative()
|
|
722
712
|
});
|
|
723
|
-
var observationTriggerSchema =
|
|
724
|
-
var completionPolicySchema =
|
|
713
|
+
var observationTriggerSchema = z8.object({ source: name, type: name }).strict();
|
|
714
|
+
var completionPolicySchema = z8.discriminatedUnion("kind", [
|
|
725
715
|
streakPolicySchema,
|
|
726
|
-
|
|
727
|
-
|
|
716
|
+
z8.object({ kind: z8.literal("once") }).strict(),
|
|
717
|
+
z8.object({ kind: z8.literal("keyed") }).strict()
|
|
728
718
|
]);
|
|
729
|
-
var completionKeySchema =
|
|
730
|
-
var budgetSchema =
|
|
719
|
+
var completionKeySchema = z8.string().min(1).max(500);
|
|
720
|
+
var budgetSchema = z8.object({
|
|
731
721
|
id: name,
|
|
732
|
-
scope:
|
|
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:
|
|
738
|
-
limit:
|
|
739
|
-
cost:
|
|
740
|
-
|
|
741
|
-
|
|
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 =
|
|
734
|
+
var observationReceiptSchema = z8.object({
|
|
745
735
|
id: name,
|
|
746
736
|
source: name,
|
|
747
|
-
attempts:
|
|
748
|
-
receivedAt:
|
|
737
|
+
attempts: z8.array(z8.string()),
|
|
738
|
+
receivedAt: z8.number()
|
|
749
739
|
});
|
|
750
|
-
var discordReactionSchema =
|
|
751
|
-
guildId:
|
|
752
|
-
channelId:
|
|
753
|
-
messageId:
|
|
754
|
-
userId:
|
|
755
|
-
messageAuthorId:
|
|
756
|
-
actorRoles:
|
|
757
|
-
emoji:
|
|
758
|
-
messagePublishedAt:
|
|
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 =
|
|
761
|
-
guildId:
|
|
762
|
-
channelId:
|
|
763
|
-
messageId:
|
|
764
|
-
userId:
|
|
765
|
-
content:
|
|
766
|
-
replyTo:
|
|
767
|
-
publishedAt:
|
|
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
|
|
772
|
-
var integrationProviderSchema =
|
|
773
|
-
var discordServerSchema =
|
|
774
|
-
id:
|
|
775
|
-
name:
|
|
776
|
-
icon:
|
|
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 =
|
|
768
|
+
var projectIntegrationSchema = z9.object({
|
|
779
769
|
provider: integrationProviderSchema,
|
|
780
|
-
configured:
|
|
781
|
-
status:
|
|
782
|
-
revision:
|
|
770
|
+
configured: z9.boolean(),
|
|
771
|
+
status: z9.enum(["disconnected", "ready", "attention"]),
|
|
772
|
+
revision: z9.number().int().nonnegative(),
|
|
783
773
|
server: discordServerSchema.nullable(),
|
|
784
|
-
issue:
|
|
785
|
-
connectedAt:
|
|
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
|
|
815
|
-
var textOptionsSchema =
|
|
816
|
-
required:
|
|
817
|
-
minLength:
|
|
818
|
-
maxLength:
|
|
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 =
|
|
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 =
|
|
835
|
-
required:
|
|
836
|
-
allowedHosts:
|
|
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 =
|
|
839
|
-
var urlEvidenceSchema =
|
|
840
|
-
var valueEvidenceSchema =
|
|
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
|
|
904
|
-
var quizId =
|
|
905
|
-
var quizChoiceSchema =
|
|
906
|
-
var quizQuestionSchema =
|
|
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:
|
|
909
|
-
choices:
|
|
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 =
|
|
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 =
|
|
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
|
|
936
|
-
var channelSourceSchema =
|
|
937
|
-
provider:
|
|
938
|
-
resource:
|
|
939
|
-
types:
|
|
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 =
|
|
942
|
-
|
|
943
|
-
provider:
|
|
944
|
-
resource:
|
|
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
|
-
|
|
948
|
-
provider:
|
|
949
|
-
resource:
|
|
950
|
-
assignable:
|
|
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 =
|
|
912
|
+
var resourceRequestSchema = z12.object({
|
|
954
913
|
source: resourceSourceSchema,
|
|
955
|
-
query:
|
|
956
|
-
cursor:
|
|
957
|
-
ids:
|
|
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 =
|
|
960
|
-
revision:
|
|
961
|
-
options:
|
|
962
|
-
|
|
963
|
-
id:
|
|
964
|
-
label:
|
|
965
|
-
description:
|
|
966
|
-
group:
|
|
967
|
-
disabledReason:
|
|
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:
|
|
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
|
-
|
|
995
|
-
|
|
996
|
-
|
|
997
|
-
|
|
998
|
-
|
|
999
|
-
|
|
1000
|
-
|
|
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:
|
|
1003
|
-
default:
|
|
950
|
+
kind: z14.literal("resource"),
|
|
951
|
+
default: settingResourceId,
|
|
1004
952
|
source: resourceSourceSchema
|
|
1005
953
|
}).strict(),
|
|
1006
|
-
|
|
1007
|
-
|
|
954
|
+
z14.object({ ...base, kind: z14.literal("quiz"), default: quizContentSchema }).strict(),
|
|
955
|
+
z14.object({
|
|
1008
956
|
...base,
|
|
1009
|
-
kind:
|
|
1010
|
-
default:
|
|
1011
|
-
minLength:
|
|
1012
|
-
maxLength:
|
|
1013
|
-
multiline:
|
|
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
|
-
|
|
963
|
+
z14.object({
|
|
1016
964
|
...base,
|
|
1017
|
-
kind:
|
|
1018
|
-
default:
|
|
1019
|
-
min:
|
|
1020
|
-
max:
|
|
965
|
+
kind: z14.literal("integer"),
|
|
966
|
+
default: z14.number().int(),
|
|
967
|
+
min: z14.number().int(),
|
|
968
|
+
max: z14.number().int()
|
|
1021
969
|
}).strict(),
|
|
1022
|
-
|
|
1023
|
-
|
|
970
|
+
z14.object({ ...base, kind: z14.literal("boolean"), default: z14.boolean() }).strict(),
|
|
971
|
+
z14.object({
|
|
1024
972
|
...base,
|
|
1025
|
-
kind:
|
|
1026
|
-
default:
|
|
1027
|
-
options:
|
|
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 =
|
|
1031
|
-
|
|
978
|
+
var settingsFieldsSchema = z14.record(
|
|
979
|
+
z14.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
|
|
1032
980
|
settingFieldSchema
|
|
1033
981
|
);
|
|
1034
|
-
var settingsValuesSchema =
|
|
1035
|
-
|
|
1036
|
-
|
|
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] =
|
|
994
|
+
shape[key] = settingInstant.default(field.default);
|
|
1100
995
|
break;
|
|
1101
996
|
case "resource":
|
|
1102
|
-
shape[key] =
|
|
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] =
|
|
1003
|
+
shape[key] = z14.string().min(field.minLength).max(field.maxLength).default(field.default);
|
|
1109
1004
|
break;
|
|
1110
1005
|
case "integer":
|
|
1111
|
-
shape[key] =
|
|
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] =
|
|
1009
|
+
shape[key] = z14.boolean().default(field.default);
|
|
1115
1010
|
break;
|
|
1116
1011
|
case "choice":
|
|
1117
|
-
shape[key] =
|
|
1012
|
+
shape[key] = z14.enum(field.options).default(field.default);
|
|
1118
1013
|
break;
|
|
1119
1014
|
}
|
|
1120
1015
|
}
|
|
1121
|
-
return settingsValuesSchema.parse(
|
|
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
|
-
|
|
1132
|
-
|
|
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:
|
|
1030
|
+
amount: z15.number().int().min(0).max(1e4)
|
|
1135
1031
|
}).strict();
|
|
1136
|
-
var tieredRewardDefinitionSchema =
|
|
1032
|
+
var tieredRewardDefinitionSchema = z15.object({
|
|
1137
1033
|
id: identifier,
|
|
1138
|
-
title:
|
|
1139
|
-
tiers:
|
|
1140
|
-
|
|
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:
|
|
1146
|
-
fulfillment:
|
|
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 =
|
|
1044
|
+
var tieredRewardReferenceSchema = z15.object({
|
|
1149
1045
|
id: identifier,
|
|
1150
1046
|
key: identifier.nullable()
|
|
1151
1047
|
});
|
|
1152
|
-
var tierRewardSchema =
|
|
1153
|
-
kind:
|
|
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 =
|
|
1161
|
-
kind:
|
|
1162
|
-
provider:
|
|
1163
|
-
action:
|
|
1164
|
-
roleId:
|
|
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 =
|
|
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 =
|
|
1178
|
-
|
|
1179
|
-
kind:
|
|
1180
|
-
input:
|
|
1073
|
+
var triggerSchema = z15.union([
|
|
1074
|
+
z15.object({
|
|
1075
|
+
kind: z15.literal("manual"),
|
|
1076
|
+
input: z15.literal("text"),
|
|
1181
1077
|
constraints: textOptionsSchema,
|
|
1182
|
-
actor:
|
|
1078
|
+
actor: z15.enum(["member", "staff"]).optional()
|
|
1183
1079
|
}).strict(),
|
|
1184
|
-
|
|
1185
|
-
kind:
|
|
1186
|
-
input:
|
|
1080
|
+
z15.object({
|
|
1081
|
+
kind: z15.literal("manual"),
|
|
1082
|
+
input: z15.literal("url"),
|
|
1187
1083
|
constraints: urlOptionsSchema,
|
|
1188
|
-
actor:
|
|
1084
|
+
actor: z15.enum(["member", "staff"]).optional()
|
|
1189
1085
|
}).strict(),
|
|
1190
|
-
|
|
1191
|
-
kind:
|
|
1192
|
-
input:
|
|
1193
|
-
actor:
|
|
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
|
-
|
|
1196
|
-
kind:
|
|
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 =
|
|
1206
|
-
var photoResultSchema =
|
|
1207
|
-
kind:
|
|
1208
|
-
reason:
|
|
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 =
|
|
1211
|
-
text:
|
|
1212
|
-
criteria:
|
|
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 =
|
|
1216
|
-
|
|
1217
|
-
kind:
|
|
1218
|
-
rewards:
|
|
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
|
-
|
|
1222
|
-
kind:
|
|
1223
|
-
reason:
|
|
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:
|
|
1121
|
+
requestedReview: z15.literal(true).optional()
|
|
1226
1122
|
}).strict(),
|
|
1227
|
-
|
|
1228
|
-
kind:
|
|
1229
|
-
reason:
|
|
1230
|
-
rewards:
|
|
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 =
|
|
1235
|
-
var storedReviewModeSchema =
|
|
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 =
|
|
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 =
|
|
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 =
|
|
1152
|
+
var questPresentationSchema = z15.object({
|
|
1257
1153
|
quiz: quizQuestionsSchema.optional(),
|
|
1258
|
-
instructions:
|
|
1259
|
-
video:
|
|
1154
|
+
instructions: z15.string().max(4e3).optional(),
|
|
1155
|
+
video: z15.object({
|
|
1260
1156
|
url: mediaUrlSchema,
|
|
1261
1157
|
poster: mediaUrlSchema.optional(),
|
|
1262
|
-
captions:
|
|
1158
|
+
captions: z15.object({
|
|
1263
1159
|
url: mediaUrlSchema,
|
|
1264
|
-
language:
|
|
1265
|
-
label:
|
|
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 =
|
|
1270
|
-
var questDescriptionSchema =
|
|
1165
|
+
var questProfileSchema = z15.object({ visible: z15.boolean() }).strict();
|
|
1166
|
+
var questDescriptionSchema = z15.object({
|
|
1271
1167
|
quest: identifier,
|
|
1272
|
-
runtimeVersion:
|
|
1273
|
-
title:
|
|
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:
|
|
1171
|
+
integrations: z15.array(integrationProviderSchema).max(10).default([]),
|
|
1276
1172
|
fields: settingsFieldsSchema,
|
|
1277
1173
|
values: settingsValuesSchema,
|
|
1278
1174
|
rewards: rewardBundleSchema,
|
|
1279
|
-
humanReview:
|
|
1175
|
+
humanReview: z15.boolean(),
|
|
1280
1176
|
trigger: triggerSchema,
|
|
1281
1177
|
performance: contentPerformancePolicySchema.optional(),
|
|
1282
|
-
requires:
|
|
1178
|
+
requires: z15.array(prerequisiteSchema).max(30).default([]),
|
|
1283
1179
|
completion: completionPolicySchema,
|
|
1284
|
-
visibility:
|
|
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:
|
|
1187
|
+
budgets: z15.array(budgetSchema).max(20).default([])
|
|
1292
1188
|
}).strict();
|
|
1293
|
-
var artifactSchema =
|
|
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:
|
|
1194
|
+
settingRenames: z15.record(z15.string(), z15.string()).optional()
|
|
1299
1195
|
}).strict();
|
|
1300
|
-
var batchReleaseSchema =
|
|
1301
|
-
var questSettingsInputSchema =
|
|
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:
|
|
1201
|
+
reset: z15.array(z15.string())
|
|
1306
1202
|
}).strict();
|
|
1307
1203
|
var storedReleaseSchema = questDescriptionSchema.extend({
|
|
1308
1204
|
key: identifier.optional(),
|
|
1309
|
-
code:
|
|
1205
|
+
code: z15.string(),
|
|
1310
1206
|
provider: storedReviewModeSchema,
|
|
1311
1207
|
id: identifier,
|
|
1312
|
-
createdAt:
|
|
1313
|
-
legacy:
|
|
1314
|
-
origin:
|
|
1315
|
-
lifecycle:
|
|
1316
|
-
configuration:
|
|
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:
|
|
1215
|
+
preserved: z15.array(z15.string())
|
|
1320
1216
|
}).strict().optional()
|
|
1321
1217
|
});
|
|
1322
|
-
var legacyReleaseSchema =
|
|
1218
|
+
var legacyReleaseSchema = z15.object({
|
|
1323
1219
|
quest: identifier,
|
|
1324
|
-
title:
|
|
1325
|
-
criteria:
|
|
1326
|
-
humanReview:
|
|
1220
|
+
title: z15.string(),
|
|
1221
|
+
criteria: z15.string(),
|
|
1222
|
+
humanReview: z15.boolean(),
|
|
1327
1223
|
rewards: rewardBundleSchema,
|
|
1328
|
-
code:
|
|
1224
|
+
code: z15.string(),
|
|
1329
1225
|
provider: storedReviewModeSchema,
|
|
1330
1226
|
id: identifier,
|
|
1331
|
-
createdAt:
|
|
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 =
|
|
1239
|
+
var publishedReleaseSchema = z15.union([
|
|
1344
1240
|
storedReleaseSchema,
|
|
1345
1241
|
legacyReleaseSchema
|
|
1346
1242
|
]);
|
|
1347
|
-
var templateSchema =
|
|
1348
|
-
code:
|
|
1243
|
+
var templateSchema = z15.object({
|
|
1244
|
+
code: z15.string(),
|
|
1349
1245
|
definition: questDescriptionSchema
|
|
1350
1246
|
});
|
|
1351
|
-
var quizAnswersSchema =
|
|
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 =
|
|
1360
|
-
kind:
|
|
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 =
|
|
1260
|
+
var submissionEvidenceSchema = z15.union([
|
|
1365
1261
|
quizEvidenceSchema,
|
|
1366
1262
|
textEvidenceSchema,
|
|
1367
1263
|
urlEvidenceSchema
|
|
1368
1264
|
]);
|
|
1369
|
-
var submitSchema =
|
|
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:
|
|
1272
|
+
faultAfterReview: z15.boolean().optional()
|
|
1377
1273
|
}).strict();
|
|
1378
|
-
var attemptSchema =
|
|
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:
|
|
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:
|
|
1395
|
-
retries:
|
|
1396
|
-
generation:
|
|
1397
|
-
completion:
|
|
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:
|
|
1404
|
-
createdAt:
|
|
1299
|
+
requestedReview: z15.boolean().default(false),
|
|
1300
|
+
createdAt: z15.number()
|
|
1405
1301
|
});
|
|
1406
|
-
var eventSchema =
|
|
1407
|
-
id:
|
|
1408
|
-
attempt:
|
|
1409
|
-
kind:
|
|
1410
|
-
detail:
|
|
1411
|
-
actor:
|
|
1412
|
-
at:
|
|
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 =
|
|
1310
|
+
var pickupSelectionSchema = z15.object({
|
|
1415
1311
|
item: identifier,
|
|
1416
|
-
revision:
|
|
1312
|
+
revision: z15.number().int().nonnegative()
|
|
1417
1313
|
}).strict();
|
|
1418
|
-
var pickupAllocationSchema =
|
|
1314
|
+
var pickupAllocationSchema = z15.object({
|
|
1419
1315
|
item: identifier,
|
|
1420
|
-
label:
|
|
1316
|
+
label: z15.string().min(1).max(80)
|
|
1421
1317
|
}).strict();
|
|
1422
|
-
var pickupPolicySchema =
|
|
1423
|
-
|
|
1424
|
-
|
|
1425
|
-
kind:
|
|
1426
|
-
tiers:
|
|
1427
|
-
|
|
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:
|
|
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 =
|
|
1330
|
+
var pickupCatalogSchema = z15.object({
|
|
1435
1331
|
reward: tieredRewardDefinitionSchema,
|
|
1436
|
-
revision:
|
|
1332
|
+
revision: z15.number().int().nonnegative(),
|
|
1437
1333
|
policy: pickupPolicySchema
|
|
1438
1334
|
});
|
|
1439
|
-
var pickupAvailabilitySchema =
|
|
1440
|
-
|
|
1441
|
-
|
|
1442
|
-
kind:
|
|
1443
|
-
revision:
|
|
1444
|
-
variants:
|
|
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:
|
|
1342
|
+
available: z15.number().int().nonnegative()
|
|
1447
1343
|
})
|
|
1448
1344
|
)
|
|
1449
1345
|
}).strict()
|
|
1450
1346
|
]);
|
|
1451
|
-
var configurePickupSchema =
|
|
1347
|
+
var configurePickupSchema = z15.object({
|
|
1452
1348
|
reward: identifier,
|
|
1453
|
-
revision:
|
|
1349
|
+
revision: z15.number().int().nonnegative(),
|
|
1454
1350
|
actionId: identifier,
|
|
1455
|
-
policy:
|
|
1456
|
-
|
|
1457
|
-
|
|
1458
|
-
kind:
|
|
1459
|
-
tiers:
|
|
1460
|
-
|
|
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:
|
|
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:
|
|
1374
|
+
revision: z15.number().int().positive()
|
|
1479
1375
|
};
|
|
1480
|
-
var entitlementSchema =
|
|
1481
|
-
|
|
1482
|
-
|
|
1376
|
+
var entitlementSchema = z15.discriminatedUnion("status", [
|
|
1377
|
+
z15.object({ ...entitlementBase, status: z15.literal("available") }).strict(),
|
|
1378
|
+
z15.object({
|
|
1483
1379
|
...entitlementBase,
|
|
1484
|
-
status:
|
|
1380
|
+
status: z15.literal("handing-over"),
|
|
1485
1381
|
handover: identifier,
|
|
1486
|
-
startedAt:
|
|
1382
|
+
startedAt: z15.number(),
|
|
1487
1383
|
allocation: pickupAllocationSchema.optional()
|
|
1488
1384
|
}).strict(),
|
|
1489
|
-
|
|
1385
|
+
z15.object({
|
|
1490
1386
|
...entitlementBase,
|
|
1491
|
-
status:
|
|
1387
|
+
status: z15.literal("collected"),
|
|
1492
1388
|
handover: identifier,
|
|
1493
|
-
startedAt:
|
|
1389
|
+
startedAt: z15.number(),
|
|
1494
1390
|
allocation: pickupAllocationSchema.optional(),
|
|
1495
|
-
collectedAt:
|
|
1391
|
+
collectedAt: z15.number()
|
|
1496
1392
|
}).strict()
|
|
1497
1393
|
]);
|
|
1498
|
-
var beginHandoverSchema =
|
|
1394
|
+
var beginHandoverSchema = z15.object({
|
|
1499
1395
|
actionId: identifier,
|
|
1500
|
-
revision:
|
|
1396
|
+
revision: z15.number().int().positive(),
|
|
1501
1397
|
selection: pickupSelectionSchema.optional()
|
|
1502
1398
|
}).strict();
|
|
1503
|
-
var confirmHandoverSchema =
|
|
1504
|
-
var completionRecordSchema =
|
|
1505
|
-
key:
|
|
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 =
|
|
1511
|
-
|
|
1512
|
-
kind:
|
|
1513
|
-
input:
|
|
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
|
-
|
|
1516
|
-
|
|
1517
|
-
kind:
|
|
1518
|
-
missing:
|
|
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
|
-
|
|
1521
|
-
|
|
1522
|
-
kind:
|
|
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
|
-
|
|
1526
|
-
|
|
1527
|
-
|
|
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 =
|
|
1425
|
+
var memberProgressSchema = z15.object({
|
|
1530
1426
|
member: identifier,
|
|
1531
|
-
quests:
|
|
1532
|
-
|
|
1427
|
+
quests: z15.array(
|
|
1428
|
+
z15.object({
|
|
1533
1429
|
quest: identifier,
|
|
1534
1430
|
key: identifier.optional(),
|
|
1535
1431
|
release: identifier.optional(),
|
|
1536
|
-
title:
|
|
1432
|
+
title: z15.string(),
|
|
1537
1433
|
presentation: questPresentationSchema.default({}),
|
|
1538
|
-
connections:
|
|
1434
|
+
connections: z15.array(authProviderSchema).default([]),
|
|
1539
1435
|
trigger: triggerSchema,
|
|
1540
1436
|
availability: questAvailabilitySchema,
|
|
1541
|
-
completed:
|
|
1437
|
+
completed: z15.boolean(),
|
|
1542
1438
|
completion: completionPolicySchema.default({ kind: "once" }),
|
|
1543
1439
|
streak: streakProgressSchema.nullable().optional(),
|
|
1544
|
-
completionCount:
|
|
1545
|
-
visibility:
|
|
1546
|
-
missing:
|
|
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:
|
|
1446
|
+
entitlements: z15.array(entitlementSchema)
|
|
1551
1447
|
});
|
|
1552
|
-
var snapshotSchema =
|
|
1553
|
-
releases:
|
|
1554
|
-
completions:
|
|
1555
|
-
entitlements:
|
|
1556
|
-
attempts:
|
|
1557
|
-
balances:
|
|
1558
|
-
|
|
1559
|
-
member:
|
|
1560
|
-
balance:
|
|
1561
|
-
earned:
|
|
1562
|
-
held:
|
|
1563
|
-
available:
|
|
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:
|
|
1462
|
+
events: z15.array(eventSchema)
|
|
1567
1463
|
});
|
|
1568
|
-
var evidenceSchema =
|
|
1464
|
+
var evidenceSchema = z15.object({
|
|
1569
1465
|
id: identifier,
|
|
1570
1466
|
member: identifier,
|
|
1571
|
-
type:
|
|
1572
|
-
size:
|
|
1467
|
+
type: z15.enum(["image/jpeg", "image/png"]),
|
|
1468
|
+
size: z15.number()
|
|
1573
1469
|
});
|
|
1574
|
-
var errorSchema =
|
|
1575
|
-
error:
|
|
1576
|
-
code:
|
|
1577
|
-
missing:
|
|
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 =
|
|
1475
|
+
var staffDecisionSchema = z15.object({
|
|
1580
1476
|
actionId: identifier,
|
|
1581
|
-
generation:
|
|
1582
|
-
decision:
|
|
1583
|
-
reason:
|
|
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 =
|
|
1586
|
-
var reservationSchema =
|
|
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:
|
|
1487
|
+
price: z15.number().int().positive().max(1e4)
|
|
1592
1488
|
}).strict();
|
|
1593
1489
|
var pageOptions = {
|
|
1594
|
-
limit:
|
|
1595
|
-
cursor:
|
|
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 =
|
|
1493
|
+
var reviewListSchema = z15.object({
|
|
1598
1494
|
...pageOptions,
|
|
1599
1495
|
member: identifier.optional(),
|
|
1600
1496
|
quest: identifier.optional()
|
|
1601
1497
|
}).strict();
|
|
1602
|
-
var memberListSchema =
|
|
1498
|
+
var memberListSchema = z15.object({
|
|
1603
1499
|
...pageOptions,
|
|
1604
1500
|
prefix: identifier.optional()
|
|
1605
1501
|
}).strict();
|
|
1606
|
-
var reviewItemSchema =
|
|
1502
|
+
var reviewItemSchema = z15.object({
|
|
1607
1503
|
attempt: attemptSchema,
|
|
1608
|
-
title:
|
|
1609
|
-
checks:
|
|
1610
|
-
|
|
1504
|
+
title: z15.string(),
|
|
1505
|
+
checks: z15.array(
|
|
1506
|
+
z15.object({ criteria: z15.string(), result: photoResultSchema })
|
|
1611
1507
|
)
|
|
1612
1508
|
});
|
|
1613
|
-
var reviewPageSchema =
|
|
1614
|
-
items:
|
|
1615
|
-
nextCursor:
|
|
1509
|
+
var reviewPageSchema = z15.object({
|
|
1510
|
+
items: z15.array(reviewItemSchema).max(100),
|
|
1511
|
+
nextCursor: z15.string().nullable()
|
|
1616
1512
|
});
|
|
1617
|
-
var memberPageSchema =
|
|
1618
|
-
items:
|
|
1619
|
-
nextCursor:
|
|
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 =
|
|
1622
|
-
var stockItemSchema =
|
|
1623
|
-
var contentPerformanceSnapshotSchema =
|
|
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:
|
|
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:
|
|
1527
|
+
content: z15.string().min(1).max(256)
|
|
1632
1528
|
});
|
|
1633
|
-
var contentPerformancePageSchema =
|
|
1634
|
-
current:
|
|
1635
|
-
state:
|
|
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:
|
|
1542
|
+
reason: z15.string().nullable(),
|
|
1647
1543
|
contentAttempt: identifier,
|
|
1648
1544
|
attempt: identifier.nullable(),
|
|
1649
1545
|
reward: contentQualificationSchema.shape.reward
|
|
1650
1546
|
}),
|
|
1651
|
-
items:
|
|
1652
|
-
|
|
1547
|
+
items: z15.array(
|
|
1548
|
+
z15.strictObject({
|
|
1653
1549
|
attempt: identifier,
|
|
1654
1550
|
contentAttempt: identifier,
|
|
1655
1551
|
observation: identifier,
|
|
1656
|
-
observedAt:
|
|
1552
|
+
observedAt: z15.number(),
|
|
1657
1553
|
metrics: contentMetricsSchema,
|
|
1658
|
-
state:
|
|
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:
|
|
1562
|
+
reason: z15.string().nullable()
|
|
1667
1563
|
})
|
|
1668
1564
|
),
|
|
1669
|
-
|
|
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
|
-
|
|
1775
|
-
|
|
1665
|
+
settingInstant,
|
|
1666
|
+
settingResourceId,
|
|
1776
1667
|
settingFieldSchema,
|
|
1777
1668
|
settingsFieldsSchema,
|
|
1778
1669
|
settingsValuesSchema,
|
|
1779
|
-
settings,
|
|
1780
1670
|
parseSettings,
|
|
1781
1671
|
missingResourceSettings,
|
|
1782
1672
|
compatibleSettingKinds,
|