@voltro/plugin-inventory 0.0.0-stage → 0.87.0

package/dist/inventoryUiCopy.js

@@ -0,0 +1,63 @@
+//#region src/inventoryUiCopy.ts
+var e = Object.freeze({
+	en: Object.freeze({
+		inventory: "Inventory",
+		loading: "Loading inventory…",
+		unavailable: "Inventory could not be loaded. Choices will return when the connection recovers.",
+		empty: "No items yet.",
+		noMatches: "No items match these filters.",
+		search: "Find an item",
+		tag: "Item tag",
+		allTags: "All tags",
+		showAll: "Show all items",
+		virtualize: "Use compact list",
+		equipped: "Equipped",
+		locked: "Locked",
+		expired: "Expired",
+		unknown: "Catalog details unavailable",
+		select: "Select item",
+		loadout: "Loadout",
+		unequipped: "Nothing equipped",
+		recipes: "Recipes",
+		batches: "Batches",
+		materials: "Materials",
+		materialsReady: "Materials available",
+		materialsMissing: "Materials missing",
+		currencyCost: "Game currency cost",
+		freeCost: "No currency cost",
+		serverCraft: "Crafting is accepted by the game server. Available materials do not reserve items or guarantee payment.",
+		count: (e, t) => `${e} of ${t} items`,
+		quantity: (e) => `Quantity: ${e}`
+	}),
+	de: Object.freeze({
+		inventory: "Inventar",
+		loading: "Inventar wird geladen…",
+		unavailable: "Das Inventar konnte nicht geladen werden. Die Auswahl kehrt zurück, sobald die Verbindung wiederhergestellt ist.",
+		empty: "Noch keine Items.",
+		noMatches: "Keine Items passen zu diesen Filtern.",
+		search: "Item suchen",
+		tag: "Item-Tag",
+		allTags: "Alle Tags",
+		showAll: "Alle Items anzeigen",
+		virtualize: "Kompakte Liste verwenden",
+		equipped: "Ausgerüstet",
+		locked: "Gesperrt",
+		expired: "Abgelaufen",
+		unknown: "Katalogdetails fehlen",
+		select: "Item auswählen",
+		loadout: "Ausrüstung",
+		unequipped: "Nichts ausgerüstet",
+		recipes: "Rezepte",
+		batches: "Chargen",
+		materials: "Materialien",
+		materialsReady: "Materialien vorhanden",
+		materialsMissing: "Materialien fehlen",
+		currencyCost: "Spielwährungskosten",
+		freeCost: "Keine Währungskosten",
+		serverCraft: "Crafting wird vom Spielserver bestätigt. Vorhandene Materialien reservieren keine Items und garantieren keine Zahlung.",
+		count: (e, t) => `${e} von ${t} Items`,
+		quantity: (e) => `Anzahl: ${e}`
+	})
+});
+//#endregion
+export { e as inventoryUiCopy };

package/dist/item.d.ts

@@ -0,0 +1,73 @@
+import { Schema } from 'effect';
+
+export declare const captureCatalogItem: (input: unknown, contracts: readonly ItemContract[]) => CatalogItem;
+
+export declare const captureItemContracts: (input: readonly ItemDefinition[]) => readonly ItemContract[];
+
+/** Serializable content uses a declared item's version, never a stored Schema object. */
+export declare interface CatalogItem {
+    readonly id: string;
+    readonly schemaVersion: number;
+    readonly kind: ItemKind;
+    readonly stackable: boolean;
+    readonly maxStack: number;
+    readonly tradable: boolean;
+    readonly rarity: string;
+    readonly tags: readonly string[];
+    readonly equipSlot: string | null;
+    readonly expiresAfter: number | null;
+    readonly display: {
+        readonly nameKey: string;
+        readonly icon: string | null;
+    };
+    readonly attributes: JsonValue;
+    readonly instanceDefaults: JsonValue;
+}
+
+export declare const contractKey: (id: string, version: number) => string;
+
+export declare const defineItem: (input: ItemDefinition) => ItemContract;
+
+export declare const ITEM_KINDS: readonly ["consumable", "equipment", "cosmetic", "currencyBundle", "key", "mod"];
+
+export declare const itemContent: (contract: ItemContract, attributes: unknown, instanceDefaults: unknown) => CatalogItem;
+
+export declare interface ItemContract extends Omit<ItemDefinition, 'schemaVersion' | 'equipSlot' | 'expiresAfter' | 'display'> {
+    readonly schemaVersion: number;
+    readonly equipSlot: string | null;
+    readonly expiresAfter: number | null;
+    readonly display: {
+        readonly nameKey: string;
+        readonly icon: string | null;
+    };
+}
+
+export declare interface ItemDefinition {
+    readonly id: string;
+    readonly kind: ItemKind;
+    readonly schemaVersion?: number;
+    readonly stackable: boolean;
+    readonly maxStack: number;
+    readonly tradable: boolean;
+    readonly rarity: string;
+    readonly tags: readonly string[];
+    readonly attributes: Schema.Top;
+    readonly instanceAttributes: Schema.Top;
+    readonly equipSlot?: string | null;
+    /** Milliseconds; resolved on grant, never by a tick. */
+    readonly expiresAfter?: number | null;
+    readonly display: {
+        readonly nameKey: string;
+        readonly icon?: string | null;
+    };
+}
+
+export declare type ItemKind = typeof ITEM_KINDS[number];
+
+declare type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+
+export declare const validateInstanceAttributes: (item: Pick<CatalogItem, "id" | "schemaVersion">, contracts: readonly ItemContract[], input: unknown) => JsonValue;
+
+export { }

package/dist/item.js

@@ -0,0 +1,105 @@
+import { inventoryError as e } from "./errors.js";
+import { identifier as t, integer as n, jsonData as r, list as i, object as a } from "./capture.js";
+import { Schema as o } from "effect";
+//#region src/item.ts
+var s = [
+	"consumable",
+	"equipment",
+	"cosmetic",
+	"currencyBundle",
+	"key",
+	"mod"
+], c = (r) => {
+	let c = a(r, [
+		"id",
+		"kind",
+		"schemaVersion",
+		"stackable",
+		"maxStack",
+		"tradable",
+		"rarity",
+		"tags",
+		"attributes",
+		"instanceAttributes",
+		"equipSlot",
+		"expiresAfter",
+		"display"
+	]);
+	if (!s.some((e) => e === c.kind) || typeof c.stackable != "boolean" || typeof c.tradable != "boolean" || !o.isSchema(c.attributes) || !o.isSchema(c.instanceAttributes)) throw e("invalid_item");
+	let l = n(c.maxStack, 1, 1e6);
+	if (!c.stackable && l !== 1) throw e("invalid_item");
+	let u = i(c.tags, 64).map(t);
+	if (new Set(u).size !== u.length) throw e("invalid_item");
+	let d = a(c.display, ["nameKey", "icon"]), f = d.icon ?? null;
+	if (f !== null && (typeof f != "string" || f.length > 512 || !/^storage:\/\/[A-Za-z0-9][A-Za-z0-9/_.-]*$/.test(f))) throw e("invalid_item");
+	return Object.freeze({
+		id: t(c.id),
+		kind: c.kind,
+		schemaVersion: n(c.schemaVersion ?? 1, 1, 1e6),
+		stackable: c.stackable,
+		maxStack: l,
+		tradable: c.tradable,
+		rarity: t(c.rarity),
+		tags: Object.freeze(u),
+		attributes: c.attributes,
+		instanceAttributes: c.instanceAttributes,
+		equipSlot: c.equipSlot === void 0 || c.equipSlot === null ? null : t(c.equipSlot),
+		expiresAfter: c.expiresAfter === void 0 || c.expiresAfter === null ? null : n(c.expiresAfter, 1, 31536e7),
+		display: Object.freeze({
+			nameKey: t(d.nameKey),
+			icon: f
+		})
+	});
+}, l = (e, t) => JSON.stringify([e, t]), u = (t, n) => {
+	try {
+		let i = r(n), a = o.decodeUnknownSync(o.toType(t), { onExcessProperty: "error" })(i);
+		if (JSON.stringify(r(a)) !== JSON.stringify(i)) throw e("invalid_attributes");
+		return i;
+	} catch {
+		throw e("invalid_attributes");
+	}
+}, d = (t) => {
+	let n = i(t, 1e4).map((e) => c(e));
+	if (new Set(n.map((e) => l(e.id, e.schemaVersion))).size !== n.length) throw e("invalid_item");
+	return Object.freeze(n);
+}, f = (e, t, n) => Object.freeze({
+	id: e.id,
+	schemaVersion: e.schemaVersion,
+	kind: e.kind,
+	stackable: e.stackable,
+	maxStack: e.maxStack,
+	tradable: e.tradable,
+	rarity: e.rarity,
+	tags: e.tags,
+	equipSlot: e.equipSlot,
+	expiresAfter: e.expiresAfter,
+	display: e.display,
+	attributes: u(e.attributes, t),
+	instanceDefaults: u(e.instanceAttributes, n)
+}), p = (i, o) => {
+	let s = a(i, [
+		"id",
+		"schemaVersion",
+		"kind",
+		"stackable",
+		"maxStack",
+		"tradable",
+		"rarity",
+		"tags",
+		"equipSlot",
+		"expiresAfter",
+		"display",
+		"attributes",
+		"instanceDefaults"
+	]), c = t(s.id), l = n(s.schemaVersion, 1, 1e6), u = o.find((e) => e.id === c && e.schemaVersion === l);
+	if (!u) throw e("invalid_item");
+	let d = f(u, s.attributes, s.instanceDefaults);
+	if (JSON.stringify(r(s)) !== JSON.stringify(r(d))) throw e("conflict");
+	return d;
+}, m = (t, n, r) => {
+	let i = n.find((e) => e.id === t.id && e.schemaVersion === t.schemaVersion);
+	if (!i) throw e("invalid_item");
+	return u(i.instanceAttributes, r);
+};
+//#endregion
+export { s as ITEM_KINDS, p as captureCatalogItem, d as captureItemContracts, l as contractKey, c as defineItem, f as itemContent, m as validateInstanceAttributes };

package/dist/plugin.js

@@ -0,0 +1,407 @@
+import { InventoryError as e, inventoryError as t } from "./errors.js";
+import { identifier as n, integer as r, object as i } from "./capture.js";
+import { CraftingPort as a, defaultCraftResolver as o, resolveCraftingOptions as s } from "./crafting.js";
+import { captureItemContracts as c } from "./item.js";
+import { INVENTORY_NAME as ee, inventoryCatalogDescriptor as l, inventoryEquipDescriptor as u, inventoryLoadoutDescriptor as d, inventoryMineDescriptor as f, inventoryRpcClientImports as p } from "./rpc.js";
+import { captureInventoryReleaseInput as m, captureInventoryReservationTransferInput as h, captureInventoryReserveInput as g, captureInventoryReserveTransferInput as _ } from "./reservation.js";
+import { CatalogSource as v } from "./catalog.js";
+import { inventoryCatalogTables as y, inventoryOwnedTables as b, inventoryRecipeTables as x } from "./tables.entity.js";
+import { catalogScope as te, dataStoreCatalog as S } from "./sqlCatalog.js";
+import { defaultExpiryPolicy as C, defaultStackPolicy as w } from "./strategies.js";
+import { dataStoreInventory as T, resolveInventoryOptions as E } from "./inventoryStore.js";
+import { InventoryPort as D } from "./port.js";
+import { Effect as O, Layer as k } from "effect";
+import { defineLicensedGamePlugin as A } from "@voltro/plugin-licensing/gate";
+//#region src/plugin.ts
+var j = Object.freeze({
+	slots: {
+		stackPolicy: {
+			defaultExport: "defaultStackPolicy",
+			fixtureExport: "stackPolicySystemFixture"
+		},
+		expiryPolicy: {
+			defaultExport: "defaultExpiryPolicy",
+			fixtureExport: "expiryPolicySystemFixture"
+		},
+		craftResolver: {
+			defaultExport: "defaultCraftResolver",
+			fixtureExport: "craftResolverSystemFixture"
+		}
+	},
+	ports: {
+		inventory: {
+			tagExport: "InventoryPort",
+			fakeLayerExport: "inventoryFakeLayer",
+			fixtureExport: "inventoryPortSystemFixture"
+		},
+		crafting: {
+			tagExport: "CraftingPort",
+			fakeLayerExport: "craftingFakeLayer",
+			fixtureExport: "craftingPortSystemFixture"
+		},
+		catalogSource: {
+			tagExport: "CatalogSource",
+			fakeLayerExport: "catalogFakeLayer",
+			fixtureExport: "catalogSourceSystemFixture"
+		}
+	},
+	events: []
+}), M = (j) => {
+	let M = i(j, [
+		"items",
+		"catalogSource",
+		"channel",
+		"locale",
+		"allowedServices",
+		"slotSets",
+		"maxInstances",
+		"maxLedgerRows",
+		"now",
+		"stackPolicy",
+		"expiryPolicy",
+		"maxCatalogItems",
+		"maxCatalogVersions",
+		"service",
+		"crafting"
+	]), N = M.crafting === void 0 ? void 0 : s(M.crafting), P = c(M.items), F, I, L, R = !1, z = M.catalogSource === void 0 ? void 0 : i(M.catalogSource);
+	if (z && typeof z.read != "function") throw t("invalid_input");
+	let B = Object.freeze({ read: (n) => {
+		try {
+			let e = te(n);
+			return O.suspend(() => R ? z ? z.read.call(M.catalogSource, e) : L ? L.read(e) : O.fail(t("unavailable")) : O.fail(t("unavailable")));
+		} catch (n) {
+			return O.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	} }), V = E({
+		items: P,
+		catalogSource: B,
+		channel: M.channel ?? "live",
+		locale: M.locale ?? "en",
+		allowedServices: M.allowedServices,
+		slotSets: M.slotSets,
+		maxInstances: M.maxInstances,
+		maxLedgerRows: M.maxLedgerRows,
+		now: M.now,
+		stackPolicy: M.stackPolicy,
+		expiryPolicy: M.expiryPolicy,
+		...N === void 0 || N.service ? {} : { crafting: N }
+	}), H = r(M.maxCatalogItems ?? 1e4, 1, 1e4), U = r(M.maxCatalogVersions ?? 1e4, 1, 1e5), W = {
+		items: P,
+		allowedServices: V.allowedServices,
+		maxCatalogItems: H,
+		maxCatalogVersions: U,
+		now: V.now
+	}, G = M.service === void 0 ? void 0 : i(M.service), K = [
+		"grant",
+		"consume",
+		"mine",
+		"loadout",
+		"equip",
+		"expire",
+		"exportSubject",
+		"eraseSubject"
+	];
+	if (G && K.some((e) => typeof G[e] != "function")) throw t("invalid_input");
+	let q = G ? Object.freeze(Object.fromEntries(K.map((e) => [e, G[e].bind(M.service)]))) : void 0;
+	if (N && !N.service && q) throw t("invalid_input");
+	let J = (e) => O.suspend(() => {
+		let n = q ?? I;
+		return R && n ? e(n) : O.fail(t("unavailable"));
+	}), Y = (e, n, r) => {
+		try {
+			let t = structuredClone(e), i = structuredClone(n);
+			return J((e) => r(e, t, i));
+		} catch {
+			return O.fail(t("invalid_input"));
+		}
+	}, X = Object.freeze({
+		grant: (e, t) => Y(e, t, (e, t, n) => e.grant(t, n)),
+		consume: (e, t) => Y(e, t, (e, t, n) => e.consume(t, n)),
+		mine: (e) => Y(e, null, (e, t) => e.mine(t)),
+		loadout: (e, t) => Y(e, t, (e, t, n) => e.loadout(t, n)),
+		equip: (e, t) => Y(e, t, (e, t, n) => e.equip(t, n)),
+		expire: (e, t) => Y(e, t, (e, t, n) => e.expire(t, n)),
+		exportSubject: (e) => {
+			try {
+				let t = structuredClone(e);
+				return J((e) => e.exportSubject(t));
+			} catch {
+				return O.fail(t("invalid_input"));
+			}
+		},
+		eraseSubject: (e) => {
+			try {
+				let t = structuredClone(e);
+				return J((e) => e.eraseSubject(t));
+			} catch {
+				return O.fail(t("invalid_input"));
+			}
+		}
+	}), Z = Object.freeze({
+		craft: (e, n) => {
+			try {
+				let r = structuredClone(e), i = structuredClone(n);
+				return O.suspend(() => !R || !N ? O.fail(t("unavailable")) : N.service ? N.service.craft(r, i) : I ? I.craft(r, i) : O.fail(t("unavailable")));
+			} catch {
+				return O.fail(t("invalid_input"));
+			}
+		},
+		recipes: (e) => {
+			try {
+				let n = structuredClone(e);
+				return O.suspend(() => !R || !N ? O.fail(t("unavailable")) : N.service ? N.service.recipes(n) : n.type !== "user" && n.type !== "system" && !(n.type === "service" && V.allowedServices.includes(n.service)) ? O.fail(t("forbidden")) : O.succeed(N.recipes));
+			} catch {
+				return O.fail(t("invalid_input"));
+			}
+		},
+		exportSubject: (e) => {
+			try {
+				let n = structuredClone(e);
+				return O.suspend(() => !R || !N ? O.fail(t("unavailable")) : N.service ? N.service.exportSubject(n) : X.exportSubject(n));
+			} catch {
+				return O.fail(t("invalid_input"));
+			}
+		},
+		eraseSubject: (e) => {
+			try {
+				let n = structuredClone(e);
+				return O.suspend(() => !R || !N ? O.fail(t("unavailable")) : N.service ? N.service.eraseSubject(n) : X.eraseSubject(n));
+			} catch {
+				return O.fail(t("invalid_input"));
+			}
+		}
+	}), ne = (r) => {
+		try {
+			let e = structuredClone(r);
+			if (e.type !== "user") throw t("forbidden");
+			return B.read({
+				tenantId: n(e.tenantId),
+				channel: V.channel,
+				locale: V.locale
+			});
+		} catch (n) {
+			return O.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, Q = [
+		...z ? [] : y,
+		...q ? [] : b,
+		...N && !N.service ? x : []
+	], re = A({
+		name: ee,
+		description: "Versioned catalog and SQL-owned item grants, consumption and equip intentions.",
+		permissions: ["store:write", "inspect:read"],
+		services: N ? k.merge(k.merge(k.succeed(D, X), k.succeed(v, B)), k.succeed(a, Z)) : k.merge(k.succeed(D, X), k.succeed(v, B)),
+		routes: [
+			{
+				...f,
+				execute: (e, t) => X.mine(t.request.subject)
+			},
+			{
+				...d,
+				execute: (e, t) => X.loadout(t.request.subject, e.slotSet)
+			},
+			{
+				...l,
+				execute: (e, t) => ne(t.request.subject)
+			},
+			{
+				...u,
+				execute: (e, t) => X.equip(t.request.subject, e)
+			}
+		],
+		rpcClientDescriptors: p,
+		errorSchemas: [{
+			schema: e,
+			import: {
+				module: "@voltro/plugin-inventory/errors",
+				name: "InventoryError"
+			}
+		}],
+		extendSchema: { tables: Q },
+		subjectPrivacy: {
+			tables: Q.map((e) => e.tableName),
+			kinds: ["user", "guest"]
+		},
+		bindDataStore: (e) => {
+			if (F !== void 0 && F !== e) throw Error("Inventory plugin instance cannot cross app stores");
+			F = e, z || (L = S(e, W)), q || (I = T(e, V)), R = !0;
+		},
+		onDeactivate: () => O.sync(() => {
+			R = !1, I = void 0, L = void 0;
+		}),
+		onExport: (e, t) => {
+			let n = {
+				subjectId: e,
+				tenantId: t.tenantId,
+				kind: t.kind
+			};
+			return N?.service ? O.gen(function* () {
+				return {
+					inventory: yield* X.exportSubject(n),
+					crafting: yield* Z.exportSubject(n)
+				};
+			}) : X.exportSubject(n);
+		},
+		onErase: (e, t) => {
+			let n = {
+				subjectId: e,
+				tenantId: t.tenantId,
+				kind: t.kind
+			};
+			return N?.service ? O.gen(function* () {
+				yield* X.eraseSubject(n), yield* Z.eraseSubject(n);
+			}) : X.eraseSubject(n);
+		},
+		inspectEndpoints: [{
+			method: "GET",
+			path: "/status",
+			scope: "process",
+			description: "Captured catalog/port/strategy declarations; no possession, subject or ledger data.",
+			handler: () => O.sync(() => ({
+				kind: "json",
+				data: {
+					capturedAt: (V.now ?? Date.now)(),
+					bound: R,
+					backend: q ? "custom" : "sql",
+					channel: V.channel,
+					locale: V.locale,
+					slots: {
+						catalogSource: z ? "custom" : "default",
+						stackPolicy: V.stackPolicy === w ? "default" : "custom",
+						expiryPolicy: V.expiryPolicy === C ? "default" : "custom"
+					},
+					contracts: P.map((e) => ({
+						id: e.id,
+						schemaVersion: e.schemaVersion,
+						kind: e.kind,
+						maxStack: e.maxStack,
+						equipSlot: e.equipSlot
+					})),
+					slotSets: Object.entries(V.slotSets).map(([e, t]) => ({
+						id: e,
+						slots: t
+					})),
+					budgets: {
+						instances: V.maxInstances,
+						ledgerRows: V.maxLedgerRows,
+						catalogItems: H,
+						catalogVersions: U
+					},
+					tableRoles: Q.map((e) => e.tableName),
+					craftingInstalled: N !== void 0,
+					craftingSystem: N ? {
+						backend: N.service ? "custom" : "sql",
+						resolver: N.craftResolver === o ? "default" : "custom",
+						version: N.version,
+						recipes: N.recipes.map((e) => ({
+							id: e.id,
+							version: e.version,
+							inputs: e.inputs,
+							outputs: e.outputs.map((e) => ({
+								itemId: e.itemId,
+								qty: e.qty
+							})),
+							maxBatches: e.maxBatches,
+							cost: e.cost
+						})),
+						currencyCostInstalled: N.economy !== void 0 || N.service !== void 0 && N.recipes.some((e) => e.cost !== null),
+						durationWorkflowInstalled: !1,
+						requirementsInstalled: !1,
+						playerCraftInstalled: !1
+					} : null,
+					tradingInstalled: !1
+				}
+			}))
+		}]
+	}), $ = (e, r, i, a) => {
+		try {
+			let o = structuredClone(e), s = n(r), c = structuredClone(i);
+			return O.suspend(() => R && I ? a ? I.rebuildInventory(o, s, c) : I.auditInventory(o, s, c) : O.fail(t("unavailable")));
+		} catch {
+			return O.fail(t("invalid_input"));
+		}
+	}, ie = (e, n) => {
+		try {
+			let r = structuredClone(e), i = structuredClone(n);
+			return O.suspend(() => R && I && !q ? I.prepareGrant(r, i) : O.fail(t("unavailable")));
+		} catch {
+			return O.fail(t("invalid_input"));
+		}
+	}, ae = (e, n) => {
+		try {
+			let r = structuredClone(e), i = structuredClone(n);
+			return O.suspend(() => R && I && N && !N.service && !q ? I.prepareCraft(r, i) : O.fail(t("unavailable")));
+		} catch {
+			return O.fail(t("invalid_input"));
+		}
+	}, oe = (n, r) => {
+		try {
+			let e = structuredClone(n), i = _(r);
+			return O.suspend(() => R && I && !q ? I.prepareReserveTransfer(e, i) : O.fail(t("unavailable")));
+		} catch (n) {
+			return O.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, se = (e, n) => {
+		try {
+			let r = structuredClone(e), i = h(n);
+			return O.suspend(() => R && I && !q ? I.prepareReservationTransfer(r, i) : O.fail(t("unavailable")));
+		} catch {
+			return O.fail(t("invalid_input"));
+		}
+	}, ce = (e, n) => {
+		try {
+			let r = structuredClone(e), i = g(n);
+			return O.suspend(() => R && I && !q ? I.prepareReserve(r, i) : O.fail(t("unavailable")));
+		} catch {
+			return O.fail(t("invalid_input"));
+		}
+	}, le = (e, n) => {
+		try {
+			let r = structuredClone(e), i = m(n);
+			return O.suspend(() => R && I && !q ? I.prepareRelease(r, i) : O.fail(t("unavailable")));
+		} catch {
+			return O.fail(t("invalid_input"));
+		}
+	}, ue = (n, r) => {
+		try {
+			let e = structuredClone(n), i = m(r);
+			return O.suspend(() => R && I && !q ? I.reservationEvidence(e, i) : O.fail(t("unavailable")));
+		} catch (n) {
+			return O.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, de = (e, n) => {
+		try {
+			let r = structuredClone(e), i = m(n);
+			return O.suspend(() => R && I && !q ? I.reservation(r, i) : O.fail(t("unavailable")));
+		} catch {
+			return O.fail(t("invalid_input"));
+		}
+	};
+	return {
+		...re,
+		inventory: Object.freeze({
+			prepareReservationTransfer: se,
+			prepareReserveTransfer: oe,
+			prepareReserve: ce,
+			prepareRelease: le,
+			reservation: de,
+			reservationEvidence: ue,
+			prepareGrant: ie,
+			prepareCraft: ae,
+			service: () => X,
+			crafting: () => Z,
+			auditInventory: (e, t, n) => $(e, t, n, !1),
+			rebuildInventory: (e, t, n) => $(e, t, n, !0),
+			importCatalog: (e, n) => {
+				try {
+					let r = structuredClone(e), i = structuredClone(n);
+					return O.suspend(() => R && L ? L.importSnapshot(r, i) : O.fail(t("unavailable")));
+				} catch {
+					return O.fail(t("invalid_input"));
+				}
+			}
+		})
+	};
+};
+//#endregion
+export { M as inventoryPlugin, j as inventorySystemContract };

package/dist/port.js

@@ -0,0 +1,5 @@
+import { Context as e } from "effect";
+//#region src/port.ts
+var t = class extends e.Service()("@voltro/InventoryPort") {};
+//#endregion
+export { t as InventoryPort };