@voltro/plugin-progression 0.0.0-stage → 0.88.0

package/dist/achievementComponents.js

@@ -0,0 +1,91 @@
+import { PlayerAchievementSchema as e } from "./rpc.js";
+import { useAchievements as t } from "./web.js";
+import { Schema as n } from "effect";
+import { useId as r } from "react";
+import { useUiStrings as i } from "@voltro/ui";
+import { jsx as a, jsxs as o } from "react/jsx-runtime";
+// src/achievementComponents.tsx
+var s = n.decodeUnknownSync(n.Array(e), { onExcessProperty: "error" }), c = (e) => /^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/.test(e), l = (e) => /^(0|[1-9][0-9]{0,18})$/.test(e) && BigInt(e) <= 9223372036854775807n, u = (e) => {
+	try {
+		if (!Array.isArray(e) || e.length > 256) return;
+		let t = s(e);
+		return new Set(t.map((e) => JSON.stringify([
+			e.achievementId,
+			e.version,
+			e.tierId
+		]))).size !== t.length || t.some((e) => !c(e.achievementId) || !c(e.tierId) || !Number.isSafeInteger(e.version) || e.version < 1 || e.version > 1e6 || e.unlocked !== (e.unlockedAt !== null) || e.unlockedAt !== null && (!Number.isSafeInteger(e.unlockedAt) || e.unlockedAt < 0 || e.unlockedAt > 864e13) || !e.unlocked && e.platform !== null || e.platform !== null && Object.values(e.platform).some((e) => e !== void 0 && !c(e)) || e.progress.length < 1 || e.progress.length > 64 || e.progress.some((e) => !c(e.stat) || !l(e.value) || !l(e.target) || e.target === "0" || e.met !== BigInt(e.value) >= BigInt(e.target) || e.period === "lifetime" && e.seasonId !== null || e.period === "season" && (e.seasonId === null || !c(e.seasonId)))) ? void 0 : t;
+	} catch {
+		return;
+	}
+};
+function d({ achievement: e, title: t, locale: n }) {
+	let s = i().achievements, c = r(), l = u([e])?.[0];
+	return l ? /* @__PURE__ */ o("article", {
+		"data-achievement": l.achievementId,
+		"data-tier": l.tierId,
+		"data-state": l.unlocked ? "unlocked" : "locked",
+		"aria-labelledby": c,
+		children: [
+			/* @__PURE__ */ o("header", { children: [/* @__PURE__ */ a("h3", {
+				id: c,
+				children: t ?? l.achievementId
+			}), /* @__PURE__ */ o("p", { children: [
+				s.tier(l.tierId),
+				" · ",
+				l.unlocked ? s.unlocked : s.locked
+			] })] }),
+			/* @__PURE__ */ a("ul", {
+				"data-achievement-progress": !0,
+				children: l.progress.map((e, t) => {
+					let n = BigInt(e.value), r = BigInt(e.target), i = Number((n >= r ? r : n) * 10000n / r);
+					return /* @__PURE__ */ o("li", { children: [/* @__PURE__ */ a("span", { children: s.progress(e.stat, e.value, e.target) }), /* @__PURE__ */ a("progress", {
+						"aria-label": e.stat,
+						"aria-valuetext": s.progress(e.stat, e.value, e.target),
+						value: i,
+						max: 1e4
+					})] }, t);
+				})
+			}),
+			l.unlockedAt === null ? null : /* @__PURE__ */ a("p", { children: /* @__PURE__ */ a("time", {
+				dateTime: new Date(l.unlockedAt).toISOString(),
+				children: s.unlockedDate(new Date(l.unlockedAt).toLocaleString(n))
+			}) })
+		]
+	}) : /* @__PURE__ */ a("p", {
+		role: "alert",
+		children: s.invalid
+	});
+}
+function f({ api: e = "app", locale: n, renderTitle: r }) {
+	let o = i().achievements, s = t(e), c = s.data === void 0 ? void 0 : u(s.data);
+	return s.error === void 0 ? s.loading ? /* @__PURE__ */ a("p", {
+		role: "status",
+		children: o.loading
+	}) : c ? /* @__PURE__ */ a("section", {
+		"data-achievements": !0,
+		"aria-label": o.title,
+		children: c.length === 0 ? /* @__PURE__ */ a("p", { children: o.empty }) : /* @__PURE__ */ a("ul", { children: c.map((e) => /* @__PURE__ */ a("li", { children: /* @__PURE__ */ a(d, {
+			achievement: e,
+			title: r?.(e),
+			locale: n
+		}) }, JSON.stringify([
+			e.achievementId,
+			e.version,
+			e.tierId
+		]))) })
+	}) : /* @__PURE__ */ a("p", {
+		role: "alert",
+		children: o.invalid
+	}) : /* @__PURE__ */ a("p", {
+		role: "alert",
+		children: o.unavailable
+	});
+}
+function p(e) {
+	let t = i().achievements;
+	return c(e.invocationScope) ? /* @__PURE__ */ a(f, { ...e }, JSON.stringify([e.api ?? "app", e.invocationScope])) : /* @__PURE__ */ a("p", {
+		role: "alert",
+		children: t.invalid
+	});
+}
+export { d as AchievementCard, p as AchievementList };

package/dist/achievementStore.js

@@ -0,0 +1,602 @@
+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 { admitRewardDeliveryRecord as c } from "./rewardDeliveryRecord.js";
+import { questHash as l } from "./questStore.js";
+import { captureAchievementPlatform as u, captureAchievementStats as d, defaultAchievementEvaluator as f, defineAchievement as p, resolveAchievementEvaluation as m } from "./achievements.js";
+import { achievementDefinitionsTable as h, achievementOperationsTable as g, achievementRewardsTable as _, achievementSubjectsTable as v, achievementUnlockLedgerTable as y, achievementsTable as b } from "./achievementTables.entity.js";
+import { Effect as x, Result as S } from "effect";
+import { and as C, eq as w, queryFor as T } from "@voltro/database";
+// src/achievementStore.ts
+var E = (e) => {
+	let n = o(e, [
+		"definitions",
+		"source",
+		"allowedServices",
+		"maxHistoryRows",
+		"maxPendingRewards",
+		"now",
+		"strategies"
+	]), s = Object.freeze(a(n.definitions, 128).map((e) => p(e))), c = o(n.source, ["history"]), l = o(n.strategies ?? {}, ["achievementEvaluator", "version"]), u = l.achievementEvaluator ?? f, d = n.now ?? Date.now, m = Object.freeze(a(n.allowedServices ?? [], 256).map(r));
+	if (s.length === 0 || new Set(s.map((e) => e.id)).size !== s.length || s.reduce((e, t) => e + t.tiers.length, 0) > 256 || typeof c.history != "function" || typeof u != "function" || typeof d != "function" || new Set(m).size !== m.length || u !== f && l.version === void 0) throw t("invalid_input");
+	return Object.freeze({
+		definitions: s,
+		source: Object.freeze({ history: c.history }),
+		allowedServices: m,
+		maxHistoryRows: i(n.maxHistoryRows ?? 1e4, 1, 1e5),
+		maxPendingRewards: i(n.maxPendingRewards ?? 4096, 1, 1e4),
+		now: d,
+		strategies: Object.freeze({
+			achievementEvaluator: u,
+			version: r(l.version ?? "default.v1")
+		})
+	});
+}, D = (e, n) => {
+	let s = o(e, [
+		"version",
+		"throughSequence",
+		"initial",
+		"events"
+	]), c = i(s.throughSequence, 0, 2147483647), l = d(s.initial), u = /* @__PURE__ */ new Set(), f = 0, p = Object.freeze(a(s.events, n).map((e) => {
+		let n = o(e, [
+			"stat",
+			"period",
+			"seasonId",
+			"value",
+			"operationId",
+			"sequence",
+			"at"
+		]), a = d([{
+			stat: n.stat,
+			period: n.period,
+			seasonId: n.seasonId,
+			value: n.value
+		}])[0], s = i(n.sequence, f + 1, c), l = r(n.operationId);
+		if (u.has(l)) throw t("invalid_record");
+		return f = s, u.add(l), Object.freeze({
+			...a,
+			sequence: s,
+			operationId: l,
+			at: i(n.at, 0, 864e13)
+		});
+	}));
+	return Object.freeze({
+		version: r(s.version),
+		throughSequence: c,
+		initial: l,
+		events: p
+	});
+}, O = (e, ...t) => e + l(t).slice(0, 56), k = (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;
+}, A = (n) => x.tryPromise({
+	try: n,
+	catch: (n) => n instanceof e ? n : t("unavailable")
+}), j = (e) => {
+	if (typeof e != "string" || !/^[0-9a-f]{64}$/.test(e)) throw t("invalid_record");
+	return e;
+}, M = (d, p) => {
+	let M = E(p), N = l({
+		definitions: M.definitions,
+		rules: M.strategies.version
+	}), P = new Set(M.allowedServices), F = new Map(M.definitions.map((e) => [e.id, e])), I = () => i(M.now(), 0, 864e13), L = (e) => {
+		if (e.type !== "system" && !(e.type === "service" && P.has(e.service))) throw t("forbidden");
+	}, R = (e, t) => O("pas_", e, t), z = (e, t) => C(w("tenantId", e), w("ownerId", t)), B = (e, t) => C(w("tenantId", e), w("ownerKey", R(e, t))), V = async (e, t) => {
+		try {
+			await d.insertIgnore(e, t, { conflictColumns: ["id"] });
+		} catch (n) {
+			if (!(await d.query({
+				table: e,
+				predicate: w("id", t.id),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			}))[0]) throw n;
+		}
+	}, H = (e, t) => V(v.tableName, {
+		id: R(e, t),
+		tenantId: e,
+		ownerId: t,
+		erased: !1,
+		sequence: 0,
+		admission: 0,
+		throughSequence: 0,
+		sourceVersion: null,
+		sourceDigest: null,
+		configDigest: null,
+		view: null
+	}), U = (e, n, r, a = !1) => {
+		if (e) {
+			if (e.id !== R(n, r) || e.tenantId !== n || typeof e.erased != "boolean") throw t("invalid_record");
+			if (e.erased) {
+				if (a && e.ownerId === null) return;
+				throw t("erased");
+			}
+			if (e.ownerId !== r) throw t("invalid_record");
+			if (i(e.sequence, 0, 2147483647), i(e.throughSequence, 0, 2147483647), e.configDigest !== null && e.configDigest !== N) throw t("conflict");
+		}
+	}, W = async (e, n, r, i = !1) => {
+		if (await e.updateMany(v.tableName, { admission: 0 }, { where: w("id", R(n, r)) }) !== 1) throw t("unavailable");
+		let a = (await e.query(T(v).where(w("id", R(n, r))).limit(1).descriptor))[0];
+		if (!a) throw t("invalid_record");
+		return U(a, n, r, i), a;
+	}, G = async (e, n, r, i) => {
+		let a = n === _ ? M.maxPendingRewards : M.maxHistoryRows, o = await e.query(T(n).where(B(r, i)).limit(a + 1).descriptor);
+		if (o.length > a) throw t("limit_exceeded");
+		if (o.some((e) => e.tenantId !== r || e.ownerKey !== R(r, i))) throw t("invalid_record");
+		return o;
+	}, K = (e, t, n) => e.query(T(b).where(z(t, n)).limit(257).descriptor), q = (e, n, i) => {
+		let a = F.get(r(e)), o = a?.tiers.find((e) => e.id === r(n));
+		if (!a || !o || i !== a.version) throw t("conflict");
+		return {
+			definition: a,
+			tier: o
+		};
+	}, J = (e, t, n, r, i) => O("pau_", e, t, n, String(r), i), Y = (e) => {
+		let n = o(e.receipt, [
+			"operationId",
+			"throughSequence",
+			"unlockedIds",
+			"rewardsQueued",
+			"at"
+		]), s = Object.freeze(a(n.unlockedIds, 256).map(r));
+		if (n.operationId !== e.id || new Set(s).size !== s.length || n.at !== k(e.at) || n.throughSequence !== e.throughSequence) throw t("invalid_record");
+		return Object.freeze({
+			operationId: r(e.id),
+			throughSequence: i(n.throughSequence, 0, 2147483647),
+			unlockedIds: s,
+			rewardsQueued: i(n.rewardsQueued, 0, 16384),
+			at: i(n.at, 0, 864e13)
+		});
+	}, X = (e) => {
+		let n = a(e, 256).map((e) => {
+			let n = o(e, [
+				"achievementId",
+				"version",
+				"tierId",
+				"unlocked",
+				"unlockedAt",
+				"progress",
+				"platform"
+			]), { definition: c, tier: d } = q(n.achievementId, n.tierId, n.version);
+			if (typeof n.unlocked != "boolean" || n.unlocked !== (n.unlockedAt !== null) || !n.unlocked && n.platform !== null) throw t("invalid_record");
+			let p = a(n.progress, 64).map((e) => {
+				let n = o(e, [
+					"stat",
+					"period",
+					"seasonId",
+					"value",
+					"target",
+					"met"
+				]), i = m({
+					kind: "statAtLeast",
+					stat: r(n.stat),
+					period: n.period,
+					seasonId: n.seasonId,
+					target: String(s(n.target))
+				}, [{
+					stat: r(n.stat),
+					period: n.period,
+					seasonId: n.seasonId,
+					value: String(s(n.value))
+				}]).progress[0];
+				if (i.met !== n.met) throw t("invalid_record");
+				return i;
+			}), h = f({
+				condition: d.condition,
+				stats: []
+			}).progress;
+			if (p.length !== h.length || p.some((e, t) => {
+				let n = h[t];
+				return e.stat !== n.stat || e.period !== n.period || e.seasonId !== n.seasonId || e.target !== n.target;
+			})) throw t("invalid_record");
+			let g = n.unlocked ? u(n.platform) : null;
+			if (g && l(g) !== l(d.platform)) throw t("invalid_record");
+			return Object.freeze({
+				achievementId: c.id,
+				version: c.version,
+				tierId: d.id,
+				unlocked: n.unlocked,
+				unlockedAt: n.unlocked ? i(n.unlockedAt, 0, 864e13) : null,
+				progress: Object.freeze(p),
+				platform: g
+			});
+		});
+		if (n.length !== M.definitions.reduce((e, t) => e + t.tiers.length, 0) || new Set(n.map((e) => JSON.stringify([e.achievementId, e.tierId]))).size !== n.length) throw t("invalid_record");
+		return Object.freeze(n);
+	}, Z = (e, t) => l({
+		version: e.version,
+		initial: e.initial,
+		throughSequence: t,
+		events: e.events.filter((e) => e.sequence <= t)
+	}), ee = (e, n) => {
+		let r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), a = (e) => JSON.stringify([
+			e.stat,
+			e.period,
+			e.seasonId
+		]);
+		for (let t of e.initial) r.set(a(t), t);
+		let o = (e, t) => {
+			for (let n of M.definitions) for (let a of n.tiers) {
+				let o = m(a.condition, [...r.values()], M.strategies.achievementEvaluator), s = JSON.stringify([n.id, a.id]);
+				o.met && !i.has(s) && i.set(s, {
+					sequence: e,
+					at: t,
+					progress: o.progress
+				});
+			}
+		};
+		o(0, n);
+		for (let i of e.events) {
+			if (i.at > n) throw t("conflict");
+			r.set(a(i), Object.freeze({
+				stat: i.stat,
+				period: i.period,
+				seasonId: i.seasonId,
+				value: i.value
+			})), o(i.sequence, i.at);
+		}
+		return {
+			first: i,
+			view: Object.freeze(M.definitions.flatMap((e) => e.tiers.map((t) => {
+				let n = i.get(JSON.stringify([e.id, t.id])), a = m(t.condition, [...r.values()], M.strategies.achievementEvaluator);
+				return Object.freeze({
+					achievementId: e.id,
+					version: e.version,
+					tierId: t.id,
+					unlocked: n !== void 0,
+					unlockedAt: n?.at ?? null,
+					progress: a.progress,
+					platform: n ? t.platform : null
+				});
+			})))
+		};
+	}, te = (a, s) => {
+		try {
+			let e = n(a), c = o(s, [
+				"tenantId",
+				"ownerId",
+				"requestId"
+			]);
+			L(e);
+			let u = r(c.tenantId), f = r(c.ownerId), p = O("pao_", u, f, r(c.requestId));
+			return A(async () => {
+				await H(u, f);
+				let n = await d.transactional(async (e) => {
+					await W(e, u, f);
+					let n = (await G(e, g, u, f)).find((e) => e.id === p);
+					if (n) {
+						if (n.state !== "committed" || n.configDigest !== N) throw t("conflict");
+						return Y(n);
+					}
+				});
+				if (n) return n;
+				let r = await x.runPromise(x.result(M.source.history(e, {
+					tenantId: u,
+					ownerId: f,
+					limit: M.maxHistoryRows
+				})));
+				if (S.isFailure(r)) throw r.failure;
+				let a = D(r.success, M.maxHistoryRows), o = I(), s = Z(a, a.throughSequence), c = ee(a, o);
+				for (let e of M.definitions) await V(h.tableName, {
+					id: O("pad_", u, e.id, String(e.version)),
+					tenantId: u,
+					achievementId: e.id,
+					version: e.version,
+					config: e,
+					rulesVersion: M.strategies.version,
+					admission: 0
+				});
+				return d.transactional(async (e) => {
+					let n = await W(e, u, f), r = await G(e, g, u, f), d = await G(e, y, u, f), m = await G(e, _, u, f), x = r.find((e) => e.id === p);
+					if (x) {
+						if (x.state !== "committed" || x.configDigest !== N) throw t("conflict");
+						return Y(x);
+					}
+					if (r.length >= M.maxHistoryRows || r.length !== n.sequence) throw t(r.length >= M.maxHistoryRows ? "limit_exceeded" : "invalid_record");
+					if (n.sourceVersion !== null && (n.sourceVersion !== a.version || Number(n.throughSequence) > a.throughSequence || n.sourceDigest !== Z(a, Number(n.throughSequence)))) throw t("conflict");
+					for (let n of M.definitions) {
+						let r = O("pad_", u, n.id, String(n.version));
+						if (await e.updateMany(h.tableName, { admission: 0 }, { where: w("id", r) }) !== 1) throw t("unavailable");
+						let i = (await e.query(T(h).where(w("id", r)).limit(1).descriptor))[0];
+						if (!i || i.tenantId !== u || i.achievementId !== n.id || i.version !== n.version || i.rulesVersion !== M.strategies.version || l(i.config) !== l(n)) throw t("conflict");
+					}
+					let S = await K(e, u, f);
+					if (S.length !== d.length || d.some((e) => !S.some((t) => t.id === e.unlockId && t.operationId === e.operationId && k(t.unlockedAt) === k(e.unlockedAt)))) throw t("invalid_record");
+					let C = [], E = 0, D = c.view.map((e) => {
+						let t = J(u, f, e.achievementId, e.version, e.tierId), n = d.find((e) => e.unlockId === t);
+						return n ? Object.freeze({
+							...e,
+							unlocked: !0,
+							unlockedAt: k(n.unlockedAt),
+							platform: q(e.achievementId, e.tierId, e.version).tier.platform
+						}) : e;
+					});
+					for (let n of D) {
+						let r = J(u, f, n.achievementId, n.version, n.tierId);
+						if (!n.unlocked || d.some((e) => e.unlockId === r)) continue;
+						let i = c.first.get(JSON.stringify([n.achievementId, n.tierId]));
+						if (!i) throw t("invalid_record");
+						let { tier: s } = q(n.achievementId, n.tierId, n.version);
+						if (d.length + C.length >= M.maxHistoryRows || m.length + E + s.reward.length > M.maxPendingRewards) throw t("limit_exceeded");
+						let l = {
+							id: r,
+							tenantId: u,
+							ownerId: f,
+							achievementId: n.achievementId,
+							version: n.version,
+							tierId: n.tierId,
+							unlockedAt: new Date(i.at),
+							sourceSequence: i.sequence,
+							operationId: p
+						};
+						await e.insert(b.tableName, l), await e.insert(y.tableName, {
+							...l,
+							id: O("pal_", r),
+							ownerKey: R(u, f),
+							unlockId: r,
+							proof: {
+								sourceVersion: a.version,
+								sourceDigest: Z(a, i.sequence),
+								rulesVersion: M.strategies.version,
+								fulfilled: !0,
+								progress: i.progress
+							}
+						});
+						for (let [t, n] of s.reward.entries()) await e.insert(_.tableName, {
+							id: O("par_", r, String(t)),
+							tenantId: u,
+							ownerId: f,
+							ownerKey: R(u, f),
+							unlockId: r,
+							operationId: p,
+							reward: n,
+							state: "pending",
+							createdAt: new Date(o),
+							deliveredAt: null,
+							deliveryIntent: null,
+							deliveryDigest: null,
+							deliveryReceipt: null
+						});
+						C.push(r), E += s.reward.length;
+					}
+					let A = Object.freeze({
+						operationId: p,
+						throughSequence: a.throughSequence,
+						unlockedIds: Object.freeze(C),
+						rewardsQueued: E,
+						at: o
+					}), j = {
+						throughSequence: a.throughSequence,
+						sourceVersion: a.version,
+						sourceDigest: s,
+						configDigest: N,
+						view: Object.freeze(D)
+					}, P = i(Number(n.sequence) + 1, 1, 2147483647);
+					return await e.insert(g.tableName, {
+						id: p,
+						tenantId: u,
+						ownerKey: R(u, f),
+						state: "committed",
+						sequence: P,
+						...j,
+						receipt: A,
+						at: new Date(o)
+					}), await e.update(v.tableName, R(u, f), {
+						sequence: P,
+						...j
+					}), A;
+				});
+			});
+		} catch (n) {
+			return x.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, ne = (i) => {
+		try {
+			let e = n(i);
+			if (e.type !== "user") throw t("forbidden");
+			let a = r(e.tenantId), o = r(e.id);
+			return A(() => d.transactional(async (e) => {
+				let t = (await e.query(T(v).where(w("id", R(a, o))).forUpdate().limit(1).descriptor))[0];
+				return U(t, a, o), !t || t.view === null ? Object.freeze(M.definitions.filter((e) => !e.hidden).flatMap((e) => e.tiers.map((t) => Object.freeze({
+					achievementId: e.id,
+					version: e.version,
+					tierId: t.id,
+					unlocked: !1,
+					unlockedAt: null,
+					progress: f({
+						condition: t.condition,
+						stats: []
+					}).progress,
+					platform: null
+				})))) : Object.freeze(X(t.view).filter((e) => e.unlocked || !F.get(e.achievementId).hidden));
+			}));
+		} catch (n) {
+			return x.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, Q = (n, i) => {
+		try {
+			let e = o(n, [
+				"tenantId",
+				"subjectId",
+				"kind"
+			]), a = r(e.tenantId), s = r(e.subjectId);
+			if (e.kind !== "user" && e.kind !== "guest") throw t("forbidden");
+			return A(async () => (await H(a, s), d.transactional(async (e) => {
+				await W(e, a, s, !0);
+				let t = await K(e, a, s), n = await G(e, y, a, s), r = await G(e, g, a, s), o = await G(e, _, a, s);
+				if (!i) return {
+					achievements: t.map((e) => ({
+						achievementId: e.achievementId,
+						version: e.version,
+						tierId: e.tierId,
+						unlockedAt: k(e.unlockedAt),
+						sourceSequence: e.sourceSequence
+					})),
+					history: n.map((e) => ({
+						achievementId: e.achievementId,
+						tierId: e.tierId,
+						proof: e.proof
+					})),
+					evaluations: r.map((e) => e.receipt),
+					rewards: o.map((e) => ({
+						reward: e.reward,
+						state: e.state,
+						deliveryIntent: e.deliveryIntent ?? null,
+						deliveryReceipt: e.deliveryReceipt ?? null
+					}))
+				};
+				await e.deleteMany(b.tableName, { where: z(a, s) }), await e.updateMany(y.tableName, {
+					ownerId: null,
+					ownerKey: null,
+					proof: null
+				}, { where: B(a, s) }), await e.updateMany(g.tableName, {
+					ownerKey: null,
+					state: "erased",
+					sourceVersion: null,
+					sourceDigest: null,
+					configDigest: null,
+					view: null,
+					receipt: null
+				}, { where: B(a, s) }), await e.updateMany(_.tableName, {
+					ownerId: null,
+					ownerKey: null,
+					reward: null,
+					state: "erased",
+					deliveryIntent: null,
+					deliveryDigest: null,
+					deliveryReceipt: null,
+					deliveredAt: null
+				}, { where: B(a, s) }), await e.update(v.tableName, R(a, s), {
+					ownerId: null,
+					erased: !0,
+					sourceVersion: null,
+					sourceDigest: null,
+					configDigest: null,
+					view: null
+				});
+			})));
+		} catch (n) {
+			return x.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, $ = (a, s, u, p) => {
+		try {
+			let e = n(a);
+			L(e);
+			let m = r(s), x = r(u);
+			return A(async () => (await H(m, x), d.transactional(async (e) => {
+				let n = await W(e, m, x), a = await G(e, y, m, x), s = await G(e, g, m, x), u = await G(e, _, m, x), d = [...s].sort((e, t) => Number(e.sequence) - Number(t.sequence)), S = /* @__PURE__ */ new Map(), C = 0, E = 0;
+				if (d.length > 0) for (let n of M.definitions) {
+					let r = (await e.query(T(h).where(w("id", O("pad_", m, n.id, String(n.version)))).limit(1).descriptor))[0];
+					if (!r || r.tenantId !== m || r.achievementId !== n.id || r.version !== n.version || r.rulesVersion !== M.strategies.version || l(r.config) !== l(n)) throw t("conflict");
+				}
+				if (d.length !== n.sequence) throw t("invalid_record");
+				for (let [e, n] of d.entries()) {
+					if (n.sequence !== e + 1 || n.state !== "committed" || n.configDigest !== N || Number(n.throughSequence) < C) throw t("invalid_record");
+					C = i(n.throughSequence, 0, 2147483647), r(n.sourceVersion), j(n.sourceDigest);
+					let s = Y(n);
+					if (s.at < E || e > 0 && n.sourceVersion !== d[e - 1].sourceVersion || e > 0 && n.throughSequence === d[e - 1].throughSequence && n.sourceDigest !== d[e - 1].sourceDigest) throw t("invalid_record");
+					E = s.at;
+					let p = X(n.view), h = a.filter((e) => e.operationId === n.id), g = u.filter((e) => e.operationId === n.id);
+					if (h.length !== s.unlockedIds.length || g.length !== s.rewardsQueued || new Set(h.map((e) => e.unlockId)).size !== h.length) throw t("invalid_record");
+					let _ = 0;
+					for (let e of h) {
+						let { definition: r, tier: a } = q(e.achievementId, e.tierId, e.version), u = J(m, x, r.id, r.version, a.id), d = p.find((e) => e.achievementId === r.id && e.tierId === a.id), h = o(e.proof, [
+							"sourceVersion",
+							"sourceDigest",
+							"rulesVersion",
+							"fulfilled",
+							"progress"
+						]);
+						if (S.has(u) || e.unlockId !== u || e.id !== O("pal_", u) || e.ownerId !== x || !s.unlockedIds.includes(u) || !d?.unlocked || d.unlockedAt !== k(e.unlockedAt) || k(e.unlockedAt) > s.at || h.sourceVersion !== n.sourceVersion || h.rulesVersion !== M.strategies.version || h.fulfilled !== !0) throw t("invalid_record");
+						j(h.sourceDigest), i(e.sourceSequence, 0, s.throughSequence);
+						let v = {
+							...d,
+							progress: h.progress
+						}, y = p.map((e) => e === d ? v : e), b = X(y).find((e) => e.achievementId === r.id && e.tierId === a.id);
+						if (M.strategies.achievementEvaluator === f) {
+							let e = /* @__PURE__ */ new Map();
+							for (let n of b.progress) {
+								let r = JSON.stringify([
+									n.stat,
+									n.period,
+									n.seasonId
+								]), i = e.get(r);
+								if (i && i.value !== n.value) throw t("invalid_record");
+								e.set(r, {
+									stat: n.stat,
+									period: n.period,
+									seasonId: n.seasonId,
+									value: n.value
+								});
+							}
+							if (!f({
+								condition: a.condition,
+								stats: [...e.values()]
+							}).met) throw t("invalid_record");
+						}
+						S.set(u, {
+							id: u,
+							tenantId: m,
+							ownerId: x,
+							achievementId: r.id,
+							version: r.version,
+							tierId: a.id,
+							unlockedAt: new Date(d.unlockedAt),
+							sourceSequence: e.sourceSequence,
+							operationId: n.id
+						});
+						for (let [e, n] of a.reward.entries()) {
+							let r = g.find((t) => t.id === O("par_", u, String(e)));
+							if (!r || r.unlockId !== u || r.ownerId !== x || l(r.reward) !== l(n) || k(r.createdAt) !== s.at || r.state !== "pending" && r.state !== "delivered" || r.state === "pending" && r.deliveredAt !== null || r.state === "delivered" && k(r.deliveredAt) < s.at) throw t("invalid_record");
+							c(r, "achievement", l), _++;
+						}
+					}
+					if (_ !== g.length || p.some((e) => {
+						let t = S.get(J(m, x, e.achievementId, e.version, e.tierId));
+						return e.unlocked !== (t !== void 0) || t !== void 0 && e.unlockedAt !== k(t.unlockedAt);
+					})) throw t("invalid_record");
+				}
+				if (a.length !== S.size || a.some((e) => !d.some((t) => t.id === e.operationId)) || u.some((e) => !d.some((t) => t.id === e.operationId))) throw t("invalid_record");
+				let D = d.at(-1), A = await K(e, m, x), P = (e) => ({
+					id: e.id,
+					achievementId: e.achievementId,
+					version: e.version,
+					tierId: e.tierId,
+					unlockedAt: k(e.unlockedAt),
+					sourceSequence: e.sourceSequence,
+					operationId: e.operationId
+				}), F = A.length === S.size && A.every((e) => S.has(String(e.id)) && l(P(e)) === l(P(S.get(String(e.id))))) && l(n.view) === l(D?.view ?? null) && n.throughSequence === (D?.throughSequence ?? 0) && n.sourceDigest === (D?.sourceDigest ?? null) && n.sourceVersion === (D?.sourceVersion ?? null) && n.configDigest === (D?.configDigest ?? null);
+				if (p && !F) {
+					await e.deleteMany(b.tableName, { where: z(m, x) });
+					for (let t of S.values()) await e.insert(b.tableName, t);
+					await e.update(v.tableName, R(m, x), {
+						throughSequence: D?.throughSequence ?? 0,
+						sourceDigest: D?.sourceDigest ?? null,
+						sourceVersion: D?.sourceVersion ?? null,
+						configDigest: D?.configDigest ?? null,
+						view: D?.view ?? null
+					});
+				}
+				return Object.freeze({
+					acceptedOperations: d.length,
+					unlocked: S.size,
+					rewardRows: u.length,
+					matches: p ? !0 : F
+				});
+			})));
+		} catch (n) {
+			return x.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	};
+	return Object.freeze({
+		evaluate: te,
+		mine: ne,
+		exportSubject: (e) => Q(e, !1),
+		eraseSubject: (e) => x.asVoid(Q(e, !0)),
+		auditAchievements: (e, t, n) => $(e, t, n, !1),
+		rebuildAchievements: (e, t, n) => $(e, t, n, !0)
+	});
+};
+export { D as captureAchievementHistory, M as dataStoreAchievements, E as resolveAchievementOptions };