@voltro/plugin-progression 0.0.0-stage → 0.88.0

package/dist/resourceStore.js

@@ -0,0 +1,463 @@
+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 { questHash as c } from "./questStore.js";
+import { captureResourceState as l, defaultResourceRegen as u, defineRegenResource as d, resolveResourceRegen as f } from "./resources.js";
+import { resourceDefinitionsTable as p, resourceMovementsTable as m, resourceOperationsTable as h, resourceOriginsTable as g, resourceSubjectsTable as _, resourcesTable as v } from "./resourceTables.entity.js";
+import { Effect as y } from "effect";
+import { and as b, eq as x, queryFor as S } from "@voltro/database";
+// src/resourceStore.ts
+var C = (e) => {
+	let n = o(e, [
+		"definitions",
+		"sources",
+		"allowedServices",
+		"maxHistoryRows",
+		"now",
+		"strategies"
+	]), s = Object.freeze(a(n.definitions, 64).map((e) => d(e))), c = (e, n) => {
+		let i = Object.freeze(a(e, n).map(r));
+		if (new Set(i).size !== i.length) throw t("invalid_input");
+		return i;
+	}, l = o(n.strategies ?? {}, ["regen", "version"]), f = l.regen ?? u, p = n.now ?? Date.now;
+	if (s.length < 1 || new Set(s.map((e) => e.id)).size !== s.length || typeof f != "function" || typeof p != "function" || f !== u && l.version === void 0) throw t("invalid_input");
+	return Object.freeze({
+		definitions: s,
+		sources: c(n.sources, 64),
+		allowedServices: c(n.allowedServices ?? [], 256),
+		maxHistoryRows: i(n.maxHistoryRows ?? 1e4, 1, 1e5),
+		now: p,
+		strategies: Object.freeze({
+			regen: f,
+			version: r(l.version ?? "default.v1")
+		})
+	});
+}, w = (e, ...t) => e + c(t).slice(0, 56), T = (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;
+}, E = (n) => y.tryPromise({
+	try: n,
+	catch: (n) => n instanceof e ? n : t("unavailable")
+}), D = (a, u) => {
+	let d = C(u), D = new Map(d.definitions.map((e) => [e.id, e])), O = new Set(d.allowedServices), k = () => i(d.now(), 0, 864e13), A = (e) => {
+		if (e.type !== "system" && !(e.type === "service" && O.has(e.service))) throw t("forbidden");
+	}, j = (e, t) => w("prs_", e, t), M = (e, t) => b(x("tenantId", e), x("ownerId", t)), N = (e, t) => b(x("tenantId", e), x("ownerKey", t)), P = async (e, t) => {
+		try {
+			await a.insertIgnore(e, t, { conflictColumns: ["id"] });
+		} catch (n) {
+			if (!(await a.query({
+				table: e,
+				predicate: x("id", t.id),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			}))[0]) throw n;
+		}
+	}, F = (e, t) => P(_.tableName, {
+		id: j(e, t),
+		tenantId: e,
+		ownerId: t,
+		erased: !1,
+		sequence: 0,
+		admission: 0
+	}), I = (e, n, r, a = !1) => {
+		if (e) {
+			if (e.id !== j(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");
+			i(e.sequence, 0, 2147483647);
+		}
+	}, L = async (e, n, r, i = !1) => {
+		let a = j(n, r);
+		if (await e.updateMany(_.tableName, { admission: 0 }, { where: x("id", a) }) !== 1) throw t("unavailable");
+		let o = (await e.query(S(_).where(x("id", a)).limit(1).descriptor))[0];
+		if (!o) throw t("invalid_record");
+		return I(o, n, r, i), o;
+	}, R = async (e, n, r, i) => {
+		let a = await e.query(S(n).where(N(r, i)).limit(d.maxHistoryRows + 1).descriptor);
+		if (a.length > d.maxHistoryRows) throw t("limit_exceeded");
+		if (a.some((e) => e.tenantId !== r || e.ownerKey !== i)) throw t("invalid_record");
+		return a;
+	}, z = async (e, n, r) => {
+		let i = await e.query(S(v).where(M(n, r)).limit(65).descriptor);
+		if (i.length > 64) throw t("limit_exceeded");
+		return i;
+	}, B = (e) => {
+		let n = D.get(e);
+		if (!n) throw t("invalid_input");
+		return n;
+	}, V = (e, n, r, i) => {
+		if (e.id !== w("prv_", n, r, i.id) || e.tenantId !== n || e.ownerId !== r || e.resourceId !== i.id || e.version !== i.version) throw t("invalid_record");
+		return l({
+			value: e.value,
+			anchorAt: T(e.anchorAt)
+		}, i);
+	}, H = (e) => {
+		let n = o(e.receipt, [
+			"operationId",
+			"kind",
+			"resourceId",
+			"amount",
+			"regenerated",
+			"after",
+			"at"
+		]);
+		if (n.operationId !== e.id || n.kind !== "initialize" && n.kind !== "consume" && n.kind !== "grant" || n.at !== T(e.at)) throw t("invalid_record");
+		let a = B(r(n.resourceId)), c = l(n.after, a), u = s(n.amount), d = s(n.regenerated), f = i(n.at, c.anchorAt, 864e13);
+		if (n.kind === "initialize" != (u === 0n)) throw t("invalid_record");
+		return Object.freeze({
+			operationId: r(e.id),
+			kind: n.kind,
+			resourceId: a.id,
+			amount: String(u),
+			regenerated: String(d),
+			after: c,
+			at: f
+		});
+	}, U = async (e, n, r) => {
+		let i = w("prd_", n, r.id, String(r.version));
+		if (await e.updateMany(p.tableName, { admission: 0 }, { where: x("id", i) }) !== 1) throw t("unavailable");
+		let a = (await e.query(S(p).where(x("id", i)).limit(1).descriptor))[0];
+		if (!a || a.tenantId !== n || a.resourceId !== r.id || a.version !== r.version || a.rulesVersion !== d.strategies.version || c(a.config) !== c(r)) throw t("conflict");
+	}, W = (u, b, C) => {
+		try {
+			let e = n(b), y = o(C, [
+				"tenantId",
+				"ownerId",
+				"resourceId",
+				"requestId",
+				"source",
+				"origin",
+				...u === "initialize" ? [] : ["amount"]
+			]);
+			A(e);
+			let D = r(y.tenantId), O = r(y.ownerId), M = B(r(y.resourceId)), N = r(y.requestId), I = r(y.source), z = r(y.origin);
+			if (!d.sources.includes(I)) throw t("forbidden");
+			let W = u === "initialize" ? 0n : s(y.amount);
+			if (u !== "initialize" && W === 0n) throw t("invalid_input");
+			let G = j(D, O), K = w("pro_", D, O, N), q = w("prn_", D, O, M.id, u, I, z), J = c({
+				tenantId: D,
+				ownerId: O,
+				resourceId: M.id,
+				version: M.version,
+				kind: u,
+				amount: String(W),
+				source: I,
+				origin: z
+			});
+			return E(async () => {
+				let e = k();
+				return await F(D, O), await P(p.tableName, {
+					id: w("prd_", D, M.id, String(M.version)),
+					tenantId: D,
+					resourceId: M.id,
+					version: M.version,
+					config: M,
+					rulesVersion: d.strategies.version,
+					admission: 0
+				}), a.transactional(async (n) => {
+					let r = await L(n, D, O), a = await R(n, h, D, G), o = (e) => {
+						if (e.digest !== J) throw t("conflict");
+						if (e.state === "committed" && e.linkedOperationId === null) return H(e);
+						if (e.state !== "replayed" || typeof e.linkedOperationId != "string") throw t("invalid_record");
+						let n = a.find((t) => t.id === e.linkedOperationId);
+						if (!n || n.state !== "committed" || n.digest !== J || n.linkedOperationId !== null) throw t("invalid_record");
+						return H(n);
+					}, s = a.find((e) => e.id === K);
+					if (s) return o(s);
+					if (a.length >= d.maxHistoryRows) throw t("limit_exceeded");
+					let p = await R(n, g, D, G), y = p.find((e) => e.id === q);
+					if (y) {
+						if (y.source !== I || y.origin !== z || y.digest !== J) throw t("conflict");
+						let r = a.find((e) => e.id === y.operationId);
+						if (!r || r.state !== "committed") throw t("invalid_record");
+						let i = o(r);
+						if (e < T(r.at)) throw t("conflict");
+						return await n.insert(h.tableName, {
+							id: K,
+							tenantId: D,
+							ownerKey: G,
+							state: "replayed",
+							linkedOperationId: r.id,
+							digest: J,
+							receipt: null,
+							at: new Date(e)
+						}), i;
+					}
+					await U(n, D, M);
+					let b = await R(n, m, D, G);
+					if (b.length >= d.maxHistoryRows || p.length >= d.maxHistoryRows) throw t("limit_exceeded");
+					let C = w("prv_", D, O, M.id), E = (await n.query(S(v).where(x("id", C)).limit(1).descriptor))[0];
+					if (u === "initialize" && E) throw t("conflict");
+					if (b.length !== r.sequence || a.filter((e) => e.state === "committed").length !== b.length) throw t("invalid_record");
+					let k = E ? V(E, D, O, M) : null, A = b.filter((e) => e.resourceId === M.id).reduce((e, t) => (i(t.sequence, 1, 2147483647), !e || Number(t.sequence) > Number(e.sequence) ? t : e), void 0);
+					if (A && (A.version !== M.version || c(l(A.after, M)) !== c(k)) || !A && k !== null) throw t("invalid_record");
+					let j = k ?? {
+						value: M.initial,
+						anchorAt: e
+					};
+					if (j.anchorAt > e) throw t("conflict");
+					let N = f({
+						resource: M,
+						state: j,
+						at: e
+					}, d.strategies.regen), P = BigInt(N.value) - BigInt(j.value), F = BigInt(N.value);
+					if (u === "consume") {
+						if (W > F) throw t("insufficient_resource");
+						F -= W;
+					}
+					if (u === "grant" && (F += W, F > BigInt(M.max))) throw t("overflow");
+					let B = Object.freeze({
+						value: String(F),
+						anchorAt: F === BigInt(M.max) ? e : N.anchorAt
+					}), Y = i(Number(r.sequence) + 1, 1, 2147483647), X = Object.freeze({
+						operationId: K,
+						kind: u,
+						resourceId: M.id,
+						amount: String(W),
+						regenerated: String(P),
+						after: B,
+						at: e
+					});
+					return E ? await n.update(v.tableName, C, {
+						value: B.value,
+						anchorAt: new Date(B.anchorAt)
+					}) : await n.insert(v.tableName, {
+						id: C,
+						tenantId: D,
+						ownerId: O,
+						resourceId: M.id,
+						version: M.version,
+						value: B.value,
+						anchorAt: new Date(B.anchorAt)
+					}), await n.insert(m.tableName, {
+						id: w("prm_", K),
+						tenantId: D,
+						ownerId: O,
+						ownerKey: G,
+						resourceId: M.id,
+						version: M.version,
+						operationId: K,
+						sequence: Y,
+						kind: u,
+						amount: String(W),
+						regenerated: String(P),
+						before: k,
+						after: B,
+						source: I,
+						origin: z,
+						at: new Date(e)
+					}), await n.insert(h.tableName, {
+						id: K,
+						tenantId: D,
+						ownerKey: G,
+						state: "committed",
+						linkedOperationId: null,
+						digest: J,
+						receipt: X,
+						at: new Date(e)
+					}), await n.insert(g.tableName, {
+						id: q,
+						tenantId: D,
+						ownerKey: G,
+						operationId: K,
+						source: I,
+						origin: z,
+						digest: J
+					}), await n.update(_.tableName, G, { sequence: Y }), X;
+				});
+			});
+		} catch (n) {
+			return y.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, G = (i) => {
+		try {
+			let e = n(i);
+			if (e.type !== "user") throw t("forbidden");
+			let o = r(e.tenantId), s = r(e.id);
+			return E(() => a.transactional(async (e) => {
+				let n = (await e.query(S(_).where(x("id", j(o, s))).forUpdate().limit(1).descriptor))[0];
+				I(n, o, s);
+				let r = await z(e, o, s), i = k();
+				if (!n && r.length !== 0 || r.some((e) => !D.has(String(e.resourceId)))) throw t("invalid_record");
+				return Object.freeze(d.definitions.map((e) => {
+					let n = r.find((t) => t.resourceId === e.id), a = n ? V(n, o, s, e) : {
+						value: e.initial,
+						anchorAt: i
+					};
+					if (a.anchorAt > i) throw t("conflict");
+					let c = f({
+						resource: e,
+						state: a,
+						at: i
+					}, d.strategies.regen), l = c.anchorAt + e.regenEveryMs;
+					return Object.freeze({
+						resourceId: e.id,
+						value: c.value,
+						max: e.max,
+						initialized: n !== void 0,
+						observedAt: i,
+						nextRegenAt: c.value === e.max || !n || l > 864e13 ? null : l,
+						...e.refillOffer === void 0 ? {} : { refillOffer: e.refillOffer }
+					});
+				}));
+			}));
+		} catch (n) {
+			return y.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, K = (n, i) => {
+		try {
+			let e = o(n, [
+				"tenantId",
+				"subjectId",
+				"kind"
+			]), s = r(e.tenantId), c = r(e.subjectId), l = j(s, c);
+			if (e.kind !== "user" && e.kind !== "guest") throw t("forbidden");
+			return E(async () => (await F(s, c), a.transactional(async (e) => {
+				await L(e, s, c, !0);
+				let t = await z(e, s, c), n = await R(e, m, s, l);
+				if (await R(e, h, s, l), await R(e, g, s, l), !i) return {
+					resources: t.map((e) => ({
+						resourceId: e.resourceId,
+						value: String(e.value),
+						anchorAt: T(e.anchorAt)
+					})),
+					movements: n.map((e) => ({
+						resourceId: e.resourceId,
+						kind: e.kind,
+						amount: String(e.amount),
+						regenerated: String(e.regenerated),
+						before: e.before,
+						after: e.after,
+						at: T(e.at)
+					}))
+				};
+				await e.deleteMany(v.tableName, { where: M(s, c) }), await e.updateMany(m.tableName, {
+					ownerId: null,
+					ownerKey: null,
+					before: null,
+					after: null,
+					source: null,
+					origin: null
+				}, { where: N(s, l) }), await e.updateMany(h.tableName, {
+					ownerKey: null,
+					state: "erased",
+					linkedOperationId: null,
+					digest: null,
+					receipt: null
+				}, { where: N(s, l) }), await e.updateMany(g.tableName, {
+					ownerKey: null,
+					source: null,
+					origin: null,
+					digest: null
+				}, { where: N(s, l) }), await e.update(_.tableName, l, {
+					ownerId: null,
+					erased: !0
+				});
+			})));
+		} catch (n) {
+			return y.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, q = (o, u, f, p) => {
+		try {
+			let e = n(o);
+			A(e);
+			let _ = r(u), y = r(f), b = j(_, y);
+			return E(async () => {
+				let e = k();
+				return await F(_, y), a.transactional(async (n) => {
+					let a = await L(n, _, y), o = await R(n, m, _, b), u = await R(n, h, _, b), f = await R(n, g, _, b), x = [...o].sort((e, t) => Number(e.sequence) - Number(t.sequence)), S = /* @__PURE__ */ new Map();
+					if (x.length !== a.sequence || u.filter((e) => e.state === "committed").length !== x.length || f.length !== x.length) throw t("invalid_record");
+					for (let [e, a] of x.entries()) {
+						let o = B(r(a.resourceId));
+						await U(n, _, o);
+						let p = i(a.sequence, 1, 2147483647), m = T(a.at), h = s(a.amount), g = s(a.regenerated);
+						if (p !== e + 1 || a.version !== o.version || a.ownerId !== y || a.id !== w("prm_", r(a.operationId))) throw t("invalid_record");
+						let v = a.before === null ? null : l(a.before, o), b = l(a.after, o), x = S.get(o.id);
+						if (c(v) !== c(x ?? null) || b.anchorAt > m || v && (v.anchorAt > m || b.anchorAt < v.anchorAt)) throw t("invalid_record");
+						let C = v ?? {
+							value: o.initial,
+							anchorAt: m
+						}, E = a.kind;
+						if (E !== "initialize" && E !== "consume" && E !== "grant" || E === "initialize" != (h === 0n) || E === "initialize" && x !== void 0) throw t("invalid_record");
+						let D = BigInt(C.value) + g;
+						if (D > BigInt(o.max) || D < h && E === "consume" || BigInt(b.value) !== D + (E === "grant" ? h : E === "consume" ? -h : 0n)) throw t("invalid_record");
+						let O = u.find((e) => e.id === a.operationId), k = r(a.source), A = r(a.origin), j = c({
+							tenantId: _,
+							ownerId: y,
+							resourceId: o.id,
+							version: o.version,
+							kind: E,
+							amount: String(h),
+							source: k,
+							origin: A
+						});
+						if (!O || O.state !== "committed" || O.linkedOperationId !== null || O.digest !== j || !d.sources.includes(k)) throw t("invalid_record");
+						let M = H(O), N = {
+							operationId: a.operationId,
+							kind: E,
+							resourceId: o.id,
+							amount: String(h),
+							regenerated: String(g),
+							after: b,
+							at: m
+						};
+						if (c(M) !== c(N)) throw t("invalid_record");
+						let P = f.find((e) => e.id === w("prn_", _, y, o.id, E, k, A));
+						if (!P || P.operationId !== a.operationId || P.source !== k || P.origin !== A || P.digest !== j) throw t("invalid_record");
+						S.set(o.id, b);
+					}
+					for (let e of u) if (e.state === "replayed") {
+						let n = u.find((t) => t.id === e.linkedOperationId);
+						if (!n || n.state !== "committed" || e.digest !== n.digest || e.receipt !== null || T(e.at) < T(n.at)) throw t("invalid_record");
+					} else if (e.state !== "committed") throw t("invalid_record");
+					let C = await z(n, _, y), E = /* @__PURE__ */ new Map();
+					for (let e of C) {
+						let n = B(r(e.resourceId));
+						if (E.has(n.id)) throw t("invalid_record");
+						E.set(n.id, V(e, _, y, n));
+					}
+					let D = S.size === E.size && [...S].every(([e, t]) => c(t) === c(E.get(e) ?? null));
+					if (p && !D) {
+						await n.deleteMany(v.tableName, { where: M(_, y) });
+						for (let [e, t] of S) {
+							let r = B(e);
+							await n.insert(v.tableName, {
+								id: w("prv_", _, y, e),
+								tenantId: _,
+								ownerId: y,
+								resourceId: e,
+								version: r.version,
+								value: t.value,
+								anchorAt: new Date(t.anchorAt)
+							});
+						}
+					}
+					return Object.freeze({
+						acceptedOperations: x.length,
+						resources: S.size,
+						matches: p ? !0 : D,
+						at: e
+					});
+				});
+			});
+		} catch (n) {
+			return y.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	};
+	return Object.freeze({
+		initialize: (e, t) => W("initialize", e, t),
+		consume: (e, t) => W("consume", e, t),
+		grant: (e, t) => W("grant", e, t),
+		mine: G,
+		exportSubject: (e) => K(e, !1),
+		eraseSubject: (e) => y.asVoid(K(e, !0)),
+		auditResources: (e, t, n) => q(e, t, n, !1),
+		rebuildResources: (e, t, n) => q(e, t, n, !0)
+	});
+};
+export { D as dataStoreResources, C as resolveResourceOptions };

package/dist/resourceTables.entity.js

@@ -0,0 +1,88 @@
+import { bigint as e, boolean as t, id as n, integer as r, json as i, table as a, text as o, timestamp as s } from "@voltro/database";
+// src/resourceTables.entity.ts
+var c = () => o().maxLength(120).externalId().sensitive("pii"), l = () => o().maxLength(120).externalId().sensitive("pii"), u = () => o().maxLength(64).nullable().serverOnly(), d = a("_voltro_prog_resource_definitions", {
+	id: n({ prefix: "prd" }),
+	tenantId: c(),
+	resourceId: o().maxLength(120).safe(),
+	version: r().safe(),
+	config: i().safe(),
+	rulesVersion: o().maxLength(120).safe(),
+	admission: r().serverOnly()
+}).index("voltro_prog_resource_definitions_version_idx", [
+	"tenantId",
+	"resourceId",
+	"version"
+]), f = a("_voltro_prog_resource_subjects", {
+	id: n({ prefix: "prs" }),
+	tenantId: c(),
+	ownerId: l().nullable(),
+	erased: t().serverOnly(),
+	sequence: r().serverOnly(),
+	admission: r().serverOnly()
+}).index(["tenantId", "ownerId"]), p = a("_voltro_prog_resources", {
+	id: n({ prefix: "prv" }),
+	tenantId: c(),
+	ownerId: l(),
+	resourceId: o().maxLength(120).safe(),
+	version: r().safe(),
+	value: e().safe(),
+	anchorAt: s().safe()
+}).index([
+	"tenantId",
+	"ownerId",
+	"resourceId"
+]), m = a("_voltro_prog_resource_movements", {
+	id: n({ prefix: "prm" }),
+	tenantId: c(),
+	ownerId: l().nullable(),
+	ownerKey: u(),
+	resourceId: o().maxLength(120).safe(),
+	version: r().safe(),
+	operationId: o().maxLength(64).safe(),
+	sequence: r().serverOnly(),
+	kind: o().maxLength(16).oneOf([
+		"initialize",
+		"consume",
+		"grant"
+	]).safe(),
+	amount: e().safe(),
+	regenerated: e().safe(),
+	before: i().nullable().serverOnly(),
+	after: i().nullable().serverOnly(),
+	source: o().maxLength(120).nullable().safe(),
+	origin: o().maxLength(120).nullable().sensitive("pii"),
+	at: s().safe()
+}).index("voltro_prog_resource_movements_owner_idx", [
+	"tenantId",
+	"ownerKey",
+	"resourceId"
+]), h = a("_voltro_prog_resource_operations", {
+	id: n({ prefix: "pro" }),
+	tenantId: c(),
+	ownerKey: u(),
+	state: o().maxLength(16).oneOf([
+		"committed",
+		"replayed",
+		"erased"
+	]).serverOnly(),
+	linkedOperationId: o().maxLength(64).nullable().serverOnly(),
+	digest: o().maxLength(64).nullable().serverOnly(),
+	receipt: i().nullable().serverOnly(),
+	at: s().safe()
+}).index(["tenantId", "ownerKey"]), g = a("_voltro_prog_resource_origins", {
+	id: n({ prefix: "prn" }),
+	tenantId: c(),
+	ownerKey: u(),
+	operationId: o().maxLength(64).safe(),
+	source: o().maxLength(120).nullable().safe(),
+	origin: o().maxLength(120).nullable().sensitive("pii"),
+	digest: o().maxLength(64).nullable().serverOnly()
+}).index(["tenantId", "ownerKey"]), _ = [
+	d,
+	f,
+	p,
+	m,
+	h,
+	g
+];
+export { d as resourceDefinitionsTable, m as resourceMovementsTable, h as resourceOperationsTable, g as resourceOriginsTable, f as resourceSubjectsTable, _ as resourceTables, p as resourcesTable };

package/dist/resources.d.ts

@@ -0,0 +1,105 @@
+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 captureResourceState: (input: unknown, resource: RegenResource) => ResourceState;
+
+export declare const defaultResourceRegen: ResourceRegenResolver;
+
+export declare const defineRegenResource: (input: RegenResourceDefinition | RegenResource) => RegenResource;
+
+export declare type InitializeResourceInput = Omit<ResourceChangeInput, 'amount'>;
+
+export declare interface PlayerResource {
+    readonly resourceId: string;
+    readonly value: string;
+    readonly max: string;
+    readonly initialized: boolean;
+    readonly observedAt: number;
+    readonly nextRegenAt: number | null;
+    readonly refillOffer?: string;
+}
+
+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 ProgressValue = string | number | bigint;
+
+export declare interface RegenResource {
+    readonly id: string;
+    readonly version: number;
+    readonly max: string;
+    readonly initial: string;
+    readonly regenPer: string;
+    readonly regenAmount: string;
+    readonly regenEveryMs: number;
+    readonly refillOffer?: string;
+}
+
+export declare interface RegenResourceDefinition {
+    readonly id: string;
+    readonly version?: number;
+    readonly max: ProgressValue;
+    readonly initial?: ProgressValue;
+    readonly regenPer: string;
+    readonly regenAmount?: ProgressValue;
+    readonly refillOffer?: string;
+}
+
+export declare class RegenResourcePort extends RegenResourcePort_base {
+}
+
+declare const RegenResourcePort_base: Context.ServiceClass<RegenResourcePort, "@voltro/RegenResourcePort", RegenResourceService>;
+
+export declare interface RegenResourceService {
+    readonly initialize: (subject: Subject, input: InitializeResourceInput) => Effect.Effect<ResourceReceipt, ProgressionError>;
+    readonly consume: (subject: Subject, input: ResourceChangeInput) => Effect.Effect<ResourceReceipt, ProgressionError>;
+    readonly grant: (subject: Subject, input: ResourceChangeInput) => Effect.Effect<ResourceReceipt, ProgressionError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly PlayerResource[], ProgressionError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, ProgressionError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, ProgressionError>;
+}
+
+export declare const resolveResourceRegen: (input: ResourceRegenContext, slot?: ResourceRegenResolver) => ResourceState;
+
+export declare interface ResourceChangeInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly resourceId: string;
+    readonly requestId: string;
+    readonly source: string;
+    readonly origin: string;
+    readonly amount: ProgressValue;
+}
+
+export declare interface ResourceReceipt {
+    readonly operationId: string;
+    readonly kind: 'initialize' | 'consume' | 'grant';
+    readonly resourceId: string;
+    readonly amount: string;
+    readonly regenerated: string;
+    readonly after: ResourceState;
+    readonly at: number;
+}
+
+export declare interface ResourceRegenContext {
+    readonly resource: RegenResource;
+    readonly state: ResourceState;
+    readonly at: number;
+}
+
+export declare type ResourceRegenResolver = (input: ResourceRegenContext) => ResourceState;
+
+export declare interface ResourceState {
+    readonly value: string;
+    readonly anchorAt: number;
+}
+
+export { }