@voltro/plugin-leaderboards 0.0.0-stage → 0.87.0

package/dist/server.d.ts

@@ -0,0 +1,1477 @@
+import { AppContext } from '@voltro/runtime';
+import { BrandedScheduleDefinition } from '@voltro/runtime';
+import { ColumnBuilder } from '@voltro/database';
+import { Context } from 'effect';
+import { DataStore } from '@voltro/database';
+import { Effect } from 'effect';
+import { FieldDefinitions } from '@voltro/database';
+import { Layer } from 'effect';
+import { PluginPrivacyRequest } from '@voltro/protocol';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { systemSubject } from '@voltro/protocol';
+import { Table } from '@voltro/database';
+import { TableLike } from '@voltro/database';
+import { WorkflowEngine } from 'effect/workflow/WorkflowEngine';
+import { WorkflowInstance } from 'effect/workflow/WorkflowEngine';
+import { YieldableError } from 'effect/Cause';
+
+export declare const acceptLeaderboardSubmission: NonNullable<LeaderboardStoreOptions['validate']>;
+
+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;
+}
+
+export declare interface ApplyRatingMatchInput {
+    readonly tenantId: string;
+    readonly pool: string;
+    readonly matchId: string;
+}
+
+export declare const BRACKET_ADMISSIONS_TABLE = "_voltro_tournament_admissions";
+
+export declare type BracketAdmissionBinding = {
+    readonly backend: 'sql';
+    readonly options: BracketAdmissionOptions;
+} | {
+    readonly backend: 'custom';
+    readonly version: string;
+    readonly service: BracketAdmissionService;
+    readonly sources: ReadonlyArray<string>;
+};
+
+export declare interface BracketAdmissionConfiguration {
+    readonly backend: 'sql' | 'custom';
+    readonly version: string;
+    readonly maxTenantTournaments: number | null;
+}
+
+declare interface BracketAdmissionDefinition {
+    readonly registrationOpensAt: number;
+    readonly registrationClosesAt: number;
+    readonly checkInOpensAt: number;
+    readonly checkInClosesAt: number;
+    readonly maxEntries: number;
+}
+
+export declare interface BracketAdmissionEntrants {
+    readonly phase: AdmissionState['phase'];
+    readonly entries: ReadonlyArray<BracketAdmissionEntry>;
+}
+
+export declare interface BracketAdmissionEntry {
+    readonly ownerId: string;
+    readonly joinedAt: number;
+    readonly checkedInAt: number | null;
+}
+
+export declare interface BracketAdmissionExport extends BracketAdmissionEntry {
+    readonly tournamentId: string;
+    readonly phase: BracketAdmissionStatus['phase'];
+}
+
+export declare const bracketAdmissionLayer: (store: DataStore, options: BracketAdmissionOptions) => Layer.Layer<BracketAdmissionPort>;
+
+export declare interface BracketAdmissionOptions {
+    readonly epochNow: () => number;
+    readonly maxTenantTournaments?: number;
+    /** Normal current application guards; no successful policy is provided. */
+    authorize(subject: Subject, scope: BracketAdmissionScope, operation: 'create' | 'register' | 'checkIn' | 'status' | 'seal' | 'entrants'): Effect.Effect<void, LeaderboardError>;
+    /** Permanent Subject admission fence + await every accepted app association. */
+    withdrawSubject(request: PluginPrivacyRequest): Effect.Effect<void, LeaderboardError>;
+    /** Cancel and await actual Rooms/timers/rewards that use this sealed roster. */
+    withdrawTournament(scope: BracketAdmissionScope, request: PluginPrivacyRequest): Effect.Effect<void, LeaderboardError>;
+    authorizeExport(request: PluginPrivacyRequest): Effect.Effect<void, LeaderboardError>;
+}
+
+/** 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>;
+}>;
+
+export declare interface BracketAdmissionRoster {
+    readonly checkedIn: ReadonlyArray<string>;
+    readonly noShows: ReadonlyArray<string>;
+}
+
+export declare interface BracketAdmissionScope {
+    readonly tenantId: string;
+    readonly tournamentId: string;
+}
+
+export declare type BracketAdmissionService = Context.Service.Shape<typeof BracketAdmissionPort>;
+
+/** Ordinary schema contribution; the optional installed SQL system owns it. */
+export declare const bracketAdmissionsTable: TableLike;
+
+export 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;
+}
+
+export declare interface CloseLeaderboardTournamentInput {
+    readonly tenantId: string;
+    readonly tournament: string;
+    readonly requestId: string;
+}
+
+export declare const dataStoreBracketAdmissions: (store: DataStore, input: BracketAdmissionOptions) => BracketAdmissionService;
+
+/** Bounded SQL snapshot foundation: no hot board, reset scheduler or client writes. */
+export declare const dataStoreLeaderboards: (store: DataStore, input: LeaderboardStoreOptions) => {
+    assignLeague: (subject: Subject, original: {
+        readonly tenantId: string;
+        readonly league: string;
+        readonly ownerId: string;
+        readonly division: string;
+    }) => Effect.Effect<{
+        readonly league: string;
+        readonly division: string;
+    }, LeaderboardError>;
+    myLeague: (subject: Subject, league: string) => Effect.Effect<{
+        readonly league: string;
+        readonly division: string;
+        readonly assigned: boolean;
+    }, LeaderboardError>;
+    rollLeague: (subject: Subject, original: {
+        readonly tenantId: string;
+        readonly league: string;
+        readonly requestId: string;
+        readonly closedAt: number;
+    }) => Effect.Effect<{
+        readonly divisions: ReadonlyArray<{
+            readonly division: string;
+            readonly closedPeriodId: string;
+            readonly activePeriodId: string;
+        }>;
+        readonly movements: ReadonlyArray<LeagueMovement>;
+    }, LeaderboardError>;
+    leagueTenants: (subject: Subject, original: {
+        readonly league: string;
+        readonly after?: string | null;
+        readonly limit: number;
+    }) => Effect.Effect<{
+        readonly tenants: ReadonlyArray<string>;
+        readonly next: string | null;
+    }, LeaderboardError>;
+    prepareRatingMatch: (subject: Subject, original: PrepareRatingMatchInput) => Effect.Effect< RatingMatchReceipt, LeaderboardError, never>;
+    applyRatingMatch: (subject: Subject, original: ApplyRatingMatchInput) => Effect.Effect< RatingMatchReceipt, LeaderboardError, never>;
+    myRating: (subject: Subject, poolName: string) => Effect.Effect<{
+        pool: string;
+        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;
+        };
+        games: number;
+        updatedAt: number | null;
+    }, LeaderboardError, never>;
+    pendingRatingMatches: (subject: Subject, tenantId: string, poolName: string, limit?: number) => Effect.Effect<{
+        tenantId: string;
+        pool: string;
+        matchId: string;
+    }[], LeaderboardError, never>;
+    closeTournament: (subject: Subject, original: CloseLeaderboardTournamentInput) => Effect.Effect<RollLeaderboardPeriodResult, LeaderboardError>;
+    joinTournament: (subject: Subject, tournamentName: string) => Effect.Effect<{
+        readonly tournament: string;
+        readonly joinedAt: number;
+        readonly attemptsLeft: number;
+    }, LeaderboardError, never>;
+    tournamentStatus: (subject: Subject, tournamentName: string) => Effect.Effect<{
+        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;
+    }, LeaderboardError, never>;
+    rollPeriod: (subject: Subject, original: RollLeaderboardPeriodInput) => Effect.Effect<RollLeaderboardPeriodResult, LeaderboardError>;
+    history: (subject: Subject, boardName: string, limit?: number) => Effect.Effect<{
+        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;
+    }[], LeaderboardError, never>;
+    submit: (subject: Subject, original: SubmitLeaderboardInput) => Effect.Effect<LeaderboardRecord, LeaderboardError>;
+    top: (subject: Subject, boardName: string, limit?: number, scope?: "global" | "bucket") => Effect.Effect<{
+        rank: number;
+        id: string;
+        board: string;
+        periodId: string;
+        ownerId: string;
+        score: string;
+        subscore: string;
+        numSubmits: number;
+        metadata: {
+            readonly [x: string]: unknown;
+        };
+        updatedAt: number;
+        bucket: string | null;
+    }[], LeaderboardError, never>;
+    me: (subject: Subject, boardName: string) => Effect.Effect<{
+        rank: number;
+        id: string;
+        board: string;
+        periodId: string;
+        ownerId: string;
+        score: string;
+        subscore: string;
+        numSubmits: number;
+        metadata: {
+            readonly [x: string]: unknown;
+        };
+        updatedAt: number;
+        bucket: string | null;
+    } | null, LeaderboardError, never>;
+    around: (subject: Subject, boardName: string, radius?: number) => Effect.Effect<{
+        rank: number;
+        id: string;
+        board: string;
+        periodId: string;
+        ownerId: string;
+        score: string;
+        subscore: string;
+        numSubmits: number;
+        metadata: {
+            readonly [x: string]: unknown;
+        };
+        updatedAt: number;
+        bucket: string | null;
+    }[], LeaderboardError, never>;
+    exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<{
+        records: {
+            readonly id: string;
+            readonly board: string;
+            readonly periodId: string;
+            readonly ownerId: string;
+            readonly score: string;
+            readonly subscore: string;
+            readonly numSubmits: number;
+            readonly metadata: {
+                readonly [x: string]: unknown;
+            };
+            readonly updatedAt: number;
+            readonly bucket: string | null;
+        }[];
+        submissions: {
+            id: unknown;
+            board: unknown;
+            periodId: unknown;
+            record: {
+                readonly id: string;
+                readonly board: string;
+                readonly periodId: string;
+                readonly ownerId: string;
+                readonly score: string;
+                readonly subscore: string;
+                readonly numSubmits: number;
+                readonly metadata: {
+                    readonly [x: string]: unknown;
+                };
+                readonly updatedAt: number;
+                readonly bucket: string | null;
+            };
+            roomId: unknown;
+            matchId: unknown;
+            tournamentId: unknown;
+            at: number;
+        }[];
+        bucketAssignments: {
+            board: unknown;
+            periodId: unknown;
+            bucket: unknown;
+            group: unknown;
+            assignedAt: number;
+        }[];
+        leagues: {
+            league: unknown;
+            division: unknown;
+            updatedAt: number;
+        }[];
+        leagueMoves: {
+            league: unknown;
+            from: string;
+            to: string;
+            at: number;
+        }[];
+        periodSummaries: {
+            periodId: string;
+            board: string;
+            startsAt: number;
+            endsAt: number;
+            record: RankedLeaderboardRecord;
+        }[];
+        tournamentEntries: {
+            readonly tournament: string;
+            readonly joinedAt: number;
+            readonly attemptsLeft: number;
+        }[];
+        ratings: {
+            pool: unknown;
+            state: unknown;
+            games: unknown;
+            updatedAt: number;
+        }[];
+        ratingResults: {
+            pool: unknown;
+            matchId: {} | null;
+            previous: unknown;
+            current: unknown;
+            at: number;
+        }[];
+        pendingRatingMatches: {
+            pool: unknown;
+            matchId: unknown;
+            weight: number;
+            rank: number | undefined;
+            preparedAt: number;
+        }[];
+    }, LeaderboardError, never>;
+    eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, LeaderboardError, never>;
+};
+
+export declare const dataStoreTournamentBrackets: (store: DataStore, offered: TournamentBracketOptions) => TournamentBracketService;
+
+export declare const dataStoreTournamentStages: (store: DataStore, offered: TournamentStageOptions) => TournamentStageService;
+
+export declare const defaultLeaderboardBucketAssign: LeaderboardBucketAssign;
+
+export declare const defaultLeaderboardRankQuery: LeaderboardRankQuery;
+
+/** Equal primary score: higher subscore, then earlier submission, then binary owner/record ID. */
+export declare const defaultLeaderboardTiebreak: LeaderboardTiebreak;
+
+export declare const defaultPeriodSummary: (records: ReadonlyArray<RankedLeaderboardRecord>, top?: number) => Readonly<{
+    participants: number;
+    top: readonly RankedLeaderboardRecord[];
+}>;
+
+/** Decay is applied on fresh participated match application, never on a read or
+ * retry. The default preserves the exact prior; no periodic decay job exists. */
+export declare const defaultRatingDecay: RatingDecayPolicy;
+
+export declare const defaultRatingPlacement: RatingPlacementPolicy;
+
+export declare const defaultRatingRate: RatingRateStrategy;
+
+/** A schedule that closes a league for every tenant with members at each firing. The firing
+ * instant is the close time and names the request, so a retried or overlapping run moves
+ * nobody twice. A tenant that fails does not stop the others; the run then fails and the
+ * next one retries only what is still open. */
+export declare const defineLeagueRollSchedule: (input: LeagueRollScheduleOptions) => BrandedScheduleDefinition;
+
+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 interface EloOptions {
+    readonly k?: number;
+    readonly scale?: number;
+}
+
+declare interface Glicko2Options {
+    readonly tau?: number;
+    readonly epsilon?: number;
+    readonly maxIterations?: number;
+    readonly maxOpponents?: number;
+}
+
+export declare class LeaderboardAdministration extends LeaderboardAdministration_base {
+}
+
+declare const LeaderboardAdministration_base: Context.ServiceClass<LeaderboardAdministration, "@voltro/LeaderboardAdministration", LeaderboardAdministrationService>;
+
+/** Internal server service for this leaf plugin's handlers, not a game-stack Port. */
+export declare type LeaderboardAdministrationService = Omit<ReturnType<typeof dataStoreLeaderboards>, 'exportSubject' | 'eraseSubject'>;
+
+export declare const leaderboardBoardsTable: Table<"_voltro_lb_boards", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly name: ColumnBuilder<string, "text", boolean>;
+    readonly periodId: ColumnBuilder<string, "text", boolean>;
+    readonly config: ColumnBuilder<unknown, "json", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly updatedAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>;
+
+/** Choose one actual capacity-admitted candidate. Grouping/SQL writer admission,
+ * membership and capacity stay inside the adapter. */
+export declare type LeaderboardBucketAssign = (context: LeaderboardBucketContext) => string;
+
+export declare const leaderboardBucketAssignmentsTable: Table<"_voltro_lb_bucket_assignments", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly board: ColumnBuilder<string, "text", boolean>;
+    readonly periodId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly bucket: ColumnBuilder<string, "text", boolean>;
+    readonly ordinal: ColumnBuilder<number, "integer", boolean>;
+    readonly groupKey: ColumnBuilder<string, "text", boolean>;
+    readonly group: ColumnBuilder<string | null, "text", boolean>;
+    readonly assignedAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, "voltro_lb_bucket_assignments_group_idx">;
+
+export declare interface LeaderboardBucketCandidate {
+    readonly id: string;
+    readonly ordinal: number;
+    readonly entries: number;
+}
+
+export declare interface LeaderboardBucketContext {
+    readonly tenantId: string;
+    readonly board: string;
+    readonly periodId: string;
+    readonly ownerId: string;
+    readonly assign: 'hash' | 'skill' | 'cohort';
+    readonly size: number;
+    readonly group: string | null;
+    readonly candidates: ReadonlyArray<LeaderboardBucketCandidate>;
+}
+
+declare interface LeaderboardDefinition<S extends Schema.Codec<unknown, unknown>> {
+    readonly name: string;
+    readonly sort?: LeaderboardSort;
+    readonly operator?: ScoreOperator;
+    readonly metadata: S;
+    /** Only service-owned writes exist in this foundation; no client score route. */
+    readonly submit?: {
+        readonly via: 'service-only';
+    };
+    readonly reset?: {
+        readonly cron: string;
+        readonly timezone: string;
+        readonly keepHistory: number;
+    } | undefined;
+    readonly maxRankRecords?: number;
+    readonly maxPageSize?: number;
+    readonly buckets?: {
+        readonly size: number;
+        readonly assign: 'hash' | 'skill' | 'cohort';
+        readonly skillWidth?: number;
+    } | undefined;
+}
+
+declare interface LeaderboardDescriptor<S extends Schema.Codec<unknown, unknown>> {
+    readonly kind: 'leaderboard';
+    readonly name: string;
+    readonly sort: LeaderboardSort;
+    readonly operator: ScoreOperator;
+    readonly metadata: S;
+    readonly submit: {
+        readonly via: 'service-only';
+    };
+    readonly reset: LeaderboardDefinition<S>['reset'];
+    readonly maxRankRecords: number;
+    readonly maxPageSize: number;
+    readonly buckets: LeaderboardDefinition<S>['buckets'];
+}
+
+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>;
+
+/** League membership: one division per owner and league (id derived from tenant, league, owner). */
+export declare const leaderboardLeagueMembersTable: Table<"_voltro_lb_league_members", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly league: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly division: ColumnBuilder<string, "text", boolean>;
+    readonly updatedAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, "voltro_lb_league_members_division_idx" | "voltro_lb_league_members_league_idx">;
+
+/** One receipt per league close request: the movements it applied, returned on retry. */
+export declare const leaderboardLeagueRollsTable: Table<"_voltro_lb_league_rolls", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly league: ColumnBuilder<string, "text", boolean>;
+    readonly movements: ColumnBuilder<unknown, "json", boolean>;
+    readonly at: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>;
+
+export declare const leaderboardPeriodsTable: Table<"_voltro_lb_periods", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly board: ColumnBuilder<string, "text", boolean>;
+    readonly startsAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly endsAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+    readonly state: ColumnBuilder<"closed" | "active" | "archived", "text", boolean>;
+    readonly summary: ColumnBuilder<unknown, "json", boolean>;
+    readonly previousPeriodId: ColumnBuilder<string | null, "text", boolean>;
+    readonly requestKey: ColumnBuilder<string | null, "text", boolean>;
+}>, true, never>;
+
+export declare interface LeaderboardPeriodSummary {
+    readonly participants: number;
+    readonly top: ReadonlyArray<RankedLeaderboardRecord>;
+}
+
+/** A summary selector may only retain exact records from the captured snapshot. */
+export declare type LeaderboardPeriodSummarySlot = (records: ReadonlyArray<RankedLeaderboardRecord>) => LeaderboardPeriodSummary;
+
+/** Complete ordered record identities. The adapter supplies consecutive ordinal
+ * ranks and all values from its SQL snapshot, never from strategy output. */
+export declare type LeaderboardRankQuery = (context: LeaderboardRankQueryContext) => Effect.Effect<ReadonlyArray<string>, LeaderboardError>;
+
+/** The admitted complete SQL snapshot is detached from the storage rows. A
+ * dialect implementation may use the declared read capability; writes are not
+ * part of this strategy's contract. Every returned ID must belong to records. */
+export declare interface LeaderboardRankQueryContext {
+    readonly tenantId: string;
+    readonly board: string;
+    readonly periodId: string;
+    /** null is the global view; a value is the admitted owner's current cohort. */
+    readonly bucketId: string | null;
+    readonly sort: LeaderboardSort;
+    readonly maxRecords: number;
+    readonly records: ReadonlyArray<LeaderboardRankRecord>;
+    readonly tiebreak: LeaderboardTiebreak;
+    readonly query: DataStore['query'];
+}
+
+declare interface LeaderboardRankRecord {
+    readonly id: string;
+    readonly tenantId: string;
+    readonly board: string;
+    readonly periodId: string;
+    readonly ownerId: string;
+    readonly score: string;
+    readonly subscore: string;
+    readonly updatedAt: number;
+}
+
+export declare const leaderboardRatingMatchesTable: Table<"_voltro_lb_rating_matches", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly pool: ColumnBuilder<string, "text", boolean>;
+    readonly matchId: ColumnBuilder<string | null, "text", boolean>;
+    readonly requestKey: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "applied" | "prepared", "text", boolean>;
+    readonly input: ColumnBuilder<unknown, "json", boolean>;
+    readonly participants: ColumnBuilder<number, "integer", boolean>;
+    readonly preparedAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly appliedAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>;
+
+export declare const leaderboardRatingPoolsTable: Table<"_voltro_lb_rating_pools", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly name: ColumnBuilder<string, "text", boolean>;
+    readonly config: ColumnBuilder<unknown, "json", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+export declare const leaderboardRatingResultsTable: Table<"_voltro_lb_rating_results", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly pool: ColumnBuilder<string, "text", boolean>;
+    readonly matchKey: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly previous: ColumnBuilder<unknown, "json", boolean>;
+    readonly current: ColumnBuilder<unknown, "json", boolean>;
+    readonly at: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>;
+
+export declare const leaderboardRatingsTable: Table<"_voltro_lb_ratings", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly pool: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<unknown, "json", boolean>;
+    readonly games: ColumnBuilder<number, "integer", boolean>;
+    readonly updatedAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>;
+
+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 leaderboardRecordsTable: Table<"_voltro_lb_records", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly board: ColumnBuilder<string, "text", boolean>;
+    readonly periodId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly score: ColumnBuilder<string, "bigint", boolean>;
+    readonly subscore: ColumnBuilder<string, "bigint", boolean>;
+    readonly numSubmits: ColumnBuilder<number, "integer", boolean>;
+    readonly metadata: ColumnBuilder<unknown, "json", boolean>;
+    readonly updatedAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly bucket: ColumnBuilder<string | null, "text", boolean>;
+}>, true, "voltro_lb_records_rank_idx">;
+
+declare type LeaderboardSort = 'asc' | 'desc';
+
+export declare interface LeaderboardStoreOptions {
+    readonly boards: ReadonlyArray<LeaderboardDescriptor<Schema.Codec<unknown, unknown>>>;
+    readonly tournaments?: ReadonlyArray<TournamentDescriptor>;
+    /** Leagues over declared, non-bucketed boards (`defineLeague`); a board belongs to at most one league. */
+    readonly leagues?: ReadonlyArray<LeagueDefinition>;
+    readonly ratingPools?: ReadonlyArray<RatingPoolDefinition>;
+    readonly ratingStrategies?: RatingStrategies;
+    /** Explicit verified service callers; none are authorized by default. System tasks are trusted. */
+    readonly allowedServices?: ReadonlyArray<string>;
+    readonly validate?: (input: SubmitLeaderboardInput, previous: LeaderboardRecord | null, tx: DataStore) => Effect.Effect<void, LeaderboardError>;
+    readonly tiebreak?: LeaderboardTiebreak;
+    readonly rankQuery?: LeaderboardRankQuery;
+    readonly bucketAssign?: LeaderboardBucketAssign;
+    readonly bucketStrategyVersion?: string;
+    readonly periodSummary?: LeaderboardPeriodSummarySlot;
+    readonly maxPeriodRows?: number;
+    readonly maxSummaryBytes?: number;
+    readonly maxMetadataBytes?: number;
+    readonly maxExportRows?: number;
+    readonly maxSubmissionsPerOwner?: number;
+    readonly now?: () => number;
+}
+
+/** Optional app-shaped discovery root. App configuration must provide actual
+ * Stage/Bracket services and privacy; exporting sources does not install them. */
+export declare const leaderboardsTournamentSources: string;
+
+export declare const leaderboardSubjectsTable: Table<"_voltro_lb_subject_admission", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly subjectId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+export declare const leaderboardSubmissionsTable: Table<"_voltro_lb_submissions", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly board: ColumnBuilder<string, "text", boolean>;
+    readonly periodId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly requestKey: ColumnBuilder<string, "text", boolean>;
+    readonly record: ColumnBuilder<unknown, "json", boolean>;
+    readonly roomId: ColumnBuilder<string | null, "text", boolean>;
+    readonly matchId: ColumnBuilder<string | null, "text", boolean>;
+    readonly at: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly tournamentId: ColumnBuilder<string | null, "text", boolean>;
+}>, true, never>;
+
+export declare const leaderboardTables: readonly [ Table<"_voltro_lb_boards", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly name: ColumnBuilder<string, "text", boolean>;
+    readonly periodId: ColumnBuilder<string, "text", boolean>;
+    readonly config: ColumnBuilder<unknown, "json", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly updatedAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>, Table<"_voltro_lb_records", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly board: ColumnBuilder<string, "text", boolean>;
+    readonly periodId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly score: ColumnBuilder<string, "bigint", boolean>;
+    readonly subscore: ColumnBuilder<string, "bigint", boolean>;
+    readonly numSubmits: ColumnBuilder<number, "integer", boolean>;
+    readonly metadata: ColumnBuilder<unknown, "json", boolean>;
+    readonly updatedAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly bucket: ColumnBuilder<string | null, "text", boolean>;
+}>, true, "voltro_lb_records_rank_idx">, Table<"_voltro_lb_periods", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly board: ColumnBuilder<string, "text", boolean>;
+    readonly startsAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly endsAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+    readonly state: ColumnBuilder<"closed" | "active" | "archived", "text", boolean>;
+    readonly summary: ColumnBuilder<unknown, "json", boolean>;
+    readonly previousPeriodId: ColumnBuilder<string | null, "text", boolean>;
+    readonly requestKey: ColumnBuilder<string | null, "text", boolean>;
+}>, true, never>, Table<"_voltro_lb_submissions", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly board: ColumnBuilder<string, "text", boolean>;
+    readonly periodId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly requestKey: ColumnBuilder<string, "text", boolean>;
+    readonly record: ColumnBuilder<unknown, "json", boolean>;
+    readonly roomId: ColumnBuilder<string | null, "text", boolean>;
+    readonly matchId: ColumnBuilder<string | null, "text", boolean>;
+    readonly at: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly tournamentId: ColumnBuilder<string | null, "text", boolean>;
+}>, true, never>, Table<"_voltro_lb_subject_admission", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly subjectId: ColumnBuilder<string | null, "text", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_lb_tournaments", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly name: ColumnBuilder<string, "text", boolean>;
+    readonly board: ColumnBuilder<string, "text", boolean>;
+    readonly periodId: ColumnBuilder<string, "text", boolean>;
+    readonly config: ColumnBuilder<unknown, "json", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly numEntries: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_lb_tournament_entries", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly tournamentId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly joinedAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly attemptsLeft: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_lb_rating_pools", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly name: ColumnBuilder<string, "text", boolean>;
+    readonly config: ColumnBuilder<unknown, "json", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>, Table<"_voltro_lb_ratings", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly pool: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<unknown, "json", boolean>;
+    readonly games: ColumnBuilder<number, "integer", boolean>;
+    readonly updatedAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>, Table<"_voltro_lb_rating_matches", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly pool: ColumnBuilder<string, "text", boolean>;
+    readonly matchId: ColumnBuilder<string | null, "text", boolean>;
+    readonly requestKey: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<"erased" | "applied" | "prepared", "text", boolean>;
+    readonly input: ColumnBuilder<unknown, "json", boolean>;
+    readonly participants: ColumnBuilder<number, "integer", boolean>;
+    readonly preparedAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly appliedAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>, Table<"_voltro_lb_rating_results", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly pool: ColumnBuilder<string, "text", boolean>;
+    readonly matchKey: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly previous: ColumnBuilder<unknown, "json", boolean>;
+    readonly current: ColumnBuilder<unknown, "json", boolean>;
+    readonly at: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>, Table<"_voltro_lb_bucket_assignments", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly board: ColumnBuilder<string, "text", boolean>;
+    readonly periodId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly bucket: ColumnBuilder<string, "text", boolean>;
+    readonly ordinal: ColumnBuilder<number, "integer", boolean>;
+    readonly groupKey: ColumnBuilder<string, "text", boolean>;
+    readonly group: ColumnBuilder<string | null, "text", boolean>;
+    readonly assignedAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, "voltro_lb_bucket_assignments_group_idx">, Table<"_voltro_lb_league_members", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly league: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly division: ColumnBuilder<string, "text", boolean>;
+    readonly updatedAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, "voltro_lb_league_members_division_idx" | "voltro_lb_league_members_league_idx">, Table<"_voltro_lb_league_rolls", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly league: ColumnBuilder<string, "text", boolean>;
+    readonly movements: ColumnBuilder<unknown, "json", boolean>;
+    readonly at: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>];
+
+declare type LeaderboardTiebreak = (left: LeaderboardRankRecord, right: LeaderboardRankRecord) => number;
+
+export declare const leaderboardTournamentEntriesTable: Table<"_voltro_lb_tournament_entries", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly tournamentId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly joinedAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly attemptsLeft: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+export declare const leaderboardTournamentsTable: Table<"_voltro_lb_tournaments", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly name: ColumnBuilder<string, "text", boolean>;
+    readonly board: ColumnBuilder<string, "text", boolean>;
+    readonly periodId: ColumnBuilder<string, "text", boolean>;
+    readonly config: ColumnBuilder<unknown, "json", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly numEntries: ColumnBuilder<number, "integer", boolean>;
+}>, true, never>;
+
+/** A league: ordered division boards (best first) whose periods close together; at each
+ * close the best `promote` of a division move up and the worst `relegate` move down. */
+declare interface LeagueDefinition {
+    readonly name: string;
+    /** Board names, top division first; each a declared, non-bucketed board of this plugin. */
+    readonly divisions: readonly [string, string, ...string[]];
+    readonly promote: number;
+    readonly relegate: number;
+}
+
+declare interface LeagueMovement {
+    readonly ownerId: string;
+    readonly from: string;
+    readonly to: string;
+}
+
+export declare interface LeagueRollScheduleOptions {
+    readonly league: string;
+    /** When the league closes, e.g. `'0 0 * * 1'` for Mondays at midnight. */
+    readonly cron: string;
+    readonly timezone?: string;
+    /** Tenants per page (default 100) and pages per run (default 100). */
+    readonly pageSize?: number;
+    readonly maxPages?: number;
+}
+
+declare interface OpenSkillOptions {
+    readonly beta?: number;
+    readonly tau?: number;
+    readonly kappa?: number;
+    readonly ordinalZ?: number;
+}
+
+export declare type PrepareRatingMatchInput = typeof PrepareRatingMatchSchema.Type;
+
+declare const PrepareRatingMatchSchema: Schema.Struct<{
+    readonly tenantId: Schema.NonEmptyString;
+    readonly pool: Schema.NonEmptyString;
+    readonly matchId: Schema.NonEmptyString;
+    readonly teams: Schema.$Array<Schema.$Array<Schema.Struct<{
+        readonly ownerId: Schema.NonEmptyString;
+        readonly weight: Schema.optional<Schema.Number>;
+    }>>>;
+    readonly ranks: Schema.$Array<Schema.Number>;
+}>;
+
+declare interface Provision extends TournamentRoomWork {
+    readonly roomId: string | null;
+    readonly epoch: number | null;
+}
+
+declare interface RankedLeaderboardRecord extends LeaderboardRankRecord {
+    readonly rank: number;
+}
+
+export declare interface RatingDecayContext extends RatingPlacementContext {
+    readonly state: RatingState;
+    readonly games: number;
+    readonly updatedAt: number;
+    readonly elapsedMs: number;
+}
+
+export declare type RatingDecayPolicy = (context: RatingDecayContext) => RatingState;
+
+export declare interface RatingMatchReceipt {
+    readonly pool: string;
+    readonly matchId: string;
+    readonly participants: number;
+    readonly state: 'prepared' | 'applied';
+    readonly preparedAt: number;
+    readonly appliedAt: number | null;
+}
+
+export declare interface RatingPlacementContext {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly pool: ResolvedRatingPool;
+    readonly at: number;
+}
+
+export declare type RatingPlacementPolicy = (context: RatingPlacementContext) => RatingState;
+
+export declare type RatingPoolDefinition = {
+    readonly name: string;
+    readonly algorithm: 'elo';
+    readonly initial?: {
+        readonly rating: number;
+    };
+    readonly options?: EloOptions;
+} | {
+    readonly name: string;
+    readonly algorithm: 'openskill';
+    readonly initial?: {
+        readonly mu: number;
+        readonly sigma: number;
+    };
+    readonly options?: OpenSkillOptions;
+} | {
+    readonly name: string;
+    readonly algorithm: 'glicko2';
+    readonly initial?: {
+        readonly rating: number;
+        readonly deviation: number;
+        readonly volatility: number;
+    };
+    readonly options?: Glicko2Options;
+};
+
+export declare interface RatingRateContext {
+    readonly tenantId: string;
+    readonly matchId: string;
+    readonly pool: ResolvedRatingPool;
+    readonly at: number;
+    readonly teams: ReadonlyArray<ReadonlyArray<RatingStrategyPlayer>>;
+    readonly ranks: ReadonlyArray<number>;
+}
+
+export declare type RatingRateStrategy = (context: RatingRateContext) => ReadonlyArray<RatingStrategyResult>;
+
+export declare type RatingState = typeof RatingStateSchema.Type;
+
+declare const RatingStateSchema: 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;
+}>]>;
+
+export declare interface RatingStrategies {
+    /** Required for any custom callback. Change it whenever rule meaning changes;
+     * the SQL pool configuration refuses conflicting versions across writers. */
+    readonly version?: string;
+    readonly rate?: RatingRateStrategy;
+    readonly placementPolicy?: RatingPlacementPolicy;
+    readonly decay?: RatingDecayPolicy;
+}
+
+export declare interface RatingStrategyPlayer {
+    readonly ownerId: string;
+    readonly state: RatingState;
+    readonly games: number;
+    readonly updatedAt: number | null;
+    readonly weight: number;
+}
+
+export declare interface RatingStrategyResult {
+    readonly ownerId: string;
+    readonly state: RatingState;
+}
+
+/** Trusted server read; callers still own current authorization. Complete
+ * state admission precedes projection, and no participant enters its result. */
+export declare const readBracketAdmissionWindow: (store: DataStore, offered: BracketAdmissionScope) => Effect.Effect<{
+    readonly phase: BracketAdmissionStatus["phase"];
+    readonly definition: BracketAdmissionDefinition;
+}, LeaderboardError>;
+
+/** Reports a verified match result, then queues `tournament.advance` for the tournament (the
+ * report ID is the run key), so the next ready matches get their Rooms without another call.
+ * Runs per tournament one at a time; a start during a run waits instead of being dropped. */
+export declare const reportTournamentResult: (ctx: TournamentWorkflowStarter, tournaments: Pick<TournamentBracketService, "report">, subject: Subject, scope: BracketAdmissionScope, report: TournamentResultReport) => Effect.Effect<TournamentBracketStatus, LeaderboardError>;
+
+/** Borrowed SQL is the roster truth. No workflow, timer, cache or Rooms host is
+ * created. Explicit current guards and all-node privacy remain app-owned. */
+export declare const resolveBracketAdmissionOptions: (input: BracketAdmissionOptions) => BracketAdmissionOptions;
+
+export declare interface ResolvedRatingPool {
+    readonly name: string;
+    readonly algorithm: RatingState['algorithm'];
+    readonly initial: RatingState;
+    readonly options: EloOptions | OpenSkillOptions | Glicko2Options;
+}
+
+/** Durable SQL graph and external-work journal. All external services are
+ * explicitly supplied; callbacks are requirements, not distributed proof. */
+export declare const resolveTournamentBracketOptions: (input: TournamentBracketOptions) => TournamentBracketOptions;
+
+export declare const resolveTournamentStageOptions: (options: TournamentStageOptions) => TournamentStageOptions;
+
+declare interface Result extends TournamentResultReport {
+    readonly reportedWinnerId: string;
+}
+
+export declare interface RollLeaderboardPeriodInput {
+    readonly tenantId: string;
+    readonly board: string;
+    readonly requestId: string;
+    readonly expectedPeriodId: string;
+    /** Stable intended boundary, retained on retry; never supplied by a player. */
+    readonly closedAt: number;
+}
+
+export declare interface RollLeaderboardPeriodResult {
+    readonly closedPeriodId: string;
+    readonly activePeriodId: string;
+    readonly closedAt: number;
+    readonly summary: LeaderboardPeriodSummary;
+}
+
+declare type ScoreOperator = 'best' | 'set' | 'increment' | 'decrement';
+
+/** Trusted service submission, never a player score-intent payload. */
+declare interface SubmitLeaderboardInput {
+    readonly tenantId: string;
+    readonly board: string;
+    readonly ownerId: string;
+    readonly submissionId: string;
+    readonly score: string;
+    readonly subscore?: string;
+    readonly metadata: Readonly<Record<string, unknown>>;
+    readonly roomId?: string;
+    readonly matchId?: string;
+    readonly tournamentId?: string;
+    readonly bucketSkill?: number;
+    readonly bucketCohort?: string;
+}
+
+export declare const summarizeTournamentStatus: (status: TournamentBracketStatus) => TournamentWorkflowSummary;
+
+export declare const TOURNAMENT_BRACKETS_TABLE = "_voltro_brackets";
+
+export declare const tournamentAdvanceExecutor: (context: Pick<AppContext, "request">) => (input: TournamentAdvancePayload) => Effect.Effect<{
+    readonly phase: "cancelled" | "complete" | "active" | "paused" | "erasing";
+    readonly ready: number;
+    readonly completed: number;
+    readonly waiting: number;
+    readonly unresolvedDisputes: number;
+}, LeaderboardError, TournamentBracketPort | WorkflowEngine | WorkflowInstance>;
+
+declare const TournamentAdvancePayload: Schema.Struct<{
+    readonly tenantId: Schema.String;
+    readonly tournamentId: Schema.String;
+    readonly runKey: Schema.String;
+}>;
+
+declare type TournamentAdvancePayload = typeof TournamentAdvancePayload.Type;
+
+export declare type TournamentBinding = ({
+    readonly backend: 'sql';
+    readonly options: TournamentBracketOptions;
+} | {
+    readonly backend: 'custom';
+    readonly version: string;
+    readonly service: TournamentBracketService;
+    readonly sources: ReadonlyArray<string>;
+}) & {
+    readonly stage?: TournamentStageBinding;
+    readonly workflowSources?: string;
+};
+
+export 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;
+}
+
+export 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;
+    }>;
+}
+
+export declare type TournamentBracketFormat = 'single-elimination' | 'double-elimination' | 'round-robin' | 'swiss';
+
+export declare const tournamentBracketLayer: (store: DataStore, options: TournamentBracketOptions) => Layer.Layer<TournamentBracketPort>;
+
+/** A bracket match with the Room it plays in, once one was provisioned. */
+export declare type TournamentBracketMatch = (BracketProgress['matches'][number] | DoubleEliminationProgress['matches'][number]) & {
+    readonly roomId: string | null;
+};
+
+export declare interface TournamentBracketOptions {
+    readonly epochNow: () => number;
+    readonly maxTenantTournaments?: number;
+    authorize(subject: Subject, scope: BracketAdmissionScope, operation: 'create' | 'report' | 'dispute' | 'resolve' | 'advance' | 'status'): Effect.Effect<void, LeaderboardError>;
+    /** Actual durable Room creation/reservations: same request returns same Room,
+     * enforces private roster/options/current grants, and awaits accepted work. */
+    provisionRoom(work: TournamentRoomWork): Effect.Effect<TournamentRoomReceipt, LeaderboardError>;
+    verifyResult(subject: Subject, scope: BracketAdmissionScope, report: TournamentResultReport): Effect.Effect<void, LeaderboardError>;
+    /** The real economy/inventory/Inbox participant owns atomic idempotency. */
+    settleChampion(work: BracketAdmissionScope & {
+        readonly requestId: string;
+        readonly winnerId: string;
+        readonly ruleVersion: string;
+    }): Effect.Effect<void, LeaderboardError>;
+    withdrawSubject(request: PluginPrivacyRequest): Effect.Effect<void, LeaderboardError>;
+    /** Must withdraw pending request identities too, even with lost Room replies. */
+    withdrawTournament(scope: BracketAdmissionScope, request: PluginPrivacyRequest): Effect.Effect<void, LeaderboardError>;
+    authorizeExport(request: PluginPrivacyRequest): Effect.Effect<void, LeaderboardError>;
+}
+
+/** 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>;
+
+/** Explicit ordinary schema contribution; no hidden startup or timer. */
+export declare const tournamentBracketsTable: TableLike;
+
+export declare interface TournamentBracketStatus {
+    readonly phase: BracketState['phase'];
+    readonly format: TournamentBracketFormat;
+    readonly champion: string | null;
+    readonly matches: ReadonlyArray<TournamentBracketMatch>;
+    readonly unresolvedDisputes: number;
+}
+
+export declare interface TournamentConfiguration {
+    readonly backend: 'sql' | 'custom';
+    readonly version: string;
+    readonly maxTenantTournaments: number | null;
+    readonly stage: {
+        readonly backend: 'sql' | 'custom';
+        readonly version: string;
+    } | null;
+    readonly workflowSource: 'default' | 'custom' | null;
+}
+
+declare interface TournamentDefinition {
+    readonly name: string;
+    readonly board: string;
+    readonly startsAt: number;
+    readonly endsAt: number;
+    readonly maxEntries: number;
+    readonly joinRequired?: boolean;
+    readonly attemptsPerEntry?: number;
+}
+
+declare interface TournamentDescriptor extends Omit<TournamentDefinition, 'joinRequired' | 'attemptsPerEntry'> {
+    readonly kind: 'tournament';
+    readonly format: 'time-window';
+    readonly joinRequired: boolean;
+    readonly attemptsPerEntry: number;
+}
+
+export declare interface TournamentDisputeIntent {
+    readonly disputeId: string;
+    readonly matchId: string;
+    readonly reason: 'result_mismatch' | 'no_show' | 'connection';
+}
+
+export declare interface TournamentDisputeResolution {
+    readonly disputeId: string;
+    readonly resolutionId: string;
+    readonly winnerId: string;
+}
+
+declare interface TournamentEntrant {
+    readonly entrantId: string;
+    readonly seed: number;
+}
+
+/** A tournament stage's `notifyEntrants` participant: when registration or check-in opens, every
+ * registered player gets an inbox message (at check-in only those not checked in yet). Each
+ * message is keyed by the stage request and the player, so a retried reminder sends none twice. */
+export declare const tournamentInboxNotice: (liveops: TournamentInboxSource, admissions: () => {
+    entrants(subject: ReturnType<typeof systemSubject>, scope: BracketAdmissionScope): Effect.Effect<BracketAdmissionEntrants, unknown>;
+}, options: TournamentInboxNoticeOptions) => (work: {
+    readonly tenantId: string;
+    readonly tournamentId: string;
+    readonly phase: "registration" | "check-in";
+    readonly requestId: string;
+}) => Effect.Effect<void, LeaderboardError>;
+
+export declare interface TournamentInboxNoticeOptions {
+    /** Inbox templates per stage phase; `tournamentId` and `phase` are passed as parameters. */
+    readonly templates: {
+        readonly registration: string;
+        readonly 'check-in': string;
+    };
+}
+
+/** A tournament bracket's `settleChampion` participant: the champion gets an inbox message with
+ * the prize attachments. The bracket's settlement request is the inbox request ID, so a retried
+ * settlement sends one message. */
+export declare const tournamentInboxPrize: (liveops: TournamentInboxSource, options: TournamentInboxPrizeOptions) => (work: {
+    readonly tenantId: string;
+    readonly tournamentId: string;
+    readonly requestId: string;
+    readonly winnerId: string;
+}) => Effect.Effect<void, LeaderboardError>;
+
+export declare interface TournamentInboxPrizeOptions {
+    /** A declared LiveOps inbox template; `tournamentId` is passed as a message parameter. */
+    readonly templateId: string;
+    /** Rewards the champion claims from the message (`{ kind: 'currency', currency, amount }` or `{ kind: 'item', itemId, qty }`). */
+    readonly attachments?: ReadonlyArray<Readonly<Record<string, unknown>>>;
+    /** How long the message stays claimable; omitted: until claimed. */
+    readonly expiresInMs?: number;
+    readonly now?: () => number;
+}
+
+/** The slice of an installed LiveOps plugin the prize participant uses (no package dependency). */
+export declare interface TournamentInboxSource {
+    readonly inbox: () => {
+        send(authority: ReturnType<typeof systemSubject>, tenantId: string, ownerId: string, input: {
+            readonly requestId: string;
+            readonly templateId: string;
+            readonly params: Readonly<Record<string, string | number | boolean | null>>;
+            readonly attachments: ReadonlyArray<Readonly<Record<string, unknown>>>;
+            readonly expiresAt: number | null;
+        }): Effect.Effect<unknown, unknown>;
+    };
+}
+
+export declare interface TournamentResultReport extends TournamentRoomReceipt {
+    readonly matchId: string;
+    readonly reportId: string;
+    readonly winnerId: string;
+}
+
+export declare interface TournamentRoomReceipt {
+    readonly roomId: string;
+    readonly epoch: number;
+}
+
+export declare interface TournamentRoomWork extends BracketAdmissionScope {
+    readonly matchId: string;
+    readonly requestId: string;
+    readonly left: string;
+    readonly right: string;
+    readonly ruleVersion: string;
+}
+
+export declare type TournamentStageBinding = ({
+    readonly backend: 'sql';
+    readonly options: Omit<TournamentStageOptions, 'admissions' | 'brackets'>;
+} | {
+    readonly backend: 'custom';
+    readonly version: string;
+    readonly service: TournamentStageService;
+}) & {
+    readonly privacy: TournamentStagePrivacy;
+};
+
+/** Absolute sleeps retain the admitted instant on replay. Every checkpointed
+ * result contains only configuration or aggregate status, never player data. */
+export declare const tournamentStageExecutor: (context: Pick<AppContext, "request">) => (input: TournamentStagePayload) => Effect.Effect<{
+    readonly phase: "cancelled" | "complete" | "active" | "paused" | "erasing";
+    readonly ready: number;
+    readonly completed: number;
+    readonly waiting: number;
+    readonly unresolvedDisputes: number;
+}, LeaderboardError, TournamentBracketPort | TournamentStagePort | WorkflowEngine | WorkflowInstance>;
+
+export declare const tournamentStageLayer: (store: DataStore, options: TournamentStageOptions) => Layer.Layer<TournamentStagePort>;
+
+export declare interface TournamentStageOptions {
+    readonly epochNow: () => number;
+    readonly admissions: Pick<BracketAdmissionService, 'seal'>;
+    readonly brackets: Pick<TournamentBracketService, 'create'>;
+    authorize(subject: Subject, scope: BracketAdmissionScope, operation: 'window' | 'notify' | 'seed'): Effect.Effect<void, LeaderboardError>;
+    /** Current SQL/rating/no-show preparation participant. Same request must
+     * recover the same durable seed decision, never reread a changed prior. */
+    seedRoster(work: TournamentStagePayload & BracketAdmissionRoster & {
+        readonly requestId: string;
+    }): Effect.Effect<ReadonlyArray<TournamentEntrant>, LeaderboardError>;
+    /** Actual Inbox/Push idempotency and external withdrawal remain required. */
+    notifyEntrants(work: TournamentStagePayload & {
+        readonly phase: 'registration' | 'check-in';
+        readonly requestId: string;
+    }): Effect.Effect<void, LeaderboardError>;
+}
+
+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 interface TournamentStagePrivacy {
+    /** Own subject data from actual seed/notification participants, no peer export. */
+    exportSubject(request: PluginPrivacyRequest): Effect.Effect<unknown, LeaderboardError>;
+    /** Permanently withdraw accepted seed/reminder work before subject cleanup. */
+    eraseSubject(request: PluginPrivacyRequest): Effect.Effect<void, LeaderboardError>;
+}
+
+export declare type TournamentStageService = Context.Service.Shape<typeof TournamentStagePort>;
+
+/** The part of a handler's `ctx` this needs: the app's workflow service. */
+export declare interface TournamentWorkflowStarter {
+    readonly workflows?: {
+        start(workflowName: string, payload: unknown): Promise<unknown>;
+    } | undefined;
+}
+
+/** 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 { }