@voltro/plugin-economy 0.0.0-stage → 0.87.0

package/dist/testing.d.ts

@@ -0,0 +1,4615 @@
+import { CatalogImport } from '@voltro/plugin-inventory/server';
+import { CatalogScope } from '@voltro/plugin-inventory';
+import { CatalogSnapshot } from '@voltro/plugin-inventory';
+import { Context } from 'effect';
+import { DataStore } from '@voltro/database';
+import { Effect } from 'effect';
+import { FieldCipher } from '@voltro/database';
+import { InMemoryDataStore } from '@voltro/runtime';
+import { InventoryError } from '@voltro/plugin-inventory';
+import { InventoryInstance } from '@voltro/plugin-inventory';
+import { InventoryReceipt } from '@voltro/plugin-inventory';
+import { InventoryReservationTransferReceipt } from '@voltro/plugin-inventory/server';
+import { InventorySqlService } from '@voltro/plugin-inventory/server';
+import { ItemContract } from '@voltro/plugin-inventory';
+import { JWSTransactionDecodedPayload } from '@apple/app-store-server-library';
+import { Layer } from 'effect';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { PreparedSqlMutation } from '@voltro/database/sql';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { VoltroPlugin } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+declare const acceptedCompletion: unique symbol;
+
+/** SQL-issued capability. A player reference or serialized object cannot authorize provider completion. */
+declare interface AcceptedIapCompletion {
+    readonly [acceptedCompletion]: true;
+    readonly orderId: string;
+}
+
+/** Read-only SQL custody capability, never current provider state or refund authority. */
+declare interface AcceptedIapNotificationTarget {
+    readonly [acceptedNotificationTarget]: true;
+    readonly orderId: string;
+    readonly noticeId: string;
+}
+
+declare const acceptedNotificationTarget: unique symbol;
+
+declare interface CodeDefinition {
+    readonly id: string;
+    readonly version?: string | undefined;
+    readonly campaign: string;
+    readonly items?: readonly {
+        readonly itemId: string | undefined;
+        readonly qty: number;
+    }[];
+    readonly currencies?: readonly {
+        readonly currency: string | undefined;
+        readonly amount: EconomyAmountInput;
+    }[];
+    readonly from?: number | null;
+    readonly until?: number | null;
+    readonly limits: {
+        readonly global: number;
+        readonly perPlayer: number;
+    };
+}
+
+declare type CodeEligibility = (input: CodeEligibilityContext) => boolean;
+
+declare interface CodeEligibilityContext {
+    readonly definition: PromoCode;
+    readonly at: number;
+    readonly claims: number;
+    readonly playerClaims: number;
+}
+
+export declare const codeEligibilityFixture: () => Readonly<{
+    currencies: {
+        id: string;
+        kind: "soft";
+        cap: string;
+    }[];
+    context: Readonly<{
+        definition: PromoCode;
+        at: 1;
+        claims: 0;
+        playerClaims: 0;
+    }>;
+}>;
+
+export declare const codeEligibilitySystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: CodeEligibility;
+    defaultProbe: {
+        run: () => Effect.Effect<boolean, never, never>;
+        expected: boolean;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<boolean, never, never>;
+        expected: boolean;
+    };
+}>;
+
+declare type CodeObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed' | 'pending';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: CodeReceipt;
+};
+
+declare class CodePort extends CodePort_base {
+}
+
+declare const CodePort_base: Context.ServiceClass<CodePort, "@voltro/CodePort", CodeService>;
+
+/** Actual installed memory-store adapter, one fresh instance per scope. Code
+ * values are runtime-generated; no credential literal or production backend. */
+export declare const codePortFixture: Effect.Effect<Readonly<{
+    plugin: EconomyPlugin;
+    store: InMemoryDataStore;
+    input: Readonly<{
+        code: string;
+        requestId: "fixture.redeem";
+    }>;
+    close: Effect.Effect<void, never, never>;
+}>, EconomyError, never>;
+
+export declare const codePortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof CodePort;
+    fakeLayer: Layer.Layer<EconomyPort | CodePort, EconomyError, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            same: boolean;
+            state: "fulfilled" | "pending" | "not-observed";
+            balance: string | undefined;
+        }, EconomyError, never>;
+        expected: {
+            same: boolean;
+            state: string;
+            balance: string;
+        };
+    };
+}>;
+
+declare interface CodeReceipt {
+    readonly operationId: string;
+    readonly codeId: string;
+    readonly version: string;
+    readonly campaign: string;
+    readonly at: number;
+    readonly transfers: readonly {
+        readonly txId: string;
+        readonly currency: string;
+        readonly amount: string;
+        readonly at: number;
+    }[];
+    readonly grants: readonly {
+        readonly operationId: string;
+        readonly kind: 'grant';
+        readonly changes: readonly {
+            readonly instanceId: string;
+            readonly delta: number;
+        }[];
+        readonly at: number;
+    }[];
+}
+
+declare interface CodeService {
+    readonly create: (subject: Subject, input: CreateCodeInput) => Effect.Effect<void, EconomyError>;
+    readonly redeem: (subject: Subject, input: RedeemCodeInput) => Effect.Effect<CodeReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: RedeemCodeInput) => Effect.Effect<CodeObservation, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+export declare const codesFakeLayer: Layer.Layer<EconomyPort | CodePort, EconomyError, never>;
+
+declare interface Container {
+    readonly id: string;
+    readonly version: string;
+    readonly group: string;
+    readonly price: Price;
+    readonly drops: readonly ContainerDrop[];
+    readonly pity: Readonly<{
+        guaranteed: string;
+        after: number;
+        softFrom: number | null;
+        softRampBps: number;
+    }> | null;
+    readonly countries: readonly string[];
+}
+
+declare interface ContainerAccessContext {
+    readonly container: Container;
+    readonly at: number;
+    readonly isMinor: boolean;
+    readonly country: string;
+    readonly eligible: boolean;
+}
+
+declare interface ContainerAccessSource {
+    readonly read: (input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly container: Container;
+        readonly at: number;
+    }) => Effect.Effect<{
+        readonly isMinor: boolean;
+        readonly country: string;
+        readonly eligible: boolean;
+        readonly adjustments: readonly VirtualPriceAdjustment[];
+    }, EconomyError>;
+}
+
+declare interface ContainerDefinition {
+    readonly id: string;
+    readonly version?: string | undefined;
+    readonly group?: string;
+    readonly price: PriceDefinition;
+    readonly drops: readonly ContainerDropDefinition[];
+    readonly pity?: {
+        readonly guaranteed: string;
+        readonly after: number;
+        readonly softFrom?: number;
+        readonly softRampBps?: number;
+    };
+    readonly countries?: readonly string[];
+}
+
+declare interface ContainerDistribution {
+    readonly entries: readonly ContainerProbabilityWeight[];
+    readonly total: string;
+    readonly guaranteed: boolean;
+}
+
+declare interface ContainerDrop {
+    readonly id: string;
+    readonly rarity: string;
+    readonly weight: string;
+    readonly items: readonly {
+        readonly itemId: string;
+        readonly qty: number;
+    }[];
+    readonly currencies: readonly {
+        readonly currency: string;
+        readonly amount: string;
+    }[];
+}
+
+declare interface ContainerDropDefinition {
+    readonly id: string;
+    readonly rarity: string;
+    readonly weight: EconomyAmountInput;
+    readonly items?: readonly {
+        readonly itemId: string | undefined;
+        readonly qty: number;
+    }[];
+    readonly currencies?: readonly {
+        readonly currency: string | undefined;
+        readonly amount: EconomyAmountInput;
+    }[];
+}
+
+declare type ContainerEligibility = (input: ContainerAccessContext) => boolean;
+
+export declare const containerEligibilitySystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: ContainerEligibility;
+    defaultProbe: {
+        run: () => Effect.Effect<boolean, never, never>;
+        expected: boolean;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<boolean, never, never>;
+        expected: boolean;
+    };
+}>;
+
+export declare const containerFixture: () => Readonly<{
+    container: Container;
+    currencies: {
+        id: string;
+        kind: "soft";
+        cap: string;
+    }[];
+    misses: 0;
+    realMoney: false;
+}>;
+
+declare type ContainerObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed' | 'pending';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: ContainerReceipt;
+};
+
+declare interface ContainerOpenInput {
+    readonly containerId: string;
+    readonly containerVersion: string;
+    readonly containerDigest: string;
+    readonly disclosureDigest: string;
+    readonly requestId: string;
+    readonly currency?: string | undefined;
+}
+
+declare interface ContainerProbabilityContext {
+    readonly container: Container;
+    readonly misses: number;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+}
+
+declare type ContainerProbabilityResolver = (input: ContainerProbabilityContext) => readonly ContainerProbabilityWeight[];
+
+export declare const containerProbabilitySystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: ContainerProbabilityResolver;
+    defaultProbe: {
+        run: () => Effect.Effect< ContainerDistribution, never, never>;
+        expected: {
+            entries: {
+                dropId: string;
+                weight: string;
+            }[];
+            total: string;
+            guaranteed: boolean;
+        };
+    };
+    overrideProbe: {
+        run: () => Effect.Effect< ContainerDistribution, never, never>;
+        expected: {
+            entries: {
+                dropId: string;
+                weight: string;
+            }[];
+            total: string;
+            guaranteed: boolean;
+        };
+    };
+}>;
+
+declare interface ContainerProbabilityWeight {
+    readonly dropId: string;
+    readonly weight: string;
+}
+
+/** A deterministic boundary draw for pure sampler composition only; not a SQL,
+ * entropy or persisted-Pity substitute. */
+export declare const containerRandomFakeLayer: Layer.Layer<ContainerRandomPort, never, never>;
+
+/** Server authority only: no player draw/seed/state is accepted by any route. */
+declare class ContainerRandomPort extends ContainerRandomPort_base {
+}
+
+declare const ContainerRandomPort_base: Context.ServiceClass<ContainerRandomPort, "@voltro/ContainerRandomPort", ContainerRandomService>;
+
+export declare const containerRandomPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof ContainerRandomPort;
+    fakeLayer: Layer.Layer<ContainerRandomPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<string, EconomyError, never>;
+        expected: string;
+    };
+}>;
+
+declare interface ContainerRandomService {
+    readonly draw: (exclusiveMaximum: string) => Effect.Effect<string, EconomyError>;
+}
+
+declare interface ContainerReceipt {
+    readonly operationId: string;
+    readonly containerId: string;
+    readonly containerVersion: string;
+    readonly containerDigest: string;
+    readonly dropId: string;
+    readonly rarity: string;
+    readonly previousMisses: number;
+    readonly misses: number;
+    readonly sequence: number;
+    readonly at: number;
+    readonly distribution: ContainerDistribution;
+    readonly pricePaid: ShopOrderReceipt['pricePaid'];
+    readonly transfers: ShopOrderReceipt['transfers'];
+    readonly grants: ShopOrderReceipt['grants'];
+}
+
+declare interface ContainerRollContext {
+    readonly distribution: ContainerDistribution;
+    readonly draw: string;
+}
+
+declare type ContainerRollResolver = (input: ContainerRollContext) => string;
+
+export declare const containerRollSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: ContainerRollResolver;
+    defaultProbe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+}>;
+
+export declare const containersFakeLayer: Layer.Layer<EconomyPort | ContainersPort, never, never>;
+
+declare class ContainersPort extends ContainersPort_base {
+}
+
+declare const ContainersPort_base: Context.ServiceClass<ContainersPort, "@voltro/ContainersPort", ContainersService>;
+
+/** Actual installed memory-store plugin with explicit fixture-only trusted
+ * facts and deterministic RNG seams, no production age/entropy authority. */
+export declare const containersPortFixture: Effect.Effect<Readonly<{
+    store: InMemoryDataStore;
+    plugin: EconomyPlugin;
+    base: {
+        base: {
+            economy: EconomySqlService;
+            inventory: InventorySqlService;
+            catalog: Readonly<{
+                read: (scope: CatalogScope) => Effect.Effect< CatalogSnapshot, InventoryError>;
+                importSnapshot: (subject: Subject, input: CatalogImport) => Effect.Effect< CatalogSnapshot, InventoryError>;
+            }>;
+            options: ShopStoreOptions;
+            shop: ShopSqlService;
+            user: {
+                readonly type: "user";
+                readonly id: string;
+                readonly tenantId: string;
+                readonly kind?: "guest" | undefined;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "apiKey";
+                readonly id: string;
+                readonly tenantId: string;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "serviceAccount";
+                readonly id: string;
+                readonly tenantId: string;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+                readonly auditActorId?: string | null;
+            } | {
+                readonly type: "anonymous";
+                readonly id: null;
+                readonly tenantId: string | null;
+                readonly credentialRejected?: string | undefined;
+            } | {
+                readonly type: "system";
+                readonly id: string;
+                readonly tenantId: null;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "service";
+                readonly id: string;
+                readonly service: string;
+                readonly tenantId: null;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            };
+            buy: ShopBuyInput;
+        };
+        options: ContainersStoreOptions;
+        service: ContainersService;
+        draws: () => number;
+    };
+    close: Effect.Effect<void, never, never>;
+}>, never, never>;
+
+export declare const containersPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof ContainersPort;
+    fakeLayer: Layer.Layer<EconomyPort | ContainersPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            same: boolean;
+            misses: number;
+            balance: string | undefined;
+        }, EconomyError, never>;
+        expected: {
+            same: boolean;
+            misses: number;
+            balance: string;
+        };
+    };
+}>;
+
+declare interface ContainersService {
+    readonly list: (subject: Subject) => Effect.Effect<readonly ContainerView[], EconomyError>;
+    readonly open: (subject: Subject, input: ContainerOpenInput) => Effect.Effect<ContainerReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: ContainerOpenInput) => Effect.Effect<ContainerObservation, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare interface ContainersStoreOptions {
+    readonly containers: readonly (ContainerDefinition | Container)[];
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly economy: Pick<EconomySqlService, 'prepareTransfer'>;
+    readonly inventory?: Pick<InventorySqlService, 'prepareGrant'> | undefined;
+    /** App-owned trusted age/country authority. No adult/allowed fallback. */
+    readonly accessSource: ContainerAccessSource;
+    readonly version: string;
+    readonly probability?: ContainerProbabilityResolver | undefined;
+    readonly roll?: ContainerRollResolver | undefined;
+    readonly random?: ContainerRandomService | undefined;
+    readonly eligibility?: ContainerEligibility | undefined;
+    readonly priceResolver?: PriceResolver | undefined;
+    readonly systemAccount?: string | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+
+declare interface ContainerView {
+    readonly container: Container;
+    readonly containerDigest: string;
+    readonly disclosureDigest: string;
+    readonly misses: number;
+    readonly price: Price;
+    readonly disclosure: ReturnType<typeof discloseContainer>;
+}
+
+declare interface CreateCodeInput {
+    readonly tenantId: string;
+    readonly code: string;
+    readonly definition: CodeDefinition | PromoCode;
+}
+
+declare interface CurrencyDefinition {
+    readonly id: string;
+    readonly kind: 'soft' | 'hard';
+    readonly cap?: EconomyAmountInput;
+    readonly premium?: boolean;
+    readonly display?: {
+        readonly nameKey: string;
+    } | null;
+}
+
+/** Public disclosure uses the exact same captured distribution as the draw. */
+declare const discloseContainer: (input: ContainerProbabilityContext, slot?: ContainerProbabilityResolver) => Readonly<{
+    guaranteed: boolean;
+    probabilities: readonly Readonly<{
+        dropId: string;
+        numerator: string;
+        denominator: string;
+    }>[];
+}>;
+
+declare type EconomyAccount = {
+    readonly kind: 'wallet';
+    readonly ownerId: string;
+    readonly ownerKind: WalletOwnerKind;
+} | {
+    readonly kind: 'system';
+    readonly id: string;
+};
+
+declare type EconomyAmountInput = string | number | bigint;
+
+declare type EconomyChannel = 'web' | 'ios' | 'android' | 'steam';
+
+declare interface EconomyConsistencyInput {
+    readonly tenantId: string;
+    readonly maxLedgerRows?: number | undefined;
+    readonly maxWallets?: number;
+}
+
+declare interface EconomyConsistencyResult {
+    readonly checked: number;
+    readonly mismatches: number;
+    readonly matches: boolean;
+    readonly ledgerRows: number;
+}
+
+declare interface EconomyConsistencyRunner {
+    readonly checkConsistency: (subject: Subject, input: EconomyConsistencyInput) => Effect.Effect<EconomyConsistencyResult, EconomyError>;
+}
+
+/** 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>;
+
+/** One fresh memory fixture per acquired scope; neither a SQL adapter nor a runtime backend. */
+export declare const economyFakeLayer: Layer.Layer<EconomyPort, never, never>;
+
+declare interface EconomyPlugin extends VoltroPlugin {
+    readonly economy: {
+        readonly service: () => EconomyService;
+        readonly prepareEscrowReserve: EconomySqlService['prepareEscrowReserve'];
+        readonly prepareEscrowRelease: EconomySqlService['prepareEscrowRelease'];
+        readonly prepareEscrowSettle: EconomySqlService['prepareEscrowSettle'];
+        readonly prepareEscrowTaxSettle: EconomySqlService['prepareEscrowTaxSettle'];
+        readonly prepareEscrowReserveTaxSettle: EconomySqlService['prepareEscrowReserveTaxSettle'];
+        readonly escrow: EconomySqlService['escrow'];
+        readonly prepareTransfer: EconomySqlService['prepareTransfer'];
+        readonly checkConsistency: EconomyConsistencyRunner['checkConsistency'];
+        readonly iap: () => IapSystemService;
+        readonly iapEntitlements: () => IapEntitlementsService;
+        readonly iapNotifications: () => IapNotificationsSystemService;
+        readonly iapRefundEvents: () => IapRefundEventsService;
+        readonly shop: () => ShopService;
+        readonly codes: () => CodeService;
+        readonly containers: () => ContainersService;
+        readonly subscriptions: () => SubscriptionsService;
+        readonly loyalty: () => LoyaltyService;
+        readonly trades: () => TradesService;
+        readonly expireTrade: TradesSqlService['expire'];
+        readonly expireDueTrades: TradesSqlService['expireDue'];
+        readonly piggyBanks: () => PiggyBanksService;
+        /** Trusted reference-price projection; never grants value. */
+        readonly price: (subject: Subject, offerId: string, adjustments?: readonly VirtualPriceAdjustment[]) => Effect.Effect<Price, EconomyError>;
+    };
+}
+
+declare class EconomyPort extends EconomyPort_base {
+}
+
+declare const EconomyPort_base: Context.ServiceClass<EconomyPort, "@voltro/EconomyPort", EconomyService>;
+
+/** Explicit test-only memory port; no SQL/native/production evidence follows. */
+export declare const economyPortFixture: (input: EconomyPortFixtureOptions) => Readonly<{
+    service: Readonly<EconomyService>;
+    layer: Layer.Layer<EconomyPort, never, never>;
+    close: Effect.Effect<void, never, never>;
+}>;
+
+export declare interface EconomyPortFixtureOptions {
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly now?: (() => number) | undefined;
+}
+
+export declare const economyPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof EconomyPort;
+    fakeLayer: Layer.Layer<EconomyPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            original: boolean;
+            balance: string | undefined;
+            matches: boolean;
+        }, EconomyError, never>;
+        expected: {
+            original: boolean;
+            balance: string;
+            matches: boolean;
+        };
+    };
+}>;
+
+declare interface EconomyReceipt {
+    readonly txId: string;
+    readonly currency: string;
+    readonly amount: string;
+    readonly at: number;
+}
+
+declare interface EconomyReference {
+    readonly kind: string;
+    readonly id: string;
+}
+
+declare interface EconomyService {
+    /** Trusted server transfer, never a player-authored value mutation. */
+    readonly transfer: (subject: Subject, input: LedgerTransferInput) => Effect.Effect<EconomyReceipt, EconomyError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly EconomyWallet[], EconomyError>;
+    readonly auditWallet: (subject: Subject, tenantId: string, account: EconomyAccount, currency: string) => Effect.Effect<EconomyWalletAudit, EconomyError>;
+    readonly rebuildWallet: (subject: Subject, tenantId: string, account: EconomyAccount, currency: string) => Effect.Effect<EconomyWalletAudit, EconomyError>;
+}
+
+declare interface EconomySqlService extends EconomySystemService, WalletEscrowParticipant {
+    /** Trusted original purchase evidence required; no player price, owner or state authority. */
+    readonly prepareIapRefund: (subject: Subject, proof: VerifiedIapCurrentState, input: IapWalletRefundInput) => Effect.Effect<PreparedSqlMutation<EconomyReceipt>, EconomyError>;
+    readonly prepareTransfer: (subject: Subject, input: LedgerTransferInput) => Effect.Effect<PreparedSqlMutation<EconomyReceipt>, EconomyError>;
+}
+
+/** Full installed replacement adds both privacy hooks; the dependent port stays four methods. */
+declare interface EconomySystemService extends EconomyService {
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare interface EconomyWallet {
+    readonly currency: string;
+    readonly balance: string;
+    readonly updatedAt: number | null;
+}
+
+declare interface EconomyWalletAudit {
+    readonly currency: string;
+    readonly balance: string;
+    readonly ledgerBalance: string;
+    readonly ledgerRows: number;
+    readonly matches: boolean;
+}
+
+declare type EscrowWallet = Extract<EconomyAccount, {
+    readonly kind: 'wallet';
+}>;
+
+declare type ExperimentBucket = (input: OfferExperimentContext) => string;
+
+export declare const experimentBucketSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: ExperimentBucket;
+    defaultProbe: {
+        run: () => Effect.Effect<string | undefined, never, never>;
+        expected: string;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<string | undefined, never, never>;
+        expected: string;
+    };
+}>;
+
+declare interface FlashOffer {
+    readonly id: string;
+    readonly version: string;
+    readonly offer: ShopOffer;
+    readonly triggerId: string;
+    readonly durationMs: number;
+}
+
+declare interface FlashOfferContext {
+    readonly flash: FlashOffer;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly at: number;
+    readonly trigger: FlashTriggerReceipt | null;
+    readonly rulesVersion?: string;
+}
+
+export declare const flashOfferFixture: () => Readonly<{
+    flash: FlashOffer;
+    currencies: {
+        id: string;
+        kind: "soft";
+    }[];
+    tenantId: "fixture";
+    ownerId: "a";
+    at: 100;
+    trigger: {
+        tenantId: string;
+        ownerId: string;
+        authorityId: string;
+        eventId: string;
+        triggerId: string;
+        acceptedAt: number;
+    };
+    realMoney: false;
+}>;
+
+declare type FlashTriggerPolicy = (context: FlashOfferContext) => FlashWindow | null;
+
+declare interface FlashTriggerReceipt {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly authorityId: string;
+    readonly eventId: string;
+    readonly triggerId: string;
+    readonly acceptedAt: number;
+}
+
+export declare const flashTriggerSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: FlashTriggerPolicy;
+    defaultProbe: {
+        run: () => Effect.Effect<number | undefined, never, never>;
+        expected: number;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<number | undefined, never, never>;
+        expected: number;
+    };
+}>;
+
+declare interface FlashWindow {
+    readonly from: number;
+    readonly until: number;
+}
+
+declare interface IapAccountBindingService {
+    /** Observe existing SQL binding only; no mint, seed, fence update or ownership write. */
+    readonly observe: (scope: IapScope, channel: EconomyChannel, environment: IapEnvironment) => Effect.Effect<string, EconomyError>;
+    readonly read: (scope: IapScope, channel: EconomyChannel, environment: IapEnvironment) => Effect.Effect<string, EconomyError>;
+    readonly prepareBinding: (scope: IapScope, channel: EconomyChannel, environment: IapEnvironment, token: string) => Effect.Effect<PreparedSqlMutation<unknown>, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare type IapAccountSource = Pick<IapAccountBindingService, 'read' | 'prepareBinding'>;
+
+declare class IapAccountsPort extends IapAccountsPort_base {
+}
+
+declare const IapAccountsPort_base: Context.ServiceClass<IapAccountsPort, "@voltro/IapAccountsPort", IapAccountBindingService>;
+
+/** A web checkout about to start: nothing is paid or verified yet. */
+declare interface IapCheckoutAdmission {
+    readonly scope: IapScope;
+    readonly product: IapProduct;
+    readonly at: number;
+}
+
+/** One purchase a provider is asked to start: the owner, the selected offer and where the
+ * player returns afterwards. The account token binds the later receipt to this owner. */
+declare interface IapCheckoutContext {
+    readonly scope: IapScope;
+    readonly product: IapProduct;
+    readonly requestId: string;
+    readonly accountToken: string;
+    readonly returnUrl: string;
+    readonly at: number;
+}
+
+/** Provider-owned web checkout (Stripe, Paddle, an app's own PSP, ...). Construction does no
+ * I/O; `initialize` checks credentials. Verification of the paid checkout stays with the same
+ * provider's `IapVerificationAuthority`, which must check the bound account token. */
+declare interface IapCheckoutService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly start: (context: IapCheckoutContext) => Effect.Effect<IapCheckoutSession, EconomyError>;
+}
+
+/** A started provider checkout. `checkoutId` is the receipt the player redeems afterwards. */
+declare interface IapCheckoutSession {
+    readonly checkoutId: string;
+    readonly redirectUrl: string;
+    readonly expiresAt: number;
+}
+
+declare interface IapCompletionReceipt {
+    readonly orderId: string;
+    readonly channel: EconomyChannel;
+    readonly operation: 'acknowledge' | 'consume' | 'finalize' | 'finish';
+    readonly observedAt: number;
+}
+
+declare interface IapCompletionService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly complete: (evidence: AcceptedIapCompletion) => Effect.Effect<IapCompletionReceipt, EconomyError>;
+}
+
+declare interface IapCurrentPurchaseState {
+    readonly orderId: string;
+    readonly channel: IapRefundChannel;
+    readonly state: 'active' | 'partially-refunded' | 'revoked';
+    /** Exact cumulative provider refund share; never floating point or money sent by a player. */
+    readonly refundNumerator: number;
+    readonly refundDenominator: number;
+    readonly observedAt: number;
+    readonly revokedAt: number | null;
+}
+
+export declare const iapCurrentStateFakeLayer: Layer.Layer<IapCurrentStatePort, EconomyError, never>;
+
+declare class IapCurrentStatePort extends IapCurrentStatePort_base {
+}
+
+declare const IapCurrentStatePort_base: Context.ServiceClass<IapCurrentStatePort, "@voltro/IapCurrentStatePort", IapCurrentStateService>;
+
+/** Actual fresh SQL/account custody; explicit active provider observation seam, no refund or live provider. */
+export declare const iapCurrentStatePortFixture: Effect.Effect<Readonly<{
+    service: Readonly<IapCurrentStateService>;
+    target: AcceptedIapNotificationTarget;
+    original: IapOrderReceipt;
+    close: Effect.Effect<void, never, never>;
+}>, EconomyError, never>;
+
+export declare const iapCurrentStatePortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof IapCurrentStatePort;
+    fakeLayer: Layer.Layer<IapCurrentStatePort, EconomyError, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            state: "revoked" | "active" | "partially-refunded";
+            share: number[];
+            copiedRefused: boolean;
+            actualOrder: boolean;
+        }, EconomyError, never>;
+        expected: {
+            state: string;
+            share: number[];
+            copiedRefused: boolean;
+            actualOrder: boolean;
+        };
+    };
+}>;
+
+declare interface IapCurrentStateService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly read: (target: AcceptedIapNotificationTarget) => Effect.Effect<VerifiedIapCurrentState, EconomyError>;
+}
+
+declare type IapDebtPolicy = 'allowNegative' | 'blockSpend';
+
+/** A purchase or subscription renewal the provider reports on its own (a webhook), for the
+ * owner it once received as account token at checkout. Redeemed through the same pipeline as a
+ * player's redeem: the same `requestId` + `receipt` converge on one order. */
+declare interface IapDelivery {
+    readonly accountToken: string;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly requestId: string;
+    readonly receipt: string;
+}
+
+/** Provider-owned delivery reader on the channel's notification route. `read` authenticates the
+ * request and returns `null` when it carries nothing to deliver; the request then continues to
+ * the notification pipeline (refunds, disputes). */
+declare interface IapDeliveryService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly read: (input: IapNotificationInput) => Effect.Effect<IapDelivery | null, EconomyError>;
+}
+
+declare interface IapEntitlementObservation {
+    readonly offerId: string;
+    readonly entitled: boolean;
+    readonly expiresAt: number | null;
+    readonly observedAt: number;
+}
+
+declare type IapEntitlementPolicy = (context: IapEntitlementPolicyContext) => boolean;
+
+declare interface IapEntitlementPolicyContext {
+    readonly period: IapSubscriptionPeriod;
+    readonly at: number;
+}
+
+/** Actual pure codec/default/policy path, separate from the installed SQL fixture. */
+export declare const iapEntitlementPolicyFixture: () => Readonly<{
+    offerId: "fixture.subscription";
+    at: 150;
+    version: "fixture.entitlement.policy.v1";
+    periods: readonly IapSubscriptionPeriod[];
+}>;
+
+export declare const iapEntitlementPolicySystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: IapEntitlementPolicy;
+    defaultProbe: {
+        run: () => Effect.Effect< IapEntitlementObservation, never, never>;
+        expected: {
+            offerId: string;
+            entitled: boolean;
+            expiresAt: number;
+            observedAt: number;
+        };
+    };
+    overrideProbe: {
+        run: () => Effect.Effect< IapEntitlementObservation, never, never>;
+        expected: {
+            offerId: string;
+            entitled: boolean;
+            expiresAt: null;
+            observedAt: number;
+        };
+    };
+}>;
+
+export declare const iapEntitlementsFakeLayer: Layer.Layer<IapEntitlementsPort, unknown, never>;
+
+declare interface IapEntitlementsPluginOptions {
+    readonly version: string;
+    readonly policy?: IapEntitlementPolicy;
+    readonly service?: IapEntitlementsService;
+    readonly querySources?: readonly string[] | undefined;
+}
+
+/** Complete replacement owns authoritative history, privacy and expiry admission. */
+declare class IapEntitlementsPort extends IapEntitlementsPort_base {
+}
+
+declare const IapEntitlementsPort_base: Context.ServiceClass<IapEntitlementsPort, "@voltro/IapEntitlementsPort", IapEntitlementsService>;
+
+/** Fresh installed account, accepted SQL period, wallet and inventory per scope.
+ * Provider verification/refund observations are private test seams, not store trust proofs.
+ */
+export declare const iapEntitlementsPortFixture: Effect.Effect<Readonly<{
+    service: IapEntitlementsService;
+    fixture: {
+        plugin: EconomyPlugin;
+        options: IapPluginOptions;
+        inventory: InventorySqlService;
+        activate: () => Effect.Effect<void, unknown>;
+        close: () => Effect.Effect<void, unknown>;
+        setTime: (value: number) => void;
+        verifications: () => number;
+        base: {
+            scope: {
+                tenantId: string;
+                ownerId: string;
+            };
+            transactionId: `${string}-${string}-${string}-${string}-${string}`;
+            definition: IapProductDefinition;
+            catalog: Readonly<{
+                read: (scope: CatalogScope) => Effect.Effect< CatalogSnapshot, InventoryError>;
+                importSnapshot: (subject: Subject, input: CatalogImport) => Effect.Effect< CatalogSnapshot, InventoryError>;
+            }>;
+            inventory: InventorySqlService;
+            economy: EconomySqlService;
+            accounts: IapAccountBindingService;
+            options: IapStoreOptions;
+            verificationOptions: {
+                products: IapProductDefinition[];
+                accounts: IapAccountBindingService;
+                realMoney: boolean;
+                channel: EconomyChannel;
+                environment: IapEnvironment;
+                applicationId: string;
+                currencies: readonly CurrencyDefinition[];
+                now?: (() => number) | undefined;
+            };
+            iap: IapSqlService;
+            user: (ownerId?: string, tenant?: string) => Subject;
+            machine: {
+                readonly type: "user";
+                readonly id: string;
+                readonly tenantId: string;
+                readonly kind?: "guest" | undefined;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "apiKey";
+                readonly id: string;
+                readonly tenantId: string;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "serviceAccount";
+                readonly id: string;
+                readonly tenantId: string;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+                readonly auditActorId?: string | null;
+            } | {
+                readonly type: "anonymous";
+                readonly id: null;
+                readonly tenantId: string | null;
+                readonly credentialRejected?: string | undefined;
+            } | {
+                readonly type: "system";
+                readonly id: string;
+                readonly tenantId: null;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "service";
+                readonly id: string;
+                readonly service: string;
+                readonly tenantId: null;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            };
+            policyId: string;
+            item: ItemContract;
+            verificationCalls: () => number;
+            at: number;
+            accountToken: `${string}-${string}-${string}-${string}-${string}`;
+            receipt: string;
+            currencies: ResolvedCurrency[];
+            intent: {
+                channel: "ios";
+                offerId: string;
+                offerVersion: string;
+                requestId: string;
+                receipt: string;
+            };
+            providerOptions: {
+                realMoney: boolean;
+                environment: IapEnvironment;
+                applicationId: string;
+                products: readonly IapProductDefinition[];
+                currencies: readonly CurrencyDefinition[];
+                accounts: IapAccountSource;
+                now: () => number;
+            };
+            context: IapVerificationContext;
+            apple: JWSTransactionDecodedPayload;
+            facts: IapTransactionFacts;
+            androidDefinition: IapProductDefinition;
+            googleContext: IapVerificationContext;
+            google: {
+                purchaseStateContext: {
+                    purchaseState: string;
+                };
+                testPurchaseContext: {
+                    fopType: string;
+                };
+                obfuscatedExternalAccountId: `${string}-${string}-${string}-${string}-${string}`;
+                purchaseCompletionTime: string;
+                acknowledgementState: string;
+                productLineItem: {
+                    productId: string;
+                    productOfferDetails: {
+                        quantity: number;
+                        refundableQuantity: number;
+                        consumptionState: string;
+                    };
+                }[];
+            };
+        };
+        store: DataStore;
+        body: string;
+        notice: {
+            notice: IapNotificationNotice;
+            options: IapNotificationTargetOptions;
+            evidence: VerifiedIapNotification;
+        };
+        ready: () => number;
+        reads: () => number;
+        failProvider: (value: boolean) => void;
+        beforeRead: (value: (() => Effect.Effect<void, EconomyError>) | undefined) => void;
+        advance: (milliseconds: number) => void;
+        currentRefund: (value: 0 | 1) => void;
+    };
+    close: Effect.Effect<void, never, never>;
+}>, unknown, never>;
+
+export declare const iapEntitlementsPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof IapEntitlementsPort;
+    fakeLayer: Layer.Layer<IapEntitlementsPort, unknown, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            accepted: boolean;
+            ownsExpiry: boolean;
+            foreign: boolean;
+            expired: boolean;
+            expiryIsReadOnly: boolean;
+        }, unknown, never>;
+        expected: {
+            accepted: boolean;
+            ownsExpiry: boolean;
+            foreign: boolean;
+            expired: boolean;
+            expiryIsReadOnly: boolean;
+        };
+    };
+}>;
+
+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>;
+}
+
+declare type IapEnvironment = 'sandbox' | 'production';
+
+export declare const iapFakeLayer: Layer.Layer<IapPort | IapAccountsPort | EconomyPort | IapSystemPort, unknown, never>;
+
+/** Where an owner manages what they pay for (cancel a subscription, change the card). */
+declare interface IapManagementContext {
+    readonly accountToken: string;
+    /** The provider's original transaction IDs (subscriptions) of the owner's accepted orders on
+     * this channel, newest first; empty when the owner holds none. */
+    readonly originals: readonly string[];
+    readonly returnUrl: string;
+    readonly at: number;
+}
+
+declare interface IapManagementService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    /** A provider page for this owner; `not_found` when the owner has nothing to manage there. */
+    readonly open: (context: IapManagementContext) => Effect.Effect<{
+        readonly url: string;
+    }, EconomyError>;
+}
+
+declare interface IapNotificationCipherSource {
+    /** Default is the registered framework FieldCipher. Explicit sources use that same codec/row binding contract. */
+    readonly read: () => FieldCipher | undefined;
+}
+
+export declare const iapNotificationCustodyFakeLayer: Layer.Layer<IapNotificationCustodyPort, EconomyError, never>;
+
+declare class IapNotificationCustodyPort extends IapNotificationCustodyPort_base {
+}
+
+declare const IapNotificationCustodyPort_base: Context.ServiceClass<IapNotificationCustodyPort, "@voltro/IapNotificationCustodyPort", IapNotificationCustodyService>;
+
+/** Fresh actual SQL + private framework cipher; explicit authenticated notice seam, no global cipher replacement. */
+export declare const iapNotificationCustodyPortFixture: Effect.Effect<Readonly<{
+    service: Readonly<IapNotificationCustodyService>;
+    evidence: VerifiedIapNotification;
+    privacy: {
+        tenantId: string;
+        subjectId: string;
+        kind: "guest";
+    };
+    close: Effect.Effect<void, never, never>;
+}>, EconomyError, never>;
+
+export declare const iapNotificationCustodyPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof IapNotificationCustodyPort;
+    fakeLayer: Layer.Layer<IapNotificationCustodyPort, EconomyError, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            state: "erased" | "expired" | "pending" | "processed";
+            actualOrder: boolean;
+            stableIdentity: boolean;
+            restoredChannel: IapRefundChannel;
+            pending: number;
+        }, EconomyError, never>;
+        expected: {
+            state: string;
+            actualOrder: boolean;
+            stableIdentity: boolean;
+            restoredChannel: string;
+            pending: number;
+        };
+    };
+}>;
+
+declare interface IapNotificationCustodyReceipt {
+    readonly id: string;
+    readonly orderId: string;
+    readonly state: 'pending' | 'processed' | 'expired' | 'erased';
+}
+
+declare interface IapNotificationCustodyService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly retain: (evidence: VerifiedIapNotification) => Effect.Effect<IapNotificationCustodyReceipt, EconomyError>;
+    /** Trusted server worker, not a player RPC. Restores only row-bound authenticated SQL custody. */
+    readonly restore: (id: string) => Effect.Effect<VerifiedIapNotification, EconomyError>;
+    /** Actual accepted refund capability and same-store journal fence required. */
+    readonly markProcessed: (id: string, receipt: IapRefundReceipt) => Effect.Effect<IapNotificationCustodyReceipt, EconomyError>;
+    readonly pending: () => Effect.Effect<readonly IapNotificationCustodyReceipt[], EconomyError>;
+    readonly prune: () => Effect.Effect<number, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+export declare const iapNotificationFakeLayer: Layer.Layer<IapNotificationPort, EconomyError, never>;
+
+declare interface IapNotificationInput {
+    readonly body: string;
+    /** Actual HTTP Authorization header for authenticated Pub/Sub push; never query/body authority. */
+    readonly authorization?: string;
+    /** The request's other headers, lowercased and bounded, for providers that sign in a header
+     * (Stripe: `stripe-signature`). Never authority by themselves. */
+    readonly headers?: Readonly<Record<string, string>>;
+}
+
+declare interface IapNotificationNotice {
+    readonly channel: IapRefundChannel;
+    readonly applicationId: string;
+    /** RTDN itself does not identify sandbox/production. Fresh lookup must establish it. */
+    readonly environment: IapEnvironment | null;
+    readonly noticeId: string;
+    readonly sourceType: string;
+    readonly kind: 'one-time' | 'subscription' | 'voided' | 'review' | 'test';
+    readonly occurredAt: number;
+    readonly transactionId: string | null;
+    readonly originalTransactionId: string | null;
+    readonly storeProductId: string | null;
+}
+
+declare class IapNotificationPort extends IapNotificationPort_base {
+}
+
+declare const IapNotificationPort_base: Context.ServiceClass<IapNotificationPort, "@voltro/IapNotificationPort", IapNotificationService>;
+
+/** Explicit synthetic TEST-notice authority only. No default adapter, signature, provider state or money writer. */
+export declare const iapNotificationPortFixture: Effect.Effect<Readonly<{
+    service: Readonly<IapNotificationService>;
+    close: Effect.Effect<void, never, never>;
+}>, EconomyError, never>;
+
+export declare const iapNotificationPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof IapNotificationPort;
+    fakeLayer: Layer.Layer<IapNotificationPort, EconomyError, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            kind: "test" | "subscription" | "one-time" | "voided" | "review";
+            channel: IapRefundChannel;
+            copiedRefused: boolean;
+            noPurchaseAuthority: boolean;
+        }, EconomyError, never>;
+        expected: {
+            kind: string;
+            channel: string;
+            copiedRefused: boolean;
+            noPurchaseAuthority: boolean;
+        };
+    };
+}>;
+
+export declare const iapNotificationProcessorFakeLayer: Layer.Layer<IapNotificationProcessorPort, EconomyError, never>;
+
+declare class IapNotificationProcessorPort extends IapNotificationProcessorPort_base {
+}
+
+declare const IapNotificationProcessorPort_base: Context.ServiceClass<IapNotificationProcessorPort, "@voltro/IapNotificationProcessorPort", IapNotificationProcessorService>;
+
+export declare const iapNotificationProcessorPortFixture: Effect.Effect<Readonly<{
+    service: Readonly<IapNotificationProcessorService>;
+    body: string;
+    privacy: {
+        tenantId: string;
+        subjectId: string;
+        kind: "guest";
+    };
+    close: Effect.Effect<void, EconomyError, never>;
+}>, EconomyError, never>;
+
+export declare const iapNotificationProcessorPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof IapNotificationProcessorPort;
+    fakeLayer: Layer.Layer<IapNotificationProcessorPort, EconomyError, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            processed: boolean;
+            replay: boolean;
+            pending: number;
+            providerCalls: number;
+        }, EconomyError, never>;
+        expected: {
+            processed: boolean;
+            replay: boolean;
+            pending: number;
+            providerCalls: number;
+        };
+    };
+}>;
+
+declare interface IapNotificationProcessorService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    /** `null`: an authenticated test notice (a store's TEST message, a provider event with no
+     * purchase in it) is acknowledged and not retained; no retry could ever process it. */
+    readonly ingest: (input: IapNotificationInput) => Effect.Effect<IapNotificationCustodyReceipt | null, EconomyError>;
+    readonly process: (id: string) => Effect.Effect<IapNotificationCustodyReceipt, EconomyError>;
+    readonly pending: () => Effect.Effect<readonly IapNotificationCustodyReceipt[], EconomyError>;
+    readonly prune: () => Effect.Effect<number, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare interface IapNotificationService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly verify: (input: IapNotificationInput) => Effect.Effect<VerifiedIapNotification, EconomyError>;
+}
+
+declare interface IapNotificationsPluginOptions {
+    readonly version: string;
+    readonly pathPrefix?: string;
+    readonly maxBodyBytes?: number;
+    readonly bodyRetentionMs?: number | undefined;
+    readonly debtPolicy?: IapDebtPolicy | undefined;
+    readonly assets?: IapRefundAssetParticipant | undefined;
+    readonly assetsVersion?: string | undefined;
+    readonly maxNoticeRows?: number;
+    readonly maxRefundRows?: number;
+    readonly cipher?: IapNotificationCipherSource | undefined;
+    /** Complete replacement owns authentication/current state/financial authority, queue and privacy. */
+    readonly service?: IapNotificationsSystemService;
+    /** Complete notification replacements may expose their own three-method event queue. */
+    readonly refundEvents?: IapRefundEventsService;
+    /** Custom borrowed-transaction SQL read. Omit when the custom system exposes no own order disposition. */
+    readonly refundDisposition?: IapRefundDispositionSource | undefined;
+    /** Runs after a notice changed a purchase (a refund, a revocation), e.g. to end game time at once:
+     * `rooms.moderation.recheckAccess({ tenantId, subjectId: ownerId })`. Best effort: a failure is
+     * ignored and the notice stays processed. Not with a complete replacement `service`. */
+    readonly onChange?: ((change: IapPurchaseChange) => Effect.Effect<void, unknown>) | undefined;
+}
+
+export declare const iapNotificationsSystemFakeLayer: Layer.Layer<IapNotificationsSystemPort, unknown, never>;
+
+declare class IapNotificationsSystemPort extends IapNotificationsSystemPort_base {
+}
+
+declare const IapNotificationsSystemPort_base: Context.ServiceClass<IapNotificationsSystemPort, "@voltro/IapNotificationsSystemPort", IapNotificationsSystemService>;
+
+/** Actual installed SQL chain and privately owned framework cipher; provider authorities are explicit seams. */
+export declare const iapNotificationsSystemPortFixture: Effect.Effect<Readonly<{
+    service: IapNotificationsSystemService;
+    plugin: EconomyPlugin;
+    user: {
+        readonly type: "user";
+        readonly id: string;
+        readonly tenantId: string;
+        readonly kind?: "guest" | undefined;
+        readonly scopes?: readonly string[] | undefined;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    } | {
+        readonly type: "apiKey";
+        readonly id: string;
+        readonly tenantId: string;
+        readonly scopes?: readonly string[] | undefined;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    } | {
+        readonly type: "serviceAccount";
+        readonly id: string;
+        readonly tenantId: string;
+        readonly scopes?: readonly string[] | undefined;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly auditActorId?: string | null;
+    } | {
+        readonly type: "anonymous";
+        readonly id: null;
+        readonly tenantId: string | null;
+        readonly credentialRejected?: string | undefined;
+    } | {
+        readonly type: "system";
+        readonly id: string;
+        readonly tenantId: null;
+        readonly scopes?: readonly string[] | undefined;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    } | {
+        readonly type: "service";
+        readonly id: string;
+        readonly service: string;
+        readonly tenantId: null;
+        readonly scopes?: readonly string[] | undefined;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    };
+    intent: {
+        channel: "ios";
+        offerId: string;
+        offerVersion: string;
+        requestId: string;
+        receipt: string;
+    };
+    body: string;
+    privacy: {
+        tenantId: string;
+        subjectId: string;
+        kind: "guest";
+    };
+    close: Effect.Effect<void, never, never>;
+}>, unknown, never>;
+
+export declare const iapNotificationsSystemPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof IapNotificationsSystemPort;
+    fakeLayer: Layer.Layer<IapNotificationsSystemPort, unknown, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            processed: boolean;
+            replay: boolean;
+            providerCalls: number;
+            pending: number;
+        }, unknown, never>;
+        expected: {
+            processed: boolean;
+            replay: boolean;
+            providerCalls: number;
+            pending: number;
+        };
+    };
+}>;
+
+declare interface IapNotificationsSystemService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly processor: (channel: EconomyChannel) => Effect.Effect<IapNotificationProcessorService, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare interface IapNotificationTargetOptions {
+    readonly realMoney: boolean;
+    readonly channel: IapRefundChannel;
+    readonly applicationId: string;
+    readonly environment: IapEnvironment;
+}
+
+declare type IapOrderObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed' | 'pending';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: IapOrderReceipt;
+    readonly refund?: IapRefundDisposition;
+} | {
+    readonly requestId: string;
+    readonly state: 'partially-refunded' | 'refunded';
+    readonly receipt: IapOrderReceipt;
+    readonly refund: IapRefundDisposition;
+};
+
+declare interface IapOrderReceipt {
+    readonly orderId: string;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly quantity: number;
+    readonly at: number;
+    readonly pricePaid: IapPaidAmount | null;
+    readonly transfers: readonly {
+        readonly txId: string;
+        readonly currency: string;
+        readonly amount: string;
+        readonly at: number;
+    }[];
+    readonly grants: readonly {
+        readonly operationId: string;
+        readonly kind: 'grant';
+        readonly changes: readonly {
+            readonly instanceId: string;
+            readonly delta: number;
+        }[];
+        readonly at: number;
+    }[];
+}
+
+/** Provider units retain their own decimal scale. Reference prices are never substituted. */
+declare interface IapPaidAmount {
+    readonly currency: string;
+    readonly units: string;
+    readonly scale: number;
+}
+
+declare interface IapPluginOptions {
+    readonly version: string;
+    readonly products: readonly IapProductDefinition[];
+    readonly providers?: readonly IapProviderDefinition[];
+    readonly namespace?: string;
+    readonly admission?: IapStoreOptions['admission'] | undefined;
+    readonly inventory?: IapStoreOptions['inventory'] | undefined;
+    readonly systemAccount?: string | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly notifications?: IapNotificationsPluginOptions | undefined;
+    readonly entitlements?: IapEntitlementsPluginOptions;
+    readonly service?: IapSystemService;
+    readonly querySources?: {
+        readonly receipt: readonly string[];
+    } | undefined;
+}
+
+declare class IapPort extends IapPort_base {
+}
+
+declare const IapPort_base: Context.ServiceClass<IapPort, "@voltro/IapPort", IapService>;
+
+/** Fresh actual installed SQL account/custody/asset services. Provider and finish authority are explicit fixtures. */
+export declare const iapPortFixture: Effect.Effect<{
+    base: {
+        scope: {
+            tenantId: string;
+            ownerId: string;
+        };
+        transactionId: `${string}-${string}-${string}-${string}-${string}`;
+        definition: IapProductDefinition;
+        catalog: Readonly<{
+            read: (scope: CatalogScope) => Effect.Effect< CatalogSnapshot, InventoryError>;
+            importSnapshot: (subject: Subject, input: CatalogImport) => Effect.Effect< CatalogSnapshot, InventoryError>;
+        }>;
+        inventory: InventorySqlService;
+        economy: EconomySqlService;
+        accounts: IapAccountBindingService;
+        options: IapStoreOptions;
+        verificationOptions: {
+            products: IapProductDefinition[];
+            accounts: IapAccountBindingService;
+            realMoney: boolean;
+            channel: EconomyChannel;
+            environment: IapEnvironment;
+            applicationId: string;
+            currencies: readonly CurrencyDefinition[];
+            now?: (() => number) | undefined;
+        };
+        iap: IapSqlService;
+        user: (ownerId?: string, tenant?: string) => Subject;
+        machine: {
+            readonly type: "user";
+            readonly id: string;
+            readonly tenantId: string;
+            readonly kind?: "guest" | undefined;
+            readonly scopes?: readonly string[] | undefined;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        } | {
+            readonly type: "apiKey";
+            readonly id: string;
+            readonly tenantId: string;
+            readonly scopes?: readonly string[] | undefined;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        } | {
+            readonly type: "serviceAccount";
+            readonly id: string;
+            readonly tenantId: string;
+            readonly scopes?: readonly string[] | undefined;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly auditActorId?: string | null;
+        } | {
+            readonly type: "anonymous";
+            readonly id: null;
+            readonly tenantId: string | null;
+            readonly credentialRejected?: string | undefined;
+        } | {
+            readonly type: "system";
+            readonly id: string;
+            readonly tenantId: null;
+            readonly scopes?: readonly string[] | undefined;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        } | {
+            readonly type: "service";
+            readonly id: string;
+            readonly service: string;
+            readonly tenantId: null;
+            readonly scopes?: readonly string[] | undefined;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        };
+        policyId: string;
+        item: ItemContract;
+        verificationCalls: () => number;
+        at: number;
+        accountToken: `${string}-${string}-${string}-${string}-${string}`;
+        receipt: string;
+        currencies: ResolvedCurrency[];
+        intent: {
+            channel: "ios";
+            offerId: string;
+            offerVersion: string;
+            requestId: string;
+            receipt: string;
+        };
+        providerOptions: {
+            realMoney: boolean;
+            environment: IapEnvironment;
+            applicationId: string;
+            products: readonly IapProductDefinition[];
+            currencies: readonly CurrencyDefinition[];
+            accounts: IapAccountSource;
+            now: () => number;
+        };
+        context: IapVerificationContext;
+        apple: JWSTransactionDecodedPayload;
+        facts: IapTransactionFacts;
+        androidDefinition: IapProductDefinition;
+        googleContext: IapVerificationContext;
+        google: {
+            purchaseStateContext: {
+                purchaseState: string;
+            };
+            testPurchaseContext: {
+                fopType: string;
+            };
+            obfuscatedExternalAccountId: `${string}-${string}-${string}-${string}-${string}`;
+            purchaseCompletionTime: string;
+            acknowledgementState: string;
+            productLineItem: {
+                productId: string;
+                productOfferDetails: {
+                    quantity: number;
+                    refundableQuantity: number;
+                    consumptionState: string;
+                };
+            }[];
+        };
+    };
+    plugin: EconomyPlugin;
+    options: IapPluginOptions;
+    store: DataStore;
+    activate: () => Effect.Effect<void, unknown>;
+    close: Effect.Effect<void, never, never>;
+    initializations: () => number;
+    verifications: () => number;
+}, unknown, never>;
+
+/** Actual Tag probes, for a future complete System21 registration; no synthetic constant probe. */
+export declare const iapPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof IapPort;
+    fakeLayer: Layer.Layer<IapPort | IapAccountsPort | EconomyPort | IapSystemPort, unknown, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            original: boolean;
+            state: "fulfilled" | "pending" | "not-observed" | "partially-refunded" | "refunded";
+            completion: boolean;
+            balance: string | undefined;
+        }, unknown, never>;
+        expected: {
+            original: boolean;
+            state: string;
+            completion: boolean;
+            balance: string;
+        };
+    };
+}>;
+
+declare interface IapProduct {
+    readonly offer: ShopOffer;
+    readonly channel: EconomyChannel;
+    readonly kind: IapProductKind;
+    readonly storeProductId: string;
+}
+
+declare interface IapProductDefinition {
+    readonly offer: ShopOfferDefinition | ShopOffer;
+    readonly channel: EconomyChannel;
+    readonly kind: IapProductKind;
+}
+
+declare type IapProductKind = 'consumable' | 'non-consumable' | 'subscription';
+
+declare interface IapProviderContext {
+    readonly realMoney: true;
+    readonly channel: EconomyChannel;
+    readonly environment: IapEnvironment;
+    readonly applicationId: string;
+    readonly products: readonly IapProductDefinition[];
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly accounts: IapAccountBindingService;
+    readonly now: () => number;
+}
+
+declare interface IapProviderDefinition {
+    readonly channel: EconomyChannel;
+    readonly environment: IapEnvironment;
+    readonly applicationId: string;
+    /** Server-owned verifier factory. Construction does no I/O; initialize is awaited at activation. */
+    readonly create: (context: IapProviderContext) => IapVerificationService;
+    /** Optional authenticated notification authority, initialized only when configured. */
+    readonly createNotifications?: ((context: IapProviderContext) => IapNotificationService) | undefined;
+    readonly createCurrentState?: ((context: IapProviderContext) => IapCurrentStateService) | undefined;
+    /** Optional server completion authority, initialized before this IAP system activates. */
+    readonly createCompletion?: ((context: IapProviderContext) => IapCompletionService) | undefined;
+    /** Optional web checkout (`economy.iap.checkout`): the provider starts a hosted payment and
+     * the player redeems its `checkoutId` as the receipt. Any payment provider fits. */
+    readonly createCheckout?: ((context: IapProviderContext) => IapCheckoutService) | undefined;
+    /** Origins a checkout may return to (`https://game.example`); required with `createCheckout`. */
+    readonly checkoutReturnOrigins?: readonly string[] | undefined;
+    /** Optional provider-delivered purchases and subscription renewals, read on the channel's
+     * notification route (needs `notifications`). Each is redeemed for the owner of its account token. */
+    readonly createDeliveries?: ((context: IapProviderContext) => IapDeliveryService) | undefined;
+    /** Optional provider page where the owner manages subscriptions (`economy.iap.manage`). */
+    readonly createManagement?: ((context: IapProviderContext) => IapManagementService) | undefined;
+}
+
+declare interface IapPurchaseAdmission {
+    readonly scope: IapScope;
+    readonly product: IapProduct;
+    readonly facts: IapTransactionFacts;
+    readonly at: number;
+}
+
+/** Required real SQL age/consent/spend eligibility authority. No permissive default. */
+declare interface IapPurchaseAdmissionSource {
+    readonly prepare: (input: IapPurchaseAdmission) => Effect.Effect<PreparedSqlMutation<unknown>, EconomyError>;
+    /** Optional check before a web checkout starts. Refuse what `prepare` would certainly
+     * refuse, so the player is never charged for a purchase that cannot be redeemed;
+     * `prepare` stays the authority. */
+    readonly checkout?: (input: IapCheckoutAdmission) => Effect.Effect<void, EconomyError>;
+}
+
+/** A store or provider notice changed a purchase: a refund, a revocation. `ownerId` is the player. */
+declare interface IapPurchaseChange {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly orderId: string;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly state: IapRefundReceipt['state'];
+}
+
+declare interface IapReceiptIntent {
+    readonly channel: EconomyChannel;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly requestId: string;
+    /** Opaque store evidence. Never log or persist this in player receipts. */
+    readonly receipt: string;
+}
+
+/** Read-only original-intention reference. Never send raw receipts in query parameters. */
+declare interface IapReceiptReference {
+    readonly channel: EconomyChannel;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly requestId: string;
+    readonly receiptDigest: string;
+}
+
+declare interface IapRefundAssetContext {
+    readonly original: IapSqlOriginalPurchase;
+    readonly state: IapCurrentPurchaseState;
+    readonly previous: IapRefundReceipt | null;
+    readonly sequence: number;
+}
+
+/** Mandatory for orders with item grants. It must use the same real store and original grant custody. */
+declare interface IapRefundAssetParticipant {
+    readonly prepare: (input: IapRefundAssetContext) => Effect.Effect<PreparedSqlMutation<unknown>, EconomyError>;
+    readonly validate: (input: IapRefundAssetContext, receipt: unknown) => unknown;
+    /** SQL-only audit of accepted movement receipts; no provider/application callbacks. */
+    readonly audit: (tx: DataStore, input: IapRefundAssetContext, receipt: unknown) => Promise<void>;
+}
+
+/** Channels whose providers report refunds and revocations to the economy. */
+declare type IapRefundChannel = 'ios' | 'android' | 'web';
+
+declare interface IapRefundCurrency {
+    readonly currency: string;
+    readonly original: string;
+    readonly refunded: string;
+}
+
+/** 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;
+}
+
+/** Borrowed transaction read only: no provider, nested transaction, seed, clock or mutation. */
+declare interface IapRefundDispositionSource {
+    readonly read: (tx: DataStore, original: IapSqlOriginalPurchase) => Promise<IapRefundDisposition | null>;
+}
+
+declare interface IapRefundEventContext {
+    readonly namespace: string;
+    readonly tenantId: string;
+    readonly subjectId: string;
+    readonly payload: IapRefundEventPayload;
+    /** Complete bounded accepted history; these are observations, never a fraud verdict. */
+    readonly refundedOrders: number;
+    readonly observedOrders: number;
+    readonly refundAdjustments: number;
+}
+
+declare type IapRefundEventPayload = typeof IapRefundEventPayloadSchema.Type;
+
+declare const IapRefundEventPayloadSchema: Schema.Struct<{
+    readonly eventId: Schema.String;
+    readonly orderId: Schema.String;
+    readonly sequence: Schema.Number;
+    readonly state: Schema.Literals<readonly ["active", "partially-refunded", "revoked"]>;
+    readonly refundNumerator: Schema.Number;
+    readonly refundDenominator: Schema.Number;
+    readonly observedAt: Schema.Number;
+}>;
+
+export declare const iapRefundEventsFakeLayer: Layer.Layer<IapRefundEventsPort, EconomyError, never>;
+
+declare class IapRefundEventsPort extends IapRefundEventsPort_base {
+}
+
+declare const IapRefundEventsPort_base: Context.ServiceClass<IapRefundEventsPort, "@voltro/IapRefundEventsPort", IapRefundEventsService>;
+
+export declare const iapRefundEventsPortFixture: Effect.Effect<Readonly<{
+    service: Readonly<IapRefundEventsService>;
+    privacy: {
+        tenantId: string;
+        subjectId: string;
+        kind: "guest";
+    };
+    create: () => Effect.Effect< IapRefundReceipt, EconomyError, never>;
+    close: Effect.Effect<void, EconomyError, never>;
+}>, EconomyError, never>;
+
+export declare const iapRefundEventsPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof IapRefundEventsPort;
+    fakeLayer: Layer.Layer<IapRefundEventsPort, EconomyError, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            state: "revoked" | "active" | "partially-refunded";
+            originals: number;
+            pending: number;
+        }, EconomyError, never>;
+        expected: {
+            state: string;
+            originals: number;
+            pending: number;
+        };
+    };
+}>;
+
+declare interface IapRefundEventsService {
+    readonly pending: (subject: Subject) => Effect.Effect<readonly PendingIapRefundEvent[], EconomyError>;
+    readonly read: (subject: Subject, event: PendingIapRefundEvent) => Effect.Effect<IapRefundEventContext, EconomyError>;
+    readonly acknowledge: (subject: Subject, event: PendingIapRefundEvent, deliveryVersion: string) => Effect.Effect<void, EconomyError>;
+}
+
+export declare const iapRefundFakeLayer: Layer.Layer<IapRefundPort, EconomyError, never>;
+
+declare interface IapRefundOptions {
+    readonly realMoney: boolean;
+    readonly namespace: string;
+    readonly debtPolicy: IapDebtPolicy;
+    readonly orders: Pick<IapSqlService, 'prepareCurrentState'>;
+    readonly economy: Pick<EconomySqlService, 'prepareTransfer' | 'prepareIapRefund'>;
+    readonly assets?: IapRefundAssetParticipant | undefined;
+    readonly assetsVersion?: string | undefined;
+    readonly maxHistoryRows?: number | undefined;
+}
+
+declare class IapRefundPort extends IapRefundPort_base {
+}
+
+declare const IapRefundPort_base: Context.ServiceClass<IapRefundPort, "@voltro/IapRefundPort", IapRefundService>;
+
+/** Fresh actual SQL participants per scope; provider/authenticated-notice fixtures are explicit seams. */
+export declare const iapRefundPortFixture: Effect.Effect<Readonly<{
+    service: Readonly<IapRefundService>;
+    fixture: {
+        store: DataStore;
+        f: {
+            scope: {
+                tenantId: string;
+                ownerId: string;
+            };
+            transactionId: `${string}-${string}-${string}-${string}-${string}`;
+            definition: IapProductDefinition;
+            catalog: Readonly<{
+                read: (scope: CatalogScope) => Effect.Effect< CatalogSnapshot, InventoryError>;
+                importSnapshot: (subject: Subject, input: CatalogImport) => Effect.Effect< CatalogSnapshot, InventoryError>;
+            }>;
+            inventory: InventorySqlService;
+            economy: EconomySqlService;
+            accounts: IapAccountBindingService;
+            options: IapStoreOptions;
+            verificationOptions: {
+                products: IapProductDefinition[];
+                accounts: IapAccountBindingService;
+                realMoney: boolean;
+                channel: EconomyChannel;
+                environment: IapEnvironment;
+                applicationId: string;
+                currencies: readonly CurrencyDefinition[];
+                now?: (() => number) | undefined;
+            };
+            iap: IapSqlService;
+            user: (ownerId?: string, tenant?: string) => Subject;
+            machine: {
+                readonly type: "user";
+                readonly id: string;
+                readonly tenantId: string;
+                readonly kind?: "guest" | undefined;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "apiKey";
+                readonly id: string;
+                readonly tenantId: string;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "serviceAccount";
+                readonly id: string;
+                readonly tenantId: string;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+                readonly auditActorId?: string | null;
+            } | {
+                readonly type: "anonymous";
+                readonly id: null;
+                readonly tenantId: string | null;
+                readonly credentialRejected?: string | undefined;
+            } | {
+                readonly type: "system";
+                readonly id: string;
+                readonly tenantId: null;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "service";
+                readonly id: string;
+                readonly service: string;
+                readonly tenantId: null;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            };
+            policyId: string;
+            item: ItemContract;
+            verificationCalls: () => number;
+            at: number;
+            accountToken: `${string}-${string}-${string}-${string}-${string}`;
+            receipt: string;
+            currencies: ResolvedCurrency[];
+            intent: {
+                channel: "ios";
+                offerId: string;
+                offerVersion: string;
+                requestId: string;
+                receipt: string;
+            };
+            providerOptions: {
+                realMoney: boolean;
+                environment: IapEnvironment;
+                applicationId: string;
+                products: readonly IapProductDefinition[];
+                currencies: readonly CurrencyDefinition[];
+                accounts: IapAccountSource;
+                now: () => number;
+            };
+            context: IapVerificationContext;
+            apple: JWSTransactionDecodedPayload;
+            facts: IapTransactionFacts;
+            androidDefinition: IapProductDefinition;
+            googleContext: IapVerificationContext;
+            google: {
+                purchaseStateContext: {
+                    purchaseState: string;
+                };
+                testPurchaseContext: {
+                    fopType: string;
+                };
+                obfuscatedExternalAccountId: `${string}-${string}-${string}-${string}-${string}`;
+                purchaseCompletionTime: string;
+                acknowledgementState: string;
+                productLineItem: {
+                    productId: string;
+                    productOfferDetails: {
+                        quantity: number;
+                        refundableQuantity: number;
+                        consumptionState: string;
+                    };
+                }[];
+            };
+        };
+        n: {
+            notice: IapNotificationNotice;
+            options: IapNotificationTargetOptions;
+            evidence: VerifiedIapNotification;
+        };
+        original: IapOrderReceipt;
+        target: AcceptedIapNotificationTarget;
+        options: IapRefundOptions;
+        assets: IapRefundAssetParticipant;
+        refunds: IapRefundSqlService;
+        observeProvider: (numerator: number, denominator?: number) => Promise< VerifiedIapCurrentState>;
+        advance: (ms: number) => void;
+        privacy: {
+            tenantId: string;
+            subjectId: string;
+            kind: "guest";
+        };
+    };
+    close: Effect.Effect<void, never, never>;
+}>, EconomyError, never>;
+
+export declare const iapRefundPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof IapRefundPort;
+    fakeLayer: Layer.Layer<IapRefundPort, EconomyError, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            refunded: string | undefined;
+            wallet: string | undefined;
+            stock: number;
+            replay: boolean;
+            rebuilt: boolean;
+        }, EconomyError | InventoryError, never>;
+        expected: {
+            refunded: string;
+            wallet: string;
+            stock: number;
+            replay: boolean;
+            rebuilt: boolean;
+        };
+    };
+}>;
+
+declare interface IapRefundReceipt {
+    readonly orderId: string;
+    readonly sequence: number;
+    readonly state: IapCurrentPurchaseState['state'];
+    readonly refundNumerator: number;
+    readonly refundDenominator: number;
+    readonly observedAt: number;
+    readonly noticeId: string;
+    readonly fingerprint: string;
+    readonly debtPolicy: IapDebtPolicy;
+    readonly currencies: readonly IapRefundCurrency[];
+    readonly transfers: readonly EconomyReceipt[];
+    /** Opaque actual asset participant receipt, validated by its captured participant. */
+    readonly assets: unknown;
+}
+
+declare interface IapRefundService {
+    readonly reconcile: (proof: VerifiedIapCurrentState) => Effect.Effect<IapRefundReceipt, EconomyError>;
+    readonly rebuild: (proof: VerifiedIapCurrentState) => Effect.Effect<IapRefundReceipt | null, EconomyError>;
+    readonly observe: (scope: IapScope, orderId: string) => Effect.Effect<IapRefundReceipt | null, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+/** SQL remains refund history and rebuild source. External provider I/O is complete before this writer. */
+declare interface IapRefundSqlService extends IapRefundService {
+    readonly events: IapRefundEventsService;
+    readonly readDisposition: IapRefundDispositionSource['read'];
+}
+
+declare interface IapScope {
+    readonly tenantId: string;
+    readonly ownerId: string;
+}
+
+declare interface IapService {
+    readonly redeem: (subject: Subject, input: IapReceiptIntent) => Effect.Effect<IapOrderReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: IapReceiptReference) => Effect.Effect<IapOrderObservation, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+/** SQL original after the owning adapter has validated its immutable custody and receipt. */
+declare interface IapSqlOriginalPurchase {
+    readonly orderId: string;
+    readonly scope: IapScope;
+    readonly receipt: IapOrderReceipt;
+    readonly product: IapProduct;
+    readonly facts: IapTransactionFacts;
+    readonly currencies: readonly CurrencyDefinition[];
+}
+
+declare interface IapSqlService extends IapService {
+    /** Complete owned accepted subscription periods. SQL reads only; never current provider status. */
+    readonly subscriptionPeriods: (subject: Subject) => Effect.Effect<readonly IapSubscriptionPeriod[], EconomyError>;
+    /** Server only: the provider's original transaction IDs (a Stripe subscription) of the owner's
+     * accepted subscription orders on `channel`, newest period first. Never a player projection. */
+    readonly subscriptionOriginals: (subject: Subject, channel: EconomyChannel) => Effect.Effect<readonly string[], EconomyError>;
+    /** Actual original IAP/account/retained-notice SQL fences; joins the same-store financial mutation group. */
+    readonly prepareCurrentState: (evidence: VerifiedIapCurrentState) => Effect.Effect<PreparedSqlMutation<IapCurrentPurchaseState>, EconomyError>;
+    /** Trusted server declaration + authenticated notice; read accepted SQL, never seed or fulfill. */
+    readonly prepareNotification: (options: IapNotificationTargetOptions, notice: VerifiedIapNotification) => Effect.Effect<AcceptedIapNotificationTarget, EconomyError>;
+    /** Read accepted SQL original and issue a revalidated capability; no grant, clock or provider call. */
+    readonly prepareCompletion: (subject: Subject, intent: Parameters<IapService['redeem']>[1]) => Effect.Effect<AcceptedIapCompletion, EconomyError>;
+}
+
+declare interface IapStoreOptions {
+    readonly realMoney: boolean;
+    /** Operator-owned immutable work/privacy namespace, never an RPC input. */
+    readonly namespace: string;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly verification: Pick<IapVerificationService, 'verify'>;
+    readonly admission: IapPurchaseAdmissionSource;
+    readonly economy: Pick<EconomySqlService, 'prepareTransfer'>;
+    readonly inventory?: Pick<InventorySqlService, 'prepareGrant'> | undefined;
+    readonly refundDisposition?: IapRefundDispositionSource | undefined;
+    readonly systemAccount: string;
+    readonly maxHistoryRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+
+/** 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;
+}
+
+declare class IapSystemPort extends IapSystemPort_base {
+}
+
+declare const IapSystemPort_base: Context.ServiceClass<IapSystemPort, "@voltro/IapSystemPort", IapSystemService>;
+
+export declare const iapSystemPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof IapSystemPort;
+    fakeLayer: Layer.Layer<IapPort | IapAccountsPort | EconomyPort | IapSystemPort, unknown, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            stable: boolean;
+            publicUuid: boolean;
+            erased: boolean;
+        }, unknown, never>;
+        expected: {
+            stable: boolean;
+            publicUuid: boolean;
+            erased: boolean;
+        };
+    };
+}>;
+
+/** Complete system replacement owns provider readiness, accounts, financial authority and privacy. */
+declare interface IapSystemService extends IapService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly account: (subject: Subject, channel: EconomyChannel) => Effect.Effect<string, EconomyError>;
+    /** Explicit retry of the same accepted original intent. Never redeems or grants. */
+    readonly complete: (subject: Subject, intent: Parameters<IapService['redeem']>[1]) => Effect.Effect<IapCompletionReceipt, EconomyError>;
+}
+
+declare interface IapTransactionFacts {
+    readonly channel: EconomyChannel;
+    readonly environment: IapEnvironment;
+    readonly applicationId: string;
+    readonly transactionId: string;
+    readonly originalTransactionId: string | null;
+    readonly storeProductId: string;
+    readonly kind: IapProductKind;
+    readonly quantity: number;
+    readonly purchasedAt: number;
+    readonly expiresAt: number | null;
+    readonly paid: IapPaidAmount | null;
+    readonly acknowledgement: 'none' | 'pending' | 'acknowledged';
+    readonly consumption: 'none' | 'available' | 'consumed';
+}
+
+declare interface IapVerificationContext {
+    readonly scope: IapScope;
+    readonly intent: IapReceiptIntent;
+    readonly product: IapProduct;
+    readonly accountToken: string;
+    readonly at: number;
+}
+
+declare interface IapVerificationService {
+    readonly initialize: () => Effect.Effect<void, EconomyError>;
+    readonly verify: (scope: IapScope, input: IapReceiptIntent) => Effect.Effect<VerifiedIapPurchase, EconomyError>;
+}
+
+declare interface IapWalletRefundInput {
+    readonly requestId: string;
+    readonly currency: string;
+    readonly amount: string;
+    readonly debtPolicy: IapDebtPolicy;
+}
+
+declare interface LedgerPosting {
+    readonly account: EconomyAccount;
+    readonly debit: string;
+    readonly credit: string;
+}
+
+declare interface LedgerTransfer {
+    readonly tenantId: string;
+    readonly requestId: string;
+    readonly currency: string;
+    readonly amount: string;
+    readonly reason: string;
+    readonly ref: EconomyReference;
+    readonly postings: readonly [LedgerPosting, LedgerPosting];
+}
+
+export declare const ledgerTransferFixture: () => LedgerTransfer;
+
+declare interface LedgerTransferInput {
+    readonly tenantId: string;
+    readonly requestId: string;
+    readonly currency: string;
+    readonly from: EconomyAccount;
+    readonly to: EconomyAccount;
+    readonly amount: EconomyAmountInput;
+    readonly reason: string;
+    readonly ref: EconomyReference;
+}
+
+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. */
+declare interface LoyaltyCreditInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly loyaltyId: string;
+    readonly sourceId: string;
+    readonly purchaseId: string;
+    readonly requestId: string;
+}
+
+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 const loyaltyFakeLayer: Layer.Layer<EconomyPort | LoyaltyPort, EconomyError, never>;
+
+export declare const loyaltyFixture: () => Readonly<{
+    loyalty: Loyalty;
+    currencies: {
+        id: string;
+        kind: "soft";
+    }[];
+    points: "1000";
+    realMoney: false;
+}>;
+
+declare interface LoyaltyMineInput {
+    readonly loyaltyId: string;
+}
+
+declare type LoyaltyObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: LoyaltyReceipt;
+};
+
+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;
+    }[];
+};
+
+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;
+};
+
+declare interface LoyaltyPerksContext extends LoyaltyTierContext {
+    readonly tierId: string;
+}
+
+declare type LoyaltyPerksResolver = (input: LoyaltyPerksContext) => readonly LoyaltyPerk[];
+
+export declare const loyaltyPerksSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: LoyaltyPerksResolver;
+    defaultProbe: {
+        run: () => Effect.Effect<readonly LoyaltyPerk[], never, never>;
+        expected: {
+            id: string;
+            kind: string;
+            bps: number;
+        }[];
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<readonly LoyaltyPerk[], never, never>;
+        expected: never[];
+    };
+}>;
+
+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;
+};
+
+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;
+    }[];
+}
+
+declare class LoyaltyPort extends LoyaltyPort_base {
+}
+
+declare const LoyaltyPort_base: Context.ServiceClass<LoyaltyPort, "@voltro/LoyaltyPort", LoyaltyService>;
+
+/** Actual installed memory-store points port and actual virtual Shop receipt.
+ * Seasons/refunds are named fixture sources; no production source is invented. */
+export declare const loyaltyPortFixture: Effect.Effect<Readonly<{
+    store: InMemoryDataStore;
+    plugin: EconomyPlugin;
+    base: {
+        base: {
+            economy: EconomySqlService;
+            inventory: InventorySqlService;
+            catalog: Readonly<{
+                read: (scope: CatalogScope) => Effect.Effect< CatalogSnapshot, InventoryError>;
+                importSnapshot: (subject: Subject, input: CatalogImport) => Effect.Effect< CatalogSnapshot, InventoryError>;
+            }>;
+            options: ShopStoreOptions;
+            shop: ShopSqlService;
+            user: {
+                readonly type: "user";
+                readonly id: string;
+                readonly tenantId: string;
+                readonly kind?: "guest" | undefined;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "apiKey";
+                readonly id: string;
+                readonly tenantId: string;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "serviceAccount";
+                readonly id: string;
+                readonly tenantId: string;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+                readonly auditActorId?: string | null;
+            } | {
+                readonly type: "anonymous";
+                readonly id: null;
+                readonly tenantId: string | null;
+                readonly credentialRejected?: string | undefined;
+            } | {
+                readonly type: "system";
+                readonly id: string;
+                readonly tenantId: null;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "service";
+                readonly id: string;
+                readonly service: string;
+                readonly tenantId: null;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            };
+            buy: ShopBuyInput;
+        };
+        options: LoyaltyStoreOptions;
+        service: LoyaltyService;
+        credit: (purchaseId: string, requestId?: string) => {
+            tenantId: string;
+            ownerId: string;
+            loyaltyId: string;
+            sourceId: string;
+            purchaseId: string;
+            requestId: string;
+        };
+        setAt: (value: number) => void;
+    };
+    purchase: ShopOrderReceipt;
+    accepted: LoyaltyReceipt;
+    close: Effect.Effect<void, never, never>;
+}>, EconomyError, never>;
+
+export declare const loyaltyPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof LoyaltyPort;
+    fakeLayer: Layer.Layer<EconomyPort | LoyaltyPort, EconomyError, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            same: boolean;
+            points: string;
+            tier: string;
+        }, EconomyError, never>;
+        expected: {
+            same: boolean;
+            points: string;
+            tier: string;
+        };
+    };
+}>;
+
+/** Receipt authority must use immutable accepted SQL/provider evidence, verify
+ * ownership and canonical purchase identity independently of source aliases,
+ * and refuse revoked/unsettled/already-refunded purchases. No player evidence. */
+declare interface LoyaltyPurchaseEvidence {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly authorityId: string;
+    readonly purchaseId: string;
+    readonly kind: 'purchase.real' | 'purchase.virtual';
+    readonly currency: string;
+    readonly amount: string;
+    readonly settledAt: number;
+    readonly refundedAmount: '0';
+}
+
+declare interface LoyaltyRebuildInput extends LoyaltyMineInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+}
+
+declare interface LoyaltyReceipt {
+    readonly operationId: string;
+    readonly requestId: string;
+    readonly loyaltyId: string;
+    readonly entry: LoyaltyPointEntry;
+    readonly points: string;
+}
+
+declare interface LoyaltyReceiptInput {
+    readonly requestId: string;
+}
+
+declare interface LoyaltyReceiptSource {
+    readonly purchase: (input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly source: Loyalty['pointsFrom'][number];
+        readonly purchaseId: string;
+    }) => Effect.Effect<LoyaltyPurchaseEvidence, EconomyError>;
+    readonly refund: (input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly purchase: LoyaltyPurchaseEvidence;
+        readonly refundId: string;
+    }) => Effect.Effect<LoyaltyRefundEvidence, EconomyError>;
+}
+
+declare interface LoyaltyRefundEvidence {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly authorityId: string;
+    readonly purchaseId: string;
+    readonly refundId: string;
+    readonly totalRefunded: string;
+    readonly refundedAt: number;
+}
+
+declare interface LoyaltyReverseInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly loyaltyId: string;
+    readonly originalId: string;
+    readonly refundId: string;
+    readonly requestId: string;
+}
+
+declare interface LoyaltySeason {
+    readonly id: string;
+    readonly startsAt: number;
+    readonly endsAt: number;
+}
+
+declare interface LoyaltySeasonSource {
+    readonly read: (input: {
+        readonly tenantId: string;
+        readonly loyaltyId: string;
+        readonly at: number;
+    }) => Effect.Effect<LoyaltySeason, EconomyError>;
+}
+
+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>;
+}
+
+declare interface LoyaltyState {
+    readonly loyalty: Loyalty;
+    readonly rulesVersion: string;
+    readonly seasonId: string | null;
+    readonly points: string;
+    readonly tierId: string;
+    readonly perks: readonly LoyaltyPerk[];
+}
+
+declare interface LoyaltyStoreOptions {
+    readonly loyalty: readonly (LoyaltyDefinition | Loyalty)[];
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly receiptSource: LoyaltyReceiptSource;
+    readonly seasonSource?: LoyaltySeasonSource | undefined;
+    readonly version: string;
+    readonly tier?: LoyaltyTierResolver | undefined;
+    readonly perks?: LoyaltyPerksResolver | undefined;
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly maxDefinitionRows?: number | undefined;
+    readonly maxSeasonRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+
+declare interface LoyaltyTierContext {
+    readonly loyalty: Loyalty;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly points: EconomyAmountInput;
+    readonly rulesVersion?: string;
+}
+
+declare type LoyaltyTierResolver = (context: LoyaltyTierContext) => string;
+
+export declare const loyaltyTierSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: LoyaltyTierResolver;
+    defaultProbe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+}>;
+
+declare interface OfferExperiment {
+    readonly id: string;
+    readonly version: string;
+    readonly from: number;
+    readonly until: number;
+    readonly variants: readonly {
+        readonly id: string;
+        readonly weight: number;
+        readonly offers: readonly ShopOffer[];
+    }[];
+    readonly metrics: readonly string[];
+}
+
+declare interface OfferExperimentContext {
+    readonly experiment: OfferExperiment;
+    readonly tenantId: string;
+    readonly key: string;
+    readonly at: number;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+}
+
+export declare const offerExperimentFixture: () => Readonly<{
+    experiment: OfferExperiment;
+    currencies: {
+        id: string;
+        kind: "soft";
+    }[];
+    tenantId: "fixture";
+    key: "canonical.a";
+    at: 1;
+    realMoney: false;
+}>;
+
+/** Actual pending SQL event authority. Copies and serialized payloads cannot authorize delivery acknowledgement. */
+declare interface PendingIapRefundEvent {
+    readonly [refundEvent]: true;
+    readonly eventId: string;
+}
+
+declare interface PersonalizedOfferContext {
+    readonly personalized: PersonalizedOffers;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly tenantId: string;
+    readonly key: string;
+    readonly at: number;
+    readonly ownedItemIds: readonly string[];
+    readonly playStyles: readonly string[];
+    readonly rulesVersion?: string;
+}
+
+export declare const personalizedOfferFixture: () => Readonly<{
+    personalized: PersonalizedOffers;
+    currencies: {
+        id: string;
+        kind: "soft";
+    }[];
+    tenantId: "fixture";
+    key: "canonical.a";
+    at: 1;
+    ownedItemIds: string[];
+    playStyles: string[];
+    realMoney: false;
+}>;
+
+declare interface PersonalizedOffers {
+    readonly id: string;
+    readonly version: string;
+    readonly slots: number;
+    readonly rotationMs: number;
+    readonly rotationAnchorAt: number;
+    readonly pool: readonly {
+        readonly offer: ShopOffer;
+        readonly affinities: readonly string[];
+    }[];
+}
+
+declare type PersonalizedOfferSelector = (input: PersonalizedSelectorContext) => readonly string[];
+
+declare interface PersonalizedSelectorContext extends PersonalizedOfferContext {
+    readonly rotation: number;
+    readonly rulesVersion: string;
+}
+
+export declare const personalizedSelectorSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: PersonalizedOfferSelector;
+    defaultProbe: {
+        run: () => Effect.Effect<string[] | undefined, never, never>;
+        expected: string[];
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<string[] | undefined, never, never>;
+        expected: string[];
+    };
+}>;
+
+declare interface PiggyBank {
+    readonly id: string;
+    readonly version: string;
+    readonly titleKey: string;
+    readonly currency: string;
+    readonly cap: string;
+    readonly unlock: Price;
+    readonly fillFrom: readonly string[];
+    readonly reset: 'onUnlock';
+}
+
+declare interface PiggyBankDefinition {
+    readonly id: string;
+    readonly version?: string | undefined;
+    readonly titleKey: string;
+    readonly currency: string;
+    readonly cap: EconomyAmountInput;
+    readonly unlock: PriceDefinition;
+    readonly fillFrom: readonly string[];
+    readonly reset?: 'onUnlock' | undefined;
+}
+
+export declare const piggyBankFixture: () => Readonly<{
+    bank: PiggyBank;
+    currencies: {
+        id: string;
+        kind: "soft";
+        cap: string;
+    }[];
+    available: "13";
+    acceptedAmount: "13";
+    realMoney: false;
+}>;
+
+export declare const piggyBanksFakeLayer: Layer.Layer<EconomyPort | PiggyBanksPort, EconomyError, never>;
+
+declare class PiggyBanksPort extends PiggyBanksPort_base {
+}
+
+declare const PiggyBanksPort_base: Context.ServiceClass<PiggyBanksPort, "@voltro/PiggyBanksPort", PiggyBanksService>;
+
+export declare const piggyBanksPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof PiggyBanksPort;
+    fakeLayer: Layer.Layer<EconomyPort | PiggyBanksPort, EconomyError, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            same: boolean;
+            observed: "fulfilled" | "not-observed";
+            available: string;
+            cycles: number;
+            balance: string;
+        }, EconomyError, never>;
+        expected: {
+            same: boolean;
+            observed: string;
+            available: string;
+            cycles: number;
+            balance: string;
+        };
+    };
+}>;
+
+declare interface PiggyBanksService {
+    readonly list: (subject: Subject) => Effect.Effect<readonly PiggyView[], EconomyError>;
+    readonly fill: (subject: Subject, input: PiggyFillInput) => Effect.Effect<PiggyReceipt, EconomyError>;
+    readonly unlock: (subject: Subject, input: PiggyUnlockInput) => Effect.Effect<PiggyReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: {
+        readonly requestId: string;
+    }) => Effect.Effect<PiggyObservation, EconomyError>;
+    readonly rebuild: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly bankId: string;
+    }) => Effect.Effect<PiggyProjection, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare type PiggyEvent = {
+    readonly id: string;
+    readonly sequence: number;
+    readonly kind: 'fill';
+    readonly at: number;
+    readonly authorityId: string;
+    readonly eventId: string;
+    readonly sourceId: string;
+    readonly acceptedAmount: string;
+    readonly delta: string;
+} | {
+    readonly id: string;
+    readonly sequence: number;
+    readonly kind: 'unlock';
+    readonly at: number;
+    readonly amount: string;
+    readonly remaining: string;
+};
+
+declare interface PiggyFillContext extends PiggyRuleContext {
+    readonly acceptedAmount: EconomyAmountInput;
+}
+
+declare interface PiggyFillEvidence {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly authorityId: string;
+    readonly eventId: string;
+    readonly sourceId: string;
+    readonly amount: string;
+    readonly acceptedAt: number;
+}
+
+declare interface PiggyFillInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly bankId: string;
+    readonly sourceId: string;
+    readonly eventId: string;
+    readonly requestId: string;
+}
+
+declare type PiggyFillPolicy = (context: PiggyFillContext) => EconomyAmountInput;
+
+/** Actual accepted server events only. Canonical authority/event identity must
+ * stay independent of aliases and be scoped/verified by the application's
+ * authoritative event source. No player match result or amount is accepted. */
+declare interface PiggyFillSource {
+    readonly read: (input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly bank: PiggyBank;
+        readonly sourceId: string;
+        readonly eventId: string;
+    }) => Effect.Effect<PiggyFillEvidence, EconomyError>;
+}
+
+export declare const piggyFillSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: PiggyFillPolicy;
+    defaultProbe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<string, never, never>;
+        expected: string;
+    };
+}>;
+
+declare type PiggyObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: PiggyReceipt;
+};
+
+/** Fresh installed port using actual wallet writers. Receipt and eligibility
+ * sources are explicitly named fixture seams, never production Match facts. */
+export declare const piggyPortFixture: Effect.Effect<Readonly<{
+    store: InMemoryDataStore;
+    base: {
+        economy: EconomySqlService;
+        user: {
+            readonly type: "user";
+            readonly id: string;
+            readonly tenantId: string;
+            readonly kind?: "guest" | undefined;
+            readonly scopes?: readonly string[] | undefined;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        } | {
+            readonly type: "apiKey";
+            readonly id: string;
+            readonly tenantId: string;
+            readonly scopes?: readonly string[] | undefined;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        } | {
+            readonly type: "serviceAccount";
+            readonly id: string;
+            readonly tenantId: string;
+            readonly scopes?: readonly string[] | undefined;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly auditActorId?: string | null;
+        } | {
+            readonly type: "anonymous";
+            readonly id: null;
+            readonly tenantId: string | null;
+            readonly credentialRejected?: string | undefined;
+        } | {
+            readonly type: "system";
+            readonly id: string;
+            readonly tenantId: null;
+            readonly scopes?: readonly string[] | undefined;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        } | {
+            readonly type: "service";
+            readonly id: string;
+            readonly service: string;
+            readonly tenantId: null;
+            readonly scopes?: readonly string[] | undefined;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        };
+        options: PiggyStoreOptions;
+        service: PiggyBanksService;
+        fill: (eventId: string, requestId?: string) => {
+            tenantId: string;
+            ownerId: string;
+            bankId: string;
+            sourceId: string;
+            eventId: string;
+            requestId: string;
+        };
+        setAt: (value: number) => void;
+    };
+    plugin: EconomyPlugin;
+    view: PiggyView;
+    unlock: {
+        bankId: string;
+        bankVersion: string;
+        bankDigest: string;
+        requestId: string;
+        currency: string | undefined;
+    };
+    close: Effect.Effect<void, never, never>;
+}>, EconomyError, never>;
+
+declare interface PiggyProjection {
+    readonly events: readonly PiggyEvent[];
+    readonly available: string;
+    readonly cycles: number;
+}
+
+declare type PiggyReceipt = {
+    readonly operationId: string;
+    readonly requestId: string;
+    readonly bankId: string;
+    readonly event: Extract<PiggyEvent, {
+        kind: 'fill';
+    }>;
+    readonly available: string;
+} | {
+    readonly operationId: string;
+    readonly requestId: string;
+    readonly bankId: string;
+    readonly event: Extract<PiggyEvent, {
+        kind: 'unlock';
+    }>;
+    readonly available: string;
+    readonly value: ShopOrderReceipt;
+};
+
+declare type PiggyResetPolicy = (context: PiggyRuleContext) => EconomyAmountInput;
+
+export declare const piggyResetSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: PiggyResetPolicy;
+    defaultProbe: {
+        run: () => Effect.Effect<Readonly<{
+            remaining: string;
+            amount: string;
+        }>, never, never>;
+        expected: {
+            remaining: string;
+            amount: string;
+        };
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<Readonly<{
+            remaining: string;
+            amount: string;
+        }>, never, never>;
+        expected: {
+            remaining: string;
+            amount: string;
+        };
+    };
+}>;
+
+declare interface PiggyRuleContext {
+    readonly bank: PiggyBank;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly available: EconomyAmountInput;
+    readonly rulesVersion?: string;
+}
+
+declare interface PiggyStoreOptions {
+    readonly banks: readonly (PiggyBankDefinition | PiggyBank)[];
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly economy: Pick<EconomySqlService, 'prepareTransfer'>;
+    readonly fillSource: PiggyFillSource;
+    readonly unlockSource: PiggyUnlockSource;
+    readonly version: string;
+    readonly fill?: PiggyFillPolicy | undefined;
+    readonly reset?: PiggyResetPolicy | undefined;
+    readonly priceResolver?: PriceResolver | undefined;
+    readonly systemAccount?: string | undefined;
+    readonly allowedServices?: readonly string[] | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+
+declare interface PiggyUnlockInput {
+    readonly bankId: string;
+    readonly bankVersion: string;
+    readonly bankDigest: string;
+    readonly requestId: string;
+    readonly currency?: string | undefined;
+}
+
+declare interface PiggyUnlockSource {
+    readonly read: (input: {
+        readonly subject: Subject;
+        readonly bank: PiggyBank;
+        readonly at: number;
+    }) => Effect.Effect<{
+        readonly eligible: boolean;
+        readonly adjustments: readonly VirtualPriceAdjustment[];
+    }, EconomyError>;
+}
+
+declare interface PiggyView {
+    readonly bank: PiggyBank;
+    readonly bankDigest: string;
+    readonly available: string;
+    readonly cycles: number;
+}
+
+declare type Price = {
+    readonly kind: 'virtual';
+    readonly options: readonly ResolvedVirtualPriceOption[];
+} | ({
+    readonly kind: 'real';
+} & RealPriceDefinition) | {
+    readonly kind: 'mixed';
+    readonly real: RealPriceDefinition;
+    readonly virtual: readonly ResolvedVirtualPriceOption[];
+} | {
+    readonly kind: 'free';
+};
+
+declare type PriceDefinition = {
+    readonly kind: 'virtual';
+    readonly options: readonly VirtualPriceOption[];
+} | ({
+    readonly kind: 'real';
+} & RealPriceDefinition) | {
+    readonly kind: 'mixed';
+    readonly real: RealPriceDefinition;
+    readonly virtual: readonly VirtualPriceOption[];
+} | {
+    readonly kind: 'free';
+};
+
+declare type PriceResolver = (context: PriceResolverContext) => Price;
+
+declare interface PriceResolverContext {
+    readonly price: Price;
+    readonly currencies: readonly ResolvedCurrency[];
+    readonly realMoney: boolean;
+    readonly adjustments: readonly Readonly<{
+        currency: string;
+        discountBps: number;
+        minimum: string;
+    }>[];
+}
+
+/** Hypothetical fixture configuration, never a deployment pricing decision. */
+export declare const priceResolverFixture: () => Readonly<{
+    resolver: PriceResolver;
+    context: PriceResolverContext;
+}>;
+
+export declare const priceResolverSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: PriceResolver;
+    defaultProbe: {
+        run: () => Effect.Effect< Price, never, never>;
+        expected: {
+            kind: string;
+            options: {
+                currency: string;
+                amount: string;
+            }[];
+        };
+    };
+    overrideProbe: {
+        run: () => Effect.Effect< Price, never, never>;
+        expected: {
+            kind: string;
+            options: {
+                currency: string;
+                amount: string;
+            }[];
+        };
+    };
+}>;
+
+declare interface PromoCode {
+    readonly id: string;
+    readonly version: string;
+    readonly campaign: string;
+    readonly items: readonly {
+        readonly itemId: string;
+        readonly qty: number;
+    }[];
+    readonly currencies: readonly {
+        readonly currency: string;
+        readonly amount: string;
+    }[];
+    readonly from: number | null;
+    readonly until: number | null;
+    readonly limits: {
+        readonly global: number;
+        readonly perPlayer: number;
+    };
+}
+
+declare interface RealPriceDefinition {
+    /** Integer minor-unit references; verified store receipts remain authoritative. */
+    readonly prices: Readonly<Record<string, number>>;
+    readonly storeProductIds: Partial<Readonly<Record<EconomyChannel, string>>>;
+}
+
+declare interface RedeemCodeInput {
+    readonly code: string;
+    readonly requestId: string;
+}
+
+declare const refundEvent: unique symbol;
+
+declare interface ResolvedCurrency {
+    readonly id: string;
+    readonly kind: 'soft' | 'hard';
+    readonly cap: string;
+    readonly premium: boolean;
+    readonly display: {
+        readonly nameKey: string;
+    } | null;
+}
+
+declare interface ResolvedVirtualPriceOption {
+    readonly currency: string;
+    readonly amount: string;
+}
+
+declare interface ShopAudit {
+    readonly matches: boolean;
+    readonly acceptedOrders: number;
+    readonly counters: number;
+}
+
+declare interface ShopBuyInput {
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly offerDigest: string;
+    readonly requestId: string;
+    readonly currency?: string | undefined;
+    readonly qty?: number | undefined;
+}
+
+declare interface ShopContextInput {
+    readonly subject: Subject;
+    readonly offer: ShopOffer;
+    readonly at: number;
+}
+
+declare interface ShopContextSnapshot {
+    readonly eligible: boolean;
+    readonly adjustments: readonly VirtualPriceAdjustment[];
+}
+
+/** Trusted external profile/segment/flag facts; never inside a replayable SQL callback. */
+declare interface ShopContextSource {
+    readonly read: (input: ShopContextInput) => Effect.Effect<ShopContextSnapshot, EconomyError>;
+}
+
+declare interface ShopCurrencyGrant {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+export declare const shopFakeLayer: Layer.Layer<ShopPort | EconomyPort, never, never>;
+
+declare interface ShopItemGrant {
+    readonly itemId: string;
+    readonly qty: number;
+}
+
+declare interface ShopOffer {
+    readonly id: string;
+    readonly version: string;
+    readonly titleKey: string;
+    readonly price: Price;
+    readonly items: readonly ShopItemGrant[];
+    readonly currencies: readonly {
+        readonly currency: string;
+        readonly amount: string;
+    }[];
+    readonly from: number | null;
+    readonly until: number | null;
+    readonly segment: string | null;
+    readonly flag: string | null;
+    readonly countries: readonly string[];
+    readonly limits: {
+        readonly perPlayer: number | null;
+        readonly perDay: number | null;
+        readonly global: number | null;
+    };
+    readonly oneTime: boolean;
+    readonly maxQuantity: number;
+}
+
+declare interface ShopOfferDefinition {
+    readonly id: string;
+    readonly version?: string | undefined;
+    readonly titleKey: string;
+    readonly price: PriceDefinition;
+    readonly items?: readonly ShopItemGrant[] | undefined;
+    readonly currencies?: readonly ShopCurrencyGrant[] | undefined;
+    readonly from?: number | null | undefined;
+    readonly until?: number | null | undefined;
+    readonly segment?: string | null | undefined;
+    readonly flag?: string | null | undefined;
+    readonly countries?: readonly string[] | undefined;
+    readonly limits?: {
+        readonly perPlayer?: number | null | undefined;
+        readonly perDay?: number | null | undefined;
+        readonly global?: number | null | undefined;
+    } | undefined;
+    readonly oneTime?: boolean | undefined;
+    readonly maxQuantity?: number | undefined;
+}
+
+/** Immediate virtual Shop example, not an Owner pricing choice. */
+export declare const shopOfferFixture: () => ShopOffer;
+
+declare interface ShopOfferView {
+    readonly offerDigest: string;
+    readonly offer: ShopOffer;
+    readonly price: Price;
+}
+
+declare interface ShopOrderReceipt {
+    readonly orderId: string;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly offerDigest: string;
+    readonly quantity: number;
+    readonly at: number;
+    readonly pricePaid: {
+        readonly kind: 'free';
+    } | {
+        readonly kind: 'virtual';
+        readonly currency: string;
+        readonly amount: string;
+    };
+    readonly transfers: readonly {
+        readonly txId: string;
+        readonly currency: string;
+        readonly amount: string;
+        readonly at: number;
+    }[];
+    readonly grants: readonly {
+        readonly operationId: string;
+        readonly kind: 'grant';
+        readonly changes: readonly {
+            readonly instanceId: string;
+            readonly delta: number;
+        }[];
+        readonly at: number;
+    }[];
+}
+
+declare class ShopPort extends ShopPort_base {
+}
+
+declare const ShopPort_base: Context.ServiceClass<ShopPort, "@voltro/ShopPort", ShopService>;
+
+/** Actual installed memory-store Shop with the borrowed wallet and inventory
+ * writers of the shop fixture; no payment provider or production catalog. */
+export declare const shopPortFixture: Effect.Effect<Readonly<{
+    store: InMemoryDataStore;
+    plugin: EconomyPlugin;
+    base: {
+        economy: EconomySqlService;
+        inventory: InventorySqlService;
+        catalog: Readonly<{
+            read: (scope: CatalogScope) => Effect.Effect< CatalogSnapshot, InventoryError>;
+            importSnapshot: (subject: Subject, input: CatalogImport) => Effect.Effect< CatalogSnapshot, InventoryError>;
+        }>;
+        options: ShopStoreOptions;
+        shop: ShopSqlService;
+        user: {
+            readonly type: "user";
+            readonly id: string;
+            readonly tenantId: string;
+            readonly kind?: "guest" | undefined;
+            readonly scopes?: readonly string[] | undefined;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        } | {
+            readonly type: "apiKey";
+            readonly id: string;
+            readonly tenantId: string;
+            readonly scopes?: readonly string[] | undefined;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        } | {
+            readonly type: "serviceAccount";
+            readonly id: string;
+            readonly tenantId: string;
+            readonly scopes?: readonly string[] | undefined;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+            readonly auditActorId?: string | null;
+        } | {
+            readonly type: "anonymous";
+            readonly id: null;
+            readonly tenantId: string | null;
+            readonly credentialRejected?: string | undefined;
+        } | {
+            readonly type: "system";
+            readonly id: string;
+            readonly tenantId: null;
+            readonly scopes?: readonly string[] | undefined;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        } | {
+            readonly type: "service";
+            readonly id: string;
+            readonly service: string;
+            readonly tenantId: null;
+            readonly scopes?: readonly string[] | undefined;
+            readonly metadata?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        };
+        buy: ShopBuyInput;
+    };
+    close: Effect.Effect<void, never, never>;
+}>, never, never>;
+
+export declare const shopPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof ShopPort;
+    fakeLayer: Layer.Layer<ShopPort | EconomyPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            same: boolean;
+            quantity: number;
+            balance: string | undefined;
+        }, EconomyError, never>;
+        expected: {
+            same: boolean;
+            quantity: number;
+            balance: string;
+        };
+    };
+}>;
+
+/** Nonterminal observations never authorize a new request identity or prove that no purchase can commit. */
+declare type ShopPurchaseObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed' | 'pending';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: ShopOrderReceipt;
+};
+
+declare interface ShopRules {
+    readonly offers: readonly (ShopOfferDefinition | ShopOffer)[];
+    readonly priceResolver?: PriceResolver | undefined;
+    readonly contextSource?: ShopContextSource | undefined;
+    readonly version?: string | undefined;
+    readonly systemAccount?: string | undefined;
+    readonly maxOrders?: number | undefined;
+    readonly maxAuditRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+
+declare interface ShopService {
+    readonly offers: (subject: Subject) => Effect.Effect<readonly ShopOfferView[], EconomyError>;
+    readonly buy: (subject: Subject, input: ShopBuyInput) => Effect.Effect<ShopOrderReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: ShopBuyInput) => Effect.Effect<ShopPurchaseObservation, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare interface ShopSqlService extends ShopService {
+    readonly auditShop: (subject: Subject, tenantId: string) => Effect.Effect<ShopAudit, EconomyError>;
+    readonly rebuildShop: (subject: Subject, tenantId: string) => Effect.Effect<ShopAudit, EconomyError>;
+}
+
+declare interface ShopStoreOptions extends ShopRules {
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly economy: Pick<EconomySqlService, 'prepareTransfer'>;
+    readonly inventory?: Pick<InventorySqlService, 'prepareGrant'> | undefined;
+}
+
+declare interface SpendBudget {
+    readonly daily: string | null;
+    readonly monthly: string | null;
+    readonly allowed: boolean;
+}
+
+declare interface SpendFacts extends SpendFactsInput {
+    readonly allowed: boolean;
+    readonly minor: boolean;
+    readonly observedAt: number;
+    readonly daily?: EconomyAmountInput | null | undefined;
+    readonly monthly?: EconomyAmountInput | null;
+    readonly blockedUntil?: number | null;
+}
+
+declare interface SpendFactsInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly ownerKind: 'player' | 'guild';
+    readonly currency: string;
+    readonly at: number;
+}
+
+declare interface SpendLimit {
+    readonly currency: string;
+    readonly daily: string | null;
+    readonly monthly: string | null;
+    readonly minors: {
+        readonly daily: string | null;
+        readonly monthly: string | null;
+    } | null;
+}
+
+declare interface SpendLimitContext {
+    readonly limit: SpendLimit;
+    readonly facts: SpendFacts;
+    readonly version: string;
+}
+
+export declare const spendLimitFixture: () => Readonly<{
+    limit: SpendLimit;
+    facts: Readonly<{
+        tenantId: "fixture";
+        ownerId: "a";
+        ownerKind: "player";
+        currency: "test.gold";
+        at: 100;
+        observedAt: 100;
+        allowed: true;
+        minor: true;
+    }>;
+    version: "test.spend.v1";
+}>;
+
+declare type SpendLimitPolicy = (input: SpendLimitContext) => SpendBudget;
+
+export declare const spendLimitPolicySystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: SpendLimitPolicy;
+    defaultProbe: {
+        run: () => Effect.Effect< SpendBudget, never, never>;
+        expected: {
+            daily: string;
+            monthly: string;
+            allowed: boolean;
+        };
+    };
+    overrideProbe: {
+        run: () => Effect.Effect< SpendBudget, never, never>;
+        expected: {
+            daily: string;
+            monthly: string;
+            allowed: boolean;
+        };
+    };
+}>;
+
+export declare const spendLimitsFakeLayer: Layer.Layer<EconomyPort, EconomyError, never>;
+
+/** Actual fresh installed wallet port. The age/parent source is a named test
+ * authority seam; a fake Layer cannot verify a production identity provider. */
+export declare const spendLimitsPortFixture: Effect.Effect<Readonly<{
+    store: InMemoryDataStore;
+    plugin: EconomyPlugin;
+    currencies: {
+        id: string;
+        kind: "soft";
+    }[];
+    who: {
+        readonly type: "user";
+        readonly id: string;
+        readonly tenantId: string;
+        readonly kind?: "guest" | undefined;
+        readonly scopes?: readonly string[] | undefined;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    } | {
+        readonly type: "apiKey";
+        readonly id: string;
+        readonly tenantId: string;
+        readonly scopes?: readonly string[] | undefined;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    } | {
+        readonly type: "serviceAccount";
+        readonly id: string;
+        readonly tenantId: string;
+        readonly scopes?: readonly string[] | undefined;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+        readonly auditActorId?: string | null;
+    } | {
+        readonly type: "anonymous";
+        readonly id: null;
+        readonly tenantId: string | null;
+        readonly credentialRejected?: string | undefined;
+    } | {
+        readonly type: "system";
+        readonly id: string;
+        readonly tenantId: null;
+        readonly scopes?: readonly string[] | undefined;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    } | {
+        readonly type: "service";
+        readonly id: string;
+        readonly service: string;
+        readonly tenantId: null;
+        readonly scopes?: readonly string[] | undefined;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
+    };
+    close: Effect.Effect<void, never, never>;
+}>, EconomyError, never>;
+
+export declare const spendLimitsPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof EconomyPort;
+    fakeLayer: Layer.Layer<EconomyPort, EconomyError, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            same: boolean;
+            refusal: string;
+            balance: string;
+        }, EconomyError, never>;
+        expected: {
+            same: boolean;
+            refusal: string;
+            balance: string;
+        };
+    };
+}>;
+
+declare interface Subscription {
+    readonly id: string;
+    readonly version: string;
+    readonly titleKey: string;
+    readonly price: Price;
+    readonly period: Readonly<{
+        unit: 'day' | 'week' | 'month';
+        count: number;
+    }>;
+    readonly grants: Readonly<{
+        onPurchase: SubscriptionGift;
+        daily: SubscriptionGift;
+    }>;
+    readonly graceDays: number;
+    readonly coolingOff: Readonly<{
+        days: number;
+        overrideReason: string | null;
+    }>;
+    readonly disclosure: Readonly<{
+        durationKey: string;
+        renewalKey: string;
+        cancellationPath: string;
+    }>;
+}
+
+/** Consent and eligibility are application authority, never inferred from a
+ * price declaration or a player boolean. No automatic provider acquisition. */
+declare interface SubscriptionAccessSource {
+    readonly read: (input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly subscription: Subscription;
+        readonly at: number;
+        readonly kind: 'start' | 'renew';
+    }) => Effect.Effect<{
+        readonly eligible: boolean;
+        readonly renewalConsent: boolean;
+        readonly adjustments: readonly VirtualPriceAdjustment[];
+    }, EconomyError>;
+}
+
+declare interface SubscriptionActiveView {
+    readonly entitlementId: string;
+    readonly subscription: Subscription;
+    readonly subscriptionDigest: string;
+    readonly originAt: number;
+    readonly periodIndex: number;
+    readonly window: SubscriptionEntitlement;
+    readonly currency: string | null;
+    readonly renews: boolean;
+    readonly cancelledAt: number | null;
+}
+
+declare interface SubscriptionCancelInput {
+    readonly entitlementId: string;
+    readonly requestId: string;
+}
+
+declare interface SubscriptionCancellationReceipt {
+    readonly operationId: string;
+    readonly entitlementId: string;
+    readonly at: number;
+    readonly renews: false;
+}
+
+declare interface SubscriptionDailyContext {
+    readonly entitlement: SubscriptionEntitlement;
+    readonly at: number;
+    readonly claimedDays: readonly number[];
+    readonly rulesVersion?: string;
+}
+
+declare type SubscriptionDailyGrantPolicy = (input: SubscriptionDailyContext) => boolean;
+
+declare interface SubscriptionDailyInput {
+    readonly entitlementId: string;
+    readonly requestId: string;
+}
+
+export declare const subscriptionDailySystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: SubscriptionDailyGrantPolicy;
+    defaultProbe: {
+        run: () => Effect.Effect<Readonly<{
+            eligible: boolean;
+            day: number;
+        }>, never, never>;
+        expected: {
+            eligible: boolean;
+            day: number;
+        };
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<Readonly<{
+            eligible: boolean;
+            day: number;
+        }>, never, never>;
+        expected: {
+            eligible: boolean;
+            day: number;
+        };
+    };
+}>;
+
+declare interface SubscriptionDefinition {
+    readonly id: string;
+    readonly version?: string | undefined;
+    readonly titleKey: string;
+    readonly price: PriceDefinition;
+    readonly period: {
+        readonly unit: 'day' | 'week' | 'month';
+        readonly count: number;
+    };
+    readonly grants: {
+        readonly onPurchase?: SubscriptionGiftDefinition;
+        readonly daily?: SubscriptionGiftDefinition | undefined;
+    };
+    readonly graceDays?: number;
+    readonly coolingOff?: {
+        readonly days: number;
+        readonly overrideReason?: string | null;
+    };
+    readonly disclosure: {
+        readonly durationKey: string;
+        readonly renewalKey: string;
+        readonly cancellationPath: string;
+    };
+}
+
+declare interface SubscriptionEntitlement {
+    readonly startsAt: number;
+    readonly expiresAt: number;
+    readonly graceUntil: number;
+    readonly state: 'active' | 'grace' | 'expired';
+}
+
+/** Actual pure defaults, not a billing, SQL-entitlement or idempotency fake. */
+export declare const subscriptionFixture: () => Readonly<{
+    subscription: Subscription;
+    currencies: readonly {
+        id: string;
+        kind: "soft";
+        cap: string;
+    }[];
+    realMoney: false;
+    originAt: number;
+    index: 0;
+}>;
+
+declare interface SubscriptionGift {
+    readonly items: ShopOffer['items'];
+    readonly currencies: ShopOffer['currencies'];
+}
+
+declare interface SubscriptionGiftDefinition {
+    readonly items?: ShopOfferDefinition['items'] | undefined;
+    readonly currencies?: ShopOfferDefinition['currencies'] | undefined;
+}
+
+declare type SubscriptionObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: SubscriptionValueReceipt | SubscriptionCancellationReceipt;
+};
+
+declare interface SubscriptionPeriodContext {
+    readonly subscription: Subscription;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly originAt: number;
+    readonly index: number;
+    readonly rulesVersion?: string;
+}
+
+declare type SubscriptionPeriodResolver = (input: SubscriptionPeriodContext) => SubscriptionWindow;
+
+export declare const subscriptionPeriodSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: SubscriptionPeriodResolver;
+    defaultProbe: {
+        run: () => Effect.Effect< SubscriptionWindow, never, never>;
+        expected: SubscriptionWindow;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect< SubscriptionWindow, never, never>;
+        expected: {
+            expiresAt: number;
+            startsAt: number;
+        };
+    };
+}>;
+
+declare type SubscriptionReceiptInput = {
+    readonly kind: 'start';
+    readonly intent: SubscriptionStartInput;
+} | {
+    readonly kind: 'renew' | 'daily' | 'cancel';
+    readonly intent: SubscriptionDailyInput;
+};
+
+declare interface SubscriptionRenewInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly entitlementId: string;
+    readonly requestId: string;
+}
+
+export declare const subscriptionsFakeLayer: Layer.Layer<EconomyPort | SubscriptionsPort, never, never>;
+
+declare class SubscriptionsPort extends SubscriptionsPort_base {
+}
+
+declare const SubscriptionsPort_base: Context.ServiceClass<SubscriptionsPort, "@voltro/SubscriptionsPort", SubscriptionsService>;
+
+/** Actual installed memory-store plugin. Consent is an explicit fixture seam,
+ * not a production default or verified consent acquisition/legal policy. */
+export declare const subscriptionsPortFixture: Effect.Effect<Readonly<{
+    store: InMemoryDataStore;
+    plugin: EconomyPlugin;
+    base: {
+        base: {
+            economy: EconomySqlService;
+            inventory: InventorySqlService;
+            catalog: Readonly<{
+                read: (scope: CatalogScope) => Effect.Effect< CatalogSnapshot, InventoryError>;
+                importSnapshot: (subject: Subject, input: CatalogImport) => Effect.Effect< CatalogSnapshot, InventoryError>;
+            }>;
+            options: ShopStoreOptions;
+            shop: ShopSqlService;
+            user: {
+                readonly type: "user";
+                readonly id: string;
+                readonly tenantId: string;
+                readonly kind?: "guest" | undefined;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "apiKey";
+                readonly id: string;
+                readonly tenantId: string;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "serviceAccount";
+                readonly id: string;
+                readonly tenantId: string;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+                readonly auditActorId?: string | null;
+            } | {
+                readonly type: "anonymous";
+                readonly id: null;
+                readonly tenantId: string | null;
+                readonly credentialRejected?: string | undefined;
+            } | {
+                readonly type: "system";
+                readonly id: string;
+                readonly tenantId: null;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            } | {
+                readonly type: "service";
+                readonly id: string;
+                readonly service: string;
+                readonly tenantId: null;
+                readonly scopes?: readonly string[] | undefined;
+                readonly metadata?: {
+                    readonly [x: string]: unknown;
+                } | undefined;
+            };
+            buy: ShopBuyInput;
+        };
+        options: SubscriptionsStoreOptions;
+        service: SubscriptionsService;
+        setAt: (value: number) => void;
+    };
+    close: Effect.Effect<void, never, never>;
+}>, never, never>;
+
+export declare const subscriptionsPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof SubscriptionsPort;
+    fakeLayer: Layer.Layer<EconomyPort | SubscriptionsPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            same: boolean;
+            daily: "start" | "daily" | "renew";
+            balance: string | undefined;
+        }, EconomyError, never>;
+        expected: {
+            same: boolean;
+            daily: string;
+            balance: string;
+        };
+    };
+}>;
+
+/** Renew is a trusted server intention. Implementations must deny players and
+ * enforce one accepted renewal per entitlement/period independently of nonce.
+ * Calendar/daily strategies alone cannot establish durable idempotency. */
+declare interface SubscriptionsService {
+    readonly list: (subject: Subject) => Effect.Effect<readonly SubscriptionView[], EconomyError>;
+    readonly active: (subject: Subject) => Effect.Effect<readonly SubscriptionActiveView[], EconomyError>;
+    readonly start: (subject: Subject, input: SubscriptionStartInput) => Effect.Effect<SubscriptionValueReceipt, EconomyError>;
+    readonly renew: (subject: Subject, input: SubscriptionRenewInput) => Effect.Effect<SubscriptionValueReceipt, EconomyError>;
+    readonly claimDaily: (subject: Subject, input: SubscriptionDailyInput) => Effect.Effect<SubscriptionValueReceipt, EconomyError>;
+    readonly cancel: (subject: Subject, input: SubscriptionCancelInput) => Effect.Effect<SubscriptionCancellationReceipt, EconomyError>;
+    readonly receipt: (subject: Subject, input: SubscriptionReceiptInput) => Effect.Effect<SubscriptionObservation, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare interface SubscriptionsStoreOptions {
+    readonly subscriptions: readonly (SubscriptionDefinition | Subscription)[];
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly realMoney?: boolean;
+    readonly economy: Pick<EconomySqlService, 'prepareTransfer'>;
+    readonly inventory?: Pick<InventorySqlService, 'prepareGrant'> | undefined;
+    readonly accessSource: SubscriptionAccessSource;
+    readonly version: string;
+    readonly period?: SubscriptionPeriodResolver | undefined;
+    readonly daily?: SubscriptionDailyGrantPolicy | undefined;
+    readonly priceResolver?: PriceResolver | undefined;
+    readonly systemAccount?: string | undefined;
+    readonly maxHistoryRows?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+
+/** Player intentions contain observed identities, never charge amounts, dates,
+ * provider receipts, claimed days, entitlement state or renewal authority. */
+declare interface SubscriptionStartInput {
+    readonly subscriptionId: string;
+    readonly subscriptionVersion: string;
+    readonly subscriptionDigest: string;
+    readonly requestId: string;
+    readonly currency?: string | undefined;
+}
+
+declare interface SubscriptionValueReceipt {
+    readonly operationId: string;
+    readonly entitlementId: string;
+    readonly kind: 'start' | 'renew' | 'daily';
+    readonly at: number;
+    readonly periodIndex: number;
+    readonly day: number | null;
+    readonly window: SubscriptionEntitlement;
+    readonly value: ShopOrderReceipt;
+}
+
+declare interface SubscriptionView {
+    readonly subscription: Subscription;
+    readonly subscriptionDigest: string;
+}
+
+declare interface SubscriptionWindow {
+    readonly startsAt: number;
+    readonly expiresAt: number;
+}
+
+declare interface TradeAcceptInput {
+    readonly tradeId: string;
+    readonly tradeDigest: string;
+    readonly requestId: string;
+}
+
+declare interface TradeAuthorityAdmission {
+    readonly tenantId: string;
+    readonly tradeId: string;
+    readonly phase: 'propose' | 'accept';
+    readonly at: number;
+    readonly expiresAt: number;
+    readonly participants: readonly TradeParticipantAuthority[];
+}
+
+/** Required real trust/sanctions facts plus an exact-store SQL revalidation unit.
+ * Read/prepare execute outside replayable SQL. The unit owns admission fences;
+ * no default permission, trust score or revoked-consent behavior is fabricated. */
+declare interface TradeAuthoritySource {
+    readonly read: (input: {
+        readonly tenantId: string;
+        readonly ownerId: string;
+        readonly tradeId: string;
+        readonly at: number;
+    }) => Effect.Effect<TradeParticipantAuthority, EconomyError>;
+    readonly prepare: (input: TradeAuthorityAdmission) => Effect.Effect<PreparedSqlMutation<void>, EconomyError>;
+}
+
+declare interface TradeCurrencyIntention {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+declare interface TradeEligibilityContext {
+    readonly tenantId: string;
+    readonly proposerId: string;
+    readonly accepterId: string;
+    readonly tradeId: string;
+    readonly proposedToId: string | null;
+    readonly createdAt: number;
+    readonly at: number;
+    readonly expiresAt: number;
+    readonly rules: TradeRules;
+    readonly currencies: readonly CurrencyDefinition[];
+    readonly offered: TradeLeg;
+    readonly requested: TradeLeg;
+    readonly proposer: TradeParticipantAuthority;
+    readonly accepter: TradeParticipantAuthority;
+}
+
+declare type TradeEligibilityPolicy = (input: TradeEligibilityContext) => boolean;
+
+export declare const tradeEligibilitySystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: TradeEligibilityPolicy;
+    defaultProbe: {
+        run: () => Effect.Effect<boolean, never, never>;
+        expected: boolean;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<boolean, never, never>;
+        expected: boolean;
+    };
+}>;
+
+declare interface TradeEscrowExchangeInput extends TradeEscrowTerms {
+    readonly accepterId: string;
+}
+
+declare interface TradeEscrowExchangeReceipt {
+    readonly tradeId: string;
+    readonly offered: TradeEscrowLegReceipt;
+    readonly requested: TradeEscrowLegReceipt;
+}
+
+declare interface TradeEscrowLegReceipt {
+    readonly inventory: InventoryReservationTransferReceipt | null;
+    readonly currencies: readonly {
+        readonly reserve: EconomyReceipt;
+        readonly settlement: WalletEscrowSettlementReceipt;
+    }[];
+}
+
+/** Server composition only. The mandatory exact-store admission belongs to the
+ * durable Trade writer and actual eligibility authority. This does not install
+ * player routes, infer consent/sanctions or replace durable Trade custody. */
+declare interface TradeEscrowParticipant {
+    readonly prepareReserve: (subject: Subject, input: TradeEscrowTerms, admission: PreparedSqlMutation<void>) => Effect.Effect<PreparedSqlMutation<TradeEscrowReserveReceipt>, EconomyError>;
+    readonly prepareRelease: (subject: Subject, input: TradeEscrowTerms, admission: PreparedSqlMutation<void>) => Effect.Effect<PreparedSqlMutation<TradeEscrowReserveReceipt>, EconomyError>;
+    readonly prepareExchange: (subject: Subject, input: TradeEscrowExchangeInput, admission: PreparedSqlMutation<void>) => Effect.Effect<PreparedSqlMutation<TradeEscrowExchangeReceipt>, EconomyError>;
+}
+
+declare interface TradeEscrowReserveReceipt {
+    readonly tradeId: string;
+    readonly inventory: InventoryReceipt | null;
+    readonly currencies: readonly EconomyReceipt[];
+}
+
+declare interface TradeEscrowTerms {
+    readonly tenantId: string;
+    readonly tradeId: string;
+    readonly proposerId: string;
+    readonly offered: TradeLegDefinition;
+    readonly requested: TradeLegDefinition;
+}
+
+declare interface TradeExpiryInput {
+    readonly tenantId: string;
+    readonly maxTrades?: number | undefined;
+}
+
+declare interface TradeExpiryResult {
+    readonly capturedAt: number;
+    readonly scannedRows: number;
+    readonly dueTrades: number;
+    /** Matching original expiry receipts observed by this call, not newly committed closes. */
+    readonly expiredTrades: number;
+    readonly alreadyClosedTrades: number;
+}
+
+export declare const tradeFixture: () => Readonly<{
+    currencies: {
+        id: string;
+        kind: "soft";
+    }[];
+    rules: TradeRules;
+    tenantId: "fixture";
+    tradeId: "trade.a";
+    proposerId: "a";
+    accepterId: "b";
+    proposedToId: "b";
+    createdAt: 0;
+    at: 100;
+    expiresAt: 1000;
+    offered: TradeLeg;
+    requested: TradeLeg;
+    proposer: {
+        tenantId: string;
+        ownerId: string;
+        allowed: boolean;
+        trustScore: number;
+        items: {
+            instanceId: string;
+            itemId: string;
+            qty: number;
+            tradable: boolean;
+            locked: boolean;
+            reservationId: string;
+            expiresAt: number;
+        }[];
+    };
+    accepter: {
+        tenantId: string;
+        ownerId: string;
+        allowed: boolean;
+        trustScore: number;
+        items: never[];
+    };
+}>;
+
+declare interface TradeItemAuthority {
+    readonly instanceId: string;
+    readonly itemId: string;
+    readonly qty: number;
+    readonly tradable: boolean;
+    readonly locked: boolean;
+    readonly reservationId: string | null;
+    readonly expiresAt: number | null;
+}
+
+declare interface TradeItemIntention {
+    readonly instanceId: string;
+    readonly qty: number;
+}
+
+declare interface TradeLeg {
+    readonly items: readonly TradeItemIntention[];
+    readonly currencies: readonly {
+        readonly currency: string;
+        readonly amount: string;
+    }[];
+}
+
+declare interface TradeLegDefinition {
+    readonly items: readonly TradeItemIntention[];
+    readonly currencies: readonly TradeCurrencyIntention[];
+}
+
+declare type TradeObservation = {
+    readonly requestId: string;
+    readonly state: 'not-observed';
+} | {
+    readonly requestId: string;
+    readonly state: 'fulfilled';
+    readonly receipt: TradeReceipt;
+};
+
+declare interface TradeParticipantAuthority {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly allowed: boolean;
+    readonly trustScore: number;
+    readonly items: readonly TradeItemAuthority[];
+}
+
+declare interface TradeProposeInput {
+    readonly toId: string | null;
+    readonly offered: TradeLegDefinition;
+    readonly requested: TradeLegDefinition;
+    readonly durationMs: number;
+    readonly requestId: string;
+}
+
+declare interface TradeReceipt {
+    readonly operationId: string;
+    readonly requestId: string;
+    readonly trade: TradeView;
+}
+
+declare interface TradeRules {
+    readonly version: string;
+    readonly taxBps: number;
+    readonly maxDurationMs: number;
+    readonly minTrustScore: number;
+}
+
+export declare const tradesFakeLayer: Layer.Layer<EconomyPort | TradesPort, never, never>;
+
+declare class TradesPort extends TradesPort_base {
+}
+
+declare const TradesPort_base: Context.ServiceClass<TradesPort, "@voltro/TradesPort", TradesService>;
+
+/** Actual installed SQL writers; allowed/trust remain explicit fixture seams.
+ * This is no production sanctions/consent or scheduler proof. */
+export declare const tradesPortFixture: Effect.Effect<Readonly<{
+    store: InMemoryDataStore;
+    base: {
+        options: {
+            authority: TradeAuthoritySource;
+            inventory: InventorySqlService;
+            now: () => number;
+            currencies: {
+                id: string;
+                kind: "soft";
+                cap: string;
+            }[];
+            rules: {
+                version: string;
+                taxBps: number;
+            };
+            economy: EconomySqlService;
+        };
+        service: TradesSqlService;
+        proposed: {
+            toId: string;
+            offered: {
+                items: {
+                    instanceId: string;
+                    qty: number;
+                }[];
+                currencies: {
+                    currency: string;
+                    amount: string;
+                }[];
+            };
+            requested: {
+                items: {
+                    instanceId: string;
+                    qty: number;
+                }[];
+                currencies: {
+                    currency: string;
+                    amount: string;
+                }[];
+            };
+            durationMs: number;
+            requestId: string;
+        };
+        accept: (receipt: TradeReceipt, requestId?: string) => {
+            tradeId: string;
+            tradeDigest: string;
+            requestId: string;
+        };
+        store: DataStore;
+        item: ItemContract;
+        economy: EconomySqlService;
+        inventory: InventorySqlService;
+        participant: TradeEscrowParticipant;
+        terms: {
+            tenantId: string;
+            tradeId: string;
+            proposerId: string;
+            offered: {
+                items: {
+                    instanceId: string;
+                    qty: number;
+                }[];
+                currencies: {
+                    currency: string;
+                    amount: string;
+                }[];
+            };
+            requested: {
+                items: {
+                    instanceId: string;
+                    qty: number;
+                }[];
+                currencies: {
+                    currency: string;
+                    amount: string;
+                }[];
+            };
+        };
+        user: (id: string) => Subject;
+        a: InventoryInstance;
+        b: InventoryInstance;
+        admission: () => PreparedSqlMutation<void>;
+    };
+    plugin: EconomyPlugin;
+    advance: (milliseconds: number) => void;
+    close: Effect.Effect<void, never, never>;
+}>, never, never>;
+
+export declare const tradesPortSystemFixture: Readonly<{
+    kind: "port";
+    tag: typeof TradesPort;
+    fakeLayer: Layer.Layer<EconomyPort | TradesPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            same: boolean;
+            observed: "fulfilled" | "not-observed";
+            state: "expired" | "cancelled" | "accepted" | "proposed";
+            balance: string;
+            tax: string[];
+        }, EconomyError, never>;
+        expected: {
+            same: boolean;
+            observed: string;
+            state: string;
+            balance: string;
+            tax: string[];
+        };
+    };
+}>;
+
+/** Full owning service; no default implementation or escrow installation is
+ * inferred from a Tag. SQL reservation/transfer/expiry/privacy own acceptance. */
+declare interface TradesService {
+    readonly propose: (subject: Subject, input: TradeProposeInput) => Effect.Effect<TradeReceipt, EconomyError>;
+    readonly accept: (subject: Subject, input: TradeAcceptInput) => Effect.Effect<TradeReceipt, EconomyError>;
+    readonly cancel: (subject: Subject, input: {
+        readonly tradeId: string;
+        readonly requestId: string;
+    }) => Effect.Effect<TradeReceipt, EconomyError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly TradeView[], EconomyError>;
+    readonly receipt: (subject: Subject, input: {
+        readonly requestId: string;
+    }) => Effect.Effect<TradeObservation, EconomyError>;
+    readonly rebuild: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly tradeId: string;
+    }) => Effect.Effect<TradeView, EconomyError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, EconomyError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, EconomyError>;
+}
+
+declare interface TradesSqlService extends TradesService {
+    readonly expireDue: (subject: Subject, input: TradeExpiryInput) => Effect.Effect<TradeExpiryResult, EconomyError>;
+    readonly expire: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly tradeId: string;
+    }) => Effect.Effect<TradeReceipt, EconomyError>;
+}
+
+declare interface TradeTaxContext {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+    readonly rules: TradeRules;
+}
+
+declare type TradeTaxPolicy = (input: TradeTaxContext) => EconomyAmountInput;
+
+export declare const tradeTaxSystemFixture: Readonly<{
+    kind: "slot";
+    defaultImplementation: TradeTaxPolicy;
+    defaultProbe: {
+        run: () => Effect.Effect<Readonly<{
+            currency: string;
+            gross: string;
+            net: string;
+            tax: string;
+        }>, never, never>;
+        expected: {
+            currency: string;
+            gross: string;
+            net: string;
+            tax: string;
+        };
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<Readonly<{
+            currency: string;
+            gross: string;
+            net: string;
+            tax: string;
+        }>, never, never>;
+        expected: {
+            currency: string;
+            gross: string;
+            net: string;
+            tax: string;
+        };
+    };
+}>;
+
+declare interface TradeTaxView {
+    readonly leg: 'offered' | 'requested';
+    readonly currency: string;
+    readonly gross: string;
+    readonly net: string;
+    readonly tax: string;
+}
+
+declare interface TradeView {
+    readonly tradeId: string;
+    readonly tradeDigest: string;
+    readonly proposerId: string;
+    readonly toId: string | null;
+    readonly offered: TradeLeg;
+    readonly requested: TradeLeg;
+    readonly createdAt: number;
+    readonly expiresAt: number;
+    readonly state: 'proposed' | 'accepted' | 'cancelled' | 'expired';
+    readonly accepterId: string | null;
+    readonly rulesVersion: string;
+    readonly taxes: readonly TradeTaxView[];
+}
+
+declare const verifiedCurrentState: unique symbol;
+
+/** Fresh provider observation bound to revalidated original SQL. Never copied player refund authority. */
+declare interface VerifiedIapCurrentState {
+    readonly [verifiedCurrentState]: true;
+    readonly orderId: string;
+}
+
+/** Authenticated notice, never current purchase state or grant/refund authority. */
+declare interface VerifiedIapNotification {
+    readonly [verifiedNotification]: true;
+    readonly noticeId: string;
+    readonly channel: IapRefundChannel;
+}
+
+/** Process-local opaque evidence. A serialized object is never a verification capability. */
+declare interface VerifiedIapPurchase {
+    readonly [verifiedPurchase]: true;
+    readonly scope: IapScope;
+    readonly offerId: string;
+    readonly offerVersion: string;
+    readonly requestId: string;
+    readonly verifiedAt: number;
+    readonly identity: string;
+    readonly facts: IapTransactionFacts;
+}
+
+declare const verifiedNotification: unique symbol;
+
+declare const verifiedPurchase: unique symbol;
+
+declare interface VirtualPriceAdjustment {
+    readonly currency: string;
+    /** Inclusive integer 0..10000. */
+    readonly discountBps: number;
+    /** A trusted floor, enforced independently of a custom resolver. */
+    readonly minimum: EconomyAmountInput;
+}
+
+declare interface VirtualPriceOption {
+    readonly currency: string;
+    readonly amount: EconomyAmountInput;
+}
+
+declare interface WalletEscrowFundedSettlementReceipt {
+    readonly reserve: EconomyReceipt;
+    readonly settlement: WalletEscrowSettlementReceipt;
+}
+
+declare interface WalletEscrowInput {
+    readonly tenantId: string;
+    readonly owner: EscrowWallet;
+    readonly reservationId: string;
+    readonly currency: string;
+}
+
+declare type WalletEscrowObservation = {
+    readonly reservationId: string;
+    readonly currency: string;
+    readonly state: 'not-observed';
+} | {
+    readonly reservationId: string;
+    readonly currency: string;
+    readonly amount: string;
+    readonly state: 'held' | 'released' | 'settled';
+    readonly receipt: EconomyReceipt;
+    readonly closingReceipt: EconomyReceipt | null;
+    readonly taxReceipt: EconomyReceipt | null;
+};
+
+declare interface WalletEscrowParticipant {
+    readonly prepareEscrowReserve: (subject: Subject, input: WalletEscrowReserveInput) => Effect.Effect<PreparedSqlMutation<EconomyReceipt>, EconomyError>;
+    readonly prepareEscrowRelease: (subject: Subject, input: WalletEscrowInput) => Effect.Effect<PreparedSqlMutation<EconomyReceipt>, EconomyError>;
+    /** Whole gross payout; use prepareEscrowTaxSettle for an exact net/sink split. */
+    readonly prepareEscrowSettle: (subject: Subject, input: WalletEscrowSettleInput) => Effect.Effect<PreparedSqlMutation<EconomyReceipt>, EconomyError>;
+    readonly prepareEscrowTaxSettle: (subject: Subject, input: WalletEscrowTaxSettleInput) => Effect.Effect<PreparedSqlMutation<WalletEscrowSettlementReceipt>, EconomyError>;
+    readonly prepareEscrowReserveTaxSettle: (subject: Subject, input: WalletEscrowReserveTaxSettleInput) => Effect.Effect<PreparedSqlMutation<WalletEscrowFundedSettlementReceipt>, EconomyError>;
+    readonly escrow: (subject: Subject, input: WalletEscrowInput) => Effect.Effect<WalletEscrowObservation, EconomyError>;
+}
+
+declare interface WalletEscrowReserveInput extends WalletEscrowInput {
+    readonly amount: EconomyAmountInput;
+}
+
+declare interface WalletEscrowReserveTaxSettleInput extends WalletEscrowReserveInput {
+    readonly to: EscrowWallet;
+    readonly taxAmount: EconomyAmountInput;
+    readonly taxAccountId?: string | undefined;
+}
+
+declare interface WalletEscrowSettleInput extends WalletEscrowInput {
+    readonly to: EscrowWallet;
+}
+
+declare interface WalletEscrowSettlementReceipt {
+    readonly reservationId: string;
+    readonly currency: string;
+    readonly gross: string;
+    readonly net: string;
+    readonly tax: string;
+    readonly payout: EconomyReceipt | null;
+    readonly taxReceipt: EconomyReceipt | null;
+}
+
+declare interface WalletEscrowTaxSettleInput extends WalletEscrowSettleInput {
+    readonly taxAmount: EconomyAmountInput;
+    readonly taxAccountId?: string | undefined;
+}
+
+declare type WalletOwnerKind = 'player' | 'guild';
+
+export { }