@voltro/plugin-economy 0.0.0-stage → 0.88.0

package/dist/index.js

@@ -0,0 +1,15 @@
+import { EconomyError as e } from "./errors.js";
+import { economyAmount as t, economyAmountString as n } from "./amount.js";
+import { defineCurrency as r } from "./currency.js";
+import { defaultPriceResolver as i, definePrice as a, priceResolverContext as o, resolvePrice as s } from "./price.js";
+import { ShopPort as c, captureShopOrderReceipt as l, captureShopService as u, defineShopOffer as d, shopBuyIntent as f, shopInteger as p, shopPayment as m } from "./shop.js";
+import { applyWalletPosting as h, economyAccountKey as g, planLedgerTransfer as _ } from "./ledger.js";
+import { assertSpendBudget as v, captureSpendLimitsOptions as y, defaultSpendLimitPolicy as b, defineSpendLimits as x, projectSpend as S, resolveSpendBudget as C, utcSpendWindows as w } from "./spendLimits.js";
+import { TradesPort as T, captureTradeLeg as E, captureTradeObservation as D, captureTradeParticipantAuthority as O, captureTradeProposeIntention as k, captureTradeReceipt as A, captureTradeView as j, captureTradesService as M, defaultTradeEligibilityPolicy as N, defaultTradeTaxPolicy as P, defineTradeRules as F, resolveTradeEligibility as I, resolveTradeTax as L, tradeAcceptIntent as R, tradeCancelIntent as z, tradeProposeIntent as B } from "./trades.js";
+import { CodePort as V, captureCodeIntent as H, captureCodeService as U, captureCodeValue as W, defaultCodeEligibility as G, defineCode as K, resolveCodeEligibility as q } from "./codes.js";
+import { SubscriptionsPort as J, captureSubscriptionReceiptIntent as Y, captureSubscriptionsService as X, defaultSubscriptionDailyGrant as Z, defaultSubscriptionPeriod as Q, defineSubscription as $, resolveSubscriptionDailyGrant as ee, resolveSubscriptionPeriod as te, subscriptionEntitlementIntent as ne, subscriptionRenewIntent as re, subscriptionStartIntent as ie } from "./subscriptions.js";
+import { LoyaltyPort as ae, captureLoyaltyService as oe, defaultLoyaltyPerks as se, defaultLoyaltyTier as ce, defineLoyalty as le, loyaltyCreditIntent as ue, loyaltyMineIntent as de, loyaltyPointsForPurchase as fe, loyaltyRebuildIntent as pe, loyaltyReceiptIntent as me, loyaltyReverseIntent as he, projectLoyaltyPoints as ge, resolveLoyaltyPerks as _e, resolveLoyaltyTier as ve } from "./loyalty.js";
+import { PiggyBanksPort as ye, capturePiggyBanksService as be, defaultPiggyFill as xe, defaultPiggyReset as Se, definePiggyBank as Ce, piggyFillIntent as we, piggyUnlockIntent as Te, projectPiggyBank as Ee, resolvePiggyFill as De, resolvePiggyReset as Oe } from "./piggyBanks.js";
+import { EconomyPort as ke, captureEconomyService as Ae } from "./port.js";
+import { economyCodesSystemContract as je, economyContainersSystemContract as Me, economyIapSystemContract as Ne, economyLoyaltySystemContract as Pe, economyPiggyBanksSystemContract as Fe, economyPlugin as Ie, economyShopSystemContract as Le, economySpendLimitsSystemContract as Re, economySubscriptionsSystemContract as ze, economySystemContract as Be, economyTradesSystemContract as Ve } from "./plugin.js";
+export { V as CodePort, e as EconomyError, ke as EconomyPort, ae as LoyaltyPort, ye as PiggyBanksPort, c as ShopPort, J as SubscriptionsPort, T as TradesPort, h as applyWalletPosting, v as assertSpendBudget, H as captureCodeIntent, U as captureCodeService, W as captureCodeValue, Ae as captureEconomyService, oe as captureLoyaltyService, be as capturePiggyBanksService, l as captureShopOrderReceipt, u as captureShopService, y as captureSpendLimitsOptions, Y as captureSubscriptionReceiptIntent, X as captureSubscriptionsService, E as captureTradeLeg, D as captureTradeObservation, O as captureTradeParticipantAuthority, k as captureTradeProposeIntention, A as captureTradeReceipt, j as captureTradeView, M as captureTradesService, G as defaultCodeEligibility, se as defaultLoyaltyPerks, ce as defaultLoyaltyTier, xe as defaultPiggyFill, Se as defaultPiggyReset, i as defaultPriceResolver, b as defaultSpendLimitPolicy, Z as defaultSubscriptionDailyGrant, Q as defaultSubscriptionPeriod, N as defaultTradeEligibilityPolicy, P as defaultTradeTaxPolicy, K as defineCode, r as defineCurrency, le as defineLoyalty, Ce as definePiggyBank, a as definePrice, d as defineShopOffer, x as defineSpendLimits, $ as defineSubscription, F as defineTradeRules, g as economyAccountKey, t as economyAmount, n as economyAmountString, je as economyCodesSystemContract, Me as economyContainersSystemContract, Ne as economyIapSystemContract, Pe as economyLoyaltySystemContract, Fe as economyPiggyBanksSystemContract, Ie as economyPlugin, Le as economyShopSystemContract, Re as economySpendLimitsSystemContract, ze as economySubscriptionsSystemContract, Be as economySystemContract, Ve as economyTradesSystemContract, ue as loyaltyCreditIntent, de as loyaltyMineIntent, fe as loyaltyPointsForPurchase, pe as loyaltyRebuildIntent, me as loyaltyReceiptIntent, he as loyaltyReverseIntent, we as piggyFillIntent, Te as piggyUnlockIntent, _ as planLedgerTransfer, o as priceResolverContext, ge as projectLoyaltyPoints, Ee as projectPiggyBank, S as projectSpend, q as resolveCodeEligibility, _e as resolveLoyaltyPerks, ve as resolveLoyaltyTier, De as resolvePiggyFill, Oe as resolvePiggyReset, s as resolvePrice, C as resolveSpendBudget, ee as resolveSubscriptionDailyGrant, te as resolveSubscriptionPeriod, I as resolveTradeEligibility, L as resolveTradeTax, f as shopBuyIntent, p as shopInteger, m as shopPayment, ne as subscriptionEntitlementIntent, re as subscriptionRenewIntent, ie as subscriptionStartIntent, R as tradeAcceptIntent, z as tradeCancelIntent, B as tradeProposeIntent, w as utcSpendWindows };

package/dist/intentionRecovery.js

@@ -0,0 +1,133 @@
+import { economyError as e } from "./errors.js";
+import { captureBoundMethods as t, dataObject as n, identifier as r } from "./capture.js";
+// src/intentionRecovery.ts
+var i = (t, i, a) => {
+	let o = n(t, [
+		"version",
+		"scope",
+		"request"
+	], "invalid_record");
+	if (o.version !== 1 || o.scope !== i) throw e("invalid_record");
+	return Object.freeze({
+		version: 1,
+		scope: r(i),
+		request: a(o.request)
+	});
+}, a = (e, t) => e.scope === t.scope && JSON.stringify(e.request) === JSON.stringify(t.request), o = (n, o, s) => {
+	let c = t(n, ["withLocked"]);
+	if (typeof o != "function") throw e("invalid_input");
+	let l, u = 0, d = () => {
+		if (l === void 0) throw e("forbidden");
+		return {
+			scope: l,
+			generation: u
+		};
+	}, f = (t) => {
+		if (t.scope !== l || t.generation !== u) throw e("conflict");
+	}, p = (e) => {
+		let t = d();
+		return c.withLocked(t.scope, async (n) => (f(t), e(n, t.scope, () => f(t))));
+	};
+	return Object.freeze({
+		selectScope: (e) => {
+			let t = e === void 0 ? void 0 : r(e);
+			u++, l = t;
+		},
+		pending: () => p(async (e, t) => {
+			let n = e.read();
+			return n === void 0 ? void 0 : i(n, t, s.request);
+		}),
+		begin: (t) => {
+			let n = s.request(t);
+			return p(async (t, r) => {
+				let o = Object.freeze({
+					version: 1,
+					scope: r,
+					request: n
+				}), c = t.read();
+				if (c !== void 0) {
+					let t = i(c, r, s.request);
+					if (!a(t, o)) throw e("conflict");
+					return t;
+				}
+				t.write(o);
+				let l = t.read();
+				if (!l || !a(i(l, r, s.request), o)) throw e("unavailable");
+				return o;
+			});
+		},
+		retry: (t) => {
+			let n = s.request(t);
+			return p(async (t, r, c) => {
+				let l = t.read();
+				if (l === void 0) throw e("not_found");
+				let u = i(l, r, s.request);
+				if (!a(u, {
+					version: 1,
+					scope: r,
+					request: n
+				})) throw e("conflict");
+				c();
+				let d = await o(u.request, c);
+				c();
+				let f = s.resolve(u.request, s.observation(s.fulfilled(u.request, d)));
+				if (f === void 0) throw e("invalid_record");
+				let p = t.read();
+				if (!p || !a(i(p, r, s.request), u)) throw e("conflict");
+				return t.clear(u), f;
+			});
+		},
+		observe: (e) => {
+			let t = s.observation(e);
+			return p(async (e, n) => {
+				let r = e.read();
+				if (r === void 0) return;
+				let a = i(r, n, s.request);
+				if (s.resolve(a.request, t) === void 0) return a;
+				e.clear(a);
+			});
+		}
+	});
+}, s = (n, o, s, c, l) => {
+	if (!n || !o) throw e("unavailable");
+	let u = t(n, [
+		"getItem",
+		"setItem",
+		"removeItem"
+	]), d = t(o, ["request"]);
+	return Object.freeze({ withLocked: (t, n) => {
+		let o = r(t), f = s + o;
+		return d.request(f, async () => {
+			let t = () => {
+				let t = u.getItem(f);
+				if (t === null) return;
+				if (t.length > c) throw e("invalid_record");
+				let n;
+				try {
+					n = JSON.parse(t);
+				} catch {
+					throw e("invalid_record");
+				}
+				return i(n, o, l);
+			};
+			return n(Object.freeze({
+				read: t,
+				write: (n) => {
+					let r = i(n, o, l), s = t();
+					if (s && !a(s, r)) throw e("conflict");
+					let d = JSON.stringify(r);
+					if (d.length > c) throw e("invalid_input");
+					u.setItem(f, d);
+					let p = t();
+					if (!p || !a(p, r)) throw e("unavailable");
+				},
+				clear: (n) => {
+					let r = t();
+					if (!r || !a(r, i(n, o, l))) throw e("conflict");
+					if (u.removeItem(f), u.getItem(f) !== null) throw e("unavailable");
+				}
+			}));
+		});
+	} });
+};
+export { s as browserIntentionJournal, o as createIntentionRecovery };

package/dist/ledger.js

@@ -0,0 +1,77 @@
+import { economyError as e } from "./errors.js";
+import { dataObject as t, identifier as n } from "./capture.js";
+import { economyAmount as r, positiveAmount as i } from "./amount.js";
+import { defineCurrency as a } from "./currency.js";
+// src/ledger.ts
+var o = (r) => {
+	let i = t(r, [
+		"kind",
+		"ownerId",
+		"ownerKind",
+		"id"
+	]);
+	if (i.kind === "system") return t(r, ["kind", "id"]), Object.freeze({
+		kind: "system",
+		id: n(i.id)
+	});
+	if (i.kind !== "wallet" || i.ownerKind !== "player" && i.ownerKind !== "guild") throw e("invalid_input");
+	return t(r, [
+		"kind",
+		"ownerId",
+		"ownerKind"
+	]), Object.freeze({
+		kind: "wallet",
+		ownerId: n(i.ownerId),
+		ownerKind: i.ownerKind
+	});
+}, s = (e) => {
+	let t = o(e);
+	return t.kind === "system" ? JSON.stringify(["system", t.id]) : JSON.stringify([
+		"wallet",
+		t.ownerKind,
+		t.ownerId
+	]);
+}, c = (r, a) => {
+	let c = t(r, [
+		"tenantId",
+		"requestId",
+		"currency",
+		"from",
+		"to",
+		"amount",
+		"reason",
+		"ref"
+	]), l = o(c.from), u = o(c.to);
+	if (s(l) === s(u) || l.kind === "system" && u.kind === "system" && (!a || !l.id.startsWith("escrow.") || l.id.startsWith("escrow.tax.") || !u.id.startsWith("escrow.tax.") || c.reason !== "escrow.tax")) throw e("invalid_input");
+	let d = i(c.amount).toString(), f = t(c.ref, ["kind", "id"]), p = Object.freeze({
+		kind: n(f.kind),
+		id: n(f.id)
+	}), m = Object.freeze([Object.freeze({
+		account: l,
+		debit: d,
+		credit: "0"
+	}), Object.freeze({
+		account: u,
+		debit: "0",
+		credit: d
+	})]);
+	return Object.freeze({
+		tenantId: n(c.tenantId),
+		requestId: n(c.requestId),
+		currency: n(c.currency),
+		amount: d,
+		reason: n(c.reason),
+		ref: p,
+		postings: m
+	});
+}, l = (e) => c(e, !1), u = (e) => c(e, !0), d = (t, n, i, o) => {
+	let s = a(i), c = r(t);
+	if (c < 0n && s.kind !== "hard" || c > BigInt(s.cap)) throw e("invalid_record");
+	let l = r(n.debit), u = r(n.credit);
+	if (l < 0n || u < 0n || l === 0n == (u === 0n)) throw e("invalid_record");
+	let d = c + u - l;
+	if (l > 0n && d < 0n && (!o || s.kind !== "hard")) throw e("insufficient_funds");
+	if (d > BigInt(s.cap)) throw e("currency_cap_reached");
+	return r(d).toString();
+}, f = (e, t, n) => d(e, t, n, !1), p = (e, t, n) => d(e, t, n, !0);
+export { f as applyWalletPosting, p as applyWalletRefundPosting, o as captureAccount, s as economyAccountKey, u as planEscrowLedgerTransfer, l as planLedgerTransfer };

package/dist/loyalty.d.ts

@@ -0,0 +1,274 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+export declare const captureLoyaltyService: (input: LoyaltyService) => LoyaltyService;
+
+declare interface CurrencyDefinition {
+    readonly id: string;
+    readonly kind: 'soft' | 'hard';
+    readonly cap?: EconomyAmountInput;
+    readonly premium?: boolean;
+    readonly display?: {
+        readonly nameKey: string;
+    } | null;
+}
+
+export declare const defaultLoyaltyPerks: LoyaltyPerksResolver;
+
+export declare const defaultLoyaltyTier: LoyaltyTierResolver;
+
+export declare const defineLoyalty: (input: LoyaltyDefinition | Loyalty, declarations: readonly CurrencyDefinition[], realMoney?: boolean) => Loyalty;
+
+declare type EconomyAmountInput = string | number | bigint;
+
+/** Redacted codes; never carries owners, amounts or provider payloads. */
+declare class EconomyError extends EconomyError_base {
+}
+
+declare const EconomyError_base: Schema.Class<EconomyError, Schema.TaggedStruct<"EconomyError", {
+    readonly code: Schema.Literals<readonly ["invalid_currency", "invalid_amount", "overflow", "invalid_price", "real_money_disabled", "invalid_input", "invalid_record", "currency_cap_reached", "insufficient_funds", "conflict", "forbidden", "unavailable", "not_found", "erased", "limit_exceeded", "already_redeemed"]>;
+}>, YieldableError>;
+
+export declare interface Loyalty {
+    readonly id: string;
+    readonly version: string;
+    readonly titleKey: string;
+    readonly pointsFrom: readonly {
+        readonly id: string;
+        readonly kind: 'purchase.real' | 'purchase.virtual';
+        readonly currency: string;
+        readonly numerator: string;
+        readonly denominator: string;
+    }[];
+    readonly tiers: readonly {
+        readonly id: string;
+        readonly at: string;
+        readonly perks: readonly LoyaltyPerk[];
+    }[];
+    readonly decay: 'none' | 'seasonal';
+}
+
+/** Only trusted server callers name receipts. Amounts, weights, points, tiers
+ * and seasons are never request fields. No player credit/reverse action. */
+export declare interface LoyaltyCreditInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly loyaltyId: string;
+    readonly sourceId: string;
+    readonly purchaseId: string;
+    readonly requestId: string;
+}
+
+export declare const loyaltyCreditIntent: (input: LoyaltyCreditInput) => LoyaltyCreditInput;
+
+export declare interface LoyaltyDefinition {
+    readonly id: string;
+    readonly version?: string | undefined;
+    readonly titleKey: string;
+    readonly pointsFrom: readonly {
+        readonly id: string;
+        readonly kind: 'purchase.real' | 'purchase.virtual';
+        readonly currency: string;
+        readonly numerator: EconomyAmountInput;
+        readonly denominator: EconomyAmountInput;
+    }[];
+    readonly tiers: readonly {
+        readonly id: string;
+        readonly at: EconomyAmountInput;
+        readonly perks: readonly LoyaltyPerkDefinition[];
+    }[];
+    readonly decay?: 'none' | 'seasonal';
+}
+
+export declare interface LoyaltyMineInput {
+    readonly loyaltyId: string;
+}
+
+export declare const loyaltyMineIntent: (input: LoyaltyMineInput) => LoyaltyMineInput;
+
+export declare type LoyaltyObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: LoyaltyReceipt;
+};
+
+export declare type LoyaltyPerk = Exclude<LoyaltyPerkDefinition, {
+    readonly kind: 'inboxGift';
+}> | {
+    readonly id: string;
+    readonly kind: 'inboxGift';
+    readonly items: readonly ShopItemGrant[];
+    readonly currencies: readonly {
+        readonly currency: string;
+        readonly amount: string;
+    }[];
+};
+
+export declare type LoyaltyPerkDefinition = {
+    readonly id: string;
+    readonly kind: 'xpMultiplier';
+    readonly bps: number;
+} | {
+    readonly id: string;
+    readonly kind: 'discount';
+    readonly bps: number;
+} | {
+    readonly id: string;
+    readonly kind: 'chatBadge';
+    readonly badgeId: string;
+} | {
+    readonly id: string;
+    readonly kind: 'inboxGift';
+    readonly items?: readonly ShopItemGrant[] | undefined;
+    readonly currencies?: readonly ShopCurrencyGrant[] | undefined;
+};
+
+export declare interface LoyaltyPerksContext extends LoyaltyTierContext {
+    readonly tierId: string;
+}
+
+export declare type LoyaltyPerksResolver = (input: LoyaltyPerksContext) => readonly LoyaltyPerk[];
+
+export declare type LoyaltyPointEntry = {
+    readonly id: string;
+    readonly sequence: number;
+    readonly kind: 'credit';
+    readonly at: number;
+    readonly sourceId: string;
+    readonly purchaseId: string;
+    readonly seasonId: string | null;
+    readonly purchaseAmount: string;
+    readonly numerator: string;
+    readonly denominator: string;
+    readonly delta: string;
+} | {
+    readonly id: string;
+    readonly sequence: number;
+    readonly kind: 'reverse';
+    readonly at: number;
+    readonly originalId: string;
+    readonly refundId: string;
+    readonly seasonId: string | null;
+    readonly totalRefunded: string;
+    readonly delta: string;
+};
+
+export declare interface LoyaltyPointProjection {
+    readonly entries: readonly LoyaltyPointEntry[];
+    readonly balances: readonly {
+        readonly seasonId: string | null;
+        readonly points: string;
+    }[];
+    readonly credits: readonly {
+        readonly id: string;
+        readonly refundedAmount: string;
+        readonly remainingPoints: string;
+    }[];
+}
+
+/** Trusted verified settlement projection only, not a player input/receipt
+ * validator. Exact floor rounding is defined once per accepted purchase; a full
+ * reversal must reverse its recorded credit, never independently reround it. */
+export declare const loyaltyPointsForPurchase: (input: LoyaltyDefinition | Loyalty, sourceId: string, amount: EconomyAmountInput, currencies: readonly CurrencyDefinition[], realMoney?: boolean) => string;
+
+export declare class LoyaltyPort extends LoyaltyPort_base {
+}
+
+declare const LoyaltyPort_base: Context.ServiceClass<LoyaltyPort, "@voltro/LoyaltyPort", LoyaltyService>;
+
+export declare interface LoyaltyRebuildInput extends LoyaltyMineInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+}
+
+export declare const loyaltyRebuildIntent: (input: LoyaltyRebuildInput) => LoyaltyRebuildInput;
+
+export declare interface LoyaltyReceipt {
+    readonly operationId: string;
+    readonly requestId: string;
+    readonly loyaltyId: string;
+    readonly entry: LoyaltyPointEntry;
+    readonly points: string;
+}
+
+export declare interface LoyaltyReceiptInput {
+    readonly requestId: string;
+}
+
+export declare const loyaltyReceiptIntent: (input: LoyaltyReceiptInput) => LoyaltyReceiptInput;
+
+export declare interface LoyaltyReverseInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly loyaltyId: string;
+    readonly originalId: string;
+    readonly refundId: string;
+    readonly requestId: string;
+}
+
+export declare const loyaltyReverseIntent: (input: LoyaltyReverseInput) => LoyaltyReverseInput;
+
+export declare interface LoyaltyService {
+    readonly list: (subject: Subject) => Effect.Effect<readonly Loyalty[], EconomyError>;
+    readonly mine: (subject: Subject, input: LoyaltyMineInput) => Effect.Effect<LoyaltyState, EconomyError>;
+    readonly credit: (subject: Subject, input: LoyaltyCreditInput) => Effect.Effect<LoyaltyReceipt, EconomyError>;
+    readonly reverse: (subject: Subject, input: LoyaltyReverseInput) => Effect.Effect<LoyaltyReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: LoyaltyReceiptInput) => Effect.Effect<LoyaltyObservation, EconomyError>;
+    readonly rebuild: (subject: Subject, input: LoyaltyRebuildInput) => Effect.Effect<LoyaltyPointProjection, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+export declare interface LoyaltyState {
+    readonly loyalty: Loyalty;
+    readonly rulesVersion: string;
+    readonly seasonId: string | null;
+    readonly points: string;
+    readonly tierId: string;
+    readonly perks: readonly LoyaltyPerk[];
+}
+
+export declare interface LoyaltyTierContext {
+    readonly loyalty: Loyalty;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly points: EconomyAmountInput;
+    readonly rulesVersion?: string;
+}
+
+export declare type LoyaltyTierResolver = (context: LoyaltyTierContext) => string;
+
+/** Whole accepted-history projection shared by the future SQL writer/rebuild.
+ * No purchase/refund authenticity is inferred here. The owner must provide all
+ * rows from one tenant/subject, and archive original source weights as evidence.
+ * Cumulative partial refunds cannot exploit independent floor rounding. */
+export declare const projectLoyaltyPoints: (input: readonly LoyaltyPointEntry[], decay?: Loyalty["decay"]) => LoyaltyPointProjection;
+
+/** A named override chooses a subset of declared qualifying-tier perks. App
+ * authors change the declaration to change rewards, never return hidden grants. */
+export declare const resolveLoyaltyPerks: (input: LoyaltyPerksContext, slot?: LoyaltyPerksResolver) => readonly LoyaltyPerk[];
+
+export declare const resolveLoyaltyTier: (input: LoyaltyTierContext, slot?: LoyaltyTierResolver) => {
+    readonly id: string;
+    readonly at: string;
+    readonly perks: readonly LoyaltyPerk[];
+};
+
+declare interface ShopCurrencyGrant {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+declare interface ShopItemGrant {
+    readonly itemId: string;
+    readonly qty: number;
+}
+
+export { }

package/dist/loyalty.fixture.js

@@ -0,0 +1,92 @@
+import { defaultLoyaltyPerks as e, defaultLoyaltyTier as t, defineLoyalty as n, resolveLoyaltyPerks as r, resolveLoyaltyTier as i } from "./loyalty.js";
+import { Effect as a } from "effect";
+// src/loyalty.fixture.ts
+var o = () => {
+	let e = [{
+		id: "test.gold",
+		kind: "soft"
+	}], t = n({
+		id: "test.vip",
+		titleKey: "test.vip",
+		pointsFrom: [{
+			id: "virtual.gold",
+			kind: "purchase.virtual",
+			currency: "test.gold",
+			numerator: "1",
+			denominator: "1"
+		}],
+		tiers: [
+			{
+				id: "base",
+				at: "0",
+				perks: []
+			},
+			{
+				id: "silver",
+				at: "1000",
+				perks: [{
+					id: "silver.discount",
+					kind: "discount",
+					bps: 500
+				}]
+			},
+			{
+				id: "gold",
+				at: "10000",
+				perks: [{
+					id: "gold.xp",
+					kind: "xpMultiplier",
+					bps: 12e3
+				}, {
+					id: "gold.badge",
+					kind: "chatBadge",
+					badgeId: "test.gold"
+				}]
+			}
+		],
+		decay: "none"
+	}, e);
+	return Object.freeze({
+		loyalty: t,
+		currencies: e,
+		points: "1000",
+		realMoney: !1
+	});
+}, s = o(), c = Object.freeze({
+	kind: "slot",
+	defaultImplementation: t,
+	defaultProbe: {
+		run: () => a.sync(() => i(s).id),
+		expected: "silver"
+	},
+	overrideProbe: {
+		run: () => a.sync(() => i({
+			...s,
+			rulesVersion: "test.lower.v1"
+		}, () => "base").id),
+		expected: "base"
+	}
+}), l = Object.freeze({
+	kind: "slot",
+	defaultImplementation: e,
+	defaultProbe: {
+		run: () => a.sync(() => r({
+			...s,
+			tierId: "silver"
+		})),
+		expected: [{
+			id: "silver.discount",
+			kind: "discount",
+			bps: 500
+		}]
+	},
+	overrideProbe: {
+		run: () => a.sync(() => r({
+			...s,
+			tierId: "silver",
+			rulesVersion: "test.no-perks.v1"
+		}, () => [])),
+		expected: []
+	}
+});
+export { o as loyaltyFixture, l as loyaltyPerksSystemFixture, c as loyaltyTierSystemFixture };