@voltro/plugin-leaderboards 0.0.0-stage → 0.87.0

package/dist/ratingStore.js

@@ -0,0 +1,334 @@
+import { LeaderboardError as e, leaderboardError as t } from "./errors.js";
+import { leaderboardIdentifier as n } from "./leaderboard.js";
+import { canonicalLeaderboardJson as r, captureLeaderboardJson as i } from "./json.js";
+import { PrepareRatingMatchSchema as a, exactRatingState as o } from "./ratingPools.js";
+import { admitRatingStrategyResults as s } from "./ratingStrategies.js";
+import { leaderboardRatingMatchesTable as c, leaderboardRatingPoolsTable as l, leaderboardRatingResultsTable as u, leaderboardRatingsTable as d } from "./tables.entity.js";
+import { Effect as f, Schema as p } from "effect";
+import { and as m, eq as h, queryFor as g } from "@voltro/database";
+//#region src/ratingStore.ts
+var _ = (n) => n instanceof e ? n : t("unavailable"), v = (e) => f.tryPromise({
+	try: e,
+	catch: _
+}), y = (e) => {
+	let n = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+	if (!Number.isSafeInteger(n) || n < 0 || n > 864e13) throw t("unavailable");
+	return n;
+}, b = (e, b, x) => {
+	let S = new Map(b.map((e) => [e.name, e])), C = (e) => ({
+		...e,
+		strategyVersion: x.strategies.version
+	}), w = (e) => {
+		let n = S.get(e);
+		if (!n) throw t("not_found");
+		return n;
+	}, T = (e) => {
+		let r = i(e, 4096);
+		if (!r || Object.keys(r).length !== 3 || ![
+			r.tenantId,
+			r.pool,
+			r.matchId
+		].every(n)) throw t("invalid_input");
+		return w(r.pool), Object.freeze(r);
+	}, E = (e, n = !0) => {
+		let o = i(e, 65536), s = p.decodeUnknownSync(a)(o);
+		if (r(s) !== r(o) || s.ranks.length !== s.teams.length || s.ranks.some((e) => e > s.teams.length)) throw t("invalid_input");
+		let c = s.teams.flat().map((e) => e.ownerId);
+		if (new Set(c).size !== c.length || c.length > 4096 || s.teams.some((e) => !e.some((e) => (e.weight ?? 1) > 0)) || n && w(s.pool).algorithm === "glicko2" && (s.teams.length !== 2 || s.teams.some((e) => e.length !== 1 || (e[0].weight ?? 1) !== 1))) throw t("invalid_input");
+		return s;
+	}, D = (e, n) => {
+		let r = E(e.input, !1);
+		if (r.tenantId !== n || r.pool !== e.pool || O(r) !== e.id || x.hash(r) !== e.requestKey) throw t("unavailable");
+		return r;
+	}, O = (e) => x.key("lbrm_", [
+		e.tenantId,
+		e.pool,
+		e.matchId
+	]), k = async (t, n) => {
+		let r = x.key("lbrp_", [t, n.name]);
+		try {
+			await e.insertIgnore(l.tableName, {
+				id: r,
+				tenantId: t,
+				name: n.name,
+				config: C(n),
+				admission: 0
+			}, { conflictColumns: ["id"] });
+		} catch (t) {
+			if (!(await e.query(g(l).where(h("id", r)).limit(1).descriptor))[0]) throw t;
+		}
+	}, A = async (e, n, i) => {
+		let a = x.key("lbrp_", [n, i.name]);
+		if (await e.updateMany(l.tableName, { admission: 0 }, { where: h("id", a) }) !== 1) throw t("unavailable");
+		let o = (await e.query(g(l).where(h("id", a)).limit(1).descriptor))[0];
+		if (!o || o.tenantId !== n || o.name !== i.name || r(o.config) !== r(C(i))) throw t("conflict");
+	}, j = async (e, n) => {
+		let r = (await e.query(g(c).where(h("id", O(n))).limit(1).descriptor))[0];
+		if (r && (r.tenantId !== n.tenantId || r.pool !== n.pool || !Number.isSafeInteger(r.participants) || Number(r.participants) < 2 || Number(r.participants) > 4096)) throw t("unavailable");
+		return r;
+	}, M = (e, n) => {
+		if (e.state !== "prepared" && e.state !== "applied") throw t(e.state === "erased" ? "erased" : "unavailable");
+		return {
+			pool: n.pool,
+			matchId: n.matchId,
+			participants: Number(e.participants),
+			state: e.state,
+			preparedAt: y(e.preparedAt),
+			appliedAt: e.appliedAt === null ? null : y(e.appliedAt)
+		};
+	}, N = async (e, n, r, i) => {
+		let a = await e.query(g(n).where(m(h("tenantId", r), h("ownerId", i))).orderBy("id", "asc").limit(x.maxRows + 1).descriptor);
+		if (a.length > x.maxRows) throw t("limit_exceeded");
+		if (a.some((e) => e.tenantId !== r || e.ownerId !== i)) throw t("unavailable");
+		return a;
+	}, P = async (e, n) => {
+		let r = await e.query(g(c).where(h("tenantId", n)).orderBy("id", "asc").limit(x.maxRows + 1).descriptor);
+		if (r.length > x.maxRows) throw t("limit_exceeded");
+		if (r.some((e) => e.tenantId !== n)) throw t("unavailable");
+		return r;
+	}, F = async (e, n, r, i) => {
+		let a = x.key("lbrr_", [
+			n,
+			r.name,
+			i
+		]), s = (await e.query(g(d).where(h("id", a)).limit(1).descriptor))[0];
+		if (s && (s.tenantId !== n || s.pool !== r.name || s.ownerId !== i || !Number.isSafeInteger(s.games) || Number(s.games) < 0 || Number(s.games) > 2147483647)) throw t("unavailable");
+		return {
+			id: a,
+			row: s,
+			state: s ? o(s.state, r.algorithm) : r.initial
+		};
+	};
+	return {
+		prepareRatingMatch: (n, r) => {
+			let i, a;
+			try {
+				if (!x.machine(n)) throw t("forbidden");
+				i = E(r), a = w(i.pool);
+			} catch (e) {
+				return f.fail(_(e));
+			}
+			let o = i.teams.flat().map((e) => e.ownerId).sort(), s = x.hash(i);
+			return v(async () => {
+				for (let e of o) await x.seedSubject(i.tenantId, e);
+				return await k(i.tenantId, a), e.transactional(async (e) => {
+					for (let t of o) await x.subjectFence(e, i.tenantId, t);
+					await A(e, i.tenantId, a);
+					let n = await j(e, i);
+					if (n) {
+						if (n.requestKey !== s) throw t("conflict");
+						return M(n, i);
+					}
+					if ((await P(e, i.tenantId)).length >= x.maxRows) throw t("limit_exceeded");
+					let r = x.now(), l = await e.insert(c.tableName, {
+						id: O(i),
+						tenantId: i.tenantId,
+						pool: i.pool,
+						matchId: i.matchId,
+						requestKey: s,
+						state: "prepared",
+						input: i,
+						participants: o.length,
+						preparedAt: new Date(r),
+						appliedAt: null
+					});
+					return M(l, i);
+				});
+			});
+		},
+		applyRatingMatch: (n, i) => {
+			let a, l;
+			try {
+				if (!x.machine(n)) throw t("forbidden");
+				a = T(i), l = w(a.pool);
+			} catch (e) {
+				return f.fail(_(e));
+			}
+			return v(async () => {
+				let n = await j(e, a);
+				if (!n) throw t("not_found");
+				if (n.state === "erased") throw t("erased");
+				if (n.state === "applied") return M(n, a);
+				let i = E(n.input), f = i.teams.flat().map((e) => e.ownerId).sort();
+				if (x.hash(i) !== n.requestKey || O(i) !== O(a)) throw t("unavailable");
+				return e.transactional(async (e) => {
+					for (let t of f) await x.subjectFence(e, a.tenantId, t);
+					await A(e, a.tenantId, l);
+					let p = await j(e, a);
+					if (!p) throw t("not_found");
+					if (p.state !== "prepared") return M(p, a);
+					if (p.requestKey !== n.requestKey || r(p.input) !== r(i)) throw t("conflict");
+					let m = x.now();
+					if (m < y(p.preparedAt)) throw t("invalid_input");
+					let h = /* @__PURE__ */ new Map();
+					for (let t of f) h.set(t, await F(e, a.tenantId, l, t));
+					let g = Object.freeze(i.teams.map((e) => Object.freeze(e.map((e) => {
+						let n = h.get(e.ownerId), r = Number(n.row?.games ?? 0), i = e.weight ?? 1, s = n.row ? y(n.row.updatedAt) : null;
+						if (s !== null && s > m) throw t("invalid_record");
+						let c = n.state;
+						if (i > 0) {
+							let i = Object.freeze({
+								tenantId: a.tenantId,
+								ownerId: e.ownerId,
+								pool: l,
+								at: m
+							}), u = n.row === void 0 ? x.strategies.placementPolicy(i) : x.strategies.decay(Object.freeze({
+								...i,
+								state: c,
+								games: r,
+								updatedAt: s,
+								elapsedMs: m - s
+							}));
+							try {
+								c = o(u, l.algorithm);
+							} catch {
+								throw t("invalid_record");
+							}
+						}
+						return Object.freeze({
+							ownerId: e.ownerId,
+							state: c,
+							games: r,
+							updatedAt: s,
+							weight: i
+						});
+					})))), _ = Object.freeze({
+						tenantId: a.tenantId,
+						matchId: a.matchId,
+						pool: l,
+						at: m,
+						teams: g,
+						ranks: Object.freeze([...i.ranks])
+					}), v = s(x.strategies.rate(_), _);
+					for (let n of i.teams.flat()) {
+						let r = h.get(n.ownerId), i = v.get(n.ownerId), o = Number(r.row?.games ?? 0) + ((n.weight ?? 1) === 0 ? 0 : 1);
+						if (o > 2147483647) throw t("overflow");
+						if (r.row) {
+							if ((n.weight ?? 1) > 0 && !await e.update(d.tableName, r.id, {
+								state: i,
+								games: o,
+								updatedAt: new Date(m)
+							})) throw t("unavailable");
+						} else await e.insert(d.tableName, {
+							id: r.id,
+							tenantId: a.tenantId,
+							pool: a.pool,
+							ownerId: n.ownerId,
+							state: i,
+							games: o,
+							updatedAt: new Date(m)
+						});
+						await e.insert(u.tableName, {
+							id: x.key("lbrs_", [
+								a.tenantId,
+								a.pool,
+								a.matchId,
+								n.ownerId
+							]),
+							tenantId: a.tenantId,
+							pool: a.pool,
+							matchKey: String(p.id),
+							ownerId: n.ownerId,
+							previous: r.state,
+							current: i,
+							at: new Date(m)
+						});
+					}
+					let b = await e.update(c.tableName, String(p.id), {
+						state: "applied",
+						input: null,
+						appliedAt: new Date(m)
+					});
+					if (!b) throw t("unavailable");
+					return M(b, a);
+				});
+			});
+		},
+		myRating: (i, a) => {
+			let o, s, c;
+			try {
+				if (i?.type !== "user" || !n(i.id) || !n(i.tenantId)) throw t("forbidden");
+				o = i.tenantId, s = i.id, c = w(a);
+			} catch (e) {
+				return f.fail(_(e));
+			}
+			return v(async () => {
+				let n = (await e.query(g(l).where(h("id", x.key("lbrp_", [o, c.name]))).limit(1).descriptor))[0];
+				if (n && (n.tenantId !== o || n.name !== c.name || r(n.config) !== r(C(c)))) throw t("conflict");
+				let i = await F(e, o, c, s);
+				if (i.row && !n) throw t("unavailable");
+				return {
+					pool: c.name,
+					state: i.state,
+					games: Number(i.row?.games ?? 0),
+					updatedAt: i.row ? y(i.row.updatedAt) : null
+				};
+			});
+		},
+		pendingRatingMatches: (r, i, a, o = 100) => {
+			try {
+				if (!x.machine(r)) throw t("forbidden");
+				if (!n(i) || !Number.isSafeInteger(o) || o < 1 || o > 1e3) throw t("invalid_input");
+				w(a);
+			} catch (e) {
+				return f.fail(_(e));
+			}
+			return v(async () => {
+				let r = await e.query(g(c).where(m(h("tenantId", i), h("pool", a), h("state", "prepared"))).orderBy("id", "asc").limit(o).descriptor);
+				if (r.some((e) => e.tenantId !== i || e.pool !== a || e.state !== "prepared" || !n(e.matchId))) throw t("unavailable");
+				return r.map((e) => ({
+					tenantId: i,
+					pool: a,
+					matchId: String(e.matchId)
+				}));
+			});
+		},
+		privacyFences: async (e, n) => {
+			let r = await e.query(g(l).where(h("tenantId", n)).orderBy("id", "asc").limit(x.maxRows + 1).descriptor);
+			if (r.length > x.maxRows) throw t("limit_exceeded");
+			for (let i of r) if (i.tenantId !== n || await e.updateMany(l.tableName, { admission: 0 }, { where: m(h("id", String(i.id)), h("tenantId", n)) }) !== 1) throw t("unavailable");
+		},
+		exportInTransaction: async (e, t, n) => {
+			let r = await N(e, d, t, n), a = await N(e, u, t, n), o = await P(e, t), s = new Map(o.map((e) => [e.id, e]));
+			return {
+				ratings: r.map((e) => ({
+					pool: e.pool,
+					state: i(e.state, 1024),
+					games: e.games,
+					updatedAt: y(e.updatedAt)
+				})),
+				ratingResults: a.map((e) => ({
+					pool: e.pool,
+					matchId: s.get(e.matchKey)?.matchId ?? null,
+					previous: i(e.previous, 1024),
+					current: i(e.current, 1024),
+					at: y(e.at)
+				})),
+				pendingRatingMatches: o.filter((e) => e.state === "prepared").flatMap((e) => {
+					let r = D(e, t);
+					return r.teams.flatMap((t, i) => t.filter((e) => e.ownerId === n).map((t) => ({
+						pool: e.pool,
+						matchId: e.matchId,
+						weight: t.weight ?? 1,
+						rank: r.ranks[i],
+						preparedAt: y(e.preparedAt)
+					})));
+				})
+			};
+		},
+		eraseInTransaction: async (e, n, r) => {
+			let i = await N(e, d, n, r), a = await N(e, u, n, r), o = new Set(a.map((e) => e.matchKey));
+			for (let i of await P(e, n)) if (i.state === "prepared") {
+				if (D(i, n).teams.flat().some((e) => e.ownerId === r) && !await e.update(c.tableName, String(i.id), {
+					state: "erased",
+					input: null,
+					matchId: null
+				})) throw t("unavailable");
+			} else if (o.has(i.id) && !await e.update(c.tableName, String(i.id), { matchId: null })) throw t("unavailable");
+			for (let t of a) await e.delete(u.tableName, String(t.id));
+			for (let t of i) await e.delete(d.tableName, String(t.id));
+		}
+	};
+};
+//#endregion
+export { b as makeRatingStore };

package/dist/ratingStrategies.js

@@ -0,0 +1,108 @@
+import { leaderboardError as e } from "./errors.js";
+import { leaderboardIdentifier as t } from "./leaderboard.js";
+import { canonicalLeaderboardJson as n } from "./json.js";
+import { glicko2 as r } from "./glicko2.js";
+import { openskill as i } from "./openskill.js";
+import { elo as a } from "./rating.js";
+import { exactRatingState as o } from "./ratingPools.js";
+//#region src/ratingStrategies.ts
+var s = (e) => e.pool.initial, c = (e) => e.state, l = (t) => {
+	let { pool: n, teams: s, ranks: c } = t;
+	if (n.algorithm === "elo") return Object.freeze(a(n.options)({
+		teams: s.map((t) => t.map((t) => {
+			if (t.state.algorithm !== "elo") throw e("invalid_record");
+			return {
+				id: t.ownerId,
+				rating: t.state.rating,
+				weight: t.weight
+			};
+		})),
+		ranks: c
+	}).flat().map((e) => Object.freeze({
+		ownerId: e.id,
+		state: o({
+			algorithm: "elo",
+			rating: e.rating
+		}, "elo")
+	})));
+	if (n.algorithm === "openskill") return Object.freeze(i(n.options)({
+		teams: s.map((t) => t.map((t) => {
+			if (t.state.algorithm !== "openskill") throw e("invalid_record");
+			return {
+				id: t.ownerId,
+				mu: t.state.mu,
+				sigma: t.state.sigma,
+				weight: t.weight
+			};
+		})),
+		ranks: c
+	}).flat().map((e) => Object.freeze({
+		ownerId: e.id,
+		state: o({
+			algorithm: "openskill",
+			mu: e.mu,
+			sigma: e.sigma
+		}, "openskill")
+	})));
+	if (s.length !== 2 || s.some((e) => e.length !== 1 || e[0].weight !== 1)) throw e("invalid_input");
+	return Object.freeze(s.map((t, i) => {
+		let a = t[0], l = s[1 - i][0], u = a.state, d = l.state;
+		if (u.algorithm !== "glicko2" || d.algorithm !== "glicko2") throw e("invalid_record");
+		let f = c[i] < c[1 - i] ? 1 : c[i] === c[1 - i] ? .5 : 0, p = r(n.options)({
+			player: u,
+			opponents: [{
+				rating: d.rating,
+				deviation: d.deviation,
+				score: f
+			}]
+		});
+		return Object.freeze({
+			ownerId: a.ownerId,
+			state: o({
+				algorithm: "glicko2",
+				rating: p.rating,
+				deviation: p.deviation,
+				volatility: p.volatility
+			}, "glicko2")
+		});
+	}));
+}, u = "voltro:rating:1", d = (n = {}) => {
+	if (!n || typeof n != "object" || Array.isArray(n)) throw e("invalid_input");
+	let r = n.rate ?? l, i = n.placementPolicy ?? s, a = n.decay ?? c;
+	if (![
+		r,
+		i,
+		a
+	].every((e) => typeof e == "function")) throw e("invalid_input");
+	let o = r !== l || i !== s || a !== c, d = n.version ?? u;
+	if (!t(d) || o && (n.version === void 0 || d.startsWith("voltro:")) || !o && d !== u) throw e("invalid_input");
+	return Object.freeze({
+		version: d,
+		rate: r,
+		placementPolicy: i,
+		decay: a
+	});
+}, f = (t, r) => {
+	let i = r.teams.flat(), a = new Map(i.map((e) => [e.ownerId, e])), s = /* @__PURE__ */ new Map();
+	if (!Array.isArray(t) || t.length !== i.length || a.size !== i.length) throw e("invalid_record");
+	for (let i = 0; i < t.length; i++) {
+		let c = Object.getOwnPropertyDescriptor(t, String(i));
+		if (!c || !("value" in c)) throw e("invalid_record");
+		let l = c.value;
+		if (!l || typeof l != "object" || Array.isArray(l) || Object.keys(l).length !== 2 || !Object.hasOwn(l, "ownerId") || !Object.hasOwn(l, "state")) throw e("invalid_record");
+		let u = Object.getOwnPropertyDescriptor(l, "ownerId"), d = Object.getOwnPropertyDescriptor(l, "state");
+		if (!u || !("value" in u) || !d || !("value" in d) || typeof u.value != "string" || !a.has(u.value) || s.has(u.value)) throw e("invalid_record");
+		let f;
+		try {
+			f = o(d.value, r.pool.algorithm);
+		} catch {
+			throw e("invalid_record");
+		}
+		let p = a.get(u.value);
+		if (p.weight === 0 && n(f) !== n(p.state)) throw e("invalid_record");
+		s.set(u.value, f);
+	}
+	return s;
+};
+//#endregion
+export { f as admitRatingStrategyResults, c as defaultRatingDecay, s as defaultRatingPlacement, l as defaultRatingRate, d as resolveRatingStrategies };

package/dist/records.d.ts

@@ -0,0 +1,116 @@
+import { Schema } from 'effect';
+
+export declare const BOARDS_TABLE = "_voltro_lb_boards";
+
+export declare const BUCKET_ASSIGNMENTS_TABLE = "_voltro_lb_bucket_assignments";
+
+export declare type LeaderboardPeriod = typeof LeaderboardPeriodSchema.Type;
+
+export declare const LeaderboardPeriodSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly board: Schema.String;
+    readonly startsAt: Schema.Number;
+    readonly endsAt: Schema.NullOr<Schema.Number>;
+    readonly state: Schema.Literals<readonly ["active", "closed", "archived"]>;
+    readonly summary: Schema.NullOr<Schema.Struct<{
+        readonly participants: Schema.Number;
+        readonly top: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly tenantId: Schema.String;
+            readonly board: Schema.String;
+            readonly periodId: Schema.String;
+            readonly ownerId: Schema.String;
+            readonly score: Schema.String;
+            readonly subscore: Schema.String;
+            readonly updatedAt: Schema.Number;
+            readonly rank: Schema.Number;
+        }>>;
+    }>>;
+}>;
+
+export declare type LeaderboardRecord = typeof LeaderboardRecordSchema.Type;
+
+export declare const LeaderboardRecordSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly board: Schema.String;
+    readonly periodId: Schema.String;
+    readonly ownerId: Schema.String;
+    readonly score: Schema.String;
+    readonly subscore: Schema.String;
+    readonly numSubmits: Schema.Number;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly updatedAt: Schema.Number;
+    readonly bucket: Schema.NullOr<Schema.String>;
+}>;
+
+export declare type LeaderboardTournamentEntry = typeof LeaderboardTournamentEntrySchema.Type;
+
+export declare const LeaderboardTournamentEntrySchema: Schema.Struct<{
+    readonly tournament: Schema.String;
+    readonly joinedAt: Schema.Number;
+    readonly attemptsLeft: Schema.Number;
+}>;
+
+export declare const LeaderboardTournamentStatusSchema: Schema.Struct<{
+    readonly tournament: Schema.String;
+    readonly board: Schema.String;
+    readonly startsAt: Schema.Number;
+    readonly endsAt: Schema.Number;
+    readonly observedAt: Schema.Number;
+    readonly joinRequired: Schema.Boolean;
+    readonly state: Schema.Literals<readonly ["upcoming", "open", "ended"]>;
+    readonly entry: Schema.NullOr<Schema.Struct<{
+        readonly tournament: Schema.String;
+        readonly joinedAt: Schema.Number;
+        readonly attemptsLeft: Schema.Number;
+    }>>;
+}>;
+
+export declare const MyRatingSchema: Schema.Struct<{
+    readonly pool: Schema.NonEmptyString;
+    readonly state: Schema.Union<readonly [Schema.Struct<{
+        readonly algorithm: Schema.Literal<"elo">;
+        readonly rating: Schema.Number;
+    }>, Schema.Struct<{
+        readonly algorithm: Schema.Literal<"openskill">;
+        readonly mu: Schema.Number;
+        readonly sigma: Schema.Number;
+    }>, Schema.Struct<{
+        readonly algorithm: Schema.Literal<"glicko2">;
+        readonly rating: Schema.Number;
+        readonly deviation: Schema.Number;
+        readonly volatility: Schema.Number;
+    }>]>;
+    readonly games: Schema.Number;
+    readonly updatedAt: Schema.NullOr<Schema.Number>;
+}>;
+
+export declare const PERIODS_TABLE = "_voltro_lb_periods";
+
+export declare const RECORDS_TABLE = "_voltro_lb_records";
+
+export declare const SUBJECTS_TABLE = "_voltro_lb_subject_admission";
+
+export declare const SUBMISSIONS_TABLE = "_voltro_lb_submissions";
+
+/** Trusted service submission, never a player score-intent payload. */
+export declare interface SubmitLeaderboardInput {
+    readonly tenantId: string;
+    readonly board: string;
+    readonly ownerId: string;
+    readonly submissionId: string;
+    readonly score: string;
+    readonly subscore?: string;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly roomId?: string;
+    readonly matchId?: string;
+    readonly tournamentId?: string;
+    readonly bucketSkill?: number;
+    readonly bucketCohort?: string;
+}
+
+export declare const TOURNAMENT_ENTRIES_TABLE = "_voltro_lb_tournament_entries";
+
+export declare const TOURNAMENTS_TABLE = "_voltro_lb_tournaments";
+
+export { }

package/dist/records.js

@@ -0,0 +1,88 @@
+import { scoreString as e } from "./score.js";
+import { RatingStateSchema as t } from "./ratingPools.js";
+import { Schema as n } from "effect";
+//#region src/records.ts
+var r = "_voltro_lb_boards", i = "_voltro_lb_records", a = "_voltro_lb_periods", o = "_voltro_lb_submissions", s = "_voltro_lb_subject_admission", c = "_voltro_lb_tournaments", l = "_voltro_lb_tournament_entries", u = "_voltro_lb_bucket_assignments", d = n.String.pipe(n.check(n.isMaxLength(20)), n.check(n.makeFilter((t) => {
+	try {
+		return e(t) === t;
+	} catch {
+		return !1;
+	}
+}))), f = n.Number.pipe(n.check(n.isInt()), n.check(n.isBetween({
+	minimum: 0,
+	maximum: 864e13
+}))), p = n.Struct({
+	pool: n.NonEmptyString,
+	state: t,
+	games: n.Number.pipe(n.check(n.isInt()), n.check(n.isBetween({
+		minimum: 0,
+		maximum: 2147483647
+	}))),
+	updatedAt: n.NullOr(f)
+}), m = n.Struct({
+	id: n.String,
+	board: n.String,
+	periodId: n.String,
+	ownerId: n.String,
+	score: d,
+	subscore: d,
+	numSubmits: n.Number.pipe(n.check(n.isInt()), n.check(n.isBetween({
+		minimum: 1,
+		maximum: 2147483647
+	}))),
+	metadata: n.Record(n.String, n.Unknown),
+	updatedAt: f,
+	bucket: n.NullOr(n.String.pipe(n.check(n.isMaxLength(64))))
+}), h = n.Struct({
+	id: n.String,
+	tenantId: n.String,
+	board: n.String,
+	periodId: n.String,
+	ownerId: n.String,
+	score: d,
+	subscore: d,
+	updatedAt: f,
+	rank: n.Number.pipe(n.check(n.isInt()), n.check(n.isBetween({
+		minimum: 1,
+		maximum: 1e5
+	})))
+}), g = n.Struct({
+	id: n.String,
+	board: n.String,
+	startsAt: f,
+	endsAt: n.NullOr(f),
+	state: n.Literals([
+		"active",
+		"closed",
+		"archived"
+	]),
+	summary: n.NullOr(n.Struct({
+		participants: n.Number.pipe(n.check(n.isInt()), n.check(n.isBetween({
+			minimum: 0,
+			maximum: 1e5
+		}))),
+		top: n.Array(h).pipe(n.check(n.isMaxLength(1e3)))
+	}))
+}), _ = n.Struct({
+	tournament: n.String,
+	joinedAt: f,
+	attemptsLeft: n.Number.pipe(n.check(n.isInt()), n.check(n.isBetween({
+		minimum: 0,
+		maximum: 2147483647
+	})))
+}), v = n.Struct({
+	tournament: n.String,
+	board: n.String,
+	startsAt: f,
+	endsAt: f,
+	observedAt: f,
+	joinRequired: n.Boolean,
+	state: n.Literals([
+		"upcoming",
+		"open",
+		"ended"
+	]),
+	entry: n.NullOr(_)
+});
+//#endregion
+export { r as BOARDS_TABLE, u as BUCKET_ASSIGNMENTS_TABLE, g as LeaderboardPeriodSchema, m as LeaderboardRecordSchema, _ as LeaderboardTournamentEntrySchema, v as LeaderboardTournamentStatusSchema, p as MyRatingSchema, a as PERIODS_TABLE, i as RECORDS_TABLE, s as SUBJECTS_TABLE, o as SUBMISSIONS_TABLE, c as TOURNAMENTS_TABLE, l as TOURNAMENT_ENTRIES_TABLE };