@voltro/plugin-progression 0.0.0-stage → 0.87.0

package/dist/progressionStore.js

@@ -0,0 +1,706 @@
+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, progressValue as s } from "./capture.js";
+import { captureRewards as c } from "./reward.js";
+import { defaultXpCurve as l, resolveXpCurve as u } from "./curve.js";
+import { ProgressionReceiptSchema as d } from "./rpc.js";
+import { admitRewardDeliveryRecord as f } from "./rewardDeliveryRecord.js";
+import { STAT_OPERATORS as p, applyStatValue as m, defineStat as h } from "./stats.js";
+import { defaultRewardResolver as g, defineProgression as _, resolveRewards as v } from "./track.js";
+import { progressionDefinitionsTable as y, progressionOperationsTable as b, progressionOriginsTable as x, progressionRewardsTable as S, progressionStatLedgerTable as C, progressionStatsTable as w, progressionSubjectsTable as T, progressionTracksTable as E, progressionXpLedgerTable as D } from "./tables.entity.js";
+import { Effect as O, Schema as k } from "effect";
+import { createHash as A } from "node:crypto";
+import { and as j, eq as M, queryFor as N } from "@voltro/database";
+//#region src/progressionStore.ts
+var P = (e) => {
+	let n = o(e, [
+		"tracks",
+		"stats",
+		"statSources",
+		"allowedServices",
+		"maxHistoryRows",
+		"maxPendingRewards",
+		"now",
+		"strategies"
+	]), s = Object.freeze(a(n.tracks, 128).map((e) => _(e))), c = Object.freeze(a(n.stats ?? [], 256).map((e) => h(e))), u = Object.freeze(a(n.statSources ?? [], 64).map(r)), d = Object.freeze(a(n.allowedServices ?? [], 256).map(r));
+	if (new Set(s.map((e) => e.id)).size !== s.length || new Set(c.map((e) => e.id)).size !== c.length || new Set(u).size !== u.length || new Set(d).size !== d.length || c.length > 0 && u.length === 0) throw t("invalid_input");
+	let f = o(n.strategies ?? {}, [
+		"xpCurve",
+		"rewardResolver",
+		"version"
+	]), p = f.xpCurve ?? l, m = f.rewardResolver ?? g, v = n.now ?? Date.now;
+	if (typeof p != "function" || typeof m != "function" || typeof v != "function" || (p !== l || m !== g) && f.version === void 0) throw t("invalid_input");
+	return Object.freeze({
+		tracks: s,
+		stats: c,
+		statSources: u,
+		allowedServices: d,
+		maxHistoryRows: i(n.maxHistoryRows ?? 1e4, 1, 1e5),
+		maxPendingRewards: i(n.maxPendingRewards ?? 4096, 1, 1e4),
+		now: v,
+		strategies: Object.freeze({
+			xpCurve: p,
+			rewardResolver: m,
+			version: r(f.version ?? "default.v1")
+		})
+	});
+}, F = (e) => {
+	if (e === null || typeof e == "boolean" || typeof e == "string" || typeof e == "number" && Number.isFinite(e)) return e;
+	if (Array.isArray(e)) return a(e, 1e5).map(F);
+	let t = o(e);
+	return Object.fromEntries(Object.keys(t).sort().map((e) => [e, F(t[e])]));
+}, I = (e) => A("sha256").update(JSON.stringify(F(e))).digest("hex"), L = (e, ...t) => e + I(t).slice(0, 56), R = (n) => O.tryPromise({
+	try: n,
+	catch: (n) => n instanceof e ? n : t("unavailable")
+}), z = (e) => {
+	let n = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+	if (!Number.isSafeInteger(n) || n < 0 || n > 864e13) throw t("invalid_record");
+	return n;
+}, B = (a, l) => {
+	let h = P(l), g = new Set(h.allowedServices), _ = new Map(h.tracks.map((e) => [e.id, e])), A = new Map(h.stats.map((e) => [e.id, e])), F = (e) => e.type === "system" || e.type === "service" && g.has(e.service), B = (e) => {
+		if (e.type !== "user") throw t("forbidden");
+		return {
+			tenantId: r(e.tenantId),
+			ownerId: r(e.id)
+		};
+	}, V = () => i(h.now(), 0, 864e13), H = (e, t) => L("pgs_", e, t), U = (e, n, r, i = !1) => {
+		if (e) {
+			if (e.tenantId !== n) throw t("invalid_record");
+			if (e.erased === !0) {
+				if (i && e.ownerId === null) return;
+				throw t("erased");
+			}
+			if (e.erased !== !1 || e.ownerId !== r) throw t("invalid_record");
+		}
+	}, W = async (e, t) => {
+		try {
+			await a.insertIgnore(e, t, { conflictColumns: ["id"] });
+		} catch (n) {
+			if (!(await a.query({
+				table: e,
+				predicate: M("id", t.id),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			}))[0]) throw n;
+		}
+	}, G = (e, t) => W(T.tableName, {
+		id: H(e, t),
+		tenantId: e,
+		ownerId: t,
+		erased: !1,
+		sequence: 0,
+		admission: 0
+	}), ee = async (e, n, r, i = !1) => {
+		let a = H(n, r);
+		if (await e.updateMany(T.tableName, { admission: 0 }, { where: M("id", a) }) !== 1) throw t("unavailable");
+		let o = (await e.query(N(T).where(M("id", a)).limit(1).descriptor))[0];
+		if (!o) throw t("invalid_record");
+		return U(o, n, r, i), o;
+	}, K = (e, t) => j(M("tenantId", e), M("ownerId", t)), q = async (e, n, r, i, a = h.maxHistoryRows) => {
+		let o = await e.query(N(n).where(K(r, i)).orderBy("id", "asc").limit(a + 1).descriptor);
+		if (o.length > a) throw t("limit_exceeded");
+		if (o.some((e) => e.tenantId !== r || e.ownerId !== i)) throw t("invalid_record");
+		return o;
+	}, J = (e) => {
+		let n = k.decodeUnknownSync(d, { onExcessProperty: "error" })(e.receipt);
+		if (n.operationId !== e.id || z(e.createdAt) > n.at || n.at > 864e13 || !Number.isSafeInteger(n.at)) throw t("invalid_record");
+		i(n.rewardsQueued, 0, 256);
+		let a = n.change;
+		if (a.kind === "xp") {
+			if (r(a.trackId), s(a.xp), s(a.delta) === 0n) throw t("invalid_record");
+			i(a.fromLevel, 1, 1e4), i(a.toLevel, a.fromLevel, 1e4);
+		} else if (r(a.stat), s(a.value), a.period === "season") r(a.seasonId);
+		else if (a.seasonId !== null) throw t("invalid_record");
+		return Object.freeze({
+			...n,
+			change: Object.freeze({ ...a })
+		});
+	}, te = (e, t) => e === "xp" ? {
+		track: _.get(t),
+		rules: h.strategies.version
+	} : {
+		stat: A.get(t),
+		sources: h.statSources
+	}, Y = (e, n) => {
+		let { tenantId: o, ownerId: c, requestId: l, kind: d, id: f, source: p, origin: g, payload: O } = n, k = H(o, c), P = L("pgo_", o, c, l), F = I({
+			tenantId: o,
+			ownerId: c,
+			kind: d,
+			id: f,
+			source: p,
+			origin: g,
+			payload: O
+		}), B = L("pgn_", o, c, d, f, p, g), U = te(d, f), K = L("pgd_", o, d, f);
+		return R(async () => {
+			let n = V();
+			return await G(o, c), await W(y.tableName, {
+				id: K,
+				tenantId: o,
+				kind: d === "xp" ? "track" : "stat",
+				definitionId: f,
+				config: U,
+				admission: 0
+			}), a.transactional(async (a) => {
+				let l = await ee(a, o, c);
+				if (!(await a.query(N(b).where(M("id", P)).limit(1).descriptor))[0]) {
+					if ((await a.query(N(b).where(j(M("tenantId", o), M("ownerKey", k))).limit(h.maxHistoryRows + 1).descriptor)).length >= h.maxHistoryRows) throw t("limit_exceeded");
+					await a.insert(b.tableName, {
+						id: P,
+						tenantId: o,
+						ownerKey: k,
+						state: "pending",
+						sequence: null,
+						linkedOperationId: null,
+						digest: null,
+						receipt: null,
+						createdAt: new Date(n),
+						admission: 0
+					});
+				}
+				if (await a.updateMany(b.tableName, { admission: 0 }, { where: M("id", P) }) !== 1) throw t("unavailable");
+				let R = (await a.query(N(b).where(M("id", P)).limit(1).descriptor))[0];
+				if (!R || R.tenantId !== o || R.ownerKey !== k) throw t("invalid_record");
+				if (R.state === "committed" || R.state === "replayed") {
+					if (R.digest !== F) throw t("conflict");
+					if (R.state === "committed") return J(R);
+					let e = (await a.query(N(b).where(M("id", r(R.linkedOperationId))).limit(1).descriptor))[0];
+					if (!e || e.tenantId !== o || e.ownerKey !== k || e.state !== "committed" || e.digest !== F) throw t("invalid_record");
+					return J(e);
+				}
+				if (R.state !== "pending" || R.sequence !== null || R.linkedOperationId !== null || R.digest !== null || R.receipt !== null || z(R.createdAt) > n) throw t("invalid_record");
+				if ((await a.query(N(b).where(j(M("tenantId", o), M("ownerKey", k))).limit(h.maxHistoryRows + 1).descriptor)).length > h.maxHistoryRows) throw t("limit_exceeded");
+				let V = (await a.query(N(x).where(M("id", B)).limit(1).descriptor))[0];
+				if (V) {
+					if (V.tenantId !== o || V.ownerKey !== k || V.source !== p || V.origin !== g || V.digest !== F) throw t("conflict");
+					let e = (await a.query(N(b).where(M("id", r(V.operationId))).limit(1).descriptor))[0];
+					if (!e || e.tenantId !== o || e.ownerKey !== k || e.state !== "committed" || e.digest !== F) throw t("invalid_record");
+					let n = J(e);
+					return await a.update(b.tableName, P, {
+						state: "replayed",
+						linkedOperationId: e.id,
+						digest: F
+					}), n;
+				}
+				if (await a.updateMany(y.tableName, { admission: 0 }, { where: M("id", K) }) !== 1) throw t("unavailable");
+				let H = (await a.query(N(y).where(M("id", K)).limit(1).descriptor))[0];
+				if (!H || H.tenantId !== o || H.definitionId !== f || H.kind !== (d === "xp" ? "track" : "stat") || I(H.config) !== I(U)) throw t("conflict");
+				let W = i(l.sequence, 0, 2147483646) + 1, G;
+				if (d === "xp") {
+					let i = _.get(f);
+					if (!i) throw t("invalid_track");
+					let l = L("pgt_", o, c, f), d = (await a.query(N(E).where(M("id", l)).limit(1).descriptor))[0];
+					if (d && (d.tenantId !== o || d.ownerId !== c || d.trackId !== f || d.version !== i.version || z(d.updatedAt) > n || d.prestige !== 0)) throw t("invalid_record");
+					let m = String(s(d?.xp ?? "0")), y = u(m, i.xpCurve, h.strategies.xpCurve);
+					if (d && d.level !== y) throw t("conflict");
+					let b = s(O.amount), x = String(s(BigInt(m) + b)), C = u(x, i.xpCurve, h.strategies.xpCurve);
+					if (C < y) throw t("conflict");
+					let w = v({
+						track: i,
+						fromLevel: y,
+						toLevel: C
+					}, h.strategies.rewardResolver), T = await a.query(N(S).where(j(M("tenantId", o), M("ownerKey", k))).limit(h.maxHistoryRows + 1).descriptor);
+					if (T.length + w.length > h.maxHistoryRows || T.filter((e) => e.state === "pending").length + w.length > h.maxPendingRewards || (await q(a, D, o, c)).length >= h.maxHistoryRows) throw t("limit_exceeded");
+					d ? await a.update(E.tableName, l, {
+						xp: x,
+						level: C,
+						updatedAt: new Date(n)
+					}) : await a.insert(E.tableName, {
+						id: l,
+						tenantId: o,
+						ownerId: c,
+						trackId: f,
+						version: i.version,
+						xp: x,
+						level: C,
+						prestige: 0,
+						updatedAt: new Date(n),
+						metadata: {}
+					}), await a.insert(D.tableName, {
+						id: L("pgx_", P),
+						tenantId: o,
+						ownerId: c,
+						ownerKey: k,
+						operationId: P,
+						sequence: W,
+						trackId: f,
+						delta: String(b),
+						afterXp: x,
+						fromLevel: y,
+						toLevel: C,
+						source: p,
+						origin: g,
+						actor: r(e.id),
+						at: new Date(n)
+					});
+					for (let [e, t] of w.entries()) await a.insert(S.tableName, {
+						id: L("pgr_", P, String(e)),
+						tenantId: o,
+						ownerId: c,
+						ownerKey: k,
+						operationId: P,
+						level: t.level,
+						reward: t.reward,
+						state: "pending",
+						createdAt: new Date(n),
+						deliveredAt: null,
+						deliveryIntent: null,
+						deliveryDigest: null,
+						deliveryReceipt: null
+					});
+					G = Object.freeze({
+						operationId: P,
+						at: n,
+						change: Object.freeze({
+							kind: "xp",
+							trackId: f,
+							xp: x,
+							delta: String(b),
+							fromLevel: y,
+							toLevel: C
+						}),
+						rewardsQueued: w.length
+					});
+				} else {
+					let i = A.get(f);
+					if (!i) throw t("invalid_stat");
+					let l = O.period, u = O.seasonId, d = O.operator, _ = O.operand, v = L("pgv_", o, c, f, l, u ?? ""), y = (await a.query(N(w).where(M("id", v)).limit(1).descriptor))[0];
+					if (y && (y.tenantId !== o || y.ownerId !== c || y.stat !== f || y.period !== l || y.seasonId !== u || z(y.updatedAt) > n)) throw t("invalid_record");
+					let b = y ? String(s(y.value)) : null, x = m(b, _, d, i);
+					if ((await q(a, C, o, c)).length >= h.maxHistoryRows) throw t("limit_exceeded");
+					y ? await a.update(w.tableName, v, {
+						value: x,
+						updatedAt: new Date(n)
+					}) : await a.insert(w.tableName, {
+						id: v,
+						tenantId: o,
+						ownerId: c,
+						stat: f,
+						period: l,
+						seasonId: u,
+						value: x,
+						updatedAt: new Date(n)
+					}), await a.insert(C.tableName, {
+						id: L("pgl_", P),
+						tenantId: o,
+						ownerId: c,
+						ownerKey: k,
+						operationId: P,
+						sequence: W,
+						stat: f,
+						period: l,
+						seasonId: u,
+						operator: d,
+						operand: _,
+						beforeValue: b,
+						afterValue: x,
+						source: p,
+						origin: g,
+						actor: r(e.id),
+						at: new Date(n)
+					}), G = Object.freeze({
+						operationId: P,
+						at: n,
+						change: Object.freeze({
+							kind: "stat",
+							stat: f,
+							period: l,
+							seasonId: u,
+							value: x,
+							operator: d
+						}),
+						rewardsQueued: 0
+					});
+				}
+				return await a.insert(x.tableName, {
+					id: B,
+					tenantId: o,
+					ownerKey: k,
+					operationId: P,
+					source: p,
+					origin: g,
+					digest: F
+				}), await a.update(b.tableName, P, {
+					state: "committed",
+					sequence: W,
+					digest: F,
+					receipt: G
+				}), await a.update(T.tableName, k, { sequence: W }), G;
+			});
+		});
+	}, X = (n) => {
+		try {
+			return n();
+		} catch (n) {
+			return O.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, ne = (e, n) => X(() => {
+		let i = structuredClone(e), a = o(n, [
+			"tenantId",
+			"ownerId",
+			"trackId",
+			"amount",
+			"requestId",
+			"source",
+			"origin"
+		]);
+		if (!F(i)) throw t("forbidden");
+		let c = r(a.trackId), l = _.get(c), u = r(a.source), d = s(a.amount);
+		if (!l || !l.sources.includes(u)) throw t("invalid_track");
+		if (d === 0n) throw t("invalid_input");
+		return Y(i, {
+			tenantId: r(a.tenantId),
+			ownerId: r(a.ownerId),
+			requestId: r(a.requestId),
+			kind: "xp",
+			id: c,
+			source: u,
+			origin: r(a.origin),
+			payload: Object.freeze({ amount: String(d) })
+		});
+	}), re = (e, n) => X(() => {
+		let i = structuredClone(e), a = o(n, [
+			"tenantId",
+			"ownerId",
+			"stat",
+			"period",
+			"seasonId",
+			"operator",
+			"operand",
+			"requestId",
+			"source",
+			"origin"
+		]);
+		if (!F(i)) throw t("forbidden");
+		let c = r(a.stat), l = r(a.source);
+		if (!A.has(c) || !h.statSources.includes(l) || !p.some((e) => e === a.operator)) throw t("invalid_stat");
+		if (a.period !== "lifetime" && a.period !== "season") throw t("invalid_input");
+		let u = a.period === "season" ? r(a.seasonId) : null;
+		if (a.period === "lifetime" && a.seasonId !== void 0 && a.seasonId !== null) throw t("invalid_input");
+		return Y(i, {
+			tenantId: r(a.tenantId),
+			ownerId: r(a.ownerId),
+			requestId: r(a.requestId),
+			kind: "stat",
+			id: c,
+			source: l,
+			origin: r(a.origin),
+			payload: Object.freeze({
+				period: a.period,
+				seasonId: u,
+				operator: a.operator,
+				operand: String(s(a.operand))
+			})
+		});
+	}), ie = (e, n) => {
+		if (e.trackId !== n.id || e.version !== n.version || e.prestige !== 0) throw t("conflict");
+		let r = String(s(e.xp)), i = u(r, n.xpCurve, h.strategies.xpCurve);
+		if (e.level !== i) throw t("invalid_record");
+		return Object.freeze({
+			trackId: n.id,
+			xp: r,
+			level: i,
+			prestige: 0,
+			updatedAt: z(e.updatedAt)
+		});
+	}, ae = (e, n) => {
+		if (e.stat !== n.id || e.period !== "lifetime" && e.period !== "season" || e.period === "lifetime" && e.seasonId !== null) throw t("invalid_record");
+		let i = String(s(e.value));
+		if (BigInt(i) > BigInt(n.cap)) throw t("conflict");
+		return Object.freeze({
+			stat: n.id,
+			period: e.period,
+			seasonId: e.period === "season" ? r(e.seasonId) : null,
+			value: i,
+			updatedAt: z(e.updatedAt)
+		});
+	}, Z = (e) => X(() => {
+		let n = structuredClone(e), { tenantId: i, ownerId: o } = B(n);
+		return R(async () => {
+			U((await a.query(N(T).where(M("id", H(i, o))).limit(1).descriptor))[0], i, o);
+			let e = await q(a, E, i, o, 128);
+			if (new Set(e.map((e) => e.trackId)).size !== e.length || e.some((e) => !_.has(String(e.trackId)) || e.id !== L("pgt_", i, o, r(e.trackId)))) throw t("invalid_track");
+			return Object.freeze(h.tracks.map((t) => {
+				let n = e.find((e) => e.trackId === t.id);
+				return n ? ie(n, t) : Object.freeze({
+					trackId: t.id,
+					xp: "0",
+					level: u("0", t.xpCurve, h.strategies.xpCurve),
+					prestige: 0,
+					updatedAt: null
+				});
+			}));
+		});
+	}), Q = (e) => X(() => {
+		let n = structuredClone(e), { tenantId: r, ownerId: i } = B(n);
+		return R(async () => {
+			U((await a.query(N(T).where(M("id", H(r, i))).limit(1).descriptor))[0], r, i);
+			let e = /* @__PURE__ */ new Set();
+			return Object.freeze((await q(a, w, r, i)).map((n) => {
+				let a = A.get(String(n.stat));
+				if (!a) throw t("invalid_stat");
+				let o = ae(n, a), s = L("pgv_", r, i, o.stat, o.period, o.seasonId ?? "");
+				if (n.id !== s || e.has(s)) throw t("invalid_record");
+				return e.add(s), o;
+			}));
+		});
+	}), $ = (e, o, l, d, g) => X(() => {
+		let v = n(e), O = r(o), k = r(l), P = H(O, k);
+		if (g !== void 0 && i(g, 1, 1e5), !F(v)) throw t("forbidden");
+		return R(async () => (g === void 0 && await G(O, k), a.transactional(async (e) => {
+			let n = g === void 0 ? await ee(e, O, k) : (await e.query(N(T).where(M("id", P)).forUpdate().limit(1).descriptor))[0];
+			U(n, O, k);
+			let a = async (n) => {
+				let r = await e.query(N(n).where(j(M("tenantId", O), M("ownerKey", P))).limit(h.maxHistoryRows + 1).descriptor);
+				if (r.length > h.maxHistoryRows) throw t("limit_exceeded");
+				if (r.some((e) => e.tenantId !== O || e.ownerKey !== P)) throw t("invalid_record");
+				return r;
+			}, o = await a(b), l = await a(x), v = await a(S), F = o.filter((e) => e.state === "committed").sort((e, t) => Number(e.sequence) - Number(t.sequence));
+			if (F.length !== i(n?.sequence ?? 0, 0, 2147483647)) throw t("invalid_record");
+			let R = new Map(o.map((e) => [e.id, e])), B = new Map(l.map((e) => [e.operationId, e]));
+			if (R.size !== o.length || B.size !== l.length || l.length !== F.length) throw t("invalid_record");
+			for (let e of o) if (e.state === "pending") {
+				if (e.sequence !== null || e.linkedOperationId !== null || e.digest !== null || e.receipt !== null) throw t("invalid_record");
+			} else if (e.state === "replayed") {
+				let n = R.get(r(e.linkedOperationId));
+				if (e.sequence !== null || e.receipt !== null || !n || n.state !== "committed" || e.digest !== n.digest) throw t("invalid_record");
+			} else if (e.state !== "committed") throw t("invalid_record");
+			let V = await q(e, D, O, k), H = await q(e, C, O, k), W = /* @__PURE__ */ new Map();
+			for (let [e, n] of [["xp", V], ["stat", H]]) for (let i of n) {
+				let n = r(i.operationId);
+				if (W.has(n) || R.get(n)?.state !== "committed") throw t("invalid_record");
+				W.set(n, {
+					kind: e,
+					row: i
+				});
+			}
+			if (W.size !== F.length) throw t("invalid_record");
+			let G = /* @__PURE__ */ new Map();
+			for (let e of v) {
+				let n = r(e.operationId), i = r(e.id), a = G.get(n) ?? /* @__PURE__ */ new Map();
+				if (a.has(i) || R.get(n)?.state !== "committed" || e.ownerId !== k) throw t("invalid_record");
+				a.set(i, e), G.set(n, a);
+			}
+			let Y = /* @__PURE__ */ new Map(), X = /* @__PURE__ */ new Map(), ne = /* @__PURE__ */ new Set(), re = [];
+			for (let [n, a] of F.entries()) {
+				if (a.sequence !== n + 1 || a.linkedOperationId !== null || typeof a.digest != "string" || !/^[0-9a-f]{64}$/.test(a.digest)) throw t("invalid_record");
+				let o = J(a), l = W.get(r(a.id)), d = B.get(a.id);
+				if (!l || !d) throw t("invalid_record");
+				let { kind: g, row: v } = l, b = o.change, x = r(v.source), S = r(v.origin);
+				if (r(v.actor), b.kind !== g || v.sequence !== a.sequence || v.ownerKey !== P || z(v.at) !== o.at || v.id !== L(g === "xp" ? "pgx_" : "pgl_", o.operationId) || d.source !== x || d.origin !== S || d.digest !== a.digest) throw t("invalid_record");
+				let C = r(g === "xp" ? v.trackId : v.stat), w = L("pgd_", O, g, C);
+				if (!ne.has(w)) {
+					let n = (await e.query(N(y).where(M("id", w)).limit(1).descriptor))[0];
+					if (!n || n.tenantId !== O || n.kind !== (g === "xp" ? "track" : "stat") || n.definitionId !== C || I(n.config) !== I(te(g, C))) throw t("conflict");
+					ne.add(w);
+				}
+				if (d.id !== L("pgn_", O, k, g, C, x, S)) throw t("invalid_record");
+				let T;
+				if (g === "xp" && b.kind === "xp") {
+					let e = _.get(C);
+					if (!e || !e.sources.includes(x)) throw t("invalid_track");
+					let n = L("pgt_", O, k, C), r = Y.get(n), a = String(r?.xp ?? "0"), l = String(s(v.delta)), d = String(s(BigInt(a) + BigInt(l))), p = u(a, e.xpCurve, h.strategies.xpCurve), m = u(d, e.xpCurve, h.strategies.xpCurve);
+					if (l === "0" || m < p || v.afterXp !== d && String(v.afterXp) !== d || v.fromLevel !== p || v.toLevel !== m || b.trackId !== C || b.xp !== d || b.delta !== l || b.fromLevel !== p || b.toLevel !== m) throw t("invalid_record");
+					let g = G.get(o.operationId) ?? /* @__PURE__ */ new Map();
+					if (g.size !== o.rewardsQueued) throw t("invalid_record");
+					for (let e = 0; e < o.rewardsQueued; e++) {
+						let n = g.get(L("pgr_", o.operationId, String(e)));
+						if (!n || i(n.level, p + 1, m) !== n.level || z(n.createdAt) !== o.at || n.state !== "pending" && n.state !== "delivered" || n.state === "pending" && n.deliveredAt !== null || n.state === "delivered" && z(n.deliveredAt) < o.at) throw t("invalid_record");
+						c([n.reward], 1), f(n, "level", I);
+					}
+					Y.set(n, {
+						id: n,
+						tenantId: O,
+						ownerId: k,
+						trackId: C,
+						version: e.version,
+						xp: d,
+						level: m,
+						prestige: 0,
+						updatedAt: new Date(o.at),
+						metadata: {}
+					}), T = { amount: l };
+				} else if (g === "stat" && b.kind === "stat") {
+					let e = A.get(C);
+					if (!e || !h.statSources.includes(x)) throw t("invalid_stat");
+					if (v.period !== "lifetime" && v.period !== "season" || v.period === "lifetime" && v.seasonId !== null || !p.some((e) => e === v.operator)) throw t("invalid_record");
+					let i = v.period === "season" ? r(v.seasonId) : null, a = L("pgv_", O, k, C, v.period, i ?? ""), c = X.get(a), l = c ? String(c.value) : null, u = String(s(v.operand)), d = v.operator, f = m(l, u, d, e);
+					if ((v.beforeValue === null ? null : String(s(v.beforeValue))) !== l || String(s(v.afterValue)) !== f || b.stat !== C || b.period !== v.period || b.seasonId !== i || b.operator !== d || b.value !== f || o.rewardsQueued !== 0 || (G.get(o.operationId)?.size ?? 0) !== 0) throw t("invalid_record");
+					X.set(a, {
+						id: a,
+						tenantId: O,
+						ownerId: k,
+						stat: C,
+						period: v.period,
+						seasonId: i,
+						value: f,
+						updatedAt: new Date(o.at)
+					}), re.push(Object.freeze({
+						stat: C,
+						period: v.period,
+						seasonId: i,
+						value: f,
+						operationId: o.operationId,
+						sequence: n + 1,
+						at: o.at
+					})), T = {
+						period: v.period,
+						seasonId: i,
+						operator: d,
+						operand: u
+					};
+				} else throw t("invalid_record");
+				if (a.digest !== I({
+					tenantId: O,
+					ownerId: k,
+					kind: g,
+					id: C,
+					source: x,
+					origin: S,
+					payload: T
+				})) throw t("invalid_record");
+			}
+			let Z = await q(e, E, O, k, 128), Q = await q(e, w, O, k), $ = !1;
+			try {
+				$ = Z.length === Y.size && Q.length === X.size && new Set(Z.map((e) => e.id)).size === Z.length && new Set(Q.map((e) => e.id)).size === Q.length && Z.every((e) => {
+					let t = Y.get(String(e.id));
+					return t ? I(ie(e, _.get(r(e.trackId)))) === I(ie(t, _.get(r(t.trackId)))) && I(e.metadata) === I({}) : !1;
+				}) && Q.every((e) => {
+					let t = X.get(String(e.id));
+					return t ? I(ae(e, A.get(r(e.stat)))) === I(ae(t, A.get(r(t.stat)))) : !1;
+				});
+			} catch {
+				$ = !1;
+			}
+			if (d && !$) {
+				await e.deleteMany(E.tableName, { where: K(O, k) }), await e.deleteMany(w.tableName, { where: K(O, k) });
+				for (let t of Y.values()) await e.insert(E.tableName, t);
+				for (let t of X.values()) await e.insert(w.tableName, t);
+				$ = !0;
+			}
+			if (g !== void 0 && re.length > g) throw t("limit_exceeded");
+			let oe = Object.freeze(h.stats.map((e) => Object.freeze({
+				stat: e.id,
+				period: "lifetime",
+				seasonId: null,
+				value: e.initial
+			})));
+			return Object.freeze({
+				audit: Object.freeze({
+					tracks: Y.size,
+					stats: X.size,
+					acceptedOperations: F.length,
+					xpLedgerRows: V.length,
+					statLedgerRows: H.length,
+					rewardRows: v.length,
+					matches: $
+				}),
+				history: Object.freeze({
+					version: I({
+						stats: h.stats,
+						sources: h.statSources
+					}),
+					throughSequence: F.length,
+					initial: oe,
+					events: Object.freeze(re)
+				})
+			});
+		})));
+	}), oe = (e, n) => X(() => {
+		let i = o(e, [
+			"subjectId",
+			"tenantId",
+			"kind"
+		]), c = r(i.tenantId), l = r(i.subjectId), u = H(c, l);
+		if (i.kind !== "user" && i.kind !== "guest") throw t("forbidden");
+		return R(async () => (await G(c, l), a.transactional(async (e) => {
+			await ee(e, c, l, !0);
+			let r = await q(e, E, c, l, 128), i = await q(e, w, c, l), a = await q(e, D, c, l), o = await q(e, C, c, l), d = [
+				b,
+				x,
+				S
+			];
+			for (let n of d) if ((await e.query(N(n).where(j(M("tenantId", c), M("ownerKey", u))).limit(h.maxHistoryRows + 1).descriptor)).length > h.maxHistoryRows) throw t("limit_exceeded");
+			let f = await e.query(N(S).where(j(M("tenantId", c), M("ownerKey", u))).limit(h.maxHistoryRows + 1).descriptor);
+			if (f.length > h.maxHistoryRows) throw t("limit_exceeded");
+			if (!n) return {
+				...f.length ? { rewards: f.map((e) => ({
+					reward: e.reward,
+					state: e.state,
+					deliveryIntent: e.deliveryIntent ?? null,
+					deliveryReceipt: e.deliveryReceipt ?? null
+				})) } : {},
+				tracks: r.map((e) => ({
+					trackId: e.trackId,
+					xp: String(s(e.xp)),
+					level: e.level,
+					prestige: e.prestige,
+					updatedAt: z(e.updatedAt)
+				})),
+				stats: i.map((e) => ({
+					stat: e.stat,
+					period: e.period,
+					seasonId: e.seasonId,
+					value: String(s(e.value)),
+					updatedAt: z(e.updatedAt)
+				})),
+				xpLedger: a.map((e) => ({
+					trackId: e.trackId,
+					delta: String(s(e.delta)),
+					source: e.source,
+					at: z(e.at)
+				})),
+				statLedger: o.map((e) => ({
+					stat: e.stat,
+					operator: e.operator,
+					operand: String(s(e.operand)),
+					at: z(e.at)
+				}))
+			};
+			await e.deleteMany(E.tableName, { where: K(c, l) }), await e.deleteMany(w.tableName, { where: K(c, l) });
+			for (let t of [D, C]) await e.updateMany(t.tableName, {
+				ownerId: null,
+				ownerKey: null,
+				origin: null,
+				actor: null
+			}, { where: K(c, l) });
+			await e.updateMany(b.tableName, {
+				ownerKey: null,
+				state: "erased",
+				digest: null,
+				receipt: null,
+				linkedOperationId: null
+			}, { where: j(M("tenantId", c), M("ownerKey", u)) }), await e.updateMany(x.tableName, {
+				ownerKey: null,
+				source: null,
+				origin: null,
+				digest: null
+			}, { where: j(M("tenantId", c), M("ownerKey", u)) }), await e.updateMany(S.tableName, {
+				ownerId: null,
+				ownerKey: null,
+				state: "erased",
+				reward: null,
+				deliveryIntent: null,
+				deliveryDigest: null,
+				deliveryReceipt: null,
+				deliveredAt: null
+			}, { where: j(M("tenantId", c), M("ownerKey", u)) }), await e.update(T.tableName, u, {
+				ownerId: null,
+				erased: !0
+			});
+		})));
+	});
+	return Object.freeze({
+		applyXp: ne,
+		applyStat: re,
+		mine: Z,
+		stats: Q,
+		exportSubject: (e) => oe(e, !1),
+		eraseSubject: (e) => O.asVoid(oe(e, !0)),
+		auditProgression: (e, t, n) => O.map($(e, t, n, !1), (e) => e.audit),
+		rebuildProgression: (e, t, n) => O.map($(e, t, n, !0), (e) => e.audit),
+		achievementHistory: (e, t, n, r) => O.map($(e, t, n, !1, r), (e) => e.history)
+	});
+};
+//#endregion
+export { B as dataStoreProgression, P as resolveProgressionOptions };