@voltro/plugin-economy 0.0.0-stage → 0.88.0

package/dist/iapCurrentState.server.js

@@ -0,0 +1,107 @@
+import { EconomyError as e, economyError as t } from "./errors.js";
+import { captureBoundMethods as n, dataObject as r, identifier as i } from "./capture.js";
+import { shopInteger as a } from "./shop.js";
+import { iapTimestamp as o } from "./iap.js";
+import { canonicalDataJson as s } from "./canonicalDataJson.js";
+import { captureIapNotificationTargetOptions as c, readAcceptedIapNotificationTarget as l } from "./iapNotificationTarget.server.js";
+import { Context as u, Effect as d } from "effect";
+// src/iapCurrentState.server.ts
+var f = class extends u.Service()("@voltro/IapCurrentStatePort") {}, p = /* @__PURE__ */ new WeakMap(), m = (n) => n instanceof e ? n : t("unavailable"), h = (e, n) => {
+	let s = r(e, [
+		"orderId",
+		"channel",
+		"state",
+		"refundNumerator",
+		"refundDenominator",
+		"observedAt",
+		"revokedAt"
+	], "invalid_record"), c = a(s.refundDenominator, 1, 1e5), l = a(s.refundNumerator, 0, c), u = l === 0 ? "active" : l === c ? "revoked" : "partially-refunded", d = o(s.observedAt), f = s.revokedAt === null ? null : o(s.revokedAt);
+	if (s.orderId !== n.orderId || s.channel !== n.facts.channel || s.state !== u || d < n.at || f !== null && (l === 0 || f < n.facts.purchasedAt || f > d)) throw t("invalid_record");
+	return Object.freeze({
+		orderId: i(s.orderId),
+		channel: s.channel,
+		state: u,
+		refundNumerator: l,
+		refundDenominator: c,
+		observedAt: d,
+		revokedAt: f
+	});
+}, g = (e) => {
+	let n = typeof e == "object" && e ? p.get(e) : void 0;
+	return n ? d.suspend(n.read).pipe(d.map((e) => Object.freeze({
+		state: n.state,
+		original: e,
+		assertFresh: n.assertFresh,
+		prepareBinding: n.prepareBinding
+	})), d.catchDefect(() => d.fail(t("unavailable")))) : d.fail(t("forbidden"));
+}, _ = (e) => g(e).pipe(d.map((e) => e.state)), v = (e) => n(e, ["initialize", "read"]), y = (e, i) => {
+	let u = r(e, [
+		"realMoney",
+		"channel",
+		"applicationId",
+		"environment",
+		"accounts",
+		"maxAgeMs",
+		"now"
+	]), f = c({
+		realMoney: u.realMoney,
+		channel: u.channel,
+		applicationId: u.applicationId,
+		environment: u.environment
+	}), g = n(u.accounts, ["observe", "prepareBinding"]), _ = n(i, ["initialize", "read"]), v = a(u.maxAgeMs ?? 3e4, 1, 3e5), y = u.now ?? Date.now;
+	if (typeof y != "function") throw t("invalid_input");
+	let b = () => o(y()), x = (e) => l(e).pipe(d.flatMap((e) => e.facts.channel !== f.channel || e.facts.environment !== f.environment || e.facts.applicationId !== f.applicationId ? d.fail(t("forbidden")) : g.observe(e.scope, f.channel, f.environment).pipe(d.map((t) => Object.freeze({
+		...e,
+		accountToken: t
+	})))));
+	return Object.freeze({
+		initialize: () => d.suspend(() => _.initialize()).pipe(d.catchDefect(() => d.fail(t("unavailable")))),
+		read: (e) => x(e).pipe(d.flatMap((e) => d.try({
+			try: () => Object.freeze({
+				...e,
+				at: b()
+			}),
+			catch: m
+		})), d.flatMap((n) => d.suspend(() => _.read(n)).pipe(d.flatMap((e) => d.try({
+			try: () => h(e, n),
+			catch: m
+		})), d.flatMap((r) => {
+			let i = () => x(e).pipe(d.flatMap((e) => d.try({
+				try: () => {
+					let i = b();
+					if (i < r.observedAt || i - r.observedAt > v) throw t("unavailable");
+					if (e.accountToken !== n.accountToken || s([
+						e.scope,
+						e.receipt,
+						e.facts,
+						e.product,
+						e.currencies,
+						e.fingerprint
+					]) !== s([
+						n.scope,
+						n.receipt,
+						n.facts,
+						n.product,
+						n.currencies,
+						n.fingerprint
+					])) throw t("conflict");
+					return e;
+				},
+				catch: m
+			})));
+			return i().pipe(d.map(() => {
+				let e = Object.freeze({ orderId: n.orderId });
+				return p.set(e, Object.freeze({
+					state: r,
+					read: i,
+					assertFresh: () => {
+						let e = b();
+						if (e < r.observedAt || e - r.observedAt > v) throw t("unavailable");
+					},
+					prepareBinding: () => g.prepareBinding(n.scope, f.channel, f.environment, n.accountToken)
+				})), e;
+			}));
+		}))), d.catchDefect(() => d.fail(t("unavailable"))))
+	});
+};
+export { f as IapCurrentStatePort, v as captureIapCurrentStateService, _ as iapCurrentPurchaseState, y as iapCurrentStatePort, g as readVerifiedIapCurrentState };

package/dist/iapCurrentState.testFixtures.js

@@ -0,0 +1,22 @@
+import { iapStoreFixture as e } from "./iapStore.testFixtures.js";
+import { iapSqlNoticeFixture as t } from "./iapNotificationTarget.testFixtures.js";
+import { Effect as n } from "effect";
+import "node:crypto";
+import { InMemoryDataStore as r } from "@voltro/runtime";
+// src/iapCurrentState.testFixtures.ts
+var i = async () => {
+	let i = new r(), a = await e(i), o = await n.runPromise(a.iap.redeem(a.user(), a.intent)), s = t(a);
+	return {
+		store: i,
+		f: a,
+		accepted: o,
+		n: s,
+		target: await n.runPromise(a.iap.prepareNotification(s.options, s.evidence)),
+		options: {
+			...s.options,
+			accounts: a.accounts,
+			now: () => a.at
+		}
+	};
+};
+export { i as currentStateSqlFixture };

package/dist/iapCurrentStatePort.fixture.js

@@ -0,0 +1,63 @@
+import { economyError as e } from "./errors.js";
+import { IapCurrentStatePort as t, iapCurrentPurchaseState as n, iapCurrentStatePort as r } from "./iapCurrentState.server.js";
+import { currentStateSqlFixture as i } from "./iapCurrentState.testFixtures.js";
+import { Effect as a, Layer as o, Result as s } from "effect";
+// src/iapCurrentStatePort.fixture.ts
+var c = /* @__PURE__ */ new WeakMap(), l = a.tryPromise({
+	try: i,
+	catch: () => e("unavailable")
+}).pipe(a.map((t) => {
+	let n = !0, i = !1, o = { observe: ((...r) => a.suspend(() => n && !i ? t.f.accounts.observe(...r) : a.fail(e("unavailable")))) }, s = r({
+		...t.options,
+		accounts: {
+			...o,
+			prepareBinding: (...r) => a.suspend(() => n && !i ? t.f.accounts.prepareBinding(...r) : a.fail(e("unavailable")))
+		}
+	}, {
+		initialize: () => a.void,
+		read: (e) => a.succeed({
+			orderId: e.orderId,
+			channel: "ios",
+			state: "active",
+			refundNumerator: 0,
+			refundDenominator: 1,
+			observedAt: e.at,
+			revokedAt: null
+		})
+	}), l = Object.freeze({
+		initialize: () => a.suspend(() => i ? a.fail(e("unavailable")) : s.initialize()),
+		read: (t) => a.suspend(() => n && !i ? s.read(t) : a.fail(e("unavailable")))
+	});
+	return c.set(l, t), Object.freeze({
+		service: l,
+		target: t.target,
+		original: t.accepted,
+		close: a.sync(() => {
+			n = !1, i = !0;
+		})
+	});
+})), u = o.effect(t, a.acquireRelease(l, (e) => e.close).pipe(a.map((e) => e.service))), d = Object.freeze({
+	kind: "port",
+	tag: t,
+	fakeLayer: u,
+	probe: {
+		run: () => a.scoped(a.gen(function* () {
+			let r = yield* t, i = c.get(r);
+			if (!i) return yield* a.fail(e("unavailable"));
+			let o = yield* r.read(i.target), l = yield* n(o), u = yield* r.read({ ...i.target }).pipe(a.result);
+			return {
+				state: l.state,
+				share: [l.refundNumerator, l.refundDenominator],
+				copiedRefused: s.isFailure(u),
+				actualOrder: l.orderId === i.accepted.orderId
+			};
+		}).pipe(a.provide(u))),
+		expected: {
+			state: "active",
+			share: [0, 1],
+			copiedRefused: !0,
+			actualOrder: !0
+		}
+	}
+});
+export { u as iapCurrentStateFakeLayer, l as iapCurrentStatePortFixture, d as iapCurrentStatePortSystemFixture };

package/dist/iapEntitlements.d.ts

@@ -0,0 +1,79 @@
+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 captureIapEntitlementObservation: (input: unknown) => IapEntitlementObservation;
+
+export declare const captureIapEntitlementsService: (input: IapEntitlementsService) => IapEntitlementsService;
+
+/** Half-open accepted period only. No grace, future renewal or provider status is invented. */
+export declare const defaultIapEntitlementPolicy: IapEntitlementPolicy;
+
+declare type EconomyChannel = 'web' | 'ios' | 'android' | 'steam';
+
+/** 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 IapEntitlementObservation {
+    readonly offerId: string;
+    readonly entitled: boolean;
+    readonly expiresAt: number | null;
+    readonly observedAt: number;
+}
+
+export declare type IapEntitlementPolicy = (context: IapEntitlementPolicyContext) => boolean;
+
+export declare interface IapEntitlementPolicyContext {
+    readonly period: IapSubscriptionPeriod;
+    readonly at: number;
+}
+
+/** Complete replacement owns authoritative history, privacy and expiry admission. */
+export declare class IapEntitlementsPort extends IapEntitlementsPort_base {
+}
+
+declare const IapEntitlementsPort_base: Context.ServiceClass<IapEntitlementsPort, "@voltro/IapEntitlementsPort", IapEntitlementsService>;
+
+export declare interface IapEntitlementsService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly entitled: (subject: Subject, offerId: string) => Effect.Effect<IapEntitlementObservation, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+/** Accepted SQL refund history only. This projection never authorizes a grant or completion. */
+declare interface IapRefundDisposition {
+    readonly sequence: number;
+    readonly state: 'active' | 'partially-refunded' | 'revoked';
+    readonly refundNumerator: number;
+    readonly refundDenominator: number;
+    readonly observedAt: number;
+}
+
+/** An accepted store period, not a fresh provider observation or financial capability. */
+declare interface IapSubscriptionPeriod {
+    readonly orderId: string;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly channel: EconomyChannel;
+    readonly startsAt: number;
+    readonly expiresAt: number;
+    readonly refund: IapRefundDisposition | null;
+}
+
+export declare const resolveIapEntitlement: (input: {
+    readonly offerId: string;
+    readonly periods: readonly IapSubscriptionPeriod[];
+    readonly at: number;
+    readonly version: string;
+}, policy?: IapEntitlementPolicy) => IapEntitlementObservation;
+
+export { }

package/dist/iapEntitlements.js

@@ -0,0 +1,57 @@
+import { economyError as e } from "./errors.js";
+import { captureBoundMethods as t, dataList as n, dataObject as r, identifier as i } from "./capture.js";
+import { captureIapSubscriptionPeriod as a, iapTimestamp as o } from "./iap.js";
+import { Context as s } from "effect";
+// src/iapEntitlements.ts
+var c = (t) => {
+	let n = r(t, [
+		"offerId",
+		"entitled",
+		"expiresAt",
+		"observedAt"
+	], "invalid_record"), a = i(n.offerId, "invalid_record"), s = o(n.observedAt);
+	if (typeof n.entitled != "boolean") throw e("invalid_record");
+	let c = n.expiresAt === null ? null : o(n.expiresAt);
+	if (n.entitled ? c === null || c <= s : c !== null) throw e("invalid_record");
+	return Object.freeze({
+		offerId: a,
+		entitled: n.entitled,
+		expiresAt: c,
+		observedAt: s
+	});
+}, l = ({ period: e, at: t }) => t >= e.startsAt && t < e.expiresAt && e.refund?.state !== "revoked", u = (t, s = l) => {
+	let c = r(t, [
+		"offerId",
+		"periods",
+		"at",
+		"version"
+	]), u = i(c.offerId), d = o(c.at), f = i(c.version);
+	if (typeof s != "function" || s !== l && f === "default.v1") throw e("invalid_input");
+	let p = Object.freeze(n(c.periods, 1e5, "invalid_record").map(a));
+	if (new Set(p.map((e) => e.orderId)).size !== p.length) throw e("invalid_record");
+	let m = null;
+	for (let t of p) {
+		if (t.offerId !== u) continue;
+		let n = s(Object.freeze({
+			period: t,
+			at: d
+		}));
+		if (typeof n != "boolean") throw e("invalid_record");
+		n && l({
+			period: t,
+			at: d
+		}) && (m = m === null ? t.expiresAt : Math.max(m, t.expiresAt));
+	}
+	return Object.freeze({
+		offerId: u,
+		entitled: m !== null,
+		expiresAt: m,
+		observedAt: d
+	});
+}, d = class extends s.Service()("@voltro/IapEntitlementsPort") {}, f = (e) => t(e, [
+	"initialize",
+	"entitled",
+	"exportSubject",
+	"eraseSubject"
+]);
+export { d as IapEntitlementsPort, c as captureIapEntitlementObservation, f as captureIapEntitlementsService, l as defaultIapEntitlementPolicy, u as resolveIapEntitlement };

package/dist/iapEntitlements.server.js

@@ -0,0 +1,48 @@
+import { EconomyError as e, economyError as t } from "./errors.js";
+import { captureBoundMethods as n, dataObject as r, identifier as i } from "./capture.js";
+import { iapTimestamp as a } from "./iap.js";
+import { defaultIapEntitlementPolicy as o, resolveIapEntitlement as s } from "./iapEntitlements.js";
+import { Effect as c } from "effect";
+// src/iapEntitlements.server.ts
+var l = (n) => n instanceof e ? n : t("unavailable"), u = (e) => {
+	let u = r(e, [
+		"realMoney",
+		"version",
+		"orders",
+		"policy",
+		"now"
+	]);
+	if (u.realMoney !== !0) throw t(u.realMoney === !1 ? "real_money_disabled" : "invalid_input");
+	let d = i(u.version), f = u.policy ?? o, p = u.now ?? Date.now;
+	if (typeof f != "function" || typeof p != "function" || f !== o && d === "default.v1") throw t("invalid_input");
+	let m = n(u.orders, [
+		"subscriptionPeriods",
+		"exportSubject",
+		"eraseSubject"
+	]), h = (e) => {
+		let n = structuredClone(e);
+		if (n.type !== "user") throw t("forbidden");
+		return i(n.id), i(n.tenantId), n;
+	};
+	return Object.freeze({
+		initialize: () => c.void,
+		entitled: (e, n) => c.try({
+			try: () => ({
+				subject: h(e),
+				offerId: i(n)
+			}),
+			catch: l
+		}).pipe(c.flatMap(({ subject: e, offerId: n }) => c.suspend(() => m.subscriptionPeriods(e)).pipe(c.flatMap((e) => c.try({
+			try: () => s({
+				offerId: n,
+				periods: e,
+				at: a(p()),
+				version: d
+			}, f),
+			catch: l
+		})), c.catchDefect(() => c.fail(t("unavailable")))))),
+		exportSubject: (e) => c.suspend(() => m.exportSubject(structuredClone(e))).pipe(c.catchDefect(() => c.fail(t("unavailable")))),
+		eraseSubject: (e) => c.suspend(() => m.eraseSubject(structuredClone(e))).pipe(c.catchDefect(() => c.fail(t("unavailable"))))
+	});
+};
+export { u as iapEntitlementsPort };

package/dist/iapEntitlementsBinding.server.js

@@ -0,0 +1,105 @@
+import { EconomyError as e, economyError as t } from "./errors.js";
+import { captureQueryTables as n, dataObject as r, identifier as i } from "./capture.js";
+import { IapEntitlementsPort as a, captureIapEntitlementObservation as o, captureIapEntitlementsService as s, defaultIapEntitlementPolicy as c } from "./iapEntitlements.js";
+import { iapEntitlementsPort as l } from "./iapEntitlements.server.js";
+import { Effect as u, Layer as d } from "effect";
+// src/iapEntitlementsBinding.server.ts
+var f = () => u.fail(t("unavailable")), p = Object.freeze({
+	initialize: f,
+	entitled: f,
+	exportSubject: f,
+	eraseSubject: f
+}), m = (p, m) => {
+	if (p === void 0) return;
+	let h = r(p, [
+		"version",
+		"policy",
+		"service",
+		"querySources"
+	]), g = i(h.version);
+	if (g === "default.v1" || m.subscriptionOffers.length === 0) throw t("invalid_input");
+	let _ = h.service === void 0 ? void 0 : s(h.service);
+	if (m.replacedIap && !_ || _ && h.policy !== void 0 || !_ && !m.refundDispositionInstalled) throw t("invalid_input");
+	let v = h.policy ?? c;
+	if (typeof v != "function") throw t("invalid_input");
+	let y = h.querySources === void 0 ? [] : n(h.querySources);
+	if (_ && y.length === 0) throw t("invalid_input");
+	let b = new Set(m.subscriptionOffers), x, S, C = 0, w = () => x !== void 0 && m.isActive(), T = (e) => u.suspend(() => {
+		let t = _ ?? S, n = C;
+		return t && w() ? u.suspend(() => e(t)).pipe(u.flatMap((e) => w() && C === n && (_ ?? S) === t ? u.succeed(e) : f()), u.catchDefect(() => f())) : f();
+	}), E = () => u.suspend(() => {
+		let e = _ ?? S, t = C;
+		return x && e ? u.suspend(() => e.initialize()).pipe(u.flatMap(() => x && C === t ? u.void : f()), u.catchDefect(() => f())) : f();
+	}), D = (e) => {
+		let n = r(e, [
+			"tenantId",
+			"subjectId",
+			"kind"
+		]);
+		if (n.kind !== "guest" && n.kind !== "user") throw t("invalid_input");
+		return Object.freeze({
+			tenantId: i(n.tenantId),
+			subjectId: i(n.subjectId),
+			kind: n.kind
+		});
+	}, O = Object.freeze({
+		initialize: E,
+		entitled: (n, r) => u.try({
+			try: () => {
+				let e = structuredClone(n), a = i(r);
+				if (e.type !== "user") throw t("forbidden");
+				if (i(e.id), i(e.tenantId), !b.has(a)) throw t("not_found");
+				return {
+					subject: e,
+					offerId: a
+				};
+			},
+			catch: (n) => n instanceof e ? n : t("invalid_input")
+		}).pipe(u.flatMap(({ subject: n, offerId: r }) => T((i) => i.entitled(n, r).pipe(u.flatMap((n) => u.try({
+			try: () => {
+				let e = o(n);
+				if (e.offerId !== r) throw t("conflict");
+				return e;
+			},
+			catch: (n) => n instanceof e ? n : t("invalid_record")
+		})))))),
+		exportSubject: (e) => u.try({
+			try: () => D(e),
+			catch: () => t("invalid_input")
+		}).pipe(u.flatMap((e) => T((t) => t.exportSubject(e)))),
+		eraseSubject: (e) => u.try({
+			try: () => D(e),
+			catch: () => t("invalid_input")
+		}).pipe(u.flatMap((e) => T((t) => t.eraseSubject(e))))
+	}), k = (e, n) => {
+		if (x && x !== e) throw Error("IAP entitlements cannot cross app stores");
+		if (x = e, C++, S = void 0, !_) {
+			if (!n) throw t("unavailable");
+			S = l({
+				realMoney: !0,
+				version: g,
+				orders: n,
+				policy: v,
+				now: m.now
+			});
+		}
+	}, A = Object.freeze({
+		backend: _ ? "custom" : "sql",
+		version: g,
+		policy: _ ? "app-owned" : v === c ? "default" : "custom",
+		budgets: _ ? null : { historyRows: m.historyRows }
+	});
+	return Object.freeze({
+		service: O,
+		initialize: E,
+		bind: k,
+		querySources: y,
+		status: A,
+		custom: _ !== void 0,
+		layer: d.succeed(a, O),
+		deactivate: () => {
+			C++, x = void 0, S = void 0;
+		}
+	});
+};
+export { m as bindIapEntitlementsSystem, p as unavailableIapEntitlements };

package/dist/iapEntitlementsPort.fixture.js

@@ -0,0 +1,80 @@
+import { economyError as e } from "./errors.js";
+import { captureIapSubscriptionPeriod as t } from "./iap.js";
+import { IapEntitlementsPort as n, defaultIapEntitlementPolicy as r, resolveIapEntitlement as i } from "./iapEntitlements.js";
+import { iapInstalledEntitlementsFixture as a } from "./iapInstalledEntitlements.testFixtures.js";
+import { Effect as o, Layer as s } from "effect";
+import { InMemoryDataStore as c } from "@voltro/runtime";
+// src/iapEntitlementsPort.fixture.ts
+var l = /* @__PURE__ */ new WeakMap(), u = o.tryPromise({
+	try: () => a(new c(), "fixture.iap.entitlements"),
+	catch: () => e("unavailable")
+}).pipe(o.flatMap((e) => e.activate().pipe(o.flatMap(() => e.plugin.economy.iap().redeem(e.base.user(), e.base.intent)), o.map(() => {
+	let t = e.plugin.economy.iapEntitlements();
+	return l.set(t, e), Object.freeze({
+		service: t,
+		fixture: e,
+		close: e.close().pipe(o.orDie)
+	});
+}), o.onError(() => e.close().pipe(o.orDie))))), d = s.effect(n, o.acquireRelease(u, (e) => e.close).pipe(o.map((e) => e.service))), f = Object.freeze({
+	kind: "port",
+	tag: n,
+	fakeLayer: d,
+	probe: {
+		run: () => o.scoped(o.gen(function* () {
+			let t = yield* n, r = l.get(t);
+			if (!r) return yield* o.fail(e("unavailable"));
+			let i = yield* t.entitled(r.base.user(), r.base.intent.offerId), a = yield* t.entitled(r.base.user("other"), r.base.intent.offerId), s = r.verifications();
+			r.setTime(r.base.at + 1e3);
+			let c = yield* t.entitled(r.base.user(), r.base.intent.offerId);
+			return {
+				accepted: i.entitled,
+				ownsExpiry: i.expiresAt === r.base.at + 1e3,
+				foreign: a.entitled,
+				expired: c.entitled,
+				expiryIsReadOnly: r.verifications() === s
+			};
+		}).pipe(o.provide(d))),
+		expected: {
+			accepted: !0,
+			ownsExpiry: !0,
+			foreign: !1,
+			expired: !1,
+			expiryIsReadOnly: !0
+		}
+	}
+}), p = () => Object.freeze({
+	offerId: "fixture.subscription",
+	at: 150,
+	version: "fixture.entitlement.policy.v1",
+	periods: Object.freeze([t({
+		orderId: "fixture.original",
+		offerId: "fixture.subscription",
+		offerVersion: "fixture.v1",
+		channel: "ios",
+		startsAt: 100,
+		expiresAt: 200,
+		refund: null
+	})])
+}), m = Object.freeze({
+	kind: "slot",
+	defaultImplementation: r,
+	defaultProbe: {
+		run: () => o.sync(() => i(p())),
+		expected: {
+			offerId: "fixture.subscription",
+			entitled: !0,
+			expiresAt: 200,
+			observedAt: 150
+		}
+	},
+	overrideProbe: {
+		run: () => o.sync(() => i(p(), () => !1)),
+		expected: {
+			offerId: "fixture.subscription",
+			entitled: !1,
+			expiresAt: null,
+			observedAt: 150
+		}
+	}
+});
+export { p as iapEntitlementPolicyFixture, m as iapEntitlementPolicySystemFixture, d as iapEntitlementsFakeLayer, u as iapEntitlementsPortFixture, f as iapEntitlementsPortSystemFixture };

package/dist/iapInstalledEntitlements.testFixtures.js

@@ -0,0 +1,75 @@
+import { iapVerificationPort as e } from "./iapVerification.server.js";
+import { economyPlugin as t } from "./plugin.js";
+import { iapFixtureLifecycle as n } from "./iapPlugin.testFixtures.js";
+import { inventoryIapRefundAssets as r } from "./iapInventoryRefunds.server.js";
+import { iapInstalledNotificationsFixture as i } from "./iapInstalledNotifications.testFixtures.js";
+import { Effect as a } from "effect";
+import { dataStoreInventory as o } from "@voltro/plugin-inventory/server";
+// src/iapInstalledEntitlements.testFixtures.ts
+var s = async (s, c = "test.installed.entitlements") => {
+	let l = await i(s, c), u = l.base;
+	await a.runPromise(l.close());
+	let d = u.at, f = 0, p = o(s, {
+		items: [u.item],
+		catalogSource: u.catalog,
+		channel: "live",
+		locale: "en",
+		now: () => d
+	}), m = {
+		...l.options,
+		inventory: p,
+		now: () => d,
+		products: [{
+			...u.definition,
+			kind: "subscription",
+			offer: {
+				...u.definition.offer,
+				maxQuantity: 1
+			}
+		}],
+		providers: [{
+			...l.options.providers[0],
+			create: (t) => e(t, {
+				initialize: () => a.void,
+				verify: () => (f++, a.succeed({
+					...u.facts,
+					transactionId: u.transactionId,
+					kind: "subscription",
+					quantity: 1,
+					purchasedAt: u.at - 1e3,
+					expiresAt: u.at + 1e3,
+					acknowledgement: "none",
+					consumption: "none"
+				}))
+			})
+		}],
+		notifications: {
+			...l.options.notifications,
+			assets: r(s, {
+				inventory: p,
+				disposition: "requireAll"
+			})
+		},
+		entitlements: { version: "periods.fixture.v1" }
+	}, h = t({
+		currencies: u.currencies,
+		realMoney: !0,
+		now: () => d,
+		iap: m
+	});
+	await h.bindDataStore?.(s);
+	let g = () => h.onActivate(n), _ = () => h.onDeactivate(n);
+	return {
+		...l,
+		plugin: h,
+		options: m,
+		inventory: p,
+		activate: g,
+		close: _,
+		setTime: (e) => {
+			d = e;
+		},
+		verifications: () => f
+	};
+};
+export { s as iapInstalledEntitlementsFixture };