@voltro/plugin-leaderboards 0.0.0-stage → 0.88.0

package/dist/tournamentStage.js

@@ -0,0 +1,150 @@
+import { LeaderboardError as e, leaderboardError as t } from "./errors.js";
+import { canonicalLeaderboardJson as n, captureLeaderboardJson as r } from "./json.js";
+import { TournamentStagePayload as i, TournamentWorkflowSummary as a } from "./tournamentWorkflowSchemas.js";
+import { MyBracketMatchesSchema as o, TournamentBracketViewSchema as s } from "./rpc.js";
+import { TournamentStagePort as c } from "./tournamentStagePorts.js";
+import { readBracketAdmissionWindow as l } from "./bracketAdmission.js";
+import { Effect as u, Layer as d, Schema as f } from "effect";
+import { Subject as p } from "@voltro/protocol";
+import { createHash as m } from "node:crypto";
+// src/tournamentStage.ts
+var h = (e) => {
+	if (!e || !Array.isArray(e.matches) || e.matches.length > 127 || new Set(e.matches.map((e) => e.id)).size !== e.matches.length) throw t("unavailable");
+	for (let n of e.matches) if (!n || typeof n.id != "string" || !n.id.length || n.id.length > 120 || !Number.isSafeInteger(n.round) || n.round < 1 || n.round > 128 || ![
+		"pending",
+		"ready",
+		"walkover",
+		"complete",
+		"empty",
+		"inactive"
+	].includes(n.status) || n.left !== null && (typeof n.left != "string" || !n.left.length) || n.right !== null && (typeof n.right != "string" || !n.right.length) || n.status === "ready" && (n.left === null || n.right === null || n.winnerId !== null) || ["complete", "walkover"].includes(n.status) && (n.winnerId === null || ![n.left, n.right].includes(n.winnerId)) || !["complete", "walkover"].includes(n.status) && n.winnerId !== null || n.roomId !== null && (typeof n.roomId != "string" || !n.roomId.length)) throw t("unavailable");
+	return f.decodeUnknownSync(f.toType(a))({
+		phase: e.phase,
+		ready: e.matches.filter((e) => e.status === "ready").length,
+		completed: e.matches.filter((e) => e.status === "complete" || e.status === "walkover").length,
+		waiting: e.matches.filter((e) => e.status === "ready" && e.roomId === null).length + +(e.phase === "active" && e.champion !== null),
+		unresolvedDisputes: e.unresolvedDisputes
+	});
+}, g = (e, t) => (h(e), f.decodeUnknownSync(f.toType(o))({
+	phase: e.phase,
+	champion: e.champion === t,
+	matches: e.matches.filter((e) => e.left === t || e.right === t).map((e) => ({
+		matchId: e.id,
+		round: e.round,
+		status: e.status,
+		opponentId: e.left === t ? e.right : e.left,
+		roomId: e.roomId,
+		won: e.winnerId === null ? null : e.winnerId === t
+	}))
+})), _ = (e) => (h(e), f.decodeUnknownSync(f.toType(s))({
+	phase: e.phase,
+	format: e.format,
+	champion: e.champion,
+	matches: e.matches.map((e) => ({
+		matchId: e.id,
+		round: e.round,
+		status: e.status,
+		left: e.left,
+		right: e.right,
+		winnerId: e.winnerId
+	}))
+})), v = (e) => {
+	let n = [
+		"epochNow",
+		"authorize",
+		"seedRoster",
+		"notifyEntrants",
+		"admissions",
+		"brackets"
+	];
+	if (!e || Object.getPrototypeOf(e) !== Object.prototype || Object.getOwnPropertySymbols(e).length || Object.entries(Object.getOwnPropertyDescriptors(e)).some(([e, t]) => !n.some((t) => t === e) || !t.enumerable || !("value" in t)) || n.slice(0, 4).some((t) => typeof e[t] != "function") || !e.admissions || !e.brackets) throw t("invalid_input");
+	for (let [n, r] of [[e.admissions, "seal"], [e.brackets, "create"]]) {
+		let e = Object.getOwnPropertyDescriptor(n, r);
+		if (!e || !("value" in e) || typeof e.value != "function") throw t("invalid_input");
+	}
+	return Object.freeze({
+		epochNow: e.epochNow.bind(e),
+		authorize: e.authorize.bind(e),
+		seedRoster: e.seedRoster.bind(e),
+		notifyEntrants: e.notifyEntrants.bind(e),
+		admissions: Object.freeze({ seal: e.admissions.seal.bind(e.admissions) }),
+		brackets: Object.freeze({ create: e.brackets.create.bind(e.brackets) })
+	});
+}, y = (a, o) => {
+	let s = v(o), c = s.epochNow, d = s.authorize, g = s.seedRoster, _ = s.notifyEntrants, y = s.admissions.seal.bind(s.admissions), b = s.brackets.create.bind(s.brackets), x = (e, n) => {
+		let a = f.decodeUnknownSync(f.toType(p))(structuredClone(e)), o = f.decodeUnknownSync(i)(r(n, 2048), { onExcessProperty: "error" });
+		if (a.type !== "system" && a.type !== "service") throw t("forbidden");
+		return {
+			who: a,
+			payload: Object.freeze(o),
+			scope: Object.freeze({
+				tenantId: o.tenantId,
+				tournamentId: o.tournamentId
+			})
+		};
+	}, S = (e, t) => "tstage:" + m("sha256").update(n([
+		e.tenantId,
+		e.tournamentId,
+		e.format,
+		e.ruleVersion,
+		t
+	])).digest("hex"), C = (n) => {
+		try {
+			return n().pipe(u.uninterruptible);
+		} catch (n) {
+			return u.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	};
+	return Object.freeze({
+		window: (e, n) => C(() => {
+			let { who: r, scope: i } = x(e, n);
+			return d(r, i, "window").pipe(u.flatMap(() => l(a, i)), u.flatMap((e) => ["erasing", "cancelled"].includes(e.phase) ? u.fail(t("erased")) : u.succeed(e.definition)));
+		}),
+		notify: (e, n, r) => C(() => {
+			let { who: i, payload: o, scope: s } = x(e, n);
+			if (r !== "registration" && r !== "check-in") throw t("invalid_input");
+			return d(i, s, "notify").pipe(u.flatMap(() => l(a, s)), u.flatMap((e) => u.try({
+				try: () => {
+					let n = c();
+					if (!Number.isSafeInteger(n) || n < 0 || n > 864e13) throw t("unavailable");
+					let i = r === "registration" ? e.definition.registrationOpensAt : e.definition.checkInOpensAt, a = r === "registration" ? e.definition.registrationClosesAt : e.definition.checkInClosesAt;
+					return e.phase === "open" && n >= i && n < a;
+				},
+				catch: () => t("unavailable")
+			})), u.flatMap((e) => e ? _(Object.freeze({
+				...o,
+				phase: r,
+				requestId: S(o, "notify:" + r)
+			})).pipe(u.as({ notified: !0 })) : u.succeed({ notified: !1 })));
+		}),
+		seed: (i, a) => C(() => {
+			let { who: o, payload: s, scope: c } = x(i, a), l = (i) => g(r({
+				...s,
+				...i,
+				requestId: S(s, "seed")
+			}, 65536)).pipe(u.flatMap((a) => u.try({
+				try: () => {
+					let e = r(a, 16384), o = [...i.checkedIn].sort();
+					if (!Array.isArray(e) || e.length !== o.length || n(e.map((e) => e.entrantId).sort()) !== n(o)) throw t("conflict");
+					return {
+						format: s.format,
+						ruleVersion: s.ruleVersion,
+						entrants: e
+					};
+				},
+				catch: (n) => n instanceof e ? n : t("invalid_input")
+			})), u.flatMap((e) => b(o, c, e)), u.flatMap((e) => u.try({
+				try: () => h(e),
+				catch: () => t("unavailable")
+			}))), f = Object.freeze({
+				phase: "cancelled",
+				ready: 0,
+				completed: 0,
+				waiting: 0,
+				unresolvedDisputes: 0
+			});
+			return d(o, c, "seed").pipe(u.flatMap(() => y(o, c)), u.flatMap((e) => e.checkedIn.length < 2 ? u.succeed(f) : l(e)));
+		})
+	});
+}, b = (e, t) => d.succeed(c, y(e, t));
+export { y as dataStoreTournamentStages, g as myBracketMatches, v as resolveTournamentStageOptions, h as summarizeTournamentStatus, _ as tournamentBracketView, b as tournamentStageLayer };

package/dist/tournamentStagePorts.js

@@ -0,0 +1,4 @@
+import { Context as e } from "effect";
+// src/tournamentStagePorts.ts
+var t = class extends e.Service()("@voltro/TournamentStagePort") {};
+export { t as TournamentStagePort };

package/dist/tournamentWorkflow.js

@@ -0,0 +1,100 @@
+import { LeaderboardError as e, leaderboardError as t } from "./errors.js";
+import { captureLeaderboardJson as n } from "./json.js";
+import { TournamentAdvancePayload as r, TournamentStageNotification as i, TournamentStagePayload as a, TournamentStageWindow as o, TournamentWorkflowSummary as s } from "./tournamentWorkflowSchemas.js";
+import { TournamentBracketPort as c } from "./bracketMatchPorts.js";
+import { TournamentStagePort as l } from "./tournamentStagePorts.js";
+import { summarizeTournamentStatus as u } from "./tournamentStage.js";
+import { Effect as d, Schema as f } from "effect";
+import { Subject as p } from "@voltro/protocol";
+import { fileURLToPath as m } from "node:url";
+import { sleepUntil as h, step as g } from "@voltro/workflow";
+// src/tournamentWorkflow.ts
+var _ = m(new URL("./tournament-app", "" + import.meta.url)), v = (e) => (i) => {
+	let a, o;
+	try {
+		a = f.decodeUnknownSync(r)(n(i, 2048), { onExcessProperty: "error" }), o = f.decodeUnknownSync(f.toType(p))(structuredClone(e.request.subject));
+	} catch {
+		return d.fail(t("invalid_input"));
+	}
+	return y(o, a, void 0);
+}, y = (n, r, i) => d.gen(function* () {
+	let a = yield* c, o = Object.freeze({
+		tenantId: r.tenantId,
+		tournamentId: r.tournamentId
+	}), l = i;
+	for (let i = 1; i <= 129 && (l === void 0 || l.phase === "active" && l.waiting > 0); i++) {
+		let c = yield* g({
+			name: "advance-" + i,
+			input: r,
+			success: s,
+			error: e,
+			execute: a.advance(n, o).pipe(d.flatMap((e) => d.try({
+				try: () => u(e),
+				catch: () => t("unavailable")
+			})))
+		}), f = l !== void 0 && c.waiting >= l.waiting;
+		if (l = c, f) break;
+	}
+	return l;
+}), b = (r) => (c) => {
+	let u, m;
+	try {
+		u = f.decodeUnknownSync(a)(n(c, 2048), { onExcessProperty: "error" }), m = f.decodeUnknownSync(f.toType(p))(structuredClone(r.request.subject));
+	} catch {
+		return d.fail(t("invalid_input"));
+	}
+	return d.gen(function* () {
+		let t = yield* l, n = yield* g({
+			name: "load-admission-window",
+			input: u,
+			success: o,
+			error: e,
+			execute: t.window(m, u)
+		});
+		yield* h({
+			name: "registration-opens",
+			until: n.registrationOpensAt
+		}), yield* g({
+			name: "notify-registration",
+			input: u,
+			success: i,
+			error: e,
+			execute: t.notify(m, u, "registration")
+		}), yield* h({
+			name: "check-in-opens",
+			until: n.checkInOpensAt
+		}), yield* g({
+			name: "notify-check-in",
+			input: u,
+			success: i,
+			error: e,
+			execute: t.notify(m, u, "check-in")
+		}), yield* h({
+			name: "check-in-closes",
+			until: n.checkInClosesAt
+		});
+		let r = yield* g({
+			name: "seal-and-seed",
+			input: u,
+			success: s,
+			error: e,
+			execute: t.seed(m, u)
+		});
+		return yield* y(m, {
+			tenantId: u.tenantId,
+			tournamentId: u.tournamentId,
+			runKey: u.runKey
+		}, r);
+	});
+}, x = (e, n, r, i, a) => d.suspend(() => {
+	let o = e?.workflows;
+	return !o || typeof o.start != "function" ? d.fail(t("unavailable")) : n.report(r, i, a).pipe(d.tap(() => d.tryPromise({
+		try: () => o.start("tournament.advance", {
+			tenantId: i.tenantId,
+			tournamentId: i.tournamentId,
+			runKey: a.reportId
+		}),
+		catch: () => t("unavailable")
+	})));
+});
+export { _ as leaderboardsTournamentSources, x as reportTournamentResult, v as tournamentAdvanceExecutor, b as tournamentStageExecutor };

package/dist/tournamentWorkflowSchemas.js

@@ -0,0 +1,53 @@
+import { Schema as e } from "effect";
+// src/tournamentWorkflowSchemas.ts
+var t = e.String.pipe(e.check(e.isMinLength(1)), e.check(e.isMaxLength(120)), e.check(e.makeFilter((e) => e.trim() === e && e.isWellFormed() && !/[\u0000-\u001f\u007f]/.test(e)))), n = e.Int.pipe(e.check(e.isBetween({
+	minimum: 0,
+	maximum: 864e13
+}))), r = e.Struct({
+	tenantId: t,
+	tournamentId: t,
+	runKey: t
+}), i = e.Struct({
+	...r.fields,
+	format: e.Literals([
+		"single-elimination",
+		"double-elimination",
+		"round-robin",
+		"swiss"
+	]),
+	ruleVersion: t
+}), a = e.Struct({
+	phase: e.Literals([
+		"active",
+		"paused",
+		"complete",
+		"erasing",
+		"cancelled"
+	]),
+	ready: e.Int.pipe(e.check(e.isBetween({
+		minimum: 0,
+		maximum: 127
+	}))),
+	completed: e.Int.pipe(e.check(e.isBetween({
+		minimum: 0,
+		maximum: 127
+	}))),
+	waiting: e.Int.pipe(e.check(e.isBetween({
+		minimum: 0,
+		maximum: 128
+	}))),
+	unresolvedDisputes: e.Int.pipe(e.check(e.isBetween({
+		minimum: 0,
+		maximum: 254
+	})))
+}), o = e.Struct({
+	registrationOpensAt: n,
+	registrationClosesAt: n,
+	checkInOpensAt: n,
+	checkInClosesAt: n,
+	maxEntries: e.Int.pipe(e.check(e.isBetween({
+		minimum: 2,
+		maximum: 256
+	})))
+}).pipe(e.check(e.makeFilter((e) => e.registrationOpensAt < e.registrationClosesAt && e.registrationClosesAt <= e.checkInOpensAt && e.checkInOpensAt < e.checkInClosesAt))), s = e.Struct({ notified: e.Boolean });
+export { r as TournamentAdvancePayload, s as TournamentStageNotification, i as TournamentStagePayload, o as TournamentStageWindow, a as TournamentWorkflowSummary };

package/dist/tournaments.d.ts

@@ -0,0 +1,32 @@
+export declare interface BracketAdmissionDefinition {
+    readonly registrationOpensAt: number;
+    readonly registrationClosesAt: number;
+    readonly checkInOpensAt: number;
+    readonly checkInClosesAt: number;
+    readonly maxEntries: number;
+}
+
+/** Author-owned windows and bounded roster only; no schedule or price guessed. */
+export declare const defineBracketAdmission: (input: BracketAdmissionDefinition) => BracketAdmissionDefinition;
+
+/** Declarative entry/attempt budgets only. No price, prize or reward is invented. */
+export declare const defineTournament: (input: TournamentDefinition) => TournamentDescriptor;
+
+export declare interface TournamentDefinition {
+    readonly name: string;
+    readonly board: string;
+    readonly startsAt: number;
+    readonly endsAt: number;
+    readonly maxEntries: number;
+    readonly joinRequired?: boolean;
+    readonly attemptsPerEntry?: number;
+}
+
+export declare interface TournamentDescriptor extends Omit<TournamentDefinition, 'joinRequired' | 'attemptsPerEntry'> {
+    readonly kind: 'tournament';
+    readonly format: 'time-window';
+    readonly joinRequired: boolean;
+    readonly attemptsPerEntry: number;
+}
+
+export { }

package/dist/tournaments.js

@@ -0,0 +1,20 @@
+import { leaderboardError as e } from "./errors.js";
+import { leaderboardIdentifier as t } from "./leaderboard.js";
+import { defineBracketAdmission as n } from "./bracketAdmissionPolicy.js";
+// src/tournaments.ts
+var r = (n) => {
+	let r = n?.attemptsPerEntry ?? 1, i = n?.joinRequired ?? !0;
+	if (!n || !t(n.name) || !t(n.board) || !Number.isSafeInteger(n.startsAt) || n.startsAt < 0 || !Number.isSafeInteger(n.endsAt) || n.endsAt > 864e13 || n.endsAt <= n.startsAt || !Number.isSafeInteger(n.maxEntries) || n.maxEntries < 1 || n.maxEntries > 1e6 || !Number.isSafeInteger(r) || r < 1 || r > 2147483647 || typeof i != "boolean") throw e("invalid_input");
+	return Object.freeze({
+		kind: "tournament",
+		format: "time-window",
+		name: n.name,
+		board: n.board,
+		startsAt: n.startsAt,
+		endsAt: n.endsAt,
+		maxEntries: n.maxEntries,
+		joinRequired: i,
+		attemptsPerEntry: r
+	});
+};
+export { n as defineBracketAdmission, r as defineTournament };

package/dist/web.d.ts

@@ -0,0 +1,175 @@
+import { ActionState } from '@voltro/client';
+import { Schema } from 'effect';
+import { SubscriptionState } from '@voltro/client';
+
+export declare interface LeaderboardRankedView extends LeaderboardRecord {
+    readonly rank: number;
+}
+
+declare type LeaderboardRecord = typeof LeaderboardRecordSchema.Type;
+
+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 const useBracketAdmissionStatus: (tournamentId: string, apiName?: string) => SubscriptionState<{
+    readonly phase: "open" | "cancelled" | "erasing" | "sealed";
+    readonly entries: number;
+    readonly checkedIn: number;
+    readonly own: {
+        readonly ownerId: string;
+        readonly joinedAt: number;
+        readonly checkedInAt: number | null;
+    } | null;
+} | null>;
+
+export declare const useCheckInBracket: (apiName?: string) => ActionState<{
+    tournamentId: string;
+}, {
+    readonly phase: "open" | "cancelled" | "erasing" | "sealed";
+    readonly entries: number;
+    readonly checkedIn: number;
+    readonly own: {
+        readonly ownerId: string;
+        readonly joinedAt: number;
+        readonly checkedInAt: number | null;
+    } | null;
+}>;
+
+export declare const useDisputeBracket: (apiName?: string) => ActionState<{
+    readonly tournamentId: string;
+    readonly matchId: string;
+    readonly disputeId: string;
+    readonly reason: "connection" | "result_mismatch" | "no_show";
+}, {
+    readonly phase: "cancelled" | "complete" | "active" | "paused" | "erasing";
+    readonly ready: number;
+    readonly completed: number;
+    readonly waiting: number;
+    readonly unresolvedDisputes: number;
+}>;
+
+export declare const useJoinLeaderboardTournament: (apiName?: string) => ActionState<{
+    tournament: string;
+}, {
+    readonly tournament: string;
+    readonly joinedAt: number;
+    readonly attemptsLeft: number;
+}>;
+
+export declare const useLeaderboardAround: (board: string, radius?: number, apiName?: string) => SubscriptionState<readonly LeaderboardRankedView[]>;
+
+export declare const useLeaderboardHistory: (board: string, limit?: number, apiName?: string) => SubscriptionState<readonly {
+    readonly id: string;
+    readonly board: string;
+    readonly startsAt: number;
+    readonly endsAt: number | null;
+    readonly state: "closed" | "active" | "archived";
+    readonly summary: {
+        readonly participants: number;
+        readonly top: readonly {
+            readonly id: string;
+            readonly tenantId: string;
+            readonly board: string;
+            readonly periodId: string;
+            readonly ownerId: string;
+            readonly score: string;
+            readonly subscore: string;
+            readonly updatedAt: number;
+            readonly rank: number;
+        }[];
+    } | null;
+}[]>;
+
+export declare const useLeaderboardMe: (board: string, apiName?: string) => SubscriptionState<LeaderboardRankedView | null>;
+
+export declare const useLeaderboardTop: (board: string, limit?: number, apiName?: string, scope?: "global" | "bucket") => SubscriptionState<readonly LeaderboardRankedView[]>;
+
+export declare const useLeaderboardTournamentStatus: (tournament: string, apiName?: string) => SubscriptionState<{
+    readonly tournament: string;
+    readonly board: string;
+    readonly startsAt: number;
+    readonly endsAt: number;
+    readonly observedAt: number;
+    readonly joinRequired: boolean;
+    readonly state: "open" | "upcoming" | "ended";
+    readonly entry: {
+        readonly tournament: string;
+        readonly joinedAt: number;
+        readonly attemptsLeft: number;
+    } | null;
+}>;
+
+/** The caller's own bracket matches, live: opponent, Room once provisioned, result; `null`
+ * until the bracket exists. */
+export declare const useMyBracketMatches: (tournamentId: string, apiName?: string) => SubscriptionState<{
+    readonly phase: "cancelled" | "complete" | "active" | "paused" | "erasing";
+    readonly champion: boolean;
+    readonly matches: readonly {
+        readonly matchId: string;
+        readonly round: number;
+        readonly status: "ready" | "empty" | "pending" | "complete" | "walkover" | "inactive";
+        readonly opponentId: string | null;
+        readonly roomId: string | null;
+        readonly won: boolean | null;
+    }[];
+} | null>;
+
+export declare const useMyLeaderboardRating: (pool: string, apiName?: string) => SubscriptionState<{
+    readonly pool: string;
+    readonly state: {
+        readonly algorithm: "elo";
+        readonly rating: number;
+    } | {
+        readonly algorithm: "openskill";
+        readonly mu: number;
+        readonly sigma: number;
+    } | {
+        readonly algorithm: "glicko2";
+        readonly rating: number;
+        readonly deviation: number;
+        readonly volatility: number;
+    };
+    readonly games: number;
+    readonly updatedAt: number | null;
+}>;
+
+export declare const useRegisterBracket: (apiName?: string) => ActionState<{
+    tournamentId: string;
+}, {
+    readonly phase: "open" | "cancelled" | "erasing" | "sealed";
+    readonly entries: number;
+    readonly checkedIn: number;
+    readonly own: {
+        readonly ownerId: string;
+        readonly joinedAt: number;
+        readonly checkedInAt: number | null;
+    } | null;
+}>;
+
+/** The whole bracket, live: rounds, pairings, results and the champion (no Room IDs); `null`
+ * until the bracket exists. */
+export declare const useTournamentBracket: (tournamentId: string, apiName?: string) => SubscriptionState<{
+    readonly phase: "cancelled" | "complete" | "active" | "paused" | "erasing";
+    readonly format: "single-elimination" | "double-elimination" | "round-robin" | "swiss";
+    readonly champion: string | null;
+    readonly matches: readonly {
+        readonly matchId: string;
+        readonly round: number;
+        readonly status: "ready" | "empty" | "pending" | "complete" | "walkover" | "inactive";
+        readonly left: string | null;
+        readonly right: string | null;
+        readonly winnerId: string | null;
+    }[];
+} | null>;
+
+export { }

package/dist/web.js

@@ -0,0 +1,16 @@
+import { BASE_NAME as e } from "./rpc.js";
+import { pluginTag as t } from "@voltro/protocol";
+import { useAction as n, useSubscription as r } from "@voltro/client";
+// src/web.ts
+var i = (n, i = "app") => r(i, t(e, "myRating"), { pool: n }), a = (n, i = 10, a = "app", o = "global") => r(a, t(e, "top"), {
+	board: n,
+	limit: i,
+	scope: o
+}), o = (n, i = "app") => r(i, t(e, "me"), { board: n }), s = (n, i = 5, a = "app") => r(a, t(e, "around"), {
+	board: n,
+	radius: i
+}), c = (n, i = 12, a = "app") => r(a, t(e, "history"), {
+	board: n,
+	limit: i
+}), l = (r = "app") => n(r, t(e, "joinTournament")), u = (n, i = "app") => r(i, t(e, "tournamentStatus"), { tournament: n }), d = (r = "app") => n(r, t(e, "registerBracket")), f = (r = "app") => n(r, t(e, "checkInBracket")), p = (n, i = "app") => r(i, t(e, "bracketStatus"), { tournamentId: n }), m = (r = "app") => n(r, t(e, "disputeBracket")), h = (n, i = "app") => r(i, t(e, "myBracketMatches"), { tournamentId: n }), g = (n, i = "app") => r(i, t(e, "bracketView"), { tournamentId: n });
+export { p as useBracketAdmissionStatus, f as useCheckInBracket, m as useDisputeBracket, l as useJoinLeaderboardTournament, s as useLeaderboardAround, c as useLeaderboardHistory, o as useLeaderboardMe, a as useLeaderboardTop, u as useLeaderboardTournamentStatus, h as useMyBracketMatches, i as useMyLeaderboardRating, d as useRegisterBracket, g as useTournamentBracket };

package/package.json

@@ -1,6 +1,115 @@
 {
   "name": "@voltro/plugin-leaderboards",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.88.0",
+  "description": "Exact leaderboard score arithmetic, bounded snapshot ranking and pure rating foundations",
+  "keywords": [
+    "voltro",
+    "typescript",
+    "framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://voltro.dev",
+  "bugs": {
+    "email": "support@voltro.dev"
+  },
+  "author": {
+    "name": "Voltro UG",
+    "url": "https://voltro.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./leaderboard": {
+      "types": "./dist/leaderboard.d.ts",
+      "import": "./dist/leaderboard.js",
+      "default": "./dist/leaderboard.js"
+    },
+    "./score": {
+      "types": "./dist/score.d.ts",
+      "import": "./dist/score.js",
+      "default": "./dist/score.js"
+    },
+    "./ranking": {
+      "types": "./dist/ranking.d.ts",
+      "import": "./dist/ranking.js",
+      "default": "./dist/ranking.js"
+    },
+    "./rating": {
+      "types": "./dist/rating.d.ts",
+      "import": "./dist/rating.js",
+      "default": "./dist/rating.js"
+    },
+    "./errors": {
+      "types": "./dist/errors.d.ts",
+      "import": "./dist/errors.js",
+      "default": "./dist/errors.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js",
+      "default": "./dist/testing.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js",
+      "default": "./dist/server.js"
+    },
+    "./records": {
+      "types": "./dist/records.d.ts",
+      "import": "./dist/records.js",
+      "default": "./dist/records.js"
+    },
+    "./rpc": {
+      "types": "./dist/rpc.d.ts",
+      "import": "./dist/rpc.js",
+      "default": "./dist/rpc.js"
+    },
+    "./web": {
+      "types": "./dist/web.d.ts",
+      "import": "./dist/web.js",
+      "default": "./dist/web.js"
+    },
+    "./tournaments": {
+      "types": "./dist/tournaments.d.ts",
+      "import": "./dist/tournaments.js",
+      "default": "./dist/tournaments.js"
+    },
+    "./brackets": {
+      "types": "./dist/brackets.d.ts",
+      "import": "./dist/brackets.js",
+      "default": "./dist/brackets.js"
+    },
+    "./ports": {
+      "types": "./dist/ports.d.ts",
+      "import": "./dist/ports.js",
+      "default": "./dist/ports.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@voltro/workflow": "0.88.0",
+    "@voltro/database": "0.88.0",
+    "@voltro/protocol": "0.88.0",
+    "@voltro/client": "0.88.0",
+    "@voltro/plugin-licensing": "0.88.0",
+    "@voltro/runtime": "0.88.0"
+  },
+  "peerDependencies": {
+    "effect": "4.1.0",
+    "react": "^19.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}