@voltro/plugin-progression 0.0.0-stage → 0.88.0

package/dist/testing.d.ts

@@ -0,0 +1,1566 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { Layer } from 'effect';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+declare type AchievementCondition = StatThreshold | CompositeCondition;
+
+declare interface AchievementEvaluation {
+    readonly met: boolean;
+    readonly progress: readonly AchievementProgress[];
+}
+
+declare type AchievementEvaluator = (input: {
+    readonly condition: AchievementCondition;
+    readonly stats: readonly AchievementStat[];
+}) => AchievementEvaluation;
+
+export declare const achievementEvaluatorSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: AchievementEvaluator;
+    defaultProbe: {
+        run: () => Effect.Effect< AchievementEvaluation, never, never>;
+        expected: {
+            met: boolean;
+            progress: {
+                stat: string;
+                period: string;
+                seasonId: null;
+                value: string;
+                target: string;
+                met: boolean;
+            }[];
+        };
+    };
+    overrideProbe: {
+        run: () => Effect.Effect< AchievementEvaluation, never, never>;
+        expected: {
+            met: boolean;
+            progress: {
+                stat: string;
+                period: string;
+                seasonId: null;
+                value: string;
+                target: string;
+                met: boolean;
+            }[];
+        };
+    };
+}>;
+
+export declare const achievementFakeLayer: Layer.Layer<FixturePorts, never, never>;
+
+declare interface AchievementPlatform {
+    readonly steam?: string;
+    readonly gameCenter?: string;
+    readonly playGames?: string;
+}
+
+declare class AchievementPort extends AchievementPort_base {
+}
+
+declare const AchievementPort_base: Context.ServiceClass<AchievementPort, "@voltro/AchievementPort", AchievementService>;
+
+export declare const achievementPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof AchievementPort;
+    fakeLayer: Layer.Layer<FixturePorts, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            original: boolean;
+            achievements: {
+                id: string;
+                tier: string;
+                unlocked: boolean;
+                value: string | undefined;
+            }[];
+        }, ProgressionError, never>;
+        expected: {
+            original: boolean;
+            achievements: {
+                id: string;
+                tier: string;
+                unlocked: boolean;
+                value: string;
+            }[];
+        };
+    };
+}>;
+
+declare interface AchievementProgress extends AchievementStat {
+    readonly target: string;
+    readonly met: boolean;
+}
+
+declare interface AchievementReceipt {
+    readonly operationId: string;
+    readonly throughSequence: number;
+    readonly unlockedIds: readonly string[];
+    readonly rewardsQueued: number;
+    readonly at: number;
+}
+
+declare interface AchievementService {
+    readonly evaluate: (subject: Subject, input: EvaluateAchievementsInput) => Effect.Effect<AchievementReceipt, ProgressionError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly PlayerAchievement[], ProgressionError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, ProgressionError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, ProgressionError>;
+}
+
+declare interface AchievementStat {
+    readonly stat: string;
+    readonly period: 'lifetime' | 'season';
+    readonly seasonId: string | null;
+    readonly value: string;
+}
+
+declare interface AchievementStatEvent extends AchievementStat {
+    readonly operationId: string;
+    readonly sequence: number;
+    readonly at: number;
+}
+
+declare interface AchievementStatHistory {
+    readonly version: string;
+    readonly throughSequence: number;
+    readonly initial: readonly AchievementStat[];
+    readonly events: readonly AchievementStatEvent[];
+}
+
+declare class AchievementStatSource extends AchievementStatSource_base {
+}
+
+declare const AchievementStatSource_base: Context.ServiceClass<AchievementStatSource, "@voltro/AchievementStatSource", AchievementStatSourceService>;
+
+export declare const achievementStatSourceFakeLayer: Layer.Layer<FixturePorts, never, never>;
+
+declare interface AchievementStatSourceService {
+    readonly history: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly limit: number;
+    }) => Effect.Effect<AchievementStatHistory, ProgressionError>;
+}
+
+export declare const achievementStatSourceSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof AchievementStatSource;
+    fakeLayer: Layer.Layer<FixturePorts, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            stat: string;
+            value: string;
+        }[], ProgressionError, never>;
+        expected: {
+            stat: string;
+            value: string;
+        }[];
+    };
+}>;
+
+declare interface ApplyStatInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly stat: string;
+    readonly period: 'lifetime' | 'season';
+    readonly seasonId?: string | null;
+    readonly operator: StatOperator;
+    readonly operand: ProgressValue;
+    readonly requestId: string;
+    readonly source: string;
+    readonly origin: string;
+}
+
+declare interface ApplyXpInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly trackId: string;
+    readonly amount: ProgressValue;
+    readonly requestId: string;
+    readonly source: string;
+    readonly origin: string;
+}
+
+declare interface AssignQuestsInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly poolId: string;
+    readonly requestId: string;
+    readonly expectedPoolDigest?: string;
+    readonly windowId: string;
+    readonly from: number;
+    readonly until: number;
+    readonly timezone: string;
+    readonly seed: number;
+}
+
+declare interface CompositeCondition {
+    readonly kind: 'composite';
+    readonly mode: 'all' | 'any';
+    readonly conditions: readonly AchievementCondition[];
+}
+
+declare interface DailyClaimInput {
+    readonly calendarId: string;
+    readonly requestId: string;
+}
+
+declare interface DailyClaimPlan {
+    readonly dayIndex: number;
+    readonly streak: number;
+    readonly protectionRemaining: number;
+    readonly cycle: number;
+}
+
+declare type DailyClaimPolicy = (input: DailyClaimPolicyContext) => DailyClaimPlan;
+
+declare interface DailyClaimPolicyContext {
+    readonly calendar: LoginCalendar;
+    readonly previous: DailyState | null;
+    readonly window: DailyWindow;
+    readonly at: number;
+}
+
+export declare const dailyClaimPolicySystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: DailyClaimPolicy;
+    defaultProbe: {
+        run: () => Effect.Effect<{
+            dayIndex: number;
+            streak: number;
+        }, never, never>;
+        expected: {
+            dayIndex: number;
+            streak: number;
+        };
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<{
+            dayIndex: number;
+            streak: number;
+        }, never, never>;
+        expected: {
+            dayIndex: number;
+            streak: number;
+        };
+    };
+}>;
+
+declare interface DailyProfile {
+    readonly timezone: string;
+    readonly version: string;
+}
+
+declare class DailyProfileSource extends DailyProfileSource_base {
+}
+
+declare const DailyProfileSource_base: Context.ServiceClass<DailyProfileSource, "@voltro/DailyProfileSource", DailyProfileSourceService>;
+
+export declare const dailyProfileSourceFakeLayer: Layer.Layer<DailyProfileSource, never, never>;
+
+declare interface DailyProfileSourceService {
+    readonly read: (subject: Subject, scope: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+    }) => Effect.Effect<DailyProfile, ProgressionError>;
+}
+
+export declare const dailyProfileSourceSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof DailyProfileSource;
+    fakeLayer: Layer.Layer<DailyProfileSource, never, never>;
+    probe: {
+        run: () => Effect.Effect< DailyProfile, ProgressionError, never>;
+        expected: {
+            timezone: string;
+            version: string;
+        };
+    };
+}>;
+
+declare interface DailyReceipt {
+    readonly operationId: string;
+    readonly claimId: string;
+    readonly calendarId: string;
+    readonly dayKey: string;
+    readonly after: DailyState;
+    readonly rewardsQueued: number;
+    readonly at: number;
+}
+
+declare interface DailyState extends DailyWindow {
+    readonly calendarId: string;
+    readonly version: number;
+    readonly dayIndex: number;
+    readonly streak: number;
+    readonly protectionRemaining: number;
+    readonly cycle: number;
+    readonly at: number;
+}
+
+declare interface DailyWindow {
+    readonly dayKey: string;
+    readonly dayOrdinal: number;
+    readonly from: number;
+    readonly until: number;
+    readonly timezone: string;
+}
+
+export declare const defaultPassCatchUp: PassCatchUp;
+
+export declare const defaultQuestProgressResolver: QuestProgressResolver;
+
+/** Deterministic weighted selection without replacement; a trusted seed is not a security RNG. */
+export declare const defaultQuestSelector: QuestSelector;
+
+/** A read-only displayed score; it never writes or claims to decay the Ratings SQL pool. */
+export declare const defaultRankDecay: RankDecayResolver;
+
+export declare const defaultRankGrade: RankGradeResolver;
+
+export declare const defaultRankScore: RankScoreResolver;
+
+export declare const defaultRankSeasonReset: RankSeasonReset;
+
+export declare const defaultResourceRegen: ResourceRegenResolver;
+
+export declare const defaultTutorialStepPolicy: TutorialStepPolicy;
+
+export declare const defineQuestPool: (input: QuestPoolDefinition) => QuestPool;
+
+export declare const defineRegenResource: (input: RegenResourceDefinition | RegenResource) => RegenResource;
+
+declare interface EvaluateAchievementsInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly requestId: string;
+}
+
+declare type FixturePorts = ProgressionPort | QuestPort | QuestSource | RegenResourcePort | AchievementPort | AchievementStatSource | SeasonPassPort;
+
+declare type InitializeResourceInput = Omit<ResourceChangeInput, 'amount'>;
+
+declare interface LevelCurve {
+    readonly thresholds: readonly string[];
+}
+
+declare interface LevelReward {
+    readonly level: number;
+    readonly reward: ProgressionReward;
+}
+
+declare interface LoginCalendar {
+    readonly id: string;
+    readonly version: number;
+    readonly days: readonly (readonly ProgressionReward[])[];
+    readonly streakProtection: number;
+}
+
+/** Test-only actual installed login calendar on a private store; the profile
+ * source is an explicit fixture timezone, not a production profile provider. */
+export declare const loginCalendarFakeLayer: Layer.Layer<LoginCalendarPort>;
+
+declare class LoginCalendarPort extends LoginCalendarPort_base {
+}
+
+declare const LoginCalendarPort_base: Context.ServiceClass<LoginCalendarPort, "@voltro/LoginCalendarPort", LoginCalendarService>;
+
+export declare const loginCalendarPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof LoginCalendarPort;
+    fakeLayer: Layer.Layer<LoginCalendarPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            original: boolean;
+            rewardsQueued: number;
+            calendars: {
+                claimed: boolean;
+                streak: number;
+                dayIndex: number;
+            }[];
+        }, ProgressionError, never>;
+        expected: {
+            original: boolean;
+            rewardsQueued: number;
+            calendars: {
+                claimed: boolean;
+                streak: number;
+                dayIndex: number;
+            }[];
+        };
+    };
+}>;
+
+declare interface LoginCalendarService {
+    readonly claim: (subject: Subject, input: DailyClaimInput) => Effect.Effect<DailyReceipt, ProgressionError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly PlayerDaily[], ProgressionError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, ProgressionError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, ProgressionError>;
+}
+
+declare type PassCatchUp = (input: PassCatchUpContext) => ProgressValue;
+
+declare interface PassCatchUpContext {
+    readonly pass: SeasonPass;
+    readonly amount: string;
+    readonly at: number;
+}
+
+export declare const passCatchUpSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: PassCatchUp;
+    defaultProbe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+}>;
+
+declare interface PassClaimInput {
+    readonly passId: string;
+    readonly tier: number;
+    readonly track: PassTrack;
+    readonly requestId: string;
+}
+
+declare interface PassCloseInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly passId: string;
+    readonly requestId: string;
+}
+
+export declare const passFakeLayer: Layer.Layer<FixturePorts, never, never>;
+
+export declare const passFixture: () => Readonly<{
+    pass: SeasonPass;
+    state: PassState;
+    passCatchUp: Readonly<{
+        pass: SeasonPass;
+        amount: "100";
+        at: number;
+    }>;
+}>;
+
+export declare const passPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof SeasonPassPort;
+    fakeLayer: Layer.Layer<FixturePorts, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            original: boolean;
+            claimedFree: string;
+            rewardsQueued: number;
+            passes: {
+                xp: string;
+                tier: number;
+                claimedFree: string;
+            }[];
+        }, ProgressionError, never>;
+        expected: {
+            original: boolean;
+            claimedFree: string;
+            rewardsQueued: number;
+            passes: {
+                xp: string;
+                tier: number;
+                claimedFree: string;
+            }[];
+        };
+    };
+}>;
+
+declare interface PassPremiumInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly passId: string;
+    readonly offerId: string;
+    readonly fulfillmentId: string;
+    readonly requestId: string;
+}
+
+declare interface PassReceipt {
+    readonly operationId: string;
+    readonly kind: 'xp' | 'premium' | 'claim' | 'close';
+    readonly after: PassState;
+    readonly claims: readonly PassTierClaim[];
+    readonly rewardsQueued: number;
+    readonly at: number;
+}
+
+declare interface PassState {
+    readonly passId: string;
+    readonly version: number;
+    readonly xp: string;
+    readonly claimedFree: string;
+    readonly claimedPremium: string;
+    readonly premium: boolean;
+    readonly purchasedAt: number | null;
+    readonly fulfillmentId: string | null;
+    readonly closed: boolean;
+    readonly updatedAt: number;
+}
+
+declare interface PassTierClaim {
+    readonly tier: number;
+    readonly track: PassTrack;
+    readonly rewards: readonly ProgressionReward[];
+}
+
+declare type PassTrack = 'free' | 'premium';
+
+declare interface PassXpInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly passId: string;
+    readonly amount: ProgressValue;
+    readonly source: string;
+    readonly originId: string;
+    readonly requestId: string;
+}
+
+declare interface PlayerAchievement {
+    readonly achievementId: string;
+    readonly version: number;
+    readonly tierId: string;
+    readonly unlocked: boolean;
+    readonly unlockedAt: number | null;
+    readonly progress: readonly AchievementProgress[];
+    readonly platform: AchievementPlatform | null;
+}
+
+declare interface PlayerDaily {
+    readonly calendarId: string;
+    readonly version: number;
+    readonly dayKey: string;
+    readonly timezone: string;
+    readonly from: number;
+    readonly until: number;
+    readonly observedAt: number;
+    readonly claimed: boolean;
+    readonly dayIndex: number;
+    readonly streak: number;
+    readonly protectionRemaining: number;
+    readonly reward: readonly ProgressionReward[];
+}
+
+declare interface PlayerPass extends PassState {
+    readonly tier: number;
+    readonly from: number;
+    readonly until: number;
+    readonly observedAt: number;
+    readonly active: boolean;
+    readonly premiumOffer: string | null;
+    readonly claimable: readonly PassTierClaim[];
+}
+
+declare interface PlayerQuest {
+    readonly id: string;
+    readonly poolId: string;
+    readonly windowId: string;
+    readonly quest: QuestDefinition;
+    readonly progress: readonly number[];
+    readonly state: 'active' | 'completed';
+    readonly assignedAt: number;
+    readonly expiresAt: number;
+    readonly rerollsUsed: number;
+    readonly rerollsAllowed: number;
+}
+
+declare interface PlayerRank {
+    readonly ladderId: string;
+    readonly version: number;
+    readonly pool: string;
+    readonly games: number;
+    readonly placementsRemaining: number;
+    readonly rawScore: number;
+    readonly score: number;
+    readonly grade: RankGrade | null;
+    readonly ratingUpdatedAt: number | null;
+    readonly observedAt: number;
+    readonly rulesVersion: string;
+}
+
+declare interface PlayerResource {
+    readonly resourceId: string;
+    readonly value: string;
+    readonly max: string;
+    readonly initialized: boolean;
+    readonly observedAt: number;
+    readonly nextRegenAt: number | null;
+    readonly refillOffer?: string;
+}
+
+declare interface PlayerStat {
+    readonly stat: string;
+    readonly period: 'lifetime' | 'season';
+    readonly seasonId: string | null;
+    readonly value: string;
+    readonly updatedAt: number;
+}
+
+declare interface PlayerTrack {
+    readonly trackId: string;
+    readonly xp: string;
+    readonly level: number;
+    readonly prestige: number;
+    readonly updatedAt: number | null;
+}
+
+declare interface PlayerTutorial extends TutorialState {
+    readonly nextStep: string | null;
+    readonly skippable: boolean;
+    readonly hints: string | null;
+}
+
+declare type ProgressionChange = {
+    readonly kind: 'xp';
+    readonly trackId: string;
+    readonly xp: string;
+    readonly delta: string;
+    readonly fromLevel: number;
+    readonly toLevel: number;
+} | {
+    readonly kind: 'stat';
+    readonly stat: string;
+    readonly period: 'lifetime' | 'season';
+    readonly seasonId: string | null;
+    readonly value: string;
+    readonly operator: StatOperator;
+};
+
+declare class ProgressionError extends ProgressionError_base {
+}
+
+declare const ProgressionError_base: Schema.Class<ProgressionError, Schema.TaggedStruct<"ProgressionError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_record", "invalid_curve", "invalid_reward", "invalid_track", "invalid_stat", "overflow", "insufficient_resource", "forbidden", "conflict", "erased", "not_found", "limit_exceeded", "unavailable"]>;
+}>, YieldableError>;
+
+export declare const progressionFakeLayer: Layer.Layer<FixturePorts, never, never>;
+
+export declare const progressionFixture: () => Readonly<{
+    curve: LevelCurve;
+    track: ProgressionTrack;
+    xpCurve: Readonly<{
+        xp: "100";
+        curve: LevelCurve;
+    }>;
+    rewardResolver: Readonly<{
+        track: ProgressionTrack;
+        fromLevel: 1;
+        toLevel: 2;
+    }>;
+}>;
+
+declare class ProgressionPort extends ProgressionPort_base {
+}
+
+declare const ProgressionPort_base: Context.ServiceClass<ProgressionPort, "@voltro/ProgressionPort", ProgressionService>;
+
+export declare const progressionPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof ProgressionPort;
+    fakeLayer: Layer.Layer<FixturePorts, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            original: boolean;
+            tracks: {
+                xp: string;
+                level: number;
+            }[];
+            stats: string[];
+            rewardsQueued: number;
+        }, ProgressionError, never>;
+        expected: {
+            original: boolean;
+            tracks: {
+                xp: string;
+                level: number;
+            }[];
+            stats: string[];
+            rewardsQueued: number;
+        };
+    };
+}>;
+
+declare interface ProgressionReceipt {
+    readonly operationId: string;
+    readonly at: number;
+    readonly change: ProgressionChange;
+    readonly rewardsQueued: number;
+}
+
+declare type ProgressionReward = {
+    readonly kind: 'currency';
+    readonly currency: string;
+    readonly amount: string;
+} | {
+    readonly kind: 'item';
+    readonly itemId: string;
+    readonly qty: number;
+} | {
+    readonly kind: 'xp';
+    readonly trackId: string;
+    readonly amount: string;
+};
+
+declare interface ProgressionService {
+    readonly applyXp: (subject: Subject, input: ApplyXpInput) => Effect.Effect<ProgressionReceipt, ProgressionError>;
+    readonly applyStat: (subject: Subject, input: ApplyStatInput) => Effect.Effect<ProgressionReceipt, ProgressionError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly PlayerTrack[], ProgressionError>;
+    readonly stats: (subject: Subject) => Effect.Effect<readonly PlayerStat[], ProgressionError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, ProgressionError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, ProgressionError>;
+}
+
+declare interface ProgressionTrack {
+    readonly id: string;
+    readonly version: number;
+    readonly xpCurve: LevelCurve;
+    readonly sources: readonly string[];
+    readonly rewards: Readonly<Record<string, readonly ProgressionReward[]>>;
+    readonly every: Readonly<Record<string, readonly ProgressionReward[]>>;
+}
+
+declare type ProgressValue = string | number | bigint;
+
+declare interface QuestDefinition {
+    readonly id: string;
+    readonly titleKey?: string;
+    readonly objectives: readonly QuestObjective[];
+    readonly reward: readonly ProgressionReward[];
+}
+
+export declare const questFakeLayer: Layer.Layer<FixturePorts, never, never>;
+
+declare type QuestObjective = {
+    readonly stat: string;
+    readonly target: number;
+} | {
+    readonly event: string;
+    readonly target: number;
+    readonly where?: Readonly<Record<string, QuestScalar>>;
+};
+
+declare interface QuestPool extends QuestPoolDefinition {
+    readonly version: number;
+    readonly rerolls: number;
+    readonly weights: Readonly<Record<string, number>>;
+}
+
+declare interface QuestPoolDefinition {
+    readonly id: string;
+    readonly version?: number;
+    readonly slots: number;
+    readonly rerolls?: number;
+    readonly refresh: {
+        readonly cron: string;
+        readonly timezone: string;
+    };
+    readonly quests: readonly QuestDefinition[];
+    readonly weights?: Readonly<Record<string, number>>;
+}
+
+declare class QuestPort extends QuestPort_base {
+}
+
+declare const QuestPort_base: Context.ServiceClass<QuestPort, "@voltro/QuestPort", QuestService>;
+
+export declare const questPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof QuestPort;
+    fakeLayer: Layer.Layer<FixturePorts, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            original: boolean;
+            quests: {
+                progress: readonly number[];
+                state: "completed" | "active";
+            }[];
+        }, ProgressionError, never>;
+        expected: {
+            original: boolean;
+            quests: {
+                progress: number[];
+                state: string;
+            }[];
+        };
+    };
+}>;
+
+declare interface QuestProgressContext {
+    readonly quest: QuestDefinition;
+    readonly progress: readonly number[];
+    readonly signal: QuestSignal;
+}
+
+declare type QuestProgressResolver = (context: QuestProgressContext) => readonly number[];
+
+export declare const questProgressResolverSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: QuestProgressResolver;
+    defaultProbe: {
+        run: () => Effect.Effect<readonly number[], never, never>;
+        expected: number[];
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<readonly number[], never, never>;
+        expected: number[];
+    };
+}>;
+
+declare interface QuestReceipt {
+    readonly operationId: string;
+    readonly kind: 'assign' | 'record' | 'reroll';
+    readonly assignmentIds: readonly string[];
+    readonly completedIds: readonly string[];
+    readonly rewardsQueued: number;
+    readonly at: number;
+}
+
+declare type QuestScalar = string | number | boolean | null;
+
+declare type QuestSelector = (context: QuestSelectorContext) => readonly string[];
+
+declare interface QuestSelectorContext {
+    readonly pool: QuestPool;
+    readonly count: number;
+    readonly seed: number;
+    readonly excluded: readonly string[];
+}
+
+export declare const questSelectorSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: QuestSelector;
+    defaultProbe: {
+        run: () => Effect.Effect<readonly string[], never, never>;
+        expected: string[];
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<readonly string[], never, never>;
+        expected: string[];
+    };
+}>;
+
+declare interface QuestService {
+    readonly assign: (subject: Subject, input: AssignQuestsInput) => Effect.Effect<QuestReceipt, ProgressionError>;
+    readonly record: (subject: Subject, input: RecordQuestInput) => Effect.Effect<QuestReceipt, ProgressionError>;
+    readonly reroll: (subject: Subject, input: RerollQuestInput) => Effect.Effect<QuestReceipt, ProgressionError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly PlayerQuest[], ProgressionError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, ProgressionError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, ProgressionError>;
+}
+
+declare type QuestSignal = {
+    readonly kind: 'stat';
+    readonly stat: string;
+    readonly delta: string;
+} | {
+    readonly kind: 'event';
+    readonly event: string;
+    readonly data: Readonly<Record<string, QuestScalar>>;
+};
+
+declare type QuestSignalInput = {
+    readonly kind: 'stat';
+    readonly stat: string;
+    readonly delta: ProgressValue;
+} | {
+    readonly kind: 'event';
+    readonly event: string;
+    readonly data?: Readonly<Record<string, QuestScalar>>;
+};
+
+declare class QuestSource extends QuestSource_base {
+}
+
+declare const QuestSource_base: Context.ServiceClass<QuestSource, "@voltro/QuestSource", QuestSourceService>;
+
+export declare const questSourceFakeLayer: Layer.Layer<FixturePorts, never, never>;
+
+declare interface QuestSourceScope {
+    readonly tenantId: string;
+    readonly channel: string;
+    readonly locale: string;
+}
+
+declare interface QuestSourceService {
+    readonly read: (scope: QuestSourceScope) => Effect.Effect<{
+        readonly revision: string;
+        readonly pools: readonly QuestPool[];
+    }, ProgressionError>;
+}
+
+export declare const questSourceSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof QuestSource;
+    fakeLayer: Layer.Layer<FixturePorts, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            revision: string;
+            pools: string[];
+        }, ProgressionError, never>;
+        expected: {
+            revision: string;
+            pools: string[];
+        };
+    };
+}>;
+
+declare interface RankCloseInput extends RankObserveInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+}
+
+declare interface RankContext {
+    readonly ladder: RankLadder;
+    readonly rating: RankRating;
+    readonly at: number;
+}
+
+declare interface RankDecayDefinition {
+    readonly afterDays: number;
+    readonly perDay: number;
+    readonly floor: number;
+}
+
+declare type RankDecayResolver = (input: RankGradeContext) => number;
+
+export declare const rankDecaySystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: RankDecayResolver;
+    defaultProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+}>;
+
+/** Test-only actual installed rank seasons on a private store; the rating source
+ * is an explicit fixture rating, not the Ratings SQL pool. */
+export declare const rankFakeLayer: Layer.Layer<RankPort>;
+
+export declare const rankFixture: () => Readonly<{
+    ladder: RankLadder;
+    rating: Readonly<{
+        pool: "test.ranked";
+        state: Readonly<{
+            algorithm: "elo";
+            rating: 250;
+        }>;
+        games: 10;
+        updatedAt: 1000;
+    }>;
+    at: 1000;
+}>;
+
+declare interface RankGrade {
+    readonly index: number;
+    readonly tier: string;
+    readonly tierIndex: number;
+    readonly division: number;
+}
+
+declare interface RankGradeContext extends RankContext {
+    readonly score: number;
+}
+
+declare type RankGradeResolver = (input: RankGradeContext) => RankGrade | null;
+
+export declare const rankGradeSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: RankGradeResolver;
+    defaultProbe: {
+        run: () => Effect.Effect<{
+            tier: string;
+            division: number;
+        } | null, never, never>;
+        expected: {
+            tier: string;
+            division: number;
+        };
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<{
+            tier: string;
+            division: number;
+        } | null, never, never>;
+        expected: {
+            tier: string;
+            division: number;
+        };
+    };
+}>;
+
+declare interface RankLadder {
+    readonly id: string;
+    readonly version: number;
+    readonly rating: string;
+    readonly tiers: readonly string[];
+    readonly divisions: number;
+    readonly thresholds: readonly number[];
+    readonly placements: number;
+    readonly confidence: number;
+    readonly decay: RankDecayDefinition | null;
+    readonly softReset: RankResetDefinition | null;
+}
+
+declare interface RankObserveInput {
+    readonly seasonId: string;
+    readonly requestId: string;
+}
+
+declare class RankPort extends RankPort_base {
+}
+
+declare const RankPort_base: Context.ServiceClass<RankPort, "@voltro/RankPort", RankSeasonService>;
+
+export declare const rankPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof RankPort;
+    fakeLayer: Layer.Layer<RankPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            original: boolean;
+            highest: string | null;
+            seasons: number;
+        }, ProgressionError, never>;
+        expected: {
+            original: boolean;
+            highest: string;
+            seasons: number;
+        };
+    };
+}>;
+
+declare interface RankRating {
+    readonly pool: string;
+    readonly state: RankRatingState;
+    readonly games: number;
+    readonly updatedAt: number | null;
+}
+
+declare class RankRatingSource extends RankRatingSource_base {
+}
+
+declare const RankRatingSource_base: Context.ServiceClass<RankRatingSource, "@voltro/RankRatingSource", RankRatingSourceService>;
+
+export declare const rankRatingSourceFakeLayer: Layer.Layer<RankRatingSource, never, never>;
+
+declare interface RankRatingSourceService {
+    readonly read: (subject: Subject, pool: string) => Effect.Effect<RankRating, ProgressionError>;
+}
+
+export declare const rankRatingSourceSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof RankRatingSource;
+    fakeLayer: Layer.Layer<RankRatingSource, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            games: number;
+            updatedAt: number | null;
+        }, ProgressionError, never>;
+        expected: {
+            games: number;
+            updatedAt: number;
+        };
+    };
+}>;
+
+/** SQL Ratings remain the authority; this detached shape matches Ratings.myRating. */
+declare type RankRatingState = {
+    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;
+};
+
+declare interface RankResetContext {
+    readonly ladder: RankLadder;
+    readonly score: number;
+}
+
+declare interface RankResetDefinition {
+    readonly target: number;
+    readonly retain: number;
+}
+
+declare type RankScoreResolver = (input: RankContext) => number;
+
+export declare const rankScoreSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: RankScoreResolver;
+    defaultProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+}>;
+
+declare interface RankSeason {
+    readonly id: string;
+    readonly version: number;
+    readonly ladderId: string;
+    readonly from: number;
+    readonly until: number;
+    readonly rewards: readonly (readonly ProgressionReward[])[];
+}
+
+export declare const rankSeasonPolicyFixture: () => Readonly<{
+    ladder: RankLadder;
+    rating: Readonly<{
+        pool: "test.ranked";
+        state: Readonly<{
+            algorithm: "elo";
+            rating: 250;
+        }>;
+        games: 10;
+        updatedAt: 1000;
+    }>;
+    at: 1000;
+    season: RankSeason;
+    state: RankSeasonState;
+}>;
+
+declare interface RankSeasonReceipt {
+    readonly operationId: string;
+    readonly kind: 'observe' | 'close';
+    readonly after: RankSeasonState;
+    readonly rewardsQueued: number;
+    readonly at: number;
+}
+
+declare type RankSeasonReset = (input: RankResetContext) => number;
+
+export declare const rankSeasonResetSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: RankSeasonReset;
+    defaultProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+}>;
+
+declare interface RankSeasonService {
+    readonly observe: (subject: Subject, input: RankObserveInput) => Effect.Effect<RankSeasonReceipt, ProgressionError>;
+    readonly close: (subject: Subject, input: RankCloseInput) => Effect.Effect<RankSeasonReceipt, ProgressionError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly RankSeasonState[], ProgressionError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, ProgressionError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, ProgressionError>;
+}
+
+declare interface RankSeasonState {
+    readonly seasonId: string;
+    readonly version: number;
+    readonly ladderId: string;
+    readonly observations: number;
+    readonly last: PlayerRank | null;
+    readonly highest: RankGrade | null;
+    readonly closedAt: number | null;
+    readonly resetScore: number | null;
+}
+
+declare interface RecordQuestInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly poolId: string;
+    readonly windowId: string;
+    readonly requestId: string;
+    readonly source: string;
+    readonly origin: string;
+    readonly signal: QuestSignalInput;
+}
+
+declare interface RegenResource {
+    readonly id: string;
+    readonly version: number;
+    readonly max: string;
+    readonly initial: string;
+    readonly regenPer: string;
+    readonly regenAmount: string;
+    readonly regenEveryMs: number;
+    readonly refillOffer?: string;
+}
+
+declare interface RegenResourceDefinition {
+    readonly id: string;
+    readonly version?: number;
+    readonly max: ProgressValue;
+    readonly initial?: ProgressValue;
+    readonly regenPer: string;
+    readonly regenAmount?: ProgressValue;
+    readonly refillOffer?: string;
+}
+
+declare class RegenResourcePort extends RegenResourcePort_base {
+}
+
+declare const RegenResourcePort_base: Context.ServiceClass<RegenResourcePort, "@voltro/RegenResourcePort", RegenResourceService>;
+
+declare interface RegenResourceService {
+    readonly initialize: (subject: Subject, input: InitializeResourceInput) => Effect.Effect<ResourceReceipt, ProgressionError>;
+    readonly consume: (subject: Subject, input: ResourceChangeInput) => Effect.Effect<ResourceReceipt, ProgressionError>;
+    readonly grant: (subject: Subject, input: ResourceChangeInput) => Effect.Effect<ResourceReceipt, ProgressionError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly PlayerResource[], ProgressionError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, ProgressionError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, ProgressionError>;
+}
+
+declare interface RerollQuestInput {
+    readonly poolId: string;
+    readonly windowId: string;
+    readonly assignmentId: string;
+    readonly requestId: string;
+}
+
+export declare const resolvePassCatchUp: (input: PassCatchUpContext, slot?: PassCatchUp) => string;
+
+export declare const resolveQuestProgress: (input: QuestProgressContext, slot?: QuestProgressResolver) => readonly number[];
+
+export declare const resolveResourceRegen: (input: ResourceRegenContext, slot?: ResourceRegenResolver) => ResourceState;
+
+export declare const resolveTutorialStep: (input: TutorialStepPolicyContext, policy?: TutorialStepPolicy) => TutorialState;
+
+declare interface ResourceChangeInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly resourceId: string;
+    readonly requestId: string;
+    readonly source: string;
+    readonly origin: string;
+    readonly amount: ProgressValue;
+}
+
+export declare const resourceFakeLayer: Layer.Layer<FixturePorts, never, never>;
+
+export declare const resourceFixture: () => Readonly<{
+    resource: RegenResource;
+    state: Readonly<{
+        value: "5";
+        anchorAt: 1000;
+    }>;
+    at: 3000;
+}>;
+
+export declare const resourcePortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof RegenResourcePort;
+    fakeLayer: Layer.Layer<FixturePorts, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            original: boolean;
+            values: string[];
+        }, ProgressionError, never>;
+        expected: {
+            original: boolean;
+            values: string[];
+        };
+    };
+}>;
+
+declare interface ResourceReceipt {
+    readonly operationId: string;
+    readonly kind: 'initialize' | 'consume' | 'grant';
+    readonly resourceId: string;
+    readonly amount: string;
+    readonly regenerated: string;
+    readonly after: ResourceState;
+    readonly at: number;
+}
+
+declare interface ResourceRegenContext {
+    readonly resource: RegenResource;
+    readonly state: ResourceState;
+    readonly at: number;
+}
+
+declare type ResourceRegenResolver = (input: ResourceRegenContext) => ResourceState;
+
+export declare const resourceRegenSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: ResourceRegenResolver;
+    defaultProbe: {
+        run: () => Effect.Effect< ResourceState, never, never>;
+        expected: {
+            value: string;
+            anchorAt: number;
+        };
+    };
+    overrideProbe: {
+        run: () => Effect.Effect< ResourceState, never, never>;
+        expected: {
+            value: string;
+            anchorAt: number;
+        };
+    };
+}>;
+
+declare interface ResourceState {
+    readonly value: string;
+    readonly anchorAt: number;
+}
+
+declare type RewardResolver = (context: RewardResolverContext) => readonly LevelReward[];
+
+declare interface RewardResolverContext {
+    readonly track: ProgressionTrack;
+    readonly fromLevel: number;
+    readonly toLevel: number;
+}
+
+export declare const rewardResolverSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: RewardResolver;
+    defaultProbe: {
+        run: () => Effect.Effect<readonly LevelReward[], never, never>;
+        expected: {
+            level: number;
+            reward: {
+                kind: string;
+                currency: string;
+                amount: string;
+            };
+        }[];
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<readonly LevelReward[], never, never>;
+        expected: never[];
+    };
+}>;
+
+declare interface SeasonPass {
+    readonly id: string;
+    readonly version: number;
+    readonly from: number;
+    readonly until: number;
+    readonly tiers: number;
+    readonly xpPerTier: string;
+    readonly tracks: {
+        readonly free: readonly (readonly ProgressionReward[])[];
+        readonly premium: readonly (readonly ProgressionReward[])[];
+    };
+    readonly premiumOffer: string | null;
+    readonly sources: readonly string[];
+    readonly catchUp: {
+        readonly xpBoostAfterDay: number;
+        readonly multiplier: number;
+    } | null;
+    readonly autoClaim: boolean;
+    readonly expireUnclaimed: 'mail' | 'forfeit';
+}
+
+declare class SeasonPassPort extends SeasonPassPort_base {
+}
+
+declare const SeasonPassPort_base: Context.ServiceClass<SeasonPassPort, "@voltro/SeasonPassPort", SeasonPassService>;
+
+declare interface SeasonPassService {
+    readonly applyXp: (subject: Subject, input: PassXpInput) => Effect.Effect<PassReceipt, ProgressionError>;
+    readonly grantPremium: (subject: Subject, input: PassPremiumInput) => Effect.Effect<PassReceipt, ProgressionError>;
+    readonly claim: (subject: Subject, input: PassClaimInput) => Effect.Effect<PassReceipt, ProgressionError>;
+    readonly close: (subject: Subject, input: PassCloseInput) => Effect.Effect<PassReceipt, ProgressionError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly PlayerPass[], ProgressionError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, ProgressionError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, ProgressionError>;
+}
+
+export declare const selectQuests: (input: QuestSelectorContext, slot?: QuestSelector) => readonly string[];
+
+declare const STAT_OPERATORS: readonly ["increment", "max", "min", "set"];
+
+export declare const staticQuestSource: (input: readonly QuestPoolDefinition[], revision?: string) => QuestSourceService;
+
+declare type StatOperator = typeof STAT_OPERATORS[number];
+
+declare interface StatThreshold {
+    readonly kind: 'statAtLeast';
+    readonly stat: string;
+    readonly target: string;
+    readonly period: 'lifetime' | 'season';
+    readonly seasonId: string | null;
+}
+
+declare interface Tutorial {
+    readonly id: string;
+    readonly version: number;
+    readonly steps: readonly string[];
+    readonly skippable: boolean;
+    readonly reward: readonly ProgressionReward[];
+    readonly rewardOnSkip: boolean;
+    readonly hints: string | null;
+}
+
+declare interface TutorialEvidence {
+    readonly source: string;
+    readonly originId: string;
+    readonly version: string;
+    readonly from: number;
+    readonly until: number;
+}
+
+/** Test-only actual installed tutorial adapter on a private store; no client
+ * verifier, reward destination or production backend. */
+export declare const tutorialFakeLayer: Layer.Layer<TutorialPort>;
+
+export declare const tutorialFixture: () => Readonly<{
+    tutorial: Tutorial;
+    state: TutorialState;
+    stepPolicy: Readonly<{
+        tutorial: Tutorial;
+        before: TutorialState;
+        step: "move";
+        evidence: Readonly<{
+            source: "test.room";
+            originId: "test.move";
+            version: "v1";
+            from: 0;
+            until: 1000;
+        }>;
+        at: 1;
+    }>;
+}>;
+
+declare class TutorialPort extends TutorialPort_base {
+}
+
+declare const TutorialPort_base: Context.ServiceClass<TutorialPort, "@voltro/TutorialPort", TutorialService>;
+
+export declare const tutorialPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof TutorialPort;
+    fakeLayer: Layer.Layer<TutorialPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            original: boolean;
+            completed: boolean;
+            rewardsQueued: number;
+            tutorials: {
+                completedSteps: readonly string[];
+                nextStep: string | null;
+            }[];
+        }, ProgressionError, never>;
+        expected: {
+            original: boolean;
+            completed: boolean;
+            rewardsQueued: number;
+            tutorials: {
+                completedSteps: string[];
+                nextStep: null;
+            }[];
+        };
+    };
+}>;
+
+declare interface TutorialReceipt {
+    readonly operationId: string;
+    readonly kind: 'step' | 'skip';
+    readonly step: string | null;
+    readonly after: TutorialState;
+    readonly rewardsQueued: number;
+    readonly at: number;
+}
+
+declare interface TutorialRecordInput extends TutorialStepInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly source: string;
+    readonly originId: string;
+}
+
+declare interface TutorialService {
+    readonly completeStep: (subject: Subject, input: TutorialStepInput) => Effect.Effect<TutorialReceipt, ProgressionError>;
+    readonly record: (subject: Subject, input: TutorialRecordInput) => Effect.Effect<TutorialReceipt, ProgressionError>;
+    readonly skip: (subject: Subject, input: TutorialSkipInput) => Effect.Effect<TutorialReceipt, ProgressionError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly PlayerTutorial[], ProgressionError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, ProgressionError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, ProgressionError>;
+}
+
+declare interface TutorialSkipInput {
+    readonly tutorialId: string;
+    readonly requestId: string;
+}
+
+declare interface TutorialState {
+    readonly tutorialId: string;
+    readonly version: number;
+    readonly completedSteps: readonly string[];
+    readonly completed: boolean;
+    readonly skipped: boolean;
+    readonly completedAt: number | null;
+    readonly updatedAt: number | null;
+}
+
+declare interface TutorialStepInput {
+    readonly tutorialId: string;
+    readonly step: string;
+    readonly requestId: string;
+}
+
+declare type TutorialStepPolicy = (input: TutorialStepPolicyContext) => boolean;
+
+declare interface TutorialStepPolicyContext {
+    readonly tutorial: Tutorial;
+    readonly before: TutorialState;
+    readonly step: string;
+    readonly evidence: TutorialEvidence;
+    readonly at: number;
+}
+
+export declare const tutorialStepPolicySystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: TutorialStepPolicy;
+    defaultProbe: {
+        run: () => Effect.Effect<readonly string[], never, never>;
+        expected: string[];
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+}>;
+
+declare type XpCurve = (context: XpCurveContext) => number;
+
+declare interface XpCurveContext {
+    readonly xp: string;
+    readonly curve: LevelCurve;
+}
+
+export declare const xpCurveSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: XpCurve;
+    defaultProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number, never, never>;
+        expected: number;
+    };
+}>;
+
+export { }