@voltro/plugin-economy 0.0.0-stage → 0.88.0

package/dist/iapInstalledNotifications.testFixtures.js

@@ -0,0 +1,93 @@
+import { economyError as e } from "./errors.js";
+import { iapNotificationTables as t } from "./iapNotificationTables.entity.js";
+import { iapCurrentStatePort as n } from "./iapCurrentState.server.js";
+import { iapRefundTables as r } from "./iapRefundTables.entity.js";
+import { economyPlugin as i } from "./plugin.js";
+import { iapFixtureLifecycle as a, iapPluginFixture as o } from "./iapPlugin.testFixtures.js";
+import { iapSqlNoticeFixture as s } from "./iapNotificationTarget.testFixtures.js";
+import { inventoryIapRefundAssets as c } from "./iapInventoryRefunds.server.js";
+import { Effect as l } from "effect";
+import { randomBytes as u } from "node:crypto";
+import { ensureTableRegistered as d } from "@voltro/database";
+import { makeFieldCipher as f } from "@voltro/runtime";
+// src/iapInstalledNotifications.testFixtures.ts
+var p = async (p, m = "test.installed.notices", h) => {
+	let g = await o(p, void 0, m), _ = g.base;
+	await l.runPromise(g.close), [...t, ...r].forEach(d);
+	let v = s(_), y = u(24).toString("base64url"), b = f(u(32).toString("base64url")), x = _.at + 1, S = 1, C = 0, w = 0, T = !1, E, D = {
+		...g.options.providers[0],
+		createNotifications: () => ({
+			initialize: () => l.sync(() => {
+				C++;
+			}),
+			verify: (t) => t.body === y ? l.succeed(v.evidence) : l.fail(e("forbidden"))
+		}),
+		createCurrentState: (t) => n({
+			realMoney: !0,
+			channel: "ios",
+			environment: t.environment,
+			applicationId: t.applicationId,
+			accounts: t.accounts,
+			now: t.now
+		}, {
+			initialize: () => l.sync(() => {
+				C++;
+			}),
+			read: (t) => l.suspend(() => (w++, T ? l.fail(e("unavailable")) : (E ? E() : l.void).pipe(l.map(() => ({
+				orderId: t.orderId,
+				channel: "ios",
+				state: S === 0 ? "active" : "revoked",
+				refundNumerator: S,
+				refundDenominator: 1,
+				observedAt: t.at,
+				revokedAt: null
+			})))))
+		})
+	}, O = {
+		...g.options,
+		now: () => x,
+		providers: [D],
+		notifications: {
+			version: "notices.fixture.v1",
+			bodyRetentionMs: 1e3,
+			debtPolicy: "blockSpend",
+			assets: c(p, {
+				inventory: _.inventory,
+				disposition: "requireAll"
+			}),
+			assetsVersion: "items.fixture.v1",
+			cipher: { read: () => b },
+			...h ? { onChange: h } : {}
+		}
+	}, k = i({
+		currencies: _.currencies,
+		realMoney: !0,
+		now: () => x,
+		iap: O
+	});
+	return await k.bindDataStore?.(p), {
+		base: _,
+		store: p,
+		plugin: k,
+		options: O,
+		body: y,
+		notice: v,
+		activate: () => k.onActivate(a),
+		close: () => k.onDeactivate(a),
+		ready: () => C,
+		reads: () => w,
+		failProvider: (e) => {
+			T = e;
+		},
+		beforeRead: (e) => {
+			E = e;
+		},
+		advance: (e) => {
+			x += e;
+		},
+		currentRefund: (e) => {
+			S = e, x++;
+		}
+	};
+};
+export { p as iapInstalledNotificationsFixture };

package/dist/iapInventoryRefunds.server.js

@@ -0,0 +1,261 @@
+import { EconomyError as e, economyError as t } from "./errors.js";
+import { captureBoundMethods as n, dataList as r, dataObject as i, identifier as a } from "./capture.js";
+import { shopInteger as o } from "./shop.js";
+import { canonicalDataJson as s } from "./canonicalDataJson.js";
+import { Effect as c, Result as l } from "effect";
+import { systemSubject as u } from "@voltro/protocol";
+import { createHash as d } from "node:crypto";
+import { and as f, eq as p, queryFor as m } from "@voltro/database";
+import { prepareSqlMutation as h, prepareSqlMutationGroup as g } from "@voltro/database/sql";
+import { inventoryItemsTable as _, inventoryLedgerTable as v, inventoryOperationsTable as y, inventorySubjectsTable as b } from "@voltro/plugin-inventory/server";
+// src/iapInventoryRefunds.server.ts
+var x = (n) => n instanceof e ? n : t("unavailable"), S = async (e) => {
+	let n = await c.runPromise(e.pipe(c.result));
+	if (l.isFailure(n)) throw t(n.failure.code === "erased" ? "erased" : "unavailable");
+	return n.success;
+}, C = (e) => d("sha256").update(s(JSON.parse(JSON.stringify(e)))).digest("hex"), w = (e) => {
+	let n = i(e, [
+		"operationId",
+		"kind",
+		"changes",
+		"at"
+	], "invalid_record");
+	if (n.kind !== "consume" && n.kind !== "grant") throw t("invalid_record");
+	let s = Object.freeze(r(n.changes, 4096, "invalid_record").map((e) => {
+		let r = i(e, ["instanceId", "delta"], "invalid_record"), s = o(r.delta, -1e6, 1e6);
+		if (s === 0 || n.kind === "consume" && s > 0 || n.kind === "grant" && s < 0) throw t("invalid_record");
+		return Object.freeze({
+			instanceId: a(r.instanceId),
+			delta: s
+		});
+	}));
+	if (new Set(s.map((e) => e.instanceId)).size !== s.length) throw t("invalid_record");
+	return Object.freeze({
+		operationId: a(n.operationId),
+		kind: n.kind,
+		changes: s,
+		at: o(n.at, 0, 864e13)
+	});
+}, T = (e) => {
+	let n = i(e, [
+		"disposition",
+		"items",
+		"operations",
+		"targets"
+	], "invalid_record");
+	if (n.disposition !== "requireAll" && n.disposition !== "recoverRemaining") throw t("invalid_record");
+	let s = Object.freeze(r(n.items, 4096, "invalid_record").map((e) => {
+		let s = i(e, [
+			"grantId",
+			"instanceId",
+			"itemId",
+			"original",
+			"requested",
+			"recovered",
+			"unrecoverable",
+			"candidates"
+		], "invalid_record"), c = o(s.original, 1, 1e6), l = o(s.requested, 0, c), u = o(s.recovered, 0, l), d = o(s.unrecoverable, 0, l);
+		if (u + d !== l || n.disposition === "requireAll" && d !== 0) throw t("invalid_record");
+		let f = Object.freeze(r(s.candidates, 4096, "invalid_record").map((e) => a(e)));
+		if (!f.length || new Set(f).size !== f.length) throw t("invalid_record");
+		return Object.freeze({
+			candidates: f,
+			grantId: a(s.grantId),
+			instanceId: a(s.instanceId),
+			itemId: a(s.itemId),
+			original: c,
+			requested: l,
+			recovered: u,
+			unrecoverable: d
+		});
+	}));
+	if (new Set(s.map((e) => e.grantId + ":" + e.instanceId)).size !== s.length) throw t("invalid_record");
+	let c = Object.freeze(r(n.operations, 4096, "invalid_record").map(w));
+	if (new Set(c.map((e) => e.operationId)).size !== c.length) throw t("invalid_record");
+	let l = Object.freeze(r(n.targets, 4096, "invalid_record").map((e) => o(e, 0, s.length - 1)));
+	if (l.length !== c.length) throw t("invalid_record");
+	return Object.freeze({
+		disposition: n.disposition,
+		items: s,
+		operations: c,
+		targets: l
+	});
+}, E = (e, r) => {
+	let l = i(r, ["inventory", "disposition"]), E = n(l.inventory, ["prepareConsume", "prepareGrant"]);
+	if (l.disposition !== "requireAll" && l.disposition !== "recoverRemaining") throw t("invalid_input");
+	let D = l.disposition, O = u("economy.iap-item-refunds"), k = async (e, n, r = !0) => {
+		let { original: i } = n, a = i.scope, o = (await e.query(m(b).where(f(p("tenantId", a.tenantId), p("ownerKind", "player"), p("ownerId", a.ownerId))).limit(2).descriptor))[0];
+		if (!o) throw t("erased");
+		if (r && await e.updateMany(b.tableName, { admission: 0 }, { where: p("id", o.id) }) !== 1) throw t("unavailable");
+		let c = (await e.query(m(b).where(p("id", o.id)).limit(1).descriptor))[0];
+		if (!c || c.erased !== !1 || c.ownerId !== a.ownerId || c.tenantId !== a.tenantId || c.ownerKind !== "player") throw t("erased");
+		let l = [];
+		for (let n of i.receipt.grants) {
+			let r = (await e.query(m(y).where(p("id", n.operationId)).limit(1).descriptor))[0];
+			if (!r || r.tenantId !== a.tenantId || r.ownerKey !== o.id || r.state !== "committed" || s(r.receipt) !== s(n)) throw t("invalid_record");
+			let c = await e.query(m(v).where(f(p("tenantId", a.tenantId), p("operationId", n.operationId))).limit(n.changes.length + 1).descriptor);
+			if (c.length !== n.changes.length) throw t("invalid_record");
+			for (let r of n.changes) {
+				let o = c.find((e) => e.instanceId === r.instanceId);
+				if (!o || o.ownerId !== a.ownerId || o.ownerKind !== "player" || o.delta !== r.delta || o.reason !== "iap.fulfill" || o.refKind !== "iap-order" || o.refId !== i.orderId || o.after === null) throw t("invalid_record");
+				let s = (await e.query(m(_).where(p("id", r.instanceId)).limit(1).descriptor))[0];
+				l.push({
+					grantId: n.operationId,
+					original: o,
+					current: s?.tenantId === a.tenantId && s.ownerId === a.ownerId && s.ownerKind === "player" ? s : null,
+					delta: r.delta
+				});
+			}
+		}
+		if (l.length > 4096) throw t("limit_exceeded");
+		return l;
+	}, A = (e, n) => {
+		let r = T(n), i = e.previous?.assets === null || !e.previous ? null : T(e.previous.assets);
+		if (r.disposition !== D || r.items.length !== e.original.receipt.grants.reduce((e, t) => e + t.changes.length, 0)) throw t("invalid_record");
+		let a = 0, o = 0;
+		for (let [n, c] of r.items.entries()) {
+			let l = e.original.receipt.grants.find((e) => e.operationId === c.grantId)?.changes.find((e) => e.instanceId === c.instanceId), u = e.original.receipt.grants.findIndex((e) => e.operationId === c.grantId);
+			if (e.original.product.offer.items[u]?.itemId !== c.itemId || !l || l.delta !== c.original || c.requested !== Number(BigInt(c.original) * BigInt(e.state.refundNumerator) / BigInt(e.state.refundDenominator))) throw t("invalid_record");
+			let d = i?.items.find((e) => e.grantId === c.grantId && e.instanceId === c.instanceId), f = new Set(d?.candidates ?? [c.instanceId]);
+			for (let [e, t] of r.operations.entries()) if (r.targets[e] === n && t.kind === "grant") for (let e of t.changes) f.add(e.instanceId);
+			if (s([...f].sort()) !== s([...c.candidates].sort())) throw t("invalid_record");
+			let p = c.recovered - (d?.recovered ?? 0);
+			if (p !== r.operations.reduce((e, t, i) => r.targets[i] === n ? e + t.changes.reduce((e, t) => e - t.delta, 0) : e, 0)) throw t("invalid_record");
+			p > 0 ? a += p : o -= p;
+		}
+		let c = r.operations.filter((e) => e.kind === "consume").reduce((e, t) => e + t.changes.reduce((e, t) => e - t.delta, 0), 0), l = r.operations.filter((e) => e.kind === "grant").reduce((e, t) => e + t.changes.reduce((e, t) => e + t.delta, 0), 0);
+		if (a !== c || o !== l) throw t("invalid_record");
+		return r;
+	};
+	return Object.freeze({
+		prepare: (n) => c.tryPromise({
+			catch: x,
+			try: async () => {
+				let r = n.previous?.assets === null || !n.previous ? null : T(n.previous.assets), c = async (e) => {
+					let t = await k(e, n), i = [];
+					for (let a of t) {
+						let t = r?.items.find((e) => e.grantId === a.grantId && e.instanceId === a.original.instanceId), o = [];
+						for (let r of t?.candidates ?? [String(a.original.instanceId)]) {
+							let t = (await e.query(m(_).where(p("id", r)).limit(1).descriptor))[0];
+							o.push(t?.tenantId === n.original.scope.tenantId && t.ownerId === n.original.scope.ownerId && t.ownerKind === "player" ? t : null);
+						}
+						i.push({
+							...a,
+							positions: o
+						});
+					}
+					return i;
+				}, l = await e.transactional(c), u = [], f = [], v = [], y = h(e, async (e) => {
+					if (C(await c(e)) !== C(l)) throw t("conflict");
+					return null;
+				});
+				f.push(y);
+				for (let e of l) {
+					let c = e.grantId, l = a(e.original.instanceId), p = a(e.original.itemId), m = r?.items.find((e) => e.grantId === c && e.instanceId === l), h = Number(BigInt(e.delta) * BigInt(n.state.refundNumerator) / BigInt(n.state.refundDenominator)), g = h - (m?.requested ?? 0), _ = m?.recovered ?? 0, y = "ifa_" + d("sha256").update(s([
+						n.original.orderId,
+						n.sequence,
+						c,
+						l
+					])).digest("hex").slice(0, 56), b = {
+						tenantId: n.original.scope.tenantId,
+						owner: {
+							ownerKind: "player",
+							ownerId: n.original.scope.ownerId
+						},
+						requestId: y,
+						ref: {
+							kind: "iap-order",
+							id: n.original.orderId
+						}
+					};
+					if (g > 0) {
+						let n = i(e.original.after, [
+							"id",
+							"itemId",
+							"schemaVersion",
+							"qty",
+							"attributes",
+							"acquiredAt",
+							"expiresAt",
+							"locked",
+							"source"
+						], "invalid_record"), r = g;
+						for (let t of e.positions) {
+							if (!r) break;
+							let e = t && t.itemId === p && t.locked === !1 && s(t.attributes) === s(n.attributes) ? o(t.qty, 1, 1e6) : 0, i = Math.min(r, e);
+							i && (f.push(await S(E.prepareConsume(O, {
+								...b,
+								requestId: b.requestId + "." + v.length,
+								instanceId: a(t.id),
+								qty: i,
+								reason: "iap.refund"
+							}))), v.push(u.length)), _ += i, r -= i;
+						}
+						if (D === "requireAll" && r) throw t("unavailable");
+					} else if (g < 0) {
+						let t = Math.max(0, _ - h);
+						if (t) {
+							let n = i(e.original.after, [
+								"id",
+								"itemId",
+								"schemaVersion",
+								"qty",
+								"attributes",
+								"acquiredAt",
+								"expiresAt",
+								"locked",
+								"source"
+							], "invalid_record");
+							f.push(await S(E.prepareGrant(O, {
+								...b,
+								itemId: p,
+								qty: t,
+								attributes: n.attributes,
+								reason: "iap.refund-reversed"
+							}))), v.push(u.length);
+						}
+						_ -= t;
+					}
+					u.push(Object.freeze({
+						candidates: m?.candidates ?? [l],
+						grantId: c,
+						instanceId: l,
+						itemId: p,
+						original: e.delta,
+						requested: h,
+						recovered: _,
+						unrecoverable: h - _
+					}));
+				}
+				return g(e, f, async (e, t) => {
+					let r = t.slice(1).map(w), i = u.map((e, t) => ({
+						...e,
+						candidates: [.../* @__PURE__ */ new Set([...e.candidates, ...r.flatMap((e, n) => e.kind === "grant" && v[n] === t ? e.changes.map((e) => e.instanceId) : [])])]
+					}));
+					return A(n, {
+						disposition: D,
+						items: i,
+						operations: r,
+						targets: v
+					});
+				});
+			}
+		}),
+		validate: A,
+		audit: async (e, n, r) => {
+			let i = A(n, r), a = n.original.scope;
+			await k(e, n, !1);
+			for (let [r, o] of i.operations.entries()) {
+				let c = (await e.query(m(y).where(p("id", o.operationId)).limit(1).descriptor))[0];
+				if (!c || c.state !== "committed" || c.tenantId !== a.tenantId || s(c.receipt) !== s(o)) throw t("invalid_record");
+				let l = await e.query(m(v).where(f(p("tenantId", a.tenantId), p("operationId", o.operationId))).limit(o.changes.length + 1).descriptor);
+				if (l.length !== o.changes.length) throw t("invalid_record");
+				for (let e of o.changes) {
+					let s = l.find((t) => t.instanceId === e.instanceId);
+					if (!s || s.itemId !== i.items[i.targets[r]].itemId || s.delta !== e.delta || s.ownerId !== a.ownerId || s.ownerKind !== "player" || s.reason !== (o.kind === "consume" ? "iap.refund" : "iap.refund-reversed") || s.refKind !== "iap-order" || s.refId !== n.original.orderId) throw t("invalid_record");
+				}
+			}
+		}
+	});
+};
+export { E as inventoryIapRefundAssets };

package/dist/iapNotificationCustodyPort.fixture.js

@@ -0,0 +1,67 @@
+import { economyError as e } from "./errors.js";
+import { iapNotificationNotice as t } from "./iapNotifications.server.js";
+import { IapNotificationCustodyPort as n } from "./iapNotificationStore.server.js";
+import { iapNotificationStoreFixture as r } from "./iapNotificationStore.testFixtures.js";
+import { Effect as i, Layer as a } from "effect";
+import { randomBytes as o } from "node:crypto";
+import { InMemoryDataStore as s, makeFieldCipher as c } from "@voltro/runtime";
+// src/iapNotificationCustodyPort.fixture.ts
+var l = /* @__PURE__ */ new WeakMap(), u = i.tryPromise({
+	try: async () => {
+		let e = c(o(32).toString("base64url")), t = { value: !0 };
+		return {
+			...await r(new s(), "fixture.notice", { cipher: { read: () => t.value ? e : void 0 } }),
+			alive: t
+		};
+	},
+	catch: () => e("unavailable")
+}).pipe(i.map((t) => {
+	let n = !0, r = (t) => i.suspend(() => n ? t : i.fail(e("unavailable"))), a = Object.freeze({
+		initialize: () => r(t.custody.initialize()),
+		retain: (e) => r(t.custody.retain(e)),
+		restore: (e) => r(t.custody.restore(e)),
+		markProcessed: (e, n) => r(t.custody.markProcessed(e, n)),
+		pending: () => r(t.custody.pending()),
+		prune: () => r(t.custody.prune()),
+		exportSubject: (e) => r(t.custody.exportSubject(e)),
+		eraseSubject: (e) => r(t.custody.eraseSubject(e))
+	});
+	return l.set(a, {
+		evidence: t.n.evidence,
+		orderId: t.original.orderId
+	}), Object.freeze({
+		service: a,
+		evidence: t.n.evidence,
+		privacy: t.privacy,
+		close: i.sync(() => {
+			n = !1, t.alive.value = !1;
+		})
+	});
+})), d = a.effect(n, i.acquireRelease(u, (e) => e.close).pipe(i.map((e) => e.service))), f = Object.freeze({
+	kind: "port",
+	tag: n,
+	fakeLayer: d,
+	probe: {
+		run: () => i.scoped(i.gen(function* () {
+			let r = yield* n, a = l.get(r);
+			if (!a) return yield* i.fail(e("unavailable"));
+			yield* r.initialize();
+			let o = yield* r.retain(a.evidence), s = yield* r.retain(a.evidence), c = yield* r.restore(o.id), u = yield* r.pending();
+			return {
+				state: o.state,
+				actualOrder: o.orderId === a.orderId,
+				stableIdentity: o.id === s.id,
+				restoredChannel: t(c).channel,
+				pending: u.length
+			};
+		}).pipe(i.provide(d))),
+		expected: {
+			state: "pending",
+			actualOrder: !0,
+			stableIdentity: !0,
+			restoredChannel: "ios",
+			pending: 1
+		}
+	}
+});
+export { d as iapNotificationCustodyFakeLayer, u as iapNotificationCustodyPortFixture, f as iapNotificationCustodyPortSystemFixture };

package/dist/iapNotificationPort.fixture.js

@@ -0,0 +1,73 @@
+import { EconomyError as e, economyError as t } from "./errors.js";
+import { dataObject as n } from "./capture.js";
+import { IapNotificationPort as r, captureNotificationInput as i, iapNotificationNotice as a, issueVerifiedIapNotification as o } from "./iapNotifications.server.js";
+import { Effect as s, Layer as c } from "effect";
+import { randomUUID as l } from "node:crypto";
+// src/iapNotificationPort.fixture.ts
+var u = s.sync(() => {
+	let r = l(), a = Date.now(), c = !1, u = !1, d = Object.freeze({
+		initialize: () => s.suspend(() => u ? s.fail(t("unavailable")) : s.sync(() => {
+			c = !0;
+		})),
+		verify: (l) => {
+			let d;
+			try {
+				d = i(l, 2048);
+			} catch (n) {
+				return s.fail(n instanceof e ? n : t("invalid_input"));
+			}
+			return s.try({
+				try: () => {
+					if (!c || u) throw t("unavailable");
+					if (n(JSON.parse(d.body), ["event"], "invalid_record").event !== "fixture") throw t("forbidden");
+					return o({
+						channel: "ios",
+						applicationId: "fixture.application",
+						environment: "sandbox",
+						noticeId: r,
+						sourceType: "fixture.notification",
+						kind: "test",
+						occurredAt: a,
+						transactionId: null,
+						originalTransactionId: null,
+						storeProductId: null
+					}, {});
+				},
+				catch: (n) => n instanceof e ? n : t("invalid_record")
+			});
+		}
+	});
+	return Object.freeze({
+		service: d,
+		close: s.sync(() => {
+			c = !1, u = !0;
+		})
+	});
+}).pipe(s.tap((e) => e.service.initialize())), d = c.effect(r, s.acquireRelease(u, (e) => e.close).pipe(s.map((e) => e.service))), f = Object.freeze({
+	kind: "port",
+	tag: r,
+	fakeLayer: d,
+	probe: {
+		run: () => s.scoped(s.gen(function* () {
+			let e = yield* (yield* r).verify({ body: JSON.stringify({ event: "fixture" }) }), t = a(e), n = !1;
+			try {
+				a({ ...e });
+			} catch {
+				n = !0;
+			}
+			return {
+				kind: t.kind,
+				channel: t.channel,
+				copiedRefused: n,
+				noPurchaseAuthority: t.transactionId === null
+			};
+		}).pipe(s.provide(d))),
+		expected: {
+			kind: "test",
+			channel: "ios",
+			copiedRefused: !0,
+			noPurchaseAuthority: !0
+		}
+	}
+});
+export { d as iapNotificationFakeLayer, u as iapNotificationPortFixture, f as iapNotificationPortSystemFixture };

package/dist/iapNotificationProcessor.server.js

@@ -0,0 +1,134 @@
+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 { captureIapNotificationService as o, readVerifiedIapNotification as s } from "./iapNotifications.server.js";
+import { captureIapNotificationTargetOptions as c, readAcceptedIapNotificationTarget as l } from "./iapNotificationTarget.server.js";
+import { captureIapCurrentStateService as u } from "./iapCurrentState.server.js";
+import { captureIapRefundService as d } from "./iapRefunds.server.js";
+import { captureIapNotificationCustodyService as f } from "./iapNotificationStore.server.js";
+import { Context as p, Effect as m, Result as h } from "effect";
+import { TextDecoder as g } from "node:util";
+// src/iapNotificationProcessor.server.ts
+var _ = class extends p.Service()("@voltro/IapNotificationProcessorPort") {}, v = (e) => n(e, [
+	"initialize",
+	"ingest",
+	"process",
+	"pending",
+	"prune",
+	"exportSubject",
+	"eraseSubject"
+]), y = (e) => {
+	let a = r(e, [
+		"deployment",
+		"notifications",
+		"current",
+		"custody",
+		"refunds",
+		"orders",
+		"changed"
+	]);
+	if (a.changed !== void 0 && typeof a.changed != "function") throw t("invalid_input");
+	let p = a.changed, h = c(a.deployment), g = o(a.notifications), _ = u(a.current), v = f(a.custody), y = d(a.refunds), b = n(a.orders, ["prepareNotification"]), x = (e) => p === void 0 ? m.succeed(null) : l(e).pipe(m.map((e) => ({
+		tenantId: e.scope.tenantId,
+		ownerId: e.scope.ownerId,
+		offerId: e.receipt.offerId,
+		offerVersion: e.receipt.offerVersion
+	}))), S = (e, t) => p === void 0 || e === null ? m.void : m.suspend(() => p(Object.freeze({
+		...e,
+		orderId: t.orderId,
+		state: t.state
+	}))).pipe(m.catchCause(() => m.void)), C = (e) => m.try({
+		try: () => i(e),
+		catch: () => t("invalid_input")
+	}).pipe(m.flatMap((e) => v.restore(e).pipe(m.flatMap((e) => b.prepareNotification(h, e)), m.flatMap((t) => x(t).pipe(m.flatMap((n) => _.read(t).pipe(m.flatMap((e) => y.reconcile(e)), m.flatMap((t) => v.markProcessed(e, t).pipe(m.tap(() => S(n, t)))))))))), m.catchDefect(() => m.fail(t("unavailable"))));
+	return Object.freeze({
+		initialize: () => m.gen(function* () {
+			yield* v.initialize(), yield* g.initialize(), yield* _.initialize();
+		}).pipe(m.catchDefect(() => m.fail(t("unavailable")))),
+		ingest: (e) => g.verify(e).pipe(m.flatMap((e) => s(e).notice.kind === "test" ? m.succeed(null) : v.retain(e).pipe(m.flatMap((e) => e.state === "processed" ? m.succeed(e) : e.state === "pending" ? C(e.id) : m.fail(t(e.state === "erased" ? "erased" : "unavailable"))))), m.catchDefect(() => m.fail(t("unavailable")))),
+		process: C,
+		pending: v.pending,
+		prune: v.prune,
+		exportSubject: (e) => m.gen(function* () {
+			return {
+				notifications: yield* v.exportSubject(e),
+				refunds: yield* y.exportSubject(e)
+			};
+		}),
+		eraseSubject: (e) => v.eraseSubject(e).pipe(m.flatMap(() => y.eraseSubject(e)))
+	});
+}, b = (n) => {
+	let i = r(n, [
+		"path",
+		"maxBodyBytes",
+		"processor",
+		"deliver"
+	]);
+	if (typeof i.path != "string" || !/^\/(?:[A-Za-z0-9_-]+\/)*[A-Za-z0-9_-]+$/.test(i.path) || i.path.length > 240) throw t("invalid_input");
+	let o = i.path, s = a(i.maxBodyBytes, 1024, 1048576), c = v(i.processor);
+	if (i.deliver !== void 0 && typeof i.deliver != "function") throw t("invalid_input");
+	let l = i.deliver;
+	return Object.freeze({
+		path: o,
+		method: "POST",
+		match: "exact",
+		answersOtherMethods: !0,
+		originGuard: "exempt",
+		maxBodyBytes: s,
+		handle: async (n) => {
+			let r = {
+				"cache-control": "no-store",
+				"x-content-type-options": "nosniff"
+			};
+			if (n.path !== o) return {
+				status: 404,
+				headers: r
+			};
+			if (n.method !== "POST") return {
+				status: 405,
+				headers: {
+					...r,
+					allow: "POST"
+				}
+			};
+			if (n.rawBody.byteLength > s) return {
+				status: 413,
+				headers: r
+			};
+			if (n.query || n.headers["content-encoding"] && n.headers["content-encoding"] !== "identity") return {
+				status: 400,
+				headers: r
+			};
+			let i;
+			try {
+				i = new g("utf-8", { fatal: !0 }).decode(n.rawBody);
+			} catch {
+				return {
+					status: 400,
+					headers: r
+				};
+			}
+			if (!i.length) return {
+				status: 400,
+				headers: r
+			};
+			let a = {
+				body: i,
+				...n.headers.authorization === void 0 ? {} : { authorization: n.headers.authorization },
+				headers: Object.fromEntries(Object.entries(n.headers).filter((e) => e[0] !== "authorization" && typeof e[1] == "string").slice(0, 64))
+			}, u = (l ? l(a) : m.succeed(!1)).pipe(m.flatMap((e) => e ? m.void : m.asVoid(c.ingest(a)))), d = await m.runPromise(u.pipe(m.result)).catch(() => h.fail(t("unavailable")));
+			if (h.isSuccess(d)) return {
+				status: 204,
+				headers: r
+			};
+			let f = d.failure;
+			return {
+				status: f instanceof e && f.code === "forbidden" ? 401 : f instanceof e && f.code === "limit_exceeded" ? 413 : f instanceof e && f.code === "invalid_input" ? 400 : 503,
+				headers: r,
+				body: "IAP notification refused",
+				contentType: "text/plain; charset=utf-8"
+			};
+		}
+	});
+};
+export { _ as IapNotificationProcessorPort, v as captureIapNotificationProcessorService, b as iapNotificationHttpRoute, y as iapNotificationProcessor };