@voltro/plugin-leaderboards 0.0.0-stage → 0.87.0

package/dist/plugin.js

@@ -0,0 +1,338 @@
+import { LeaderboardError as e, leaderboardError as t } from "./errors.js";
+import { LeaderboardRecordSchema as n } from "./records.js";
+import { leaderboardTables as r } from "./tables.entity.js";
+import { dataStoreLeaderboards as i, resolveLeaderboardStoreOptions as a } from "./service.js";
+import { LeaderboardAdministration as o } from "./administration.js";
+import { BASE_NAME as s, aroundDescriptor as c, bracketRpcClientImports as l, bracketStatusDescriptor as u, bracketViewDescriptor as d, checkInBracketDescriptor as f, disputeBracketDescriptor as p, historyDescriptor as m, joinTournamentDescriptor as h, leaderboardRpcClientImports as g, meDescriptor as _, myBracketMatchesDescriptor as ee, myRatingDescriptor as v, ratingRpcClientImports as y, registerBracketDescriptor as b, topDescriptor as x, tournamentCoordinationRpcClientImports as S, tournamentRpcClientImports as te, tournamentStatusDescriptor as ne } from "./rpc.js";
+import { leaderboardsStatus as C } from "./inspect.js";
+import { TournamentBracketPort as w } from "./bracketMatchPorts.js";
+import { TournamentStagePort as T } from "./tournamentStagePorts.js";
+import { BracketAdmissionPort as E } from "./ports.js";
+import { bracketAdmissionsTable as D } from "./bracketAdmission.js";
+import { makeBracketAdmissionInstallation as O } from "./bracketInstallation.js";
+import { tournamentBracketsTable as k } from "./bracketMatches.js";
+import { myBracketMatches as A, summarizeTournamentStatus as j, tournamentBracketView as M } from "./tournamentStage.js";
+import { makeTournamentInstallation as N } from "./tournamentInstallation.js";
+import { Effect as P, Layer as F, Schema as I } from "effect";
+import { defineLicensedGamePlugin as L } from "@voltro/plugin-licensing/gate";
+import { defineAction as R, systemSubject as z } from "@voltro/protocol";
+//#region src/plugin.ts
+var B = R({
+	name: "leaderboards.submit",
+	guards: [{ scope: "leaderboards:submit" }],
+	input: I.Struct({
+		tenantId: I.NonEmptyString,
+		board: I.NonEmptyString,
+		ownerId: I.NonEmptyString,
+		submissionId: I.NonEmptyString,
+		score: I.String,
+		subscore: I.optional(I.String),
+		metadata: I.Record(I.String, I.Unknown),
+		roomId: I.optional(I.NonEmptyString),
+		matchId: I.optional(I.NonEmptyString),
+		tournamentId: I.optional(I.NonEmptyString),
+		bucketSkill: I.optional(I.Number.pipe(I.check(I.isFinite()), I.check(I.isBetween({
+			minimum: -1e9,
+			maximum: 1e9
+		})))),
+		bucketCohort: I.optional(I.NonEmptyString)
+	}),
+	output: n,
+	error: e
+}), V = Object.freeze({
+	slots: {
+		tiebreak: {
+			defaultExport: "defaultLeaderboardTiebreak",
+			fixtureExport: "tiebreakSystemFixture"
+		},
+		rankQuery: {
+			defaultExport: "defaultLeaderboardRankQuery",
+			fixtureExport: "rankQuerySystemFixture"
+		},
+		bucketAssign: {
+			defaultExport: "defaultLeaderboardBucketAssign",
+			fixtureExport: "bucketAssignSystemFixture"
+		},
+		periodSummary: {
+			defaultExport: "defaultPeriodSummary",
+			fixtureExport: "periodSummarySystemFixture"
+		},
+		validate: {
+			defaultExport: "acceptLeaderboardSubmission",
+			fixtureExport: "validateSystemFixture"
+		},
+		ratingRate: {
+			defaultExport: "defaultRatingRate",
+			fixtureExport: "ratingRateSystemFixture"
+		},
+		ratingPlacement: {
+			defaultExport: "defaultRatingPlacement",
+			fixtureExport: "ratingPlacementSystemFixture"
+		},
+		ratingDecay: {
+			defaultExport: "defaultRatingDecay",
+			fixtureExport: "ratingDecaySystemFixture"
+		}
+	},
+	ports: {
+		bracketAdmission: {
+			tagExport: "BracketAdmissionPort",
+			fakeLayerExport: "bracketAdmissionSystemFakeLayer",
+			fixtureExport: "bracketAdmissionPortSystemFixture"
+		},
+		tournamentBracket: {
+			tagExport: "TournamentBracketPort",
+			fakeLayerExport: "tournamentBracketSystemFakeLayer",
+			fixtureExport: "tournamentBracketPortSystemFixture"
+		},
+		tournamentStage: {
+			tagExport: "TournamentStagePort",
+			fakeLayerExport: "tournamentStageSystemFakeLayer",
+			fixtureExport: "tournamentStagePortSystemFixture"
+		}
+	},
+	events: []
+}), H = (n) => {
+	let I = (e) => {
+		let r = Object.getOwnPropertyDescriptor(n, e);
+		if (r !== void 0 && (!r.enumerable || !("value" in r))) throw t("invalid_input");
+		return r?.value;
+	}, R = I("brackets"), V = I("tournamentCoordination"), H = a(n), U = O(R), W = N(V, U.service, U.configuration?.backend), G = [
+		...r,
+		...U.configuration?.backend === "sql" ? [D] : [],
+		...W.configuration?.backend === "sql" ? [k] : []
+	], K, q, J = (e) => P.suspend(() => q === void 0 ? P.fail(t("unavailable")) : e(q)), Y = (e, n, r) => {
+		try {
+			let t = structuredClone(e), i = structuredClone(n);
+			return J((e) => r(e, t, i));
+		} catch {
+			return P.fail(t("invalid_input"));
+		}
+	}, X = {
+		assignLeague: (e, t) => Y(e, t, (e, t, n) => e.assignLeague(t, n)),
+		myLeague: (e, t) => Y(e, t, (e, t, n) => e.myLeague(t, n)),
+		rollLeague: (e, t) => Y(e, t, (e, t, n) => e.rollLeague(t, n)),
+		leagueTenants: (e, t) => Y(e, t, (e, t, n) => e.leagueTenants(t, n)),
+		prepareRatingMatch: (e, t) => Y(e, t, (e, t, n) => e.prepareRatingMatch(t, n)),
+		applyRatingMatch: (e, t) => Y(e, t, (e, t, n) => e.applyRatingMatch(t, n)),
+		myRating: (e, t) => Y(e, t, (e, t, n) => e.myRating(t, n)),
+		pendingRatingMatches: (e, t, n, r) => Y(e, {
+			tenantId: t,
+			pool: n,
+			limit: r
+		}, (e, t, n) => e.pendingRatingMatches(t, n.tenantId, n.pool, n.limit)),
+		submit: (e, t) => Y(e, t, (e, t, n) => e.submit(t, n)),
+		top: (e, t, n, r) => Y(e, {
+			board: t,
+			limit: n,
+			scope: r
+		}, (e, t, n) => e.top(t, n.board, n.limit, n.scope)),
+		me: (e, t) => Y(e, t, (e, t, n) => e.me(t, n)),
+		around: (e, t, n) => Y(e, {
+			board: t,
+			radius: n
+		}, (e, t, n) => e.around(t, n.board, n.radius)),
+		rollPeriod: (e, t) => Y(e, t, (e, t, n) => e.rollPeriod(t, n)),
+		history: (e, t, n) => Y(e, {
+			board: t,
+			limit: n
+		}, (e, t, n) => e.history(t, n.board, n.limit)),
+		joinTournament: (e, t) => Y(e, t, (e, t, n) => e.joinTournament(t, n)),
+		tournamentStatus: (e, t) => Y(e, t, (e, t, n) => e.tournamentStatus(t, n)),
+		closeTournament: (e, t) => Y(e, t, (e, t, n) => e.closeTournament(t, n))
+	}, Z = [
+		{
+			...v,
+			execute: (e, t) => X.myRating(t.request.subject, e.pool)
+		},
+		{
+			...B,
+			execute: (e, t) => X.submit(t.request.subject, e)
+		},
+		{
+			...x,
+			execute: (e, t) => X.top(t.request.subject, e.board, e.limit, e.scope)
+		},
+		{
+			..._,
+			execute: (e, t) => X.me(t.request.subject, e.board)
+		},
+		{
+			...c,
+			execute: (e, t) => X.around(t.request.subject, e.board, e.radius)
+		},
+		{
+			...m,
+			execute: (e, t) => X.history(t.request.subject, e.board, e.limit)
+		},
+		{
+			...h,
+			execute: (e, t) => X.joinTournament(t.request.subject, e.tournament)
+		},
+		{
+			...ne,
+			execute: (e, t) => X.tournamentStatus(t.request.subject, e.tournament)
+		}
+	], Q = (e, n, r) => e.type !== "user" || e.id === null || e.tenantId === null ? P.fail(t("forbidden")) : U.service[r](e, {
+		tenantId: e.tenantId,
+		tournamentId: n
+	}), $ = (e) => e.pipe(P.catchTag("LeaderboardError", (e) => e.code === "not_found" ? P.succeed(null) : P.fail(e))), re = U.configuration === null ? [] : [
+		{
+			...b,
+			execute: (e, t) => Q(t.request.subject, e.tournamentId, "register")
+		},
+		{
+			...f,
+			execute: (e, t) => Q(t.request.subject, e.tournamentId, "checkIn")
+		},
+		{
+			...u,
+			source: [...U.sources],
+			execute: (e, t) => $(Q(t.request.subject, e.tournamentId, "status"))
+		}
+	];
+	return {
+		...L({
+			name: s,
+			description: "SQL-owned service scores with bounded reactive rank views.",
+			permissions: ["store:write", "inspect:read"],
+			...W.sourceRoot === void 0 ? {} : { sources: { tournaments: W.sourceRoot } },
+			routes: [
+				...Z,
+				...re,
+				...W.configuration === null ? [] : [
+					{
+						...p,
+						execute: (e, n) => {
+							let r = n.request.subject;
+							return r.type !== "user" || r.id === null || r.tenantId === null ? P.fail(t("forbidden")) : W.service.dispute(r, {
+								tenantId: r.tenantId,
+								tournamentId: e.tournamentId
+							}, {
+								matchId: e.matchId,
+								disputeId: e.disputeId,
+								reason: e.reason
+							}).pipe(P.flatMap((e) => P.try({
+								try: () => j(e),
+								catch: () => t("unavailable")
+							})));
+						}
+					},
+					{
+						...ee,
+						source: [...W.sources],
+						execute: (e, n) => {
+							let r = n.request.subject;
+							return r.type !== "user" || r.id === null || r.tenantId === null ? P.fail(t("forbidden")) : $(W.service.status(z("leaderboards.myBracketMatches"), {
+								tenantId: r.tenantId,
+								tournamentId: e.tournamentId
+							}).pipe(P.map((e) => A(e, r.id))));
+						}
+					},
+					{
+						...d,
+						source: [...W.sources],
+						execute: (e, n) => {
+							let r = n.request.subject;
+							return r.type !== "user" || r.id === null || r.tenantId === null ? P.fail(t("forbidden")) : $(W.service.status(z("leaderboards.bracketView"), {
+								tenantId: r.tenantId,
+								tournamentId: e.tournamentId
+							}).pipe(P.map(M)));
+						}
+					}
+				]
+			],
+			rpcClientDescriptors: [
+				...g,
+				...te,
+				...y,
+				...U.configuration === null ? [] : l,
+				...W.configuration === null ? [] : S
+			],
+			inspectEndpoints: [{
+				method: "GET",
+				path: "/status",
+				scope: "process",
+				description: "Captured board configuration and binding; no owner, score or submission enumeration.",
+				handler: () => P.try({
+					try: () => ({
+						kind: "json",
+						data: C(H, q !== void 0, (H.now ?? Date.now)(), U.configuration === null ? null : {
+							...U.configuration,
+							bound: U.isBound()
+						}, W.configuration === null ? null : {
+							...W.configuration,
+							bound: W.isBound(),
+							stageBound: W.isStageBound()
+						})
+					}),
+					catch: () => t("unavailable")
+				})
+			}],
+			services: F.mergeAll(F.succeed(o, X), U.configuration === null ? F.empty : F.succeed(E, U.service), W.configuration === null ? F.empty : F.succeed(w, W.service), W.configuration?.stage == null ? F.empty : F.succeed(T, W.stageService)),
+			errorSchemas: [{
+				schema: e,
+				import: {
+					module: "@voltro/plugin-leaderboards/errors",
+					name: "LeaderboardError"
+				}
+			}],
+			extendSchema: { tables: G },
+			subjectPrivacy: {
+				tables: G.map((e) => e.tableName),
+				kinds: ["user", "guest"]
+			},
+			bindDataStore: (e) => {
+				if (K !== void 0 && K !== e) throw Error("Leaderboard plugin instance cannot cross app stores");
+				if (K === e && q !== void 0) return;
+				let t = i(e, H);
+				U.bind(e), W.bind(e, U.boundService()), K = e, q = t;
+			},
+			onExport: (e, t) => {
+				let n = {
+					subjectId: e,
+					tenantId: t.tenantId,
+					kind: t.kind
+				}, r = J((e) => e.exportSubject(n)), i = {
+					requestId: t.requestId,
+					target: n
+				}, a = U.configuration === null ? r : U.service.exportSubject(i).pipe(P.flatMap((e) => r.pipe(P.map((t) => ({
+					...t,
+					bracketAdmissions: e
+				}))))), o = W.configuration === null ? a : W.service.exportSubject(i).pipe(P.flatMap((e) => a.pipe(P.map((t) => ({
+					...t,
+					tournamentBrackets: e
+				})))));
+				return W.configuration?.stage == null ? o : W.exportStageSubject(i).pipe(P.flatMap((e) => o.pipe(P.map((t) => ({
+					...t,
+					tournamentStages: e
+				})))));
+			},
+			onErase: (e, t) => {
+				let n = {
+					subjectId: e,
+					tenantId: t.tenantId,
+					kind: t.kind
+				}, r = J((e) => e.eraseSubject(n)), i = {
+					requestId: t.requestId,
+					target: n
+				}, a = U.configuration === null ? r : U.service.eraseSubject(i).pipe(P.flatMap(() => r)), o = W.configuration === null ? a : W.service.eraseSubject(i).pipe(P.flatMap(() => a));
+				return W.configuration?.stage == null ? o : W.eraseStageSubject(i).pipe(P.flatMap(() => o));
+			},
+			onDeactivate: () => P.sync(() => {
+				q = void 0, W.close(), U.close();
+			}).pipe(P.flatMap(() => P.all([W.awaitIdle(), U.deactivate()], {
+				concurrency: "unbounded",
+				discard: !0
+			})))
+		}),
+		leaderboards: Object.freeze({
+			service: () => X,
+			brackets: () => U.service,
+			tournaments: () => W.service,
+			tournamentStages: () => W.stageService
+		})
+	};
+};
+//#endregion
+export { H as leaderboardsPlugin, V as leaderboardsSystemContract };

package/dist/portLifetime.js

@@ -0,0 +1,67 @@
+import { LeaderboardError as e, leaderboardError as t } from "./errors.js";
+import { captureLeaderboardJson as n } from "./json.js";
+import { Effect as r, Schema as i } from "effect";
+import { Subject as a } from "@voltro/protocol";
+//#region src/portLifetime.ts
+function o() {
+	throw t("invalid_input");
+}
+var s = (e, t, n = []) => {
+	(!e || Object.getPrototypeOf(e) !== Object.prototype || Object.getOwnPropertySymbols(e).length) && o();
+	let r = Object.getOwnPropertyDescriptors(e);
+	(Object.entries(r).some(([e, r]) => ![...t, ...n].includes(e) || !r.enumerable || !("value" in r)) || t.some((e) => !Object.hasOwn(r, e))) && o();
+}, c = (e, t) => {
+	(!e || typeof e != "object") && o();
+	let n = t.map((t) => {
+		let n = Object.getOwnPropertyDescriptor(e, t);
+		return (!n || !("value" in n) || typeof n.value != "function") && o(), [t, n.value.bind(e)];
+	});
+	return Object.freeze(Object.fromEntries(n));
+}, l = (e) => ((typeof e != "string" || !/^[a-zA-Z0-9][a-zA-Z0-9:._-]{0,119}$/.test(e) || e.startsWith("voltro:")) && o(), e), u = (e) => {
+	let t = n(e, 4096);
+	return (!Array.isArray(t) || t.length < 1 || t.length > 32 || new Set(t).size !== t.length || t.some((e) => typeof e != "string" || !/^[a-zA-Z_][a-zA-Z0-9_]{0,119}$/.test(e))) && o(), Object.freeze(t);
+}, d = (e) => i.decodeUnknownSync(i.toType(a))(structuredClone(e)), f = (e) => i.decodeUnknownSync(i.Struct({
+	requestId: i.NonEmptyString,
+	target: i.Struct({
+		subjectId: i.NonEmptyString,
+		tenantId: i.NullOr(i.NonEmptyString),
+		kind: i.Literals(["user", "guest"])
+	})
+}))(n(e, 2048), { onExcessProperty: "error" }), p = () => {
+	let n, i = !1, a = 0, o = /* @__PURE__ */ new Set(), s = () => {
+		if (a--, a === 0) for (let e of [...o]) e();
+	};
+	return Object.freeze({
+		call: (o) => {
+			let c;
+			try {
+				c = o();
+			} catch (n) {
+				return r.fail(n instanceof e ? n : t("invalid_input"));
+			}
+			return r.acquireUseRelease(r.suspend(() => i || n === void 0 ? r.fail(t("unavailable")) : (a++, r.succeed(n))), (e) => r.suspend(() => c(e)), () => r.sync(s)).pipe(r.uninterruptible);
+		},
+		isBound: () => n !== void 0 && !i,
+		bind: (e) => {
+			if (i || n !== void 0) throw t("unavailable");
+			n = e;
+		},
+		close: () => {
+			i = !0, n = void 0;
+		},
+		awaitIdle: () => r.callback((e) => {
+			if (a === 0) {
+				e(r.void);
+				return;
+			}
+			let t = () => {
+				o.delete(t), e(r.void);
+			};
+			return o.add(t), r.sync(() => {
+				o.delete(t);
+			});
+		})
+	});
+};
+//#endregion
+export { s as assertPortBindingKeys, c as capturePortMethods, f as capturePortPrivacyRequest, u as capturePortSources, d as capturePortSubject, l as capturePortVersion, o as invalidPortBinding, p as makeLeaderboardPortLifetime };

package/dist/ports.d.ts

@@ -0,0 +1,294 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { PluginPrivacyRequest } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+declare interface AdmissionState {
+    readonly version: 1;
+    readonly definition: BracketAdmissionDefinition;
+    readonly phase: 'open' | 'sealed' | 'erasing' | 'cancelled';
+    readonly entries: ReadonlyArray<BracketAdmissionEntry>;
+    readonly eraseRequest: string | null;
+    readonly eraseTarget: string | null;
+}
+
+declare interface BracketAdmissionDefinition {
+    readonly registrationOpensAt: number;
+    readonly registrationClosesAt: number;
+    readonly checkInOpensAt: number;
+    readonly checkInClosesAt: number;
+    readonly maxEntries: number;
+}
+
+declare interface BracketAdmissionEntrants {
+    readonly phase: AdmissionState['phase'];
+    readonly entries: ReadonlyArray<BracketAdmissionEntry>;
+}
+
+declare interface BracketAdmissionEntry {
+    readonly ownerId: string;
+    readonly joinedAt: number;
+    readonly checkedInAt: number | null;
+}
+
+declare interface BracketAdmissionExport extends BracketAdmissionEntry {
+    readonly tournamentId: string;
+    readonly phase: BracketAdmissionStatus['phase'];
+}
+
+/** Browser-safe Tag; consumers depend on admission, never a SQL adapter. */
+export declare class BracketAdmissionPort extends BracketAdmissionPort_base {
+}
+
+declare const BracketAdmissionPort_base: Context.ServiceClass<BracketAdmissionPort, "@voltro/BracketAdmissionPort", {
+    create(subject: Subject, scope: BracketAdmissionScope, definition: BracketAdmissionDefinition): Effect.Effect<void, LeaderboardError>;
+    register(subject: Subject, scope: BracketAdmissionScope): Effect.Effect<BracketAdmissionStatus, LeaderboardError>;
+    checkIn(subject: Subject, scope: BracketAdmissionScope): Effect.Effect<BracketAdmissionStatus, LeaderboardError>;
+    status(subject: Subject, scope: BracketAdmissionScope): Effect.Effect<BracketAdmissionStatus, LeaderboardError>;
+    seal(subject: Subject, scope: BracketAdmissionScope): Effect.Effect<BracketAdmissionRoster, LeaderboardError>;
+    /** Trusted read of every registration with its check-in, for notifications. */
+    entrants(subject: Subject, scope: BracketAdmissionScope): Effect.Effect<BracketAdmissionEntrants, LeaderboardError>;
+    exportSubject(request: PluginPrivacyRequest): Effect.Effect<ReadonlyArray<BracketAdmissionExport>, LeaderboardError>;
+    eraseSubject(request: PluginPrivacyRequest): Effect.Effect<void, LeaderboardError>;
+}>;
+
+declare interface BracketAdmissionRoster {
+    readonly checkedIn: ReadonlyArray<string>;
+    readonly noShows: ReadonlyArray<string>;
+}
+
+declare interface BracketAdmissionScope {
+    readonly tenantId: string;
+    readonly tournamentId: string;
+}
+
+export declare type BracketAdmissionService = Context.Service.Shape<typeof BracketAdmissionPort>;
+
+declare interface BracketAdmissionStatus {
+    readonly phase: AdmissionState['phase'];
+    readonly entries: number;
+    readonly checkedIn: number;
+    readonly own: BracketAdmissionEntry | null;
+}
+
+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;
+}
+
+declare interface BracketProgress {
+    readonly matches: ReadonlyArray<BracketMatchObservation>;
+    readonly champion: string | null;
+}
+
+declare type BracketSlot = {
+    readonly kind: 'entrant';
+    readonly entrantId: string;
+} | {
+    readonly kind: 'winner';
+    readonly matchId: string;
+} | {
+    readonly kind: 'bye';
+};
+
+declare interface BracketState extends TournamentBracketDefinition {
+    readonly version: 1;
+    readonly phase: 'active' | 'paused' | 'complete' | 'erasing' | 'cancelled';
+    readonly withdrawn: boolean;
+    readonly provisions: ReadonlyArray<Provision>;
+    readonly results: ReadonlyArray<Result>;
+    readonly disputes: ReadonlyArray<Dispute>;
+    readonly settlement: {
+        readonly requestId: string;
+        readonly winnerId: string;
+        readonly complete: boolean;
+    } | null;
+    readonly erase: {
+        readonly requestId: string;
+        readonly targetDigest: string;
+    } | null;
+}
+
+declare interface Dispute extends TournamentDisputeIntent {
+    readonly ownerId: string;
+    readonly resolutionId: string | null;
+    readonly winnerId: string | null;
+}
+
+declare interface DoubleEliminationMatch {
+    readonly id: string;
+    readonly stage: 'winners' | 'losers' | 'final' | 'reset';
+    readonly round: number;
+    readonly left: DoubleEliminationSlot;
+    readonly right: DoubleEliminationSlot;
+}
+
+declare interface DoubleEliminationObservation extends Omit<BracketMatchObservation, 'status'> {
+    readonly stage: DoubleEliminationMatch['stage'];
+    readonly status: BracketMatchObservation['status'] | 'empty' | 'inactive';
+    readonly loserId: string | null;
+}
+
+declare interface DoubleEliminationProgress {
+    readonly matches: ReadonlyArray<DoubleEliminationObservation>;
+    readonly champion: string | null;
+    readonly losses: ReadonlyArray<{
+        readonly entrantId: string;
+        readonly losses: number;
+    }>;
+}
+
+declare type DoubleEliminationSlot = BracketSlot | {
+    readonly kind: 'loser';
+    readonly matchId: string;
+};
+
+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>;
+
+declare interface Provision extends TournamentRoomWork {
+    readonly roomId: string | null;
+    readonly epoch: number | null;
+}
+
+declare interface Result extends TournamentResultReport {
+    readonly reportedWinnerId: string;
+}
+
+declare interface TournamentBracketDefinition {
+    readonly format: TournamentBracketFormat;
+    readonly entrants: ReadonlyArray<TournamentEntrant>;
+    /** Swiss only: rounds to play (default: enough to separate a winner, ceil(log2 entrants)). */
+    readonly rounds?: number | undefined;
+    /** Immutable application prize/Room/no-show policy identity, not a price. */
+    readonly ruleVersion: string;
+}
+
+declare interface TournamentBracketExport {
+    readonly tournamentId: string;
+    readonly phase: BracketState['phase'];
+    readonly seed: number;
+    readonly matches: ReadonlyArray<{
+        readonly matchId: string;
+        readonly roomId: string;
+        readonly won: boolean;
+    }>;
+    readonly disputes: ReadonlyArray<TournamentDisputeIntent & {
+        readonly resolutionId: string | null;
+    }>;
+}
+
+declare type TournamentBracketFormat = 'single-elimination' | 'double-elimination' | 'round-robin' | 'swiss';
+
+/** A bracket match with the Room it plays in, once one was provisioned. */
+declare type TournamentBracketMatch = (BracketProgress['matches'][number] | DoubleEliminationProgress['matches'][number]) & {
+    readonly roomId: string | null;
+};
+
+/** Trusted server coordinator contract; SQL types are erased imports only. */
+export declare class TournamentBracketPort extends TournamentBracketPort_base {
+}
+
+declare const TournamentBracketPort_base: Context.ServiceClass<TournamentBracketPort, "@voltro/TournamentBracketPort", {
+    create(subject: Subject, scope: BracketAdmissionScope, definition: TournamentBracketDefinition): Effect.Effect<TournamentBracketStatus, LeaderboardError>;
+    report(subject: Subject, scope: BracketAdmissionScope, report: TournamentResultReport): Effect.Effect<TournamentBracketStatus, LeaderboardError>;
+    dispute(subject: Subject, scope: BracketAdmissionScope, intent: TournamentDisputeIntent): Effect.Effect<TournamentBracketStatus, LeaderboardError>;
+    resolve(subject: Subject, scope: BracketAdmissionScope, intent: TournamentDisputeResolution): Effect.Effect<TournamentBracketStatus, LeaderboardError>;
+    advance(subject: Subject, scope: BracketAdmissionScope): Effect.Effect<TournamentBracketStatus, LeaderboardError>;
+    status(subject: Subject, scope: BracketAdmissionScope): Effect.Effect<TournamentBracketStatus, LeaderboardError>;
+    exportSubject(request: PluginPrivacyRequest): Effect.Effect<ReadonlyArray<TournamentBracketExport>, LeaderboardError>;
+    eraseSubject(request: PluginPrivacyRequest): Effect.Effect<void, LeaderboardError>;
+}>;
+
+export declare type TournamentBracketService = Context.Service.Shape<typeof TournamentBracketPort>;
+
+declare interface TournamentBracketStatus {
+    readonly phase: BracketState['phase'];
+    readonly format: TournamentBracketFormat;
+    readonly champion: string | null;
+    readonly matches: ReadonlyArray<TournamentBracketMatch>;
+    readonly unresolvedDisputes: number;
+}
+
+declare interface TournamentDisputeIntent {
+    readonly disputeId: string;
+    readonly matchId: string;
+    readonly reason: 'result_mismatch' | 'no_show' | 'connection';
+}
+
+declare interface TournamentDisputeResolution {
+    readonly disputeId: string;
+    readonly resolutionId: string;
+    readonly winnerId: string;
+}
+
+declare interface TournamentEntrant {
+    readonly entrantId: string;
+    readonly seed: number;
+}
+
+declare interface TournamentResultReport extends TournamentRoomReceipt {
+    readonly matchId: string;
+    readonly reportId: string;
+    readonly winnerId: string;
+}
+
+declare interface TournamentRoomReceipt {
+    readonly roomId: string;
+    readonly epoch: number;
+}
+
+declare interface TournamentRoomWork extends BracketAdmissionScope {
+    readonly matchId: string;
+    readonly requestId: string;
+    readonly left: string;
+    readonly right: string;
+    readonly ruleVersion: string;
+}
+
+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;
+}>;
+
+declare type TournamentStagePayload = typeof TournamentStagePayload.Type;
+
+export declare class TournamentStagePort extends TournamentStagePort_base {
+}
+
+declare const TournamentStagePort_base: Context.ServiceClass<TournamentStagePort, "@voltro/TournamentStagePort", {
+    window(subject: Subject, payload: TournamentStagePayload): Effect.Effect<BracketAdmissionDefinition, LeaderboardError>;
+    notify(subject: Subject, payload: TournamentStagePayload, phase: "registration" | "check-in"): Effect.Effect<{
+        readonly notified: boolean;
+    }, LeaderboardError>;
+    seed(subject: Subject, payload: TournamentStagePayload): Effect.Effect<TournamentWorkflowSummary, LeaderboardError>;
+}>;
+
+export declare type TournamentStageService = Context.Service.Shape<typeof TournamentStagePort>;
+
+/** Counts only: no roster/winner/ratings/Room credentials in workflow journals. */
+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;
+}>;
+
+declare type TournamentWorkflowSummary = typeof TournamentWorkflowSummary.Type;
+
+export { }