@chipmobilesdk/rn-payment 0.5.0 → 0.7.0

package/lib/typescript/commonjs/engine/internals.d.ts

@@ -0,0 +1,28 @@
+/**
+ * What tests and diagnostics need from an engine, off its public type (PAY-11).
+ *
+ * Until 0.6.0 these were methods of `PaymentEngine`, so any consumer could commit
+ * a snapshot of its own and grant itself an entitlement the store never sold,
+ * and a hand-written engine double had to implement all of them. They live in a
+ * WeakMap keyed by the engine now, and this module is not exported from the
+ * package entrypoint.
+ */
+import type { ProductKey } from '../config/types';
+import type { ResolvedConfig } from '../config/validate';
+import type { PaymentEmitter } from '../diagnostics/events';
+import type { PersistedSnapshot } from '../persistence/snapshot';
+import type { PaymentEngine } from './engine';
+export interface EngineInternals {
+    resolvedConfig(): ResolvedConfig;
+    nextCorrelationId(): string;
+    emitter(): PaymentEmitter;
+    snapshot(): PersistedSnapshot;
+    commitSnapshot(next: PersistedSnapshot): void;
+    mayCreateRealTransaction(): boolean;
+    /** Records a purchase refused because this environment may not move real money (FR-014). */
+    recordBlockedOperation(productKey: ProductKey): void;
+}
+export declare function attachEngineInternals(engine: PaymentEngine, internals: EngineInternals): void;
+/** The internals of an engine `createEngine` made. Throws for any other object. */
+export declare function engineInternals(engine: PaymentEngine): EngineInternals;
+//# sourceMappingURL=internals.d.ts.map

package/lib/typescript/commonjs/engine/internals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internals.d.ts","sourceRoot":"","sources":["../../../../src/engine/internals.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,MAAM,WAAW,eAAe;IAC/B,cAAc,IAAI,cAAc,CAAC;IACjC,iBAAiB,IAAI,MAAM,CAAC;IAC5B,OAAO,IAAI,cAAc,CAAC;IAC1B,QAAQ,IAAI,iBAAiB,CAAC;IAC9B,cAAc,CAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC9C,wBAAwB,IAAI,OAAO,CAAC;IACpC,4FAA4F;IAC5F,sBAAsB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;CACrD;AAID,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,eAAe,GAAG,IAAI,CAE7F;AAED,mFAAmF;AACnF,wBAAgB,eAAe,CAAC,MAAM,EAAE,aAAa,GAAG,eAAe,CAMtE"}

package/lib/typescript/commonjs/engine/pending.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The pending set, and how a pending purchase ends (FR-101 – FR-104), added in
+ * 0.2.0.
+ *
+ * 0.1.0 handled pending purchases correctly on the grant side — pending never
+ * grants, a settled one is granted at the next sync, an abandoned one is removed
+ * — but an app could only *see* one in the session it started in. The record
+ * was already persisted with a `pending` state; this module is the read side of
+ * it, and nothing more. It decides nothing about granting: that stays in
+ * `entitlements/aggregate.ts`, where pending is refused unconditionally.
+ *
+ * Pure: no provider, no I/O, no React. The engine calls it from `commit`.
+ */
+import type { ResolvedConfig } from '../config/validate';
+import type { PendingPurchasesState, PendingResolution, ProductKey } from '../config/types';
+import type { PersistedSnapshot } from '../persistence/snapshot';
+export declare const UNKNOWN_PENDING: PendingPurchasesState;
+/**
+ * Derives the pending set from the snapshot.
+ *
+ * Read from the persisted record, so it survives an app kill and an offline
+ * restart, and judged by the very staleness rule entitlements use (FR-103).
+ * Products no longer in the catalog are left out: an app cannot render a row,
+ * or withhold a Buy button, for a product key it no longer has.
+ */
+export declare function derivePending(input: {
+    config: ResolvedConfig;
+    snapshot: PersistedSnapshot;
+    hasSynced: boolean;
+    now: number;
+}): PendingPurchasesState;
+export interface PendingTransition {
+    readonly productKey: ProductKey;
+    readonly outcome: PendingResolution;
+}
+/**
+ * Every pending transaction that stopped being pending between two snapshots.
+ *
+ * Computed from the commit itself rather than at each call site that might end
+ * a pending purchase — sync, a store push, a purchase — which is what makes
+ * "exactly once" structural (FR-104, FR-079). A store push and a sync racing on
+ * one settling purchase both commit, but only the first commit sees it leave
+ * the pending set.
+ *
+ * A record that disappeared ended without payment. Why is the store's to say;
+ * when it says nothing, `cancelled` (see `PendingResolution`).
+ */
+export declare function pendingTransitions(previous: PersistedSnapshot, next: PersistedSnapshot, config: ResolvedConfig, endReason: (transactionId: string) => 'cancelled' | 'expired' | undefined): PendingTransition[];
+/** Whether a listener has anything new to hear. */
+export declare function samePending(a: PendingPurchasesState, b: PendingPurchasesState): boolean;
+//# sourceMappingURL=pending.d.ts.map

package/lib/typescript/commonjs/engine/pending.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending.d.ts","sourceRoot":"","sources":["../../../../src/engine/pending.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAEX,qBAAqB,EACrB,iBAAiB,EACjB,UAAU,EACV,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAGjE,eAAO,MAAM,eAAe,EAAE,qBAI7B,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE;IACpC,MAAM,EAAE,cAAc,CAAC;IACvB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,SAAS,EAAE,OAAO,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;CACZ,GAAG,qBAAqB,CAoBxB;AAED,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;CACpC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CACjC,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,iBAAiB,EACvB,MAAM,EAAE,cAAc,EACtB,SAAS,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,WAAW,GAAG,SAAS,GAAG,SAAS,GACvE,iBAAiB,EAAE,CAgBrB;AAED,mDAAmD;AACnD,wBAAgB,WAAW,CAAC,CAAC,EAAE,qBAAqB,EAAE,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAWvF"}

package/lib/typescript/commonjs/engine/products.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Product query, normalization, and the in-memory price cache (US11).
+ *
+ * Two rules shape this module:
+ *
+ * - **Prices come from the store, formatted.** An app must never build a price
+ *   string (FR-028): only the store knows the right currency symbol, its
+ *   placement, the decimal separator, and the grouping for the user's locale. A
+ *   hand-built "$9.99" is wrong in most of the world.
+ * - **Offer eligibility is reported, never computed.** The store decides who
+ *   qualifies for a trial or an introductory price (FR-026). Guessing locally
+ *   would promise a trial the store then refuses at checkout.
+ *
+ * The cache is in **memory only** and short-lived. Persisting prices would risk
+ * showing a stale one as current in a later session, and a paywall is exactly
+ * where that matters.
+ */
+import type { ProductKey, ProductType } from '../config/types';
+import type { ResolvedConfig } from '../config/validate';
+import type { ProviderPort } from '../adapter/port';
+import { PaymentError } from '../diagnostics/errors';
+import type { PaymentEventInput } from '../diagnostics/events';
+export interface Offer {
+    offerKey: string;
+    billingPeriod: string;
+    formattedPrice: string;
+    priceAmountMicros: number;
+    currencyCode: string;
+    trialPeriod?: string;
+    introductoryPrice?: {
+        formattedPrice: string;
+        period: string;
+        cycles: number;
+    };
+    /** As the store determined it. Never computed here (FR-026). */
+    isEligible: boolean;
+}
+export interface ProductInfo {
+    productKey: ProductKey;
+    productType: ProductType;
+    title: string;
+    description: string;
+    /** Store-formatted and locale-correct. For display (FR-024). */
+    formattedPrice: string;
+    currencyCode: string;
+    /** For comparison and sorting only — never for display (FR-028). */
+    priceAmountMicros: number;
+    offers: Offer[];
+}
+/** Why a requested product produced nothing, kept distinct from a network error. */
+export type MissingProductReason = 'not_in_catalog'
+/** Does not exist, is unapproved, or is not sold in this country (FR-027). */
+ | 'not_available_from_store';
+export interface MissingProduct {
+    productKey: ProductKey;
+    reason: MissingProductReason;
+}
+export type ProductQueryResult = {
+    ok: true;
+    products: ProductInfo[];
+    /** Reported separately so an app shows an explanation, not an empty row. */
+    missing: MissingProduct[];
+    fromCache: boolean;
+} | {
+    ok: false;
+    error: PaymentError;
+};
+export interface ProductsDeps {
+    resolved: ResolvedConfig;
+    provider: ProviderPort;
+    emit: (event: PaymentEventInput) => void;
+    now: () => number;
+}
+export interface Products {
+    get(productKeys: ProductKey[]): Promise<ProductQueryResult>;
+    /** Bypasses the cache; for a pull-to-refresh on a paywall (FR-029). */
+    refresh(productKeys: ProductKey[]): Promise<ProductQueryResult>;
+    /** Drops the cache, e.g. after a locale or account change. */
+    invalidate(): void;
+}
+export declare function createProducts(deps: ProductsDeps): Products;
+//# sourceMappingURL=products.d.ts.map

package/lib/typescript/commonjs/engine/products.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"products.d.ts","sourceRoot":"","sources":["../../../../src/engine/products.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAG/D,MAAM,WAAW,KAAK;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE;QACnB,cAAc,EAAE,MAAM,CAAC;QACvB,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;KACf,CAAC;IACF,gEAAgE;IAChE,UAAU,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC3B,UAAU,EAAE,UAAU,CAAC;IACvB,WAAW,EAAE,WAAW,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,oEAAoE;IACpE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,KAAK,EAAE,CAAC;CAChB;AAED,oFAAoF;AACpF,MAAM,MAAM,oBAAoB,GAC7B,gBAAgB;AAClB,8EAA8E;GAC5E,0BAA0B,CAAC;AAE9B,MAAM,WAAW,cAAc;IAC9B,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,oBAAoB,CAAC;CAC7B;AAED,MAAM,MAAM,kBAAkB,GAC3B;IACA,EAAE,EAAE,IAAI,CAAC;IACT,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,4EAA4E;IAC5E,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,SAAS,EAAE,OAAO,CAAC;CAClB,GACD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,YAAY,CAAA;CAAE,CAAC;AAEtC,MAAM,WAAW,YAAY;IAC5B,QAAQ,EAAE,cAAc,CAAC;IACzB,QAAQ,EAAE,YAAY,CAAC;IACvB,IAAI,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACzC,GAAG,EAAE,MAAM,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,QAAQ;IACxB,GAAG,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAC5D,uEAAuE;IACvE,OAAO,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAChE,8DAA8D;IAC9D,UAAU,IAAI,IAAI,CAAC;CACnB;AAiCD,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,QAAQ,CA8J3D"}

package/lib/typescript/commonjs/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';
+import type { ResolvedConfig, TargetPlatform } from '../config/validate';
+import type { ProviderPort, ProviderPurchase } from '../adapter/port';
+import type { ExclusiveOutcome } from '../core/mutex';
+import type { PaymentEventInput } from '../diagnostics/events';
+import type { PersistedSnapshot } from '../persistence/snapshot';
+import type { Finalizer } from './finalize';
+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/commonjs/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,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,KAAK,EACX,YAAY,EACZ,gBAAgB,EAIhB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAItD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,KAAK,EAAqB,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEpF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,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/commonjs/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';
+import type { PaymentStatusKind, ProductKey, PurchaseResult } from '../config/types';
+import type { PaymentErrorCode } from '../diagnostics/errors';
+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/commonjs/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,iBAAiB,CAAC;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACrF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,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/commonjs/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';
+import type { PaymentConfig, ProductKey } from '../config/types';
+import type { ResolvedConfig, TargetPlatform } from '../config/validate';
+import type { PaymentEventInput } from '../diagnostics/events';
+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("..").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/commonjs/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,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,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/commonjs/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';
+import type { ResolvedConfig } from '../config/validate';
+import type { PaymentConfig, PaymentStatus, PendingPurchasesState } from '../config/types';
+import { type PaymentEmitter, type PaymentEventInput } from '../diagnostics/events';
+import { type EntitlementMap } from '../entitlements/aggregate';
+import type { SnapshotStore } from '../persistence/mmkv-store';
+import { type PersistedSnapshot } from '../persistence/snapshot';
+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/commonjs/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,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE3F,OAAO,EAEN,KAAK,cAAc,EAEnB,KAAK,iBAAiB,EACtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAKN,KAAK,cAAc,EACnB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,yBAAyB,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/commonjs/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';
+import type { ResolvedConfig } from '../config/validate';
+import type { ProviderPort } from '../adapter/port';
+import type { PersistedSnapshot } from '../persistence/snapshot';
+/**
+ * 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/commonjs/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,iBAAiB,CAAC;AACnF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,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/commonjs/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';
+import type { ProductKey } from '../config/types';
+import type { ResolvedConfig } from '../config/validate';
+import { PaymentError } from '../diagnostics/errors';
+import type { SyncTrigger } from '../diagnostics/events';
+import { type PersistedPurchase } from '../persistence/snapshot';
+import type { EngineState } from './state';
+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/commonjs/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,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAGzD,OAAO,EAAwB,KAAK,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACvF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,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/commonjs/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';
+import type { EntitlementKey, ProductKey } from '../config/types';
+import type { PersistedSnapshot } from '../persistence/snapshot';
+import { type RenewalState } from './policy';
+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/commonjs/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,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,KAAK,EAAqB,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEpF,OAAO,EAAqD,KAAK,YAAY,EAAE,MAAM,UAAU,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/commonjs/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';
+import type { EntitlementKey, ProductKey } from '../config/types';
+/** 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/commonjs/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,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,iBAAiB,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"}