@voltro/plugin-progression 0.0.0-stage → 0.87.0

package/dist/index.js

@@ -0,0 +1,19 @@
+import { ProgressionError as e } from "./errors.js";
+import { RankRatingSource as t, capturePlayerRank as n, captureRankRating as r, defaultRankDecay as i, defaultRankGrade as a, defaultRankScore as o, defaultRankSeasonReset as s, defineRankLadder as c, resolveRank as l, resolveRankSeasonReset as u, resolveRankStrategies as d } from "./ranks.js";
+import { grant as f, grantItem as p, xp as m } from "./reward.js";
+import { RankPort as h, acceptRankObservation as g, captureRankSeasonState as _, closeRankSeasonState as v, defineRankSeason as y, initialRankSeasonState as b } from "./rankSeasons.js";
+import { TutorialPort as x, TutorialVerifier as S, defaultTutorialStepPolicy as C, defineTutorial as w, resolveTutorialSkip as T, resolveTutorialStep as E } from "./tutorial.js";
+import { SeasonPassPort as D, defaultPassCatchUp as O, defineSeasonPass as k, resolvePassCatchUp as A } from "./pass.js";
+import { QuestSource as j, defaultQuestProgressResolver as M, defaultQuestSelector as N, defineQuest as P, defineQuestPool as F, resolveQuestProgress as I, selectQuests as L, staticQuestSource as R } from "./quests.js";
+import { DailyProfileSource as z, LoginCalendarPort as B, defaultDailyClaimPolicy as V, defaultDailyWindow as H, defineLoginCalendar as U, resolveDailyClaim as W } from "./daily.js";
+import { RewardDeliveryPort as G } from "./rewardDelivery.js";
+import { defaultXpCurve as K, explicitLevelCurve as q, levelCurve as J, resolveXpCurve as Y } from "./curve.js";
+import { ProgressionPort as X } from "./port.js";
+import { applyStatValue as Z, defineStat as Q } from "./stats.js";
+import { defaultRewardResolver as $, defineProgression as ee, resolveRewards as te } from "./track.js";
+import { QuestPort as ne } from "./questPort.js";
+import { QuestPlayerSource as re, QuestRefreshPort as ie, defaultQuestWindow as ae, resolveQuestWindow as oe } from "./questRefresh.js";
+import { RegenResourcePort as se, defaultResourceRegen as ce, defineRegenResource as le, resolveResourceRegen as ue } from "./resources.js";
+import { AchievementPort as de, AchievementStatSource as fe, captureAchievementCondition as pe, captureAchievementPlatform as me, captureAchievementStats as he, composite as ge, defaultAchievementEvaluator as _e, defineAchievement as ve, resolveAchievementEvaluation as ye, statAtLeast as be } from "./achievements.js";
+import { progressionAchievementsSystemContract as xe, progressionDailySystemContract as Se, progressionPassesSystemContract as Ce, progressionPlugin as we, progressionQuestsSystemContract as Te, progressionRanksSystemContract as Ee, progressionResourcesSystemContract as De, progressionSystemContract as Oe, progressionTutorialsSystemContract as ke } from "./plugin.js";
+export { de as AchievementPort, fe as AchievementStatSource, z as DailyProfileSource, B as LoginCalendarPort, e as ProgressionError, X as ProgressionPort, re as QuestPlayerSource, ne as QuestPort, ie as QuestRefreshPort, j as QuestSource, h as RankPort, t as RankRatingSource, se as RegenResourcePort, G as RewardDeliveryPort, D as SeasonPassPort, x as TutorialPort, S as TutorialVerifier, g as acceptRankObservation, Z as applyStatValue, pe as captureAchievementCondition, me as captureAchievementPlatform, he as captureAchievementStats, n as capturePlayerRank, r as captureRankRating, _ as captureRankSeasonState, v as closeRankSeasonState, ge as composite, _e as defaultAchievementEvaluator, V as defaultDailyClaimPolicy, H as defaultDailyWindow, O as defaultPassCatchUp, M as defaultQuestProgressResolver, N as defaultQuestSelector, ae as defaultQuestWindow, i as defaultRankDecay, a as defaultRankGrade, o as defaultRankScore, s as defaultRankSeasonReset, ce as defaultResourceRegen, $ as defaultRewardResolver, C as defaultTutorialStepPolicy, K as defaultXpCurve, ve as defineAchievement, U as defineLoginCalendar, ee as defineProgression, P as defineQuest, F as defineQuestPool, c as defineRankLadder, y as defineRankSeason, le as defineRegenResource, k as defineSeasonPass, Q as defineStat, w as defineTutorial, q as explicitLevelCurve, f as grant, p as grantItem, b as initialRankSeasonState, J as levelCurve, xe as progressionAchievementsSystemContract, Se as progressionDailySystemContract, Ce as progressionPassesSystemContract, we as progressionPlugin, Te as progressionQuestsSystemContract, Ee as progressionRanksSystemContract, De as progressionResourcesSystemContract, Oe as progressionSystemContract, ke as progressionTutorialsSystemContract, ye as resolveAchievementEvaluation, W as resolveDailyClaim, A as resolvePassCatchUp, I as resolveQuestProgress, oe as resolveQuestWindow, l as resolveRank, u as resolveRankSeasonReset, d as resolveRankStrategies, ue as resolveResourceRegen, te as resolveRewards, T as resolveTutorialSkip, E as resolveTutorialStep, Y as resolveXpCurve, L as selectQuests, be as statAtLeast, R as staticQuestSource, m as xp };

package/dist/pass.d.ts

@@ -0,0 +1,186 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+export declare const capturePassState: (input: unknown, pass: SeasonPass) => PassState;
+
+export declare const claimablePassTiers: (pass: SeasonPass, state: PassState) => readonly PassTierClaim[];
+
+export declare const defaultPassCatchUp: PassCatchUp;
+
+/** UTC elapsed days govern pass catch-up; player timezone does not change a season. */
+export declare const defineSeasonPass: (input: SeasonPassDefinition | SeasonPass) => SeasonPass;
+
+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 const passInitialState: (pass: SeasonPass) => PassState;
+
+export declare const passMask: (input: unknown, tiers: number) => bigint;
+
+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;
+}
+
+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;
+}
+
+export declare const passTier: (pass: SeasonPass, xp: string) => number;
+
+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 PlayerPass extends PassState {
+    readonly tier: number;
+    readonly from: number;
+    readonly until: number;
+    readonly observedAt: number;
+    readonly active: boolean;
+    readonly premiumOffer: string | null;
+    readonly claimable: readonly PassTierClaim[];
+}
+
+declare 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>;
+
+declare type ProgressionReward = {
+    readonly kind: 'currency';
+    readonly currency: string;
+    readonly amount: string;
+} | {
+    readonly kind: 'item';
+    readonly itemId: string;
+    readonly qty: number;
+} | {
+    readonly kind: 'xp';
+    readonly trackId: string;
+    readonly amount: string;
+};
+
+declare type ProgressValue = string | number | bigint;
+
+export declare const resolvePassCatchUp: (input: PassCatchUpContext, slot?: PassCatchUp) => string;
+
+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 { }

package/dist/pass.js

@@ -0,0 +1,122 @@
+import { progressionError as e } from "./errors.js";
+import { identifier as t, integer as n, list as r, object as i, progressValue as a } from "./capture.js";
+import { captureRewards as o } from "./reward.js";
+import { Context as s } from "effect";
+//#region src/pass.ts
+var c = (s) => {
+	let c = i(s, [
+		"id",
+		"version",
+		"from",
+		"until",
+		"tiers",
+		"xpPerTier",
+		"tracks",
+		"premiumOffer",
+		"sources",
+		"catchUp",
+		"autoClaim",
+		"expireUnclaimed"
+	]), l = n(c.from, 0, 864e13), u = n(c.until, l + 1, 864e13), d = n(c.tiers, 1, 256), f = a(c.xpPerTier);
+	if (!f || f * BigInt(d) > 9223372036854775807n) throw e("overflow");
+	let p = i(c.tracks, ["free", "premium"]), m = r(p.free, d).map((e) => o(e, 64)), h = r(p.premium, d).map((e) => o(e, 64));
+	if (m.length !== d || h.length !== d) throw e("invalid_input");
+	let g = r(c.sources, 64).map(t);
+	if (!g.length || new Set(g).size !== g.length) throw e("invalid_input");
+	let _ = c.catchUp == null ? null : i(c.catchUp, ["xpBoostAfterDay", "multiplier"]);
+	if (c.autoClaim !== void 0 && typeof c.autoClaim != "boolean" || c.expireUnclaimed !== void 0 && c.expireUnclaimed !== "mail" && c.expireUnclaimed !== "forfeit") throw e("invalid_input");
+	return Object.freeze({
+		id: t(c.id),
+		version: n(c.version ?? 1, 1, 1e6),
+		from: l,
+		until: u,
+		tiers: d,
+		xpPerTier: String(f),
+		tracks: Object.freeze({
+			free: Object.freeze(m),
+			premium: Object.freeze(h)
+		}),
+		premiumOffer: c.premiumOffer == null ? null : t(c.premiumOffer),
+		sources: Object.freeze(g),
+		catchUp: _ ? Object.freeze({
+			xpBoostAfterDay: n(_.xpBoostAfterDay, 0, 1e5),
+			multiplier: n(_.multiplier ?? 2, 1, 1e3)
+		}) : null,
+		autoClaim: c.autoClaim ?? !1,
+		expireUnclaimed: c.expireUnclaimed ?? "forfeit"
+	});
+}, l = ({ pass: e, amount: t, at: n }) => {
+	let r = e.catchUp && Math.floor((n - e.from) / 864e5) >= e.catchUp.xpBoostAfterDay ? e.catchUp.multiplier : 1;
+	return String(a(t) * BigInt(r));
+}, u = (t, r = l) => {
+	let i = c(t.pass), o = String(a(t.amount)), s = n(t.at, i.from, i.until - 1);
+	if (o === "0") throw e("invalid_input");
+	let u = a(r(Object.freeze({
+		pass: i,
+		amount: o,
+		at: s
+	})));
+	if (!u) throw e("invalid_input");
+	return String(u);
+}, d = (t, n) => {
+	if (typeof t != "string" || !/^(0|[1-9][0-9]{0,77})$/.test(t)) throw e("invalid_record");
+	let r = BigInt(t);
+	if (r >= 1n << BigInt(n)) throw e("invalid_record");
+	return r;
+}, f = (e, t) => Number(a(t) / BigInt(e.xpPerTier) > BigInt(e.tiers) ? BigInt(e.tiers) : a(t) / BigInt(e.xpPerTier)), p = (e) => Object.freeze({
+	passId: e.id,
+	version: e.version,
+	xp: "0",
+	claimedFree: "0",
+	claimedPremium: "0",
+	premium: !1,
+	purchasedAt: null,
+	fulfillmentId: null,
+	closed: !1,
+	updatedAt: e.from
+}), m = (r, o) => {
+	let s = i(r, [
+		"passId",
+		"version",
+		"xp",
+		"claimedFree",
+		"claimedPremium",
+		"premium",
+		"purchasedAt",
+		"fulfillmentId",
+		"closed",
+		"updatedAt"
+	]);
+	if (s.passId !== o.id || s.version !== o.version || typeof s.premium != "boolean" || typeof s.closed != "boolean") throw e("invalid_record");
+	let c = String(a(s.xp));
+	if (BigInt(c) > BigInt(o.xpPerTier) * BigInt(o.tiers)) throw e("invalid_record");
+	let l = (1n << BigInt(f(o, c))) - 1n, u = d(s.claimedFree, o.tiers), p = d(s.claimedPremium, o.tiers);
+	if ((u & l) !== u || (p & l) !== p || !s.premium && (p !== 0n || s.purchasedAt !== null || s.fulfillmentId !== null) || s.premium && (!o.premiumOffer || s.purchasedAt === null || s.fulfillmentId === null)) throw e("invalid_record");
+	let m = s.premium ? n(s.purchasedAt, o.from, o.until - 1) : null, h = s.premium ? t(s.fulfillmentId) : null, g = n(s.updatedAt, o.from, 864e13);
+	if (m !== null && m > g || !s.closed && g >= o.until || s.closed && g < o.until) throw e("invalid_record");
+	return Object.freeze({
+		passId: o.id,
+		version: o.version,
+		xp: c,
+		claimedFree: String(u),
+		claimedPremium: String(p),
+		premium: s.premium,
+		purchasedAt: m,
+		fulfillmentId: h,
+		closed: s.closed,
+		updatedAt: g
+	});
+}, h = (e, t) => {
+	let n = m(t, e), r = f(e, n.xp), i = [];
+	for (let t of ["free", "premium"]) if (t === "free" || n.premium) {
+		let a = d(t === "free" ? n.claimedFree : n.claimedPremium, e.tiers);
+		for (let n = 1; n <= r; n++) a & 1n << BigInt(n - 1) || i.push(Object.freeze({
+			tier: n,
+			track: t,
+			rewards: e.tracks[t][n - 1]
+		}));
+	}
+	return Object.freeze(i);
+}, g = class extends s.Service()("@voltro/SeasonPassPort") {};
+//#endregion
+export { g as SeasonPassPort, m as capturePassState, h as claimablePassTiers, l as defaultPassCatchUp, c as defineSeasonPass, p as passInitialState, d as passMask, f as passTier, u as resolvePassCatchUp };

package/dist/passRules.js

@@ -0,0 +1,96 @@
+import { progressionError as e } from "./errors.js";
+import { identifier as t, integer as n, object as r, progressValue as i } from "./capture.js";
+import { capturePassState as a, claimablePassTiers as o, passMask as s } from "./pass.js";
+//#region src/passRules.ts
+var c = (a, o) => {
+	let s = r(a);
+	if (s.kind === "xp" && Object.keys(s).length === 5) {
+		r(a, [
+			"kind",
+			"amount",
+			"effectiveAmount",
+			"source",
+			"originId"
+		]);
+		let n = String(i(s.amount)), c = String(i(s.effectiveAmount)), l = t(s.source);
+		if (n === "0" || c === "0" || !o.sources.includes(l)) throw e("invalid_input");
+		return Object.freeze({
+			kind: "xp",
+			amount: n,
+			effectiveAmount: c,
+			source: l,
+			originId: t(s.originId)
+		});
+	}
+	if (s.kind === "premium" && Object.keys(s).length === 3) {
+		r(a, [
+			"kind",
+			"offerId",
+			"fulfillmentId"
+		]);
+		let n = t(s.offerId);
+		if (n !== o.premiumOffer) throw e("forbidden");
+		return Object.freeze({
+			kind: "premium",
+			offerId: n,
+			fulfillmentId: t(s.fulfillmentId)
+		});
+	}
+	if (s.kind === "claim" && Object.keys(s).length === 3) {
+		if (r(a, [
+			"kind",
+			"tier",
+			"track"
+		]), s.track !== "free" && s.track !== "premium") throw e("invalid_input");
+		return Object.freeze({
+			kind: "claim",
+			tier: n(s.tier, 1, o.tiers),
+			track: s.track
+		});
+	}
+	if (s.kind === "close" && Object.keys(s).length === 1) return Object.freeze({ kind: "close" });
+	throw e("invalid_input");
+}, l = (t, r, l, u) => {
+	let d = a(r, t), f = c(l, t), p = n(u, d.updatedAt, 864e13);
+	if (d.closed || f.kind === "close" && p < t.until || f.kind !== "close" && (p < t.from || p >= t.until)) throw e("conflict");
+	if (f.kind === "close" && t.expireUnclaimed === "mail") throw e("unavailable");
+	let m = {
+		...d,
+		updatedAt: p
+	};
+	if (f.kind === "xp") {
+		let e = i(d.xp) + i(f.effectiveAmount), n = BigInt(t.xpPerTier) * BigInt(t.tiers);
+		m = {
+			...m,
+			xp: String(e > n ? n : e)
+		};
+	} else if (f.kind === "premium") {
+		if (d.premium) throw e("conflict");
+		m = {
+			...m,
+			premium: !0,
+			purchasedAt: p,
+			fulfillmentId: f.fulfillmentId
+		};
+	} else f.kind === "close" && (m = {
+		...m,
+		closed: !0
+	});
+	let h = o(t, m), g = f.kind === "claim" ? h.filter((e) => e.tier === f.tier && e.track === f.track) : t.autoClaim && (f.kind === "xp" || f.kind === "premium") ? h : [];
+	if (f.kind === "claim" && g.length !== 1) throw e("conflict");
+	let _ = s(m.claimedFree, t.tiers), v = s(m.claimedPremium, t.tiers);
+	for (let e of g) {
+		let t = 1n << BigInt(e.tier - 1);
+		e.track === "free" ? _ |= t : v |= t;
+	}
+	return Object.freeze({
+		after: a({
+			...m,
+			claimedFree: String(_),
+			claimedPremium: String(v)
+		}, t),
+		claims: Object.freeze(g)
+	});
+};
+//#endregion
+export { l as applyPassIntent, c as capturePassIntent };