@voltro/plugin-progression 0.0.0-stage → 0.87.0

package/dist/testing.js

@@ -0,0 +1,11 @@
+import { defaultRankDecay as e, defaultRankGrade as t, defaultRankScore as n, defaultRankSeasonReset as r } from "./ranks.js";
+import { defaultTutorialStepPolicy as i, resolveTutorialStep as a } from "./tutorial.js";
+import { defaultPassCatchUp as o, resolvePassCatchUp as s } from "./pass.js";
+import { defaultQuestProgressResolver as c, defaultQuestSelector as l, defineQuestPool as u, resolveQuestProgress as d, selectQuests as f, staticQuestSource as p } from "./quests.js";
+import { defaultResourceRegen as m, defineRegenResource as h, resolveResourceRegen as g } from "./resources.js";
+import { passFixture as _, progressionFixture as v, rankFixture as y, rankSeasonPolicyFixture as b, resourceFixture as x, tutorialFixture as S } from "./declarationFixtures.js";
+import { achievementEvaluatorSystemFixture as C, achievementFakeLayer as w, achievementPortSystemFixture as T, achievementStatSourceFakeLayer as E, achievementStatSourceSystemFixture as D, passCatchUpSystemFixture as O, passFakeLayer as k, passPortSystemFixture as A, progressionFakeLayer as j, progressionPortSystemFixture as M, questFakeLayer as N, questPortSystemFixture as P, questProgressResolverSystemFixture as F, questSelectorSystemFixture as I, questSourceFakeLayer as L, questSourceSystemFixture as R, resourceFakeLayer as z, resourcePortSystemFixture as B, resourceRegenSystemFixture as V, rewardResolverSystemFixture as H, xpCurveSystemFixture as U } from "./systemFixtures.js";
+import { tutorialFakeLayer as W, tutorialPortSystemFixture as G, tutorialStepPolicySystemFixture as K } from "./tutorialSystem.fixture.js";
+import { dailyClaimPolicySystemFixture as q, dailyProfileSourceFakeLayer as J, dailyProfileSourceSystemFixture as Y, loginCalendarFakeLayer as X, loginCalendarPortSystemFixture as Z } from "./dailySystem.fixture.js";
+import { rankDecaySystemFixture as Q, rankFakeLayer as $, rankGradeSystemFixture as ee, rankPortSystemFixture as te, rankRatingSourceFakeLayer as ne, rankRatingSourceSystemFixture as re, rankScoreSystemFixture as ie, rankSeasonResetSystemFixture as ae } from "./rankSystem.fixture.js";
+export { C as achievementEvaluatorSystemFixture, w as achievementFakeLayer, T as achievementPortSystemFixture, E as achievementStatSourceFakeLayer, D as achievementStatSourceSystemFixture, q as dailyClaimPolicySystemFixture, J as dailyProfileSourceFakeLayer, Y as dailyProfileSourceSystemFixture, o as defaultPassCatchUp, c as defaultQuestProgressResolver, l as defaultQuestSelector, e as defaultRankDecay, t as defaultRankGrade, n as defaultRankScore, r as defaultRankSeasonReset, m as defaultResourceRegen, i as defaultTutorialStepPolicy, u as defineQuestPool, h as defineRegenResource, X as loginCalendarFakeLayer, Z as loginCalendarPortSystemFixture, O as passCatchUpSystemFixture, k as passFakeLayer, _ as passFixture, A as passPortSystemFixture, j as progressionFakeLayer, v as progressionFixture, M as progressionPortSystemFixture, N as questFakeLayer, P as questPortSystemFixture, F as questProgressResolverSystemFixture, I as questSelectorSystemFixture, L as questSourceFakeLayer, R as questSourceSystemFixture, Q as rankDecaySystemFixture, $ as rankFakeLayer, y as rankFixture, ee as rankGradeSystemFixture, te as rankPortSystemFixture, ne as rankRatingSourceFakeLayer, re as rankRatingSourceSystemFixture, ie as rankScoreSystemFixture, b as rankSeasonPolicyFixture, ae as rankSeasonResetSystemFixture, s as resolvePassCatchUp, d as resolveQuestProgress, g as resolveResourceRegen, a as resolveTutorialStep, z as resourceFakeLayer, x as resourceFixture, B as resourcePortSystemFixture, V as resourceRegenSystemFixture, H as rewardResolverSystemFixture, f as selectQuests, p as staticQuestSource, W as tutorialFakeLayer, S as tutorialFixture, G as tutorialPortSystemFixture, K as tutorialStepPolicySystemFixture, U as xpCurveSystemFixture };

package/dist/track.js

@@ -0,0 +1,72 @@
+import { progressionError as e } from "./errors.js";
+import { identifier as t, integer as n, list as r, object as i } from "./capture.js";
+import { captureRewards as a } from "./reward.js";
+import { explicitLevelCurve as o } from "./curve.js";
+//#region src/track.ts
+var s = (s) => {
+	let c = i(s, [
+		"id",
+		"version",
+		"xpCurve",
+		"sources",
+		"rewards"
+	]), l = i(c.xpCurve, ["thresholds"]), u = o(l.thresholds), d = r(c.sources, 64).map(t);
+	if (d.length === 0 || new Set(d).size !== d.length) throw e("invalid_track");
+	let f = i(c.rewards ?? {}), p = Object.create(null), m = Object.create(null), h = (t) => {
+		if (!/^[1-9][0-9]*$/.test(t)) throw e("invalid_reward");
+		return String(n(Number(t), 2, u.thresholds.length));
+	};
+	for (let [e, t] of Object.entries(f)) if (e === "every") for (let [e, n] of Object.entries(i(t))) m[h(e)] = a(n, 64);
+	else p[h(e)] = a(t, 64);
+	return Object.freeze({
+		id: t(c.id),
+		version: n(c.version ?? 1, 1, 1e6),
+		xpCurve: u,
+		sources: Object.freeze(d),
+		rewards: Object.freeze(p),
+		every: Object.freeze(m)
+	});
+}, c = (e) => ({
+	id: e.id,
+	version: e.version,
+	xpCurve: e.xpCurve,
+	sources: e.sources,
+	rewards: {
+		...e.rewards,
+		every: e.every
+	}
+}), l = ({ track: t, fromLevel: n, toLevel: r }) => {
+	let i = [];
+	for (let a = n + 1; a <= r; a++) {
+		for (let n of t.rewards[String(a)] ?? []) {
+			if (i.length >= 256) throw e("limit_exceeded");
+			i.push(Object.freeze({
+				level: a,
+				reward: n
+			}));
+		}
+		for (let [n, r] of Object.entries(t.every)) if (a % Number(n) === 0) for (let t of r) {
+			if (i.length >= 256) throw e("limit_exceeded");
+			i.push(Object.freeze({
+				level: a,
+				reward: t
+			}));
+		}
+	}
+	return Object.freeze(i);
+}, u = (e, t = l) => {
+	let o = s(c(e.track)), u = n(e.fromLevel, 1, o.xpCurve.thresholds.length), d = n(e.toLevel, u, o.xpCurve.thresholds.length);
+	return Object.freeze(r(t(Object.freeze({
+		track: o,
+		fromLevel: u,
+		toLevel: d
+	})), 256).map((e) => {
+		let t = i(e, ["level", "reward"]);
+		return Object.freeze({
+			level: n(t.level, u + 1, d),
+			reward: a([t.reward], 1)[0]
+		});
+	}));
+};
+//#endregion
+export { l as defaultRewardResolver, s as defineProgression, u as resolveRewards, c as trackDeclaration };

package/dist/tutorial.d.ts

@@ -0,0 +1,157 @@
+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 captureTutorialEvidence: (input: unknown, at: number) => TutorialEvidence;
+
+export declare const captureTutorialState: (input: unknown, tutorial: Tutorial) => TutorialState;
+
+export declare const defaultTutorialStepPolicy: TutorialStepPolicy;
+
+export declare const defineTutorial: (input: TutorialDefinition | Tutorial) => Tutorial;
+
+export declare const initialTutorialState: (tutorial: Tutorial) => TutorialState;
+
+export declare interface PlayerTutorial extends TutorialState {
+    readonly nextStep: string | null;
+    readonly skippable: boolean;
+    readonly hints: string | null;
+}
+
+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;
+};
+
+export declare const resolveTutorialSkip: (tutorial: Tutorial, input: TutorialState, atInput: number) => TutorialState;
+
+export declare const resolveTutorialStep: (input: TutorialStepPolicyContext, policy?: TutorialStepPolicy) => TutorialState;
+
+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;
+}
+
+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 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;
+}
+
+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;
+}
+
+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 { }

package/dist/tutorial.js

@@ -0,0 +1,110 @@
+import { progressionError as e } from "./errors.js";
+import { identifier as t, integer as n, list as r, object as i } from "./capture.js";
+import { captureRewards as a } from "./reward.js";
+import { Context as o } from "effect";
+//#region src/tutorial.ts
+var s = (o) => {
+	let s = i(o, [
+		"id",
+		"version",
+		"steps",
+		"skippable",
+		"reward",
+		"rewardOnSkip",
+		"hints"
+	]), c = r(s.steps, 128).map(t);
+	if (!c.length || new Set(c).size !== c.length || s.skippable !== void 0 && typeof s.skippable != "boolean" || s.rewardOnSkip !== void 0 && typeof s.rewardOnSkip != "boolean") throw e("invalid_input");
+	return Object.freeze({
+		id: t(s.id ?? "tutorial"),
+		version: n(s.version ?? 1, 1, 1e6),
+		steps: Object.freeze(c),
+		skippable: s.skippable ?? !1,
+		reward: a(s.reward ?? [], 64),
+		rewardOnSkip: s.rewardOnSkip ?? !1,
+		hints: s.hints == null ? null : t(s.hints)
+	});
+}, c = (e) => Object.freeze({
+	tutorialId: e.id,
+	version: e.version,
+	completedSteps: Object.freeze([]),
+	completed: !1,
+	skipped: !1,
+	completedAt: null,
+	updatedAt: null
+}), l = (a, o) => {
+	let s = i(a, [
+		"tutorialId",
+		"version",
+		"completedSteps",
+		"completed",
+		"skipped",
+		"completedAt",
+		"updatedAt"
+	]), c = r(s.completedSteps, o.steps.length).map(t);
+	if (s.tutorialId !== o.id || s.version !== o.version || c.some((e, t) => e !== o.steps[t]) || typeof s.completed != "boolean" || typeof s.skipped != "boolean" || s.skipped && !o.skippable || s.completed !== (s.skipped || c.length === o.steps.length)) throw e("invalid_record");
+	let l = s.updatedAt === null ? null : n(s.updatedAt, 0, 864e13), u = s.completed ? n(s.completedAt, 0, l ?? -1) : null;
+	if (!s.completed && s.completedAt !== null || l === null && (c.length !== 0 || s.completed) || l !== null && c.length === 0 && !s.skipped) throw e("invalid_record");
+	return Object.freeze({
+		tutorialId: o.id,
+		version: o.version,
+		completedSteps: Object.freeze(c),
+		completed: s.completed,
+		skipped: s.skipped,
+		completedAt: u,
+		updatedAt: l
+	});
+}, u = (e, r) => {
+	let a = i(e, [
+		"source",
+		"originId",
+		"version",
+		"from",
+		"until"
+	]), o = n(a.from, 0, r), s = n(a.until, r + 1, 864e13);
+	return Object.freeze({
+		source: t(a.source),
+		originId: t(a.originId),
+		version: t(a.version),
+		from: o,
+		until: s
+	});
+}, d = class extends o.Service()("@voltro/TutorialVerifier") {}, f = ({ tutorial: e, before: t, step: n }) => !t.completed && e.steps[t.completedSteps.length] === n, p = (r, i = f) => {
+	let a = s(r.tutorial), o = l(r.before, a), c = n(r.at, o.updatedAt ?? 0, 864e13), d = t(r.step), p = u(r.evidence, c);
+	if (!f({
+		tutorial: a,
+		before: o,
+		step: d,
+		evidence: p,
+		at: c
+	})) throw e("conflict");
+	let m = i(Object.freeze({
+		tutorial: a,
+		before: o,
+		step: d,
+		evidence: p,
+		at: c
+	}));
+	if (typeof m != "boolean") throw e("invalid_input");
+	if (!m) throw e("forbidden");
+	let h = Object.freeze([...o.completedSteps, d]), g = h.length === a.steps.length;
+	return l({
+		...o,
+		completedSteps: h,
+		completed: g,
+		completedAt: g ? c : null,
+		updatedAt: c
+	}, a);
+}, m = (t, r, i) => {
+	let a = l(r, t), o = n(i, a.updatedAt ?? 0, 864e13);
+	if (!t.skippable) throw e("forbidden");
+	if (a.completed) throw e("conflict");
+	return l({
+		...a,
+		completed: !0,
+		skipped: !0,
+		completedAt: o,
+		updatedAt: o
+	}, t);
+}, h = class extends o.Service()("@voltro/TutorialPort") {};
+//#endregion
+export { h as TutorialPort, d as TutorialVerifier, u as captureTutorialEvidence, l as captureTutorialState, f as defaultTutorialStepPolicy, s as defineTutorial, c as initialTutorialState, m as resolveTutorialSkip, p as resolveTutorialStep };