@voltro/plugin-progression 0.0.0-stage → 0.88.0

package/dist/plugin.js

@@ -0,0 +1,1085 @@
+import { ProgressionError as e, progressionError as t } from "./errors.js";
+import { captureArguments as n, captureMethods as r, object as i } from "./capture.js";
+import { RankClosurePort as a } from "./rankClosure.js";
+import { RankRatingSource as ee, defaultRankDecay as te, defaultRankGrade as ne, defaultRankScore as re, defaultRankSeasonReset as ie } from "./ranks.js";
+import { RankPort as ae } from "./rankSeasons.js";
+import { TutorialPort as oe, TutorialVerifier as se, defaultTutorialStepPolicy as ce } from "./tutorial.js";
+import { SeasonPassPort as le, defaultPassCatchUp as ue } from "./pass.js";
+import { QuestSource as de, defaultQuestProgressResolver as fe, defaultQuestSelector as pe } from "./quests.js";
+import { DailyProfileSource as me, LoginCalendarPort as he, defaultDailyClaimPolicy as ge } from "./daily.js";
+import { RewardDeliveryPort as _e } from "./rewardDelivery.js";
+import { defaultXpCurve as ve } from "./curve.js";
+import { ProgressionPort as ye } from "./port.js";
+import { PROGRESSION_NAME as be, achievementsMineDescriptor as xe, achievementsRpcClientImports as Se, claimDailyDescriptor as Ce, dailyRpcClientImports as we, dailyStateDescriptor as Te, passClaimDescriptor as Ee, passesMineDescriptor as De, passesRpcClientImports as Oe, progressionMineDescriptor as ke, progressionRpcClientImports as Ae, progressionStatsDescriptor as je, questsMineDescriptor as Me, questsRerollDescriptor as Ne, questsRpcClientImports as Pe, rankObserveDescriptor as Fe, rankRpcClientImports as Ie, ranksMineDescriptor as Le, resourcesMineDescriptor as Re, resourcesRpcClientImports as ze, tutorialRpcClientImports as Be, tutorialSkipDescriptor as Ve, tutorialStepDescriptor as He, tutorialsMineDescriptor as Ue } from "./rpc.js";
+import { defaultRewardResolver as We, trackDeclaration as Ge } from "./track.js";
+import { progressionTables as Ke } from "./tables.entity.js";
+import { dataStoreProgression as qe, resolveProgressionOptions as Je } from "./progressionStore.js";
+import { QuestPort as Ye } from "./questPort.js";
+import { questTables as Xe } from "./questTables.entity.js";
+import { dataStoreQuests as Ze, questHash as Qe, resolveQuestOptions as $e } from "./questStore.js";
+import { QuestPlayerSource as et, QuestRefreshPort as tt, capturedRefresh as o, defaultQuestWindow as nt } from "./questRefresh.js";
+import { defaultQuestSeed as rt, makeQuestRefreshService as it, resolveQuestRefreshOptions as at } from "./questRefresh.server.js";
+import { RegenResourcePort as ot, defaultResourceRegen as st } from "./resources.js";
+import { resourceTables as ct } from "./resourceTables.entity.js";
+import { dataStoreResources as lt, resolveResourceOptions as ut } from "./resourceStore.js";
+import { AchievementPort as dt, AchievementStatSource as ft, defaultAchievementEvaluator as pt } from "./achievements.js";
+import { achievementTables as mt } from "./achievementTables.entity.js";
+import { dataStoreAchievements as ht, resolveAchievementOptions as gt } from "./achievementStore.js";
+import { dailyTables as _t } from "./dailyTables.entity.js";
+import { passTables as vt } from "./passTables.entity.js";
+import { tutorialTables as yt } from "./tutorialTables.entity.js";
+import { rankTables as bt } from "./rankTables.entity.js";
+import { dataStoreRewardDelivery as xt, resolveRewardDeliveryOptions as St } from "./rewardDelivery.server.js";
+import { dataStoreLoginCalendars as Ct, resolveDailyOptions as wt } from "./dailyStore.js";
+import { dataStoreSeasonPasses as Tt, resolvePassOptions as Et } from "./passStore.js";
+import { dataStoreTutorials as Dt, resolveTutorialOptions as Ot } from "./tutorialStore.js";
+import { dataStoreRankSeasons as kt, resolveRankStoreOptions as At } from "./rankStore.js";
+import { dataStoreRankClosure as jt, resolveRankClosureOptions as Mt } from "./rankClosure.server.js";
+import { Effect as s, Layer as c } from "effect";
+import { defineLicensedGamePlugin as Nt } from "@voltro/plugin-licensing/gate";
+import { fileURLToPath as Pt } from "node:url";
+import { systemSubject as Ft } from "@voltro/protocol";
+// src/plugin.ts
+var It = Object.freeze({
+	slots: {
+		questSelector: {
+			defaultExport: "defaultQuestSelector",
+			fixtureExport: "questSelectorSystemFixture"
+		},
+		questProgressResolver: {
+			defaultExport: "defaultQuestProgressResolver",
+			fixtureExport: "questProgressResolverSystemFixture"
+		}
+	},
+	ports: {
+		quests: {
+			tagExport: "QuestPort",
+			fakeLayerExport: "questFakeLayer",
+			fixtureExport: "questPortSystemFixture"
+		},
+		questSource: {
+			tagExport: "QuestSource",
+			fakeLayerExport: "questSourceFakeLayer",
+			fixtureExport: "questSourceSystemFixture"
+		}
+	},
+	events: []
+}), l = Object.freeze({
+	slots: { resourceRegen: {
+		defaultExport: "defaultResourceRegen",
+		fixtureExport: "resourceRegenSystemFixture"
+	} },
+	ports: { resources: {
+		tagExport: "RegenResourcePort",
+		fakeLayerExport: "resourceFakeLayer",
+		fixtureExport: "resourcePortSystemFixture"
+	} },
+	events: []
+}), u = Object.freeze({
+	slots: { achievementEvaluator: {
+		defaultExport: "defaultAchievementEvaluator",
+		fixtureExport: "achievementEvaluatorSystemFixture"
+	} },
+	ports: {
+		achievements: {
+			tagExport: "AchievementPort",
+			fakeLayerExport: "achievementFakeLayer",
+			fixtureExport: "achievementPortSystemFixture"
+		},
+		achievementStatSource: {
+			tagExport: "AchievementStatSource",
+			fakeLayerExport: "achievementStatSourceFakeLayer",
+			fixtureExport: "achievementStatSourceSystemFixture"
+		}
+	},
+	events: []
+}), d = Object.freeze({
+	slots: { passCatchUp: {
+		defaultExport: "defaultPassCatchUp",
+		fixtureExport: "passCatchUpSystemFixture"
+	} },
+	ports: { passes: {
+		tagExport: "SeasonPassPort",
+		fakeLayerExport: "passFakeLayer",
+		fixtureExport: "passPortSystemFixture"
+	} },
+	events: []
+}), f = Object.freeze({
+	slots: { tutorialStepPolicy: {
+		defaultExport: "defaultTutorialStepPolicy",
+		fixtureExport: "tutorialStepPolicySystemFixture"
+	} },
+	ports: { tutorials: {
+		tagExport: "TutorialPort",
+		fakeLayerExport: "tutorialFakeLayer",
+		fixtureExport: "tutorialPortSystemFixture"
+	} },
+	events: []
+}), p = Object.freeze({
+	slots: { dailyClaimPolicy: {
+		defaultExport: "defaultDailyClaimPolicy",
+		fixtureExport: "dailyClaimPolicySystemFixture"
+	} },
+	ports: {
+		daily: {
+			tagExport: "LoginCalendarPort",
+			fakeLayerExport: "loginCalendarFakeLayer",
+			fixtureExport: "loginCalendarPortSystemFixture"
+		},
+		dailyProfileSource: {
+			tagExport: "DailyProfileSource",
+			fakeLayerExport: "dailyProfileSourceFakeLayer",
+			fixtureExport: "dailyProfileSourceSystemFixture"
+		}
+	},
+	events: []
+}), m = Object.freeze({
+	slots: {
+		rankScore: {
+			defaultExport: "defaultRankScore",
+			fixtureExport: "rankScoreSystemFixture"
+		},
+		rankDecay: {
+			defaultExport: "defaultRankDecay",
+			fixtureExport: "rankDecaySystemFixture"
+		},
+		rankGrade: {
+			defaultExport: "defaultRankGrade",
+			fixtureExport: "rankGradeSystemFixture"
+		},
+		rankSeasonReset: {
+			defaultExport: "defaultRankSeasonReset",
+			fixtureExport: "rankSeasonResetSystemFixture"
+		}
+	},
+	ports: {
+		ranks: {
+			tagExport: "RankPort",
+			fakeLayerExport: "rankFakeLayer",
+			fixtureExport: "rankPortSystemFixture"
+		},
+		rankRatingSource: {
+			tagExport: "RankRatingSource",
+			fakeLayerExport: "rankRatingSourceFakeLayer",
+			fixtureExport: "rankRatingSourceSystemFixture"
+		}
+	},
+	events: []
+}), h = Object.freeze({
+	slots: {
+		xpCurve: {
+			defaultExport: "defaultXpCurve",
+			fixtureExport: "xpCurveSystemFixture"
+		},
+		rewardResolver: {
+			defaultExport: "defaultRewardResolver",
+			fixtureExport: "rewardResolverSystemFixture"
+		}
+	},
+	ports: { progression: {
+		tagExport: "ProgressionPort",
+		fakeLayerExport: "progressionFakeLayer",
+		fixtureExport: "progressionPortSystemFixture"
+	} },
+	events: []
+}), g = (It) => {
+	let l = i(It, [
+		"tracks",
+		"stats",
+		"statSources",
+		"allowedServices",
+		"maxHistoryRows",
+		"maxPendingRewards",
+		"now",
+		"strategies",
+		"service",
+		"quests",
+		"resources",
+		"achievements",
+		"delivery",
+		"daily",
+		"passes",
+		"tutorials",
+		"ranks"
+	]), u = Je({
+		tracks: l.tracks,
+		stats: l.stats,
+		statSources: l.statSources,
+		allowedServices: l.allowedServices,
+		maxHistoryRows: l.maxHistoryRows,
+		maxPendingRewards: l.maxPendingRewards,
+		now: l.now,
+		strategies: l.strategies
+	}), d = l.service === void 0 ? void 0 : r(l.service, [
+		"applyXp",
+		"applyStat",
+		"mine",
+		"stats",
+		"exportSubject",
+		"eraseSubject"
+	]), f = l.quests === void 0 ? void 0 : i(l.quests, [
+		"source",
+		"channel",
+		"locale",
+		"allowedServices",
+		"eventSources",
+		"statSources",
+		"maxWorkRows",
+		"now",
+		"strategies",
+		"service",
+		"refresh"
+	]), p = f ? $e({
+		source: f.source,
+		channel: f.channel,
+		locale: f.locale,
+		allowedServices: f.allowedServices,
+		eventSources: f.eventSources,
+		statSources: f.statSources,
+		maxWorkRows: f.maxWorkRows,
+		now: f.now,
+		strategies: f.strategies
+	}) : void 0, m = f?.service === void 0 ? void 0 : r(f.service, [
+		"assign",
+		"record",
+		"reroll",
+		"mine",
+		"exportSubject",
+		"eraseSubject"
+	]), h = l.resources === void 0 ? void 0 : i(l.resources, [
+		"definitions",
+		"sources",
+		"allowedServices",
+		"maxHistoryRows",
+		"now",
+		"strategies",
+		"service"
+	]), g = h ? ut({
+		definitions: h.definitions,
+		sources: h.sources,
+		allowedServices: h.allowedServices,
+		maxHistoryRows: h.maxHistoryRows,
+		now: h.now,
+		strategies: h.strategies
+	}) : void 0, _ = h?.service === void 0 ? void 0 : r(h.service, [
+		"initialize",
+		"consume",
+		"grant",
+		"mine",
+		"exportSubject",
+		"eraseSubject"
+	]), v, Lt, y, b = !1, x = l.achievements === void 0 ? void 0 : i(l.achievements, [
+		"definitions",
+		"source",
+		"allowedServices",
+		"maxHistoryRows",
+		"maxPendingRewards",
+		"now",
+		"strategies",
+		"service"
+	]), Rt = Object.freeze({ history: (e, n) => o({
+		subject: e,
+		input: n
+	}, (e) => s.suspend(() => b && y && !d ? y.achievementHistory(e.subject, e.input.tenantId, e.input.ownerId, e.input.limit) : s.fail(t("unavailable")))) });
+	if (x && d && x.source === void 0) throw t("invalid_input");
+	let zt = x ? {
+		definitions: n(x.definitions),
+		source: x.source ?? Rt,
+		allowedServices: x.allowedServices ?? u.allowedServices,
+		maxHistoryRows: x.maxHistoryRows,
+		maxPendingRewards: x.maxPendingRewards,
+		now: x.now,
+		strategies: x.strategies
+	} : void 0, S = zt ? gt(zt) : void 0, C = x?.service === void 0 ? void 0 : r(x.service, [
+		"evaluate",
+		"mine",
+		"exportSubject",
+		"eraseSubject"
+	]), w, T = f?.refresh === void 0 ? void 0 : at(f.refresh), Bt, Vt, Ht, Ut = (e) => s.suspend(() => {
+		let n = d ?? y;
+		return b && n ? e(n) : s.fail(t("unavailable"));
+	}), Wt = (e, r, i) => {
+		try {
+			let t = n(e), a = n(r);
+			return Ut((e) => i(e, t, a));
+		} catch {
+			return s.fail(t("invalid_input"));
+		}
+	}, E = Object.freeze({
+		applyXp: (e, t) => Wt(e, t, (e, t, n) => e.applyXp(t, n)),
+		applyStat: (e, t) => Wt(e, t, (e, t, n) => s.flatMap(e.applyStat(t, n), (e) => S ? s.as(k.evaluate(t, {
+			tenantId: n.tenantId,
+			ownerId: n.ownerId,
+			requestId: "stat." + Qe(e.operationId).slice(0, 56)
+		}), e) : s.succeed(e))),
+		mine: (e) => Wt(e, null, (e, t) => e.mine(t)),
+		stats: (e) => Wt(e, null, (e, t) => e.stats(t)),
+		exportSubject: (e) => {
+			try {
+				let t = n(e);
+				return Ut((e) => e.exportSubject(t));
+			} catch {
+				return s.fail(t("invalid_input"));
+			}
+		},
+		eraseSubject: (e) => {
+			try {
+				let t = n(e);
+				return Ut((e) => e.eraseSubject(t));
+			} catch {
+				return s.fail(t("invalid_input"));
+			}
+		}
+	}), Gt = (e, r) => {
+		try {
+			let i = n(e);
+			return s.suspend(() => {
+				let e = m ?? Ht;
+				return b && p && e ? r(e, i) : s.fail(t("unavailable"));
+			});
+		} catch {
+			return s.fail(t("invalid_input"));
+		}
+	}, D = Object.freeze({
+		assign: (e, t) => Gt({
+			subject: e,
+			input: t
+		}, (e, t) => e.assign(t.subject, t.input)),
+		record: (e, t) => Gt({
+			subject: e,
+			input: t
+		}, (e, t) => e.record(t.subject, t.input)),
+		reroll: (e, t) => Gt({
+			subject: e,
+			input: t
+		}, (e, t) => e.reroll(t.subject, t.input)),
+		mine: (e) => Gt(e, (e, t) => e.mine(t)),
+		exportSubject: (e) => Gt(e, (e, t) => e.exportSubject(t)),
+		eraseSubject: (e) => Gt(e, (e, t) => e.eraseSubject(t))
+	}), Kt = Object.freeze({
+		refreshOwner: (e, n) => o({
+			subject: e,
+			player: n
+		}, (e) => s.suspend(() => b && Vt ? Vt.refreshOwner(e.subject, e.player) : s.fail(t("unavailable")))),
+		refreshAll: (e) => o(e, (e) => s.suspend(() => b && Vt ? Vt.refreshAll(e) : s.fail(t("unavailable"))))
+	}), O = (e, n) => o(e, (e) => s.suspend(() => {
+		let r = _ ?? v;
+		return b && g && r ? n(r, e) : s.fail(t("unavailable"));
+	})), qt = Object.freeze({
+		initialize: (e, t) => O({
+			subject: e,
+			input: t
+		}, (e, t) => e.initialize(t.subject, t.input)),
+		consume: (e, t) => O({
+			subject: e,
+			input: t
+		}, (e, t) => e.consume(t.subject, t.input)),
+		grant: (e, t) => O({
+			subject: e,
+			input: t
+		}, (e, t) => e.grant(t.subject, t.input)),
+		mine: (e) => O(e, (e, t) => e.mine(t)),
+		exportSubject: (e) => O(e, (e, t) => e.exportSubject(t)),
+		eraseSubject: (e) => O(e, (e, t) => e.eraseSubject(t))
+	}), Jt = (e, n) => o(e, (e) => s.suspend(() => {
+		let r = C ?? w;
+		return b && S && r ? n(r, e) : s.fail(t("unavailable"));
+	})), k = Object.freeze({
+		evaluate: (e, t) => Jt({
+			subject: e,
+			input: t
+		}, (e, t) => e.evaluate(t.subject, t.input)),
+		mine: (e) => Jt(e, (e, t) => e.mine(t)),
+		exportSubject: (e) => Jt(e, (e, t) => e.exportSubject(t)),
+		eraseSubject: (e) => Jt(e, (e, t) => e.eraseSubject(t))
+	}), A = l.daily === void 0 ? void 0 : i(l.daily, [
+		"calendars",
+		"profileSource",
+		"maxHistoryRows",
+		"now",
+		"allowedServices",
+		"strategies",
+		"service"
+	]), j = A ? wt({
+		calendars: A.calendars,
+		profileSource: A.profileSource,
+		maxHistoryRows: A.maxHistoryRows,
+		now: A.now,
+		allowedServices: A.allowedServices,
+		strategies: A.strategies
+	}) : void 0, M = A?.service === void 0 ? void 0 : r(A.service, [
+		"claim",
+		"mine",
+		"exportSubject",
+		"eraseSubject"
+	]), N, Yt = (e, n) => o(e, (e) => s.suspend(() => {
+		let r = M ?? N;
+		return b && j && r ? n(r, e) : s.fail(t("unavailable"));
+	})), P = Object.freeze({
+		claim: (e, t) => Yt({
+			subject: e,
+			input: t
+		}, (e, t) => e.claim(t.subject, t.input)),
+		mine: (e) => Yt(e, (e, t) => e.mine(t)),
+		exportSubject: (e) => Yt(e, (e, t) => e.exportSubject(t)),
+		eraseSubject: (e) => Yt(e, (e, t) => e.eraseSubject(t))
+	}), F = l.passes === void 0 ? void 0 : i(l.passes, [
+		"definitions",
+		"allowedServices",
+		"maxHistoryRows",
+		"maxPendingRewards",
+		"now",
+		"strategies",
+		"service"
+	]), I = F ? Et({
+		definitions: F.definitions,
+		allowedServices: F.allowedServices,
+		maxHistoryRows: F.maxHistoryRows,
+		maxPendingRewards: F.maxPendingRewards,
+		now: F.now,
+		strategies: F.strategies
+	}) : void 0, L = F?.service === void 0 ? void 0 : r(F.service, [
+		"applyXp",
+		"grantPremium",
+		"claim",
+		"close",
+		"mine",
+		"exportSubject",
+		"eraseSubject"
+	]), R, z = (e, n) => o(e, (e) => s.suspend(() => {
+		let r = L ?? R;
+		return b && I && r ? n(r, e) : s.fail(t("unavailable"));
+	})), B = Object.freeze({
+		applyXp: (e, t) => z({
+			subject: e,
+			input: t
+		}, (e, t) => e.applyXp(t.subject, t.input)),
+		grantPremium: (e, t) => z({
+			subject: e,
+			input: t
+		}, (e, t) => e.grantPremium(t.subject, t.input)),
+		claim: (e, t) => z({
+			subject: e,
+			input: t
+		}, (e, t) => e.claim(t.subject, t.input)),
+		close: (e, t) => z({
+			subject: e,
+			input: t
+		}, (e, t) => e.close(t.subject, t.input)),
+		mine: (e) => z(e, (e, t) => e.mine(t)),
+		exportSubject: (e) => z(e, (e, t) => e.exportSubject(t)),
+		eraseSubject: (e) => z(e, (e, t) => e.eraseSubject(t))
+	}), V = l.tutorials === void 0 ? void 0 : i(l.tutorials, [
+		"definitions",
+		"eventSources",
+		"verifier",
+		"allowedServices",
+		"maxHistoryRows",
+		"maxPendingRewards",
+		"now",
+		"strategies",
+		"service"
+	]), H = V ? Ot({
+		definitions: V.definitions,
+		eventSources: V.eventSources,
+		verifier: V.verifier,
+		allowedServices: V.allowedServices,
+		maxHistoryRows: V.maxHistoryRows,
+		maxPendingRewards: V.maxPendingRewards,
+		now: V.now,
+		strategies: V.strategies
+	}) : void 0, U = V?.service === void 0 ? void 0 : r(V.service, [
+		"completeStep",
+		"record",
+		"skip",
+		"mine",
+		"exportSubject",
+		"eraseSubject"
+	]), W, G = (e, n) => o(e, (e) => s.suspend(() => {
+		let r = U ?? W;
+		return b && H && r ? n(r, e) : s.fail(t("unavailable"));
+	})), K = Object.freeze({
+		completeStep: (e, t) => G({
+			subject: e,
+			input: t
+		}, (e, t) => e.completeStep(t.subject, t.input)),
+		record: (e, t) => G({
+			subject: e,
+			input: t
+		}, (e, t) => e.record(t.subject, t.input)),
+		skip: (e, t) => G({
+			subject: e,
+			input: t
+		}, (e, t) => e.skip(t.subject, t.input)),
+		mine: (e) => G(e, (e, t) => e.mine(t)),
+		exportSubject: (e) => G(e, (e, t) => e.exportSubject(t)),
+		eraseSubject: (e) => G(e, (e, t) => e.eraseSubject(t))
+	}), q = l.ranks === void 0 ? void 0 : i(l.ranks, [
+		"ladders",
+		"seasons",
+		"source",
+		"strategies",
+		"allowedServices",
+		"maxHistoryRows",
+		"maxPendingRewards",
+		"now",
+		"service",
+		"closure"
+	]), J = q ? At({
+		ladders: q.ladders,
+		seasons: q.seasons,
+		source: q.source,
+		strategies: q.strategies,
+		allowedServices: q.allowedServices,
+		maxHistoryRows: q.maxHistoryRows,
+		maxPendingRewards: q.maxPendingRewards,
+		now: q.now
+	}) : void 0, Y = q?.service === void 0 ? void 0 : r(q.service, [
+		"observe",
+		"close",
+		"mine",
+		"exportSubject",
+		"eraseSubject"
+	]), X, Xt = (e, n) => o(e, (e) => s.suspend(() => {
+		let r = Y ?? X;
+		return b && J && r ? n(r, e) : s.fail(t("unavailable"));
+	})), Z = Object.freeze({
+		observe: (e, t) => Xt({
+			subject: e,
+			input: t
+		}, (e, t) => e.observe(t.subject, t.input)),
+		close: (e, t) => Xt({
+			subject: e,
+			input: t
+		}, (e, t) => e.close(t.subject, t.input)),
+		mine: (e) => Xt(e, (e, t) => e.mine(t)),
+		exportSubject: (e) => Xt(e, (e, t) => e.exportSubject(t)),
+		eraseSubject: (e) => Xt(e, (e, t) => e.eraseSubject(t))
+	}), Zt = q?.closure === void 0 ? void 0 : i(q.closure, [
+		"service",
+		"now",
+		"allowedServices"
+	]), Q = Zt ? Mt({
+		...Zt,
+		now: Zt.now ?? J.now,
+		allowedServices: Zt.allowedServices ?? J.allowedServices
+	}) : void 0;
+	if (Q && !Q.service && Y) throw t("invalid_input");
+	let Qt, $t = (e, n) => o(e, (e) => s.suspend(() => {
+		let r = Q?.service ?? Qt;
+		return b && Q && r ? n(r, e) : s.fail(t("unavailable"));
+	})), en = Object.freeze({
+		execute: (e, t) => $t({
+			subject: e,
+			input: t
+		}, (e, t) => e.execute(t.subject, t.input)),
+		dispatch: (e, t, n) => $t({
+			subject: e,
+			input: t
+		}, (e, t) => e.dispatch(t.subject, t.input, n))
+	}), tn = l.delivery === void 0 ? void 0 : i(l.delivery, [
+		"systemAccount",
+		"economy",
+		"inventory",
+		"progression",
+		"allowedServices",
+		"now",
+		"version",
+		"service"
+	]), $ = tn ? St({
+		...tn,
+		progression: tn.progression ?? E
+	}) : void 0;
+	if ($ && !$.service && (d || m || C || M || L || U || Y)) throw t("invalid_input");
+	let nn = Object.freeze([
+		"level",
+		...p ? ["quest"] : [],
+		...S ? ["achievement"] : [],
+		...j ? ["daily"] : [],
+		...I ? ["pass"] : [],
+		...H ? ["tutorial"] : [],
+		...J ? ["rank"] : []
+	]), rn, an = (e, n) => o(e, (e) => s.suspend(() => {
+		let r = $?.service ?? rn;
+		return b && $ && r ? n(r, e) : s.fail(t("unavailable"));
+	})), on = Object.freeze({
+		execute: (e, t) => an({
+			subject: e,
+			input: t
+		}, (e, t) => e.execute(t.subject, t.input)),
+		dispatch: (e, t, n) => an({
+			subject: e,
+			input: t
+		}, (e, t) => e.dispatch(t.subject, t.input, n))
+	}), sn = [
+		...d ? [] : Ke,
+		...p && !m ? Xe : [],
+		...g && !_ ? ct : [],
+		...S && !C ? mt : [],
+		...j && !M ? _t : [],
+		...I && !L ? vt : [],
+		...H && !U ? yt : [],
+		...J && !Y ? bt : []
+	], cn = c.succeed(ye, E), ln = p ? c.merge(cn, c.merge(c.succeed(Ye, D), c.succeed(de, p.source))) : cn, un = T ? c.merge(ln, c.merge(c.succeed(tt, Kt), c.succeed(et, T.players))) : ln, dn = g ? c.merge(un, c.succeed(ot, qt)) : un, fn = S ? c.merge(dn, c.merge(c.succeed(dt, k), c.succeed(ft, S.source))) : dn, pn = j ? c.merge(fn, c.merge(c.succeed(he, P), c.succeed(me, j.profileSource))) : fn, mn = I ? c.merge(pn, c.succeed(le, B)) : pn, hn = H ? c.merge(mn, c.succeed(oe, K)) : mn, gn = H?.verifier ? c.merge(hn, c.succeed(se, H.verifier)) : hn, _n = J ? c.merge(gn, c.merge(c.succeed(ae, Z), c.succeed(ee, J.source))) : gn, vn = Q ? c.merge(_n, c.succeed(a, en)) : _n, yn = $ ? c.merge(vn, c.succeed(_e, on)) : vn, bn = Nt({
+		name: be,
+		description: "Exact SQL XP/stat progression and durable level-reward intentions.",
+		permissions: ["store:write", "inspect:read"],
+		services: yn,
+		...$ || Q ? { sources: Object.freeze({
+			...$ ? { rewards: Pt(new URL("./reward-app", "" + import.meta.url)) } : {},
+			...Q ? { ranks: Pt(new URL("./rank-app", "" + import.meta.url)) } : {}
+		}) } : {},
+		routes: [
+			{
+				...ke,
+				execute: (e, t) => E.mine(t.request.subject)
+			},
+			{
+				...je,
+				execute: (e, t) => E.stats(t.request.subject)
+			},
+			...p ? [{
+				...Me,
+				execute: (e, t) => D.mine(t.request.subject)
+			}, {
+				...Ne,
+				execute: (e, t) => D.reroll(t.request.subject, e)
+			}] : [],
+			...g ? [{
+				...Re,
+				execute: (e, t) => qt.mine(t.request.subject)
+			}] : [],
+			...S ? [{
+				...xe,
+				execute: (e, t) => k.mine(t.request.subject)
+			}] : [],
+			...j ? [{
+				...Te,
+				execute: (e, t) => P.mine(t.request.subject)
+			}, {
+				...Ce,
+				execute: (e, t) => P.claim(t.request.subject, e)
+			}] : [],
+			...I ? [{
+				...De,
+				execute: (e, t) => B.mine(t.request.subject)
+			}, {
+				...Ee,
+				execute: (e, t) => B.claim(t.request.subject, e)
+			}] : [],
+			...J ? [{
+				...Le,
+				execute: (e, t) => Z.mine(t.request.subject)
+			}, {
+				...Fe,
+				execute: (e, t) => Z.observe(t.request.subject, e)
+			}] : [],
+			...H ? [
+				{
+					...Ue,
+					execute: (e, t) => K.mine(t.request.subject)
+				},
+				{
+					...He,
+					execute: (e, t) => K.completeStep(t.request.subject, e)
+				},
+				{
+					...Ve,
+					execute: (e, t) => K.skip(t.request.subject, e)
+				}
+			] : []
+		],
+		rpcClientDescriptors: [
+			...Ae,
+			...p ? Pe : [],
+			...g ? ze : [],
+			...S ? Se : [],
+			...j ? we : [],
+			...I ? Oe : [],
+			...H ? Be : [],
+			...J ? Ie : []
+		],
+		errorSchemas: [{
+			schema: e,
+			import: {
+				module: "@voltro/plugin-progression/errors",
+				name: "ProgressionError"
+			}
+		}],
+		extendSchema: { tables: sn },
+		subjectPrivacy: {
+			tables: sn.map((e) => e.tableName),
+			kinds: ["user", "guest"]
+		},
+		bindDataStore: (e, n) => {
+			if (T && !n?.scheduleCoordinated) throw Error("Quest refresh requires the framework coordinated scheduler bind context");
+			if (Lt !== void 0 && Lt !== e) throw Error("Progression plugin instance cannot cross app stores");
+			Lt = e, d || (y = qe(e, {
+				tracks: u.tracks.map(Ge),
+				stats: u.stats,
+				statSources: u.statSources,
+				allowedServices: u.allowedServices,
+				maxHistoryRows: u.maxHistoryRows,
+				maxPendingRewards: u.maxPendingRewards,
+				now: u.now,
+				strategies: u.strategies
+			})), p && !m && (Ht = Ze(e, p)), g && !_ && (v = lt(e, g)), zt && !C && (w = ht(e, zt)), j && !M && (N = Ct(e, j)), I && !L && (R = Tt(e, I)), H && !U && (W = Dt(e, H)), J && !Y && (X = kt(e, J)), Q && !Q.service && (Qt = jt(e, X, J, Q)), $ && !$.service && (rn = xt(e, $, nn)), b = !0, T && p && (Vt = T.service ?? it(D, p, T), Bt?.stop(), Bt = n.scheduleCoordinated("progression.quests.refresh", T.intervalMs, async () => {
+				let e = await s.runPromise(Kt.refreshAll(Ft("progression.quests.refresh")));
+				if (e.failures.length > 0) throw t("unavailable");
+				return { idle: e.players === 0 };
+			}));
+		},
+		onDeactivate: () => s.sync(() => {
+			b = !1, Bt?.stop(), Bt = void 0, Vt = void 0, v = void 0, w = void 0, rn = void 0, N = void 0, R = void 0, W = void 0, X = void 0, Qt = void 0, y = void 0, Ht = void 0;
+		}),
+		onExport: (e, t) => {
+			let n = {
+				subjectId: e,
+				tenantId: t.tenantId,
+				kind: t.kind
+			};
+			return p || g || S || j || I || H || J ? s.gen(function* () {
+				let e = yield* E.exportSubject(n), t = p ? yield* D.exportSubject(n) : void 0, r = g ? yield* qt.exportSubject(n) : void 0, i = S ? yield* k.exportSubject(n) : void 0, a = j ? yield* P.exportSubject(n) : void 0, ee = I ? yield* B.exportSubject(n) : void 0, te = H ? yield* K.exportSubject(n) : void 0, ne = J ? yield* Z.exportSubject(n) : void 0;
+				return {
+					progression: e,
+					...p ? { quests: t } : {},
+					...g ? { resources: r } : {},
+					...S ? { achievements: i } : {},
+					...j ? { daily: a } : {},
+					...I ? { passes: ee } : {},
+					...H ? { tutorials: te } : {},
+					...J ? { ranks: ne } : {}
+				};
+			}) : E.exportSubject(n);
+		},
+		onErase: (e, t) => {
+			let n = {
+				subjectId: e,
+				tenantId: t.tenantId,
+				kind: t.kind
+			}, r = p ? s.andThen(E.eraseSubject(n), D.eraseSubject(n)) : E.eraseSubject(n), i = g ? s.andThen(r, qt.eraseSubject(n)) : r, a = S ? s.andThen(i, k.eraseSubject(n)) : i, ee = j ? s.andThen(a, P.eraseSubject(n)) : a, te = I ? s.andThen(ee, B.eraseSubject(n)) : ee, ne = H ? s.andThen(te, K.eraseSubject(n)) : te;
+			return J ? s.andThen(ne, Z.eraseSubject(n)) : ne;
+		},
+		inspectEndpoints: [{
+			method: "GET",
+			path: "/status",
+			scope: "process",
+			description: "Captured progression declarations and binding; no player values, origins or reward bodies.",
+			handler: () => s.sync(() => ({
+				kind: "json",
+				data: {
+					capturedAt: (u.now ?? Date.now)(),
+					bound: b,
+					backend: d ? "custom" : "sql",
+					slots: {
+						xpCurve: u.strategies.xpCurve === ve ? "default" : "custom",
+						rewardResolver: u.strategies.rewardResolver === We ? "default" : "custom",
+						version: u.strategies.version
+					},
+					tracks: u.tracks.map((e) => ({
+						id: e.id,
+						version: e.version,
+						levels: e.xpCurve.thresholds.length,
+						sources: e.sources
+					})),
+					stats: u.stats.map((e) => ({
+						id: e.id,
+						cap: e.cap,
+						operators: e.operators
+					})),
+					budgets: {
+						historyRows: u.maxHistoryRows,
+						pendingRewards: u.maxPendingRewards
+					},
+					tableRoles: sn.map((e) => e.tableName),
+					rankInstalled: J !== void 0,
+					rankSystem: J ? {
+						backend: Y ? "custom" : "sql",
+						source: "custom",
+						maxHistoryRows: J.maxHistoryRows,
+						maxPendingRewards: J.maxPendingRewards,
+						ladders: J.ladders,
+						seasons: J.seasons.map((e) => ({
+							id: e.id,
+							version: e.version,
+							ladderId: e.ladderId,
+							from: e.from,
+							until: e.until,
+							rewardCounts: e.rewards.map((e) => e.length)
+						})),
+						slots: {
+							score: J.strategies.score === re ? "default" : "custom",
+							decay: J.strategies.decay === te ? "default" : "custom",
+							grade: J.strategies.grade === ne ? "default" : "custom",
+							seasonReset: J.strategies.seasonReset === ie ? "default" : "custom",
+							version: J.strategies.version
+						},
+						closureWorkflowInstalled: Q !== void 0,
+						closureSystem: Q ? {
+							backend: Q.service ? "custom" : "sql",
+							workflow: "progression.closeRankSeason",
+							schedule: "progression.dispatchRankClosures",
+							cron: "* * * * *",
+							timezone: "UTC",
+							scan: {
+								pageSize: 100,
+								maxPages: 100
+							},
+							activityMaxAttempts: 5,
+							suspendOnFailure: !0
+						} : null,
+						observationInstalled: !0,
+						completeMatchCoverageInstalled: !1,
+						seasonPlacementsInstalled: !1,
+						decayWorkflowInstalled: !1,
+						ratingResetInstalled: !1,
+						rewardDeliveryInstalled: $ !== void 0
+					} : null,
+					passInstalled: I !== void 0,
+					passSystem: I ? {
+						backend: L ? "custom" : "sql",
+						maxHistoryRows: I.maxHistoryRows,
+						maxPendingRewards: I.maxPendingRewards,
+						definitions: I.definitions.map((e) => ({
+							id: e.id,
+							version: e.version,
+							from: e.from,
+							until: e.until,
+							tiers: e.tiers,
+							xpPerTier: e.xpPerTier,
+							premiumOffer: e.premiumOffer,
+							autoClaim: e.autoClaim,
+							expireUnclaimed: e.expireUnclaimed,
+							catchUp: e.catchUp,
+							sources: e.sources
+						})),
+						slots: {
+							passCatchUp: I.strategies.passCatchUp === ue ? "default" : "custom",
+							version: I.strategies.version
+						},
+						claimInstalled: !0,
+						shopInstalled: !1,
+						expiryWorkflowInstalled: !1,
+						inboxInstalled: !1,
+						rewardDeliveryInstalled: $ !== void 0
+					} : null,
+					tutorialInstalled: H !== void 0,
+					tutorialSystem: H ? {
+						backend: U ? "custom" : "sql",
+						maxHistoryRows: H.maxHistoryRows,
+						maxPendingRewards: H.maxPendingRewards,
+						eventSources: H.eventSources,
+						definitions: H.definitions.map((e) => ({
+							id: e.id,
+							version: e.version,
+							steps: e.steps,
+							skippable: e.skippable,
+							rewardOnSkip: e.rewardOnSkip,
+							hints: e.hints
+						})),
+						slots: {
+							stepPolicy: H.strategies.stepPolicy === ce ? "default" : "custom",
+							version: H.strategies.version
+						},
+						verifier: U ? "customPort" : H.verifier ? "custom" : "absent",
+						telemetryInstalled: !1,
+						joinContextInstalled: !1,
+						hintsContentInstalled: !1,
+						rewardDeliveryInstalled: $ !== void 0
+					} : null,
+					resourcesInstalled: g !== void 0,
+					resourceSystem: g ? {
+						backend: _ ? "custom" : "sql",
+						definitions: g.definitions.map((e) => ({
+							id: e.id,
+							version: e.version,
+							max: e.max,
+							initial: e.initial,
+							regenAmount: e.regenAmount,
+							regenEveryMs: e.regenEveryMs,
+							refillOffer: e.refillOffer ?? null
+						})),
+						sources: g.sources,
+						maxHistoryRows: g.maxHistoryRows,
+						slots: {
+							regen: g.strategies.regen === st ? "default" : "custom",
+							version: g.strategies.version
+						}
+					} : null,
+					dailyInstalled: j !== void 0,
+					dailySystem: j ? {
+						backend: M ? "custom" : "sql",
+						profileSource: "custom",
+						maxHistoryRows: j.maxHistoryRows,
+						definitions: j.calendars.map((e) => ({
+							id: e.id,
+							version: e.version,
+							days: e.days.length,
+							streakProtection: e.streakProtection
+						})),
+						slots: {
+							claimPolicy: j.strategies.claimPolicy === ge ? "default" : "custom",
+							version: j.strategies.version
+						},
+						timezonePolicy: "pin-on-first-claim",
+						claimInstalled: !0,
+						rewardDeliveryInstalled: $ !== void 0,
+						timePushInstalled: !1
+					} : null,
+					deliverySystem: $ ? {
+						backend: $.service ? "custom" : "sql",
+						version: $.version,
+						sourceKinds: nn,
+						currencyPort: $.economy !== void 0,
+						itemPort: $.inventory !== void 0,
+						xpPort: $.progression !== void 0,
+						workflow: "progression.deliverReward",
+						schedule: "progression.dispatchRewards",
+						cron: "* * * * *",
+						timezone: "UTC",
+						scan: {
+							pageSize: 100,
+							maxPages: 100
+						},
+						activityMaxAttempts: 5,
+						suspendOnFailure: !0
+					} : null,
+					rewardDeliveryInstalled: $ !== void 0,
+					questsInstalled: p !== void 0,
+					achievementsInstalled: S !== void 0,
+					achievementSystem: S ? {
+						backend: C ? "custom" : "sql",
+						source: x?.source === void 0 ? "progressionSql" : "custom",
+						maxHistoryRows: S.maxHistoryRows,
+						maxPendingRewards: S.maxPendingRewards,
+						definitions: S.definitions.map((e) => ({
+							id: e.id,
+							version: e.version,
+							hidden: e.hidden,
+							tiers: e.tiers.length,
+							platformMappings: e.tiers.reduce((e, t) => e + Object.keys(t.platform).length, 0)
+						})),
+						slots: {
+							achievementEvaluator: S.strategies.achievementEvaluator === pt ? "default" : "custom",
+							version: S.strategies.version
+						},
+						statEvaluationInstalled: !0,
+						platformSyncInstalled: !1,
+						rewardDeliveryInstalled: $ !== void 0
+					} : null,
+					questSystem: p ? {
+						backend: m ? "custom" : "sql",
+						channel: p.channel,
+						locale: p.locale,
+						maxWorkRows: p.maxWorkRows,
+						eventSources: p.eventSources,
+						statSources: p.statSources,
+						slots: {
+							questSelector: p.strategies.questSelector === pe ? "default" : "custom",
+							questProgressResolver: p.strategies.questProgressResolver === fe ? "default" : "custom",
+							version: p.strategies.version
+						},
+						schedulingInstalled: Bt !== void 0,
+						refresh: T ? {
+							backend: T.service ? "custom" : "default",
+							intervalMs: T.intervalMs,
+							maxPlayers: T.maxPlayers,
+							slots: {
+								questWindow: T.strategies.questWindow === nt ? "default" : "custom",
+								questSeed: T.strategies.questSeed === rt ? "default" : "custom",
+								version: T.strategies.version
+							}
+						} : null,
+						rewardDeliveryInstalled: $ !== void 0
+					} : null
+				}
+			}))
+		}]
+	}), xn = (e, r, i, a) => {
+		try {
+			let ee = n(e), te = r, ne = i;
+			return s.suspend(() => b && y && !d ? a(y, ee, te, ne) : s.fail(t("unavailable")));
+		} catch {
+			return s.fail(t("invalid_input"));
+		}
+	};
+	return {
+		...bn,
+		progression: Object.freeze({
+			service: () => E,
+			auditProgression: (e, t, n) => xn(e, t, n, (e, t, n, r) => e.auditProgression(t, n, r)),
+			rebuildProgression: (e, t, n) => xn(e, t, n, (e, t, n, r) => e.rebuildProgression(t, n, r)),
+			ranks: () => Z,
+			rankClosure: () => en,
+			auditRanks: (e, n, r) => o({
+				subject: e,
+				tenantId: n,
+				ownerId: r
+			}, (e) => s.suspend(() => b && X && !Y ? X.auditRanks(e.subject, e.tenantId, e.ownerId) : s.fail(t("unavailable")))),
+			rebuildRanks: (e, n, r) => o({
+				subject: e,
+				tenantId: n,
+				ownerId: r
+			}, (e) => s.suspend(() => b && X && !Y ? X.rebuildRanks(e.subject, e.tenantId, e.ownerId) : s.fail(t("unavailable")))),
+			tutorials: () => K,
+			auditTutorials: (e, n, r) => o({
+				subject: e,
+				tenantId: n,
+				ownerId: r
+			}, (e) => s.suspend(() => b && W && !U ? W.auditTutorials(e.subject, e.tenantId, e.ownerId) : s.fail(t("unavailable")))),
+			rebuildTutorials: (e, n, r) => o({
+				subject: e,
+				tenantId: n,
+				ownerId: r
+			}, (e) => s.suspend(() => b && W && !U ? W.rebuildTutorials(e.subject, e.tenantId, e.ownerId) : s.fail(t("unavailable")))),
+			passes: () => B,
+			auditPasses: (e, n, r) => o({
+				subject: e,
+				tenantId: n,
+				ownerId: r
+			}, (e) => s.suspend(() => b && R && !L ? R.auditPasses(e.subject, e.tenantId, e.ownerId) : s.fail(t("unavailable")))),
+			rebuildPasses: (e, n, r) => o({
+				subject: e,
+				tenantId: n,
+				ownerId: r
+			}, (e) => s.suspend(() => b && R && !L ? R.rebuildPasses(e.subject, e.tenantId, e.ownerId) : s.fail(t("unavailable")))),
+			daily: () => P,
+			auditDaily: (e, n, r) => o({
+				subject: e,
+				tenantId: n,
+				ownerId: r
+			}, (e) => s.suspend(() => b && N && !M ? N.auditDaily(e.subject, e.tenantId, e.ownerId) : s.fail(t("unavailable")))),
+			rebuildDaily: (e, n, r) => o({
+				subject: e,
+				tenantId: n,
+				ownerId: r
+			}, (e) => s.suspend(() => b && N && !M ? N.rebuildDaily(e.subject, e.tenantId, e.ownerId) : s.fail(t("unavailable")))),
+			delivery: () => on,
+			achievements: () => k,
+			auditAchievements: (e, n, r) => o({
+				subject: e,
+				tenantId: n,
+				ownerId: r
+			}, (e) => s.suspend(() => b && w && !C ? w.auditAchievements(e.subject, e.tenantId, e.ownerId) : s.fail(t("unavailable")))),
+			rebuildAchievements: (e, n, r) => o({
+				subject: e,
+				tenantId: n,
+				ownerId: r
+			}, (e) => s.suspend(() => b && w && !C ? w.rebuildAchievements(e.subject, e.tenantId, e.ownerId) : s.fail(t("unavailable")))),
+			quests: () => D,
+			questRefresh: () => Kt,
+			resources: () => qt,
+			auditResources: (e, n, r) => o({
+				subject: e,
+				tenantId: n,
+				ownerId: r
+			}, (e) => s.suspend(() => b && v && !_ ? v.auditResources(e.subject, e.tenantId, e.ownerId) : s.fail(t("unavailable")))),
+			rebuildResources: (e, n, r) => o({
+				subject: e,
+				tenantId: n,
+				ownerId: r
+			}, (e) => s.suspend(() => b && v && !_ ? v.rebuildResources(e.subject, e.tenantId, e.ownerId) : s.fail(t("unavailable"))))
+		})
+	};
+};
+export { u as progressionAchievementsSystemContract, p as progressionDailySystemContract, d as progressionPassesSystemContract, g as progressionPlugin, It as progressionQuestsSystemContract, m as progressionRanksSystemContract, l as progressionResourcesSystemContract, h as progressionSystemContract, f as progressionTutorialsSystemContract };