@chipmobilesdk/rn-payment 0.6.0 → 0.7.0

package/lib/typescript/module/engine/purchase.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The purchase flow.
+ *
+ * Ordering here is deliberate and load-bearing:
+ *
+ * 1. Refuse early and cheaply — disabled, not ready, already busy, environment
+ *    blocked, unknown product — so nothing reaches the store that should not.
+ * 2. Launch, and map every store outcome onto a typed result (FR-005).
+ * 3. Pending stops here: it is persisted and signalled, but **never granted**
+ *    (FR-037).
+ * 4. Validate with the app's backend, if one is configured, and only for a
+ *    **newly completed** purchase (FR-069a).
+ * 5. Grant the entitlement, then finalize. In that order — the user gets what
+ *    they paid for before the bookkeeping completes, so a finalize failure never
+ *    withholds a paid entitlement. Finalization is still guaranteed, by the
+ *    persisted queue.
+ */
+import type { PaymentConfig, PaymentStatusKind, ProductKey, PurchaseOptions, PurchaseResult } from '../config/types.js';
+import type { ResolvedConfig, TargetPlatform } from '../config/validate.js';
+import type { ProviderPort, ProviderPurchase } from '../adapter/port.js';
+import type { ExclusiveOutcome } from '../core/mutex.js';
+import type { PaymentEventInput } from '../diagnostics/events.js';
+import type { PersistedSnapshot } from '../persistence/snapshot.js';
+import type { Finalizer } from './finalize.js';
+export interface PurchaseFlowDeps {
+    config: PaymentConfig;
+    resolved: ResolvedConfig;
+    provider: ProviderPort;
+    platform: TargetPlatform;
+    finalizer: Finalizer;
+    snapshot: () => PersistedSnapshot;
+    commit: (next: PersistedSnapshot) => void;
+    emit: (event: PaymentEventInput) => void;
+    now: () => number;
+    nextCorrelationId: () => string;
+    statusKind: () => PaymentStatusKind;
+    mayCreateRealTransaction: () => boolean;
+    recordBlockedOperation: (productKey: ProductKey) => void;
+    requestSync: (trigger: 'already_owned') => void;
+    runExclusive: <T>(operation: () => Promise<T>) => Promise<ExclusiveOutcome<T>>;
+}
+export interface InternalPurchaseOptions extends PurchaseOptions {
+    replaceProductKey?: ProductKey;
+    prorationMode?: string;
+}
+export interface PurchaseFlow {
+    purchase(productKey: ProductKey, options?: InternalPurchaseOptions): Promise<PurchaseResult>;
+    /** Handles a store-pushed update, e.g. a pending purchase settling (FR-039). */
+    ingest(purchase: ProviderPurchase): Promise<void>;
+    /**
+     * Re-runs the backend check for transactions granted under the
+     * failure-fallback (FR-072a).
+     *
+     * Called on sync, so recovery happens on the app's own rhythm rather than on a
+     * timer of ours. A rejection here revokes, which is what bounds the exposure
+     * that `grant_and_queue` accepts.
+     */
+    revalidate(): Promise<void>;
+}
+export declare function createPurchaseFlow(deps: PurchaseFlowDeps): PurchaseFlow;
+//# sourceMappingURL=purchase.d.ts.map

package/lib/typescript/module/engine/purchase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"purchase.d.ts","sourceRoot":"","sources":["../../../../src/engine/purchase.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EACX,aAAa,EACb,iBAAiB,EACjB,UAAU,EACV,eAAe,EACf,cAAc,EAEd,MAAM,oBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,uBAAoB,CAAC;AACzE,OAAO,KAAK,EACX,YAAY,EACZ,gBAAgB,EAIhB,MAAM,oBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAe,CAAC;AAItD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAAuB,CAAC;AAC/D,OAAO,KAAK,EAAqB,iBAAiB,EAAE,MAAM,4BAAyB,CAAC;AAEpF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAY,CAAC;AAG5C,MAAM,WAAW,gBAAgB;IAChC,MAAM,EAAE,aAAa,CAAC;IACtB,QAAQ,EAAE,cAAc,CAAC;IACzB,QAAQ,EAAE,YAAY,CAAC;IACvB,QAAQ,EAAE,cAAc,CAAC;IACzB,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,MAAM,iBAAiB,CAAC;IAClC,MAAM,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,CAAC;IAC1C,IAAI,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACzC,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,MAAM,CAAC;IAChC,UAAU,EAAE,MAAM,iBAAiB,CAAC;IACpC,wBAAwB,EAAE,MAAM,OAAO,CAAC;IACxC,sBAAsB,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,CAAC;IACzD,WAAW,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAC;IAChD,YAAY,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;CAC/E;AAMD,MAAM,WAAW,uBAAwB,SAAQ,eAAe;IAC/D,iBAAiB,CAAC,EAAE,UAAU,CAAC;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAC7F,gFAAgF;IAChF,MAAM,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClD;;;;;;;OAOG;IACH,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,GAAG,YAAY,CA0YvE"}

package/lib/typescript/module/engine/purchaseFailure.d.ts

@@ -0,0 +1,15 @@
+/**
+ * What a refused purchase means to the app (PAY-19).
+ *
+ * The store answers with a reason of its own; this turns it into the result the
+ * app sees, under the code it can branch on, so no store vocabulary leaks out.
+ * Split from the flow next door, which is about the sequence of calls.
+ */
+import type { ProviderFailureReason } from '../adapter/port.js';
+import type { PaymentStatusKind, ProductKey, PurchaseResult } from '../config/types.js';
+import type { PaymentErrorCode } from '../diagnostics/errors.js';
+export declare const FAILURE_CODES: Partial<Record<PurchaseResult['kind'], PaymentErrorCode>>;
+/** Maps a provider failure onto the public vocabulary, so no store code leaks out. */
+export declare function mapFailure(reason: ProviderFailureReason, productKey: ProductKey, status: PaymentStatusKind): PurchaseResult;
+/** Plan-change parameters, which only `subscriptions.ts` supplies. */
+//# sourceMappingURL=purchaseFailure.d.ts.map

package/lib/typescript/module/engine/purchaseFailure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"purchaseFailure.d.ts","sourceRoot":"","sources":["../../../../src/engine/purchaseFailure.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAiB,CAAC;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,oBAAiB,CAAC;AACrF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAAuB,CAAC;AAE9D,eAAO,MAAM,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC,CAKnF,CAAC;AAEF,sFAAsF;AACtF,wBAAgB,UAAU,CACzB,MAAM,EAAE,qBAAqB,EAC7B,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,iBAAiB,GACvB,cAAc,CAsBhB;AAED,sEAAsE"}

package/lib/typescript/module/engine/receiptValidation.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Asking the app's backend whether a purchase is real (FR-069a, FR-072b).
+ *
+ * The hook is optional and bounded by a timeout, and its answer decides whether
+ * an entitlement is granted — so what happens when it throws, times out, or is
+ * absent is the whole point of this module. Split from the flow next door,
+ * which is about the sequence of store calls.
+ *
+ * A hook that could not answer is never an implicit approval: the configured
+ * `onValidationUnavailable` decides, and the default refuses.
+ */
+import type { ProviderPurchase } from '../adapter/port.js';
+import type { PaymentConfig, ProductKey } from '../config/types.js';
+import type { ResolvedConfig, TargetPlatform } from '../config/validate.js';
+import type { PaymentEventInput } from '../diagnostics/events.js';
+export interface ReceiptValidationDeps {
+    config: PaymentConfig;
+    platform: TargetPlatform;
+    resolved: ResolvedConfig;
+    emit: (event: PaymentEventInput) => void;
+}
+/** What the backend decided about one purchase. */
+export type ValidationOutcome = {
+    outcome: 'approved';
+} | {
+    outcome: 'rejected';
+    reason?: string;
+} | {
+    outcome: 'granted_pending_revalidation';
+};
+export declare function createReceiptValidation(deps: ReceiptValidationDeps): {
+    askHook: (hook: NonNullable<PaymentConfig["validateTransaction"]>, candidate: Parameters<NonNullable<PaymentConfig["validateTransaction"]>>[0]) => Promise<import("../index.js").ValidationDecision>;
+    validate: (purchase: ProviderPurchase, productKey: ProductKey, correlationId: string) => Promise<{
+        outcome: "approved";
+    } | {
+        outcome: "rejected";
+        reason?: string;
+    } | {
+        outcome: "granted_pending_revalidation";
+    }>;
+};
+//# sourceMappingURL=receiptValidation.d.ts.map

package/lib/typescript/module/engine/receiptValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"receiptValidation.d.ts","sourceRoot":"","sources":["../../../../src/engine/receiptValidation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,oBAAiB,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,uBAAoB,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAAuB,CAAC;AAI/D,MAAM,WAAW,qBAAqB;IACrC,MAAM,EAAE,aAAa,CAAC;IACtB,QAAQ,EAAE,cAAc,CAAC;IACzB,QAAQ,EAAE,cAAc,CAAC;IACzB,IAAI,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;CACzC;AAED,mDAAmD;AACnD,MAAM,MAAM,iBAAiB,GAC1B;IAAE,OAAO,EAAE,UAAU,CAAA;CAAE,GACvB;IAAE,OAAO,EAAE,UAAU,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,OAAO,EAAE,8BAA8B,CAAA;CAAE,CAAC;AAE/C,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,qBAAqB;oBAI3D,WAAW,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC,aAC5C,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;yBAsBjE,gBAAgB,cACd,UAAU,iBACP,MAAM,KACnB,OAAO,CACP;QAAE,OAAO,EAAE,UAAU,CAAA;KAAE,GACvB;QAAE,OAAO,EAAE,UAAU,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GACxC;QAAE,OAAO,EAAE,8BAA8B,CAAA;KAAE,CAC7C;EAmCD"}

package/lib/typescript/module/engine/state.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The engine's state and the one way it changes (PAY-10).
+ *
+ * Status, the persisted snapshot, entitlements and pending purchases live here
+ * with the listeners that hear about them. Every change goes through `commit`
+ * (the snapshot) or `setStatus`, so diffing and emission are written once:
+ * an entitlement is granted or revoked exactly once however many sources it has
+ * (FR-079), a renewal that changes nothing emits nothing (FR-068), and an
+ * unchanged map is the same object (PERF-03).
+ */
+import { type ListenerSet } from '@chipmobilesdk/rn-core';
+import type { ProviderPort } from '../adapter/port.js';
+import type { ResolvedConfig } from '../config/validate.js';
+import type { PaymentConfig, PaymentStatus, PendingPurchasesState } from '../config/types.js';
+import { type PaymentEmitter, type PaymentEventInput } from '../diagnostics/events.js';
+import { type EntitlementMap } from '../entitlements/aggregate.js';
+import type { SnapshotStore } from '../persistence/mmkv-store.js';
+import { type PersistedSnapshot } from '../persistence/snapshot.js';
+export interface EngineState {
+    readonly config: PaymentConfig;
+    readonly resolved: ResolvedConfig;
+    readonly provider: ProviderPort;
+    readonly store: SnapshotStore;
+    readonly now: () => number;
+    readonly emitter: PaymentEmitter;
+    readonly statusListeners: ListenerSet<[PaymentStatus]>;
+    readonly entitlementListeners: ListenerSet<[EntitlementMap]>;
+    readonly pendingListeners: ListenerSet<[PendingPurchasesState]>;
+    disposed: boolean;
+    /** Whether the snapshot comes from a sync that succeeded; until then entitlements are `unknown`. */
+    hasSynced: boolean;
+    snapshot: PersistedSnapshot;
+    entitlements: EntitlementMap;
+    status: PaymentStatus;
+    pending: PendingPurchasesState;
+    emit(event: PaymentEventInput): void;
+    setStatus(next: Partial<PaymentStatus>): void;
+    /** Writes the snapshot, reports pending purchases that ended, and recomputes. */
+    commit(next: PersistedSnapshot): void;
+    /** Loads the persisted snapshot at startup (FR-053). */
+    hydrate(): void;
+    /** Forgets everything local, back to `unknown` (FR-057). */
+    forget(): void;
+}
+export declare function createEngineState(config: PaymentConfig, resolved: ResolvedConfig, provider: ProviderPort, store: SnapshotStore, now: () => number): EngineState;
+//# sourceMappingURL=state.d.ts.map

package/lib/typescript/module/engine/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../src/engine/state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE7E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,oBAAiB,CAAC;AAE3F,OAAO,EAEN,KAAK,cAAc,EAEnB,KAAK,iBAAiB,EACtB,MAAM,0BAAuB,CAAC;AAC/B,OAAO,EAKN,KAAK,cAAc,EACnB,MAAM,8BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA2B,CAAC;AAC/D,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,4BAAyB,CAAC;AAKhF,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,GAAG,EAAE,MAAM,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,QAAQ,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC;IACvD,QAAQ,CAAC,oBAAoB,EAAE,WAAW,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC;IAC7D,QAAQ,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC;IAEhE,QAAQ,EAAE,OAAO,CAAC;IAClB,oGAAoG;IACpG,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,YAAY,EAAE,cAAc,CAAC;IAC7B,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,EAAE,qBAAqB,CAAC;IAE/B,IAAI,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACrC,SAAS,CAAC,IAAI,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC;IAC9C,iFAAiF;IACjF,MAAM,CAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACtC,wDAAwD;IACxD,OAAO,IAAI,IAAI,CAAC;IAChB,4DAA4D;IAC5D,MAAM,IAAI,IAAI,CAAC;CACf;AAED,wBAAgB,iBAAiB,CAChC,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,cAAc,EACxB,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,MAAM,MAAM,GACf,WAAW,CAsLb"}

package/lib/typescript/module/engine/subscriptions.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Subscription plan changes and the route to the store's management screen (US12).
+ *
+ * Two platform rules drive this module:
+ *
+ * - **Proration is the app's decision, inside what the store permits** (FR-065).
+ *   Whether a user who upgrades gets charged immediately, keeps their remaining
+ *   time, or starts a fresh period is a product and pricing choice, so the
+ *   package forwards it rather than picking.
+ * - **Cancellation belongs to the store.** Platforms forbid an app presenting its
+ *   own cancellation screen, so this module offers only a route to the store's
+ *   (FR-066) — there is deliberately no self-built alternative anywhere in the
+ *   package.
+ */
+import type { ProductKey, PurchaseOptions, PurchaseResult } from '../config/types.js';
+import type { ResolvedConfig } from '../config/validate.js';
+import type { ProviderPort } from '../adapter/port.js';
+import type { PersistedSnapshot } from '../persistence/snapshot.js';
+/**
+ * How already-paid time is handled when a plan changes.
+ *
+ * Named for the user-visible effect rather than mirroring a store's enum, so the
+ * same vocabulary will map onto StoreKit later (FR-004).
+ */
+export type ProrationMode = 
+/** Switch now; credit unused time against the new plan. The usual upgrade. */
+'immediate_with_time_proration'
+/** Switch now; charge the full new price immediately and restart the period. */
+ | 'immediate_and_charge_full_price'
+/** Switch now; charge the prorated difference for the current period. */
+ | 'immediate_and_charge_prorated_price'
+/** Keep the current plan until it expires, then start the new one. Usual downgrade. */
+ | 'deferred';
+export type PriceChangeResult = {
+    kind: 'confirmed';
+} | {
+    kind: 'dismissed';
+}
+/** The platform has no client-side flow; it notifies the user itself (FR-067). */
+ | {
+    kind: 'unsupported';
+} | {
+    kind: 'failed';
+    code: string;
+};
+export interface SubscriptionsDeps {
+    resolved: ResolvedConfig;
+    provider: ProviderPort;
+    snapshot: () => PersistedSnapshot;
+    purchase: (productKey: ProductKey, options?: PurchaseOptions & {
+        replaceProductKey?: ProductKey;
+        prorationMode?: string;
+    }) => Promise<PurchaseResult>;
+}
+export interface Subscriptions {
+    changePlan(fromProductKey: ProductKey, toProductKey: ProductKey, mode: ProrationMode, options?: PurchaseOptions): Promise<PurchaseResult>;
+    openManagement(productKey?: ProductKey): Promise<void>;
+    confirmPriceChange(productKey: ProductKey): Promise<PriceChangeResult>;
+}
+export declare function createSubscriptions(deps: SubscriptionsDeps): Subscriptions;
+//# sourceMappingURL=subscriptions.d.ts.map

package/lib/typescript/module/engine/subscriptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions.d.ts","sourceRoot":"","sources":["../../../../src/engine/subscriptions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,oBAAiB,CAAC;AACnF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAiB,CAAC;AAEpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAAyB,CAAC;AAEjE;;;;;GAKG;AACH,MAAM,MAAM,aAAa;AACxB,8EAA8E;AAC5E,+BAA+B;AACjC,gFAAgF;GAC9E,iCAAiC;AACnC,yEAAyE;GACvE,qCAAqC;AACvC,uFAAuF;GACrF,UAAU,CAAC;AAUd,MAAM,MAAM,iBAAiB,GAC1B;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GACrB;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE;AACvB,kFAAkF;GAChF;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpC,MAAM,WAAW,iBAAiB;IACjC,QAAQ,EAAE,cAAc,CAAC;IACzB,QAAQ,EAAE,YAAY,CAAC;IACvB,QAAQ,EAAE,MAAM,iBAAiB,CAAC;IAClC,QAAQ,EAAE,CACT,UAAU,EAAE,UAAU,EACtB,OAAO,CAAC,EAAE,eAAe,GAAG;QAAE,iBAAiB,CAAC,EAAE,UAAU,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,KAClF,OAAO,CAAC,cAAc,CAAC,CAAC;CAC7B;AAED,MAAM,WAAW,aAAa;IAC7B,UAAU,CACT,cAAc,EAAE,UAAU,EAC1B,YAAY,EAAE,UAAU,EACxB,IAAI,EAAE,aAAa,EACnB,OAAO,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAAC;IAC3B,cAAc,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,kBAAkB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;CACvE;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,aAAa,CAwE1E"}

package/lib/typescript/module/engine/sync.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Syncing with the store, and the one translation from a store purchase to a
+ * persisted record (PAY-10).
+ *
+ * The purchase flow and sync both build records here, so they cannot disagree
+ * about what a transaction still owes: a disagreement is how a paid purchase
+ * goes unacknowledged and is refunded three days later.
+ */
+import type { ProviderPurchase } from '../adapter/port.js';
+import type { ProductKey } from '../config/types.js';
+import type { ResolvedConfig } from '../config/validate.js';
+import { PaymentError } from '../diagnostics/errors.js';
+import type { SyncTrigger } from '../diagnostics/events.js';
+import { type PersistedPurchase } from '../persistence/snapshot.js';
+import type { EngineState } from './state.js';
+export type SyncOutcome = {
+    ok: true;
+    restoredCount: number;
+    revokedCount: number;
+} | {
+    ok: false;
+    error: PaymentError;
+};
+/** The persisted record for one store purchase, keeping what we already knew about it. */
+export declare function toPersistedRecord(resolved: ResolvedConfig, purchase: ProviderPurchase, productKey: ProductKey, existing: PersistedPurchase | undefined): PersistedPurchase;
+export interface Sync {
+    sync(trigger?: SyncTrigger): Promise<SyncOutcome>;
+}
+/**
+ * `settle` runs after every successful sync, outside the sync flight: the finalize
+ * drain and backend revalidation (FR-039, FR-042, FR-072a). Inside the flight, one
+ * store call or hook that never answered held it, and every later sync joined
+ * that stuck promise for the rest of the session.
+ */
+export declare function createSync(state: EngineState, settle: () => Promise<void>): Sync;
+//# sourceMappingURL=sync.d.ts.map

package/lib/typescript/module/engine/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../../../src/engine/sync.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAoB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAAuB,CAAC;AAGzD,OAAO,EAAwB,KAAK,iBAAiB,EAAE,MAAM,4BAAyB,CAAC;AACvF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAS,CAAC;AAE3C,MAAM,MAAM,WAAW,GACtB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,YAAY,CAAA;CAAE,CAAC;AAEhG,0FAA0F;AAC1F,wBAAgB,iBAAiB,CAChC,QAAQ,EAAE,cAAc,EACxB,QAAQ,EAAE,gBAAgB,EAC1B,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,iBAAiB,GAAG,SAAS,GACrC,iBAAiB,CAgBnB;AAkCD,MAAM,WAAW,IAAI;IACpB,IAAI,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CAClD;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAyEhF"}

package/lib/typescript/module/entitlements/aggregate.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Entitlement aggregation — the package's primary output.
+ *
+ * Everything else exists to make this one answer correct. The most damaging
+ * defect class in a payment SDK lives here: collapsing "not yet synced" into "not
+ * entitled" makes a paying user watch ads flash on cold start or see a purchased
+ * feature sit locked.
+ *
+ * Two rules do most of the work:
+ *
+ * - **A pending purchase is never a source** (FR-037). Enforced here, in
+ *   aggregation, rather than at each call site, so no future code path can grant
+ *   on money that has not arrived.
+ * - **Uncertainty resolves to `unknown`, never `not_entitled`** (FR-047,
+ *   FR-055a). Never synced, stale, or scope-changed all mean "we do not know",
+ *   and the package says so rather than asserting the user did not pay.
+ */
+import type { ResolvedConfig } from '../config/validate.js';
+import type { EntitlementKey, ProductKey } from '../config/types.js';
+import type { PersistedSnapshot } from '../persistence/snapshot.js';
+import { type RenewalState } from './policy.js';
+export type EntitlementStatus = 'unknown' | 'entitled' | 'not_entitled';
+export interface SubscriptionDetail {
+    expiresAt?: number;
+    willAutoRenew: boolean;
+    isCancelledButValid: boolean;
+    renewalState: RenewalState;
+}
+export interface EntitlementState {
+    key: EntitlementKey;
+    status: EntitlementStatus;
+    /** The app's own product keys currently granting this. Never raw transactions (FR-051). */
+    sources: ProductKey[];
+    subscription?: SubscriptionDetail;
+    lastSyncedAt?: number;
+    /** True once the snapshot is older than `staleAfterMs`; status is then `unknown`. */
+    isStale: boolean;
+}
+export type EntitlementMap = Record<EntitlementKey, EntitlementState>;
+export interface AggregateInput {
+    config: ResolvedConfig;
+    snapshot: PersistedSnapshot;
+    /** False until the first successful sync of this session or a hydrated one. */
+    hasSynced: boolean;
+    reportsGraceAndHoldDistinctly: boolean;
+    now: number;
+}
+/**
+ * Computes the full entitlement map.
+ *
+ * Pure and synchronous by design: it runs on render paths, so it must never
+ * touch I/O (PERF-001). The engine calls it after any state change and caches the
+ * result.
+ */
+/**
+ * How far the snapshot can be trusted right now.
+ *
+ * Shared by entitlements and the pending set (FR-103) so the two can never
+ * disagree about whether the package knows anything — a paywall that showed
+ * "not entitled" next to "nothing pending" from one stale snapshot would offer
+ * Buy to a user whose payment is in flight.
+ */
+export declare function snapshotCertainty(input: {
+    config: Pick<ResolvedConfig, 'staleAfterMs'>;
+    snapshot: Pick<PersistedSnapshot, 'lastSyncedAt'>;
+    hasSynced: boolean;
+    now: number;
+}): {
+    isStale: boolean;
+    undetermined: boolean;
+};
+export declare function aggregate(input: AggregateInput): EntitlementMap;
+/** The initial map, before anything is known. Every key starts at `unknown` (FR-047). */
+export declare function initialEntitlements(config: ResolvedConfig): EntitlementMap;
+export interface EntitlementChange {
+    key: EntitlementKey;
+    previous: EntitlementStatus;
+    next: EntitlementStatus;
+    sources: ProductKey[];
+}
+/**
+ * Diffs two maps to produce change signals.
+ *
+ * Emitting from a diff rather than from grant call sites is what makes the
+ * exactly-once guarantees structural (FR-079): a successful subscription renewal
+ * changes no status, so it produces no event and cannot double-signal (FR-068);
+ * and an entitlement with three sources fires once on transition, not once per
+ * source.
+ */
+export declare function diffEntitlements(previous: EntitlementMap, next: EntitlementMap): EntitlementChange[];
+/**
+ * `next`, with every entitlement that did not change replaced by the object it
+ * replaces, and `previous` itself when nothing changed (PERF-03, PAY-08). A hook
+ * selecting one entitlement then sees the same object and does not re-render.
+ */
+export declare function shareUnchanged(previous: EntitlementMap, next: EntitlementMap): EntitlementMap;
+//# sourceMappingURL=aggregate.d.ts.map

package/lib/typescript/module/entitlements/aggregate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../../../src/entitlements/aggregate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,oBAAiB,CAAC;AAClE,OAAO,KAAK,EAAqB,iBAAiB,EAAE,MAAM,4BAAyB,CAAC;AAEpF,OAAO,EAAqD,KAAK,YAAY,EAAE,MAAM,aAAU,CAAC;AAEhG,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,UAAU,GAAG,cAAc,CAAC;AAExE,MAAM,WAAW,kBAAkB;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,OAAO,CAAC;IACvB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,YAAY,EAAE,YAAY,CAAC;CAC3B;AAED,MAAM,WAAW,gBAAgB;IAChC,GAAG,EAAE,cAAc,CAAC;IACpB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,2FAA2F;IAC3F,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qFAAqF;IACrF,OAAO,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;AAEtE,MAAM,WAAW,cAAc;IAC9B,MAAM,EAAE,cAAc,CAAC;IACvB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,+EAA+E;IAC/E,SAAS,EAAE,OAAO,CAAC;IACnB,6BAA6B,EAAE,OAAO,CAAC;IACvC,GAAG,EAAE,MAAM,CAAC;CACZ;AAkED;;;;;;GAMG;AACH;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IACxC,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC;IAC7C,QAAQ,EAAE,IAAI,CAAC,iBAAiB,EAAE,cAAc,CAAC,CAAC;IAClD,SAAS,EAAE,OAAO,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;CACZ,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAAE,CAS9C;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc,CAuB/D;AAED,yFAAyF;AACzF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,GAAG,cAAc,CAY1E;AAED,MAAM,WAAW,iBAAiB;IACjC,GAAG,EAAE,cAAc,CAAC;IACpB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,IAAI,EAAE,iBAAiB,CAAC;IACxB,OAAO,EAAE,UAAU,EAAE,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC/B,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,cAAc,GAClB,iBAAiB,EAAE,CAerB;AAaD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,cAAc,EAAE,IAAI,EAAE,cAAc,GAAG,cAAc,CAe7F"}

package/lib/typescript/module/entitlements/mapping.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Product ↔ entitlement indexing.
+ *
+ * The relation is many-to-many (FR-010): monthly, yearly, and lifetime products
+ * may all grant `no_ads`, and one bundle product may grant several entitlements.
+ *
+ * Both directions are indexed once at configure time. The reverse direction is
+ * what makes two requirements cheap on hot paths: naming which product currently
+ * grants an entitlement (FR-051), and keeping an entitlement valid while *any*
+ * source remains (FR-052).
+ */
+import type { ResolvedConfig } from '../config/validate.js';
+import type { EntitlementKey, ProductKey } from '../config/types.js';
+/** Entitlements a product confers. Empty for an unknown key rather than throwing. */
+export declare function entitlementsFor(config: ResolvedConfig, productKey: ProductKey): readonly EntitlementKey[];
+/**
+ * Translates a store product id back to the app's own product key.
+ *
+ * Needed because store callbacks and `queryOwned` speak in store ids, while
+ * everything above the adapter speaks in product keys (FR-003). Returns
+ * `undefined` for an id absent from the catalog — which happens legitimately when
+ * a user owns something from a build whose catalog has since changed, so it must
+ * be handled rather than treated as impossible.
+ */
+export declare function productKeyForStoreId(config: ResolvedConfig, storeProductId: string): ProductKey | undefined;
+export declare function storeIdForProductKey(config: ResolvedConfig, productKey: ProductKey): string | undefined;
+//# sourceMappingURL=mapping.d.ts.map

package/lib/typescript/module/entitlements/mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../../../../src/entitlements/mapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,oBAAiB,CAAC;AAElE,qFAAqF;AACrF,wBAAgB,eAAe,CAC9B,MAAM,EAAE,cAAc,EACtB,UAAU,EAAE,UAAU,GACpB,SAAS,cAAc,EAAE,CAE3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,cAAc,EACtB,cAAc,EAAE,MAAM,GACpB,UAAU,GAAG,SAAS,CAExB;AAED,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,cAAc,EACtB,UAAU,EAAE,UAAU,GACpB,MAAM,GAAG,SAAS,CAEpB"}

package/lib/typescript/module/entitlements/policy.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Grace and hold entitlement policy.
+ *
+ * This is a **business decision, not a technical constant** (FR-049), so it is
+ * configurable with documented defaults.
+ *
+ * ## The defaults, and why
+ *
+ * `gracePolicy: 'grant'` — a grace period means the store is still retrying a
+ * payment method that failed for reasons usually outside the user's control: an
+ * expired card, a bank decline, a temporary hold. Revoking immediately punishes a
+ * paying customer for a billing hiccup they may not know about yet.
+ *
+ * `holdPolicy: 'withhold'` — account hold means the store has given up retrying.
+ * The subscription is effectively unpaid, and continuing to serve paid features
+ * indefinitely is giving away the product.
+ *
+ * ## What Android can actually tell us
+ *
+ * Client-side Play Billing **cannot** separate grace from hold: a grace-period
+ * subscription is still returned as active, and one in account hold stops being
+ * returned at all — indistinguishable from expired, cancelled, or refunded.
+ *
+ * Fortunately the platform's own behavior matches the defaults above. Play keeps
+ * returning a grace-period purchase, so the entitlement holds. Play stops
+ * returning a held one, so it lapses at the next sync. **The default policy is
+ * therefore correct with no backend at all.**
+ *
+ * What is *not* achievable client-side is a non-default policy — withholding
+ * during grace, or granting during hold — because that needs the state the client
+ * cannot see. Such an app supplies it through the validation hook (FR-069). This
+ * limitation is documented rather than papered over (FR-058).
+ */
+import type { LapsePolicy } from '../config/types.js';
+/**
+ * A subscription's renewal state as far as the package can honestly tell.
+ *
+ * `indeterminate` is not a failure — it is the truthful answer when the platform
+ * reports a subscription as active but cannot say whether that is a healthy
+ * renewal, a cancelled-but-still-paid period, or a grace period.
+ */
+export type RenewalState = 'active' | 'cancelled_valid' | 'grace' | 'hold' | 'indeterminate';
+export interface LapsePolicyConfig {
+    gracePolicy: LapsePolicy;
+    holdPolicy: LapsePolicy;
+}
+export interface SubscriptionFacts {
+    expiresAt?: number;
+    willAutoRenew?: boolean;
+    /** True only where the provider genuinely distinguishes grace/hold. */
+    reportsGraceAndHoldDistinctly: boolean;
+    /** Provider-reported, only meaningful when the flag above is true. */
+    providerRenewalState?: 'active' | 'grace' | 'hold';
+}
+/**
+ * Derives the renewal state without inventing information.
+ *
+ * The temptation is to read `willAutoRenew === false` as "grace period", but that
+ * same value is what a deliberate cancellation looks like. Guessing would mean
+ * showing "there's a problem with your payment method" to someone who simply
+ * chose not to renew — so when the provider cannot distinguish, neither do we.
+ */
+export declare function deriveRenewalState(facts: SubscriptionFacts): RenewalState;
+/**
+ * Whether a subscription in this state should confer its entitlement.
+ *
+ * `hold` reaching this function at all requires a provider that reports it,
+ * which Android does not. On Android a held subscription simply stops being
+ * returned, so it never becomes a source and the entitlement lapses — the same
+ * result the `withhold` default expresses.
+ */
+export declare function grantsUnderPolicy(state: RenewalState, policy: LapsePolicyConfig): boolean;
+/** True once a subscription's paid period has genuinely elapsed (FR-048). */
+export declare function hasExpired(expiresAt: number | undefined, now: number): boolean;
+//# sourceMappingURL=policy.d.ts.map

package/lib/typescript/module/entitlements/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../../../src/entitlements/policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAiB,CAAC;AAEnD;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,iBAAiB,GAAG,OAAO,GAAG,MAAM,GAAG,eAAe,CAAC;AAE7F,MAAM,WAAW,iBAAiB;IACjC,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,WAAW,CAAC;CACxB;AAED,MAAM,WAAW,iBAAiB;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,uEAAuE;IACvE,6BAA6B,EAAE,OAAO,CAAC;IACvC,sEAAsE;IACtE,oBAAoB,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;CACnD;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,CAwBzE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAczF;AAED,6EAA6E;AAC7E,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAE9E"}

package/lib/typescript/module/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `@chipmobilesdk/rn-payment` — reusable in-app payment and entitlement
+ * capability for ChipMobileSdk-family React Native apps.
+ *
+ * This is the public entrypoint (LIB-003). Modules under `config/`, `core/`,
+ * `engine/`, `entitlements/`, `persistence/`, `adapter/`, `diagnostics/`, and
+ * `react/` are private; import them only through this file. The fake store lives
+ * behind `@chipmobilesdk/rn-payment/testing` so test doubles cannot reach a
+ * production bundle.
+ *
+ * Nothing exported here names Google, Play Billing, or `react-native-iap`
+ * (FR-002). `src/__tests__/public-api.test.ts` asserts that mechanically.
+ *
+ * The package owns **capability**: a safe, consistent way to sell, finalize,
+ * restore, and report entitlements. The consuming app owns **policy** — what is
+ * sold, at what price, on which screen, at which moment, what each entitlement
+ * unlocks, and how generous the grace policy is. There is no product identifier,
+ * no screen name, and no business rule in this package (FR-016).
+ *
+ * The one output that matters most is the **entitlement key**: an app-chosen key
+ * such as `no_ads`. Business logic asks about entitlement keys and never about
+ * store product identifiers, product types, or which store sold the thing.
+ */
+export type { BackoffConfig, BlockedOperation, CatalogEntry, EntitlementKey, Environment, FinalizeResult, LapsePolicy, LoggerAdapter, PaymentConfig, PaymentStatus, PaymentStatusKind, PendingPurchase, PendingPurchasesState, PendingResolution, ProductKey, ProductType, PurchaseOptions, PurchaseResult, RetryConfig, StoreProductIds, TimeoutConfig, TransactionRef, UnavailableReason, UnfinalizedSummary, Unsubscribe, ValidationCandidate, ValidationDecision, ValidationHook, ValidationUnavailablePolicy, } from './config/types.js';
+export { BACKOFF_ATTEMPT_BOUNDS, BACKOFF_MAX_DELAY_BOUNDS, CONNECT_TIMEOUT_BOUNDS, DEFAULT_CONNECT_TIMEOUT_MS, DEFAULT_FINALIZE_ATTEMPT_TIMEOUT_MS, DEFAULT_FINALIZE_BACKOFF, DEFAULT_FOREGROUND_SYNC_MIN_INTERVAL_MS, DEFAULT_PRODUCT_CACHE_TTL_MS, DEFAULT_PRODUCT_QUERY_TIMEOUT_MS, DEFAULT_PURCHASE_LAUNCH_TIMEOUT_MS, DEFAULT_RECONNECT_BACKOFF, DEFAULT_STALE_AFTER_MS, DEFAULT_SYNC_TIMEOUT_MS, FINALIZE_ATTEMPT_TIMEOUT_BOUNDS, FOREGROUND_SYNC_MIN_INTERVAL_BOUNDS, PRODUCT_CACHE_TTL_BOUNDS, PRODUCT_QUERY_TIMEOUT_BOUNDS, PURCHASE_LAUNCH_TIMEOUT_BOUNDS, STALE_AFTER_BOUNDS, SYNC_TIMEOUT_BOUNDS, } from './core/timers.js';
+export type { MissingProduct, MissingProductReason, Offer, ProductInfo, ProductQueryResult, } from './engine/products.js';
+export type { PriceChangeResult, ProrationMode } from './engine/subscriptions.js';
+export type { EntitlementMap, EntitlementState, EntitlementStatus, SubscriptionDetail, } from './entitlements/aggregate.js';
+export type { RenewalState } from './entitlements/policy.js';
+export { createStoreProvider } from './adapter/createStoreProvider.js';
+export type { StoreProviderOptions } from './adapter/createStoreProvider.js';
+export { createEngine } from './engine/engine.js';
+export type { EngineDeps, InitOutcome, PaymentEngine, RestoreOutcome, SyncOutcome, } from './engine/engine.js';
+export { syncOnForeground } from './engine/foreground.js';
+export { PaymentProvider, usePaymentEngine } from './react/PaymentProvider.js';
+export type { PaymentProviderProps } from './react/PaymentProvider.js';
+export { useEntitlement, useEntitlements, usePaymentStatus, usePendingPurchases, useProducts, usePurchase, useSync, } from './react/hooks.js';
+export type { UseProductsResult, UsePurchaseResult, UseSyncResult } from './react/hooks.js';
+export { PaymentConfigError, PaymentError, PAYMENT_ERROR_CODES } from './diagnostics/errors.js';
+export type { PaymentErrorCode, PaymentOperation } from './diagnostics/errors.js';
+export type { PaymentEvent, PaymentEventListener, PaymentEventType, SyncTrigger, } from './diagnostics/events.js';
+export { DEFAULT_DEVELOPER_MESSAGES, DEFAULT_MESSAGES, paymentMessages, DEFAULT_USER_MESSAGES, DEVELOPER_MESSAGE_KEYS, USER_MESSAGE_KEYS, isUserMessageKey, } from './diagnostics/messageKeys.js';
+export type { PaymentDeveloperMessageKey, PaymentDeveloperMessageMap, PaymentMessageKey, PaymentMessageMap, PaymentUserMessageKey, PaymentUserMessageMap, } from './diagnostics/messageKeys.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,YAAY,EACX,aAAa,EACb,gBAAgB,EAChB,YAAY,EACZ,cAAc,EACd,WAAW,EACX,cAAc,EACd,WAAW,EACX,aAAa,EACb,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,qBAAqB,EACrB,iBAAiB,EACjB,UAAU,EACV,WAAW,EACX,eAAe,EACf,cAAc,EACd,WAAW,EACX,eAAe,EACf,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,WAAW,EACX,mBAAmB,EACnB,kBAAkB,EAClB,cAAc,EACd,2BAA2B,GAC3B,MAAM,mBAAgB,CAAC;AAKxB,OAAO,EACN,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,EACtB,0BAA0B,EAC1B,mCAAmC,EACnC,wBAAwB,EACxB,uCAAuC,EACvC,4BAA4B,EAC5B,gCAAgC,EAChC,kCAAkC,EAClC,yBAAyB,EACzB,sBAAsB,EACtB,uBAAuB,EACvB,+BAA+B,EAC/B,mCAAmC,EACnC,wBAAwB,EACxB,4BAA4B,EAC5B,8BAA8B,EAC9B,kBAAkB,EAClB,mBAAmB,GACnB,MAAM,kBAAe,CAAC;AAGvB,YAAY,EACX,cAAc,EACd,oBAAoB,EACpB,KAAK,EACL,WAAW,EACX,kBAAkB,GAClB,MAAM,sBAAmB,CAAC;AAG3B,YAAY,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,2BAAwB,CAAC;AAG/E,YAAY,EACX,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,GAClB,MAAM,6BAA0B,CAAC;AAClC,YAAY,EAAE,YAAY,EAAE,MAAM,0BAAuB,CAAC;AAO1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAA+B,CAAC;AACpE,YAAY,EAAE,oBAAoB,EAAE,MAAM,kCAA+B,CAAC;AAG1E,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAiB,CAAC;AAC/C,YAAY,EACX,UAAU,EACV,WAAW,EACX,aAAa,EACb,cAAc,EACd,WAAW,GACX,MAAM,oBAAiB,CAAC;AAEzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAqB,CAAC;AAGvD,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,4BAAyB,CAAC;AAC5E,YAAY,EAAE,oBAAoB,EAAE,MAAM,4BAAyB,CAAC;AACpE,OAAO,EACN,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,OAAO,GACP,MAAM,kBAAe,CAAC;AACvB,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,kBAAe,CAAC;AAGzF,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,yBAAsB,CAAC;AAC7F,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,yBAAsB,CAAC;AAC/E,YAAY,EACX,YAAY,EACZ,oBAAoB,EACpB,gBAAgB,EAChB,WAAW,GACX,MAAM,yBAAsB,CAAC;AAK9B,OAAO,EACN,0BAA0B,EAC1B,gBAAgB,EAChB,eAAe,EACf,qBAAqB,EACrB,sBAAsB,EACtB,iBAAiB,EACjB,gBAAgB,GAChB,MAAM,8BAA2B,CAAC;AACnC,YAAY,EACX,0BAA0B,EAC1B,0BAA0B,EAC1B,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,GACrB,MAAM,8BAA2B,CAAC"}

package/lib/typescript/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/module/persistence/mmkv-store.d.ts

@@ -0,0 +1,45 @@
+/**
+ * MMKV-backed snapshot store.
+ *
+ * Every MMKV import is confined to this file, so the rest of the package stays
+ * testable without a native module.
+ *
+ * MMKV is chosen because it is **synchronous**, which is what lets
+ * `getEntitlement` be an in-memory read with no I/O on render paths (PERF-001).
+ * An async store would force either an async entitlement read or a hidden
+ * hydration race on every call.
+ *
+ * Records are partitioned by cache-scope token (FR-057a). The token is a
+ * partition key and nothing more: never interpreted, never transmitted, never
+ * attached to a transaction.
+ */
+import { type MmkvLike } from '@chipmobilesdk/rn-core';
+import { type PersistedSnapshot } from './snapshot.js';
+export interface SnapshotStore {
+    load(scopeToken?: string): PersistedSnapshot;
+    /**
+     * Writes the snapshot. Returns false when the write failed, so the engine can
+     * say so; a store returning nothing is taken to have succeeded.
+     */
+    save(snapshot: PersistedSnapshot): boolean | void;
+    /** Clears every scope — for logout and data-deletion requests (FR-057). */
+    clearAll(): void;
+    /** Whether writes actually persist. False means the memory fallback is active. */
+    isDurable(): boolean;
+}
+/**
+ * Creates the store.
+ *
+ * The memory fallback is a **documented degradation**, not a silent one: without
+ * MMKV the snapshot does not survive a cold start, so entitlements read `unknown`
+ * until the first sync. That is safe by construction — `unknown`, never
+ * `not_entitled` (FR-047) — and FR-059's startup sync repairs it. `isDurable()`
+ * lets the engine warn, so the condition is visible rather than mysterious.
+ */
+export declare function createSnapshotStore(injected?: {
+    backing: MmkvLike;
+    durable: boolean;
+}): SnapshotStore;
+/** Test seam for driving the store without the native module. */
+export declare function createMemorySnapshotStore(): SnapshotStore;
+//# sourceMappingURL=mmkv-store.d.ts.map

package/lib/typescript/module/persistence/mmkv-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mmkv-store.d.ts","sourceRoot":"","sources":["../../../../src/persistence/mmkv-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAA+C,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEpG,OAAO,EAAkC,KAAK,iBAAiB,EAAE,MAAM,eAAY,CAAC;AAcpF,MAAM,WAAW,aAAa;IAC7B,IAAI,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAAC;IAC7C;;;OAGG;IACH,IAAI,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,GAAG,IAAI,CAAC;IAClD,2EAA2E;IAC3E,QAAQ,IAAI,IAAI,CAAC;IACjB,kFAAkF;IAClF,SAAS,IAAI,OAAO,CAAC;CACrB;AAkCD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,CAAC,EAAE;IAC9C,OAAO,EAAE,QAAQ,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;CACjB,GAAG,aAAa,CA4DhB;AAED,iEAAiE;AACjE,wBAAgB,yBAAyB,IAAI,aAAa,CAYzD"}