@voltro/plugin-progression 0.0.0-stage → 0.88.0

package/dist/rankStore.js

@@ -0,0 +1,520 @@
+import { ProgressionError as e, progressionError as t } from "./errors.js";
+import { captureArguments as n, identifier as r, integer as i, list as a, object as o } from "./capture.js";
+import { captureRankClosureReceipt as s } from "./rankClosure.js";
+import { capturePlayerRank as c, captureRankRating as l, defineRankLadder as u, resolveRank as d, resolveRankSeasonReset as f, resolveRankStrategies as p } from "./ranks.js";
+import { acceptRankObservation as m, captureRankSeasonState as h, closeRankSeasonState as ee, defineRankSeason as g, initialRankSeasonState as _ } from "./rankSeasons.js";
+import { admitRewardDeliveryRecord as v } from "./rewardDeliveryRecord.js";
+import { questHash as y } from "./questStore.js";
+import { rankClosureUnitsTable as b, rankDefinitionsTable as x, rankLedgerTable as S, rankOperationsTable as C, rankRewardsTable as w, rankStatesTable as T, rankSubjectsTable as E } from "./rankTables.entity.js";
+import { Effect as D } from "effect";
+import { and as O, eq as k, queryFor as A } from "@voltro/database";
+// src/rankStore.ts
+var j = (e) => {
+	let n = o(e, [
+		"ladders",
+		"seasons",
+		"source",
+		"strategies",
+		"allowedServices",
+		"maxHistoryRows",
+		"maxPendingRewards",
+		"now"
+	]), s = Object.freeze(a(n.ladders, 64).map((e) => u(e))), c = o(n.source), l = n.now ?? Date.now, d = p(n.strategies), f = new Map(s.map((e) => [e.id, e])), m = Object.freeze(a(n.seasons, 256).map((e) => {
+		let n = o(e), i = f.get(r(n.ladderId));
+		if (!i) throw t("invalid_input");
+		return g(e, i);
+	})), h = Object.freeze(a(n.allowedServices ?? [], 256).map(r));
+	if (!s.length || !m.length || f.size !== s.length || new Set(m.map((e) => e.id)).size !== m.length || new Set(h).size !== h.length || typeof c.read != "function" || typeof l != "function") throw t("invalid_input");
+	return Object.freeze({
+		ladders: s,
+		seasons: m,
+		source: Object.freeze({ read: c.read.bind(n.source) }),
+		strategies: d,
+		allowedServices: h,
+		now: l,
+		maxHistoryRows: i(n.maxHistoryRows ?? 1e4, 1, 1e5),
+		maxPendingRewards: i(n.maxPendingRewards ?? 1e4, 1, 1e5)
+	});
+}, M = (e, ...t) => e + y(t).slice(0, 56), N = (e) => i(e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN, 0, 864e13), P = (n) => D.tryPromise({
+	try: n,
+	catch: (n) => n instanceof e ? n : t("unavailable")
+}), F = (a, u) => {
+	let p = j(u), g = new Map(p.ladders.map((e) => [e.id, e])), F = new Map(p.seasons.map((e) => [e.id, e])), I = new Set(p.allowedServices), L = (e) => {
+		let n = F.get(e);
+		if (!n) throw t("not_found");
+		return {
+			season: n,
+			ladder: g.get(n.ladderId)
+		};
+	}, R = (e) => {
+		if (e.type !== "system" && !(e.type === "service" && I.has(e.service))) throw t("forbidden");
+	}, z = (e) => {
+		if (e.type !== "user") throw t("forbidden");
+		return {
+			tenant: r(e.tenantId),
+			owner: r(e.id)
+		};
+	}, B = (e, t) => M("prs_", e, t), V = (e, t, n) => M("prv_", e, t, n.id, String(n.version)), H = (e, t) => O(k("tenantId", e), k("ownerKey", B(e, t))), U = (e) => {
+		let n = o(e, [
+			"seasonId",
+			"kind",
+			"requestId"
+		]);
+		if (n.kind !== "observe" && n.kind !== "close") throw t("invalid_record");
+		return L(r(n.seasonId)), Object.freeze({
+			seasonId: r(n.seasonId),
+			kind: n.kind,
+			requestId: r(n.requestId)
+		});
+	}, W = (e, t, n) => y({
+		tenant: e,
+		owner: t,
+		request: n
+	}), G = (e, t, n) => M("pro_", e, t, n.requestId), te = (e, t, n, r) => M("pri_", e, t, n.seasonId, n.kind, n.kind === "observe" ? y(r) : ""), ne = async (e, n) => {
+		if ((await a.insertIgnoreWithOutcome(e.tableName, n, { conflictColumns: ["id"] })).outcome !== "inserted" && !(await a.query(A(e).where(k("id", n.id)).limit(1).descriptor))[0]) throw t("unavailable");
+	}, K = (e, t) => ne(E, {
+		id: B(e, t),
+		tenantId: e,
+		ownerId: t,
+		erased: !1,
+		sequence: 0,
+		admission: 0
+	}), q = (e, n, r, a = !1) => {
+		if (e) {
+			if (e.id !== B(n, r) || e.tenantId !== n || typeof e.erased != "boolean") throw t("invalid_record");
+			if (e.erased) {
+				if (e.ownerId !== null) throw t("invalid_record");
+				if (!a) throw t("erased");
+			} else if (e.ownerId !== r) throw t("invalid_record");
+			i(e.sequence, 0, 2147483647);
+		}
+	}, re = async (e, n, r, i = !1) => {
+		if (await e.updateMany(E.tableName, { admission: 0 }, { where: k("id", B(n, r)) }) !== 1) throw t("invalid_record");
+		let a = (await e.query(A(E).where(k("id", B(n, r))).limit(1).descriptor))[0];
+		if (q(a, n, r, i), !a) throw t("invalid_record");
+		return a;
+	}, J = async (e, n, r, i) => {
+		let a = n === w ? p.maxPendingRewards : p.maxHistoryRows, o = await e.query(A(n).where(H(r, i)).limit(a + 1).descriptor);
+		if (o.length > a) throw t("limit_exceeded");
+		if (o.some((e) => e.tenantId !== r || e.ownerKey !== B(r, i))) throw t("invalid_record");
+		return o;
+	}, Y = (e, t) => M("prd_", e, t.id, String(t.version)), X = async (e, n, r, i = !1) => {
+		let a = Y(n, r);
+		if (i && await e.updateMany(x.tableName, { admission: 0 }, { where: k("id", a) }) !== 1) throw t("invalid_record");
+		let o = (await e.query(A(x).where(k("id", a)).limit(1).descriptor))[0];
+		if (!o || o.tenantId !== n || o.seasonId !== r.id || o.rulesVersion !== p.strategies.version || y(o.config) !== y({
+			season: r,
+			ladder: g.get(r.ladderId)
+		})) throw t("conflict");
+	}, Z = (e, n, i) => {
+		let { season: a, ladder: o } = L(r(e.seasonId)), s = h(e.state, a, o, p.strategies.version);
+		if (e.id !== V(n, i, a) || e.ownerId !== i || e.ownerKey !== B(n, i) || e.tenantId !== n || N(e.updatedAt) !== (s.closedAt ?? s.last?.observedAt)) throw t("invalid_record");
+		return s;
+	}, Q = (e) => {
+		let n = U(e.intent), { season: i, ladder: a } = L(n.seasonId), s = o(e.receipt, [
+			"operationId",
+			"kind",
+			"after",
+			"rewardsQueued",
+			"at"
+		]), c = h(s.after, i, a, p.strategies.version), l = N(e.at), u = n.kind === "close" && c.highest ? i.rewards[c.highest.tierIndex].length : 0;
+		if (r(e.claimKey), e.state !== "committed" || e.linkedOperationId !== null || s.operationId !== e.id || s.kind !== n.kind || s.at !== l || (n.kind === "close" ? c.closedAt !== l : c.last?.observedAt !== l || c.closedAt !== null) || s.rewardsQueued !== u) throw t("invalid_record");
+		return Object.freeze({
+			operationId: r(e.id),
+			kind: n.kind,
+			after: c,
+			rewardsQueued: u,
+			at: l
+		});
+	}, ie = async (e, n, r, i) => {
+		let a = (await e.query(A(C).where(k("id", G(n, r, i))).limit(1).descriptor))[0];
+		if (!a) return;
+		if (a.state === "erased") throw t("erased");
+		if (a.tenantId !== n || a.ownerKey !== B(n, r) || a.digest !== W(n, r, i) || y(U(a.intent)) !== y(i)) throw t("conflict");
+		if (await X(e, n, L(i.seasonId).season), a.state === "committed") return Q(a);
+		if (a.state !== "replayed" || a.receipt !== null || typeof a.linkedOperationId != "string") throw t("invalid_record");
+		let o = (await e.query(A(C).where(k("id", a.linkedOperationId)).limit(1).descriptor))[0], s = o ? U(o.intent) : void 0;
+		if (!o || o.tenantId !== n || o.ownerKey !== B(n, r) || s?.seasonId !== i.seasonId || s.kind !== i.kind || o.claimKey !== a.claimKey) throw t("invalid_record");
+		return Q(o);
+	}, ae = async (e, n, r, i) => {
+		let a = (await J(e, T, n, r)).filter((e) => e.seasonId === i.id), o = (await J(e, S, n, r)).filter((e) => e.seasonId === i.id).sort((e, t) => Number(e.sequence) - Number(t.sequence)).at(-1);
+		if (a.length > 1 || !!o != !!a.length) throw t("invalid_record");
+		let s = a[0] ? Z(a[0], n, r) : _(i);
+		if (o && y(o.after) !== y(s)) throw t("invalid_record");
+		return s;
+	}, $ = (c, u, h) => {
+		try {
+			let e = n(c), g = o(u, h === "observe" ? ["seasonId", "requestId"] : [
+				"tenantId",
+				"ownerId",
+				"seasonId",
+				"requestId"
+			]), { tenant: _, owner: v } = h === "observe" ? z(e) : (R(e), {
+				tenant: r(g.tenantId),
+				owner: r(g.ownerId)
+			}), O = U({
+				seasonId: g.seasonId,
+				requestId: g.requestId,
+				kind: h
+			}), { season: j, ladder: F } = L(O.seasonId);
+			return P(async () => {
+				let n = (await a.query(A(E).where(k("id", B(_, v))).limit(1).descriptor))[0];
+				q(n, _, v);
+				let r = await ie(a, _, v, O);
+				if (r) return r;
+				let o = null, c = null;
+				h === "observe" && (o = l(await D.runPromise(D.try({
+					try: () => p.source.read(e, F.rating),
+					catch: () => t("unavailable")
+				}).pipe(D.flatten)), F.rating));
+				let u = i(p.now(), 0, 864e13);
+				if (h === "observe") {
+					if (u < j.from || u >= j.until) throw t("conflict");
+					c = d({
+						ladder: F,
+						rating: o,
+						at: u
+					}, p.strategies);
+				} else if (u < j.until) throw t("conflict");
+				await K(_, v), await ne(x, {
+					id: Y(_, j),
+					tenantId: _,
+					seasonId: j.id,
+					config: {
+						season: j,
+						ladder: F
+					},
+					rulesVersion: p.strategies.version,
+					admission: 0
+				});
+				let g = null, P = null;
+				if (h === "close") {
+					let e = await ae(a, _, v, j);
+					P = y(e.last), e.last && (g = f(F, e.last.rawScore, p.strategies));
+				}
+				return a.transactional(async (e) => {
+					let n = await re(e, _, v);
+					await X(e, _, j, !0);
+					let r = await ie(e, _, v, O);
+					if (r) return r;
+					let a = await J(e, S, _, v), l = await J(e, C, _, v), d = await J(e, w, _, v), f = te(_, v, O, o), x = a.find((e) => e.claimKey === f);
+					if (l.length >= p.maxHistoryRows) throw t("limit_exceeded");
+					if (x) {
+						let n = l.find((e) => e.id === x.operationId);
+						if (!n) throw t("invalid_record");
+						let r = Q(n);
+						return await e.insert(C.tableName, {
+							id: G(_, v, O),
+							tenantId: _,
+							ownerKey: B(_, v),
+							state: "replayed",
+							claimKey: f,
+							linkedOperationId: r.operationId,
+							intent: O,
+							digest: W(_, v, O),
+							receipt: null,
+							at: new Date(u)
+						}), r;
+					}
+					if (a.length >= p.maxHistoryRows) throw t("limit_exceeded");
+					if (a.length !== n.sequence) throw t("invalid_record");
+					let D = await ae(e, _, v, j);
+					if (h === "close" && y(D.last) !== P) throw t("conflict");
+					let I = h === "observe" ? m(j, F, D, c, p.strategies.version) : ee(j, F, D, u, g, p.strategies.version), L = h === "close" && I.highest ? j.rewards[I.highest.tierIndex] : [], R = L.length;
+					if (d.length + R > p.maxPendingRewards) throw t("limit_exceeded");
+					let z = G(_, v, O), H = i(Number(n.sequence) + 1, 1, 2147483647), U = Object.freeze({
+						operationId: z,
+						kind: h,
+						after: I,
+						rewardsQueued: R,
+						at: u
+					}), ne = {
+						request: O,
+						rating: o,
+						rank: c,
+						resetScore: g
+					}, K = (await e.query(A(T).where(k("id", V(_, v, j))).limit(1).descriptor))[0], q = {
+						tenantId: _,
+						ownerId: v,
+						ownerKey: B(_, v),
+						seasonId: j.id,
+						state: I,
+						updatedAt: new Date(u)
+					};
+					if (K) {
+						if (!await e.update(T.tableName, String(K.id), q)) throw t("invalid_record");
+					} else await e.insert(T.tableName, {
+						id: V(_, v, j),
+						...q
+					});
+					let Y = V(_, v, j), Z = M("prc_", Y), $ = (await e.query(A(b).where(k("id", Z)).limit(1).descriptor))[0], oe = h === "close" ? s({
+						unitId: Z,
+						status: "closed",
+						operationId: z,
+						rewardsQueued: R,
+						at: u
+					}) : null;
+					if ($) {
+						if ($.tenantId !== _ || $.ownerId !== v || $.ownerKey !== B(_, v) || $.stateId !== Y || $.seasonId !== j.id || $.version !== j.version || N($.until) !== j.until || $.state !== "open" || $.receipt !== null || h === "close" && !await e.update(b.tableName, Z, {
+							state: "closed",
+							receipt: oe
+						})) throw t("invalid_record");
+					} else {
+						if (D.observations > 0) throw t("invalid_record");
+						await e.insert(b.tableName, {
+							id: Z,
+							tenantId: _,
+							ownerId: v,
+							ownerKey: B(_, v),
+							seasonId: j.id,
+							version: j.version,
+							stateId: Y,
+							until: new Date(j.until),
+							state: h === "close" ? "closed" : "open",
+							receipt: oe,
+							createdAt: new Date(u)
+						});
+					}
+					await e.insert(S.tableName, {
+						id: M("prl_", z),
+						tenantId: _,
+						ownerId: v,
+						ownerKey: B(_, v),
+						seasonId: j.id,
+						sequence: H,
+						operationId: z,
+						claimKey: f,
+						intent: ne,
+						before: D,
+						after: I,
+						at: new Date(u)
+					}), await e.insert(C.tableName, {
+						id: z,
+						tenantId: _,
+						ownerKey: B(_, v),
+						state: "committed",
+						claimKey: f,
+						linkedOperationId: null,
+						intent: O,
+						digest: W(_, v, O),
+						receipt: U,
+						at: new Date(u)
+					});
+					for (let [t, n] of L.entries()) await e.insert(w.tableName, {
+						id: M("prr_", z, String(t)),
+						tenantId: _,
+						ownerId: v,
+						ownerKey: B(_, v),
+						seasonId: j.id,
+						operationId: z,
+						reward: n,
+						state: "pending",
+						createdAt: new Date(u),
+						deliveredAt: null,
+						deliveryIntent: null,
+						deliveryDigest: null,
+						deliveryReceipt: null
+					});
+					if (!await e.update(E.tableName, B(_, v), { sequence: H })) throw t("invalid_record");
+					return U;
+				});
+			});
+		} catch (n) {
+			return D.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, oe = (n, i) => {
+		try {
+			let e = o(n, [
+				"tenantId",
+				"subjectId",
+				"kind"
+			]), s = r(e.tenantId), c = r(e.subjectId);
+			if (e.kind !== "user" && e.kind !== "guest") throw t("invalid_input");
+			return P(async () => (await K(s, c), a.transactional(async (e) => {
+				await re(e, s, c, !0);
+				let n = await J(e, T, s, c), r = await J(e, S, s, c), a = await J(e, C, s, c), o = await J(e, w, s, c), l = await J(e, b, s, c);
+				if (!i) return {
+					ranks: n.map((e) => e.state),
+					history: r.map((e) => ({
+						intent: e.intent,
+						before: e.before,
+						after: e.after
+					})),
+					requests: a.map((e) => ({
+						intent: e.intent,
+						receipt: e.receipt
+					})),
+					rewards: o.map((e) => ({
+						reward: e.reward,
+						state: e.state,
+						deliveryIntent: e.deliveryIntent,
+						deliveryReceipt: e.deliveryReceipt
+					})),
+					closure: l.map((e) => ({
+						seasonId: e.seasonId,
+						state: e.state,
+						receipt: e.receipt
+					}))
+				};
+				if (await e.deleteMany(T.tableName, { where: H(s, c) }), await e.updateMany(S.tableName, {
+					ownerId: null,
+					ownerKey: null,
+					intent: null,
+					before: null,
+					after: null
+				}, { where: H(s, c) }), await e.updateMany(C.tableName, {
+					ownerKey: null,
+					state: "erased",
+					linkedOperationId: null,
+					intent: null,
+					digest: null,
+					receipt: null
+				}, { where: H(s, c) }), await e.updateMany(w.tableName, {
+					ownerId: null,
+					ownerKey: null,
+					reward: null,
+					state: "erased",
+					deliveredAt: null,
+					deliveryIntent: null,
+					deliveryDigest: null,
+					deliveryReceipt: null
+				}, { where: H(s, c) }), await e.updateMany(b.tableName, {
+					ownerId: null,
+					ownerKey: null,
+					state: "erased",
+					receipt: null
+				}, { where: H(s, c) }), !await e.update(E.tableName, B(s, c), {
+					erased: !0,
+					ownerId: null
+				})) throw t("invalid_record");
+			})));
+		} catch (n) {
+			return D.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, se = (i, u, d, f) => {
+		try {
+			R(n(i));
+			let e = r(u), h = r(d);
+			return P(async () => (await K(e, h), a.transactional(async (n) => {
+				let i = await re(n, e, h), a = [...await J(n, S, e, h)].sort((e, t) => Number(e.sequence) - Number(t.sequence)), u = await J(n, C, e, h), d = await J(n, w, e, h), g = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Set(), E = 0;
+				if (a.length !== i.sequence) throw t("invalid_record");
+				for (let [i, s] of a.entries()) {
+					let a = o(s.intent, [
+						"request",
+						"rating",
+						"rank",
+						"resetScore"
+					]), f = U(a.request), { season: b, ladder: S } = L(f.seasonId), C = g.get(b.id) ?? _(b), w = u.find((e) => e.id === s.operationId), T = N(s.at);
+					await X(n, e, b);
+					let D = f.kind === "observe" ? l(a.rating, S.rating) : null, O = f.kind === "observe" ? c(a.rank, S, p.strategies.version) : null;
+					if (f.kind === "close" && (a.rating !== null || a.rank !== null) || f.kind === "observe" && (a.resetScore !== null || O.games !== D.games || O.ratingUpdatedAt !== D.updatedAt || O.observedAt !== T)) throw t("invalid_record");
+					let k = te(e, h, f, D);
+					if (s.sequence !== i + 1 || s.id !== M("prl_", r(s.operationId)) || s.operationId !== G(e, h, f) || s.seasonId !== b.id || s.ownerId !== h || s.claimKey !== k || w?.claimKey !== k || x.has(k) || y(s.before) !== y(C) || !w || w.digest !== W(e, h, f) || y(U(w.intent)) !== y(f)) throw t("invalid_record");
+					let A = f.kind === "observe" ? m(b, S, C, O, p.strategies.version) : ee(b, S, C, T, a.resetScore, p.strategies.version), j = Q(w);
+					if (y(A) !== y(s.after) || y(A) !== y(j.after) || j.at !== T) throw t("invalid_record");
+					let P = f.kind === "close" && A.highest ? b.rewards[A.highest.tierIndex] : [];
+					for (let [e, n] of P.entries()) {
+						let r = d.find((t) => t.id === M("prr_", j.operationId, String(e)));
+						if (!r || r.ownerId !== h || r.seasonId !== b.id || r.operationId !== j.operationId || r.state !== "pending" && r.state !== "delivered" || N(r.createdAt) !== T || y(r.reward) !== y(n)) throw t("invalid_record");
+					}
+					for (let e of d.filter((e) => e.operationId === j.operationId)) v(e, "rank", y);
+					E += P.length, g.set(b.id, A), x.add(k);
+				}
+				if (d.length !== E || u.filter((e) => e.state === "committed").length !== a.length) throw t("invalid_record");
+				for (let n of u) {
+					let r = U(n.intent);
+					if (n.id !== G(e, h, r) || n.digest !== W(e, h, r)) throw t("invalid_record");
+					if (n.state === "committed") {
+						Q(n);
+						continue;
+					}
+					if (n.state !== "replayed" || n.receipt !== null || typeof n.linkedOperationId != "string") throw t("invalid_record");
+					let i = u.find((e) => e.id === n.linkedOperationId), a = i ? U(i.intent) : void 0;
+					if (!i || a?.seasonId !== r.seasonId || a.kind !== r.kind || i.claimKey !== n.claimKey) throw t("invalid_record");
+					Q(i);
+				}
+				let D = await J(n, T, e, h), O = await J(n, b, e, h), k = D.length === g.size && O.length === g.size;
+				for (let t of D) {
+					let n = Z(t, e, h), r = g.get(n.seasonId);
+					r && y(r) === y(n) || (k = !1);
+				}
+				let A = [...g.values()].map((t) => {
+					let { season: n } = L(t.seasonId), r = V(e, h, n), i = M("prc_", r), c = a.find((e) => e.seasonId === n.id), l = t.closedAt === null ? void 0 : a.find((e) => e.seasonId === n.id && o(o(e.intent).request).kind === "close"), d = l ? Q(u.find((e) => e.id === l.operationId)) : null;
+					return {
+						id: i,
+						tenantId: e,
+						ownerId: h,
+						ownerKey: B(e, h),
+						seasonId: n.id,
+						version: n.version,
+						stateId: r,
+						until: new Date(n.until),
+						state: t.closedAt === null ? "open" : "closed",
+						receipt: d ? s({
+							unitId: i,
+							status: "closed",
+							operationId: d.operationId,
+							rewardsQueued: d.rewardsQueued,
+							at: d.at
+						}) : null,
+						createdAt: new Date(N(c.at))
+					};
+				});
+				for (let e of O) {
+					let t = A.find((t) => t.id === e.id);
+					t && e.ownerId === h && e.stateId === t.stateId && e.seasonId === t.seasonId && e.version === t.version && e.state === t.state && N(e.until) === t.until.getTime() && N(e.createdAt) === t.createdAt.getTime() && y(e.receipt) === y(t.receipt) || (k = !1);
+				}
+				if (f) {
+					await n.deleteMany(T.tableName, { where: H(e, h) });
+					for (let t of g.values()) {
+						let { season: r } = L(t.seasonId);
+						await n.insert(T.tableName, {
+							id: V(e, h, r),
+							tenantId: e,
+							ownerId: h,
+							ownerKey: B(e, h),
+							seasonId: r.id,
+							state: t,
+							updatedAt: new Date(t.closedAt ?? t.last.observedAt)
+						});
+					}
+					await n.deleteMany(b.tableName, { where: H(e, h) });
+					for (let e of A) await n.insert(b.tableName, e);
+					k = !0;
+				}
+				return {
+					operations: a.length,
+					seasons: g.size,
+					rewardRows: d.length,
+					matches: k
+				};
+			})));
+		} catch (n) {
+			return D.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	};
+	return Object.freeze({
+		observe: (e, t) => $(e, t, "observe"),
+		close: (e, t) => $(e, t, "close"),
+		mine: (i) => {
+			try {
+				let { tenant: e, owner: o } = z(n(i));
+				return P(async () => {
+					let n = (await a.query(A(E).where(k("id", B(e, o))).limit(1).descriptor))[0];
+					q(n, e, o);
+					let i = await J(a, T, e, o);
+					if (!n && i.length) throw t("invalid_record");
+					for (let t of i) await X(a, e, L(r(t.seasonId)).season);
+					return Object.freeze(i.map((t) => Z(t, e, o)));
+				});
+			} catch (n) {
+				return D.fail(n instanceof e ? n : t("invalid_input"));
+			}
+		},
+		exportSubject: (e) => oe(e, !1),
+		eraseSubject: (e) => D.asVoid(oe(e, !0)),
+		auditRanks: (e, t, n) => se(e, t, n, !1),
+		rebuildRanks: (e, t, n) => se(e, t, n, !0)
+	});
+};
+export { F as dataStoreRankSeasons, j as resolveRankStoreOptions };

package/dist/rankSystem.fixture.js

@@ -0,0 +1,169 @@
+import { RankRatingSource as e, defaultRankDecay as t, defaultRankGrade as n, defaultRankScore as r, defaultRankSeasonReset as i, resolveRank as a, resolveRankSeasonReset as o } from "./ranks.js";
+import { RankPort as s } from "./rankSeasons.js";
+import { trackDeclaration as c } from "./track.js";
+import { progressionPlugin as l } from "./plugin.js";
+import { progressionFixture as u, rankSeasonPolicyFixture as d } from "./declarationFixtures.js";
+import { Effect as f, Layer as p } from "effect";
+import { ensureTableRegistered as m } from "@voltro/database";
+import { InMemoryDataStore as h } from "@voltro/runtime";
+// src/rankSystem.fixture.ts
+var g = u(), { ladder: _, rating: v, at: y, season: b } = d(), x = Object.freeze({ read: () => f.succeed(v) }), S = {
+	app: {
+		name: "rank-port-fixture",
+		type: "api",
+		voltroVersion: "0.83.1"
+	},
+	config: {},
+	env: {},
+	logger: {
+		info() {},
+		warn() {},
+		error() {},
+		debug() {}
+	}
+}, C = p.effectContext(f.acquireRelease(f.sync(() => l({
+	tracks: [c(g.track)],
+	stats: [{ id: "wins" }],
+	statSources: ["match.finished"],
+	now: () => y,
+	ranks: {
+		ladders: [_],
+		seasons: [b],
+		source: x,
+		now: () => y
+	}
+})), (e) => f.suspend(() => e.onDeactivate(S))).pipe(f.tap((e) => f.gen(function* () {
+	e.extendSchema.tables.forEach((e) => m(e)), yield* f.promise(() => Promise.resolve(e.bindDataStore(new h())));
+}).pipe(f.orDie)), f.flatMap((e) => p.build(e.services)))), w = p.succeed(e, x), T = {
+	type: "user",
+	id: "a",
+	tenantId: "fixture",
+	kind: "guest"
+}, E = Object.freeze({
+	kind: "port",
+	tag: s,
+	fakeLayer: C,
+	probe: {
+		run: () => f.scoped(f.gen(function* () {
+			let e = yield* s, t = {
+				seasonId: b.id,
+				requestId: "fixture.observe"
+			}, n = yield* e.observe(T, t), r = yield* e.observe(T, t);
+			return {
+				original: n.operationId === r.operationId,
+				highest: n.after.highest?.tier ?? null,
+				seasons: (yield* e.mine(T)).length
+			};
+		}).pipe(f.provide(C))),
+		expected: {
+			original: !0,
+			highest: "Gold",
+			seasons: 1
+		}
+	}
+}), D = Object.freeze({
+	kind: "port",
+	tag: e,
+	fakeLayer: w,
+	probe: {
+		run: () => f.scoped(f.gen(function* () {
+			let t = yield* (yield* e).read(T, _.rating);
+			return {
+				games: t.games,
+				updatedAt: t.updatedAt
+			};
+		}).pipe(f.provide(w))),
+		expected: {
+			games: 10,
+			updatedAt: 1e3
+		}
+	}
+}), O = Object.freeze({
+	ladder: _,
+	rating: v,
+	at: y
+}), k = Object.freeze({
+	ladder: _,
+	rating: v,
+	at: y + 2592e6
+}), A = Object.freeze({
+	kind: "slot",
+	defaultImplementation: r,
+	defaultProbe: {
+		run: () => f.sync(() => a(O).rawScore),
+		expected: 250
+	},
+	overrideProbe: {
+		run: () => f.sync(() => a(O, {
+			version: "fixture.v2",
+			score: () => 120
+		}).rawScore),
+		expected: 120
+	}
+}), j = Object.freeze({
+	kind: "slot",
+	defaultImplementation: t,
+	defaultProbe: {
+		run: () => f.sync(() => a(k).score),
+		expected: 10
+	},
+	overrideProbe: {
+		run: () => f.sync(() => a(k, {
+			version: "fixture.v2",
+			decay: (e) => e.score
+		}).score),
+		expected: 250
+	}
+}), M = Object.freeze({
+	kind: "slot",
+	defaultImplementation: n,
+	defaultProbe: {
+		run: () => f.sync(() => {
+			let e = a(O).grade;
+			return e && {
+				tier: e.tier,
+				division: e.division
+			};
+		}),
+		expected: {
+			tier: "Gold",
+			division: 2
+		}
+	},
+	overrideProbe: {
+		run: () => f.sync(() => {
+			let e = a(O, {
+				version: "fixture.v2",
+				grade: () => ({
+					index: 0,
+					tier: "Bronze",
+					tierIndex: 0,
+					division: 2
+				})
+			}).grade;
+			return e && {
+				tier: e.tier,
+				division: e.division
+			};
+		}),
+		expected: {
+			tier: "Bronze",
+			division: 2
+		}
+	}
+}), N = Object.freeze({
+	kind: "slot",
+	defaultImplementation: i,
+	defaultProbe: {
+		run: () => f.sync(() => o(_, 250)),
+		expected: 175
+	},
+	overrideProbe: {
+		run: () => f.sync(() => o(_, 250, {
+			version: "fixture.v2",
+			seasonReset: () => 0
+		})),
+		expected: 0
+	}
+});
+export { j as rankDecaySystemFixture, C as rankFakeLayer, M as rankGradeSystemFixture, E as rankPortSystemFixture, w as rankRatingSourceFakeLayer, D as rankRatingSourceSystemFixture, A as rankScoreSystemFixture, N as rankSeasonResetSystemFixture };