@voltro/plugin-leaderboards 0.0.0-stage → 0.87.0

package/dist/rpc.d.ts

@@ -0,0 +1,321 @@
+import { ActionProcedureDescriptor } from '@voltro/protocol';
+import { PluginRpcClientDescriptor } from '@voltro/protocol';
+import { QueryProcedureDescriptor } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+export declare const aroundDescriptor: QueryProcedureDescriptor<"leaderboards.around", Schema.Struct<{
+    readonly board: Schema.NonEmptyString;
+    readonly radius: Schema.optional<Schema.Number>;
+}>, Schema.$Array<Schema.Struct<{
+    readonly rank: Schema.Number;
+    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>;
+}>>, typeof LeaderboardError>;
+
+export declare const BASE_NAME = "@voltro/plugin-leaderboards";
+
+export declare const BracketAdmissionStatusSchema: Schema.Struct<{
+    readonly phase: Schema.Literals<readonly ["open", "sealed", "erasing", "cancelled"]>;
+    readonly entries: Schema.Int;
+    readonly checkedIn: Schema.Int;
+    readonly own: Schema.NullOr<Schema.Struct<{
+        readonly ownerId: Schema.NonEmptyString;
+        readonly joinedAt: Schema.Int;
+        readonly checkedInAt: Schema.NullOr<Schema.Int>;
+    }>>;
+}>;
+
+export declare const bracketRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
+
+export declare const bracketStatusDescriptor: QueryProcedureDescriptor<"leaderboards.bracketStatus", Schema.Struct<{
+    readonly tournamentId: Schema.String;
+}>, Schema.NullOr<Schema.Struct<{
+    readonly phase: Schema.Literals<readonly ["open", "sealed", "erasing", "cancelled"]>;
+    readonly entries: Schema.Int;
+    readonly checkedIn: Schema.Int;
+    readonly own: Schema.NullOr<Schema.Struct<{
+        readonly ownerId: Schema.NonEmptyString;
+        readonly joinedAt: Schema.Int;
+        readonly checkedInAt: Schema.NullOr<Schema.Int>;
+    }>>;
+}>>, typeof LeaderboardError>;
+
+export declare const bracketViewDescriptor: QueryProcedureDescriptor<"leaderboards.bracketView", Schema.Struct<{
+    readonly tournamentId: Schema.String;
+}>, Schema.NullOr<Schema.Struct<{
+    readonly phase: Schema.Literals<readonly ["active", "paused", "complete", "erasing", "cancelled"]>;
+    readonly format: Schema.Literals<readonly ["single-elimination", "double-elimination", "round-robin", "swiss"]>;
+    readonly champion: Schema.NullOr<Schema.NonEmptyString>;
+    readonly matches: Schema.$Array<Schema.Struct<{
+        readonly matchId: Schema.NonEmptyString;
+        readonly round: Schema.Int;
+        readonly status: Schema.Literals<readonly ["pending", "ready", "walkover", "complete", "empty", "inactive"]>;
+        readonly left: Schema.NullOr<Schema.NonEmptyString>;
+        readonly right: Schema.NullOr<Schema.NonEmptyString>;
+        readonly winnerId: Schema.NullOr<Schema.NonEmptyString>;
+    }>>;
+}>>, typeof LeaderboardError>;
+
+export declare const checkInBracketDescriptor: ActionProcedureDescriptor<"leaderboards.checkInBracket", Schema.Struct<{
+    readonly tournamentId: Schema.String;
+}>, Schema.Struct<{
+    readonly phase: Schema.Literals<readonly ["open", "sealed", "erasing", "cancelled"]>;
+    readonly entries: Schema.Int;
+    readonly checkedIn: Schema.Int;
+    readonly own: Schema.NullOr<Schema.Struct<{
+        readonly ownerId: Schema.NonEmptyString;
+        readonly joinedAt: Schema.Int;
+        readonly checkedInAt: Schema.NullOr<Schema.Int>;
+    }>>;
+}>, typeof LeaderboardError>;
+
+export declare const disputeBracketDescriptor: ActionProcedureDescriptor<"leaderboards.disputeBracket", Schema.Struct<{
+    readonly tournamentId: Schema.String;
+    readonly matchId: Schema.String;
+    readonly disputeId: Schema.String;
+    readonly reason: Schema.Literals<readonly ["result_mismatch", "no_show", "connection"]>;
+}>, Schema.Struct<{
+    readonly phase: Schema.Literals<readonly ["active", "paused", "complete", "erasing", "cancelled"]>;
+    readonly ready: Schema.Int;
+    readonly completed: Schema.Int;
+    readonly waiting: Schema.Int;
+    readonly unresolvedDisputes: Schema.Int;
+}>, typeof LeaderboardError>;
+
+export declare const historyDescriptor: QueryProcedureDescriptor<"leaderboards.history", Schema.Struct<{
+    readonly board: Schema.NonEmptyString;
+    readonly limit: Schema.optional<Schema.Number>;
+}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly board: Schema.String;
+    readonly startsAt: Schema.Number;
+    readonly endsAt: Schema.NullOr<Schema.Number>;
+    readonly state: Schema.Literals<readonly ["active", "closed", "archived"]>;
+    readonly summary: Schema.NullOr<Schema.Struct<{
+        readonly participants: Schema.Number;
+        readonly top: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly tenantId: Schema.String;
+            readonly board: Schema.String;
+            readonly periodId: Schema.String;
+            readonly ownerId: Schema.String;
+            readonly score: Schema.String;
+            readonly subscore: Schema.String;
+            readonly updatedAt: Schema.Number;
+            readonly rank: Schema.Number;
+        }>>;
+    }>>;
+}>>, typeof LeaderboardError>;
+
+export declare const joinTournamentDescriptor: ActionProcedureDescriptor<"leaderboards.joinTournament", Schema.Struct<{
+    readonly tournament: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly tournament: Schema.String;
+    readonly joinedAt: Schema.Number;
+    readonly attemptsLeft: Schema.Number;
+}>, typeof LeaderboardError>;
+
+declare class LeaderboardError extends LeaderboardError_base {
+}
+
+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 declare const leaderboardRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
+
+export declare const meDescriptor: QueryProcedureDescriptor<"leaderboards.me", Schema.Struct<{
+    readonly board: Schema.NonEmptyString;
+}>, Schema.NullOr<Schema.Struct<{
+    readonly rank: Schema.Number;
+    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>;
+}>>, typeof LeaderboardError>;
+
+export declare const myBracketMatchesDescriptor: QueryProcedureDescriptor<"leaderboards.myBracketMatches", Schema.Struct<{
+    readonly tournamentId: Schema.String;
+}>, Schema.NullOr<Schema.Struct<{
+    readonly phase: Schema.Literals<readonly ["active", "paused", "complete", "erasing", "cancelled"]>;
+    readonly champion: Schema.Boolean;
+    readonly matches: Schema.$Array<Schema.Struct<{
+        readonly matchId: Schema.NonEmptyString;
+        readonly round: Schema.Int;
+        readonly status: Schema.Literals<readonly ["pending", "ready", "walkover", "complete", "empty", "inactive"]>;
+        readonly opponentId: Schema.NullOr<Schema.NonEmptyString>;
+        readonly roomId: Schema.NullOr<Schema.NonEmptyString>;
+        readonly won: Schema.NullOr<Schema.Boolean>;
+    }>>;
+}>>, typeof LeaderboardError>;
+
+/** The caller's own bracket matches: opponent, Room once provisioned, and the result. */
+export declare const MyBracketMatchesSchema: Schema.Struct<{
+    readonly phase: Schema.Literals<readonly ["active", "paused", "complete", "erasing", "cancelled"]>;
+    readonly champion: Schema.Boolean;
+    readonly matches: Schema.$Array<Schema.Struct<{
+        readonly matchId: Schema.NonEmptyString;
+        readonly round: Schema.Int;
+        readonly status: Schema.Literals<readonly ["pending", "ready", "walkover", "complete", "empty", "inactive"]>;
+        readonly opponentId: Schema.NullOr<Schema.NonEmptyString>;
+        readonly roomId: Schema.NullOr<Schema.NonEmptyString>;
+        readonly won: Schema.NullOr<Schema.Boolean>;
+    }>>;
+}>;
+
+export declare const myRatingDescriptor: QueryProcedureDescriptor<"leaderboards.myRating", Schema.Struct<{
+    readonly pool: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly pool: Schema.NonEmptyString;
+    readonly state: Schema.Union<readonly [Schema.Struct<{
+        readonly algorithm: Schema.Literal<"elo">;
+        readonly rating: Schema.Number;
+    }>, Schema.Struct<{
+        readonly algorithm: Schema.Literal<"openskill">;
+        readonly mu: Schema.Number;
+        readonly sigma: Schema.Number;
+    }>, Schema.Struct<{
+        readonly algorithm: Schema.Literal<"glicko2">;
+        readonly rating: Schema.Number;
+        readonly deviation: Schema.Number;
+        readonly volatility: Schema.Number;
+    }>]>;
+    readonly games: Schema.Number;
+    readonly updatedAt: Schema.NullOr<Schema.Number>;
+}>, typeof LeaderboardError>;
+
+export declare const ratingRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
+
+export declare const registerBracketDescriptor: ActionProcedureDescriptor<"leaderboards.registerBracket", Schema.Struct<{
+    readonly tournamentId: Schema.String;
+}>, Schema.Struct<{
+    readonly phase: Schema.Literals<readonly ["open", "sealed", "erasing", "cancelled"]>;
+    readonly entries: Schema.Int;
+    readonly checkedIn: Schema.Int;
+    readonly own: Schema.NullOr<Schema.Struct<{
+        readonly ownerId: Schema.NonEmptyString;
+        readonly joinedAt: Schema.Int;
+        readonly checkedInAt: Schema.NullOr<Schema.Int>;
+    }>>;
+}>, typeof LeaderboardError>;
+
+export declare const topDescriptor: QueryProcedureDescriptor<"leaderboards.top", Schema.Struct<{
+    readonly board: Schema.NonEmptyString;
+    readonly limit: Schema.optional<Schema.Number>;
+    readonly scope: Schema.optional<Schema.Literals<readonly ["global", "bucket"]>>;
+}>, Schema.$Array<Schema.Struct<{
+    readonly rank: Schema.Number;
+    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>;
+}>>, typeof LeaderboardError>;
+
+export declare const TournamentAdvancePayload: Schema.Struct<{
+    readonly tenantId: Schema.String;
+    readonly tournamentId: Schema.String;
+    readonly runKey: Schema.String;
+}>;
+
+export declare type TournamentAdvancePayload = typeof TournamentAdvancePayload.Type;
+
+/** The whole bracket for the tournament's players: rounds, pairings, results and the champion.
+ * Room IDs are not part of it; each player reads their own Room with `myBracketMatches`. */
+export declare const TournamentBracketViewSchema: Schema.Struct<{
+    readonly phase: Schema.Literals<readonly ["active", "paused", "complete", "erasing", "cancelled"]>;
+    readonly format: Schema.Literals<readonly ["single-elimination", "double-elimination", "round-robin", "swiss"]>;
+    readonly champion: Schema.NullOr<Schema.NonEmptyString>;
+    readonly matches: Schema.$Array<Schema.Struct<{
+        readonly matchId: Schema.NonEmptyString;
+        readonly round: Schema.Int;
+        readonly status: Schema.Literals<readonly ["pending", "ready", "walkover", "complete", "empty", "inactive"]>;
+        readonly left: Schema.NullOr<Schema.NonEmptyString>;
+        readonly right: Schema.NullOr<Schema.NonEmptyString>;
+        readonly winnerId: Schema.NullOr<Schema.NonEmptyString>;
+    }>>;
+}>;
+
+export declare const tournamentCoordinationRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
+
+export declare const TournamentDisputeInput: Schema.Struct<{
+    readonly tournamentId: Schema.String;
+    readonly matchId: Schema.String;
+    readonly disputeId: Schema.String;
+    readonly reason: Schema.Literals<readonly ["result_mismatch", "no_show", "connection"]>;
+}>;
+
+export declare const tournamentRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
+
+export declare const TournamentStageNotification: Schema.Struct<{
+    readonly notified: Schema.Boolean;
+}>;
+
+export declare const TournamentStagePayload: Schema.Struct<{
+    readonly format: Schema.Literals<readonly ["single-elimination", "double-elimination", "round-robin", "swiss"]>;
+    readonly ruleVersion: Schema.String;
+    readonly tenantId: Schema.String;
+    readonly tournamentId: Schema.String;
+    readonly runKey: Schema.String;
+}>;
+
+export declare type TournamentStagePayload = typeof TournamentStagePayload.Type;
+
+export declare const TournamentStageWindow: Schema.Struct<{
+    readonly registrationOpensAt: Schema.Int;
+    readonly registrationClosesAt: Schema.Int;
+    readonly checkInOpensAt: Schema.Int;
+    readonly checkInClosesAt: Schema.Int;
+    readonly maxEntries: Schema.Int;
+}>;
+
+export declare const tournamentStatusDescriptor: QueryProcedureDescriptor<"leaderboards.tournamentStatus", Schema.Struct<{
+    readonly tournament: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly tournament: Schema.String;
+    readonly board: Schema.String;
+    readonly startsAt: Schema.Number;
+    readonly endsAt: Schema.Number;
+    readonly observedAt: Schema.Number;
+    readonly joinRequired: Schema.Boolean;
+    readonly state: Schema.Literals<readonly ["upcoming", "open", "ended"]>;
+    readonly entry: Schema.NullOr<Schema.Struct<{
+        readonly tournament: Schema.String;
+        readonly joinedAt: Schema.Number;
+        readonly attemptsLeft: Schema.Number;
+    }>>;
+}>, typeof LeaderboardError>;
+
+/** Counts only: no roster/winner/ratings/Room credentials in workflow journals. */
+export declare const TournamentWorkflowSummary: Schema.Struct<{
+    readonly phase: Schema.Literals<readonly ["active", "paused", "complete", "erasing", "cancelled"]>;
+    readonly ready: Schema.Int;
+    readonly completed: Schema.Int;
+    /** Advance work still open: ready matches without a Room, plus the champion's settlement. */
+    readonly waiting: Schema.Int;
+    readonly unresolvedDisputes: Schema.Int;
+}>;
+
+export declare type TournamentWorkflowSummary = typeof TournamentWorkflowSummary.Type;
+
+export { }

package/dist/rpc.js

@@ -0,0 +1,306 @@
+import { LeaderboardError as e } from "./errors.js";
+import { BOARDS_TABLE as t, BUCKET_ASSIGNMENTS_TABLE as n, LeaderboardPeriodSchema as r, LeaderboardRecordSchema as i, LeaderboardTournamentEntrySchema as a, LeaderboardTournamentStatusSchema as o, MyRatingSchema as s, PERIODS_TABLE as c, RECORDS_TABLE as l, TOURNAMENTS_TABLE as u, TOURNAMENT_ENTRIES_TABLE as d } from "./records.js";
+import { TournamentAdvancePayload as f, TournamentStageNotification as p, TournamentStagePayload as m, TournamentStageWindow as h, TournamentWorkflowSummary as g } from "./tournamentWorkflowSchemas.js";
+import { Schema as _ } from "effect";
+import { defineAction as v, defineQuery as y } from "@voltro/protocol";
+//#region src/rpc.ts
+var b = "@voltro/plugin-leaderboards", x = "The adapter requires a verified human and resolves the tenant from the request, never a player-supplied tenant or score.", S = _.Struct({
+	...i.fields,
+	rank: _.Number.pipe(_.check(_.isInt()), _.check(_.isGreaterThan(0)))
+}), C = _.Struct({
+	phase: _.Literals([
+		"open",
+		"sealed",
+		"erasing",
+		"cancelled"
+	]),
+	entries: _.Int.pipe(_.check(_.isBetween({
+		minimum: 0,
+		maximum: 256
+	}))),
+	checkedIn: _.Int.pipe(_.check(_.isBetween({
+		minimum: 0,
+		maximum: 256
+	}))),
+	own: _.NullOr(_.Struct({
+		ownerId: _.NonEmptyString,
+		joinedAt: _.Int.pipe(_.check(_.isGreaterThanOrEqualTo(0))),
+		checkedInAt: _.NullOr(_.Int.pipe(_.check(_.isGreaterThanOrEqualTo(0))))
+	}))
+}).pipe(_.check(_.makeFilter((e) => e.checkedIn <= e.entries))), w = _.Struct({ tournamentId: _.String.pipe(_.check(_.isMinLength(1)), _.check(_.isMaxLength(120))) }), T = _.Struct({
+	tournamentId: w.fields.tournamentId,
+	matchId: _.String.pipe(_.check(_.isMinLength(1)), _.check(_.isMaxLength(120))),
+	disputeId: _.String.pipe(_.check(_.isMinLength(1)), _.check(_.isMaxLength(120))),
+	reason: _.Literals([
+		"result_mismatch",
+		"no_show",
+		"connection"
+	])
+}), E = v({
+	name: "leaderboards.disputeBracket",
+	input: T,
+	output: g,
+	error: e,
+	openAccess: x
+}), D = v({
+	name: "leaderboards.registerBracket",
+	input: w,
+	output: C,
+	error: e,
+	openAccess: x
+}), O = v({
+	name: "leaderboards.checkInBracket",
+	input: w,
+	output: C,
+	error: e,
+	openAccess: x
+}), k = _.Struct({
+	phase: _.Literals([
+		"active",
+		"paused",
+		"complete",
+		"erasing",
+		"cancelled"
+	]),
+	champion: _.Boolean,
+	matches: _.Array(_.Struct({
+		matchId: _.NonEmptyString,
+		round: _.Int.pipe(_.check(_.isBetween({
+			minimum: 1,
+			maximum: 128
+		}))),
+		status: _.Literals([
+			"pending",
+			"ready",
+			"walkover",
+			"complete",
+			"empty",
+			"inactive"
+		]),
+		opponentId: _.NullOr(_.NonEmptyString),
+		roomId: _.NullOr(_.NonEmptyString),
+		won: _.NullOr(_.Boolean)
+	})).pipe(_.check(_.isMaxLength(127)))
+}), A = y({
+	name: "leaderboards.myBracketMatches",
+	input: w,
+	output: _.NullOr(k),
+	error: e,
+	source: "_voltro_brackets",
+	openAccess: x
+}), j = _.Struct({
+	phase: _.Literals([
+		"active",
+		"paused",
+		"complete",
+		"erasing",
+		"cancelled"
+	]),
+	format: _.Literals([
+		"single-elimination",
+		"double-elimination",
+		"round-robin",
+		"swiss"
+	]),
+	champion: _.NullOr(_.NonEmptyString),
+	matches: _.Array(_.Struct({
+		matchId: _.NonEmptyString,
+		round: _.Int.pipe(_.check(_.isBetween({
+			minimum: 1,
+			maximum: 128
+		}))),
+		status: _.Literals([
+			"pending",
+			"ready",
+			"walkover",
+			"complete",
+			"empty",
+			"inactive"
+		]),
+		left: _.NullOr(_.NonEmptyString),
+		right: _.NullOr(_.NonEmptyString),
+		winnerId: _.NullOr(_.NonEmptyString)
+	})).pipe(_.check(_.isMaxLength(127)))
+}), M = y({
+	name: "leaderboards.bracketView",
+	input: w,
+	output: _.NullOr(j),
+	error: e,
+	source: "_voltro_brackets",
+	openAccess: x
+}), N = y({
+	name: "leaderboards.bracketStatus",
+	input: w,
+	output: _.NullOr(C),
+	error: e,
+	source: "_voltro_tournament_admissions",
+	openAccess: x
+}), P = y({
+	name: "leaderboards.myRating",
+	input: _.Struct({ pool: _.NonEmptyString }),
+	output: s,
+	error: e,
+	source: "_voltro_lb_ratings",
+	openAccess: x
+}), F = y({
+	name: "leaderboards.top",
+	input: _.Struct({
+		board: _.NonEmptyString,
+		limit: _.optional(_.Number.pipe(_.check(_.isInt()), _.check(_.isBetween({
+			minimum: 1,
+			maximum: 1e3
+		})))),
+		scope: _.optional(_.Literals(["global", "bucket"]))
+	}),
+	output: _.Array(S),
+	error: e,
+	source: [
+		l,
+		t,
+		n
+	],
+	openAccess: x
+}), I = y({
+	name: "leaderboards.me",
+	input: _.Struct({ board: _.NonEmptyString }),
+	output: _.NullOr(S),
+	error: e,
+	source: [
+		l,
+		t,
+		n
+	],
+	openAccess: x
+}), L = y({
+	name: "leaderboards.around",
+	input: _.Struct({
+		board: _.NonEmptyString,
+		radius: _.optional(_.Number.pipe(_.check(_.isInt()), _.check(_.isBetween({
+			minimum: 0,
+			maximum: 500
+		}))))
+	}),
+	output: _.Array(S),
+	error: e,
+	source: [
+		l,
+		t,
+		n
+	],
+	openAccess: x
+}), R = y({
+	name: "leaderboards.history",
+	input: _.Struct({
+		board: _.NonEmptyString,
+		limit: _.optional(_.Number.pipe(_.check(_.isInt()), _.check(_.isBetween({
+			minimum: 1,
+			maximum: 1e5
+		}))))
+	}),
+	output: _.Array(r),
+	error: e,
+	source: c,
+	openAccess: x
+}), z = v({
+	name: "leaderboards.joinTournament",
+	input: _.Struct({ tournament: _.NonEmptyString }),
+	output: a,
+	error: e,
+	openAccess: x
+}), B = y({
+	name: "leaderboards.tournamentStatus",
+	input: _.Struct({ tournament: _.NonEmptyString }),
+	output: o,
+	error: e,
+	source: [
+		d,
+		u,
+		t
+	],
+	openAccess: x
+}), V = [
+	"top",
+	"me",
+	"around",
+	"history"
+].map((e) => ({
+	tag: "leaderboards." + e,
+	kind: "query",
+	import: {
+		module: "@voltro/plugin-leaderboards/rpc",
+		name: e + "Descriptor"
+	}
+})), H = [{
+	tag: "leaderboards.joinTournament",
+	kind: "action",
+	import: {
+		module: "@voltro/plugin-leaderboards/rpc",
+		name: "joinTournamentDescriptor"
+	}
+}, {
+	tag: "leaderboards.tournamentStatus",
+	kind: "query",
+	import: {
+		module: "@voltro/plugin-leaderboards/rpc",
+		name: "tournamentStatusDescriptor"
+	}
+}], U = [{
+	tag: "leaderboards.myRating",
+	kind: "query",
+	import: {
+		module: "@voltro/plugin-leaderboards/rpc",
+		name: "myRatingDescriptor"
+	}
+}], W = [
+	{
+		tag: "leaderboards.registerBracket",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-leaderboards/rpc",
+			name: "registerBracketDescriptor"
+		}
+	},
+	{
+		tag: "leaderboards.checkInBracket",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-leaderboards/rpc",
+			name: "checkInBracketDescriptor"
+		}
+	},
+	{
+		tag: "leaderboards.bracketStatus",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-leaderboards/rpc",
+			name: "bracketStatusDescriptor"
+		}
+	}
+], G = [
+	{
+		tag: "leaderboards.disputeBracket",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-leaderboards/rpc",
+			name: "disputeBracketDescriptor"
+		}
+	},
+	{
+		tag: "leaderboards.myBracketMatches",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-leaderboards/rpc",
+			name: "myBracketMatchesDescriptor"
+		}
+	},
+	{
+		tag: "leaderboards.bracketView",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-leaderboards/rpc",
+			name: "bracketViewDescriptor"
+		}
+	}
+];
+//#endregion
+export { b as BASE_NAME, C as BracketAdmissionStatusSchema, k as MyBracketMatchesSchema, f as TournamentAdvancePayload, j as TournamentBracketViewSchema, T as TournamentDisputeInput, p as TournamentStageNotification, m as TournamentStagePayload, h as TournamentStageWindow, g as TournamentWorkflowSummary, L as aroundDescriptor, W as bracketRpcClientImports, N as bracketStatusDescriptor, M as bracketViewDescriptor, O as checkInBracketDescriptor, E as disputeBracketDescriptor, R as historyDescriptor, z as joinTournamentDescriptor, V as leaderboardRpcClientImports, I as meDescriptor, A as myBracketMatchesDescriptor, P as myRatingDescriptor, U as ratingRpcClientImports, D as registerBracketDescriptor, F as topDescriptor, G as tournamentCoordinationRpcClientImports, H as tournamentRpcClientImports, B as tournamentStatusDescriptor };

package/dist/score.d.ts

@@ -0,0 +1,13 @@
+/** Submission idempotency belongs to SQL, not this pure arithmetic function. */
+export declare const applyScore: (previous: string | bigint | number | null, submitted: string | bigint | number, operator: ScoreOperator, sort?: LeaderboardSort) => string;
+
+export declare type LeaderboardSort = 'asc' | 'desc';
+
+export declare type ScoreOperator = 'best' | 'set' | 'increment' | 'decrement';
+
+export declare const scoreString: (input: string | bigint | number) => string;
+
+/** SQL signed BIGINT range; wire values use canonical decimal strings. */
+export declare const scoreValue: (input: string | bigint | number) => bigint;
+
+export { }

package/dist/score.js

@@ -0,0 +1,27 @@
+import { leaderboardError as e } from "./errors.js";
+//#region src/score.ts
+var t = -(1n << 63n), n = (1n << 63n) - 1n, r = (r) => {
+	let i;
+	if (typeof r == "bigint") i = r;
+	else if (typeof r == "number" && Number.isSafeInteger(r) && !Object.is(r, -0)) i = BigInt(r);
+	else if (typeof r == "string" && r.length <= 20 && /^(?:0|-?[1-9][0-9]*)$/.test(r)) i = BigInt(r);
+	else throw e("invalid_score");
+	if (i < t || i > n) throw e("overflow");
+	return i;
+}, i = (e) => r(e).toString(), a = (t, n, a, o = "desc") => {
+	if (![
+		"best",
+		"set",
+		"increment",
+		"decrement"
+	].includes(a) || !["asc", "desc"].includes(o)) throw e("invalid_board");
+	let s = r(n), c = t === null ? void 0 : r(t);
+	switch (a) {
+		case "set": return s.toString();
+		case "best": return (c === void 0 || (o === "desc" ? s > c : s < c) ? s : c).toString();
+		case "increment": return i((c ?? 0n) + s);
+		case "decrement": return i((c ?? 0n) - s);
+	}
+};
+//#endregion
+export { a as applyScore, i as scoreString, r as scoreValue };