@voltro/plugin-leaderboards 0.0.0-stage → 0.88.0

package/dist/service.js

@@ -0,0 +1,948 @@
+import { LeaderboardError as e, leaderboardError as t } from "./errors.js";
+import { defineLeaderboard as n, leaderboardIdentifier as r } from "./leaderboard.js";
+import { defineLeague as i, leagueMovements as a } from "./leagues.js";
+import { canonicalLeaderboardJson as o, captureLeaderboardJson as s } from "./json.js";
+import { applyScore as c, scoreString as l, scoreValue as u } from "./score.js";
+import { resolveRatingPools as d } from "./ratingPools.js";
+import { LeaderboardPeriodSchema as f, LeaderboardRecordSchema as p, LeaderboardTournamentEntrySchema as m, LeaderboardTournamentStatusSchema as h } from "./records.js";
+import { defineTournament as g } from "./tournaments.js";
+import { resolveRatingStrategies as _ } from "./ratingStrategies.js";
+import { leaderboardBoardsTable as v, leaderboardBucketAssignmentsTable as y, leaderboardLeagueMembersTable as b, leaderboardLeagueRollsTable as x, leaderboardPeriodsTable as S, leaderboardRecordsTable as C, leaderboardSubjectsTable as w, leaderboardSubmissionsTable as T, leaderboardTournamentEntriesTable as E, leaderboardTournamentsTable as D } from "./tables.entity.js";
+import { makeRatingStore as ee } from "./ratingStore.js";
+import { defaultLeaderboardTiebreak as te, defaultPeriodSummary as ne, leaderboardAround as re, rankLeaderboardRecords as ie } from "./ranking.js";
+import { defaultLeaderboardBucketAssign as O } from "./buckets.js";
+import { makeBucketStore as ae } from "./bucketStore.js";
+import { makeLeaderboardSubjectFences as oe } from "./subjectFences.js";
+import { admitLeaderboardRankOrder as se, defaultLeaderboardRankQuery as ce } from "./rankQuery.js";
+import { Cron as le, Effect as k, Result as ue, Schema as A } from "effect";
+import { createHash as de } from "node:crypto";
+import { and as j, eq as M, gt as fe, queryFor as N } from "@voltro/database";
+// src/service.ts
+var pe = () => k.void, P = (n) => n instanceof e ? n : t("unavailable"), F = (e) => k.tryPromise({
+	try: e,
+	catch: P
+}), I = (e) => de("sha256").update(o(e)).digest("hex"), L = (e, t) => e + I(t).slice(0, 56), R = (e) => {
+	let n = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : typeof e == "number" ? e : NaN;
+	if (!Number.isSafeInteger(n) || n < 0) throw t("unavailable");
+	return n;
+}, z = (e) => A.decodeUnknownSync(p)(structuredClone({
+	id: e.id,
+	board: e.board,
+	periodId: e.periodId,
+	ownerId: e.ownerId,
+	score: l(e.score),
+	subscore: l(e.subscore),
+	numSubmits: e.numSubmits,
+	metadata: e.metadata,
+	updatedAt: R(e.updatedAt),
+	bucket: e.bucket
+})), me = (e, n) => {
+	if (e.reset === void 0) return null;
+	let r = le.parse(e.reset.cron, e.reset.timezone);
+	if (ue.isFailure(r)) throw t("invalid_board");
+	let i = le.next(r.success, new Date(n)), a = i.getTime();
+	if (!Number.isSafeInteger(a) || a <= n || a > 864e13) throw t("unavailable");
+	return i;
+}, he = (e) => {
+	if (!e || !Array.isArray(e.boards) || e.boards.length > 256) throw t("invalid_board");
+	let a = Array.from(e.boards, (e) => {
+		if (!e || typeof e != "object") throw t("invalid_board");
+		return n({
+			name: e.name,
+			sort: e.sort,
+			operator: e.operator,
+			metadata: e.metadata,
+			maxRankRecords: e.maxRankRecords,
+			maxPageSize: e.maxPageSize,
+			submit: e.submit,
+			...e.reset === void 0 ? {} : { reset: e.reset },
+			...e.buckets === void 0 ? {} : { buckets: e.buckets }
+		});
+	});
+	if (new Set(a.map((e) => e.name)).size !== e.boards.length) throw t("invalid_board");
+	if (e.tournaments !== void 0 && (!Array.isArray(e.tournaments) || e.tournaments.length > 256)) throw t("invalid_input");
+	let o = Array.from(e.tournaments ?? [], (e) => {
+		if (!e || e.kind !== "tournament" || e.format !== "time-window") throw t("invalid_input");
+		return g(e);
+	});
+	if (new Set(o.map((e) => e.name)).size !== o.length || new Set(o.map((e) => e.board)).size !== o.length || o.some((e) => !a.some((t) => t.name === e.board))) throw t("invalid_input");
+	for (let e of o) {
+		let n = me(a.find((t) => t.name === e.board), e.startsAt);
+		if (n !== null && e.endsAt > n.getTime()) throw t("invalid_input");
+	}
+	if (e.leagues !== void 0 && (!Array.isArray(e.leagues) || e.leagues.length > 64)) throw t("invalid_input");
+	let c = Array.from(e.leagues ?? [], (e) => i(e)), l = c.flatMap((e) => e.divisions);
+	if (new Set(c.map((e) => e.name)).size !== c.length || new Set(l).size !== l.length || l.some((e) => {
+		let t = a.find((t) => t.name === e);
+		return !t || t.buckets !== void 0;
+	}) || e.allowedServices !== void 0 && (!Array.isArray(e.allowedServices) || e.allowedServices.length > 256)) throw t("invalid_input");
+	let u = s(e.ratingPools ?? [], 65536);
+	d(u);
+	let f = _(e.ratingStrategies), p = new Set(e.allowedServices ?? []);
+	if (p.size > 256 || [...p].some((e) => !r(e))) throw t("invalid_input");
+	let m = e.validate ?? pe, h = e.now ?? Date.now, v = e.tiebreak, y = e.rankQuery ?? ce, b = e.bucketAssign ?? O, x = e.periodSummary ?? ne, S = e.maxPeriodRows ?? 1e4, C = e.maxSummaryBytes ?? 16384, w = e.maxMetadataBytes ?? 16384, T = e.maxExportRows ?? 1e4, E = e.maxSubmissionsPerOwner ?? 1e4, D = e.bucketStrategyVersion ?? "voltro:bucket:1";
+	if (!r(D) || b !== O && (e.bucketStrategyVersion === void 0 || D.startsWith("voltro:")) || b === O && D !== "voltro:bucket:1" || typeof m != "function" || typeof h != "function" || typeof y != "function" || typeof b != "function" || v !== void 0 && typeof v != "function" || !Number.isSafeInteger(w) || w < 1 || w > 65536 || !Number.isSafeInteger(T) || T < 1 || T > 1e5 || !Number.isSafeInteger(E) || E < 1 || E > T || typeof x != "function" || !Number.isSafeInteger(S) || S < 1 || S > 1e5 || !Number.isSafeInteger(C) || C < 1 || C > 65536) throw t("invalid_input");
+	return Object.freeze({
+		boards: Object.freeze(a),
+		tournaments: Object.freeze(o),
+		leagues: Object.freeze(c),
+		ratingPools: u,
+		ratingStrategies: f,
+		allowedServices: Object.freeze([...p]),
+		validate: m,
+		now: h,
+		maxMetadataBytes: w,
+		maxExportRows: T,
+		maxSubmissionsPerOwner: E,
+		periodSummary: x,
+		maxPeriodRows: S,
+		maxSummaryBytes: C,
+		rankQuery: y,
+		bucketAssign: b,
+		bucketStrategyVersion: D,
+		...v === void 0 ? {} : { tiebreak: v }
+	});
+}, ge = (n, i) => {
+	let g = he(i), ne = new Map(g.boards.map((e) => [e.name, e])), O = new Map(g.tournaments.map((e) => [e.name, e])), ce = new Map(g.tournaments.map((e) => [e.board, e])), le = new Set(g.allowedServices), de = g.validate, pe = g.now, ge = g.tiebreak, _e = g.maxMetadataBytes, B = g.maxExportRows, ve = g.maxSubmissionsPerOwner, ye = g.maxPeriodRows, be = g.maxSummaryBytes, xe = g.periodSummary, Se = g.rankQuery, V = () => {
+		let e = pe();
+		if (!Number.isSafeInteger(e) || e < 0 || e > 864e13) throw t("unavailable");
+		return e;
+	}, H = (e) => {
+		let n = ne.get(e);
+		if (!n) throw t("not_found");
+		return n;
+	}, U = (e) => e?.type === "system" || e?.type === "service" && le.has(e.service), W = (e) => {
+		if (!e || e.type !== "user" || !r(e.id) || !r(e.tenantId)) throw t("forbidden");
+		return e.tenantId;
+	}, { seedSubject: G, subjectFence: K } = oe(n), q = ee(n, d(g.ratingPools), {
+		seedSubject: G,
+		subjectFence: K,
+		machine: U,
+		now: V,
+		key: L,
+		hash: I,
+		maxRows: B,
+		strategies: _(g.ratingStrategies)
+	}), Ce = ae({
+		key: L,
+		hash: I,
+		assign: g.bucketAssign
+	}), J = (e) => ({
+		sort: e.sort,
+		operator: e.operator,
+		reset: e.reset ?? null,
+		buckets: e.buckets ?? null,
+		bucketStrategyVersion: e.buckets === void 0 ? null : g.bucketStrategyVersion,
+		tournament: ce.get(e.name) ?? null
+	}), Y = async (e, t) => {
+		let r = L("lbb_", [e, t.name]), i = L("lbp_", [
+			e,
+			t.name,
+			"initial"
+		]), a = J(t);
+		try {
+			await n.insertIgnore(v.tableName, {
+				id: r,
+				tenantId: e,
+				name: t.name,
+				periodId: i,
+				config: a,
+				admission: 0,
+				updatedAt: new Date(V())
+			}, { conflictColumns: ["id"] });
+		} catch (e) {
+			if (!(await n.query(N(v).where(M("id", r)).limit(1).descriptor))[0]) throw e;
+		}
+	}, we = async (e, n, r) => {
+		let i = L("lbb_", [n, r.name]);
+		if (await e.updateMany(v.tableName, { admission: 0 }, { where: M("id", i) }) !== 1) throw t("unavailable");
+		let a = (await e.query(N(v).where(M("id", i)).limit(1).descriptor))[0];
+		if (!a || a.tenantId !== n || a.name !== r.name || o(a.config) !== o(J(r))) throw t("conflict");
+		return a;
+	}, X = async (e, n, r, i) => {
+		let a = await e.query(N(n).where(j(M("tenantId", r), M("ownerId", i))).orderBy("id", "asc").limit(B + 1).descriptor);
+		if (a.length > B) throw t("limit_exceeded");
+		if (a.some((e) => e.tenantId !== r || e.ownerId !== i)) throw t("unavailable");
+		return a;
+	}, Z = async (e, r, i = n, a, s) => {
+		let c = (await i.query(N(v).where(M("id", L("lbb_", [e, r.name]))).limit(1).descriptor))[0];
+		if (!c) return [];
+		if (c.tenantId !== e || c.name !== r.name || typeof c.periodId != "string") throw t("unavailable");
+		if (o(c.config) !== o(J(r))) throw t("conflict");
+		let l = await i.query(N(C).where(j(M("tenantId", e), M("board", r.name), M("periodId", a ?? c.periodId), ...s === void 0 ? [] : [M("bucket", s)])).limit(r.maxRankRecords + 1).descriptor);
+		if (l.length > r.maxRankRecords) throw t("limit_exceeded");
+		let u = l.map((n) => {
+			if (n.tenantId !== e || n.board !== r.name || n.periodId !== (a ?? c.periodId) || s !== void 0 && n.bucket !== s) throw t("unavailable");
+			return {
+				...z(n),
+				tenantId: e
+			};
+		}), d = new Map(u.map((e) => [e.id, e])), f = Object.freeze(u.map((t) => Object.freeze({
+			id: t.id,
+			tenantId: e,
+			board: t.board,
+			periodId: t.periodId,
+			ownerId: t.ownerId,
+			score: t.score,
+			subscore: t.subscore,
+			updatedAt: t.updatedAt
+		}))), p = Object.freeze({
+			tenantId: e,
+			board: r.name,
+			periodId: a ?? c.periodId,
+			sort: r.sort,
+			maxRecords: r.maxRankRecords,
+			records: f,
+			bucketId: s ?? null,
+			tiebreak: ge ?? te,
+			query: i.query.bind(i)
+		}), m = await k.runPromise(k.result(k.suspend(() => Se(p))));
+		if (ue.isFailure(m)) throw m.failure;
+		return se(m.success, f).map((e, t) => {
+			let n = d.get(e);
+			return {
+				...z({
+					...n,
+					updatedAt: new Date(n.updatedAt)
+				}),
+				rank: t + 1
+			};
+		});
+	}, Te = async (e, r, i) => {
+		if (i.buckets === void 0) return Z(e, i);
+		let a = (await n.query(N(v).where(M("id", L("lbb_", [e, i.name]))).limit(1).descriptor))[0];
+		if (!a) return [];
+		if (a.tenantId !== e || a.name !== i.name || typeof a.periodId != "string") throw t("unavailable");
+		if (o(a.config) !== o(J(i))) throw t("conflict");
+		let s = await Ce.readOwn(n, e, i.name, a.periodId, r);
+		return s ? Z(e, i, n, a.periodId, String(s.bucket)) : [];
+	}, Q = async (e, n, r) => {
+		let i = await e.query(N(S).where(r === void 0 ? M("tenantId", n) : j(M("tenantId", n), M("board", r))).orderBy("startsAt", "desc").orderBy("id", "asc").limit(ye + 1).descriptor);
+		if (i.length > ye) throw t("limit_exceeded");
+		if (i.some((e) => e.tenantId !== n || r !== void 0 && e.board !== r)) throw t("unavailable");
+		return i;
+	}, $ = (e, n, r, i) => {
+		let a = s(e, be);
+		if (!a || typeof a != "object" || Array.isArray(a)) throw t("unavailable");
+		let c = a;
+		if (Object.keys(c).length !== 2 || !Number.isSafeInteger(c.participants) || Number(c.participants) < 0 || Number(c.participants) > 1e5 || !Array.isArray(c.top) || c.top.length > 1e3 || c.top.length > Number(c.participants)) throw t("unavailable");
+		let l = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set();
+		for (let e of c.top) {
+			let a = ie([e], { maxRecords: 1 })[0];
+			if (n !== void 0 && a.tenantId !== n || r !== void 0 && a.board !== r || i !== void 0 && a.periodId !== i || !Number.isSafeInteger(e.rank) || e.rank < 1 || e.rank > Number(c.participants) || l.has(a.ownerId) || u.has(a.id) || d.has(e.rank) || o(e) !== o({
+				...a,
+				rank: e.rank
+			})) throw t("unavailable");
+			l.add(a.ownerId), u.add(a.id), d.add(e.rank);
+		}
+		return a;
+	}, Ee = (e) => {
+		let n = Object.freeze(e.map((e) => Object.freeze({ ...e }))), r = new Map(n.map((e) => [e.id, e])), i;
+		try {
+			i = $(xe(n));
+		} catch (e) {
+			throw P(e);
+		}
+		if (i.participants !== e.length || i.top.some((e) => o(e) !== o(r.get(e.id)))) throw t("invalid_record");
+		return i;
+	}, De = async (e, n) => {
+		let r = await e.query(N(v).where(M("tenantId", n)).orderBy("id", "asc").limit(B + 1).descriptor);
+		if (r.length > B) throw t("limit_exceeded");
+		for (let i of r) if (i.tenantId !== n || await e.updateMany(v.tableName, { admission: 0 }, { where: j(M("id", String(i.id)), M("tenantId", n)) }) !== 1) throw t("unavailable");
+	}, Oe = (e, t) => A.decodeUnknownSync(m)({
+		tournament: t,
+		joinedAt: R(e.joinedAt),
+		attemptsLeft: e.attemptsLeft
+	}), ke = async (e, n, r, i, a = !1) => {
+		let s = L("lbt_", [n, r.name]);
+		if (!(await e.query(N(D).where(M("id", s)).limit(1).descriptor))[0]) {
+			let o = V();
+			if (o < r.startsAt || o >= r.endsAt && !a) throw t("forbidden");
+			if ((await e.query(N(C).where(j(M("tenantId", n), M("board", r.board), M("periodId", String(i.periodId)))).limit(1).descriptor)).length > 0) throw t("conflict");
+			await e.insertIgnore(S.tableName, {
+				id: String(i.periodId),
+				tenantId: n,
+				board: r.board,
+				startsAt: new Date(r.startsAt),
+				endsAt: me(H(r.board), r.startsAt),
+				state: "active",
+				summary: {},
+				previousPeriodId: null,
+				requestKey: null
+			}, { conflictColumns: ["id"] }), await e.insert(D.tableName, {
+				id: s,
+				tenantId: n,
+				name: r.name,
+				board: r.board,
+				periodId: String(i.periodId),
+				config: r,
+				admission: 0,
+				numEntries: 0
+			});
+		}
+		if (await e.updateMany(D.tableName, { admission: 0 }, { where: M("id", s) }) !== 1) throw t("unavailable");
+		let c = (await e.query(N(D).where(M("id", s)).limit(1).descriptor))[0];
+		if (!c || c.tenantId !== n || c.name !== r.name || c.board !== r.board || o(c.config) !== o(r) || !Number.isSafeInteger(c.numEntries) || Number(c.numEntries) < 0 || Number(c.numEntries) > r.maxEntries) throw t("conflict");
+		return c;
+	}, Ae = async (e, n, r, i) => {
+		let a = (await e.query(N(E).where(M("id", L("lbe_", [
+			n,
+			String(i.id),
+			r
+		]))).limit(1).descriptor))[0];
+		if (a && (a.tenantId !== n || a.ownerId !== r || a.tournamentId !== i.id)) throw t("unavailable");
+		return a;
+	}, je = (e, n, r, i) => {
+		if (i < e.startsAt || i >= e.endsAt || n.periodId !== r.periodId) throw t("forbidden");
+	}, Me = async (e, n, r, i, a, o) => {
+		if (Number(a.numEntries) >= i.maxEntries) throw t("limit_exceeded");
+		let s = await e.insert(E.tableName, {
+			id: L("lbe_", [
+				n,
+				String(a.id),
+				r
+			]),
+			tenantId: n,
+			tournamentId: String(a.id),
+			ownerId: r,
+			joinedAt: new Date(o),
+			attemptsLeft: i.attemptsPerEntry
+		});
+		if (!s || !await e.update(D.tableName, String(a.id), { numEntries: Number(a.numEntries) + 1 })) throw t("unavailable");
+		return s;
+	}, Ne = async (e, n) => {
+		let r = await e.query(N(D).where(M("tenantId", n)).orderBy("id", "asc").limit(B + 1).descriptor);
+		if (r.length > B) throw t("limit_exceeded");
+		for (let i of r) if (i.tenantId !== n || await e.updateMany(D.tableName, { admission: 0 }, { where: j(M("id", String(i.id)), M("tenantId", n)) }) !== 1) throw t("unavailable");
+		let i = [];
+		for (let a of r) {
+			let r = (await e.query(N(D).where(M("id", String(a.id))).limit(1).descriptor))[0];
+			if (!r || r.tenantId !== n) throw t("unavailable");
+			i.push(r);
+		}
+		return i;
+	}, Pe = (e, i) => {
+		let a, o;
+		try {
+			if (!U(e)) throw t("forbidden");
+			if (!i || ![
+				i.tenantId,
+				i.board,
+				i.requestId,
+				i.expectedPeriodId
+			].every(r) || !Number.isSafeInteger(i.closedAt) || i.closedAt < 0 || i.closedAt > V()) throw t("invalid_input");
+			o = H(i.board), a = Object.freeze({
+				tenantId: i.tenantId,
+				board: i.board,
+				requestId: i.requestId,
+				expectedPeriodId: i.expectedPeriodId,
+				closedAt: i.closedAt
+			});
+		} catch (e) {
+			return k.fail(P(e));
+		}
+		return F(async () => (await Y(a.tenantId, o), n.transactional(async (e) => {
+			let n = await we(e, a.tenantId, o), r = L("lbp_", [
+				a.tenantId,
+				a.board,
+				a.requestId
+			]), i = I(a);
+			if (r === a.expectedPeriodId) throw t("conflict");
+			let s = (await e.query(N(S).where(M("id", r)).limit(1).descriptor))[0];
+			if (s) {
+				if (s.tenantId !== a.tenantId || s.board !== a.board || s.requestKey !== i || s.previousPeriodId !== a.expectedPeriodId || R(s.startsAt) !== a.closedAt) throw t("conflict");
+				let n = (await e.query(N(S).where(M("id", a.expectedPeriodId)).limit(1).descriptor))[0];
+				if (!n || n.tenantId !== a.tenantId || n.board !== a.board || R(n.endsAt) !== a.closedAt || !["closed", "archived"].includes(String(n.state))) throw t("unavailable");
+				return {
+					closedPeriodId: a.expectedPeriodId,
+					activePeriodId: r,
+					closedAt: a.closedAt,
+					summary: $(n.summary, a.tenantId, a.board, a.expectedPeriodId)
+				};
+			}
+			if (n.periodId !== a.expectedPeriodId) throw t("conflict");
+			let c = await Q(e, a.tenantId, a.board);
+			if (c.length >= ye) throw t("limit_exceeded");
+			let l = c.find((e) => e.id === a.expectedPeriodId);
+			if (!l || l.state !== "active" || R(l.startsAt) > a.closedAt || l.endsAt !== null && R(l.endsAt) < a.closedAt) throw t("conflict");
+			let u = (await Z(a.tenantId, o, e, a.expectedPeriodId)).map((e) => ({
+				id: e.id,
+				tenantId: a.tenantId,
+				board: e.board,
+				periodId: e.periodId,
+				ownerId: e.ownerId,
+				score: e.score,
+				subscore: e.subscore,
+				updatedAt: e.updatedAt,
+				rank: e.rank
+			}));
+			if (u.some((e) => e.updatedAt > a.closedAt)) throw t("conflict");
+			let d = Ee(u);
+			if (!await e.update(S.tableName, a.expectedPeriodId, {
+				endsAt: new Date(a.closedAt),
+				state: "closed",
+				summary: d
+			}) || (await e.insert(S.tableName, {
+				id: r,
+				tenantId: a.tenantId,
+				board: a.board,
+				startsAt: new Date(a.closedAt),
+				endsAt: me(o, a.closedAt),
+				state: "active",
+				summary: {},
+				previousPeriodId: a.expectedPeriodId,
+				requestKey: i
+			}), !await e.update(v.tableName, String(n.id), {
+				periodId: r,
+				updatedAt: new Date(a.closedAt)
+			}))) throw t("unavailable");
+			if (o.reset !== void 0) {
+				let n = (await Q(e, a.tenantId, a.board)).filter((e) => e.state === "closed");
+				for (let r of n.slice(o.reset.keepHistory)) if (!await e.update(S.tableName, String(r.id), { state: "archived" })) throw t("unavailable");
+			}
+			return {
+				closedPeriodId: a.expectedPeriodId,
+				activePeriodId: r,
+				closedAt: a.closedAt,
+				summary: d
+			};
+		})));
+	}, Fe = new Map((g.leagues ?? []).map((e) => [e.name, e])), Ie = (e) => {
+		let n = typeof e == "string" ? Fe.get(e) : void 0;
+		if (!n) throw t("not_found");
+		return n;
+	}, Le = (e, t, n) => L("lblm_", [
+		e,
+		t,
+		n
+	]);
+	return {
+		assignLeague: (e, i) => {
+			let a;
+			try {
+				if (!U(e)) throw t("forbidden");
+				if (!i || ![i.tenantId, i.ownerId].every(r) || !Ie(i.league).divisions.includes(i.division)) throw t("invalid_input");
+				a = Object.freeze({
+					tenantId: i.tenantId,
+					league: i.league,
+					ownerId: i.ownerId,
+					division: i.division
+				});
+			} catch (e) {
+				return k.fail(P(e));
+			}
+			return F(async () => (await G(a.tenantId, a.ownerId), n.transactional(async (e) => {
+				await K(e, a.tenantId, a.ownerId);
+				let t = Le(a.tenantId, a.league, a.ownerId), n = new Date(V());
+				return await e.insertIgnore(b.tableName, {
+					id: t,
+					tenantId: a.tenantId,
+					league: a.league,
+					ownerId: a.ownerId,
+					division: a.division,
+					updatedAt: n
+				}, { conflictColumns: ["id"] }), await e.update(b.tableName, t, {
+					division: a.division,
+					updatedAt: n
+				}), {
+					league: a.league,
+					division: a.division
+				};
+			})));
+		},
+		myLeague: (e, i) => {
+			let a, o, s;
+			try {
+				if (s = Ie(i), a = W(e), typeof e.id != "string" || !r(e.id)) throw t("forbidden");
+				o = e.id;
+			} catch (e) {
+				return k.fail(P(e));
+			}
+			return F(async () => {
+				let e = (await n.query(N(b).where(M("id", Le(a, s.name, o))).limit(1).descriptor))[0];
+				if (e && (e.tenantId !== a || e.ownerId !== o || !s.divisions.includes(String(e.division)))) throw t("unavailable");
+				return e ? {
+					league: s.name,
+					division: String(e.division),
+					assigned: !0
+				} : {
+					league: s.name,
+					division: s.divisions.at(-1),
+					assigned: !1
+				};
+			});
+		},
+		rollLeague: (e, i) => {
+			let o, s;
+			try {
+				if (!U(e)) throw t("forbidden");
+				if (!i || ![i.tenantId, i.requestId].every(r)) throw t("invalid_input");
+				s = Ie(i.league), o = Object.freeze({
+					tenantId: i.tenantId,
+					league: i.league,
+					requestId: i.requestId,
+					closedAt: i.closedAt
+				});
+			} catch (e) {
+				return k.fail(P(e));
+			}
+			return k.gen(function* () {
+				let r = [];
+				for (let t of s.divisions) {
+					let i = H(t), a = o.requestId + ":" + t, s = L("lbp_", [
+						o.tenantId,
+						t,
+						a
+					]), c = yield* F(async () => (await Y(o.tenantId, i), (await n.query(N(S).where(M("id", s)).limit(1).descriptor))[0])), l = c ? String(c.previousPeriodId) : yield* F(async () => {
+						let e = String((await n.query(N(v).where(M("id", L("lbb_", [o.tenantId, t]))).limit(1).descriptor))[0]?.periodId ?? ""), r = Math.min(V(), o.closedAt);
+						return await n.insertIgnore(S.tableName, {
+							id: e,
+							tenantId: o.tenantId,
+							board: t,
+							startsAt: new Date(r),
+							endsAt: me(i, r),
+							state: "active",
+							summary: {},
+							previousPeriodId: null,
+							requestKey: null
+						}, { conflictColumns: ["id"] }), e;
+					}), u = yield* Pe(e, {
+						tenantId: o.tenantId,
+						board: t,
+						requestId: a,
+						expectedPeriodId: l,
+						closedAt: o.closedAt
+					});
+					r.push({
+						division: t,
+						closedPeriodId: u.closedPeriodId,
+						activePeriodId: u.activePeriodId
+					});
+				}
+				return yield* F(async () => n.transactional(async (e) => {
+					let n = L("lblr_", [
+						o.tenantId,
+						s.name,
+						o.requestId
+					]), i = (await e.query(N(x).where(M("id", n)).forUpdate().limit(1).descriptor))[0];
+					if (i) {
+						if (i.tenantId !== o.tenantId || i.league !== s.name || !Array.isArray(i.movements)) throw t("unavailable");
+						return {
+							divisions: Object.freeze(r),
+							movements: Object.freeze(i.movements)
+						};
+					}
+					let c = [];
+					for (let n of r) {
+						let r = await e.query(N(b).where(j(M("tenantId", o.tenantId), M("league", s.name), M("division", n.division))).limit((g.maxExportRows ?? 1e4) + 1).descriptor);
+						if (r.length > (g.maxExportRows ?? 1e4)) throw t("limit_exceeded");
+						let i = await Z(o.tenantId, H(n.division), e, n.closedPeriodId), a = new Map(i.map((e) => [e.ownerId, e.rank])), l = r.map((e) => String(e.ownerId)).sort((e, t) => (a.get(e) ?? 2 ** 53 - 1) - (a.get(t) ?? 2 ** 53 - 1) || (e < t ? -1 : +(e > t)));
+						c.push({
+							division: n.division,
+							owners: l
+						});
+					}
+					let l = a(s, c), u = new Date(o.closedAt);
+					for (let n of l) if (await e.updateMany(b.tableName, {
+						division: n.to,
+						updatedAt: u
+					}, { where: j(M("id", Le(o.tenantId, s.name, n.ownerId)), M("division", n.from)) }) !== 1) throw t("conflict");
+					return await e.insert(x.tableName, {
+						id: n,
+						tenantId: o.tenantId,
+						league: s.name,
+						movements: l,
+						at: u
+					}), {
+						divisions: Object.freeze(r),
+						movements: l
+					};
+				}));
+			});
+		},
+		leagueTenants: (e, i) => {
+			let a, o, s;
+			try {
+				if (!U(e)) throw t("forbidden");
+				if (!i || !Number.isSafeInteger(i.limit) || i.limit < 1 || i.limit > 1e3 || i.after != null && !r(i.after)) throw t("invalid_input");
+				a = Ie(i.league), o = i.after ?? null, s = i.limit;
+			} catch (e) {
+				return k.fail(P(e));
+			}
+			return F(async () => {
+				let e = [], t = o;
+				for (; e.length <= s;) {
+					let r = (await n.query(N(b).where(t === null ? M("league", a.name) : j(M("league", a.name), fe("tenantId", t))).orderBy("tenantId", "asc").limit(1).descriptor))[0];
+					if (!r) break;
+					t = String(r.tenantId), e.push(t);
+				}
+				return {
+					tenants: Object.freeze(e.slice(0, s)),
+					next: e.length > s ? e[s - 1] : null
+				};
+			});
+		},
+		prepareRatingMatch: q.prepareRatingMatch,
+		applyRatingMatch: q.applyRatingMatch,
+		myRating: q.myRating,
+		pendingRatingMatches: q.pendingRatingMatches,
+		closeTournament: (e, i) => {
+			let a, o, s;
+			try {
+				if (!U(e)) throw t("forbidden");
+				if (!i || ![
+					i.tenantId,
+					i.tournament,
+					i.requestId
+				].every(r)) throw t("invalid_input");
+				let n = O.get(i.tournament);
+				if (!n) throw t("not_found");
+				if (o = n, V() < n.endsAt) throw t("forbidden");
+				s = structuredClone(e), a = Object.freeze({
+					tenantId: i.tenantId,
+					tournament: i.tournament,
+					requestId: i.requestId
+				});
+			} catch (e) {
+				return k.fail(P(e));
+			}
+			return F(async () => {
+				let e = H(o.board);
+				await Y(a.tenantId, e);
+				let r = await n.transactional(async (n) => {
+					if (V() < o.endsAt) throw t("forbidden");
+					let r = await we(n, a.tenantId, e), i = await ke(n, a.tenantId, o, r, !0);
+					return String(i.periodId);
+				}), i = await k.runPromise(k.result(Pe(s, {
+					tenantId: a.tenantId,
+					board: o.board,
+					requestId: "ltc_" + I([
+						a.tenantId,
+						a.tournament,
+						a.requestId
+					]),
+					expectedPeriodId: r,
+					closedAt: o.endsAt
+				})));
+				if (ue.isFailure(i)) throw i.failure;
+				return i.success;
+			});
+		},
+		joinTournament: (e, r) => {
+			let i, a, o, s;
+			try {
+				i = W(e), a = e.id;
+				let n = O.get(r);
+				if (!n) throw t("not_found");
+				o = n, s = H(n.board);
+			} catch (e) {
+				return k.fail(P(e));
+			}
+			return F(async () => (await G(i, a), await Y(i, s), n.transactional(async (e) => {
+				await K(e, i, a);
+				let t = await we(e, i, s), n = await ke(e, i, o, t), r = await Ae(e, i, a, n);
+				if (r) return Oe(r, o.name);
+				let c = V();
+				return je(o, n, t, c), Oe(await Me(e, i, a, o, n, c), o.name);
+			})));
+		},
+		tournamentStatus: (e, r) => {
+			let i, a, s;
+			try {
+				i = W(e), a = e.id;
+				let n = O.get(r);
+				if (!n) throw t("not_found");
+				s = n;
+			} catch (e) {
+				return k.fail(P(e));
+			}
+			return F(async () => {
+				let e = (await n.query(N(D).where(M("id", L("lbt_", [i, s.name]))).limit(1).descriptor))[0];
+				if (e && (e.tenantId !== i || e.name !== s.name || o(e.config) !== o(s))) throw t("conflict");
+				let r = (await n.query(N(v).where(M("id", L("lbb_", [i, s.board]))).limit(1).descriptor))[0];
+				if (r && (r.tenantId !== i || r.name !== s.board)) throw t("unavailable");
+				if (r && o(r.config) !== o(J(H(s.board)))) throw t("conflict");
+				let c = e === void 0 ? void 0 : await Ae(n, i, a, e), l = V();
+				return A.decodeUnknownSync(h)({
+					tournament: s.name,
+					board: s.board,
+					startsAt: s.startsAt,
+					endsAt: s.endsAt,
+					observedAt: l,
+					joinRequired: s.joinRequired,
+					state: l < s.startsAt ? "upcoming" : l >= s.endsAt || e && e.periodId !== r?.periodId ? "ended" : "open",
+					entry: c === void 0 ? null : Oe(c, s.name)
+				});
+			});
+		},
+		rollPeriod: Pe,
+		history: (e, r, i = 12) => {
+			let a, o;
+			try {
+				if (a = W(e), o = H(r), !Number.isSafeInteger(i) || i < 1 || i > ye) throw t("invalid_input");
+			} catch (e) {
+				return k.fail(P(e));
+			}
+			return F(async () => (await Q(n, a, o.name)).slice(0, i).map((e) => A.decodeUnknownSync(f)({
+				id: String(e.id),
+				board: String(e.board),
+				startsAt: R(e.startsAt),
+				endsAt: e.endsAt === null ? null : R(e.endsAt),
+				state: String(e.state),
+				summary: e.state === "active" ? null : $(e.summary, a, o.name, String(e.id))
+			})));
+		},
+		submit: (i, a) => {
+			let d, f;
+			try {
+				if (!U(i)) throw t("forbidden");
+				if (!a || ![
+					a.tenantId,
+					a.board,
+					a.ownerId,
+					a.submissionId
+				].every(r) || a.roomId !== void 0 && !r(a.roomId) || a.matchId !== void 0 && !r(a.matchId) || a.tournamentId !== void 0 && !r(a.tournamentId) || (f = H(a.board), a.bucketSkill !== void 0 && (!Number.isFinite(a.bucketSkill) || Math.abs(a.bucketSkill) > 1e9) || a.bucketCohort !== void 0 && !r(a.bucketCohort) || f.buckets?.assign === "skill" && a.bucketSkill === void 0 || f.buckets?.assign === "cohort" && a.bucketCohort === void 0 || f.buckets?.assign !== "skill" && a.bucketSkill !== void 0 || f.buckets?.assign !== "cohort" && a.bucketCohort !== void 0)) throw t("invalid_input");
+				let e = ce.get(a.board);
+				if (e === void 0 ? a.tournamentId !== void 0 : a.tournamentId !== e.name) throw t("invalid_input");
+				let n = s(a.metadata, _e);
+				if (!n || typeof n != "object" || Array.isArray(n)) throw t("invalid_input");
+				let c = A.decodeUnknownSync(f.metadata, { onExcessProperty: "error" })(n);
+				if (o(n) !== o(c)) throw t("invalid_input");
+				d = Object.freeze({
+					tenantId: a.tenantId,
+					board: a.board,
+					ownerId: a.ownerId,
+					submissionId: a.submissionId,
+					score: l(a.score),
+					subscore: l(a.subscore ?? "0"),
+					metadata: n,
+					...a.roomId === void 0 ? {} : { roomId: a.roomId },
+					...a.matchId === void 0 ? {} : { matchId: a.matchId },
+					...a.tournamentId === void 0 ? {} : { tournamentId: a.tournamentId },
+					...a.bucketSkill === void 0 ? {} : { bucketSkill: a.bucketSkill },
+					...a.bucketCohort === void 0 ? {} : { bucketCohort: a.bucketCohort }
+				});
+			} catch (n) {
+				return k.fail(n instanceof e ? n : t("invalid_input"));
+			}
+			return F(async () => (await G(d.tenantId, d.ownerId), await Y(d.tenantId, f), n.transactional(async (e) => {
+				await K(e, d.tenantId, d.ownerId);
+				let n = await we(e, d.tenantId, f), r = L("lbs_", [
+					d.tenantId,
+					d.board,
+					d.ownerId,
+					d.submissionId
+				]), i = I(d), a = (await e.query(N(T).where(M("id", r)).limit(1).descriptor))[0];
+				if (a) {
+					if (a.tenantId !== d.tenantId || a.ownerId !== d.ownerId || a.board !== d.board || a.requestKey !== i) throw t("conflict");
+					return A.decodeUnknownSync(p)(structuredClone(a.record));
+				}
+				if ((await X(e, T, d.tenantId, d.ownerId)).length >= ve) throw t("limit_exceeded");
+				let o = String(n.periodId), s = L("lbr_", [
+					d.tenantId,
+					d.board,
+					o,
+					d.ownerId
+				]), l = V(), m = ce.get(d.board), h;
+				if (m !== void 0) {
+					let r = await ke(e, d.tenantId, m, n);
+					if (je(m, r, n, l), h = await Ae(e, d.tenantId, d.ownerId, r), h === void 0) {
+						if (m.joinRequired) throw t("forbidden");
+						h = await Me(e, d.tenantId, d.ownerId, m, r, l);
+					}
+					if (!Number.isSafeInteger(h.attemptsLeft) || Number(h.attemptsLeft) < 1 || Number(h.attemptsLeft) > m.attemptsPerEntry) throw t("limit_exceeded");
+				}
+				let g = (await e.query(N(C).where(M("id", s)).limit(1).descriptor))[0];
+				if (g && (g.tenantId !== d.tenantId || g.ownerId !== d.ownerId || g.board !== d.board || g.periodId !== o)) throw t("unavailable");
+				let _ = g ? z(g) : null;
+				if (_ && _.numSubmits >= 2147483647) throw t("overflow");
+				await e.insertIgnore(S.tableName, {
+					id: o,
+					tenantId: d.tenantId,
+					board: d.board,
+					startsAt: new Date(l),
+					endsAt: me(f, l),
+					state: "active",
+					summary: {},
+					previousPeriodId: null,
+					requestKey: null
+				}, { conflictColumns: ["id"] });
+				let y = (await e.query(N(S).where(M("id", o)).limit(1).descriptor))[0];
+				if (!y || y.tenantId !== d.tenantId || y.board !== d.board || y.state !== "active" || R(y.startsAt) > l || y.endsAt !== null && l >= R(y.endsAt)) throw t("conflict");
+				let b = await k.runPromise(k.result(k.suspend(() => de(d, _, e)).pipe(k.catchDefect(() => k.fail(t("unavailable"))))));
+				if (ue.isFailure(b)) throw b.failure;
+				let x = await Ce.admit(e, f, d, o, l);
+				if (_ && _.bucket !== x) throw t("unavailable");
+				let w = c(_?.score ?? null, d.score, f.operator, f.sort), D = f.operator === "best" && _ !== null && (u(d.score) !== u(w) || w === _.score && u(d.subscore) <= u(_.subscore)), ee = {
+					score: w,
+					subscore: D ? _.subscore : d.subscore,
+					bucket: x,
+					numSubmits: (_?.numSubmits ?? 0) + 1,
+					metadata: D ? _.metadata : d.metadata,
+					updatedAt: new Date(D ? _.updatedAt : l)
+				}, te = g ? await e.update(C.tableName, s, ee) : await e.insert(C.tableName, {
+					id: s,
+					tenantId: d.tenantId,
+					board: d.board,
+					periodId: o,
+					ownerId: d.ownerId,
+					...ee
+				});
+				if (!te) throw t("unavailable");
+				let ne = z(te);
+				if (h !== void 0 && !await e.update(E.tableName, String(h.id), { attemptsLeft: Number(h.attemptsLeft) - 1 })) throw t("unavailable");
+				return await e.insert(T.tableName, {
+					id: r,
+					tenantId: d.tenantId,
+					board: d.board,
+					periodId: o,
+					ownerId: d.ownerId,
+					requestKey: i,
+					record: ne,
+					roomId: d.roomId ?? null,
+					matchId: d.matchId ?? null,
+					tournamentId: d.tournamentId ?? null,
+					at: new Date(l)
+				}), await e.update(v.tableName, String(n.id), { updatedAt: new Date(l) }), ne;
+			})));
+		},
+		top: (e, n, r = 10, i = "global") => {
+			let a, o;
+			try {
+				if (a = W(e), o = H(n), !Number.isSafeInteger(r) || r < 1 || r > o.maxPageSize || !["global", "bucket"].includes(i)) throw t("invalid_input");
+			} catch (e) {
+				return k.fail(P(e));
+			}
+			let s = e.id;
+			return F(async () => (i === "global" ? await Z(a, o) : await Te(a, s, o)).slice(0, r));
+		},
+		me: (e, t) => {
+			let n, r, i;
+			try {
+				n = W(e), r = e.id, i = H(t);
+			} catch (e) {
+				return k.fail(P(e));
+			}
+			return F(async () => (await Te(n, r, i)).find((e) => e.ownerId === r) ?? null);
+		},
+		around: (e, n, r = 5) => {
+			let i, a, o;
+			try {
+				if (i = W(e), a = e.id, o = H(n), !Number.isSafeInteger(r) || r < 0 || r * 2 + 1 > o.maxPageSize) throw t("invalid_input");
+			} catch (e) {
+				return k.fail(P(e));
+			}
+			return F(async () => {
+				let e = await Te(i, a, o), t = re(e.map((e) => ({
+					...e,
+					tenantId: i
+				})), a, r), n = new Set(t.map((e) => e.id));
+				return e.filter((e) => n.has(e.id));
+			});
+		},
+		exportSubject: (e) => {
+			let i, a;
+			try {
+				if (!e || !r(e.tenantId) || !r(e.subjectId) || !["user", "guest"].includes(e.kind)) throw t("invalid_input");
+				i = e.tenantId, a = e.subjectId;
+			} catch (e) {
+				return k.fail(P(e));
+			}
+			return F(async () => (await G(i, a), n.transactional(async (e) => {
+				await K(e, i, a, !0), await De(e, i);
+				let n = await Ne(e, i);
+				await q.privacyFences(e, i);
+				let r = await q.exportInTransaction(e, i, a), o = await X(e, C, i, a), s = await X(e, T, i, a), c = await X(e, E, i, a), l = await X(e, y, i, a), u = await X(e, b, i, a), d = await e.query(N(x).where(M("tenantId", i)).limit(B + 1).descriptor);
+				if (d.length > B) throw t("limit_exceeded");
+				let f = (await Q(e, i)).filter((e) => e.state !== "active").flatMap((e) => $(e.summary, i, String(e.board), String(e.id)).top.filter((e) => e.ownerId === a).map((t) => ({
+					periodId: String(e.id),
+					board: String(e.board),
+					startsAt: R(e.startsAt),
+					endsAt: R(e.endsAt),
+					record: t
+				})));
+				return {
+					...r,
+					records: o.map(z),
+					submissions: s.map((e) => ({
+						id: e.id,
+						board: e.board,
+						periodId: e.periodId,
+						record: A.decodeUnknownSync(p)(structuredClone(e.record)),
+						roomId: e.roomId,
+						matchId: e.matchId,
+						tournamentId: e.tournamentId,
+						at: R(e.at)
+					})),
+					bucketAssignments: l.map((e) => ({
+						board: e.board,
+						periodId: e.periodId,
+						bucket: e.bucket,
+						group: e.group,
+						assignedAt: R(e.assignedAt)
+					})),
+					leagues: u.map((e) => ({
+						league: e.league,
+						division: e.division,
+						updatedAt: R(e.updatedAt)
+					})),
+					leagueMoves: d.flatMap((e) => (Array.isArray(e.movements) ? e.movements : []).filter((e) => e.ownerId === a).map((t) => ({
+						league: e.league,
+						from: t.from,
+						to: t.to,
+						at: R(e.at)
+					}))),
+					periodSummaries: f,
+					tournamentEntries: c.map((e) => {
+						let r = n.find((t) => t.id === e.tournamentId);
+						if (!r) throw t("unavailable");
+						return Oe(e, String(r.name));
+					})
+				};
+			})));
+		},
+		eraseSubject: (e) => {
+			let i, a;
+			try {
+				if (!e || !r(e.tenantId) || !r(e.subjectId) || !["user", "guest"].includes(e.kind)) throw t("invalid_input");
+				i = e.tenantId, a = e.subjectId;
+			} catch (e) {
+				return k.fail(P(e));
+			}
+			return F(async () => (await G(i, a), n.transactional(async (e) => {
+				let n = await K(e, i, a, !0);
+				await De(e, i);
+				let r = await Ne(e, i);
+				await q.privacyFences(e, i), await q.eraseInTransaction(e, i, a);
+				let o = await X(e, C, i, a), s = await X(e, T, i, a), c = await X(e, E, i, a), l = (await Q(e, i)).filter((e) => e.state !== "active").map((e) => ({
+					row: e,
+					summary: $(e.summary, i, String(e.board), String(e.id))
+				}));
+				for (let { row: n, summary: r } of l) if (r.top.some((e) => e.ownerId === a) && !await e.update(S.tableName, String(n.id), { summary: {
+					...r,
+					top: r.top.filter((e) => e.ownerId !== a)
+				} })) throw t("unavailable");
+				for (let t of s) await e.delete(T.tableName, String(t.id));
+				for (let t of o) await e.delete(C.tableName, String(t.id));
+				for (let t of await X(e, y, i, a)) await e.delete(y.tableName, String(t.id));
+				for (let t of await X(e, b, i, a)) await e.delete(b.tableName, String(t.id));
+				let u = await e.query(N(x).where(M("tenantId", i)).limit(B + 1).descriptor);
+				if (u.length > B) throw t("limit_exceeded");
+				for (let t of u) {
+					let n = Array.isArray(t.movements) ? t.movements : [];
+					n.some((e) => e.ownerId === a) && await e.update(x.tableName, String(t.id), { movements: n.filter((e) => e.ownerId !== a) });
+				}
+				for (let n of c) {
+					let i = r.find((e) => e.id === n.tournamentId);
+					if (!i || !Number.isSafeInteger(i.numEntries) || Number(i.numEntries) < 1 || !await e.update(D.tableName, String(i.id), { numEntries: Number(i.numEntries) - 1 })) throw t("unavailable");
+					await e.delete(E.tableName, String(n.id));
+				}
+				await e.update(w.tableName, String(n.id), {
+					subjectId: null,
+					erased: !0
+				});
+			})));
+		}
+	};
+};
+export { pe as acceptLeaderboardSubmission, ge as dataStoreLeaderboards, he as resolveLeaderboardStoreOptions };