@voltro/plugin-progression 0.0.0-stage → 0.87.0

package/dist/index.d.ts

@@ -0,0 +1,1833 @@
+import { Context } from 'effect';
+import { EconomyService } from '@voltro/plugin-economy';
+import { Effect } from 'effect';
+import { InventoryService } from '@voltro/plugin-inventory';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { VoltroPlugin } from '@voltro/protocol';
+import { WorkflowRunHandle } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+export declare const acceptRankObservation: (season: RankSeason, ladder: RankLadder, beforeInput: RankSeasonState, rankInput: PlayerRank, rulesVersion: string) => RankSeasonState;
+
+export declare interface Achievement {
+    readonly id: string;
+    readonly version: number;
+    readonly hidden: boolean;
+    readonly tiers: readonly AchievementTier[];
+}
+
+declare interface AchievementAudit {
+    readonly acceptedOperations: number;
+    readonly unlocked: number;
+    readonly rewardRows: number;
+    readonly matches: boolean;
+}
+
+export declare type AchievementCondition = StatThreshold | CompositeCondition;
+
+export declare interface AchievementDefinition {
+    readonly id: string;
+    readonly version?: number;
+    readonly condition: AchievementCondition;
+    readonly tiers?: readonly AchievementTierDefinition[];
+    readonly hidden?: boolean;
+    readonly reward?: readonly ProgressionReward[];
+    readonly platform?: AchievementPlatform;
+}
+
+export declare interface AchievementEvaluation {
+    readonly met: boolean;
+    readonly progress: readonly AchievementProgress[];
+}
+
+export declare type AchievementEvaluator = (input: {
+    readonly condition: AchievementCondition;
+    readonly stats: readonly AchievementStat[];
+}) => AchievementEvaluation;
+
+export declare interface AchievementPlatform {
+    readonly steam?: string;
+    readonly gameCenter?: string;
+    readonly playGames?: string;
+}
+
+export declare interface AchievementPluginOptions extends Omit<AchievementStoreOptions, 'source'> {
+    readonly source?: AchievementStatSourceService;
+    readonly service?: AchievementService | undefined;
+}
+
+export declare class AchievementPort extends AchievementPort_base {
+}
+
+declare const AchievementPort_base: Context.ServiceClass<AchievementPort, "@voltro/AchievementPort", AchievementService>;
+
+export declare interface AchievementProgress extends AchievementStat {
+    readonly target: string;
+    readonly met: boolean;
+}
+
+export declare interface AchievementReceipt {
+    readonly operationId: string;
+    readonly throughSequence: number;
+    readonly unlockedIds: readonly string[];
+    readonly rewardsQueued: number;
+    readonly at: number;
+}
+
+export 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 AchievementSqlService extends AchievementService {
+    readonly auditAchievements: (subject: Subject, tenantId: string, ownerId: string) => Effect.Effect<AchievementAudit, ProgressionError>;
+    readonly rebuildAchievements: (subject: Subject, tenantId: string, ownerId: string) => Effect.Effect<AchievementAudit, ProgressionError>;
+}
+
+export declare interface AchievementStat {
+    readonly stat: string;
+    readonly period: 'lifetime' | 'season';
+    readonly seasonId: string | null;
+    readonly value: string;
+}
+
+export declare interface AchievementStatEvent extends AchievementStat {
+    readonly operationId: string;
+    readonly sequence: number;
+    readonly at: number;
+}
+
+export declare interface AchievementStatHistory {
+    readonly version: string;
+    readonly throughSequence: number;
+    readonly initial: readonly AchievementStat[];
+    readonly events: readonly AchievementStatEvent[];
+}
+
+export declare class AchievementStatSource extends AchievementStatSource_base {
+}
+
+declare const AchievementStatSource_base: Context.ServiceClass<AchievementStatSource, "@voltro/AchievementStatSource", AchievementStatSourceService>;
+
+export declare interface AchievementStatSourceService {
+    readonly history: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly limit: number;
+    }) => Effect.Effect<AchievementStatHistory, ProgressionError>;
+}
+
+declare interface AchievementStoreOptions {
+    readonly definitions: readonly (AchievementDefinition | Achievement)[];
+    readonly source: AchievementStatSourceService;
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly maxPendingRewards?: number | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly strategies?: {
+        readonly achievementEvaluator?: AchievementEvaluator | undefined;
+        readonly version?: string;
+    } | undefined;
+}
+
+export declare interface AchievementTier {
+    readonly id: string;
+    readonly condition: AchievementCondition;
+    readonly reward: readonly ProgressionReward[];
+    readonly platform: AchievementPlatform;
+}
+
+export declare interface AchievementTierDefinition {
+    readonly id: string;
+    readonly condition: AchievementCondition;
+    readonly reward?: readonly ProgressionReward[];
+    readonly platform?: AchievementPlatform;
+}
+
+export 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;
+}
+
+export declare const applyStatValue: (previous: ProgressValue | null, operand: ProgressValue, operator: StatOperator, stat: ProgressionStat) => string;
+
+export declare interface ApplyXpInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly trackId: string;
+    readonly amount: ProgressValue;
+    readonly requestId: string;
+    readonly source: string;
+    readonly origin: string;
+}
+
+export 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;
+}
+
+export declare const captureAchievementCondition: (input: unknown) => AchievementCondition;
+
+export declare const captureAchievementPlatform: (input: unknown) => AchievementPlatform;
+
+export declare const captureAchievementStats: (input: unknown) => readonly AchievementStat[];
+
+/** Admit accepted custom-slot output for journal repair without calling historical strategies. */
+export declare const capturePlayerRank: (input: unknown, ladder: RankLadder, rulesVersion: string) => PlayerRank;
+
+export declare const captureRankRating: (input: unknown, pool: string) => RankRating;
+
+export declare const captureRankSeasonState: (input: unknown, season: RankSeason, ladder: RankLadder, rulesVersion: string) => RankSeasonState;
+
+export declare const closeRankSeasonState: (season: RankSeason, ladder: RankLadder, beforeInput: RankSeasonState, at: number, resetScore: number | null, rulesVersion: string) => RankSeasonState;
+
+export declare const composite: (conditions: readonly AchievementCondition[], mode?: "all" | "any") => AchievementCondition;
+
+export declare interface CompositeCondition {
+    readonly kind: 'composite';
+    readonly mode: 'all' | 'any';
+    readonly conditions: readonly AchievementCondition[];
+}
+
+declare interface DailyAudit {
+    readonly claims: number;
+    readonly rewardRows: number;
+    readonly calendars: number;
+    readonly matches: boolean;
+}
+
+export declare interface DailyClaimInput {
+    readonly calendarId: string;
+    readonly requestId: string;
+}
+
+export declare interface DailyClaimPlan {
+    readonly dayIndex: number;
+    readonly streak: number;
+    readonly protectionRemaining: number;
+    readonly cycle: number;
+}
+
+export declare type DailyClaimPolicy = (input: DailyClaimPolicyContext) => DailyClaimPlan;
+
+export declare interface DailyClaimPolicyContext {
+    readonly calendar: LoginCalendar;
+    readonly previous: DailyState | null;
+    readonly window: DailyWindow;
+    readonly at: number;
+}
+
+export declare interface DailyPluginOptions extends DailyStoreOptions {
+    readonly service?: LoginCalendarService | undefined;
+}
+
+export declare interface DailyProfile {
+    readonly timezone: string;
+    readonly version: string;
+}
+
+export declare class DailyProfileSource extends DailyProfileSource_base {
+}
+
+declare const DailyProfileSource_base: Context.ServiceClass<DailyProfileSource, "@voltro/DailyProfileSource", DailyProfileSourceService>;
+
+export declare interface DailyProfileSourceService {
+    readonly read: (subject: Subject, scope: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+    }) => Effect.Effect<DailyProfile, ProgressionError>;
+}
+
+export 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 DailySqlService extends LoginCalendarService {
+    readonly auditDaily: (subject: Subject, tenantId: string, ownerId: string) => Effect.Effect<DailyAudit, ProgressionError>;
+    readonly rebuildDaily: (subject: Subject, tenantId: string, ownerId: string) => Effect.Effect<DailyAudit, ProgressionError>;
+}
+
+export 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 DailyStoreOptions {
+    readonly calendars: readonly LoginCalendarDefinition[];
+    readonly profileSource: DailyProfileSourceService;
+    readonly now?: (() => number) | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly strategies?: {
+        readonly claimPolicy?: DailyClaimPolicy | undefined;
+        readonly version?: string;
+    } | undefined;
+}
+
+export declare interface DailyWindow {
+    readonly dayKey: string;
+    readonly dayOrdinal: number;
+    readonly from: number;
+    readonly until: number;
+    readonly timezone: string;
+}
+
+export declare const defaultAchievementEvaluator: AchievementEvaluator;
+
+export declare const defaultDailyClaimPolicy: DailyClaimPolicy;
+
+/** Effect Cron owns the timezone/DST boundary; day ordinals count civil dates, not 24-hour intervals. */
+export declare const defaultDailyWindow: (input: {
+    readonly timezone: string;
+    readonly at: number;
+}) => DailyWindow;
+
+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;
+
+/** Effect's timezone-aware Cron is the single parser/calendar implementation. */
+export declare const defaultQuestWindow: QuestWindowResolver;
+
+/** 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 defaultRewardResolver: RewardResolver;
+
+export declare const defaultTutorialStepPolicy: TutorialStepPolicy;
+
+export declare const defaultXpCurve: XpCurve;
+
+export declare const defineAchievement: (input: AchievementDefinition | Achievement) => Achievement;
+
+export declare const defineLoginCalendar: (input: LoginCalendarDefinition) => LoginCalendar;
+
+export declare const defineProgression: (input: ProgressionDefinition) => ProgressionTrack;
+
+export declare const defineQuest: (input: QuestDefinition) => QuestDefinition;
+
+export declare const defineQuestPool: (input: QuestPoolDefinition) => QuestPool;
+
+export declare const defineRankLadder: (input: RankLadderDefinition | RankLadder) => RankLadder;
+
+export declare const defineRankSeason: (input: RankSeasonDefinition | RankSeason, ladder: RankLadder) => RankSeason;
+
+export declare const defineRegenResource: (input: RegenResourceDefinition | RegenResource) => RegenResource;
+
+/** UTC elapsed days govern pass catch-up; player timezone does not change a season. */
+export declare const defineSeasonPass: (input: SeasonPassDefinition | SeasonPass) => SeasonPass;
+
+export declare const defineStat: (input: StatDefinition) => ProgressionStat;
+
+export declare const defineTutorial: (input: TutorialDefinition | Tutorial) => Tutorial;
+
+export declare interface EvaluateAchievementsInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly requestId: string;
+}
+
+export declare const explicitLevelCurve: (thresholds: readonly ProgressValue[]) => LevelCurve;
+
+export declare const grant: (currency: string, amount: ProgressValue) => ProgressionReward;
+
+export declare const grantItem: (itemId: string, qty?: number) => ProgressionReward;
+
+export declare type InitializeResourceInput = Omit<ResourceChangeInput, 'amount'>;
+
+export declare const initialRankSeasonState: (season: RankSeason) => RankSeasonState;
+
+export declare interface LevelCurve {
+    readonly thresholds: readonly string[];
+}
+
+/** Recurrence rounds the next per-level requirement up using an exact decimal ratio. */
+export declare const levelCurve: (input: {
+    readonly base: ProgressValue;
+    readonly growth: number;
+    readonly maxLevel: number;
+}) => LevelCurve;
+
+declare interface LevelReward {
+    readonly level: number;
+    readonly reward: ProgressionReward;
+}
+
+export declare interface LoginCalendar {
+    readonly id: string;
+    readonly version: number;
+    readonly days: readonly (readonly ProgressionReward[])[];
+    readonly streakProtection: number;
+}
+
+export declare interface LoginCalendarDefinition {
+    readonly id: string;
+    readonly version?: number;
+    readonly days: readonly (readonly ProgressionReward[])[];
+    readonly streakProtection?: number;
+}
+
+export declare class LoginCalendarPort extends LoginCalendarPort_base {
+}
+
+declare const LoginCalendarPort_base: Context.ServiceClass<LoginCalendarPort, "@voltro/LoginCalendarPort", LoginCalendarService>;
+
+export 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 interface PassAudit {
+    readonly operations: number;
+    readonly passes: number;
+    readonly rewardRows: number;
+    readonly matches: boolean;
+}
+
+export declare type PassCatchUp = (input: PassCatchUpContext) => ProgressValue;
+
+export declare interface PassCatchUpContext {
+    readonly pass: SeasonPass;
+    readonly amount: string;
+    readonly at: number;
+}
+
+export declare interface PassClaimInput {
+    readonly passId: string;
+    readonly tier: number;
+    readonly track: PassTrack;
+    readonly requestId: string;
+}
+
+export declare interface PassCloseInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly passId: string;
+    readonly requestId: string;
+}
+
+export declare interface PassPluginOptions extends PassStoreOptions {
+    readonly service?: SeasonPassService | undefined;
+}
+
+export declare interface PassPremiumInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly passId: string;
+    readonly offerId: string;
+    readonly fulfillmentId: string;
+    readonly requestId: string;
+}
+
+export 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 PassSqlService extends SeasonPassService {
+    readonly auditPasses: (subject: Subject, tenantId: string, ownerId: string) => Effect.Effect<PassAudit, ProgressionError>;
+    readonly rebuildPasses: (subject: Subject, tenantId: string, ownerId: string) => Effect.Effect<PassAudit, ProgressionError>;
+}
+
+export 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 PassStoreOptions {
+    readonly definitions: readonly (SeasonPassDefinition | SeasonPass)[];
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly maxPendingRewards?: number | undefined;
+    readonly strategies?: {
+        readonly passCatchUp?: PassCatchUp | undefined;
+        readonly version?: string;
+    } | undefined;
+}
+
+export declare interface PassTierClaim {
+    readonly tier: number;
+    readonly track: PassTrack;
+    readonly rewards: readonly ProgressionReward[];
+}
+
+export declare type PassTrack = 'free' | 'premium';
+
+export declare interface PassXpInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly passId: string;
+    readonly amount: ProgressValue;
+    readonly source: string;
+    readonly originId: string;
+    readonly requestId: string;
+}
+
+export 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;
+}
+
+export 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[];
+}
+
+export 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[];
+}
+
+export 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;
+}
+
+export 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;
+}
+
+export 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;
+}
+
+export declare interface PlayerStat {
+    readonly stat: string;
+    readonly period: 'lifetime' | 'season';
+    readonly seasonId: string | null;
+    readonly value: string;
+    readonly updatedAt: number;
+}
+
+export declare interface PlayerTrack {
+    readonly trackId: string;
+    readonly xp: string;
+    readonly level: number;
+    readonly prestige: number;
+    readonly updatedAt: number | null;
+}
+
+export declare interface PlayerTutorial extends TutorialState {
+    readonly nextStep: string | null;
+    readonly skippable: boolean;
+    readonly hints: string | null;
+}
+
+export declare const progressionAchievementsSystemContract: Readonly<{
+    slots: {
+        achievementEvaluator: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        achievements: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        achievementStatSource: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+declare interface ProgressionAudit {
+    readonly tracks: number;
+    readonly stats: number;
+    readonly acceptedOperations: number;
+    readonly xpLedgerRows: number;
+    readonly statLedgerRows: number;
+    readonly rewardRows: number;
+    readonly matches: boolean;
+}
+
+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;
+};
+
+export declare const progressionDailySystemContract: Readonly<{
+    slots: {
+        dailyClaimPolicy: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        daily: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        dailyProfileSource: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+export declare interface ProgressionDefinition {
+    readonly id: string;
+    readonly version?: number;
+    readonly xpCurve: LevelCurve;
+    readonly sources: readonly string[];
+    readonly rewards?: Readonly<Record<string, readonly ProgressionReward[] | Readonly<Record<string, readonly ProgressionReward[]>>>>;
+}
+
+export 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 progressionPassesSystemContract: Readonly<{
+    slots: {
+        passCatchUp: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        passes: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+export declare interface ProgressionPlugin extends VoltroPlugin {
+    readonly progression: {
+        readonly service: () => ProgressionService;
+        readonly auditProgression: ProgressionSqlService['auditProgression'];
+        readonly rebuildProgression: ProgressionSqlService['rebuildProgression'];
+        readonly quests: () => QuestService;
+        readonly questRefresh: () => QuestRefreshService;
+        readonly ranks: () => RankSeasonService;
+        readonly rankClosure: () => RankClosureService;
+        readonly auditRanks: RankSqlService['auditRanks'];
+        readonly rebuildRanks: RankSqlService['rebuildRanks'];
+        readonly tutorials: () => TutorialService;
+        readonly auditTutorials: TutorialSqlService['auditTutorials'];
+        readonly rebuildTutorials: TutorialSqlService['rebuildTutorials'];
+        readonly passes: () => SeasonPassService;
+        readonly auditPasses: PassSqlService['auditPasses'];
+        readonly rebuildPasses: PassSqlService['rebuildPasses'];
+        readonly daily: () => LoginCalendarService;
+        readonly auditDaily: DailySqlService['auditDaily'];
+        readonly rebuildDaily: DailySqlService['rebuildDaily'];
+        readonly delivery: () => RewardDeliveryService;
+        readonly achievements: () => AchievementService;
+        readonly auditAchievements: AchievementSqlService['auditAchievements'];
+        readonly rebuildAchievements: AchievementSqlService['rebuildAchievements'];
+        readonly resources: () => RegenResourceService;
+        readonly auditResources: ResourceSqlService['auditResources'];
+        readonly rebuildResources: ResourceSqlService['rebuildResources'];
+    };
+}
+
+export declare const progressionPlugin: (input: ProgressionPluginOptions) => ProgressionPlugin;
+
+export declare interface ProgressionPluginOptions extends ProgressionStoreOptions {
+    readonly service?: ProgressionService | undefined;
+    readonly quests?: QuestPluginOptions;
+    readonly resources?: ResourcePluginOptions;
+    readonly achievements?: AchievementPluginOptions;
+    readonly delivery?: RewardDeliveryOptions;
+    readonly daily?: DailyPluginOptions;
+    readonly passes?: PassPluginOptions;
+    readonly tutorials?: TutorialPluginOptions;
+    readonly ranks?: RankPluginOptions;
+}
+
+export declare class ProgressionPort extends ProgressionPort_base {
+}
+
+declare const ProgressionPort_base: Context.ServiceClass<ProgressionPort, "@voltro/ProgressionPort", ProgressionService>;
+
+/** System21 manifest of the installed core track/stat system. Optional quests, resources, achievements,
+ * daily calendars, passes and ranks contribute their own slots, ports and tables. */
+export declare const progressionQuestsSystemContract: Readonly<{
+    slots: {
+        questSelector: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        questProgressResolver: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        quests: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        questSource: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+export declare const progressionRanksSystemContract: Readonly<{
+    slots: {
+        rankScore: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        rankDecay: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        rankGrade: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        rankSeasonReset: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        ranks: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+        rankRatingSource: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+export declare interface ProgressionReceipt {
+    readonly operationId: string;
+    readonly at: number;
+    readonly change: ProgressionChange;
+    readonly rewardsQueued: number;
+}
+
+export declare const progressionResourcesSystemContract: Readonly<{
+    slots: {
+        resourceRegen: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        resources: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+export 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;
+};
+
+export 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 ProgressionSqlService extends ProgressionService {
+    readonly achievementHistory: (subject: Subject, tenantId: string, ownerId: string, limit: number) => Effect.Effect<AchievementStatHistory, ProgressionError>;
+    readonly auditProgression: (subject: Subject, tenantId: string, ownerId: string) => Effect.Effect<ProgressionAudit, ProgressionError>;
+    readonly rebuildProgression: (subject: Subject, tenantId: string, ownerId: string) => Effect.Effect<ProgressionAudit, ProgressionError>;
+}
+
+export declare interface ProgressionStat {
+    readonly id: string;
+    readonly initial: string;
+    readonly cap: string;
+    readonly operators: readonly StatOperator[];
+}
+
+declare interface ProgressionStoreOptions {
+    readonly tracks: readonly ProgressionDefinition[];
+    readonly stats?: readonly StatDefinition[] | undefined;
+    readonly statSources?: readonly string[] | undefined;
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly maxPendingRewards?: number | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly strategies?: {
+        readonly xpCurve?: XpCurve | undefined;
+        readonly rewardResolver?: RewardResolver;
+        readonly version?: string;
+    } | undefined;
+}
+
+export declare const progressionSystemContract: Readonly<{
+    slots: {
+        xpCurve: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+        rewardResolver: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        progression: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+export 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[]>>;
+}
+
+export declare const progressionTutorialsSystemContract: Readonly<{
+    slots: {
+        tutorialStepPolicy: {
+            defaultExport: string;
+            fixtureExport: string;
+        };
+    };
+    ports: {
+        tutorials: {
+            tagExport: string;
+            fakeLayerExport: string;
+            fixtureExport: string;
+        };
+    };
+    events: readonly string[];
+}>;
+
+declare type ProgressValue = string | number | bigint;
+
+export declare interface QuestDefinition {
+    readonly id: string;
+    readonly titleKey?: string;
+    readonly objectives: readonly QuestObjective[];
+    readonly reward: readonly ProgressionReward[];
+}
+
+declare type QuestObjective = {
+    readonly stat: string;
+    readonly target: number;
+} | {
+    readonly event: string;
+    readonly target: number;
+    readonly where?: Readonly<Record<string, QuestScalar>>;
+};
+
+/** Trusted profile data, obtained from the owning player service; never client input. */
+export declare interface QuestPlayer {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly timezone: string;
+}
+
+export declare class QuestPlayerSource extends QuestPlayerSource_base {
+}
+
+declare const QuestPlayerSource_base: Context.ServiceClass<QuestPlayerSource, "@voltro/QuestPlayerSource", QuestPlayerSourceService>;
+
+export declare interface QuestPlayerSourceService {
+    /** Complete bounded roster. Return over-limit as an error; do not truncate it silently. */
+    readonly read: (input: {
+        readonly limit: number;
+    }) => Effect.Effect<readonly QuestPlayer[], ProgressionError>;
+}
+
+export declare interface QuestPluginOptions extends QuestStoreOptions {
+    readonly service?: QuestService | undefined;
+    readonly refresh?: QuestRefreshOptions;
+}
+
+export declare interface QuestPool extends QuestPoolDefinition {
+    readonly version: number;
+    readonly rerolls: number;
+    readonly weights: Readonly<Record<string, number>>;
+}
+
+export 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>>;
+}
+
+export declare class QuestPort extends QuestPort_base {
+}
+
+declare const QuestPort_base: Context.ServiceClass<QuestPort, "@voltro/QuestPort", QuestService>;
+
+declare interface QuestProgressContext {
+    readonly quest: QuestDefinition;
+    readonly progress: readonly number[];
+    readonly signal: QuestSignal;
+}
+
+export declare type QuestProgressResolver = (context: QuestProgressContext) => readonly number[];
+
+export 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;
+}
+
+export declare interface QuestRefreshOptions {
+    readonly players: QuestPlayerSourceService;
+    readonly intervalMs?: number;
+    readonly maxPlayers?: number;
+    readonly strategies?: {
+        readonly questWindow?: QuestWindowResolver | undefined;
+        readonly questSeed?: QuestSeedResolver;
+        readonly version?: string;
+    } | undefined;
+    readonly service?: QuestRefreshService | undefined;
+}
+
+export declare class QuestRefreshPort extends QuestRefreshPort_base {
+}
+
+declare const QuestRefreshPort_base: Context.ServiceClass<QuestRefreshPort, "@voltro/QuestRefreshPort", QuestRefreshService>;
+
+export declare interface QuestRefreshReport {
+    readonly players: number;
+    readonly assignments: number;
+    readonly erased: number;
+    readonly failures: readonly ProgressionError['code'][];
+}
+
+export declare interface QuestRefreshService {
+    readonly refreshOwner: (subject: Subject, player: QuestPlayer) => Effect.Effect<readonly QuestReceipt[], ProgressionError>;
+    readonly refreshAll: (subject: Subject) => Effect.Effect<QuestRefreshReport, ProgressionError>;
+}
+
+declare type QuestScalar = string | number | boolean | null;
+
+export declare interface QuestSeedContext extends QuestWindowContext {
+    readonly window: QuestWindow;
+}
+
+export declare type QuestSeedResolver = (input: QuestSeedContext) => number;
+
+export 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 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>>;
+};
+
+export declare type QuestSignalInput = {
+    readonly kind: 'stat';
+    readonly stat: string;
+    readonly delta: ProgressValue;
+} | {
+    readonly kind: 'event';
+    readonly event: string;
+    readonly data?: Readonly<Record<string, QuestScalar>>;
+};
+
+export declare class QuestSource extends QuestSource_base {
+}
+
+declare const QuestSource_base: Context.ServiceClass<QuestSource, "@voltro/QuestSource", QuestSourceService>;
+
+declare interface QuestSourceScope {
+    readonly tenantId: string;
+    readonly channel: string;
+    readonly locale: string;
+}
+
+export declare interface QuestSourceService {
+    readonly read: (scope: QuestSourceScope) => Effect.Effect<{
+        readonly revision: string;
+        readonly pools: readonly QuestPool[];
+    }, ProgressionError>;
+}
+
+declare interface QuestStoreOptions {
+    readonly source: QuestSourceService;
+    readonly channel: string;
+    readonly locale: string;
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly eventSources?: readonly string[] | undefined;
+    readonly statSources?: readonly string[] | undefined;
+    readonly maxWorkRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly strategies?: {
+        readonly questSelector?: QuestSelector | undefined;
+        readonly questProgressResolver?: QuestProgressResolver;
+        readonly version?: string;
+    } | undefined;
+}
+
+declare interface QuestWindow {
+    readonly from: number;
+    readonly until: number;
+    readonly timezone: string;
+}
+
+export declare interface QuestWindowContext {
+    readonly pool: QuestPool;
+    readonly player: QuestPlayer;
+    readonly at: number;
+}
+
+export declare type QuestWindowResolver = (input: QuestWindowContext) => QuestWindow;
+
+declare interface RankAudit {
+    readonly operations: number;
+    readonly seasons: number;
+    readonly rewardRows: number;
+    readonly matches: boolean;
+}
+
+export declare interface RankCloseInput extends RankObserveInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+}
+
+declare interface RankClosureDispatchInput {
+    readonly limit?: number;
+    readonly after?: string;
+}
+
+declare interface RankClosureDispatchResult {
+    readonly scanned: number;
+    readonly admitted: number;
+    readonly failed: readonly string[];
+    readonly next: string | null;
+}
+
+declare interface RankClosureOptions {
+    readonly service?: RankClosureService | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly allowedServices?: readonly string[] | undefined;
+}
+
+declare interface RankClosureReceipt {
+    readonly unitId: string;
+    readonly status: 'closed' | 'erased';
+    readonly operationId: string | null;
+    readonly rewardsQueued: number;
+    readonly at: number;
+}
+
+declare interface RankClosureRequest {
+    readonly unitId: string;
+}
+
+declare interface RankClosureService {
+    readonly execute: (subject: Subject, input: RankClosureRequest) => Effect.Effect<RankClosureReceipt, ProgressionError>;
+    readonly dispatch: (subject: Subject, input: RankClosureDispatchInput, start: (payload: RankClosureRequest) => Effect.Effect<WorkflowRunHandle, unknown>) => Effect.Effect<RankClosureDispatchResult, ProgressionError>;
+}
+
+export declare interface RankContext {
+    readonly ladder: RankLadder;
+    readonly rating: RankRating;
+    readonly at: number;
+}
+
+export declare interface RankDecayDefinition {
+    readonly afterDays: number;
+    readonly perDay: number;
+    readonly floor: number;
+}
+
+export declare type RankDecayResolver = (input: RankGradeContext) => number;
+
+export declare interface RankGrade {
+    readonly index: number;
+    readonly tier: string;
+    readonly tierIndex: number;
+    readonly division: number;
+}
+
+export declare interface RankGradeContext extends RankContext {
+    readonly score: number;
+}
+
+export declare type RankGradeResolver = (input: RankGradeContext) => RankGrade | null;
+
+export 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;
+}
+
+export declare interface RankLadderDefinition {
+    readonly id?: string;
+    readonly version?: number;
+    readonly rating: string;
+    readonly tiers: readonly string[];
+    readonly divisions?: number;
+    /** Ascending cutoffs for each boundary, lowest division to highest. No hidden balancing values. */
+    readonly thresholds: readonly number[];
+    readonly placements?: number;
+    readonly confidence?: number;
+    readonly decay?: RankDecayDefinition | null;
+    readonly softReset?: RankResetDefinition | null;
+}
+
+export declare interface RankObserveInput {
+    readonly seasonId: string;
+    readonly requestId: string;
+}
+
+export declare interface RankPluginOptions extends RankStoreOptions {
+    readonly service?: RankSeasonService | undefined;
+    readonly closure?: RankClosureOptions;
+}
+
+export declare class RankPort extends RankPort_base {
+}
+
+declare const RankPort_base: Context.ServiceClass<RankPort, "@voltro/RankPort", RankSeasonService>;
+
+export declare interface RankRating {
+    readonly pool: string;
+    readonly state: RankRatingState;
+    readonly games: number;
+    readonly updatedAt: number | null;
+}
+
+export declare class RankRatingSource extends RankRatingSource_base {
+}
+
+declare const RankRatingSource_base: Context.ServiceClass<RankRatingSource, "@voltro/RankRatingSource", RankRatingSourceService>;
+
+export declare interface RankRatingSourceService {
+    readonly read: (subject: Subject, pool: string) => Effect.Effect<RankRating, ProgressionError>;
+}
+
+/** SQL Ratings remain the authority; this detached shape matches Ratings.myRating. */
+export 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;
+};
+
+export declare interface RankReaderService {
+    readonly mine: (subject: Subject) => Effect.Effect<readonly PlayerRank[], ProgressionError>;
+}
+
+export declare interface RankResetContext {
+    readonly ladder: RankLadder;
+    readonly score: number;
+}
+
+export declare interface RankResetDefinition {
+    readonly target: number;
+    readonly retain: number;
+}
+
+export declare type RankScoreResolver = (input: RankContext) => number;
+
+export 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 interface RankSeasonDefinition {
+    readonly id: string;
+    readonly version?: number;
+    readonly ladderId: string;
+    readonly from: number;
+    readonly until: number;
+    readonly rewards: readonly (readonly ProgressionReward[])[];
+}
+
+export declare interface RankSeasonReceipt {
+    readonly operationId: string;
+    readonly kind: 'observe' | 'close';
+    readonly after: RankSeasonState;
+    readonly rewardsQueued: number;
+    readonly at: number;
+}
+
+export declare type RankSeasonReset = (input: RankResetContext) => number;
+
+export 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>;
+}
+
+export 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 RankSqlService extends RankSeasonService {
+    readonly auditRanks: (subject: Subject, tenantId: string, ownerId: string) => Effect.Effect<RankAudit, ProgressionError>;
+    readonly rebuildRanks: (subject: Subject, tenantId: string, ownerId: string) => Effect.Effect<RankAudit, ProgressionError>;
+}
+
+declare interface RankStoreOptions {
+    readonly ladders: readonly (RankLadderDefinition | RankLadder)[];
+    readonly seasons: readonly (RankSeasonDefinition | RankSeason)[];
+    readonly source: RankRatingSourceService;
+    readonly strategies?: RankStrategies | undefined;
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly maxPendingRewards?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+
+export declare interface RankStrategies {
+    readonly version?: string;
+    readonly score?: RankScoreResolver;
+    readonly decay?: RankDecayResolver;
+    readonly grade?: RankGradeResolver;
+    readonly seasonReset?: RankSeasonReset;
+}
+
+export 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;
+}
+
+export 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;
+}
+
+export declare interface RegenResourceDefinition {
+    readonly id: string;
+    readonly version?: number;
+    readonly max: ProgressValue;
+    readonly initial?: ProgressValue;
+    readonly regenPer: string;
+    readonly regenAmount?: ProgressValue;
+    readonly refillOffer?: string;
+}
+
+export declare class RegenResourcePort extends RegenResourcePort_base {
+}
+
+declare const RegenResourcePort_base: Context.ServiceClass<RegenResourcePort, "@voltro/RegenResourcePort", RegenResourceService>;
+
+export 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>;
+}
+
+export declare interface RerollQuestInput {
+    readonly poolId: string;
+    readonly windowId: string;
+    readonly assignmentId: string;
+    readonly requestId: string;
+}
+
+/** A custom evaluator may change fulfillment; it must retain truthful threshold progress. */
+export declare const resolveAchievementEvaluation: (condition: AchievementCondition, stats: readonly AchievementStat[], slot?: AchievementEvaluator) => AchievementEvaluation;
+
+export declare const resolveDailyClaim: (input: DailyClaimPolicyContext, slot?: DailyClaimPolicy) => DailyState;
+
+export declare const resolvePassCatchUp: (input: PassCatchUpContext, slot?: PassCatchUp) => string;
+
+export declare const resolveQuestProgress: (input: QuestProgressContext, slot?: QuestProgressResolver) => readonly number[];
+
+export declare const resolveQuestWindow: (input: QuestWindowContext, slot?: QuestWindowResolver) => QuestWindow;
+
+export declare const resolveRank: (input: RankContext, strategies?: RankStrategies) => PlayerRank;
+
+export declare const resolveRankSeasonReset: (ladderInput: RankLadder, value: number, strategies?: RankStrategies) => number;
+
+export declare const resolveRankStrategies: (input?: RankStrategies) => Readonly<{
+    version: string;
+    score: RankScoreResolver;
+    decay: RankDecayResolver;
+    grade: RankGradeResolver;
+    seasonReset: RankSeasonReset;
+}>;
+
+export declare const resolveResourceRegen: (input: ResourceRegenContext, slot?: ResourceRegenResolver) => ResourceState;
+
+export declare const resolveRewards: (context: RewardResolverContext, slot?: RewardResolver) => readonly LevelReward[];
+
+export declare const resolveTutorialSkip: (tutorial: Tutorial, input: TutorialState, atInput: number) => TutorialState;
+
+export declare const resolveTutorialStep: (input: TutorialStepPolicyContext, policy?: TutorialStepPolicy) => TutorialState;
+
+export declare const resolveXpCurve: (xp: ProgressValue, curve: LevelCurve, slot?: XpCurve) => number;
+
+declare interface ResourceAudit {
+    readonly acceptedOperations: number;
+    readonly resources: number;
+    readonly matches: boolean;
+    readonly at: number;
+}
+
+export 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 interface ResourcePluginOptions extends ResourceStoreOptions {
+    readonly service?: RegenResourceService | undefined;
+}
+
+export 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;
+}
+
+export declare type ResourceRegenResolver = (input: ResourceRegenContext) => ResourceState;
+
+declare interface ResourceSqlService extends RegenResourceService {
+    readonly auditResources: (subject: Subject, tenantId: string, ownerId: string) => Effect.Effect<ResourceAudit, ProgressionError>;
+    readonly rebuildResources: (subject: Subject, tenantId: string, ownerId: string) => Effect.Effect<ResourceAudit, ProgressionError>;
+}
+
+export declare interface ResourceState {
+    readonly value: string;
+    readonly anchorAt: number;
+}
+
+declare interface ResourceStoreOptions {
+    readonly definitions: readonly RegenResourceDefinition[];
+    readonly sources: readonly string[];
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly strategies?: {
+        readonly regen?: ResourceRegenResolver | undefined;
+        readonly version?: string;
+    } | undefined;
+}
+
+export declare interface RewardDeliveryOptions {
+    /** An explicit app-owned funding account; never a balance/price/credential. */
+    readonly systemAccount: string;
+    readonly economy?: EconomyService | undefined;
+    readonly inventory?: InventoryService | undefined;
+    readonly progression?: ProgressionService | undefined;
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly version?: string;
+    /** Full replacement must own queue/privacy semantics of its source ports. */
+    readonly service?: RewardDeliveryService | undefined;
+}
+
+export declare class RewardDeliveryPort extends RewardDeliveryPort_base {
+}
+
+declare const RewardDeliveryPort_base: Context.ServiceClass<RewardDeliveryPort, "@voltro/RewardDeliveryPort", RewardDeliveryService>;
+
+export declare interface RewardDeliveryReceipt extends RewardDeliveryRequest {
+    readonly status: 'delivered' | 'erased';
+    readonly outputKind: 'currency' | 'item' | 'xp' | null;
+    readonly externalOperationId: string | null;
+    readonly at: number;
+}
+
+export declare interface RewardDeliveryRequest {
+    readonly kind: RewardSourceKind;
+    readonly rewardId: string;
+}
+
+export declare interface RewardDeliveryService {
+    readonly execute: (subject: Subject, input: RewardDeliveryRequest) => Effect.Effect<RewardDeliveryReceipt, ProgressionError>;
+    readonly dispatch: (subject: Subject, input: RewardDispatchInput, start: (payload: RewardDeliveryRequest) => Promise<WorkflowRunHandle>) => Effect.Effect<RewardDispatchResult, ProgressionError>;
+}
+
+export declare interface RewardDispatchCursor extends RewardDeliveryRequest {
+}
+
+export declare interface RewardDispatchInput {
+    readonly limit: number;
+    readonly after?: RewardDispatchCursor;
+}
+
+export declare interface RewardDispatchResult {
+    readonly submitted: readonly {
+        readonly request: RewardDeliveryRequest;
+        readonly status: WorkflowRunHandle['status'];
+    }[];
+    readonly failed: readonly RewardDeliveryRequest[];
+    readonly next: RewardDispatchCursor | null;
+}
+
+export declare type RewardResolver = (context: RewardResolverContext) => readonly LevelReward[];
+
+declare interface RewardResolverContext {
+    readonly track: ProgressionTrack;
+    readonly fromLevel: number;
+    readonly toLevel: number;
+}
+
+export declare type RewardSourceKind = 'level' | 'quest' | 'achievement' | 'daily' | 'pass' | 'tutorial' | 'rank';
+
+export 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';
+}
+
+export declare interface SeasonPassDefinition {
+    readonly id: string;
+    readonly version?: number;
+    readonly from: number;
+    readonly until: number;
+    readonly tiers: number;
+    readonly xpPerTier: ProgressValue;
+    readonly tracks: {
+        readonly free: readonly (readonly ProgressionReward[])[];
+        readonly premium: readonly (readonly ProgressionReward[])[];
+    };
+    readonly premiumOffer?: string;
+    readonly sources: readonly string[];
+    readonly catchUp?: {
+        readonly xpBoostAfterDay: number;
+        readonly multiplier?: number;
+    };
+    readonly autoClaim?: boolean;
+    readonly expireUnclaimed?: 'mail' | 'forfeit';
+}
+
+export declare class SeasonPassPort extends SeasonPassPort_base {
+}
+
+declare const SeasonPassPort_base: Context.ServiceClass<SeasonPassPort, "@voltro/SeasonPassPort", SeasonPassService>;
+
+export 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 statAtLeast: (stat: string, target: ProgressValue, scope?: {
+    readonly period?: "lifetime" | "season";
+    readonly seasonId?: string | null;
+}) => StatThreshold;
+
+export declare interface StatDefinition {
+    readonly id: string;
+    readonly initial?: ProgressValue;
+    readonly cap?: ProgressValue;
+    readonly operators?: readonly StatOperator[];
+}
+
+export declare const staticQuestSource: (input: readonly QuestPoolDefinition[], revision?: string) => QuestSourceService;
+
+export declare type StatOperator = typeof STAT_OPERATORS[number];
+
+export declare interface StatThreshold {
+    readonly kind: 'statAtLeast';
+    readonly stat: string;
+    readonly target: string;
+    readonly period: 'lifetime' | 'season';
+    readonly seasonId: string | null;
+}
+
+export 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 TutorialAudit {
+    readonly operations: number;
+    readonly tutorials: number;
+    readonly rewardRows: number;
+    readonly matches: boolean;
+}
+
+export declare interface TutorialDefinition {
+    readonly id?: string;
+    readonly version?: number;
+    readonly steps: readonly string[];
+    readonly skippable?: boolean;
+    readonly reward?: readonly ProgressionReward[];
+    readonly rewardOnSkip?: boolean;
+    readonly hints?: string;
+}
+
+export declare interface TutorialEvidence {
+    readonly source: string;
+    readonly originId: string;
+    readonly version: string;
+    readonly from: number;
+    readonly until: number;
+}
+
+export declare interface TutorialPluginOptions extends TutorialStoreOptions {
+    readonly service?: TutorialService | undefined;
+}
+
+export declare class TutorialPort extends TutorialPort_base {
+}
+
+declare const TutorialPort_base: Context.ServiceClass<TutorialPort, "@voltro/TutorialPort", TutorialService>;
+
+export declare interface TutorialReceipt {
+    readonly operationId: string;
+    readonly kind: 'step' | 'skip';
+    readonly step: string | null;
+    readonly after: TutorialState;
+    readonly rewardsQueued: number;
+    readonly at: number;
+}
+
+export declare interface TutorialRecordInput extends TutorialStepInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly source: string;
+    readonly originId: string;
+}
+
+export 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>;
+}
+
+export declare interface TutorialSkipInput {
+    readonly tutorialId: string;
+    readonly requestId: string;
+}
+
+declare interface TutorialSqlService extends TutorialService {
+    readonly auditTutorials: (subject: Subject, tenantId: string, ownerId: string) => Effect.Effect<TutorialAudit, ProgressionError>;
+    readonly rebuildTutorials: (subject: Subject, tenantId: string, ownerId: string) => Effect.Effect<TutorialAudit, ProgressionError>;
+}
+
+export 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;
+}
+
+export declare interface TutorialStepInput {
+    readonly tutorialId: string;
+    readonly step: string;
+    readonly requestId: string;
+}
+
+export declare type TutorialStepPolicy = (input: TutorialStepPolicyContext) => boolean;
+
+export declare interface TutorialStepPolicyContext {
+    readonly tutorial: Tutorial;
+    readonly before: TutorialState;
+    readonly step: string;
+    readonly evidence: TutorialEvidence;
+    readonly at: number;
+}
+
+declare interface TutorialStoreOptions {
+    readonly definitions: readonly (TutorialDefinition | Tutorial)[];
+    readonly eventSources: readonly string[];
+    readonly verifier?: TutorialVerifierService | undefined;
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly maxPendingRewards?: number | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly strategies?: {
+        readonly stepPolicy?: TutorialStepPolicy | undefined;
+        readonly version?: string;
+    } | undefined;
+}
+
+export declare interface TutorialVerificationInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly tutorialId: string;
+    readonly version: number;
+    readonly step: string;
+    readonly requestId: string;
+}
+
+export declare class TutorialVerifier extends TutorialVerifier_base {
+}
+
+declare const TutorialVerifier_base: Context.ServiceClass<TutorialVerifier, "@voltro/TutorialVerifier", TutorialVerifierService>;
+
+/** An app checks actual authoritative gameplay evidence; a client completion boolean is never evidence. */
+export declare interface TutorialVerifierService {
+    readonly verify: (subject: Subject, input: TutorialVerificationInput) => Effect.Effect<TutorialEvidence, ProgressionError>;
+}
+
+export declare const xp: (trackId: string, amount: ProgressValue) => ProgressionReward;
+
+export declare type XpCurve = (context: XpCurveContext) => number;
+
+declare interface XpCurveContext {
+    readonly xp: string;
+    readonly curve: LevelCurve;
+}
+
+export { }