@voltro/plugin-inventory 0.0.0-stage → 0.87.0

package/dist/inventoryStore.js

@@ -0,0 +1,1576 @@
+import { InventoryError as e, inventoryError as t } from "./errors.js";
+import { identifier as n, integer as r, jsonData as i, list as a, object as o } from "./capture.js";
+import { captureCraftPayment as s, captureCraftPlan as c, defineRecipe as l, resolveCraftPlan as u, resolveCraftingOptions as d } from "./crafting.js";
+import { captureCatalogItem as f, captureItemContracts as p, validateInstanceAttributes as m } from "./item.js";
+import { captureInventoryReservationTransferInput as h, captureInventoryReserveTransferInput as g, captureReservationItems as _ } from "./reservation.js";
+import { inventoryItemsTable as v, inventoryLedgerTable as y, inventoryLoadoutsTable as b, inventoryOperationsTable as x, inventoryRecipesTable as S, inventorySubjectsTable as C } from "./tables.entity.js";
+import { catalogScope as w, inventoryHash as T, inventoryIo as E, inventoryKey as D } from "./sqlCatalog.js";
+import { defaultExpiryPolicy as O, defaultStackPolicy as k, resolveExpiry as A, resolveStack as ee } from "./strategies.js";
+import { Effect as j, Result as M } from "effect";
+import { and as N, eq as P, inSet as F, queryFor as I } from "@voltro/database";
+import { executeSqlMutations as L, prepareSqlMutation as te, prepareSqlMutationGroup as ne } from "@voltro/database/sql";
+//#region src/inventoryStore.ts
+var R = (e) => {
+	let i = o(e, [
+		"items",
+		"catalogSource",
+		"channel",
+		"locale",
+		"allowedServices",
+		"slotSets",
+		"maxInstances",
+		"maxLedgerRows",
+		"now",
+		"stackPolicy",
+		"expiryPolicy",
+		"crafting"
+	]), s = i.crafting === void 0 ? void 0 : d(i.crafting);
+	if (s?.service) throw t("invalid_input");
+	let c = p(i.items), l = o(i.catalogSource);
+	if (s?.recipes.some((e) => [...e.inputs, ...e.outputs].some((e) => !c.some((t) => t.id === e.itemId)))) throw t("invalid_input");
+	let u = i.now ?? Date.now, f = i.stackPolicy ?? k, m = i.expiryPolicy ?? O;
+	if (s?.version === "default.v1" && (f !== k || m !== O) || typeof l.read != "function" || typeof u != "function" || typeof f != "function" || typeof m != "function") throw t("invalid_input");
+	let h = o(i.slotSets ?? {}), g = Object.create(null);
+	if (Object.keys(h).length > 32) throw t("limit_exceeded");
+	for (let [e, r] of Object.entries(h)) {
+		let i = a(r, 64).map(n);
+		if (i.length === 0 || new Set(i).size !== i.length) throw t("invalid_slot");
+		g[n(e)] = Object.freeze(i);
+	}
+	let _ = a(i.allowedServices ?? [], 256).map(n);
+	if (new Set(_).size !== _.length) throw t("invalid_input");
+	return Object.freeze({
+		items: c,
+		catalogSource: Object.freeze({ read: l.read.bind(i.catalogSource) }),
+		channel: n(i.channel),
+		locale: n(i.locale),
+		slotSets: Object.freeze(g),
+		allowedServices: Object.freeze(_),
+		maxInstances: r(i.maxInstances ?? 4096, 1, 1e4),
+		maxLedgerRows: r(i.maxLedgerRows ?? 1e4, 1, 1e5),
+		crafting: s,
+		now: u,
+		stackPolicy: f,
+		expiryPolicy: m
+	});
+}, z = (e) => {
+	let r = o(e, ["ownerKind", "ownerId"]);
+	if (r.ownerKind !== "player" && r.ownerKind !== "guild") throw t("invalid_input");
+	return Object.freeze({
+		ownerKind: r.ownerKind,
+		ownerId: n(r.ownerId)
+	});
+}, B = (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;
+}, V = (d, p) => {
+	let O = R(p), V = new Set(O.allowedServices), re = () => r(O.now(), 0, 864e13), H = (e) => e.type === "system" || e.type === "service" && V.has(e.service), U = (e) => {
+		if (e.type !== "user") throw t("forbidden");
+		return {
+			tenantId: n(e.tenantId),
+			owner: z({
+				ownerKind: "player",
+				ownerId: e.id
+			})
+		};
+	}, W = (e, t) => D("ivs_", e, t.ownerKind, t.ownerId), ie = (e, t) => N(P("tenantId", e), P("ownerKind", t.ownerKind), P("ownerId", t.ownerId)), G = async (e, t) => {
+		let n = W(e, t);
+		try {
+			await d.insertIgnore(C.tableName, {
+				id: n,
+				tenantId: e,
+				...t,
+				erased: !1,
+				admission: 0,
+				sequence: 0
+			}, { conflictColumns: ["id"] });
+		} catch (e) {
+			if (!(await d.query(I(C).where(P("id", n)).limit(1).descriptor))[0]) throw e;
+		}
+	}, ae = (e, n, r, i = !1) => {
+		if (e) {
+			if (e.tenantId !== n || e.ownerKind !== r.ownerKind) throw t("invalid_record");
+			if (e.erased === !0) {
+				if (i && e.ownerId === null) return;
+				throw t("erased");
+			}
+			if (e.ownerId !== r.ownerId || e.erased !== !1) throw t("invalid_record");
+		}
+	}, K = async (e, n, r, i = !1) => {
+		let a = W(n, r);
+		if (await e.updateMany(C.tableName, { admission: 0 }, { where: P("id", a) }) !== 1) throw t("unavailable");
+		let o = (await e.query(I(C).where(P("id", a)).limit(1).descriptor))[0];
+		if (!o) throw t("invalid_record");
+		return ae(o, n, r, i), o;
+	}, q = async (e, n, r, i, a) => {
+		let o = await e.query(I(n).where(ie(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.ownerKind !== i.ownerKind || e.ownerId !== i.ownerId)) throw t("invalid_record");
+		return o;
+	}, J = (e) => {
+		let a = O.items.find((t) => t.id === e.itemId && t.schemaVersion === e.schemaVersion);
+		if (!a || typeof e.locked != "boolean") throw t("invalid_record");
+		let o = n(e.id), s = r(e.qty, 1, a.maxStack), c = B(e.acquiredAt), l = e.expiresAt === null ? null : B(e.expiresAt);
+		if (!/^ivi_[0-9a-f]{56}$/.test(o) || l !== null && l <= c) throw t("invalid_record");
+		let u = i(e.attributes);
+		return m(a, O.items, u), Object.freeze({
+			id: o,
+			itemId: a.id,
+			schemaVersion: a.schemaVersion,
+			qty: s,
+			attributes: u,
+			acquiredAt: c,
+			expiresAt: l,
+			locked: e.locked,
+			source: n(e.source)
+		});
+	}, oe = (e) => ({
+		id: e.id,
+		itemId: e.itemId,
+		schemaVersion: e.schemaVersion,
+		qty: e.qty,
+		attributes: e.attributes,
+		acquiredAt: new Date(e.acquiredAt),
+		expiresAt: e.expiresAt === null ? null : new Date(e.expiresAt),
+		locked: e.locked,
+		source: e.source
+	}), Y = (e, i) => {
+		let c = o(e.receipt, [
+			"operationId",
+			"kind",
+			"changes",
+			"at"
+		]);
+		if (c.operationId !== e.id || c.kind !== i) throw t("invalid_record");
+		let u = r(c.at, 0, 864e13);
+		if (B(e.createdAt) > u) throw t("invalid_record");
+		let d = a(c.changes, O.maxInstances).map((e) => {
+			let t = o(e, ["instanceId", "delta"]);
+			return Object.freeze({
+				instanceId: n(t.instanceId),
+				delta: r(t.delta, -1e6, 1e6)
+			});
+		});
+		if (new Set(d.map((e) => e.instanceId)).size !== d.length) throw t("invalid_record");
+		if (i === "reserve" || i === "release") {
+			let n = ce(e, i, u);
+			if (d.length !== n.selections.length || d.some((e, t) => e.delta !== 0 || e.instanceId !== n.selections[t]?.instanceId)) throw t("invalid_record");
+		} else if (e.reservation !== null) throw t("invalid_record");
+		if (i === "transfer-out" || i === "transfer-in") {
+			let n = Z(e, i, u);
+			if (d.length !== n.selections.length || d.some((e, t) => {
+				let r = n.selections[t];
+				return !r || e.instanceId !== (i === "transfer-out" ? r.instanceId : r.destinationId) || e.delta !== (i === "transfer-out" ? -r.qty : r.qty);
+			})) throw t("invalid_record");
+		} else if (e.transfer !== null) throw t("invalid_record");
+		if (i === "craft") {
+			let t = o(e.craft, [
+				"intent",
+				"recipe",
+				"version",
+				"batches",
+				"catalogRevision",
+				"excludedIds",
+				"plan",
+				"payment"
+			]);
+			s(t.payment, l(t.recipe), r(t.batches, 1, 1e3));
+		}
+		return Object.freeze({
+			operationId: String(e.id),
+			kind: i,
+			changes: Object.freeze(d),
+			at: u
+		});
+	}, X = (e, t) => D("ivz_", e, t), se = (e, t, n, r) => D("ivo_", e, t.ownerKind, t.ownerId, X(n, r)), ce = (e, i, s) => {
+		let c = o(e.reservation, [
+			"intent",
+			"reservationId",
+			"catalogRevision",
+			"selections"
+		]), l = o(c.intent, [
+			"tenantId",
+			"owner",
+			"requestId",
+			"kind",
+			"payload"
+		]), u = z(l.owner), d = n(l.tenantId), p = n(c.reservationId), m = o(l.payload, i === "reserve" ? ["reservationId", "items"] : ["reservationId"]);
+		if (l.kind !== i || m.reservationId !== p || l.requestId !== X(i, p) || e.id !== se(d, u, i, p) || e.tenantId !== d || e.ownerKey !== W(d, u) || T(l) !== e.digest) throw t("invalid_record");
+		let h = Object.freeze(a(c.selections, 32).map((e) => {
+			let a = o(e, [
+				"instanceId",
+				"qty",
+				"item",
+				"before"
+			]), c = o(a.before, [
+				"id",
+				"itemId",
+				"schemaVersion",
+				"qty",
+				"attributes",
+				"acquiredAt",
+				"expiresAt",
+				"locked",
+				"source"
+			]), l = r(c.acquiredAt, 0, s), u = c.expiresAt === null ? null : r(c.expiresAt, l + 1, 864e13), d = J({
+				...c,
+				acquiredAt: new Date(l),
+				expiresAt: u === null ? null : new Date(u)
+			}), p = f(a.item, O.items), m = n(a.instanceId), h = r(a.qty, 1, d.qty);
+			if (!p.tradable || p.id !== d.itemId || p.schemaVersion !== d.schemaVersion || m !== d.id || d.locked !== (i === "release") || i === "reserve" && d.expiresAt !== null && d.expiresAt <= s) throw t("invalid_record");
+			return Object.freeze({
+				instanceId: m,
+				qty: h,
+				item: p,
+				before: d
+			});
+		})), g = _(h.map((e) => ({
+			instanceId: e.instanceId,
+			qty: e.qty
+		})));
+		if (T(g) !== T(h.map((e) => ({
+			instanceId: e.instanceId,
+			qty: e.qty
+		}))) || i === "reserve" && T(g) !== T(_(m.items))) throw t("invalid_record");
+		let v = i === "reserve" ? n(c.catalogRevision) : c.catalogRevision === null ? null : (() => {
+			throw t("invalid_record");
+		})();
+		return Object.freeze({
+			intent: {
+				tenantId: d,
+				owner: u,
+				requestId: n(l.requestId),
+				kind: i,
+				payload: m
+			},
+			reservationId: p,
+			catalogRevision: v,
+			selections: h
+		});
+	}, le = async (e, n, r, i) => {
+		let a = (await e.query(I(x).where(P("id", se(n, r, "reserve", i))).limit(1).descriptor))[0];
+		if (!a || a.state !== "committed") throw t("not_found");
+		let o = Y(a, "reserve"), s = ce(a, "reserve", o.at);
+		if (s.intent.tenantId !== n || T(s.intent.owner) !== T(r) || s.reservationId !== i) throw t("invalid_record");
+		return {
+			receipt: o,
+			accepted: s
+		};
+	}, ue = async (e, r) => {
+		let { tenantId: i, owner: s, kind: c, payload: l } = e, u = n(l.reservationId);
+		if (c === "release") return d.transactional(async (n) => {
+			await K(n, i, s);
+			let a = await le(n, i, s, u);
+			if (a.receipt.at > r) throw t("invalid_record");
+			let o = (await q(n, v, i, s, O.maxInstances)).map(J), c = Object.freeze(a.accepted.selections.map((e) => {
+				let n = Object.freeze({
+					...e.before,
+					locked: !0
+				}), r = o.find((t) => t.id === e.instanceId);
+				if (!r || T(r) !== T(n)) throw t("conflict");
+				return Object.freeze({
+					...e,
+					before: n
+				});
+			}));
+			return Object.freeze({
+				intent: e,
+				reservationId: u,
+				catalogRevision: null,
+				selections: c
+			});
+		});
+		if (c !== "reserve") throw t("invalid_input");
+		let p = await j.runPromise(j.result(O.catalogSource.read(w({
+			tenantId: i,
+			channel: O.channel,
+			locale: O.locale
+		}))));
+		if (M.isFailure(p)) throw p.failure;
+		let m = o(p.success, ["revision", "items"]), h = n(m.revision), g = a(m.items, 1e4).map((e) => f(e, O.items));
+		if (new Set(g.map((e) => e.id)).size !== g.length) throw t("invalid_record");
+		let y = _(l.items);
+		return d.transactional(async (n) => {
+			await K(n, i, s);
+			let a = (await q(n, v, i, s, O.maxInstances)).map(J), o = await q(n, b, i, s, 2048), c = Object.freeze(y.map((e) => {
+				let n = a.find((t) => t.id === e.instanceId);
+				if (!n) throw t("not_found");
+				if (n.locked || o.some((e) => e.instanceId === n.id)) throw t("locked");
+				if (n.acquiredAt > r || n.expiresAt !== null && n.expiresAt <= r) throw t("expired");
+				if (e.qty > n.qty) throw t("insufficient_items");
+				let i = g.find((e) => e.id === n.itemId && e.schemaVersion === n.schemaVersion);
+				if (!i || !i.tradable) throw t("invalid_item");
+				return Object.freeze({
+					...e,
+					item: i,
+					before: n
+				});
+			}));
+			return Object.freeze({
+				intent: e,
+				reservationId: u,
+				catalogRevision: h,
+				selections: c
+			});
+		});
+	}, de = (e, t, n) => e === "transfer-out" ? D("ivz_", e, t) : D("ivz_", e, t, n), Z = (e, i, s) => {
+		let c = o(e.transfer, ["intent"]), l = o(c.intent, [
+			"tenantId",
+			"owner",
+			"requestId",
+			"kind",
+			"payload"
+		]), u = z(l.owner), d = n(l.tenantId), p = W(d, u), m = o(l.payload, [
+			"reservationId",
+			"peerKey",
+			"peerOperationId",
+			"selections"
+		]), h = n(m.reservationId), g = n(m.peerKey), v = n(m.peerOperationId), y = i === "transfer-out" ? p : g, b = i === "transfer-out" ? g : p;
+		if (!/^ivs_[a-f0-9]{56}$/.test(g) || !/^ivo_[a-f0-9]{56}$/.test(v) || g === p || l.kind !== i || l.requestId !== de(i, h, y) || e.id !== D("ivo_", d, u.ownerKind, u.ownerId, n(l.requestId)) || e.tenantId !== d || e.ownerKey !== p || T(l) !== e.digest) throw t("invalid_record");
+		let x = Object.freeze(a(m.selections, 32).map((e) => {
+			let i = o(e, [
+				"instanceId",
+				"qty",
+				"item",
+				"before",
+				"destinationId"
+			]), a = o(i.before, [
+				"id",
+				"itemId",
+				"schemaVersion",
+				"qty",
+				"attributes",
+				"acquiredAt",
+				"expiresAt",
+				"locked",
+				"source"
+			]), c = r(a.acquiredAt, 0, s), l = a.expiresAt === null ? null : r(a.expiresAt, c + 1, 864e13), u = J({
+				...a,
+				acquiredAt: new Date(c),
+				expiresAt: l === null ? null : new Date(l)
+			}), p = f(i.item, O.items), m = r(i.qty, 1, u.qty), g = n(i.instanceId), _ = n(i.destinationId), v = m === u.qty ? u.id : D("ivi_", "reservation.transfer", d, h, y, b, u.id);
+			if (g !== u.id || _ !== v || !u.locked || !p.tradable || p.id !== u.itemId || p.schemaVersion !== u.schemaVersion || u.expiresAt !== null && u.expiresAt <= s) throw t("invalid_record");
+			return Object.freeze({
+				instanceId: g,
+				qty: m,
+				item: p,
+				before: u,
+				destinationId: _
+			});
+		})), S = _(x.map((e) => ({
+			instanceId: e.instanceId,
+			qty: e.qty
+		})));
+		if (T(S) !== T(x.map((e) => ({
+			instanceId: e.instanceId,
+			qty: e.qty
+		}))) || new Set(x.map((e) => e.destinationId)).size !== x.length) throw t("invalid_record");
+		return Object.freeze({
+			intent: {
+				tenantId: d,
+				owner: u,
+				requestId: n(l.requestId),
+				kind: i,
+				payload: m
+			},
+			reservationId: h,
+			peerKey: g,
+			peerOperationId: v,
+			selections: x
+		});
+	}, fe = (e) => e.map((e) => ({
+		instanceId: e.instanceId,
+		qty: e.qty,
+		item: e.item,
+		before: e.before
+	})), pe = (e) => Object.freeze({
+		...e.before,
+		id: e.destinationId,
+		qty: e.qty,
+		locked: !1
+	}), me = async (e, n, r) => {
+		let i = n.intent.kind;
+		if (i !== "transfer-out" && i !== "transfer-in") throw t("invalid_record");
+		let a = i === "transfer-out" ? "transfer-in" : "transfer-out", o = (await e.query(I(x).where(P("id", n.peerOperationId)).limit(1).descriptor))[0];
+		if (!o || o.tenantId !== n.intent.tenantId || o.state !== "committed" && o.state !== "erased" || o.state === "committed" && o.ownerKey !== n.peerKey || o.state === "erased" && (o.ownerKey !== null || o.receipt !== null || o.transfer !== null || o.digest !== null)) throw t("invalid_record");
+		let s, c = null;
+		if (o.state === "committed") {
+			let e = Y(o, a), l = Z(o, a, e.at);
+			s = e.at, c = e;
+			let u = D("ivo_", n.intent.tenantId, n.intent.owner.ownerKind, n.intent.owner.ownerId, n.intent.requestId);
+			if (l.reservationId !== n.reservationId || l.peerOperationId !== u || l.peerKey !== W(n.intent.tenantId, n.intent.owner) || T(l.selections) !== T(n.selections) || (i === "transfer-out" ? e.at < r : e.at > r)) throw t("invalid_record");
+		}
+		let l = await e.query(I(y).where(N(P("tenantId", n.intent.tenantId), P("operationId", n.peerOperationId))).limit(33).descriptor);
+		if (l.length !== n.selections.length || !Number.isSafeInteger(o.sequence)) throw t("invalid_record");
+		for (let [e, r] of n.selections.entries()) {
+			let i = l.find((t) => t.id === D("ivg_", n.peerOperationId, String(e))), c = a === "transfer-out" ? r.instanceId : r.destinationId, u = a === "transfer-out" ? -r.qty : r.qty, d = a === "transfer-in" ? pe(r) : r.qty === r.before.qty ? null : Object.freeze({
+				...r.before,
+				qty: r.before.qty - r.qty,
+				locked: !1
+			});
+			if (!i || i.operationId !== n.peerOperationId || i.sequence !== o.sequence || i.itemId !== r.before.itemId || i.delta !== u || o.state === "committed" && (i.instanceId !== c || i.reason !== "transferred" || i.refKind !== "inventory.reservation" || i.refId !== n.reservationId || B(i.at) !== s || T(i.after) !== T(d)) || o.state === "erased" && (i.instanceId !== null || i.after !== null || i.actor !== null || i.refId !== null || i.refKind !== null || i.ownerId !== null || i.ownerKind !== null)) throw t("invalid_record");
+		}
+		return c;
+	}, he = (e) => e.map((e) => ({
+		id: n(e.id),
+		slotSet: n(e.slotSet),
+		slot: n(e.slot),
+		instanceId: n(e.instanceId)
+	})), ge = (e, t) => D("ivr_", e, t.id, String(t.version)), _e = async (e, n, r, i) => {
+		let a = (await e.query(I(S).where(P("id", ge(n, r))).limit(1).descriptor))[0];
+		if (!a || a.tenantId !== n || a.recipeId !== r.id || a.version !== r.version || a.rulesVersion !== i || T(a.definition) !== T(r)) throw t("conflict");
+	}, ve = async (e, i) => {
+		let { tenantId: s, owner: c, payload: p } = e, h = l(p.recipe), g = n(p.version), _ = r(p.batches, 1, h.maxBatches);
+		if (!O.crafting) throw t("unavailable");
+		await d.insertIgnore(S.tableName, {
+			id: ge(s, h),
+			tenantId: s,
+			recipeId: h.id,
+			version: h.version,
+			definition: h,
+			rulesVersion: g
+		}, { conflictColumns: ["id"] }), await _e(d, s, h, g);
+		let y = await j.runPromise(j.result(O.catalogSource.read(w({
+			tenantId: s,
+			channel: O.channel,
+			locale: O.locale
+		}))));
+		if (M.isFailure(y)) throw y.failure;
+		let x = o(y.success, ["revision", "items"]), C = n(x.revision), E = a(x.items, 1e4).map((e) => f(e, O.items));
+		if (new Set(E.map((e) => e.id)).size !== E.length) throw t("invalid_record");
+		let k = await d.transactional(async (e) => {
+			let t = await K(e, s, c), n = await q(e, v, s, c, O.maxInstances), i = he(await q(e, b, s, c, 2048));
+			return {
+				owned: n.map(J),
+				slots: i,
+				sequence: r(t.sequence, 0, 2147483646)
+			};
+		});
+		if (k.owned.some((e) => e.acquiredAt > i)) throw t("invalid_record");
+		let N = Object.freeze([...new Set(k.slots.map((e) => e.instanceId))]), P = u({
+			recipe: h,
+			batches: _,
+			at: i,
+			available: k.owned,
+			excludedIds: N
+		}, O.crafting.craftResolver), F = [], I = new Set(P.consume.map((e) => e.instanceId)), L = new Map(k.owned.map((e) => [e.id, e])), te = [], ne = D("ivo_", s, c.ownerKind, c.ownerId, e.requestId);
+		for (let e of P.consume) {
+			let t = L.get(e.instanceId), n = t.qty === e.qty ? null : Object.freeze({
+				...t,
+				qty: t.qty - e.qty
+			});
+			F.push({
+				instanceId: t.id,
+				delta: -e.qty,
+				after: n
+			}), n ? L.set(t.id, n) : L.delete(t.id);
+		}
+		for (let [e, n] of P.outputs.entries()) {
+			let r = E.find((e) => e.id === n.itemId);
+			if (!r) throw t("not_found");
+			let a = m(r, O.items, n.attributes === void 0 ? r.instanceDefaults : n.attributes), o = A({
+				item: r,
+				acquiredAt: i
+			}, O.expiryPolicy);
+			te.push(Object.freeze({
+				itemId: n.itemId,
+				qty: n.qty,
+				attributes: a
+			}));
+			let s = [...L.values()].filter((e) => !I.has(e.id) && e.itemId === r.id && e.schemaVersion === r.schemaVersion && !e.locked && e.expiresAt === o && (e.expiresAt === null || e.expiresAt > i) && T(e.attributes) === T(a)), c = ee({
+				item: r,
+				quantity: n.qty,
+				available: s.map((e) => ({
+					id: e.id,
+					quantity: e.qty
+				}))
+			}, O.stackPolicy);
+			for (let e of c.existing) {
+				let t = L.get(e.id), n = Object.freeze({
+					...t,
+					qty: t.qty + e.add
+				});
+				F.push({
+					instanceId: t.id,
+					delta: e.add,
+					after: n
+				}), L.set(t.id, n);
+			}
+			for (let [n, s] of c.create.entries()) {
+				let c = D("ivi_", ne, "craft", String(e), String(n)), l = Object.freeze({
+					id: c,
+					itemId: r.id,
+					schemaVersion: r.schemaVersion,
+					qty: s,
+					attributes: a,
+					acquiredAt: i,
+					expiresAt: o,
+					locked: !1,
+					source: "crafted"
+				});
+				if (L.has(c)) throw t("invalid_record");
+				F.push({
+					instanceId: c,
+					delta: s,
+					after: l
+				}), L.set(c, l);
+			}
+		}
+		if (L.size > O.maxInstances || new Set(F.map((e) => e.instanceId)).size !== F.length) throw t("limit_exceeded");
+		return {
+			sequence: k.sequence,
+			basis: T({
+				owned: k.owned,
+				slots: k.slots
+			}),
+			changes: F,
+			accepted: {
+				intent: e,
+				recipe: h,
+				version: g,
+				batches: _,
+				catalogRevision: C,
+				excludedIds: N,
+				payment: null,
+				plan: {
+					consume: P.consume,
+					outputs: te
+				}
+			}
+		};
+	}, Q = (e, i) => {
+		let { tenantId: c, owner: u, requestId: p, kind: h, payload: g } = i, _ = D("ivo_", c, u.ownerKind, u.ownerId, p), S = T(i);
+		return E(async () => {
+			await G(c, u);
+			let E = (await d.transactional(async (e) => {
+				await K(e, c, u);
+				let n = (await e.query(I(x).where(P("id", _)).limit(1).descriptor))[0];
+				if (n?.state === "committed") {
+					if (n.tenantId !== c || n.ownerKey !== W(c, u) || n.digest !== S) throw t("conflict");
+					return Y(n, h);
+				}
+			}))?.at ?? re(), F = await d.transactional(async (e) => {
+				await K(e, c, u);
+				let n = (await e.query(I(x).where(P("id", _)).limit(1).descriptor))[0];
+				if (n) {
+					if (n.tenantId !== c || n.ownerKey !== W(c, u)) throw t("invalid_record");
+					if (n.state === "committed" && n.digest !== S) throw t("conflict");
+					return n;
+				}
+				if ((await e.query(I(x).where(N(P("tenantId", c), P("ownerKey", W(c, u)))).limit(O.maxLedgerRows + 1).descriptor)).length >= O.maxLedgerRows) throw t("limit_exceeded");
+				let r = {
+					id: _,
+					tenantId: c,
+					ownerKey: W(c, u),
+					sequence: null,
+					state: "pending",
+					digest: null,
+					receipt: null,
+					craft: null,
+					reservation: null,
+					transfer: null,
+					admission: 0,
+					createdAt: new Date(E)
+				};
+				return await e.insert(x.tableName, r), r;
+			}), L;
+			if (h === "grant" && F?.state !== "committed") {
+				let e = await j.runPromise(j.result(O.catalogSource.read(w({
+					tenantId: c,
+					channel: O.channel,
+					locale: O.locale
+				}))));
+				if (M.isFailure(e)) throw e.failure;
+				let r = o(e.success, ["revision", "items"]);
+				n(r.revision);
+				let i = a(r.items, 1e4).map((e) => f(e, O.items));
+				if (new Set(i.map((e) => e.id)).size !== i.length) throw t("invalid_record");
+				if (L = i.find((e) => e.id === g.itemId), !L) throw t("not_found");
+			}
+			let R;
+			if (h === "grant" && F.state !== "committed") {
+				if (!L) throw t("unavailable");
+				let e = m(L, O.items, g.attributes === void 0 ? L.instanceDefaults : g.attributes), n = A({
+					item: L,
+					acquiredAt: E
+				}, O.expiryPolicy);
+				if (O.stackPolicy === k) R = Object.freeze({
+					attributes: e,
+					expiresAt: n
+				});
+				else {
+					let i = await d.transactional(async (e) => (await K(e, c, u), (await q(e, v, c, u, O.maxInstances)).map(J)));
+					if (i.some((e) => e.acquiredAt > E)) throw t("invalid_record");
+					let a = i.filter((t) => t.itemId === L.id && t.schemaVersion === L.schemaVersion && !t.locked && t.expiresAt === n && (t.expiresAt === null || t.expiresAt > E) && T(t.attributes) === T(e)), o = ee({
+						item: L,
+						quantity: r(g.qty, 1, 1e6),
+						available: a.map((e) => ({
+							id: e.id,
+							quantity: e.qty
+						}))
+					}, O.stackPolicy);
+					R = Object.freeze({
+						attributes: e,
+						expiresAt: n,
+						basis: T(i),
+						stack: o
+					});
+				}
+			}
+			let z = (e) => e().catch(async (e) => {
+				if ((await d.transactional(async (e) => (await K(e, c, u), (await e.query(I(x).where(P("id", _)).limit(1).descriptor))[0])))?.state !== "committed") throw e;
+			}), V = h === "craft" && F.state !== "committed" ? await z(() => ve(i, E)) : void 0, H = (h === "reserve" || h === "release") && F.state !== "committed" ? await z(() => ue(i, E)) : void 0, U = (h === "transfer-out" || h === "transfer-in") && F.state !== "committed" ? Z({
+				id: _,
+				tenantId: c,
+				ownerKey: W(c, u),
+				digest: S,
+				transfer: { intent: i }
+			}, h, E) : void 0, ae = te(d, async (i) => {
+				let a = await K(i, c, u);
+				if (await i.updateMany(x.tableName, { admission: 0 }, { where: P("id", _) }) !== 1) throw t("unavailable");
+				let s = (await i.query(I(x).where(P("id", _)).limit(1).descriptor))[0];
+				if (!s || s.tenantId !== c || s.ownerKey !== W(c, u)) throw t("invalid_record");
+				if (s.state === "erased") throw t("erased");
+				if (s.state === "committed") {
+					if (s.digest !== S) throw t("conflict");
+					return Y(s, h);
+				}
+				if (s.state !== "pending" || s.sequence !== null || s.digest !== null || s.receipt !== null || B(s.createdAt) > E) throw t("invalid_record");
+				let d = r(a.sequence, 0, 2147483646) + 1;
+				if ((await i.query(I(y).where(N(P("tenantId", c), P("operationId", _))).limit(1).descriptor)).length) throw t("invalid_record");
+				let f = await q(i, v, c, u, O.maxInstances), p = f.map(J);
+				if (p.some((e) => e.acquiredAt > E)) throw t("invalid_record");
+				if ((await i.query(I(x).where(N(P("tenantId", c), P("ownerKey", W(c, u)))).limit(O.maxLedgerRows + 1).descriptor)).length > O.maxLedgerRows) throw t("limit_exceeded");
+				let m = await q(i, y, c, u, O.maxLedgerRows), w = [], k = h === "transfer-out" || h === "transfer-in" ? "transferred" : h === "reserve" ? "reserved" : h === "release" ? "released" : h === "craft" ? "crafted" : h === "grant" || h === "consume" ? n(g.reason) : h === "expire" ? "expired" : "equipped", A = h === "reserve" || h === "release" || h === "transfer-out" || h === "transfer-in" ? {
+					kind: "inventory.reservation",
+					id: n(g.reservationId)
+				} : h === "craft" ? {
+					kind: "recipe",
+					id: n(o(g.recipe).id)
+				} : h === "grant" || h === "consume" ? o(g.ref, ["kind", "id"]) : null;
+				if (h === "transfer-out" || h === "transfer-in") {
+					if (!U) throw t("unavailable");
+					if (h === "transfer-out") {
+						let e = await le(i, c, u, U.reservationId);
+						if (e.receipt.at > E || T(e.accepted.selections.map((e) => ({
+							...e,
+							before: {
+								...e.before,
+								locked: !0
+							}
+						}))) !== T(fe(U.selections)) || (await i.query(I(x).where(P("id", se(c, u, "release", U.reservationId))).limit(1).descriptor))[0]?.state === "committed") throw t("conflict");
+						let n = await q(i, b, c, u, 2048);
+						for (let e of U.selections) {
+							let r = p.find((t) => t.id === e.instanceId);
+							if (!r || T(r) !== T(e.before) || n.some((e) => e.instanceId === r.id)) throw t("conflict");
+							w.push({
+								instanceId: r.id,
+								delta: -e.qty,
+								after: r.qty === e.qty ? null : Object.freeze({
+									...r,
+									qty: r.qty - e.qty,
+									locked: !1
+								})
+							});
+						}
+					} else {
+						if (await me(i, U, E), p.length + U.selections.length > O.maxInstances) throw t("limit_exceeded");
+						for (let e of U.selections) {
+							if ((await i.query(I(v).where(P("id", e.destinationId)).limit(1).descriptor))[0]) throw t("conflict");
+							w.push({
+								instanceId: e.destinationId,
+								delta: e.qty,
+								after: pe(e)
+							});
+						}
+					}
+				} else if (h === "reserve" || h === "release") {
+					if (!H) throw t("unavailable");
+					if (h === "release") {
+						let e = await le(i, c, u, H.reservationId);
+						if (e.receipt.at > E || T(e.accepted.selections.map((e) => ({
+							...e,
+							before: {
+								...e.before,
+								locked: !0
+							}
+						}))) !== T(H.selections)) throw t("conflict");
+					}
+					let e = await q(i, b, c, u, 2048);
+					for (let n of H.selections) {
+						let r = p.find((e) => e.id === n.instanceId);
+						if (!r || T(r) !== T(n.before) || e.some((e) => e.instanceId === n.instanceId)) throw t("conflict");
+						if (h === "reserve" && r.expiresAt !== null && r.expiresAt <= E) throw t("expired");
+						w.push({
+							instanceId: r.id,
+							delta: 0,
+							after: Object.freeze({
+								...r,
+								locked: h === "reserve"
+							})
+						});
+					}
+				} else if (h === "craft") {
+					if (!V || V.sequence !== a.sequence || V.basis !== T({
+						owned: p,
+						slots: he(await q(i, b, c, u, 2048))
+					})) throw t("conflict");
+					await _e(i, c, l(g.recipe), n(g.version)), w.push(...V.changes);
+				} else if (h === "grant") {
+					if (!L || !R) throw t("unavailable");
+					if (R.basis !== void 0 && R.basis !== T(p)) throw t("conflict");
+					let { attributes: e, expiresAt: n } = R, i = p.filter((t) => t.itemId === L?.id && t.schemaVersion === L.schemaVersion && !t.locked && t.expiresAt === n && (t.expiresAt === null || t.expiresAt > E) && T(t.attributes) === T(e)), a = R.stack ?? ee({
+						item: L,
+						quantity: r(g.qty, 1, 1e6),
+						available: i.map((e) => ({
+							id: e.id,
+							quantity: e.qty
+						}))
+					});
+					if (p.length + a.create.length > O.maxInstances) throw t("limit_exceeded");
+					for (let e of a.existing) {
+						let n = p.find((t) => t.id === e.id);
+						if (!n) throw t("invalid_record");
+						w.push({
+							instanceId: e.id,
+							delta: e.add,
+							after: Object.freeze({
+								...n,
+								qty: n.qty + e.add
+							})
+						});
+					}
+					for (let [t, r] of a.create.entries()) {
+						let i = D("ivi_", _, String(t));
+						w.push({
+							instanceId: i,
+							delta: r,
+							after: Object.freeze({
+								id: i,
+								itemId: L.id,
+								schemaVersion: L.schemaVersion,
+								qty: r,
+								attributes: e,
+								acquiredAt: E,
+								expiresAt: n,
+								locked: !1,
+								source: k
+							})
+						});
+					}
+				} else if (h === "consume") {
+					let e = p.find((e) => e.id === g.instanceId);
+					if (!e) throw t("not_found");
+					if (e.locked) throw t("locked");
+					if (e.expiresAt !== null && e.expiresAt <= E) throw t("expired");
+					let n = r(g.qty, 1, 1e6);
+					if (n > e.qty) throw t("insufficient_items");
+					w.push({
+						instanceId: e.id,
+						delta: -n,
+						after: e.qty === n ? null : Object.freeze({
+							...e,
+							qty: e.qty - n
+						})
+					});
+				} else if (h === "expire") {
+					let e = r(g.until, 0, E);
+					for (let n of p) if (n.expiresAt !== null && n.expiresAt <= e) {
+						if (n.locked) throw t("locked");
+						w.push({
+							instanceId: n.id,
+							delta: -n.qty,
+							after: null
+						});
+					}
+				} else {
+					let e = n(g.slotSet), r = n(g.slot), a = g.instanceId;
+					if (!O.slotSets[e]?.includes(r)) throw t("invalid_slot");
+					let o = D("ivl_", c, u.ownerKind, u.ownerId, e, r), s = (await i.query(I(b).where(P("id", o)).limit(1).descriptor))[0];
+					if (s && (s.tenantId !== c || s.ownerKind !== u.ownerKind || s.ownerId !== u.ownerId || s.slotSet !== e || s.slot !== r)) throw t("invalid_record");
+					if (a === null) {
+						if (s) {
+							let e = p.find((e) => e.id === s.instanceId);
+							if (!e) throw t("invalid_record");
+							await i.delete(b.tableName, o), w.push({
+								instanceId: e.id,
+								delta: 0,
+								after: e
+							});
+						}
+					} else {
+						let n = p.find((e) => e.id === a);
+						if (!n) throw t("not_found");
+						if (n.locked) throw t("locked");
+						if (n.expiresAt !== null && n.expiresAt <= E) throw t("expired");
+						if (O.items.find((e) => e.id === n.itemId && e.schemaVersion === n.schemaVersion)?.equipSlot !== r) throw t("invalid_slot");
+						s ? await i.update(b.tableName, o, { instanceId: n.id }) : await i.insert(b.tableName, {
+							id: o,
+							tenantId: c,
+							...u,
+							slotSet: e,
+							slot: r,
+							instanceId: n.id
+						}), w.push({
+							instanceId: n.id,
+							delta: 0,
+							after: n
+						});
+					}
+				}
+				if (m.length + w.length > O.maxLedgerRows) throw t("limit_exceeded");
+				for (let [r, a] of w.entries()) {
+					let o = f.find((e) => e.id === a.instanceId);
+					if (h !== "equip") {
+						if (a.after === null) {
+							if (!o) throw t("invalid_record");
+							await i.delete(v.tableName, a.instanceId), await i.deleteMany(b.tableName, { where: N(ie(c, u), P("instanceId", a.instanceId)) });
+						} else o ? await i.update(v.tableName, a.instanceId, oe(a.after)) : await i.insert(v.tableName, {
+							tenantId: c,
+							...u,
+							...oe(a.after)
+						});
+					}
+					let s = a.after?.itemId ?? n(o?.itemId);
+					await i.insert(y.tableName, {
+						id: D("ivg_", _, String(r)),
+						tenantId: c,
+						...u,
+						operationId: _,
+						sequence: d,
+						instanceId: a.instanceId,
+						itemId: s,
+						delta: a.delta,
+						after: a.after,
+						reason: k,
+						refKind: A ? n(A.kind) : null,
+						refId: A ? n(A.id) : null,
+						actor: n(e.id),
+						at: new Date(E)
+					});
+				}
+				let j = Object.freeze({
+					operationId: _,
+					kind: h,
+					changes: Object.freeze(w.map(({ instanceId: e, delta: t }) => Object.freeze({
+						instanceId: e,
+						delta: t
+					}))),
+					at: E
+				});
+				return await i.update(x.tableName, _, {
+					state: "committed",
+					sequence: d,
+					digest: S,
+					receipt: j,
+					craft: V?.accepted ?? null,
+					reservation: H ?? null,
+					transfer: U ? { intent: U.intent } : null
+				}), await i.update(C.tableName, W(c, u), { sequence: d }), j;
+			}), X = h === "craft" ? l(g.recipe) : void 0;
+			if (X?.cost && F.state !== "committed") {
+				let n = O.crafting?.economy;
+				if (!n || !V) throw t("unavailable");
+				let i = r(g.batches, 1, X.maxBatches), a = await j.runPromise(j.result(n.prepareTransfer(e, {
+					tenantId: c,
+					requestId: D("ivc_", c, u.ownerKind, u.ownerId, p),
+					currency: X.cost.currency,
+					amount: (BigInt(X.cost.amount) * BigInt(i)).toString(),
+					from: {
+						kind: "wallet",
+						...u
+					},
+					to: {
+						kind: "system",
+						id: O.crafting.systemAccount
+					},
+					reason: "crafting.cost",
+					ref: {
+						kind: "inventory.craft",
+						id: _
+					}
+				})));
+				if (M.isFailure(a)) throw t(a.failure.code === "insufficient_funds" ? "insufficient_funds" : "payment_refused");
+				return ne(d, [a.success, ae], async (e, [n, r]) => {
+					let a = s(n, X, i), c = (await e.query(I(x).where(P("id", _)).limit(1).descriptor))[0];
+					if (!c || c.state !== "committed" || c.digest !== S) throw t("invalid_record");
+					let l = o(c.craft, [
+						"intent",
+						"recipe",
+						"version",
+						"batches",
+						"catalogRevision",
+						"excludedIds",
+						"plan",
+						"payment"
+					]);
+					if (l.payment !== null) {
+						if (T(s(l.payment, X, i)) !== T(a)) throw t("conflict");
+					} else {
+						if (T(l) !== T(V.accepted)) throw t("invalid_record");
+						await e.update(x.tableName, _, { craft: {
+							...l,
+							payment: a
+						} });
+					}
+					return r;
+				});
+			}
+			return ae;
+		});
+	}, ye = (n, r) => j.flatMap(Q(n, r), (n) => j.tryPromise({
+		try: async () => (await L(d, [n]))[0],
+		catch: (n) => {
+			if (n instanceof e) return n;
+			if (r.kind !== "craft" || !o(r.payload.recipe).cost) return t("unavailable");
+			let i = typeof n == "object" && n ? Object.getOwnPropertyDescriptor(n, "code") : void 0;
+			return t(i && "value" in i && i.value === "insufficient_funds" ? "insufficient_funds" : "payment_refused");
+		}
+	})), $ = (n) => {
+		try {
+			return n();
+		} catch (n) {
+			return j.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, be = (e, r) => $(() => {
+		let i = structuredClone(e), { tenantId: a, owner: o } = U(i), s = r === void 0 ? void 0 : n(r);
+		if (s !== void 0 && !O.slotSets[s]) throw t("invalid_slot");
+		return E(async () => {
+			let e = re(), r = (await d.query(I(C).where(P("id", W(a, o))).limit(1).descriptor))[0];
+			ae(r, a, o);
+			let i = (await q(d, v, a, o, O.maxInstances)).map(J).filter((t) => t.expiresAt === null || t.expiresAt > e);
+			if (s === void 0) return Object.freeze(i);
+			let c = await q(d, b, a, o, 2048);
+			return Object.freeze(c.filter((e) => e.slotSet === s).flatMap((e) => {
+				let r = n(e.slot), c = n(e.instanceId), l = i.find((e) => e.id === c);
+				if (!O.slotSets[s]?.includes(r) || e.id !== D("ivl_", a, o.ownerKind, o.ownerId, s, r)) throw t("invalid_record");
+				if (!l) return [];
+				if (O.items.find((e) => e.id === l.itemId && e.schemaVersion === l.schemaVersion)?.equipSlot !== r) throw t("invalid_record");
+				return [Object.freeze({
+					slotSet: s,
+					slot: r,
+					instanceId: c
+				})];
+			}));
+		});
+	}), xe = (e) => {
+		let r = o(e, [
+			"subjectId",
+			"tenantId",
+			"kind"
+		]);
+		if (r.kind !== "user" && r.kind !== "guest") throw t("forbidden");
+		return {
+			tenantId: n(r.tenantId),
+			owner: z({
+				ownerKind: "player",
+				ownerId: r.subjectId
+			})
+		};
+	}, Se = (e, i, u, f) => $(() => {
+		let p = structuredClone(e), m = n(i), h = z(u);
+		if (!H(p)) throw t("forbidden");
+		return E(async () => (await G(m, h), d.transactional(async (e) => {
+			let i = await K(e, m, h), u = await q(e, y, m, h, O.maxLedgerRows), d = await e.query(I(x).where(N(P("tenantId", m), P("ownerKey", W(m, h)))).limit(O.maxLedgerRows + 1).descriptor);
+			if (d.length > O.maxLedgerRows) throw t("limit_exceeded");
+			let p = d.filter((e) => e.state === "committed").sort((e, t) => Number(e.sequence) - Number(t.sequence)), g = new Set(p.map((e) => e.id)), _ = /* @__PURE__ */ new Map();
+			for (let e of u) {
+				if (!g.has(e.operationId)) throw t("invalid_record");
+				let n = _.get(e.operationId) ?? /* @__PURE__ */ new Map();
+				if (n.has(e.id)) throw t("invalid_record");
+				n.set(e.id, e), _.set(e.operationId, n);
+			}
+			if (p.length !== r(i.sequence, 0, 2147483647)) throw t("invalid_record");
+			let S = /* @__PURE__ */ new Map(), C = /* @__PURE__ */ new Set(), w = /* @__PURE__ */ new Map();
+			for (let [i, u] of p.entries()) {
+				if (u.sequence !== i + 1 || u.tenantId !== m || u.ownerKey !== W(m, h) || typeof u.digest != "string" || !/^[0-9a-f]{64}$/.test(u.digest)) throw t("invalid_record");
+				let d = o(u.receipt, [
+					"operationId",
+					"kind",
+					"changes",
+					"at"
+				]);
+				if (d.kind !== "grant" && d.kind !== "consume" && d.kind !== "equip" && d.kind !== "expire" && d.kind !== "craft" && d.kind !== "reserve" && d.kind !== "release" && d.kind !== "transfer-out" && d.kind !== "transfer-in") throw t("invalid_record");
+				let f = Y(u, d.kind), p = _.get(u.id) ?? /* @__PURE__ */ new Map();
+				if (p.size !== f.changes.length) throw t("invalid_record");
+				if (f.kind === "craft") {
+					let i = o(u.craft, [
+						"intent",
+						"recipe",
+						"version",
+						"batches",
+						"catalogRevision",
+						"excludedIds",
+						"plan",
+						"payment"
+					]), d = l(i.recipe), g = n(i.version), _ = r(i.batches, 1, d.maxBatches), v = Object.freeze(a(i.excludedIds, 2048).map(n)), y = o(i.intent, [
+						"tenantId",
+						"owner",
+						"requestId",
+						"kind",
+						"payload"
+					]), b = o(y.payload, [
+						"recipe",
+						"version",
+						"batches"
+					]);
+					n(i.catalogRevision);
+					let x = s(i.payment, d, _);
+					if (x) {
+						if (C.has(x.txId)) throw t("invalid_record");
+						C.add(x.txId);
+					}
+					if (y.tenantId !== m || T(z(y.owner)) !== T(h) || y.kind !== "craft" || D("ivo_", m, h.ownerKind, h.ownerId, n(y.requestId)) !== u.id || T(y) !== u.digest || b.batches !== _ || b.version !== g || T(b.recipe) !== T(d) || v.some((e) => !S.has(e))) throw t("invalid_record");
+					await _e(e, m, d, g);
+					let w = c(i.plan, {
+						recipe: d,
+						batches: _,
+						at: f.at,
+						available: [...S.values()],
+						excludedIds: v
+					}), E = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Set();
+					for (let e of p.values()) {
+						if (e.reason !== "crafted" || e.refKind !== "recipe" || e.refId !== d.id) throw t("invalid_record");
+						let i = r(e.delta, -1e6, 1e6), a = n(e.instanceId);
+						if (i < 0) {
+							let e = w.consume.find((e) => e.instanceId === a);
+							if (!e || -i !== e.qty || O.has(a)) throw t("invalid_record");
+							O.add(a);
+						} else {
+							let n = w.outputs.find((t) => t.itemId === e.itemId);
+							if (!i || !n || w.consume.some((e) => e.instanceId === a) || T(o(e.after).attributes) !== T(n.attributes)) throw t("invalid_record");
+							E.set(n.itemId, (E.get(n.itemId) ?? 0) + i);
+						}
+					}
+					if (O.size !== w.consume.length || w.outputs.some((e) => E.get(e.itemId) !== e.qty)) throw t("invalid_record");
+				} else if (u.craft !== null) throw t("invalid_record");
+				if (f.kind === "reserve" || f.kind === "release") {
+					let e = ce(u, f.kind, f.at), n = w.get(e.reservationId);
+					if (e.selections.length !== f.changes.length) throw t("invalid_record");
+					if (f.kind === "reserve") {
+						if (n) throw t("invalid_record");
+						w.set(e.reservationId, {
+							admission: e,
+							at: f.at,
+							released: !1
+						});
+					} else {
+						if (!n || n.released || n.at > f.at || T(n.admission.selections.map((e) => ({
+							...e,
+							before: {
+								...e.before,
+								locked: !0
+							}
+						}))) !== T(e.selections)) throw t("invalid_record");
+						n.released = !0;
+					}
+					for (let [n, r] of e.selections.entries()) {
+						let i = S.get(r.instanceId), a = f.changes[n], o = p.get(D("ivg_", f.operationId, String(n)));
+						if (!i || T(i) !== T(r.before) || a?.instanceId !== r.instanceId || a.delta !== 0 || !o || o.reason !== (f.kind === "reserve" ? "reserved" : "released") || o.refKind !== "inventory.reservation" || o.refId !== e.reservationId) throw t("invalid_record");
+					}
+				}
+				let g = f.kind === "transfer-out" || f.kind === "transfer-in" ? Z(u, f.kind, f.at) : void 0;
+				if (g) {
+					if (await me(e, g, f.at), f.kind === "transfer-out") {
+						let e = w.get(g.reservationId);
+						if (!e || e.released || e.at > f.at || T(e.admission.selections.map((e) => ({
+							...e,
+							before: {
+								...e.before,
+								locked: !0
+							}
+						}))) !== T(fe(g.selections))) throw t("invalid_record");
+						e.released = !0;
+					}
+					for (let [e, n] of g.selections.entries()) {
+						let r = S.get(f.kind === "transfer-out" ? n.instanceId : n.destinationId), i = p.get(D("ivg_", f.operationId, String(e)));
+						if ((f.kind === "transfer-out" ? !r || T(r) !== T(n.before) : r !== void 0) || !i || i.reason !== "transferred" || i.refKind !== "inventory.reservation" || i.refId !== g.reservationId) throw t("invalid_record");
+					}
+				}
+				for (let [e, n] of f.changes.entries()) {
+					let i = p.get(D("ivg_", f.operationId, String(e)));
+					if (!i || i.sequence !== u.sequence || i.instanceId !== n.instanceId || i.delta !== n.delta || B(i.at) !== f.at) throw t("invalid_record");
+					let a = S.get(n.instanceId), s = (a?.qty ?? 0) + n.delta;
+					if (f.kind === "grant" && n.delta <= 0 || (f.kind === "consume" || f.kind === "expire" || f.kind === "transfer-out") && n.delta >= 0 || f.kind === "transfer-in" && n.delta <= 0 || (f.kind === "equip" || f.kind === "reserve" || f.kind === "release") && n.delta !== 0 || s < 0 || !a && f.kind !== "grant" && !(f.kind === "craft" && n.delta > 0) && f.kind !== "transfer-in") throw t("invalid_record");
+					if (s === 0) {
+						if (i.after !== null || !a || i.itemId !== a.itemId) throw t("invalid_record");
+						S.delete(n.instanceId);
+					} else {
+						let c = o(i.after, [
+							"id",
+							"itemId",
+							"schemaVersion",
+							"qty",
+							"attributes",
+							"acquiredAt",
+							"expiresAt",
+							"locked",
+							"source"
+						]), l = r(c.acquiredAt, 0, f.at), u = c.expiresAt === null ? null : r(c.expiresAt, l + 1, 864e13), d = J({
+							...c,
+							acquiredAt: new Date(l),
+							expiresAt: u === null ? null : new Date(u)
+						});
+						if (d.id !== n.instanceId || d.itemId !== i.itemId || d.qty !== s || !a && f.kind !== "transfer-in" && d.acquiredAt !== f.at || a && T({
+							...a,
+							qty: s,
+							...f.kind === "reserve" || f.kind === "release" || f.kind === "transfer-out" ? { locked: f.kind === "reserve" } : {}
+						}) !== T(d) || f.kind === "transfer-in" && T(d) !== T(pe(g.selections[e]))) throw t("invalid_record");
+						S.set(d.id, d);
+					}
+				}
+			}
+			if (S.size > O.maxInstances) throw t("limit_exceeded");
+			let E = await q(e, v, m, h, O.maxInstances), k = !1;
+			try {
+				k = E.length === S.size && E.every((e) => {
+					let t = J(e), n = S.get(t.id);
+					return n !== void 0 && T(t) === T(n);
+				});
+			} catch {
+				k = !1;
+			}
+			if (f && !k) {
+				await e.deleteMany(v.tableName, { where: ie(m, h) });
+				for (let t of S.values()) await e.insert(v.tableName, {
+					tenantId: m,
+					...h,
+					...oe(t)
+				});
+				let t = await q(e, b, m, h, 2048);
+				for (let r of t) S.has(n(r.instanceId)) || await e.delete(b.tableName, String(r.id));
+				k = !0;
+			}
+			return Object.freeze({
+				instances: S.size,
+				ledgerRows: u.length,
+				matches: k
+			});
+		})));
+	}), Ce = (e, r) => $(() => {
+		let { tenantId: i, owner: a } = xe(e);
+		return E(async () => (await G(i, a), d.transactional(async (e) => {
+			await K(e, i, a, !0);
+			let o = await q(e, v, i, a, O.maxInstances), s = await q(e, b, i, a, 2048), c = await q(e, y, i, a, O.maxLedgerRows), l = await e.query(I(x).where(N(P("tenantId", i), P("ownerKey", W(i, a)))).limit(O.maxLedgerRows + 1).descriptor);
+			if (l.length > O.maxLedgerRows) throw t("limit_exceeded");
+			if (!r) return {
+				items: o.map(J),
+				loadouts: s.map((e) => ({
+					slotSet: e.slotSet,
+					slot: e.slot,
+					instanceId: e.instanceId
+				})),
+				ledger: c.map((e) => ({
+					operationId: e.operationId,
+					sequence: e.sequence,
+					instanceId: e.instanceId,
+					itemId: e.itemId,
+					delta: e.delta,
+					reason: e.reason,
+					after: e.after,
+					refKind: e.refKind,
+					refId: e.refId,
+					actor: e.actor,
+					at: B(e.at)
+				})),
+				requests: l.map((e) => ({
+					operationId: e.id,
+					state: e.state,
+					sequence: e.sequence,
+					digest: e.digest,
+					receipt: e.receipt,
+					craft: e.craft,
+					reservation: e.reservation,
+					transfer: e.transfer,
+					createdAt: B(e.createdAt)
+				})),
+				craft: l.filter((e) => e.craft !== null).map((e) => e.craft),
+				reservations: l.filter((e) => e.reservation !== null).map((e) => e.reservation),
+				transfers: l.filter((e) => e.transfer !== null).map((e) => e.transfer)
+			};
+			let u = [.../* @__PURE__ */ new Set([...c.map((e) => n(e.operationId)), ...l.map((e) => n(e.id))])];
+			for (let t = 0; t < u.length; t += 128) await e.updateMany(x.tableName, {
+				state: "erased",
+				ownerKey: null,
+				digest: null,
+				receipt: null,
+				craft: null,
+				reservation: null,
+				transfer: null
+			}, { where: N(P("tenantId", i), F("id", u.slice(t, t + 128))) });
+			await e.updateMany(y.tableName, {
+				ownerId: null,
+				ownerKind: null,
+				instanceId: null,
+				after: null,
+				refKind: null,
+				refId: null,
+				actor: null
+			}, { where: ie(i, a) }), await e.deleteMany(b.tableName, { where: ie(i, a) }), await e.deleteMany(v.tableName, { where: ie(i, a) }), await e.update(C.tableName, W(i, a), {
+				erased: !0,
+				ownerId: null
+			});
+		})));
+	}), we = (e, i) => {
+		let a = structuredClone(e), s = o(i, [
+			"tenantId",
+			"owner",
+			"recipeId",
+			"requestId",
+			"batches"
+		]);
+		if (!H(a)) throw t("forbidden");
+		if (!O.crafting) throw t("unavailable");
+		let c = O.crafting.recipes.find((e) => e.id === n(s.recipeId));
+		if (!c) throw t("not_found");
+		return {
+			who: a,
+			operation: {
+				tenantId: n(s.tenantId),
+				owner: z(s.owner),
+				requestId: n(s.requestId),
+				kind: "craft",
+				payload: Object.freeze({
+					recipe: c,
+					version: O.crafting.version,
+					batches: r(s.batches ?? 1, 1, c.maxBatches)
+				})
+			}
+		};
+	}, Te = (e, a) => {
+		let s = structuredClone(e), c = o(a, [
+			"tenantId",
+			"owner",
+			"requestId",
+			"itemId",
+			"qty",
+			"attributes",
+			"reason",
+			"ref"
+		]);
+		if (!H(s)) throw t("forbidden");
+		let l = o(c.ref, ["kind", "id"]);
+		return {
+			who: s,
+			operation: {
+				tenantId: n(c.tenantId),
+				owner: z(c.owner),
+				requestId: n(c.requestId),
+				kind: "grant",
+				payload: Object.freeze({
+					itemId: n(c.itemId),
+					qty: r(c.qty, 1, 1e6),
+					...c.attributes === void 0 ? {} : { attributes: i(c.attributes) },
+					reason: n(c.reason),
+					ref: Object.freeze({
+						kind: n(l.kind),
+						id: n(l.id)
+					})
+				})
+			}
+		};
+	}, Ee = (e, r, i) => {
+		let a = structuredClone(e), s = o(r, i === "reserve" ? [
+			"tenantId",
+			"owner",
+			"reservationId",
+			"items"
+		] : [
+			"tenantId",
+			"owner",
+			"reservationId"
+		]);
+		if (!H(a)) throw t("forbidden");
+		let c = n(s.tenantId), l = z(s.owner), u = n(s.reservationId);
+		return {
+			who: a,
+			operation: Object.freeze({
+				tenantId: c,
+				owner: l,
+				requestId: X(i, u),
+				kind: i,
+				payload: Object.freeze({
+					reservationId: u,
+					...i === "reserve" ? { items: _(s.items) } : {}
+				})
+			})
+		};
+	}, De = (e, r) => $(() => {
+		let { operation: i } = Ee(e, r, "release"), { tenantId: a, owner: o, payload: s } = i, c = n(s.reservationId);
+		return E(() => d.transactional(async (e) => {
+			let n = (await e.query(I(C).where(P("id", W(a, o))).limit(1).descriptor))[0];
+			ae(n, a, o);
+			let r = (await e.query(I(x).where(P("id", se(a, o, "reserve", c))).limit(1).descriptor))[0];
+			if (!r || r.state === "pending") {
+				if (r && (r.tenantId !== a || r.ownerKey !== W(a, o) || r.reservation !== null || r.craft !== null || r.transfer !== null || r.receipt !== null || r.digest !== null || r.sequence !== null)) throw t("invalid_record");
+				return Object.freeze({
+					reservationId: c,
+					state: "not-observed",
+					items: Object.freeze([]),
+					reserve: null,
+					release: null,
+					transfer: null
+				});
+			}
+			if (!n || r.state !== "committed") throw t("invalid_record");
+			let i = await le(e, a, o, c), s = Object.freeze(i.accepted.selections.map((e) => Object.freeze({
+				qty: e.qty,
+				instance: Object.freeze({
+					...e.before,
+					locked: !0
+				})
+			}))), l = (await e.query(I(x).where(P("id", D("ivo_", a, o.ownerKind, o.ownerId, de("transfer-out", c, W(a, o))))).limit(1).descriptor))[0];
+			if (l && l.state !== "pending" && l.state !== "committed") throw t("invalid_record");
+			let u = (await e.query(I(x).where(P("id", se(a, o, "release", c))).limit(1).descriptor))[0];
+			if (l?.state === "committed" && u && u.state !== "pending") throw t("invalid_record");
+			if (l?.state === "committed") {
+				let n = Y(l, "transfer-out"), r = Z(l, "transfer-out", n.at);
+				if (n.at < i.receipt.at || T(fe(r.selections)) !== T(i.accepted.selections.map((e) => ({
+					...e,
+					before: {
+						...e.before,
+						locked: !0
+					}
+				})))) throw t("invalid_record");
+				let a = await me(e, r, n.at);
+				return Object.freeze({
+					reservationId: c,
+					state: "transferred",
+					items: s,
+					reserve: i.receipt,
+					release: null,
+					transfer: Object.freeze({
+						from: n,
+						to: a
+					})
+				});
+			}
+			if (u && u.state !== "pending" && u.state !== "committed") throw t("invalid_record");
+			if (u?.state === "committed") {
+				let e = Y(u, "release"), n = ce(u, "release", e.at);
+				if (e.at < i.receipt.at || T(n.selections) !== T(i.accepted.selections.map((e) => ({
+					...e,
+					before: {
+						...e.before,
+						locked: !0
+					}
+				})))) throw t("invalid_record");
+				return Object.freeze({
+					reservationId: c,
+					state: "released",
+					items: s,
+					reserve: i.receipt,
+					release: e,
+					transfer: null
+				});
+			}
+			return Object.freeze({
+				reservationId: c,
+				state: "reserved",
+				items: s,
+				reserve: i.receipt,
+				release: null,
+				transfer: null
+			});
+		}));
+	}), Oe = (e, t) => j.map(De(e, t), (e) => Object.freeze({
+		reservationId: e.reservationId,
+		state: e.state,
+		items: e.state === "reserved" ? e.items : Object.freeze([])
+	})), ke = async (e, n, r) => {
+		let { tenantId: i, from: a, to: o, reservationId: s } = n, c = W(i, a), l = W(i, o), u = de("transfer-out", s, c), f = de("transfer-in", s, c), p = D("ivo_", i, a.ownerKind, a.ownerId, u), m = D("ivo_", i, o.ownerKind, o.ownerId, f), h = Object.freeze(r.map((e) => Object.freeze({
+			...e,
+			before: Object.freeze({
+				...e.before,
+				locked: !0
+			}),
+			destinationId: e.qty === e.before.qty ? e.instanceId : D("ivi_", "reservation.transfer", i, s, c, l, e.instanceId)
+		}))), g = Object.freeze({
+			tenantId: i,
+			owner: a,
+			requestId: u,
+			kind: "transfer-out",
+			payload: Object.freeze({
+				reservationId: s,
+				peerKey: l,
+				peerOperationId: m,
+				selections: h
+			})
+		}), _ = Object.freeze({
+			tenantId: i,
+			owner: o,
+			requestId: f,
+			kind: "transfer-in",
+			payload: Object.freeze({
+				reservationId: s,
+				peerKey: c,
+				peerOperationId: p,
+				selections: h
+			})
+		}), v = await j.runPromise(j.result(Q(e, g)));
+		if (M.isFailure(v)) throw v.failure;
+		let y = await j.runPromise(j.result(Q(e, _)));
+		if (M.isFailure(y)) throw y.failure;
+		let b = te(d, async (e) => {
+			for (let t of [a, o].sort((e, t) => W(i, e) < W(i, t) ? -1 : 1)) await K(e, i, t);
+		});
+		return ne(d, [
+			b,
+			v.success,
+			y.success
+		], async (e, [, n, r]) => {
+			let i = (await e.query(I(x).where(P("id", p)).limit(1).descriptor))[0], a = (await e.query(I(x).where(P("id", m)).limit(1).descriptor))[0];
+			if (!i || !a) throw t("invalid_record");
+			return await me(e, Z(i, "transfer-out", n.at), n.at), await me(e, Z(a, "transfer-in", r.at), r.at), Object.freeze({
+				reservationId: s,
+				from: n,
+				to: r
+			});
+		});
+	}, Ae = (e, n) => $(() => {
+		let r = structuredClone(e), i = h(n), { tenantId: a, from: o, to: s, reservationId: c } = i;
+		if (!H(r)) throw t("forbidden");
+		return E(async () => {
+			await G(a, o), await G(a, s);
+			let e = await d.transactional(async (e) => {
+				for (let t of [o, s].sort((e, t) => W(a, e) < W(a, t) ? -1 : 1)) await K(e, a, t);
+				return le(e, a, o, c);
+			});
+			return ke(r, i, e.accepted.selections);
+		});
+	}), je = (e, n) => $(() => {
+		let r = structuredClone(e), i = g(n), { tenantId: a, from: o, to: s, reservationId: c } = i;
+		if (!H(r)) throw t("forbidden");
+		let { operation: l } = Ee(r, {
+			tenantId: a,
+			owner: o,
+			reservationId: c,
+			items: i.items
+		}, "reserve");
+		return E(async () => {
+			await G(a, o), await G(a, s);
+			let e = await j.runPromise(j.result(Q(r, l)));
+			if (M.isFailure(e)) throw e.failure;
+			let t = await d.transactional(async (e) => {
+				for (let t of [o, s].sort((e, t) => W(a, e) < W(a, t) ? -1 : 1)) await K(e, a, t);
+				return (await e.query(I(x).where(P("id", se(a, o, "reserve", c))).limit(1).descriptor))[0]?.state === "committed" ? (await le(e, a, o, c)).accepted : void 0;
+			}) ?? await ue(l, re()), n = await ke(r, i, t.selections);
+			return ne(d, [e.success, n], async (e, [t, n]) => Object.freeze({
+				reserve: t,
+				transfer: n
+			}));
+		});
+	}), Me = (e, i) => {
+		let a = structuredClone(e), s = o(i, [
+			"tenantId",
+			"owner",
+			"requestId",
+			"instanceId",
+			"qty",
+			"reason",
+			"ref"
+		]);
+		if (!H(a)) throw t("forbidden");
+		let c = o(s.ref, ["kind", "id"]);
+		return {
+			who: a,
+			operation: {
+				tenantId: n(s.tenantId),
+				owner: z(s.owner),
+				requestId: n(s.requestId),
+				kind: "consume",
+				payload: Object.freeze({
+					instanceId: n(s.instanceId),
+					qty: r(s.qty, 1, 1e6),
+					reason: n(s.reason),
+					ref: Object.freeze({
+						kind: n(c.kind),
+						id: n(c.id)
+					})
+				})
+			}
+		};
+	};
+	return Object.freeze({
+		prepareReservationTransfer: Ae,
+		prepareReserveTransfer: je,
+		prepareReserve: (e, t) => $(() => {
+			let { who: n, operation: r } = Ee(e, t, "reserve");
+			return Q(n, r);
+		}),
+		prepareRelease: (e, t) => $(() => {
+			let { who: n, operation: r } = Ee(e, t, "release");
+			return Q(n, r);
+		}),
+		reservation: Oe,
+		reservationEvidence: De,
+		prepareCraft: (e, t) => $(() => {
+			let { who: n, operation: r } = we(e, t);
+			return Q(n, r);
+		}),
+		prepareGrant: (e, t) => $(() => {
+			let { who: n, operation: r } = Te(e, t);
+			return Q(n, r);
+		}),
+		craft: (e, t) => $(() => {
+			let { who: n, operation: r } = we(e, t);
+			return ye(n, r);
+		}),
+		grant: (e, t) => $(() => {
+			let { who: n, operation: r } = Te(e, t);
+			return ye(n, r);
+		}),
+		prepareConsume: (e, t) => $(() => {
+			let { who: n, operation: r } = Me(e, t);
+			return Q(n, r);
+		}),
+		consume: (e, t) => $(() => {
+			let { who: n, operation: r } = Me(e, t);
+			return ye(n, r);
+		}),
+		expire: (e, i) => $(() => {
+			let a = structuredClone(e), s = o(i, [
+				"tenantId",
+				"owner",
+				"requestId",
+				"until"
+			]);
+			if (!H(a)) throw t("forbidden");
+			return ye(a, {
+				tenantId: n(s.tenantId),
+				owner: z(s.owner),
+				requestId: n(s.requestId),
+				kind: "expire",
+				payload: Object.freeze({ until: r(s.until, 0, 864e13) })
+			});
+		}),
+		equip: (e, t) => $(() => {
+			let r = structuredClone(e), { tenantId: i, owner: a } = U(r), s = o(t, [
+				"slotSet",
+				"slot",
+				"instanceId",
+				"requestId"
+			]);
+			return ye(r, {
+				tenantId: i,
+				owner: a,
+				requestId: n(s.requestId),
+				kind: "equip",
+				payload: Object.freeze({
+					slotSet: n(s.slotSet),
+					slot: n(s.slot),
+					instanceId: s.instanceId === null ? null : n(s.instanceId)
+				})
+			});
+		}),
+		mine: (e) => be(e),
+		loadout: (e, t) => be(e, t),
+		exportSubject: (e) => Ce(e, !1),
+		eraseSubject: (e) => j.asVoid(Ce(e, !0)),
+		auditInventory: (e, t, n) => Se(e, t, n, !1),
+		rebuildInventory: (e, t, n) => Se(e, t, n, !0)
+	});
+};
+//#endregion
+export { V as dataStoreInventory, z as inventoryOwner, R as resolveInventoryOptions };