@voltro/plugin-economy 0.0.0-stage → 0.87.0

package/dist/rpc.js

@@ -0,0 +1,1201 @@
+import { EconomyError as e } from "./errors.js";
+import { captureIapObservation as ee } from "./iap.js";
+import { captureIapEntitlementObservation as te } from "./iapEntitlements.js";
+import { captureTradeView as ne } from "./trades.js";
+import { Schema as t } from "effect";
+import { defineAction as n, defineQuery as r } from "@voltro/protocol";
+//#region src/rpc.ts
+var re = "@voltro/plugin-economy", i = t.Literals([
+	"ios",
+	"android",
+	"steam",
+	"web"
+]), a = {
+	channel: i,
+	offerId: t.String,
+	offerVersion: t.String,
+	requestId: t.String
+}, o = t.Struct({
+	...a,
+	receiptDigest: t.String.pipe(t.check(t.makeFilter((e) => /^[a-f0-9]{64}$/.test(e))))
+}), s = t.Struct({
+	...a,
+	receipt: t.String.pipe(t.check(t.makeFilter((e) => e.length > 0 && e.length <= 65536 && !/[\u0000-\u0020\u007f]/.test(e))))
+}), c = t.Struct({
+	orderId: t.String,
+	offerId: t.String,
+	offerVersion: t.String,
+	quantity: t.Number,
+	at: t.Number,
+	pricePaid: t.NullOr(t.Struct({
+		currency: t.String,
+		units: t.String,
+		scale: t.Number
+	})),
+	transfers: t.Array(t.Struct({
+		txId: t.String,
+		currency: t.String,
+		amount: t.String,
+		at: t.Number
+	})),
+	grants: t.Array(t.Struct({
+		operationId: t.String,
+		kind: t.Literal("grant"),
+		changes: t.Array(t.Struct({
+			instanceId: t.String,
+			delta: t.Number
+		})),
+		at: t.Number
+	}))
+}), l = t.Struct({
+	sequence: t.Number,
+	state: t.Literals([
+		"active",
+		"partially-refunded",
+		"revoked"
+	]),
+	refundNumerator: t.Number,
+	refundDenominator: t.Number,
+	observedAt: t.Number
+}), u = t.Union([
+	t.Struct({
+		requestId: t.String,
+		state: t.Literals(["not-observed", "pending"])
+	}),
+	t.Struct({
+		requestId: t.String,
+		state: t.Literal("fulfilled"),
+		receipt: c,
+		refund: t.optional(l)
+	}),
+	t.Struct({
+		requestId: t.String,
+		state: t.Literals(["partially-refunded", "refunded"]),
+		receipt: c,
+		refund: l
+	})
+]).pipe(t.check(t.makeFilter((e) => {
+	try {
+		return ee(e), !0;
+	} catch {
+		return !1;
+	}
+}))), ie = [
+	"_voltro_eco_iap_refund_namespaces",
+	"_voltro_eco_iap_refund_subjects",
+	"_voltro_eco_iap_refund_orders",
+	"_voltro_eco_iap_refund_adjustments"
+], d = t.Struct({
+	offerId: t.String,
+	entitled: t.Boolean,
+	expiresAt: t.NullOr(t.Number),
+	observedAt: t.Number
+}).pipe(t.check(t.makeFilter((e) => {
+	try {
+		return te(e), !0;
+	} catch {
+		return !1;
+	}
+}))), f = t.Struct({ offerId: t.String }), p = "Verified own user selects an installed subscription offer only. Complete accepted SQL originals and refund history plus the current server clock determine the observation. No player ownership, dates or state. Database changes invalidate the subscription; mere time passage requires a fresh check. This snapshot is not value-write authority.", ae = r({
+	name: "economy.iap.entitled",
+	input: f,
+	output: d,
+	error: e,
+	source: [
+		"_voltro_eco_iap_subjects",
+		"_voltro_eco_iap_orders",
+		"_voltro_eco_iap_receipts"
+	],
+	openAccess: p
+}), oe = n({
+	name: "economy.iap.checkEntitlement",
+	input: f,
+	output: d,
+	error: e,
+	openAccess: p
+}), se = [{
+	tag: "economy.iap.entitled",
+	kind: "query",
+	import: {
+		module: "@voltro/plugin-economy/rpc",
+		name: "iapEntitledDescriptor"
+	}
+}, {
+	tag: "economy.iap.checkEntitlement",
+	kind: "action",
+	import: {
+		module: "@voltro/plugin-economy/rpc",
+		name: "iapCheckEntitlementDescriptor"
+	}
+}], ce = r({
+	name: "economy.iap.receipt",
+	input: o,
+	output: u,
+	error: e,
+	source: [
+		"_voltro_eco_iap_subjects",
+		"_voltro_eco_iap_orders",
+		"_voltro_eco_iap_receipts",
+		"_voltro_eco_wallets",
+		"_voltro_eco_tx",
+		"_voltro_eco_ledger",
+		"_voltro_inv_items",
+		"_voltro_inv_operations"
+	],
+	openAccess: "Verified own Subject supplies tenant and owner. Hash-only original reference; never raw store evidence in query parameters. Reads accepted SQL original and configured accepted refund disposition in one borrowed transaction without seeding, verification, clock or another grant. Pending and missing are nonterminal; changed reference conflicts. Refunded is financial history, not provider completion."
+}), le = n({
+	name: "economy.iap.account",
+	input: t.Struct({ channel: i }),
+	output: t.String,
+	error: e,
+	openAccess: "Verified user or guest chooses channel only. Server selects configured app/environment and persists a public random account UUID. No supplied token, tenant, owner or purchase authority. Owning account adapter controls its transaction; no outer transaction."
+}), ue = n({
+	name: "economy.iap.redeem",
+	input: s,
+	output: c,
+	error: e,
+	openAccess: "Verified own Subject supplies tenant and owner. Player selects configured offer/version, original request and opaque store receipt only. Actual server verifier plus prepared account/age/consent/spend gates authorize one atomic Wallet/Inventory/order/custody commit. No client amounts or states. No outer transaction; keep audit input redacted."
+}), m = t.Struct({
+	orderId: t.String,
+	channel: i,
+	operation: t.Literals([
+		"acknowledge",
+		"consume",
+		"finalize",
+		"finish"
+	]),
+	observedAt: t.Number
+}), de = n({
+	name: "economy.iap.complete",
+	input: s,
+	output: m,
+	error: e,
+	openAccess: "Verified own Subject and the exact original intention must resolve an accepted SQL order before provider completion. No grant, redemption, supplied completion state or SQL outer transaction. Explicit retry only; a fresh matching terminal provider observation authorizes the result. Raw receipt is mutation input; keep audit input redacted."
+}), fe = t.Struct({
+	...a,
+	returnUrl: t.String.pipe(t.check(t.isMaxLength(2048)))
+}), pe = t.Struct({
+	checkoutId: t.String,
+	redirectUrl: t.String,
+	expiresAt: t.Number
+}), me = n({
+	name: "economy.iap.checkout",
+	input: fe,
+	output: pe,
+	error: e,
+	openAccess: "Verified own user or guest selects a configured web offer, an original request and a return URL on the provider's allowed origins. The server binds the owner's account token into the provider checkout; the paid checkout is redeemed through economy.iap.redeem with the checkout ID as receipt. No grant, price or state is accepted from the client."
+}), he = [{
+	tag: "economy.iap.checkout",
+	kind: "action",
+	import: {
+		module: "@voltro/plugin-economy/rpc",
+		name: "iapCheckoutDescriptor"
+	}
+}], ge = t.Struct({
+	channel: i,
+	returnUrl: t.String.pipe(t.check(t.isMaxLength(2048)))
+}), _e = t.Struct({ url: t.String }), ve = n({
+	name: "economy.iap.manage",
+	input: ge,
+	output: _e,
+	error: e,
+	openAccess: "Verified own user or guest opens the payment provider's management page (cancel a subscription, change the card) for the account token already bound to them; the return URL stays on the provider's allowed origins. No token is minted, no purchase or entitlement changes here."
+}), ye = [{
+	tag: "economy.iap.manage",
+	kind: "action",
+	import: {
+		module: "@voltro/plugin-economy/rpc",
+		name: "iapManageDescriptor"
+	}
+}], be = [{
+	tag: "economy.iap.complete",
+	kind: "action",
+	import: {
+		module: "@voltro/plugin-economy/rpc",
+		name: "iapCompleteDescriptor"
+	}
+}], xe = [
+	{
+		tag: "economy.iap.receipt",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "iapReceiptDescriptor"
+		}
+	},
+	{
+		tag: "economy.iap.account",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "iapAccountDescriptor"
+		}
+	},
+	{
+		tag: "economy.iap.redeem",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "iapRedeemDescriptor"
+		}
+	}
+], h = t.Struct({
+	currency: t.String,
+	balance: t.String,
+	updatedAt: t.NullOr(t.Number)
+}), Se = r({
+	name: "economy.mine",
+	input: t.Struct({}),
+	output: t.Array(h),
+	error: e,
+	source: [
+		"_voltro_eco_wallets",
+		"_voltro_eco_subjects",
+		"_voltro_eco_currencies"
+	],
+	openAccess: "The installed service requires a verified user or guest; tenant and owner come only from its authenticated Subject. No value-write route is mounted."
+}), Ce = [{
+	tag: "economy.mine",
+	kind: "query",
+	import: {
+		module: "@voltro/plugin-economy/rpc",
+		name: "economyMineDescriptor"
+	}
+}], g = t.Struct({
+	currency: t.String,
+	amount: t.String
+}), _ = {
+	prices: t.Record(t.String, t.Number),
+	storeProductIds: t.Record(t.String, t.String)
+}, v = t.Union([
+	t.Struct({ kind: t.Literal("free") }),
+	t.Struct({
+		kind: t.Literal("virtual"),
+		options: t.Array(g)
+	}),
+	t.Struct({
+		kind: t.Literal("real"),
+		..._
+	}),
+	t.Struct({
+		kind: t.Literal("mixed"),
+		real: t.Struct(_),
+		virtual: t.Array(g)
+	})
+]), y = t.Struct({
+	id: t.String,
+	version: t.String,
+	titleKey: t.String,
+	price: v,
+	items: t.Array(t.Struct({
+		itemId: t.String,
+		qty: t.Number
+	})),
+	currencies: t.Array(g),
+	from: t.NullOr(t.Number),
+	until: t.NullOr(t.Number),
+	segment: t.NullOr(t.String),
+	flag: t.NullOr(t.String),
+	countries: t.Array(t.String),
+	limits: t.Struct({
+		perPlayer: t.NullOr(t.Number),
+		perDay: t.NullOr(t.Number),
+		global: t.NullOr(t.Number)
+	}),
+	oneTime: t.Boolean,
+	maxQuantity: t.Number
+}), b = t.Struct({
+	offerDigest: t.String.pipe(t.check(t.makeFilter((e) => /^[a-f0-9]{64}$/.test(e)))),
+	offer: y,
+	price: v
+}), x = t.Struct({
+	orderId: t.String,
+	offerId: t.String,
+	offerVersion: t.String,
+	offerDigest: t.String.pipe(t.check(t.makeFilter((e) => /^[a-f0-9]{64}$/.test(e)))),
+	quantity: t.Number,
+	at: t.Number,
+	pricePaid: t.Union([t.Struct({ kind: t.Literal("free") }), t.Struct({
+		kind: t.Literal("virtual"),
+		currency: t.String,
+		amount: t.String
+	})]),
+	transfers: t.Array(t.Struct({
+		txId: t.String,
+		currency: t.String,
+		amount: t.String,
+		at: t.Number
+	})),
+	grants: t.Array(t.Struct({
+		operationId: t.String,
+		kind: t.Literal("grant"),
+		changes: t.Array(t.Struct({
+			instanceId: t.String,
+			delta: t.Number
+		})),
+		at: t.Number
+	}))
+}), we = r({
+	name: "shop.offers",
+	input: t.Struct({}),
+	output: t.Array(b),
+	error: e,
+	source: [
+		"_voltro_eco_shop_subjects",
+		"_voltro_eco_offers",
+		"_voltro_eco_orders",
+		"_voltro_eco_shop_counters",
+		"_voltro_eco_wallets",
+		"_voltro_inv_items"
+	],
+	openAccess: "The optional installed ShopPort derives verified user/guest owner and tenant, captures trusted eligibility and price. No player state is accepted. Time-only availability requires an explicit client refresh; source integration is app-owned."
+}), S = t.Struct({
+	offerId: t.String,
+	offerVersion: t.String,
+	offerDigest: t.String.pipe(t.check(t.makeFilter((e) => /^[a-f0-9]{64}$/.test(e)))),
+	requestId: t.String,
+	currency: t.optional(t.String),
+	qty: t.optional(t.Number.pipe(t.check(t.isInt()), t.check(t.isBetween({
+		minimum: 1,
+		maximum: 1e3
+	}))))
+}), C = t.Union([t.Struct({
+	requestId: t.String,
+	state: t.Literals(["not-observed", "pending"])
+}), t.Struct({
+	requestId: t.String,
+	state: t.Literal("fulfilled"),
+	receipt: x
+})]), Te = r({
+	name: "shop.receipt",
+	input: S,
+	output: C,
+	error: e,
+	source: [
+		"_voltro_eco_shop_subjects",
+		"_voltro_eco_orders",
+		"_voltro_eco_offers"
+	],
+	openAccess: "Verified user/guest owner and tenant come only from Subject. Reads original request/intent SQL evidence without creating rows, callbacks or another buy. Missing and pending observations are nonterminal; changed accepted intent conflicts. Source erasure refuses the read."
+}), Ee = n({
+	name: "shop.buy",
+	input: S,
+	output: x,
+	error: e,
+	openAccess: "The client chooses offer ID/version/server declaration digest/request/optional quantity/virtual currency only. The server checks its declaration/rule digest before preparation; the client supplies no price or financial state. Installed ShopPort derives owner/tenant, prices, grants and limits. The borrowed SQL adapter owns one complete transaction; action dispatch adds no outer transaction. Real payment is not accepted here."
+}), De = [
+	{
+		tag: "shop.offers",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "shopOffersDescriptor"
+		}
+	},
+	{
+		tag: "shop.receipt",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "shopReceiptDescriptor"
+		}
+	},
+	{
+		tag: "shop.buy",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "shopBuyDescriptor"
+		}
+	}
+], w = t.Struct({
+	code: t.String.pipe(t.check(t.makeFilter((e) => /^[A-Za-z0-9_-]{8,120}$/.test(e)))),
+	requestId: t.String
+}), T = t.Struct({
+	operationId: t.String,
+	codeId: t.String,
+	version: t.String,
+	campaign: t.String,
+	at: t.Number,
+	transfers: t.Array(t.Struct({
+		txId: t.String,
+		currency: t.String,
+		amount: t.String,
+		at: t.Number
+	})),
+	grants: t.Array(t.Struct({
+		operationId: t.String,
+		kind: t.Literal("grant"),
+		changes: t.Array(t.Struct({
+			instanceId: t.String,
+			delta: t.Number
+		})),
+		at: t.Number
+	}))
+}), E = t.Union([t.Struct({
+	requestId: t.String,
+	state: t.Literals(["not-observed", "pending"])
+}), t.Struct({
+	requestId: t.String,
+	state: t.Literal("fulfilled"),
+	receipt: T
+})]), Oe = r({
+	name: "economy.codes.receipt",
+	input: w,
+	output: E,
+	error: e,
+	source: ["_voltro_eco_code_subjects", "_voltro_eco_code_claims"],
+	openAccess: "Installed CodePort derives verified user/guest owner and tenant from Subject. Reads only the original intention; missing and pending remain nonterminal. No code creation, grants, clock or fresh redeem is invoked. Erased owners refuse."
+}), ke = n({
+	name: "economy.redeem",
+	input: w,
+	output: T,
+	error: e,
+	openAccess: "Players supply only case-sensitive code and independent request ID. The installed CodePort derives tenant, owner, gifts and limits. Default adapter owns one complete SQL transaction with actual prepared wallet/item writers; dispatch must not add an outer transaction. No plaintext code is stored in SQL or inspect."
+}), Ae = [{
+	tag: "economy.codes.receipt",
+	kind: "query",
+	import: {
+		module: "@voltro/plugin-economy/rpc",
+		name: "codesReceiptDescriptor"
+	}
+}, {
+	tag: "economy.redeem",
+	kind: "action",
+	import: {
+		module: "@voltro/plugin-economy/rpc",
+		name: "codesRedeemDescriptor"
+	}
+}], D = t.String.pipe(t.check(t.makeFilter((e) => /^[a-f0-9]{64}$/.test(e)))), O = t.Struct({
+	id: t.String,
+	version: t.String,
+	group: t.String,
+	price: v,
+	countries: t.Array(t.String),
+	drops: t.Array(t.Struct({
+		id: t.String,
+		rarity: t.String,
+		weight: t.String,
+		items: t.Array(t.Struct({
+			itemId: t.String,
+			qty: t.Number
+		})),
+		currencies: t.Array(g)
+	})),
+	pity: t.NullOr(t.Struct({
+		guaranteed: t.String,
+		after: t.Number,
+		softFrom: t.NullOr(t.Number),
+		softRampBps: t.Number
+	}))
+}), k = t.Struct({
+	entries: t.Array(t.Struct({
+		dropId: t.String,
+		weight: t.String
+	})),
+	total: t.String,
+	guaranteed: t.Boolean
+}), A = t.Struct({
+	container: O,
+	containerDigest: D,
+	disclosureDigest: D,
+	misses: t.Number,
+	price: v,
+	disclosure: t.Struct({
+		guaranteed: t.Boolean,
+		probabilities: t.Array(t.Struct({
+			dropId: t.String,
+			numerator: t.String,
+			denominator: t.String
+		}))
+	})
+}), j = t.Struct({
+	containerId: t.String,
+	containerVersion: t.String,
+	containerDigest: D,
+	disclosureDigest: D,
+	requestId: t.String,
+	currency: t.optional(t.String)
+}), M = t.Struct({
+	operationId: t.String,
+	containerId: t.String,
+	containerVersion: t.String,
+	containerDigest: D,
+	dropId: t.String,
+	rarity: t.String,
+	previousMisses: t.Number,
+	misses: t.Number,
+	sequence: t.Number,
+	at: t.Number,
+	distribution: k,
+	pricePaid: t.Union([t.Struct({ kind: t.Literal("free") }), t.Struct({
+		kind: t.Literal("virtual"),
+		currency: t.String,
+		amount: t.String
+	})]),
+	transfers: t.Array(t.Struct({
+		txId: t.String,
+		currency: t.String,
+		amount: t.String,
+		at: t.Number
+	})),
+	grants: t.Array(t.Struct({
+		operationId: t.String,
+		kind: t.Literal("grant"),
+		changes: t.Array(t.Struct({
+			instanceId: t.String,
+			delta: t.Number
+		})),
+		at: t.Number
+	}))
+}), N = t.Union([t.Struct({
+	requestId: t.String,
+	state: t.Literals(["not-observed", "pending"])
+}), t.Struct({
+	requestId: t.String,
+	state: t.Literal("fulfilled"),
+	receipt: M
+})]), je = r({
+	name: "economy.containers",
+	input: t.Struct({}),
+	output: t.Array(A),
+	error: e,
+	source: [
+		"_voltro_eco_container_subjects",
+		"_voltro_eco_container_openings",
+		"_voltro_eco_containers"
+	],
+	openAccess: "Optional installed ContainersPort derives verified user/guest owner and tenant. Required trusted age/country source and configured legal eligibility precede own probability/price observations. App supplies actual invalidation tables for external facts when needed. No player state is accepted."
+}), Me = r({
+	name: "economy.containers.receipt",
+	input: j,
+	output: N,
+	error: e,
+	source: ["_voltro_eco_container_subjects", "_voltro_eco_container_openings"],
+	openAccess: "Verified user/guest tenant and owner come from Subject. Only original intention evidence is read, no rows seeded, clock/facts/RNG evaluated or opening invoked. Pending/missing remain nonterminal and hide the selected unaccepted outcome. Erased subjects refuse."
+}), Ne = n({
+	name: "economy.openContainer",
+	input: j,
+	output: M,
+	error: e,
+	openAccess: "Players send only observed declaration/disclosure identity, request ID and optional game currency, never draw, seed, price or state. Installed port owns legal authority, selection, Pity and atomic prepared SQL debit/grants. Dispatch adds no outer transaction. Original pending selection cannot be bypassed with a new nonce. Real payments are not fulfilled here."
+}), Pe = [
+	{
+		tag: "economy.containers",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "containersListDescriptor"
+		}
+	},
+	{
+		tag: "economy.containers.receipt",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "containerReceiptDescriptor"
+		}
+	},
+	{
+		tag: "economy.openContainer",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "containerOpenDescriptor"
+		}
+	}
+], P = t.Struct({
+	items: t.Array(t.Struct({
+		itemId: t.String,
+		qty: t.Number
+	})),
+	currencies: t.Array(g)
+}), F = t.Struct({
+	id: t.String,
+	version: t.String,
+	titleKey: t.String,
+	price: v,
+	period: t.Struct({
+		unit: t.Literals([
+			"day",
+			"week",
+			"month"
+		]),
+		count: t.Number
+	}),
+	grants: t.Struct({
+		onPurchase: P,
+		daily: P
+	}),
+	graceDays: t.Number,
+	coolingOff: t.Struct({
+		days: t.Number,
+		overrideReason: t.NullOr(t.String)
+	}),
+	disclosure: t.Struct({
+		durationKey: t.String,
+		renewalKey: t.String,
+		cancellationPath: t.String
+	})
+}), I = t.Struct({
+	startsAt: t.Number,
+	expiresAt: t.Number,
+	graceUntil: t.Number,
+	state: t.Literals([
+		"active",
+		"grace",
+		"expired"
+	])
+}), L = t.Struct({
+	subscription: F,
+	subscriptionDigest: D
+}), R = t.Struct({
+	entitlementId: t.String,
+	subscription: F,
+	subscriptionDigest: D,
+	originAt: t.Number,
+	periodIndex: t.Number,
+	window: I,
+	currency: t.NullOr(t.String),
+	renews: t.Boolean,
+	cancelledAt: t.NullOr(t.Number)
+}), z = t.Struct({
+	subscriptionId: t.String,
+	subscriptionVersion: t.String,
+	subscriptionDigest: D,
+	requestId: t.String,
+	currency: t.optional(t.String)
+}), B = t.Struct({
+	entitlementId: t.String,
+	requestId: t.String
+}), V = t.Struct({
+	operationId: t.String,
+	entitlementId: t.String,
+	kind: t.Literals([
+		"start",
+		"renew",
+		"daily"
+	]),
+	at: t.Number,
+	periodIndex: t.Number,
+	day: t.NullOr(t.Number),
+	window: I,
+	value: x
+}), H = t.Struct({
+	operationId: t.String,
+	entitlementId: t.String,
+	at: t.Number,
+	renews: t.Literal(!1)
+}), U = t.Union([t.Struct({
+	kind: t.Literal("start"),
+	intent: z
+}), t.Struct({
+	kind: t.Literals([
+		"renew",
+		"daily",
+		"cancel"
+	]),
+	intent: B
+})]), W = t.Union([t.Struct({
+	requestId: t.String,
+	state: t.Literal("not-observed")
+}), t.Struct({
+	requestId: t.String,
+	state: t.Literal("fulfilled"),
+	receipt: t.Union([V, H])
+})]), Fe = r({
+	name: "economy.subscriptions.receipt",
+	input: U,
+	output: W,
+	error: e,
+	source: [
+		"_voltro_eco_subscription_subjects",
+		"_voltro_eco_subscription_events",
+		"_voltro_eco_subscriptions"
+	],
+	openAccess: "Verified own subject/tenant supplies scope, including when observing a trusted renewal original. Reads accepted original intent evidence without seeding, clock, facts or another writer. Not-observed is nonterminal; changed intent conflicts. Reading a renewal is not authority to renew."
+}), Ie = r({
+	name: "economy.subscriptions",
+	input: t.Struct({}),
+	output: t.Array(L),
+	error: e,
+	source: ["_voltro_eco_subscription_subjects", "_voltro_eco_subscriptions"],
+	openAccess: "Verified user/guest Subject supplies tenant and owner. This reads captured declaration ceilings and does not invent consent or provider state. Optional app sources own external fact invalidation."
+}), Le = r({
+	name: "economy.subscriptions.active",
+	input: t.Struct({}),
+	output: t.Array(R),
+	error: e,
+	source: [
+		"_voltro_eco_subscription_subjects",
+		"_voltro_eco_subscription_events",
+		"_voltro_eco_subscriptions"
+	],
+	openAccess: "Only verified own entitlements are reconstructed from complete ordered SQL events. Time transitions require explicit refresh; no value write or player state input."
+}), Re = n({
+	name: "economy.subscriptions.start",
+	input: z,
+	output: V,
+	error: e,
+	openAccess: "Player sends only observed content identity, original request and optional currency. Installed port owns trusted eligibility/consent and one atomic exact-store debit/grant/entitlement group. Dispatch must not add an outer transaction. No real payment is fulfilled."
+}), ze = n({
+	name: "economy.subscriptions.claimDaily",
+	input: B,
+	output: V,
+	error: e,
+	openAccess: "Player chooses own entitlement and original request only. Server time, complete SQL history and policy determine the UTC grant day; player dates or claimed state are forbidden. Installed port owns its atomic prepared group; no outer transaction."
+}), Be = n({
+	name: "economy.subscriptions.cancel",
+	input: B,
+	output: H,
+	error: e,
+	openAccess: "Verified own entitlement only. Cancel removes renewal authority; no refund or paid-period shortening is implied. Original requests remain immutable. Trusted renewal has no player RPC."
+}), Ve = [
+	{
+		tag: "economy.subscriptions.receipt",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "subscriptionReceiptDescriptor"
+		}
+	},
+	{
+		tag: "economy.subscriptions",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "subscriptionsListDescriptor"
+		}
+	},
+	{
+		tag: "economy.subscriptions.active",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "subscriptionsActiveDescriptor"
+		}
+	},
+	{
+		tag: "economy.subscriptions.start",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "subscriptionStartDescriptor"
+		}
+	},
+	{
+		tag: "economy.subscriptions.claimDaily",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "subscriptionDailyDescriptor"
+		}
+	},
+	{
+		tag: "economy.subscriptions.cancel",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "subscriptionCancelDescriptor"
+		}
+	}
+], G = t.Union([
+	t.Struct({
+		id: t.String,
+		kind: t.Literals(["xpMultiplier", "discount"]),
+		bps: t.Number
+	}),
+	t.Struct({
+		id: t.String,
+		kind: t.Literal("chatBadge"),
+		badgeId: t.String
+	}),
+	t.Struct({
+		id: t.String,
+		kind: t.Literal("inboxGift"),
+		items: P.fields.items,
+		currencies: P.fields.currencies
+	})
+]), K = t.Struct({
+	id: t.String,
+	version: t.String,
+	titleKey: t.String,
+	decay: t.Literals(["none", "seasonal"]),
+	pointsFrom: t.Array(t.Struct({
+		id: t.String,
+		kind: t.Literals(["purchase.real", "purchase.virtual"]),
+		currency: t.String,
+		numerator: t.String,
+		denominator: t.String
+	})),
+	tiers: t.Array(t.Struct({
+		id: t.String,
+		at: t.String,
+		perks: t.Array(G)
+	}))
+}), He = t.Struct({
+	loyalty: K,
+	rulesVersion: t.String,
+	seasonId: t.NullOr(t.String),
+	points: t.String,
+	tierId: t.String,
+	perks: t.Array(G)
+}), Ue = {
+	id: t.String,
+	sequence: t.Number,
+	at: t.Number,
+	seasonId: t.NullOr(t.String),
+	delta: t.String
+}, We = t.Union([t.Struct({
+	...Ue,
+	kind: t.Literal("credit"),
+	sourceId: t.String,
+	purchaseId: t.String,
+	purchaseAmount: t.String,
+	numerator: t.String,
+	denominator: t.String
+}), t.Struct({
+	...Ue,
+	kind: t.Literal("reverse"),
+	originalId: t.String,
+	refundId: t.String,
+	totalRefunded: t.String
+})]), Ge = t.Struct({
+	operationId: t.String,
+	requestId: t.String,
+	loyaltyId: t.String,
+	entry: We,
+	points: t.String
+}), Ke = t.Union([t.Struct({
+	requestId: t.String,
+	state: t.Literal("not-observed")
+}), t.Struct({
+	requestId: t.String,
+	state: t.Literal("fulfilled"),
+	receipt: Ge
+})]), qe = r({
+	name: "economy.loyalty",
+	input: t.Struct({}),
+	output: t.Array(K),
+	error: e,
+	source: ["_voltro_eco_loyalty_subjects", "_voltro_eco_loyalty_definitions"],
+	openAccess: "Verified user/guest Subject supplies tenant and owner. Captured declarations only; no provider verification, point credit or perk application is inferred."
+}), Je = r({
+	name: "economy.loyalty.mine",
+	input: t.Struct({ loyaltyId: t.String }),
+	output: He,
+	error: e,
+	source: [
+		"_voltro_eco_loyalty_subjects",
+		"_voltro_eco_loyalty_entries",
+		"_voltro_eco_loyalty_definitions",
+		"_voltro_eco_loyalty_seasons"
+	],
+	openAccess: "Only own complete accepted SQL points and current trusted season determine this view. Named pure tier/perks slots cannot grant hidden or unearned advantages. No player points/state/season/value inputs; no perk side effects. Time transitions require explicit refresh; app supplies season/fact invalidation sources."
+}), Ye = r({
+	name: "economy.loyalty.receipt",
+	input: t.Struct({ requestId: t.String }),
+	output: Ke,
+	error: e,
+	source: [
+		"_voltro_eco_loyalty_subjects",
+		"_voltro_eco_loyalty_entries",
+		"_voltro_eco_loyalty_definitions",
+		"_voltro_eco_loyalty_seasons"
+	],
+	openAccess: "Verified own tenant/owner only. Historical original receipt read without seeding, clock, current sources, slots or another credit. Not-observed is nonterminal; observation grants no server credit/refund authority."
+}), Xe = [
+	{
+		tag: "economy.loyalty",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "loyaltyListDescriptor"
+		}
+	},
+	{
+		tag: "economy.loyalty.mine",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "loyaltyMineDescriptor"
+		}
+	},
+	{
+		tag: "economy.loyalty.receipt",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "loyaltyReceiptDescriptor"
+		}
+	}
+], Ze = t.Struct({
+	id: t.String,
+	version: t.String,
+	titleKey: t.String,
+	currency: t.String,
+	cap: t.String,
+	unlock: v,
+	fillFrom: t.Array(t.String),
+	reset: t.Literal("onUnlock")
+}), Qe = t.Struct({
+	bank: Ze,
+	bankDigest: D,
+	available: t.String,
+	cycles: t.Number
+}), $e = {
+	id: t.String,
+	sequence: t.Number,
+	at: t.Number
+}, et = t.Struct({
+	...$e,
+	kind: t.Literal("fill"),
+	authorityId: t.String,
+	eventId: t.String,
+	sourceId: t.String,
+	acceptedAmount: t.String,
+	delta: t.String
+}), tt = t.Struct({
+	...$e,
+	kind: t.Literal("unlock"),
+	amount: t.String,
+	remaining: t.String
+}), nt = {
+	operationId: t.String,
+	requestId: t.String,
+	bankId: t.String,
+	available: t.String
+}, q = t.Union([t.Struct({
+	...nt,
+	event: et
+}), t.Struct({
+	...nt,
+	event: tt,
+	value: x
+})]), J = t.Union([t.Struct({
+	requestId: t.String,
+	state: t.Literal("not-observed")
+}), t.Struct({
+	requestId: t.String,
+	state: t.Literal("fulfilled"),
+	receipt: q
+})]), rt = r({
+	name: "economy.piggyBanks",
+	input: t.Struct({}),
+	output: t.Array(Qe),
+	error: e,
+	source: [
+		"_voltro_eco_piggy_subjects",
+		"_voltro_eco_piggy_events",
+		"_voltro_eco_piggy_definitions"
+	],
+	openAccess: "Verified own Subject supplies tenant/owner. Complete accepted SQL fills/unlocks reconstruct capped available value and cycles. Prices are declarations, not pinned personalized quotes; no player state or automatic fill."
+}), it = r({
+	name: "economy.piggyBanks.receipt",
+	input: t.Struct({ requestId: t.String }),
+	output: J,
+	error: e,
+	source: [
+		"_voltro_eco_piggy_subjects",
+		"_voltro_eco_piggy_events",
+		"_voltro_eco_piggy_definitions"
+	],
+	openAccess: "Verified own tenant/owner, historical original only. No row seeding, source/clock/policy/writer or fresh unlock. Not-observed is nonterminal. Reading a trusted fill receipt does not authorize a fill."
+}), at = n({
+	name: "economy.piggyBanks.unlock",
+	input: t.Struct({
+		bankId: t.String,
+		bankVersion: t.String,
+		bankDigest: D,
+		requestId: t.String,
+		currency: t.optional(t.String)
+	}),
+	output: q,
+	error: e,
+	openAccess: "Player chooses observed bank identity, original request and optional virtual currency only. Installed port owns trusted eligibility, actual wallet debit/grant and reset in one exact-store SQL group; dispatch adds no outer transaction. No amount/event/result/available state or real settlement. Fill/rebuild have no player RPC."
+}), ot = [
+	{
+		tag: "economy.piggyBanks",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "piggyListDescriptor"
+		}
+	},
+	{
+		tag: "economy.piggyBanks.receipt",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "piggyReceiptDescriptor"
+		}
+	},
+	{
+		tag: "economy.piggyBanks.unlock",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "piggyUnlockDescriptor"
+		}
+	}
+], Y = t.String.pipe(t.check(t.makeFilter((e) => e.length <= 120 && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(e)))), st = t.String.pipe(t.check(t.makeFilter((e) => e.length <= 19 && /^[1-9][0-9]*$/.test(e) && BigInt(e) <= 9223372036854775807n))), ct = t.String.pipe(t.check(t.makeFilter((e) => e.length <= 19 && /^(?:0|[1-9][0-9]*)$/.test(e) && BigInt(e) <= 9223372036854775807n))), lt = t.Number.pipe(t.check(t.isInt()), t.check(t.isBetween({
+	minimum: 0,
+	maximum: 864e13
+}))), X = t.Struct({
+	items: t.Array(t.Struct({
+		instanceId: Y,
+		qty: t.Number.pipe(t.check(t.isInt()), t.check(t.isBetween({
+			minimum: 1,
+			maximum: 1e6
+		})))
+	})).pipe(t.check(t.makeFilter((e) => e.length <= 32))),
+	currencies: t.Array(t.Struct({
+		currency: Y,
+		amount: st
+	})).pipe(t.check(t.makeFilter((e) => e.length <= 32)))
+}), ut = t.Struct({
+	toId: t.NullOr(Y),
+	offered: X,
+	requested: X,
+	durationMs: t.Number.pipe(t.check(t.isInt()), t.check(t.isBetween({
+		minimum: 1,
+		maximum: 316224e5
+	}))),
+	requestId: Y
+}), Z = t.Struct({
+	tradeId: Y,
+	tradeDigest: D,
+	proposerId: Y,
+	toId: t.NullOr(Y),
+	offered: X,
+	requested: X,
+	createdAt: lt,
+	expiresAt: lt,
+	state: t.Literals([
+		"proposed",
+		"accepted",
+		"cancelled",
+		"expired"
+	]),
+	accepterId: t.NullOr(Y),
+	rulesVersion: Y,
+	taxes: t.Array(t.Struct({
+		leg: t.Literals(["offered", "requested"]),
+		currency: Y,
+		gross: st,
+		net: ct,
+		tax: ct
+	})).pipe(t.check(t.makeFilter((e) => e.length <= 64)))
+}).pipe(t.check(t.makeFilter((e) => {
+	try {
+		return ne(e), !0;
+	} catch {
+		return !1;
+	}
+}))), Q = t.Struct({
+	operationId: Y,
+	requestId: Y,
+	trade: Z
+}), dt = t.Union([t.Struct({
+	requestId: Y,
+	state: t.Literal("not-observed")
+}), t.Struct({
+	requestId: Y,
+	state: t.Literal("fulfilled"),
+	receipt: Q
+})]), $ = [
+	"_voltro_eco_trade_tenants",
+	"_voltro_eco_trade_subjects",
+	"_voltro_eco_trades",
+	"_voltro_eco_trade_operations",
+	"_voltro_eco_tx",
+	"_voltro_eco_ledger",
+	"_voltro_inv_items",
+	"_voltro_inv_operations",
+	"_voltro_inv_subjects",
+	"_voltro_inv_ledger",
+	"_voltro_eco_subjects",
+	"_voltro_eco_currencies"
+], ft = r({
+	name: "economy.trades.mine",
+	input: t.Struct({}),
+	output: t.Array(Z),
+	error: e,
+	source: $,
+	openAccess: "Verified user/guest Subject supplies tenant and owner. Own, targeted and accepted trades only; no public marketplace. SQL and actual asset receipt evidence own the observed original terms, rules and net/tax disclosure."
+}), pt = r({
+	name: "economy.trades.receipt",
+	input: t.Struct({ requestId: Y }),
+	output: dt,
+	error: e,
+	source: $,
+	openAccess: "Verified own tenant/owner request. Read original evidence without row creation, clock, fresh authority or exchange. Not-observed is nonterminal; erasure refuses access. A receipt read grants no trade authority."
+}), mt = n({
+	name: "economy.trades.propose",
+	input: ut,
+	output: Q,
+	error: e,
+	openAccess: "Player proposes immutable item selections, quantities, consideration, target, lifetime and request identity. These are intentions, never balances, ownership, tax or permission state. Server-derived owner/tenant and required real authority plus actual prepared asset writers accept one SQL transaction; dispatch adds no outer transaction."
+}), ht = n({
+	name: "economy.trades.accept",
+	input: t.Struct({
+		tradeId: Y,
+		tradeDigest: D,
+		requestId: Y
+	}),
+	output: Q,
+	error: e,
+	openAccess: "Player chooses trade ID, observed immutable terms digest and request identity only. Required prepared SQL authority revalidates both participants; actual held and requested assets, net payout, tax and receipt commit atomically. Client cannot supply accepter/owner or resulting state."
+}), gt = n({
+	name: "economy.trades.cancel",
+	input: t.Struct({
+		tradeId: Y,
+		requestId: Y
+	}),
+	output: Q,
+	error: e,
+	openAccess: "Verified proposer chooses its trade ID and request identity. One permanent close competes with acceptance/expiry and releases original held assets through the same prepared writers. No player repair, expiry or asset grant route."
+}), _t = [
+	{
+		tag: "economy.trades.mine",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "tradesMineDescriptor"
+		}
+	},
+	{
+		tag: "economy.trades.receipt",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "tradeReceiptDescriptor"
+		}
+	},
+	{
+		tag: "economy.trades.propose",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "tradeProposeDescriptor"
+		}
+	},
+	{
+		tag: "economy.trades.accept",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "tradeAcceptDescriptor"
+		}
+	},
+	{
+		tag: "economy.trades.cancel",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-economy/rpc",
+			name: "tradeCancelDescriptor"
+		}
+	}
+];
+//#endregion
+export { w as CodeIntentSchema, E as CodeObservationSchema, T as CodeReceiptSchema, k as ContainerDistributionSchema, N as ContainerObservationSchema, j as ContainerOpenInputSchema, M as ContainerReceiptSchema, O as ContainerSchema, A as ContainerViewSchema, re as ECONOMY_NAME, h as EconomyWalletSchema, i as IapChannelSchema, fe as IapCheckoutInputSchema, pe as IapCheckoutSessionSchema, m as IapCompletionReceiptSchema, d as IapEntitlementObservationSchema, ge as IapManageInputSchema, _e as IapManagePageSchema, u as IapObservationSchema, c as IapOrderReceiptSchema, o as IapReceiptReferenceSchema, s as IapRedeemInputSchema, l as IapRefundDispositionSchema, Ke as LoyaltyObservationSchema, G as LoyaltyPerkSchema, We as LoyaltyPointEntrySchema, Ge as LoyaltyReceiptSchema, K as LoyaltySchema, He as LoyaltyStateSchema, Ze as PiggyBankSchema, et as PiggyFillEventSchema, J as PiggyObservationSchema, q as PiggyReceiptSchema, tt as PiggyUnlockEventSchema, Qe as PiggyViewSchema, S as ShopBuyInputSchema, y as ShopOfferSchema, b as ShopOfferViewSchema, x as ShopOrderReceiptSchema, v as ShopPriceSchema, C as ShopPurchaseObservationSchema, R as SubscriptionActiveViewSchema, H as SubscriptionCancellationReceiptSchema, B as SubscriptionEntitlementInputSchema, W as SubscriptionObservationSchema, U as SubscriptionReceiptInputSchema, F as SubscriptionSchema, z as SubscriptionStartInputSchema, V as SubscriptionValueReceiptSchema, L as SubscriptionViewSchema, I as SubscriptionWindowSchema, X as TradeLegSchema, dt as TradeObservationSchema, ut as TradeProposeInputSchema, Q as TradeReceiptSchema, Z as TradeViewSchema, Oe as codesReceiptDescriptor, ke as codesRedeemDescriptor, Ae as codesRpcClientImports, Ne as containerOpenDescriptor, Me as containerReceiptDescriptor, je as containersListDescriptor, Pe as containersRpcClientImports, Se as economyMineDescriptor, Ce as economyRpcClientImports, le as iapAccountDescriptor, oe as iapCheckEntitlementDescriptor, me as iapCheckoutDescriptor, he as iapCheckoutRpcClientImports, de as iapCompleteDescriptor, be as iapCompletionRpcClientImports, ae as iapEntitledDescriptor, se as iapEntitlementRpcClientImports, ve as iapManageDescriptor, ye as iapManageRpcClientImports, ce as iapReceiptDescriptor, ue as iapRedeemDescriptor, ie as iapRefundReceiptSources, xe as iapRpcClientImports, qe as loyaltyListDescriptor, Je as loyaltyMineDescriptor, Ye as loyaltyReceiptDescriptor, Xe as loyaltyRpcClientImports, rt as piggyListDescriptor, it as piggyReceiptDescriptor, ot as piggyRpcClientImports, at as piggyUnlockDescriptor, Ee as shopBuyDescriptor, we as shopOffersDescriptor, Te as shopReceiptDescriptor, De as shopRpcClientImports, Be as subscriptionCancelDescriptor, ze as subscriptionDailyDescriptor, Fe as subscriptionReceiptDescriptor, Re as subscriptionStartDescriptor, Le as subscriptionsActiveDescriptor, Ie as subscriptionsListDescriptor, Ve as subscriptionsRpcClientImports, ht as tradeAcceptDescriptor, gt as tradeCancelDescriptor, mt as tradeProposeDescriptor, pt as tradeReceiptDescriptor, ft as tradesMineDescriptor, _t as tradesRpcClientImports };