@voltro/plugin-leaderboards 0.0.0-stage → 0.88.0

package/dist/bracketMatches.js

@@ -0,0 +1,545 @@
+import { LeaderboardError as e, leaderboardError as t } from "./errors.js";
+import { canonicalLeaderboardJson as n, captureLeaderboardJson as r } from "./json.js";
+import { makeLeaderboardSubjectFences as i } from "./subjectFences.js";
+import { TournamentBracketPort as a } from "./bracketMatchPorts.js";
+import { advanceDoubleElimination as o, advanceRoundRobin as s, advanceSingleElimination as c, advanceSwiss as l, seedDoubleElimination as u, seedSingleElimination as d } from "./brackets.js";
+import { Effect as f, Layer as p, Schema as m } from "effect";
+import { Subject as h } from "@voltro/protocol";
+import { createHash as g } from "node:crypto";
+import { and as _, eq as v, id as y, json as b, table as x, text as S, timestamp as C } from "@voltro/database";
+// src/bracketMatches.ts
+var w = "_voltro_brackets", T = x(w, {
+	id: y({ prefix: "tbrk" }),
+	tenantId: S().maxLength(120).externalId().sensitive("pii"),
+	tournamentId: S().maxLength(120).serverOnly(),
+	state: b().sensitive("pii"),
+	createdAt: C(),
+	updatedAt: C()
+}).unique("byTournamentBracket", ["tenantId", "tournamentId"]).index(["tenantId"]);
+function E(e) {
+	throw t(e);
+}
+var D = (e) => typeof e == "string" && e.length > 0 && e.length <= 120 && e.trim() === e && e.isWellFormed() && !/[\u0000-\u001f\u007f]/.test(e) ? e : E("invalid_input"), O = (e) => Number.isSafeInteger(e) && e >= 0 && e <= 864e13 ? e : E("invalid_input"), k = (e) => {
+	let t = r(e, 1024);
+	return t && Object.keys(t).length === 2 && Object.hasOwn(t, "tenantId") && Object.hasOwn(t, "tournamentId") || E("invalid_input"), Object.freeze({
+		tenantId: D(t.tenantId),
+		tournamentId: D(t.tournamentId)
+	});
+}, A = (e, t) => m.decodeUnknownSync(e)(r(t, 65536), { onExcessProperty: "error" }), j = m.Struct({
+	format: m.Literals([
+		"single-elimination",
+		"double-elimination",
+		"round-robin",
+		"swiss"
+	]),
+	entrants: m.Array(m.Struct({
+		entrantId: m.String,
+		seed: m.Int
+	})).pipe(m.check(m.isMinLength(2)), m.check(m.isMaxLength(64))),
+	rounds: m.optional(m.Int.pipe(m.check(m.isBetween({
+		minimum: 1,
+		maximum: 63
+	})))),
+	ruleVersion: m.String
+}), M = m.Struct({
+	roomId: m.String,
+	epoch: m.Int.pipe(m.check(m.isBetween({
+		minimum: 1,
+		maximum: 4294967295
+	})))
+}), N = m.Struct({
+	...M.fields,
+	matchId: m.String,
+	reportId: m.String,
+	winnerId: m.String
+}), P = m.Struct({
+	disputeId: m.String,
+	matchId: m.String,
+	reason: m.Literals([
+		"result_mismatch",
+		"no_show",
+		"connection"
+	])
+}), F = m.Struct({
+	disputeId: m.String,
+	resolutionId: m.String,
+	winnerId: m.String
+}), I = m.Struct({
+	tenantId: m.String,
+	tournamentId: m.String,
+	matchId: m.String,
+	requestId: m.String,
+	left: m.String,
+	right: m.String,
+	ruleVersion: m.String,
+	roomId: m.NullOr(m.String),
+	epoch: m.NullOr(m.Int)
+}), L = m.Struct({
+	version: m.Literal(1),
+	format: j.fields.format,
+	rounds: j.fields.rounds,
+	entrants: m.Array(m.Struct({
+		entrantId: m.String,
+		seed: m.Int
+	})).pipe(m.check(m.isMaxLength(64))),
+	ruleVersion: m.String,
+	phase: m.Literals([
+		"active",
+		"paused",
+		"complete",
+		"erasing",
+		"cancelled"
+	]),
+	withdrawn: m.Boolean,
+	provisions: m.Array(I),
+	results: m.Array(m.Struct({
+		...N.fields,
+		reportedWinnerId: m.String
+	})),
+	disputes: m.Array(m.Struct({
+		...P.fields,
+		ownerId: m.String,
+		resolutionId: m.NullOr(m.String),
+		winnerId: m.NullOr(m.String)
+	})),
+	settlement: m.NullOr(m.Struct({
+		requestId: m.String,
+		winnerId: m.String,
+		complete: m.Boolean
+	})),
+	erase: m.NullOr(m.Struct({
+		requestId: m.String,
+		targetDigest: m.String
+	}))
+}), R = (e) => g("sha256").update(n(e)).digest("hex"), z = (e, t, n) => "tbrk:" + R([
+	e,
+	t,
+	n
+]), B = (e, t) => {
+	let n = t.map((e) => ({
+		matchId: e.matchId,
+		winnerId: e.winnerId
+	}));
+	switch (e.format) {
+		case "single-elimination": return c(d(e.entrants), n);
+		case "double-elimination": return o(u(e.entrants), n);
+		case "round-robin": return s(e.entrants, n);
+		case "swiss": return l(e.entrants, n, V(e));
+	}
+}, V = (e) => e.rounds ?? Math.max(1, Math.ceil(Math.log2(e.entrants.length))), H = (e) => {
+	let t = e.entrants.length;
+	return e.format === "round-robin" ? t * (t - 1) / 2 : e.format === "swiss" ? V(e) * Math.floor(t / 2) : 2 * t - 1;
+}, U = (e) => {
+	let t = A(j, e);
+	return D(t.ruleVersion), (t.rounds !== void 0 && t.format !== "swiss" || H(t) > 127) && E("invalid_input"), B(t, []), r(t, 16384);
+}, W = (e, t) => {
+	new Set(e.map(t)).size !== e.length && E("unavailable");
+}, G = (e, t) => {
+	(e.tenantId !== t.tenantId || e.tournamentId !== t.tournamentId) && E("unavailable");
+	let n = A(L, e.state);
+	D(n.ruleVersion), W(n.entrants, (e) => e.entrantId), W(n.provisions, (e) => e.matchId), W(n.provisions, (e) => e.requestId), W(n.results, (e) => e.matchId), W(n.results, (e) => e.reportId), W(n.disputes, (e) => e.disputeId);
+	for (let t of ["createdAt", "updatedAt"]) e[t] instanceof Date && Number.isFinite(e[t].getTime()) || E("unavailable");
+	(n.provisions.length > 127 || n.results.length > 127 || n.disputes.length > 254) && E("unavailable");
+	for (let e of n.entrants) D(e.entrantId), (!Number.isSafeInteger(e.seed) || e.seed < 1 || e.seed > 64) && E("unavailable");
+	for (let e of n.provisions) {
+		for (let t of [
+			"matchId",
+			"left",
+			"right",
+			"requestId"
+		]) D(e[t]);
+		(e.tenantId !== t.tenantId || e.tournamentId !== t.tournamentId || e.ruleVersion !== n.ruleVersion || e.left === e.right || e.requestId !== z(t, n.ruleVersion, "room:" + e.matchId) || e.roomId === null != (e.epoch === null)) && E("unavailable"), e.roomId !== null && A(M, {
+			roomId: D(e.roomId),
+			epoch: e.epoch
+		});
+	}
+	for (let e of n.results) {
+		for (let t of [
+			"reportId",
+			"winnerId",
+			"reportedWinnerId"
+		]) D(e[t]);
+		let t = n.provisions.find((t) => t.matchId === e.matchId);
+		t && t.roomId === e.roomId && t.epoch === e.epoch && [t.left, t.right].includes(e.winnerId) && [t.left, t.right].includes(e.reportedWinnerId) || E("unavailable");
+	}
+	for (let e of n.disputes) {
+		D(e.disputeId), D(e.ownerId);
+		let t = n.provisions.find((t) => t.matchId === e.matchId);
+		t && n.results.some((t) => t.matchId === e.matchId) && [t.left, t.right].includes(e.ownerId) && e.resolutionId === null == (e.winnerId === null) || E("unavailable"), e.resolutionId !== null && (D(e.resolutionId), t && [t.left, t.right].includes(e.winnerId) || E("unavailable"));
+	}
+	if (n.erase === null || /^[a-f0-9]{64}$/.test(n.erase.targetDigest) && D(n.erase.requestId) || E("unavailable"), ["erasing", "cancelled"].includes(n.phase) !== (n.erase !== null) && E("unavailable"), n.phase === "cancelled" && !n.withdrawn && E("unavailable"), n.withdrawn) return (!["erasing", "cancelled"].includes(n.phase) || n.provisions.length || n.results.length || n.disputes.length || n.settlement !== null) && E("unavailable"), n;
+	let r = B(n, n.results);
+	for (let e of n.provisions) {
+		let t = r.matches.find((t) => t.id === e.matchId);
+		t && t.left === e.left && t.right === e.right && ["ready", "complete"].includes(t.status) || E("unavailable");
+	}
+	let i = n.disputes.filter((e) => e.resolutionId === null).length;
+	return n.phase !== "erasing" && (n.phase === "paused" ? i === 0 : i !== 0) && E("unavailable"), n.settlement !== null && (r.champion !== n.settlement.winnerId || n.settlement.requestId !== z(t, n.ruleVersion, "champion") || i !== 0) && E("unavailable"), (n.phase === "complete" && n.settlement?.complete !== !0 || n.settlement?.complete && !["complete", "erasing"].includes(n.phase)) && E("unavailable"), n;
+}, K = (e) => {
+	let t = [
+		"epochNow",
+		"authorize",
+		"provisionRoom",
+		"verifyResult",
+		"settleChampion",
+		"withdrawSubject",
+		"withdrawTournament",
+		"authorizeExport"
+	];
+	(!e || Object.getPrototypeOf(e) !== Object.prototype || Object.getOwnPropertySymbols(e).length || Object.entries(Object.getOwnPropertyDescriptors(e)).some(([e, n]) => ![...t, "maxTenantTournaments"].includes(e) || !n.enumerable || !("value" in n)) || t.some((t) => typeof e[t] != "function")) && E("invalid_input");
+	let n = e.maxTenantTournaments ?? 1024;
+	return (!Number.isSafeInteger(n) || n < 1 || n > 4096) && E("invalid_input"), Object.freeze({
+		epochNow: e.epochNow.bind(e),
+		authorize: e.authorize.bind(e),
+		provisionRoom: e.provisionRoom.bind(e),
+		verifyResult: e.verifyResult.bind(e),
+		settleChampion: e.settleChampion.bind(e),
+		withdrawSubject: e.withdrawSubject.bind(e),
+		withdrawTournament: e.withdrawTournament.bind(e),
+		authorizeExport: e.authorizeExport.bind(e),
+		maxTenantTournaments: n
+	});
+}, q = (a, o) => {
+	let s = K(o), c = s.maxTenantTournaments, l = s.epochNow.bind(s), u = s.authorize.bind(s), d = s.provisionRoom.bind(s), p = s.verifyResult.bind(s), g = s.settleChampion.bind(s), y = s.withdrawSubject.bind(s), b = s.withdrawTournament.bind(s), x = s.authorizeExport.bind(s), { seedSubject: S, subjectFence: C, eraseSubjectFence: T } = i(a), j = (n) => f.tryPromise({
+		try: n,
+		catch: (n) => n instanceof e ? n : t("unavailable")
+	}).pipe(f.uninterruptible), I = (n) => {
+		try {
+			return n().pipe(f.uninterruptible);
+		} catch (n) {
+			return f.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, L = (e, t, n) => {
+		let r = m.decodeUnknownSync(m.toType(h))(structuredClone(e));
+		return (n ? !["system", "service"].includes(r.type) : r.type !== "user" || r.id === null || r.tenantId !== t.tenantId) && E("forbidden"), r;
+	}, V = (e) => {
+		let t = A(m.Struct({
+			requestId: m.String,
+			target: m.Struct({
+				tenantId: m.String,
+				subjectId: m.String,
+				kind: m.Literals(["user", "guest"])
+			})
+		}), e);
+		return D(t.requestId), D(t.target.tenantId), D(t.target.subjectId), r(t, 2048);
+	}, H = async (e, t, n = !1) => {
+		let r = await e.query({
+			table: w,
+			predicate: _(v("tenantId", t.tenantId), v("tournamentId", t.tournamentId)),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: void 0,
+			...n ? { lock: "update" } : {}
+		});
+		return r.length !== 1 && E(r.length ? "unavailable" : "not_found"), {
+			row: r[0],
+			state: G(r[0], t)
+		};
+	}, q = async (e, t, n) => {
+		r(n, 65536), G({
+			...t,
+			state: n
+		}, k({
+			tenantId: D(t.tenantId),
+			tournamentId: D(t.tournamentId)
+		})), await e.update("_voltro_brackets", String(t.id), {
+			state: n,
+			updatedAt: new Date(O(l()))
+		}) || E("unavailable");
+	}, J = (e) => {
+		(e.phase === "erasing" || e.phase === "cancelled") && E("erased");
+	}, Y = (e) => {
+		let t = e.withdrawn ? {
+			champion: null,
+			matches: []
+		} : B(e, e.results), n = new Map(e.provisions.filter((e) => e.roomId !== null).map((e) => [e.matchId, e.roomId]));
+		return r({
+			phase: e.phase,
+			format: e.format,
+			champion: t.champion,
+			matches: t.matches.map((e) => ({
+				...e,
+				roomId: n.get(e.id) ?? null
+			})),
+			unresolvedDisputes: e.disputes.filter((e) => e.resolutionId === null).length
+		}, 65536);
+	}, X = (e, t, r = !1) => j(async () => {
+		let i = r ? [] : (await H(a, e)).state.entrants.map((e) => e.entrantId).sort();
+		return a.transactional(async (a) => {
+			for (let t of i) await C(a, e.tenantId, t);
+			let { row: o, state: s } = await H(a, e, !0);
+			return !r && n(s.entrants.map((e) => e.entrantId).sort()) !== n(i) && E("conflict"), t(a, o, s);
+		});
+	}), Z = async (e) => {
+		let t = await a.query({
+			table: w,
+			predicate: v("tenantId", e),
+			order: [],
+			take: c + 1,
+			skip: void 0,
+			projection: void 0
+		});
+		t.length > c && E("limit_exceeded");
+		let n = t.map((t) => {
+			let n = k({
+				tenantId: e,
+				tournamentId: D(t.tournamentId)
+			});
+			return {
+				scope: n,
+				state: G(t, n)
+			};
+		});
+		return W(n, (e) => e.scope.tournamentId), n.sort((e, t) => e.scope.tournamentId < t.scope.tournamentId ? -1 : +(e.scope.tournamentId > t.scope.tournamentId));
+	}, ee = (e) => {
+		let t = A(N, e);
+		for (let e of [
+			"roomId",
+			"matchId",
+			"reportId",
+			"winnerId"
+		]) D(t[e]);
+		return r(t, 2048);
+	}, Q = (e, t) => e.roomId === t.roomId && e.epoch === t.epoch && e.reportId === t.reportId && e.reportedWinnerId === t.winnerId && e.matchId === t.matchId, $ = (e, t) => {
+		J(e), e.phase !== "active" && E("conflict");
+		let n = B(e, e.results).matches.find((e) => e.id === t.matchId), r = e.provisions.find((e) => e.matchId === t.matchId);
+		n && n.status === "ready" && [n.left, n.right].includes(t.winnerId) && r && r.roomId === t.roomId && r.epoch === t.epoch || E("conflict");
+	};
+	return Object.freeze({
+		create: (e, t, r) => I(() => {
+			let i = k(t), o = L(e, i, !0), s = U(r);
+			return u(o, i, "create").pipe(f.flatMap(() => j(async () => {
+				for (let e of s.entrants.map((e) => e.entrantId).sort()) await S(i.tenantId, e);
+				return a.transactional(async (e) => {
+					for (let t of s.entrants.map((e) => e.entrantId).sort()) await C(e, i.tenantId, t);
+					let t = O(l()), r = {
+						...s,
+						version: 1,
+						phase: "active",
+						withdrawn: !1,
+						provisions: [],
+						results: [],
+						disputes: [],
+						settlement: null,
+						erase: null
+					};
+					await e.insertIgnore(w, {
+						...i,
+						state: r,
+						createdAt: new Date(t),
+						updatedAt: new Date(t)
+					}, { conflictColumns: ["tenantId", "tournamentId"] });
+					let a = (await H(e, i)).state;
+					return n({
+						format: a.format,
+						entrants: a.entrants,
+						...a.rounds === void 0 ? {} : { rounds: a.rounds },
+						ruleVersion: a.ruleVersion
+					}) !== n(s) && E("conflict"), J(a), Y(a);
+				});
+			})));
+		}),
+		report: (e, t, n) => I(() => {
+			let r = k(t), i = L(e, r, !0), o = ee(n);
+			return u(i, r, "report").pipe(f.flatMap(() => j(async () => {
+				let { state: e } = await H(a, r);
+				J(e);
+				let t = e.results.find((e) => e.matchId === o.matchId);
+				return t ? (Q(t, o) || E("conflict"), Y(e)) : ($(e, o), null);
+			})), f.flatMap((e) => e === null ? p(i, r, o).pipe(f.flatMap(() => X(r, async (e, t, n) => {
+				J(n);
+				let r = n.results.find((e) => e.matchId === o.matchId);
+				if (r) return Q(r, o) || E("conflict"), Y(n);
+				$(n, o);
+				let i = {
+					...n,
+					results: [...n.results, {
+						...o,
+						reportedWinnerId: o.winnerId
+					}]
+				};
+				return await q(e, t, i), Y(i);
+			}))) : f.succeed(e)));
+		}),
+		dispute: (e, t, n) => I(() => {
+			let r = k(t), i = L(e, r, !1), a = A(P, n);
+			return D(a.disputeId), D(a.matchId), u(i, r, "dispute").pipe(f.flatMap(() => X(r, async (e, t, n) => {
+				J(n);
+				let r = n.disputes.find((e) => e.disputeId === a.disputeId);
+				if (r) return (r.ownerId !== i.id || r.matchId !== a.matchId || r.reason !== a.reason) && E("conflict"), Y(n);
+				let o = n.provisions.find((e) => e.matchId === a.matchId);
+				n.settlement === null && o && [o.left, o.right].includes(i.id) && n.results.some((e) => e.matchId === a.matchId) && !n.disputes.some((e) => e.matchId === a.matchId && e.ownerId === i.id) || E("conflict");
+				let s = {
+					...n,
+					phase: "paused",
+					disputes: [...n.disputes, {
+						...a,
+						ownerId: i.id,
+						resolutionId: null,
+						winnerId: null
+					}]
+				};
+				return await q(e, t, s), Y(s);
+			})));
+		}),
+		resolve: (e, t, n) => I(() => {
+			let r = k(t), i = L(e, r, !0), a = A(F, n);
+			return D(a.disputeId), D(a.resolutionId), D(a.winnerId), u(i, r, "resolve").pipe(f.flatMap(() => X(r, async (e, t, n) => {
+				J(n);
+				let r = n.disputes.find((e) => e.disputeId === a.disputeId);
+				if (r || E("not_found"), r.resolutionId !== null) return (r.resolutionId !== a.resolutionId || r.winnerId !== a.winnerId) && E("conflict"), Y(n);
+				(n.phase !== "paused" || n.settlement !== null || n.disputes.some((e) => e.resolutionId === a.resolutionId)) && E("conflict");
+				let i = n.disputes.map((e) => e.disputeId === a.disputeId ? {
+					...e,
+					resolutionId: a.resolutionId,
+					winnerId: a.winnerId
+				} : e), o = {
+					...n,
+					disputes: i,
+					phase: i.some((e) => e.resolutionId === null) ? "paused" : "active",
+					results: n.results.map((e) => e.matchId === r.matchId ? {
+						...e,
+						winnerId: a.winnerId
+					} : e)
+				};
+				return await q(e, t, o), Y(o);
+			})));
+		}),
+		advance: (n, r) => I(() => {
+			let i = k(r), o = L(n, i, !0);
+			return u(o, i, "advance").pipe(f.flatMap(() => X(i, async (e, t, n) => {
+				if (J(n), n.phase === "complete") return { kind: "idle" };
+				n.phase !== "active" && E("conflict");
+				let r = B(n, n.results);
+				if (r.champion !== null) {
+					let a = n.settlement ?? {
+						requestId: z(i, n.ruleVersion, "champion"),
+						winnerId: r.champion,
+						complete: !1
+					};
+					return n.settlement === null && await q(e, t, {
+						...n,
+						settlement: a
+					}), {
+						kind: "settle",
+						work: {
+							...i,
+							requestId: a.requestId,
+							winnerId: a.winnerId,
+							ruleVersion: n.ruleVersion
+						}
+					};
+				}
+				let a = r.matches.find((e) => e.status === "ready" && !n.provisions.some((t) => t.matchId === e.id && t.roomId !== null));
+				if (!a || a.left === null || a.right === null) return { kind: "idle" };
+				let o = n.provisions.find((e) => e.matchId === a.id), s = o ?? {
+					...i,
+					matchId: a.id,
+					requestId: z(i, n.ruleVersion, "room:" + a.id),
+					left: a.left,
+					right: a.right,
+					ruleVersion: n.ruleVersion,
+					roomId: null,
+					epoch: null
+				};
+				return o || await q(e, t, {
+					...n,
+					provisions: [...n.provisions, s]
+				}), {
+					kind: "room",
+					work: {
+						...i,
+						matchId: s.matchId,
+						requestId: s.requestId,
+						left: s.left,
+						right: s.right,
+						ruleVersion: s.ruleVersion
+					}
+				};
+			})), f.flatMap((n) => n.kind === "idle" ? j(async () => Y((await H(a, i)).state)) : n.kind === "settle" ? g(n.work).pipe(f.flatMap(() => X(i, async (e, t, r) => {
+				if (J(r), r.phase === "complete" && r.settlement?.requestId === n.work.requestId) return Y(r);
+				(r.phase !== "active" || r.settlement?.requestId !== n.work.requestId || r.settlement.winnerId !== n.work.winnerId) && E("conflict");
+				let i = {
+					...r,
+					phase: "complete",
+					settlement: {
+						...r.settlement,
+						complete: !0
+					}
+				};
+				return await q(e, t, i), Y(i);
+			}))) : d(n.work).pipe(f.flatMap((n) => f.try({
+				try: () => {
+					let e = A(M, n);
+					return D(e.roomId), e;
+				},
+				catch: (n) => n instanceof e ? n : t("invalid_input")
+			})), f.flatMap((e) => X(i, async (t, r, i) => {
+				J(i);
+				let a = i.provisions.find((e) => e.requestId === n.work.requestId);
+				if (i.phase === "active" && a || E("conflict"), a.roomId !== null) return (a.roomId !== e.roomId || a.epoch !== e.epoch) && E("conflict"), Y(i);
+				let o = {
+					...i,
+					provisions: i.provisions.map((t) => t.requestId === n.work.requestId ? {
+						...t,
+						...e
+					} : t)
+				};
+				return await q(t, r, o), Y(o);
+			})))));
+		}),
+		status: (e, t) => I(() => {
+			let n = k(t), r = L(e, n, !0);
+			return u(r, n, "status").pipe(f.flatMap(() => j(async () => Y((await H(a, n)).state))));
+		}),
+		exportSubject: (e) => I(() => {
+			let t = V(e);
+			return x(t).pipe(f.flatMap(() => j(async () => (await Z(t.target.tenantId)).flatMap(({ scope: e, state: n }) => {
+				let r = n.entrants.find((e) => e.entrantId === t.target.subjectId);
+				return r ? [{
+					tournamentId: e.tournamentId,
+					phase: n.phase,
+					seed: r.seed,
+					matches: n.results.filter((e) => n.provisions.some((t) => t.matchId === e.matchId && [t.left, t.right].includes(r.entrantId))).map((e) => ({
+						matchId: e.matchId,
+						roomId: e.roomId,
+						won: e.winnerId === r.entrantId
+					})),
+					disputes: n.disputes.filter((e) => e.ownerId === r.entrantId).map((e) => ({
+						disputeId: e.disputeId,
+						matchId: e.matchId,
+						reason: e.reason,
+						resolutionId: e.resolutionId
+					}))
+				}] : [];
+			}))));
+		}),
+		eraseSubject: (e) => I(() => {
+			let t = V(e), n = R(t.target);
+			return y(t).pipe(f.flatMap(() => j(() => T(t.target.tenantId, t.target.subjectId))), f.flatMap(() => j(() => Z(t.target.tenantId))), f.flatMap((e) => f.forEach(e.filter(({ state: e }) => e.entrants.some((e) => e.entrantId === t.target.subjectId) || e.erase?.requestId === t.requestId && e.erase.targetDigest === n), ({ scope: e }) => X(e, async (e, r, i) => i.phase === "cancelled" && i.erase?.requestId === t.requestId && i.erase.targetDigest === n && !i.entrants.some((e) => e.entrantId === t.target.subjectId) || (i.phase === "erasing" && (i.erase?.requestId !== t.requestId || i.erase.targetDigest !== n) && E("conflict"), i.entrants.some((e) => e.entrantId === t.target.subjectId) || E("unavailable"), await q(e, r, {
+				...i,
+				phase: "erasing",
+				erase: {
+					requestId: t.requestId,
+					targetDigest: n
+				}
+			}), !1), !0).pipe(f.flatMap((r) => r ? f.void : b(e, t).pipe(f.flatMap(() => X(e, async (e, r, i) => {
+				(i.phase !== "erasing" || i.erase?.requestId !== t.requestId || i.erase.targetDigest !== n) && E("conflict"), await q(e, r, {
+					...i,
+					phase: "cancelled",
+					withdrawn: !0,
+					entrants: i.entrants.filter((e) => e.entrantId !== t.target.subjectId),
+					provisions: [],
+					results: [],
+					disputes: [],
+					settlement: null
+				});
+			}, !0))))), {
+				concurrency: 1,
+				discard: !0
+			})));
+		})
+	});
+}, J = (e, t) => p.succeed(a, q(e, t));
+export { w as TOURNAMENT_BRACKETS_TABLE, q as dataStoreTournamentBrackets, K as resolveTournamentBracketOptions, J as tournamentBracketLayer, T as tournamentBracketsTable };

package/dist/brackets.d.ts

@@ -0,0 +1,149 @@
+export declare const advanceDoubleElimination: (input: DoubleEliminationBracket, inputResults: ReadonlyArray<BracketResult>, config?: Partial<TournamentPairingLimits>) => DoubleEliminationProgress;
+
+/** Round robin as a bracket: every pair once (circle schedule), all matches ready from the
+ * start. The champion is known once every match is complete (a win is one point). */
+export declare const advanceRoundRobin: (input: ReadonlyArray<TournamentEntrant>, inputResults: ReadonlyArray<BracketResult>, config?: Partial<TournamentPairingLimits>) => BracketProgress;
+
+/** Rebuilds and verifies the canonical graph from its roster before advancing.
+ * Results are trusted server facts supplied by a later SQL/Room coordinator. */
+export declare const advanceSingleElimination: (input: SingleEliminationBracket, inputResults: ReadonlyArray<BracketResult>, config?: Partial<TournamentPairingLimits>) => BracketProgress;
+
+/** Swiss as a bracket: round r is paired (no rematches, close scores first) once round r-1 is
+ * complete; an odd roster gives one bye per round (a walkover, worth a win). After `rounds`
+ * complete rounds the champion is the points leader. */
+export declare const advanceSwiss: (input: ReadonlyArray<TournamentEntrant>, inputResults: ReadonlyArray<BracketResult>, rounds: number, config?: Partial<TournamentPairingLimits>) => BracketProgress;
+
+export declare interface BracketMatchObservation {
+    readonly id: string;
+    readonly round: number;
+    readonly left: string | null;
+    readonly right: string | null;
+    readonly status: 'pending' | 'ready' | 'walkover' | 'complete';
+    readonly winnerId: string | null;
+}
+
+export declare interface BracketProgress {
+    readonly matches: ReadonlyArray<BracketMatchObservation>;
+    readonly champion: string | null;
+}
+
+export declare interface BracketResult {
+    readonly matchId: string;
+    readonly winnerId: string;
+}
+
+export declare type BracketSlot = {
+    readonly kind: 'entrant';
+    readonly entrantId: string;
+} | {
+    readonly kind: 'winner';
+    readonly matchId: string;
+} | {
+    readonly kind: 'bye';
+};
+
+export declare interface DoubleEliminationBracket {
+    readonly format: 'double-elimination';
+    readonly version: 1;
+    readonly entrants: ReadonlyArray<TournamentEntrant>;
+    readonly matches: ReadonlyArray<DoubleEliminationMatch>;
+}
+
+export declare interface DoubleEliminationMatch {
+    readonly id: string;
+    readonly stage: 'winners' | 'losers' | 'final' | 'reset';
+    readonly round: number;
+    readonly left: DoubleEliminationSlot;
+    readonly right: DoubleEliminationSlot;
+}
+
+export declare interface DoubleEliminationObservation extends Omit<BracketMatchObservation, 'status'> {
+    readonly stage: DoubleEliminationMatch['stage'];
+    readonly status: BracketMatchObservation['status'] | 'empty' | 'inactive';
+    readonly loserId: string | null;
+}
+
+export declare interface DoubleEliminationProgress {
+    readonly matches: ReadonlyArray<DoubleEliminationObservation>;
+    readonly champion: string | null;
+    readonly losses: ReadonlyArray<{
+        readonly entrantId: string;
+        readonly losses: number;
+    }>;
+}
+
+export declare type DoubleEliminationSlot = BracketSlot | {
+    readonly kind: 'loser';
+    readonly matchId: string;
+};
+
+/** Circle schedule, fixed first seed, whole roster and one bye per odd round.
+ * The return value is a plan; it creates no Room or result authority. */
+export declare const roundRobin: (input: ReadonlyArray<TournamentEntrant>, options?: {
+    readonly doubleRound?: boolean;
+    readonly limits?: Partial<TournamentPairingLimits>;
+}) => ReadonlyArray<RoundRobinRound>;
+
+export declare interface RoundRobinRound {
+    readonly round: number;
+    readonly pairs: ReadonlyArray<TournamentPair>;
+    readonly bye: string | null;
+}
+
+/** Winners use the same mirrored seeds. Losers alternate cross-dropped winners
+ * losses and consolidation rounds. Grand Final resets only when the lower
+ * bracket finalist wins its first game against the undefeated finalist. */
+export declare const seedDoubleElimination: (input: ReadonlyArray<TournamentEntrant>, config?: Partial<TournamentPairingLimits>) => DoubleEliminationBracket;
+
+export declare const seedSingleElimination: (input: ReadonlyArray<TournamentEntrant>, config?: Partial<TournamentPairingLimits>) => SingleEliminationBracket;
+
+export declare interface SingleEliminationBracket {
+    readonly format: 'single-elimination';
+    readonly version: 1;
+    readonly entrants: ReadonlyArray<TournamentEntrant>;
+    readonly matches: ReadonlyArray<SingleEliminationMatch>;
+}
+
+export declare interface SingleEliminationMatch {
+    readonly id: string;
+    readonly round: number;
+    readonly left: BracketSlot;
+    readonly right: BracketSlot;
+}
+
+export declare interface SwissPairing {
+    readonly pairs: ReadonlyArray<TournamentPair>;
+    readonly bye: string | null;
+    readonly searchNodes: number;
+}
+
+/** Ordered bounded backtracking. Prioritizes close scores then seed distance;
+ * finds the first complete no-rematch assignment, not a federation algorithm or
+ * a globally optimal pairing. No partial result escapes budget exhaustion. */
+export declare const swissPairings: (input: ReadonlyArray<SwissStanding>, config?: Partial<TournamentPairingLimits>) => SwissPairing;
+
+export declare interface SwissStanding extends TournamentEntrant {
+    /** Whole scoring units selected by the studio (for example win2/draw1). */
+    readonly points: number;
+    readonly byes: number;
+    readonly opponents: ReadonlyArray<string>;
+}
+
+export declare interface TournamentEntrant {
+    readonly entrantId: string;
+    readonly seed: number;
+}
+
+export declare interface TournamentPair {
+    readonly left: string;
+    readonly right: string;
+}
+
+export declare interface TournamentPairingLimits {
+    readonly maxEntrants: number;
+    readonly maxMatches: number;
+    readonly maxSearchNodes: number;
+    readonly maxInputBytes: number;
+}
+
+export { }