@voltro/plugin-leaderboards 0.0.0-stage → 0.88.0

package/dist/brackets.js

@@ -0,0 +1,378 @@
+import { leaderboardError as e } from "./errors.js";
+import { canonicalLeaderboardJson as t, captureLeaderboardJson as n } from "./json.js";
+import { Schema as r } from "effect";
+// src/brackets.ts
+var i = Object.freeze({
+	maxEntrants: 256,
+	maxMatches: 65536,
+	maxSearchNodes: 1e5,
+	maxInputBytes: 65536
+});
+function a() {
+	throw e("invalid_input");
+}
+var o = (e, t) => Number.isSafeInteger(e) && e > 0 && e <= t ? e : a(), s = (e) => typeof e == "string" && e.length > 0 && e.length <= 120 && e.trim() === e && e.isWellFormed() && !/[\u0000-\u001f\u007f]/.test(e) ? e : a(), c = (e, t) => {
+	try {
+		return r.decodeUnknownSync(e)(t, { onExcessProperty: "error" });
+	} catch {
+		return a();
+	}
+}, l = r.Struct({
+	entrantId: r.String,
+	seed: r.Int
+}), u = (e) => {
+	let t = n(e, 1024);
+	(typeof t != "object" || !t || Array.isArray(t)) && a();
+	for (let e of Object.keys(t)) Object.hasOwn(i, e) || a();
+	let r = {
+		...i,
+		...t
+	};
+	return o(r.maxEntrants, 256), o(r.maxMatches, 65536), o(r.maxSearchNodes, 1e6), o(r.maxInputBytes, 65536), Object.freeze(r);
+}, d = (e, t) => {
+	let i = c(r.Array(l), n(e, t.maxInputBytes));
+	(i.length < 2 || i.length > t.maxEntrants) && a();
+	let u = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set();
+	for (let e of i) s(e.entrantId), o(e.seed, i.length), (u.has(e.seed) || d.has(e.entrantId)) && a(), u.add(e.seed), d.add(e.entrantId);
+	return Object.freeze(i.map((e) => Object.freeze({ ...e })).sort((e, t) => e.seed - t.seed));
+}, f = (e, t) => Object.freeze({
+	left: e,
+	right: t
+}), p = (t, i = {}) => {
+	let o = c(r.Struct({
+		doubleRound: r.optional(r.Boolean),
+		limits: r.optional(r.Unknown)
+	}), n(i, 2048)), s = u(o.limits ?? {}), l = d(t, s);
+	if (l.length * (l.length - 1) / 2 * (o.doubleRound ? 2 : 1) > s.maxMatches) throw e("limit_exceeded");
+	let p = l.map((e) => e.entrantId);
+	p.length % 2 == 1 && p.push(null);
+	let m = [];
+	for (let e = 0; e < p.length - 1; e++) {
+		let t = [], n = null;
+		for (let r = 0; r < p.length / 2; r++) {
+			let i = p[r], o = p[p.length - r - 1];
+			(i === void 0 || o === void 0 || i === null && o === null) && a(), i === null ? n = o : o === null ? n = i : t.push(e % 2 == 0 ? f(i, o) : f(o, i));
+		}
+		m.push(Object.freeze({
+			round: e + 1,
+			pairs: Object.freeze(t),
+			bye: n
+		}));
+		let r = p.pop();
+		r === void 0 && a(), p.splice(1, 0, r);
+	}
+	if (o.doubleRound) {
+		let e = m.length;
+		for (let t of m.slice()) m.push(Object.freeze({
+			round: t.round + e,
+			bye: t.bye,
+			pairs: Object.freeze(t.pairs.map((e) => f(e.right, e.left)))
+		}));
+	}
+	return Object.freeze(m);
+}, m = r.Struct({
+	entrantId: r.String,
+	seed: r.Int,
+	points: r.Int,
+	byes: r.Int,
+	opponents: r.Array(r.String)
+}), h = (t, i = {}) => {
+	let o = u(i), s = c(r.Array(m), n(t, o.maxInputBytes)), l = d(s.map((e) => ({
+		entrantId: e.entrantId,
+		seed: e.seed
+	})), o);
+	if (s.length > 128) throw e("limit_exceeded");
+	let p = new Set(l.map((e) => e.entrantId)), h = /* @__PURE__ */ new Map();
+	for (let e of s) {
+		(!Number.isSafeInteger(e.points) || e.points < 0 || !Number.isSafeInteger(e.byes) || e.byes < 0 || e.byes > 1e6 || e.opponents.length >= s.length) && a();
+		let t = /* @__PURE__ */ new Set();
+		for (let n of e.opponents) (!p.has(n) || n === e.entrantId || t.has(n)) && a(), t.add(n);
+		h.set(e.entrantId, t);
+	}
+	for (let [e, t] of h) for (let n of t) h.get(n)?.has(e) || a();
+	let g = s.map((e) => Object.freeze({
+		...e,
+		opponents: Object.freeze([...e.opponents])
+	})).sort((e, t) => e.points === t.points ? e.seed - t.seed : e.points > t.points ? -1 : 1), _ = 0, v = (t, n) => {
+		if (_ >= o.maxSearchNodes) throw e("limit_exceeded");
+		_++;
+		let r = t[0];
+		if (!r) return n;
+		let i = t.slice(1).filter((e) => !h.get(r.entrantId)?.has(e.entrantId)).sort((e, t) => {
+			let n = r.points > e.points ? BigInt(r.points) - BigInt(e.points) : BigInt(e.points) - BigInt(r.points), i = r.points > t.points ? BigInt(r.points) - BigInt(t.points) : BigInt(t.points) - BigInt(r.points);
+			return n === i ? Math.abs(e.seed - r.seed) - Math.abs(t.seed - r.seed) || e.seed - t.seed : n < i ? -1 : 1;
+		});
+		for (let e of i) {
+			let i = v(t.filter((t) => t.entrantId !== r.entrantId && t.entrantId !== e.entrantId), [...n, f(r.entrantId, e.entrantId)]);
+			if (i) return i;
+		}
+		return null;
+	};
+	if (Math.floor(s.length / 2) > o.maxMatches) throw e("limit_exceeded");
+	let y = Math.min(...g.map((e) => e.byes)), b = g.length % 2 == 0 ? [null] : g.filter((e) => e.byes === y).sort((e, t) => e.points === t.points ? t.seed - e.seed : e.points < t.points ? -1 : 1);
+	for (let e of b) {
+		let t = v(g.filter((t) => t.entrantId !== e?.entrantId), []);
+		if (t) return Object.freeze({
+			pairs: Object.freeze(t),
+			bye: e?.entrantId ?? null,
+			searchNodes: _
+		});
+	}
+	throw e("conflict");
+}, g = (e, t, i) => {
+	let o = c(r.Array(r.Struct({
+		matchId: r.String,
+		winnerId: r.String
+	})), n(e, i.maxInputBytes)), l = /* @__PURE__ */ new Map();
+	for (let e of o) s(e.winnerId), (!t.has(e.matchId) || l.has(e.matchId)) && a(), l.set(e.matchId, e.winnerId);
+	return l;
+}, _ = (t, n, r, i, a) => {
+	if (a !== void 0 && a !== r && a !== i) throw e("conflict");
+	return Object.freeze({
+		id: t,
+		round: n,
+		left: r,
+		right: i,
+		status: a === void 0 ? "ready" : "complete",
+		winnerId: a ?? null
+	});
+}, v = (e, t, n) => {
+	let r = Math.max(...e.map((e) => t.get(e.entrantId) ?? 0)), i = new Set(e.filter((e) => (t.get(e.entrantId) ?? 0) === r).map((e) => e.entrantId)), a = (e) => n.filter((t) => t.winnerId === e && i.has(t.left) && i.has(t.right)).length, o = (e) => n.filter((t) => t.left === e || t.right === e).reduce((n, r) => n + (t.get(r.left === e ? r.right : r.left) ?? 0), 0);
+	return [...e].filter((e) => i.has(e.entrantId)).sort((e, t) => a(t.entrantId) - a(e.entrantId) || o(t.entrantId) - o(e.entrantId) || e.seed - t.seed)[0].entrantId;
+}, y = (e, t, n = {}) => {
+	let r = u(n), i = d(e, r), a = p(i, { limits: r }).flatMap((e) => e.pairs.map((t, n) => ({
+		id: "rr-" + e.round + "-" + (n + 1),
+		round: e.round,
+		pairing: t
+	}))), o = g(t, new Set(a.map((e) => e.id)), r), s = a.map((e) => _(e.id, e.round, e.pairing.left, e.pairing.right, o.get(e.id))), c = /* @__PURE__ */ new Map();
+	for (let e of s) e.winnerId && c.set(e.winnerId, (c.get(e.winnerId) ?? 0) + 1);
+	let l = s.every((e) => e.status === "complete");
+	return Object.freeze({
+		matches: Object.freeze(s),
+		champion: l ? v(i, c, s) : null
+	});
+}, b = (t, i, o, l = {}) => {
+	let f = u(l), p = d(t, f);
+	(!Number.isSafeInteger(o) || o < 1 || o >= p.length) && a();
+	let m = c(r.Array(r.Struct({
+		matchId: r.String,
+		winnerId: r.String
+	})), n(i, f.maxInputBytes)), g = /* @__PURE__ */ new Map();
+	for (let e of m) s(e.winnerId), (!/^sw-[0-9]+-[0-9]+$/.test(e.matchId) || g.has(e.matchId)) && a(), g.set(e.matchId, e.winnerId);
+	let y = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Map(), S = [];
+	for (let e = 1; e <= o; e++) {
+		let t = h(p.map((e) => ({
+			...e,
+			points: y.get(e.entrantId) ?? 0,
+			byes: b.get(e.entrantId) ?? 0,
+			opponents: x.get(e.entrantId) ?? []
+		})), f), n = t.pairs.map((t, n) => {
+			let r = "sw-" + e + "-" + (n + 1), i = g.get(r);
+			return g.delete(r), _(r, e, t.left, t.right, i);
+		});
+		if (t.bye !== null && S.push(Object.freeze({
+			id: "sw-" + e + "-bye",
+			round: e,
+			left: t.bye,
+			right: null,
+			status: "walkover",
+			winnerId: t.bye
+		})), S.push(...n), n.some((e) => e.status !== "complete")) break;
+		for (let e of n) y.set(e.winnerId, (y.get(e.winnerId) ?? 0) + 1), x.set(e.left, [...x.get(e.left) ?? [], e.right]), x.set(e.right, [...x.get(e.right) ?? [], e.left]);
+		t.bye !== null && (y.set(t.bye, (y.get(t.bye) ?? 0) + 1), b.set(t.bye, (b.get(t.bye) ?? 0) + 1));
+	}
+	if (g.size > 0) throw e("conflict");
+	let C = S.filter((e) => e.right !== null), w = S.filter((e) => e.right !== null && e.round === o).length > 0 && C.every((e) => e.status === "complete");
+	return Object.freeze({
+		matches: Object.freeze(S),
+		champion: w ? v(p, y, C) : null
+	});
+}, x = (t, n = {}) => {
+	let r = u(n), i = d(t, r), o = 2, s = [1, 2];
+	for (; o < i.length;) o *= 2, s = s.flatMap((e) => [e, o + 1 - e]);
+	if (o - 1 > r.maxMatches) throw e("limit_exceeded");
+	let c = [], l = (e) => {
+		let t = i[e - 1];
+		return Object.freeze(t ? {
+			kind: "entrant",
+			entrantId: t.entrantId
+		} : { kind: "bye" });
+	}, f = [];
+	for (let e = o / 2, t = 1; e >= 1; e /= 2, t++) {
+		let n = [];
+		for (let r = 0; r < e; r++) {
+			let e = `w${t}.${r + 1}`, i = (e) => t === 1 ? l(s[e] ?? a()) : Object.freeze({
+				kind: "winner",
+				matchId: f[e] ?? a()
+			});
+			c.push(Object.freeze({
+				id: e,
+				round: t,
+				left: i(r * 2),
+				right: i(r * 2 + 1)
+			})), n.push(e);
+		}
+		f = n;
+	}
+	return Object.freeze({
+		format: "single-elimination",
+		version: 1,
+		entrants: i,
+		matches: Object.freeze(c)
+	});
+}, S = (i, o, l = {}) => {
+	let d = u(l), f = n(i, d.maxInputBytes);
+	(typeof f != "object" || !f || Array.isArray(f)) && a();
+	let p = x(f.entrants, d);
+	t(f) !== t(p) && a();
+	let m = c(r.Array(r.Struct({
+		matchId: r.String,
+		winnerId: r.String
+	})), n(o, d.maxInputBytes)), h = /* @__PURE__ */ new Map(), g = new Set(p.matches.map((e) => e.id));
+	for (let e of m) s(e.winnerId), (!g.has(e.matchId) || h.has(e.matchId)) && a(), h.set(e.matchId, e.winnerId);
+	let _ = /* @__PURE__ */ new Map(), v = [], y = (e) => {
+		if (e.kind === "entrant") return {
+			kind: "present",
+			id: e.entrantId
+		};
+		if (e.kind === "bye") return e;
+		let t = _.get(e.matchId)?.winnerId;
+		return t ? {
+			kind: "present",
+			id: t
+		} : { kind: "waiting" };
+	};
+	for (let t of p.matches) {
+		let n = y(t.left), r = y(t.right), i = h.get(t.id), a = "pending", o = null;
+		if (n.kind === "present" && r.kind === "present") {
+			if (a = i === void 0 ? "ready" : "complete", i !== void 0 && i !== n.id && i !== r.id) throw e("conflict");
+			o = i ?? null;
+		} else n.kind === "present" && r.kind === "bye" ? (a = "walkover", o = n.id) : r.kind === "present" && n.kind === "bye" && (a = "walkover", o = r.id);
+		if (i !== void 0 && a !== "complete") throw e("conflict");
+		let s = Object.freeze({
+			id: t.id,
+			round: t.round,
+			left: n.kind === "present" ? n.id : null,
+			right: r.kind === "present" ? r.id : null,
+			status: a,
+			winnerId: o
+		});
+		_.set(t.id, s), v.push(s);
+	}
+	return Object.freeze({
+		matches: Object.freeze(v),
+		champion: v.at(-1)?.winnerId ?? null
+	});
+}, C = (t, n = {}) => {
+	let r = u(n), i = x(t, r), o = i.matches.at(-1)?.round ?? a(), s = 2 ** o;
+	if (2 * s - 1 > r.maxMatches) throw e("limit_exceeded");
+	let c = i.matches.map((e) => Object.freeze({
+		...e,
+		stage: "winners"
+	})), l = (e, t) => Object.freeze({
+		kind: e,
+		matchId: t
+	}), d = (e, t, n, r) => {
+		let i = `l${e}.${t + 1}`;
+		return c.push(Object.freeze({
+			id: i,
+			stage: "losers",
+			round: e,
+			left: n,
+			right: r
+		})), i;
+	}, f = [], p = 1;
+	for (let e = 0; e < Math.floor(s / 4); e++) f.push(d(p, e, l("loser", `w1.${e * 2 + 1}`), l("loser", `w1.${e * 2 + 2}`)));
+	for (let e = 2; e <= o; e++) {
+		let t = s / 2 ** e, n = [];
+		p++;
+		for (let r = 0; r < t; r++) {
+			let i = t > 1 ? r ^ 1 : r;
+			n.push(d(p, r, l("winner", f[r] ?? a()), l("loser", `w${e}.${i + 1}`)));
+		}
+		if (e === o) {
+			f = n;
+			break;
+		}
+		let r = [];
+		p++;
+		for (let e = 0; e < n.length / 2; e++) r.push(d(p, e, l("winner", n[e * 2] ?? a()), l("winner", n[e * 2 + 1] ?? a())));
+		f = r;
+	}
+	let m = o === 1 ? l("loser", "w1.1") : l("winner", f[0] ?? a());
+	return c.push(Object.freeze({
+		id: "g1.1",
+		stage: "final",
+		round: 1,
+		left: l("winner", `w${o}.1`),
+		right: m
+	})), c.push(Object.freeze({
+		id: "g2.1",
+		stage: "reset",
+		round: 2,
+		left: l("loser", "g1.1"),
+		right: l("winner", "g1.1")
+	})), Object.freeze({
+		format: "double-elimination",
+		version: 1,
+		entrants: i.entrants,
+		matches: Object.freeze(c)
+	});
+}, w = (i, o, l = {}) => {
+	let d = u(l), f = n(i, d.maxInputBytes);
+	(typeof f != "object" || !f || Array.isArray(f)) && a();
+	let p = C(f.entrants, d);
+	t(f) !== t(p) && a();
+	let m = c(r.Array(r.Struct({
+		matchId: r.String,
+		winnerId: r.String
+	})), n(o, d.maxInputBytes)), h = /* @__PURE__ */ new Map(), g = new Set(p.matches.map((e) => e.id));
+	for (let e of m) s(e.winnerId), (!g.has(e.matchId) || h.has(e.matchId)) && a(), h.set(e.matchId, e.winnerId);
+	let _ = [], v = /* @__PURE__ */ new Map(), y = new Map(p.entrants.map((e) => [e.entrantId, 0])), b = (e) => {
+		if (e.kind === "entrant") return {
+			kind: "present",
+			id: e.entrantId
+		};
+		if (e.kind === "bye") return e;
+		let t = v.get(e.matchId);
+		if (!t || t.status === "pending" || t.status === "ready") return { kind: "waiting" };
+		let n = e.kind === "winner" ? t.winnerId : t.loserId;
+		return n ? {
+			kind: "present",
+			id: n
+		} : { kind: "bye" };
+	};
+	for (let t of p.matches) {
+		let n = b(t.left), r = b(t.right), i = h.get(t.id), a = v.get("g1.1"), o = "pending", s = null, c = null;
+		if (t.stage === "reset" && a?.status === "complete" && a.winnerId === a.left) o = "inactive";
+		else if (n.kind === "present" && r.kind === "present") {
+			if (n.id === r.id || (y.get(n.id) ?? 2) >= 2 || (y.get(r.id) ?? 2) >= 2) throw e("conflict");
+			if (o = i === void 0 ? "ready" : "complete", i !== void 0) {
+				if (i !== n.id && i !== r.id) throw e("conflict");
+				s = i, c = i === n.id ? r.id : n.id, y.set(c, (y.get(c) ?? 0) + 1);
+			}
+		} else n.kind === "present" && r.kind === "bye" ? (o = "walkover", s = n.id) : r.kind === "present" && n.kind === "bye" ? (o = "walkover", s = r.id) : n.kind === "bye" && r.kind === "bye" && (o = "empty");
+		if (i !== void 0 && o !== "complete") throw e("conflict");
+		let l = Object.freeze({
+			id: t.id,
+			round: t.round,
+			stage: t.stage,
+			left: n.kind === "present" ? n.id : null,
+			right: r.kind === "present" ? r.id : null,
+			status: o,
+			winnerId: s,
+			loserId: c
+		});
+		_.push(l), v.set(t.id, l);
+	}
+	let x = v.get("g1.1"), S = v.get("g2.1"), w = x?.status === "complete" ? x.winnerId === x.left ? x.winnerId : S?.status === "complete" ? S.winnerId : null : null;
+	return Object.freeze({
+		matches: Object.freeze(_),
+		champion: w,
+		losses: Object.freeze(p.entrants.map((e) => Object.freeze({
+			entrantId: e.entrantId,
+			losses: y.get(e.entrantId) ?? 0
+		})))
+	});
+};
+export { w as advanceDoubleElimination, y as advanceRoundRobin, S as advanceSingleElimination, b as advanceSwiss, p as roundRobin, C as seedDoubleElimination, x as seedSingleElimination, h as swissPairings };

package/dist/bucketStore.js

@@ -0,0 +1,92 @@
+import { leaderboardError as e } from "./errors.js";
+import { leaderboardBucketAssignmentsTable as t } from "./tables.entity.js";
+import { and as n, eq as r, queryFor as i } from "@voltro/database";
+// src/bucketStore.ts
+var a = (a) => {
+	let o = (e, t, n, r) => a.key("lbba_", [
+		e,
+		t,
+		n,
+		r
+	]), s = async (n, a, s, c, l) => {
+		let u = o(a, s, c, l), d = (await n.query(i(t).where(r("id", u)).limit(1).descriptor))[0];
+		if (d && (d.tenantId !== a || d.board !== s || d.periodId !== c || d.ownerId !== l || typeof d.bucket != "string" || d.bucket.length > 64)) throw e("unavailable");
+		return d;
+	};
+	return {
+		readOwn: s,
+		admit: async (c, l, u, d, f) => {
+			if (l.buckets === void 0) return null;
+			let p = await s(c, u.tenantId, l.name, d, u.ownerId);
+			if (p) return String(p.bucket);
+			let m = l.buckets, h = m.assign === "hash" ? null : m.assign === "cohort" ? u.bucketCohort : "skill:" + Math.floor(u.bucketSkill / m.skillWidth), g = a.hash([
+				u.tenantId,
+				l.name,
+				d,
+				m.assign,
+				h
+			]), _ = await c.query(i(t).where(n(r("tenantId", u.tenantId), r("board", l.name), r("periodId", d))).orderBy("id", "asc").limit(l.maxRankRecords + 1).descriptor);
+			if (_.length >= l.maxRankRecords) throw e("limit_exceeded");
+			let v = /* @__PURE__ */ new Map(), y = -1;
+			for (let t of _) {
+				if (t.tenantId !== u.tenantId || t.board !== l.name || t.periodId !== d || !Number.isSafeInteger(t.ordinal) || Number(t.ordinal) < 0 || Number(t.ordinal) >= l.maxRankRecords || typeof t.groupKey != "string" || typeof t.bucket != "string") throw e("unavailable");
+				let n = a.key("lbbk_", [
+					u.tenantId,
+					l.name,
+					d,
+					t.groupKey,
+					String(t.ordinal)
+				]);
+				if (t.bucket !== n) throw e("unavailable");
+				if (t.groupKey !== g) continue;
+				if (t.group !== h) throw e("unavailable");
+				let r = Number(t.ordinal), i = v.get(t.bucket);
+				i ? i.entries++ : v.set(t.bucket, {
+					id: t.bucket,
+					ordinal: r,
+					entries: 1
+				}), y = Math.max(y, r);
+			}
+			if ([...v.values()].some((e) => e.entries > m.size)) throw e("unavailable");
+			let b = [...v.values()].filter((e) => e.entries < m.size).sort((e, t) => e.ordinal - t.ordinal);
+			if (b.length === 0) {
+				let e = y + 1;
+				b = [{
+					id: a.key("lbbk_", [
+						u.tenantId,
+						l.name,
+						d,
+						g,
+						String(e)
+					]),
+					ordinal: e,
+					entries: 0
+				}];
+			}
+			let x = Object.freeze(b.map((e) => Object.freeze({ ...e }))), S = a.assign(Object.freeze({
+				tenantId: u.tenantId,
+				board: l.name,
+				periodId: d,
+				ownerId: u.ownerId,
+				assign: m.assign,
+				size: m.size,
+				group: h,
+				candidates: x
+			})), C = x.find((e) => e.id === S);
+			if (!C) throw e("invalid_record");
+			return await c.insert(t.tableName, {
+				id: o(u.tenantId, l.name, d, u.ownerId),
+				tenantId: u.tenantId,
+				board: l.name,
+				periodId: d,
+				ownerId: u.ownerId,
+				bucket: S,
+				ordinal: C.ordinal,
+				groupKey: g,
+				group: h,
+				assignedAt: new Date(f)
+			}), S;
+		}
+	};
+};
+export { a as makeBucketStore };

package/dist/buckets.js

@@ -0,0 +1,8 @@
+import { leaderboardError as e } from "./errors.js";
+import { hashBucket as t } from "./ranking.js";
+// src/buckets.ts
+var n = (n) => {
+	if (n.candidates.length === 0) throw e("limit_exceeded");
+	return n.candidates[t(n.tenantId, n.periodId, n.ownerId, n.candidates.length)].id;
+};
+export { n as defaultLeaderboardBucketAssign };

package/dist/errors.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+export declare class LeaderboardError extends LeaderboardError_base {
+}
+
+export declare const leaderboardError: (code: LeaderboardError["code"]) => LeaderboardError;
+
+declare const LeaderboardError_base: Schema.Class<LeaderboardError, Schema.TaggedStruct<"LeaderboardError", {
+    readonly code: Schema.Literals<readonly ["invalid_board", "invalid_score", "invalid_record", "invalid_input", "overflow", "unavailable", "forbidden", "not_found", "conflict", "erased", "limit_exceeded"]>;
+}>, YieldableError>;
+
+export { }

package/dist/errors.js

@@ -0,0 +1,16 @@
+import { Schema as e } from "effect";
+// src/errors.ts
+var t = class extends e.TaggedError()("LeaderboardError", { code: e.Literals([
+	"invalid_board",
+	"invalid_score",
+	"invalid_record",
+	"invalid_input",
+	"overflow",
+	"unavailable",
+	"forbidden",
+	"not_found",
+	"conflict",
+	"erased",
+	"limit_exceeded"
+]) }) {}, n = (e) => new t({ code: e });
+export { t as LeaderboardError, n as leaderboardError };

package/dist/glicko2.js

@@ -0,0 +1,71 @@
+import { leaderboardError as e } from "./errors.js";
+// src/glicko2.ts
+var t = 173.7178, n = (e, t, n) => Number.isFinite(e) && e >= t && e <= n, r = (e, t) => Number.isSafeInteger(e) && e >= 1 && e <= t, i = (e) => n(e, -1e9, 1e9), a = (e) => n(e, 1e-6, 1e6), o = (e) => n(e, 1e-12, 10), s = (t) => {
+	if (!Number.isFinite(t)) throw e("overflow");
+	return t;
+}, c = (e) => e >= 0 ? 1 / (1 + Math.exp(-e)) : Math.exp(e) / (1 + Math.exp(e)), l = (l = {}) => {
+	let u = l.tau ?? .5, d = l.epsilon ?? 1e-6, f = l.maxIterations ?? 100, p = l.maxOpponents ?? 4096;
+	if (!n(u, 1e-6, 10) || !n(d, 1e-12, .01) || !r(f, 1e4) || !r(p, 1e5)) throw e("invalid_input");
+	return (n) => {
+		let r = n?.player, l = n?.opponents;
+		if (!r || !i(r.rating) || !a(r.deviation) || !o(r.volatility) || !Array.isArray(l)) throw e("invalid_input");
+		if (l.length > p) throw e("limit_exceeded");
+		let m = Object.freeze({
+			rating: r.rating,
+			deviation: r.deviation,
+			volatility: r.volatility
+		}), h = l.map((t) => {
+			if (!t || !i(t.rating) || !a(t.deviation) || ![
+				0,
+				.5,
+				1
+			].includes(t.score)) throw e("invalid_input");
+			return {
+				rating: t.rating,
+				deviation: t.deviation,
+				score: t.score
+			};
+		});
+		for (let t = 0; t < l.length; t++) if (!Object.hasOwn(l, t)) throw e("invalid_input");
+		let g = (m.rating - 1500) / t, _ = m.deviation / t, v = (n, r, c) => {
+			let l = s(n * t + 1500), u = s(r * t);
+			if (!i(l) || !a(u) || !o(c)) throw e("overflow");
+			return Object.freeze({
+				previous: m,
+				rating: l,
+				deviation: u,
+				volatility: c
+			});
+		};
+		if (h.length === 0) return v(g, Math.hypot(_, m.volatility), m.volatility);
+		let y = 0, b = 0;
+		for (let e of h) {
+			let n = e.deviation / t, r = 1 / Math.sqrt(1 + 3 * n ** 2 / Math.PI ** 2), i = c(r * (g - (e.rating - 1500) / t));
+			y += r ** 2 * i * (1 - i), b += r * (e.score - i);
+		}
+		if (!Number.isFinite(y) || y <= 0) throw e("overflow");
+		let x = s(1 / y), S = s(s(x * b) ** 2), C = Math.log(m.volatility ** 2), w = _ ** 2, T = (e) => {
+			let t = s(Math.exp(e)), n = w + x + t;
+			return s(t * (S - n) / (2 * n ** 2) - (e - C) / u ** 2);
+		}, E = 0, D = () => {
+			if (++E > f) throw e("limit_exceeded");
+		}, O = C, k;
+		if (S > w + x) k = Math.log(S - w - x);
+		else {
+			let e = 1;
+			for (k = C - e * u; T(k) < 0;) D(), k = C - ++e * u;
+		}
+		let A = T(O), j = T(k);
+		if (A * j > 0) throw e("overflow");
+		for (; Math.abs(k - O) > d && A !== 0 && j !== 0;) {
+			D();
+			let t = j - A;
+			if (t === 0) throw e("overflow");
+			let n = s(O + (O - k) * A / t), r = T(n);
+			r * j <= 0 ? (O = k, A = j) : A /= 2, k = n, j = r;
+		}
+		let M = s(Math.exp((j === 0 ? k : O) / 2)), N = 1 / Math.sqrt(1 / Math.hypot(_, M) ** 2 + y);
+		return v(g + N ** 2 * b, N, M);
+	};
+};
+export { l as glicko2 };