@chipmobilesdk/rn-payment 0.6.0 → 0.7.0

package/lib/commonjs/engine/sync.js

@@ -0,0 +1,163 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSync = createSync;
+exports.toPersistedRecord = toPersistedRecord;
+var _errors = require("../diagnostics/errors.js");
+var _mapping = require("../entitlements/mapping.js");
+var _mutex = require("../core/mutex.js");
+var _snapshot = require("../persistence/snapshot.js");
+/**
+ * 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.
+ */
+
+/** The persisted record for one store purchase, keeping what we already knew about it. */
+function toPersistedRecord(resolved, purchase, productKey, existing) {
+  return {
+    transactionId: purchase.transactionId,
+    productKey,
+    productType: resolved.entries.get(productKey)?.productType ?? 'one_time_permanent',
+    token: purchase.token,
+    state: purchase.state === 'pending' ? 'pending' : 'purchased',
+    purchasedAt: purchase.purchasedAt,
+    // Finalize progress survives: a sync must never reset a queued
+    // acknowledgement and lose the paid transaction.
+    finalizeState: (0, _snapshot.resolveFinalizeState)(purchase, existing),
+    attempts: existing?.attempts ?? 0,
+    validationState: existing?.validationState ?? 'not_required',
+    expiresAt: purchase.expiresAt,
+    willAutoRenew: purchase.willAutoRenew
+  };
+}
+
+/** Store purchases as records, dropping products this catalog does not know. */
+function toPersisted(resolved, purchases, known) {
+  const records = [];
+  for (const purchase of purchases) {
+    // Legitimately possible: a user owns something from a build whose catalog
+    // has since changed. Ignored rather than treated as impossible.
+    const productKey = (0, _mapping.productKeyForStoreId)(resolved, purchase.storeProductId);
+    if (!productKey || !resolved.entries.has(productKey)) {
+      continue;
+    }
+    const existing = known.find(p => p.transactionId === purchase.transactionId);
+    if (purchase.state === 'unspecified') {
+      // No basis for granting, finalizing or ending anything: a new transaction
+      // waits until the store says what it is, a known one keeps what we knew.
+      if (existing) {
+        records.push(existing);
+      }
+      continue;
+    }
+    records.push(toPersistedRecord(resolved, purchase, productKey, existing));
+  }
+  return records;
+}
+function purchasedIds(records) {
+  return new Set(records.filter(p => p.state === 'purchased').map(p => p.transactionId));
+}
+/**
+ * `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.
+ */
+function createSync(state, settle) {
+  const {
+    resolved,
+    provider,
+    now
+  } = state;
+  const syncFlight = (0, _mutex.createSingleFlight)();
+  const settleFlight = (0, _mutex.createSingleFlight)();
+  const foregroundLimiter = (0, _mutex.createRateLimiter)(resolved.foregroundSyncMinIntervalMs, now);
+  async function querySnapshot(trigger) {
+    try {
+      const owned = await (0, _mutex.withTimeout)(provider.queryOwned(), resolved.timeouts.syncMs, () => new _errors.PaymentError({
+        code: 'PAYMENT_TIMEOUT',
+        message: 'Syncing entitlements timed out',
+        operation: 'sync',
+        retryable: true
+      }));
+      const before = purchasedIds(state.snapshot.purchases);
+      const records = toPersisted(resolved, owned, state.snapshot.purchases);
+      const after = purchasedIds(records);
+      // A transaction the store no longer reports is revoked — a refund. The
+      // cache must not resurrect it (FR-064, FR-055).
+      const revokedCount = [...before].filter(id => !after.has(id)).length;
+      const restoredCount = [...after].filter(id => !before.has(id)).length;
+      state.hasSynced = true;
+      state.commit({
+        ...state.snapshot,
+        purchases: records,
+        lastSyncedAt: now()
+      });
+      state.emit({
+        type: 'sync_completed',
+        restoredCount,
+        revokedCount,
+        trigger
+      });
+      return {
+        ok: true,
+        restoredCount,
+        revokedCount
+      };
+    } catch (error) {
+      const paymentError = error instanceof _errors.PaymentError ? error : new _errors.PaymentError({
+        code: 'PAYMENT_STORE_ERROR',
+        message: 'Sync failed',
+        operation: 'sync',
+        retryable: true
+      });
+      // A failed sync leaves the previous snapshot in place, so offline
+      // entitlements survive rather than being wiped (FR-053).
+      state.emit({
+        type: 'internal_error',
+        code: paymentError.code,
+        operation: 'sync'
+      });
+      return {
+        ok: false,
+        error: paymentError
+      };
+    }
+  }
+  return {
+    async sync(trigger = 'manual') {
+      if (state.disposed || !resolved.enabled) {
+        return {
+          ok: false,
+          error: new _errors.PaymentError({
+            code: 'PAYMENT_DISABLED',
+            message: 'Payments are disabled',
+            operation: 'sync'
+          })
+        };
+      }
+      // Rejected rather than deferred: the next foreground event tries again,
+      // whereas queueing would fire a burst once the interval elapsed (PERF-002).
+      if (trigger === 'foreground' && !foregroundLimiter.tryAcquire()) {
+        return {
+          ok: true,
+          restoredCount: 0,
+          revokedCount: 0
+        };
+      }
+      // Concurrent callers join one flight: one store request (FR-063).
+      const outcome = await syncFlight.run(() => querySnapshot(trigger));
+      if (outcome.ok) {
+        await settleFlight.run(settle);
+      }
+      return outcome;
+    }
+  };
+}
+//# sourceMappingURL=sync.js.map

package/lib/commonjs/engine/sync.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","_mapping","_mutex","_snapshot","toPersistedRecord","resolved","purchase","productKey","existing","transactionId","productType","entries","get","token","state","purchasedAt","finalizeState","resolveFinalizeState","attempts","validationState","expiresAt","willAutoRenew","toPersisted","purchases","known","records","productKeyForStoreId","storeProductId","has","find","p","push","purchasedIds","Set","filter","map","createSync","settle","provider","now","syncFlight","createSingleFlight","settleFlight","foregroundLimiter","createRateLimiter","foregroundSyncMinIntervalMs","querySnapshot","trigger","owned","withTimeout","queryOwned","timeouts","syncMs","PaymentError","code","message","operation","retryable","before","snapshot","after","revokedCount","id","length","restoredCount","hasSynced","commit","lastSyncedAt","emit","type","ok","error","paymentError","sync","disposed","enabled","tryAcquire","outcome","run"],"sourceRoot":"../../../src","sources":["engine/sync.ts"],"mappings":";;;;;;;AAWA,IAAAA,OAAA,GAAAC,OAAA;AAEA,IAAAC,QAAA,GAAAD,OAAA;AACA,IAAAE,MAAA,GAAAF,OAAA;AACA,IAAAG,SAAA,GAAAH,OAAA;AAfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAcA;AACO,SAASI,iBAAiBA,CAChCC,QAAwB,EACxBC,QAA0B,EAC1BC,UAAsB,EACtBC,QAAuC,EACnB;EACpB,OAAO;IACNC,aAAa,EAAEH,QAAQ,CAACG,aAAa;IACrCF,UAAU;IACVG,WAAW,EAAEL,QAAQ,CAACM,OAAO,CAACC,GAAG,CAACL,UAAU,CAAC,EAAEG,WAAW,IAAI,oBAAoB;IAClFG,KAAK,EAAEP,QAAQ,CAACO,KAAK;IACrBC,KAAK,EAAER,QAAQ,CAACQ,KAAK,KAAK,SAAS,GAAG,SAAS,GAAG,WAAW;IAC7DC,WAAW,EAAET,QAAQ,CAACS,WAAW;IACjC;IACA;IACAC,aAAa,EAAE,IAAAC,8BAAoB,EAACX,QAAQ,EAAEE,QAAQ,CAAC;IACvDU,QAAQ,EAAEV,QAAQ,EAAEU,QAAQ,IAAI,CAAC;IACjCC,eAAe,EAAEX,QAAQ,EAAEW,eAAe,IAAI,cAAc;IAC5DC,SAAS,EAAEd,QAAQ,CAACc,SAAS;IAC7BC,aAAa,EAAEf,QAAQ,CAACe;EACzB,CAAC;AACF;;AAEA;AACA,SAASC,WAAWA,CACnBjB,QAAwB,EACxBkB,SAAsC,EACtCC,KAAmC,EACb;EACtB,MAAMC,OAA4B,GAAG,EAAE;EACvC,KAAK,MAAMnB,QAAQ,IAAIiB,SAAS,EAAE;IACjC;IACA;IACA,MAAMhB,UAAU,GAAG,IAAAmB,6BAAoB,EAACrB,QAAQ,EAAEC,QAAQ,CAACqB,cAAc,CAAC;IAC1E,IAAI,CAACpB,UAAU,IAAI,CAACF,QAAQ,CAACM,OAAO,CAACiB,GAAG,CAACrB,UAAU,CAAC,EAAE;MACrD;IACD;IACA,MAAMC,QAAQ,GAAGgB,KAAK,CAACK,IAAI,CAACC,CAAC,IAAIA,CAAC,CAACrB,aAAa,KAAKH,QAAQ,CAACG,aAAa,CAAC;IAC5E,IAAIH,QAAQ,CAACQ,KAAK,KAAK,aAAa,EAAE;MACrC;MACA;MACA,IAAIN,QAAQ,EAAE;QACbiB,OAAO,CAACM,IAAI,CAACvB,QAAQ,CAAC;MACvB;MACA;IACD;IACAiB,OAAO,CAACM,IAAI,CAAC3B,iBAAiB,CAACC,QAAQ,EAAEC,QAAQ,EAAEC,UAAU,EAAEC,QAAQ,CAAC,CAAC;EAC1E;EACA,OAAOiB,OAAO;AACf;AAEA,SAASO,YAAYA,CAACP,OAAqC,EAAe;EACzE,OAAO,IAAIQ,GAAG,CAACR,OAAO,CAACS,MAAM,CAACJ,CAAC,IAAIA,CAAC,CAAChB,KAAK,KAAK,WAAW,CAAC,CAACqB,GAAG,CAACL,CAAC,IAAIA,CAAC,CAACrB,aAAa,CAAC,CAAC;AACvF;AAMA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS2B,UAAUA,CAACtB,KAAkB,EAAEuB,MAA2B,EAAQ;EACjF,MAAM;IAAEhC,QAAQ;IAAEiC,QAAQ;IAAEC;EAAI,CAAC,GAAGzB,KAAK;EACzC,MAAM0B,UAAU,GAAG,IAAAC,yBAAkB,EAAc,CAAC;EACpD,MAAMC,YAAY,GAAG,IAAAD,yBAAkB,EAAO,CAAC;EAC/C,MAAME,iBAAiB,GAAG,IAAAC,wBAAiB,EAACvC,QAAQ,CAACwC,2BAA2B,EAAEN,GAAG,CAAC;EAEtF,eAAeO,aAAaA,CAACC,OAAoB,EAAwB;IACxE,IAAI;MACH,MAAMC,KAAK,GAAG,MAAM,IAAAC,kBAAW,EAC9BX,QAAQ,CAACY,UAAU,CAAC,CAAC,EACrB7C,QAAQ,CAAC8C,QAAQ,CAACC,MAAM,EACxB,MACC,IAAIC,oBAAY,CAAC;QAChBC,IAAI,EAAE,iBAAiB;QACvBC,OAAO,EAAE,gCAAgC;QACzCC,SAAS,EAAE,MAAM;QACjBC,SAAS,EAAE;MACZ,CAAC,CACH,CAAC;MACD,MAAMC,MAAM,GAAG1B,YAAY,CAAClB,KAAK,CAAC6C,QAAQ,CAACpC,SAAS,CAAC;MACrD,MAAME,OAAO,GAAGH,WAAW,CAACjB,QAAQ,EAAE2C,KAAK,EAAElC,KAAK,CAAC6C,QAAQ,CAACpC,SAAS,CAAC;MACtE,MAAMqC,KAAK,GAAG5B,YAAY,CAACP,OAAO,CAAC;MACnC;MACA;MACA,MAAMoC,YAAY,GAAG,CAAC,GAAGH,MAAM,CAAC,CAACxB,MAAM,CAAC4B,EAAE,IAAI,CAACF,KAAK,CAAChC,GAAG,CAACkC,EAAE,CAAC,CAAC,CAACC,MAAM;MACpE,MAAMC,aAAa,GAAG,CAAC,GAAGJ,KAAK,CAAC,CAAC1B,MAAM,CAAC4B,EAAE,IAAI,CAACJ,MAAM,CAAC9B,GAAG,CAACkC,EAAE,CAAC,CAAC,CAACC,MAAM;MAErEjD,KAAK,CAACmD,SAAS,GAAG,IAAI;MACtBnD,KAAK,CAACoD,MAAM,CAAC;QAAE,GAAGpD,KAAK,CAAC6C,QAAQ;QAAEpC,SAAS,EAAEE,OAAO;QAAE0C,YAAY,EAAE5B,GAAG,CAAC;MAAE,CAAC,CAAC;MAC5EzB,KAAK,CAACsD,IAAI,CAAC;QAAEC,IAAI,EAAE,gBAAgB;QAAEL,aAAa;QAAEH,YAAY;QAAEd;MAAQ,CAAC,CAAC;MAC5E,OAAO;QAAEuB,EAAE,EAAE,IAAI;QAAEN,aAAa;QAAEH;MAAa,CAAC;IACjD,CAAC,CAAC,OAAOU,KAAK,EAAE;MACf,MAAMC,YAAY,GACjBD,KAAK,YAAYlB,oBAAY,GAC1BkB,KAAK,GACL,IAAIlB,oBAAY,CAAC;QACjBC,IAAI,EAAE,qBAAqB;QAC3BC,OAAO,EAAE,aAAa;QACtBC,SAAS,EAAE,MAAM;QACjBC,SAAS,EAAE;MACZ,CAAC,CAAC;MACL;MACA;MACA3C,KAAK,CAACsD,IAAI,CAAC;QAAEC,IAAI,EAAE,gBAAgB;QAAEf,IAAI,EAAEkB,YAAY,CAAClB,IAAI;QAAEE,SAAS,EAAE;MAAO,CAAC,CAAC;MAClF,OAAO;QAAEc,EAAE,EAAE,KAAK;QAAEC,KAAK,EAAEC;MAAa,CAAC;IAC1C;EACD;EAEA,OAAO;IACN,MAAMC,IAAIA,CAAC1B,OAAO,GAAG,QAAQ,EAAE;MAC9B,IAAIjC,KAAK,CAAC4D,QAAQ,IAAI,CAACrE,QAAQ,CAACsE,OAAO,EAAE;QACxC,OAAO;UACNL,EAAE,EAAE,KAAK;UACTC,KAAK,EAAE,IAAIlB,oBAAY,CAAC;YACvBC,IAAI,EAAE,kBAAkB;YACxBC,OAAO,EAAE,uBAAuB;YAChCC,SAAS,EAAE;UACZ,CAAC;QACF,CAAC;MACF;MACA;MACA;MACA,IAAIT,OAAO,KAAK,YAAY,IAAI,CAACJ,iBAAiB,CAACiC,UAAU,CAAC,CAAC,EAAE;QAChE,OAAO;UAAEN,EAAE,EAAE,IAAI;UAAEN,aAAa,EAAE,CAAC;UAAEH,YAAY,EAAE;QAAE,CAAC;MACvD;MACA;MACA,MAAMgB,OAAO,GAAG,MAAMrC,UAAU,CAACsC,GAAG,CAAC,MAAMhC,aAAa,CAACC,OAAO,CAAC,CAAC;MAClE,IAAI8B,OAAO,CAACP,EAAE,EAAE;QACf,MAAM5B,YAAY,CAACoC,GAAG,CAACzC,MAAM,CAAC;MAC/B;MACA,OAAOwC,OAAO;IACf;EACD,CAAC;AACF","ignoreList":[]}

package/lib/commonjs/entitlements/aggregate.js

@@ -0,0 +1,212 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.aggregate = aggregate;
+exports.diffEntitlements = diffEntitlements;
+exports.initialEntitlements = initialEntitlements;
+exports.shareUnchanged = shareUnchanged;
+exports.snapshotCertainty = snapshotCertainty;
+var _rnCore = require("@chipmobilesdk/rn-core");
+var _mapping = require("./mapping.js");
+var _policy = require("./policy.js");
+/**
+ * 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.
+ */
+
+/** A purchase that currently confers its entitlements. */
+function isValidSource(purchase, input) {
+  // Only a purchase the store confirmed grants. Pending money is not money, and a
+  // state this version does not know is no basis for a grant either (PAY-13).
+  if (purchase.state !== 'purchased') {
+    return false;
+  }
+  // A backend that said no is final (FR-071). A queued re-validation still
+  // grants, which is the documented `grant_and_queue` fallback (FR-072).
+  if (purchase.validationState === 'rejected') {
+    return false;
+  }
+  if (purchase.productType === 'subscription') {
+    if ((0, _policy.hasExpired)(purchase.expiresAt, input.now)) {
+      return false;
+    }
+    const renewalState = (0, _policy.deriveRenewalState)({
+      expiresAt: purchase.expiresAt,
+      willAutoRenew: purchase.willAutoRenew,
+      reportsGraceAndHoldDistinctly: input.reportsGraceAndHoldDistinctly
+    });
+    return (0, _policy.grantsUnderPolicy)(renewalState, {
+      gracePolicy: input.config.gracePolicy,
+      holdPolicy: input.config.holdPolicy
+    });
+  }
+
+  // A consumable that has not been consumed yet is owned, but it must never
+  // become a permanent entitlement — consumption flips it to `consumed` above.
+  return true;
+}
+function subscriptionDetailFor(purchases, input) {
+  const subs = purchases.filter(p => p.productType === 'subscription');
+  if (subs.length === 0) {
+    return undefined;
+  }
+
+  // Where several subscriptions grant one entitlement, the one running longest
+  // is what the user experiences, so report that one.
+  const furthest = subs.reduce((best, candidate) => {
+    const bestAt = best.expiresAt ?? Number.MAX_SAFE_INTEGER;
+    const candidateAt = candidate.expiresAt ?? Number.MAX_SAFE_INTEGER;
+    return candidateAt > bestAt ? candidate : best;
+  });
+  const renewalState = (0, _policy.deriveRenewalState)({
+    expiresAt: furthest.expiresAt,
+    willAutoRenew: furthest.willAutoRenew,
+    reportsGraceAndHoldDistinctly: input.reportsGraceAndHoldDistinctly
+  });
+  return {
+    expiresAt: furthest.expiresAt,
+    willAutoRenew: furthest.willAutoRenew === true,
+    isCancelledButValid: renewalState === 'cancelled_valid',
+    renewalState
+  };
+}
+
+/**
+ * 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.
+ */
+function snapshotCertainty(input) {
+  const {
+    config,
+    snapshot,
+    hasSynced,
+    now
+  } = input;
+  const isStale = snapshot.lastSyncedAt !== undefined && now - snapshot.lastSyncedAt > config.staleAfterMs;
+
+  // Both roads lead to `unknown`, never to a confident "no". Never having synced
+  // and having synced too long ago are the same epistemic state: we cannot
+  // currently support a claim either way.
+  return {
+    isStale,
+    undetermined: !hasSynced || isStale
+  };
+}
+function aggregate(input) {
+  const {
+    config,
+    snapshot
+  } = input;
+  const {
+    isStale,
+    undetermined
+  } = snapshotCertainty(input);
+  const valid = snapshot.purchases.filter(p => isValidSource(p, input));
+  const result = {};
+  for (const key of config.entitlementKeys) {
+    const granting = valid.filter(p => (0, _mapping.entitlementsFor)(config, p.productKey).includes(key));
+    const sources = [...new Set(granting.map(p => p.productKey))];
+    result[key] = {
+      key,
+      // An entitlement stays valid while at least one source remains (FR-052).
+      status: undetermined ? 'unknown' : sources.length > 0 ? 'entitled' : 'not_entitled',
+      sources,
+      subscription: subscriptionDetailFor(granting, input),
+      lastSyncedAt: snapshot.lastSyncedAt,
+      isStale
+    };
+  }
+  return result;
+}
+
+/** The initial map, before anything is known. Every key starts at `unknown` (FR-047). */
+function initialEntitlements(config) {
+  const result = {};
+  for (const key of config.entitlementKeys) {
+    result[key] = {
+      key,
+      status: 'unknown',
+      sources: [],
+      lastSyncedAt: undefined,
+      isStale: false
+    };
+  }
+  return result;
+}
+/**
+ * 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.
+ */
+function diffEntitlements(previous, next) {
+  const changes = [];
+  for (const key of Object.keys(next)) {
+    const before = previous[key]?.status ?? 'unknown';
+    const after = next[key].status;
+    if (before !== after) {
+      changes.push({
+        key,
+        previous: before,
+        next: after,
+        sources: next[key].sources
+      });
+    }
+  }
+  return changes;
+}
+function sameEntitlement(a, b) {
+  return a.status === b.status && a.isStale === b.isStale && a.lastSyncedAt === b.lastSyncedAt && a.sources.length === b.sources.length && a.sources.every((source, index) => source === b.sources[index]) && (0, _rnCore.shallowEqual)(a.subscription, b.subscription);
+}
+
+/**
+ * `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.
+ */
+function shareUnchanged(previous, next) {
+  const keys = Object.keys(next);
+  let changed = keys.length !== Object.keys(previous).length;
+  const shared = {};
+  for (const key of keys) {
+    const before = previous[key];
+    const after = next[key];
+    if (before && sameEntitlement(before, after)) {
+      shared[key] = before;
+    } else {
+      shared[key] = after;
+      changed = true;
+    }
+  }
+  return changed ? shared : previous;
+}
+//# sourceMappingURL=aggregate.js.map

package/lib/commonjs/entitlements/aggregate.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_rnCore","require","_mapping","_policy","isValidSource","purchase","input","state","validationState","productType","hasExpired","expiresAt","now","renewalState","deriveRenewalState","willAutoRenew","reportsGraceAndHoldDistinctly","grantsUnderPolicy","gracePolicy","config","holdPolicy","subscriptionDetailFor","purchases","subs","filter","p","length","undefined","furthest","reduce","best","candidate","bestAt","Number","MAX_SAFE_INTEGER","candidateAt","isCancelledButValid","snapshotCertainty","snapshot","hasSynced","isStale","lastSyncedAt","staleAfterMs","undetermined","aggregate","valid","result","key","entitlementKeys","granting","entitlementsFor","productKey","includes","sources","Set","map","status","subscription","initialEntitlements","diffEntitlements","previous","next","changes","Object","keys","before","after","push","sameEntitlement","a","b","every","source","index","shallowEqual","shareUnchanged","changed","shared"],"sourceRoot":"../../../src","sources":["entitlements/aggregate.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/entitlements/mapping.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.entitlementsFor = entitlementsFor;
+exports.productKeyForStoreId = productKeyForStoreId;
+exports.storeIdForProductKey = storeIdForProductKey;
+/**
+ * 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).
+ */
+
+/** Entitlements a product confers. Empty for an unknown key rather than throwing. */
+function entitlementsFor(config, productKey) {
+  return config.grants.get(productKey) ?? [];
+}
+
+/**
+ * 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.
+ */
+function productKeyForStoreId(config, storeProductId) {
+  return config.byStoreId.get(storeProductId);
+}
+function storeIdForProductKey(config, productKey) {
+  return config.entries.get(productKey)?.storeProductIds[config.platform];
+}
+//# sourceMappingURL=mapping.js.map

package/lib/commonjs/entitlements/mapping.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["entitlementsFor","config","productKey","grants","get","productKeyForStoreId","storeProductId","byStoreId","storeIdForProductKey","entries","storeProductIds","platform"],"sourceRoot":"../../../src","sources":["entitlements/mapping.ts"],"mappings":";;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKA;AACO,SAASA,eAAeA,CAC9BC,MAAsB,EACtBC,UAAsB,EACM;EAC5B,OAAOD,MAAM,CAACE,MAAM,CAACC,GAAG,CAACF,UAAU,CAAC,IAAI,EAAE;AAC3C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,oBAAoBA,CACnCJ,MAAsB,EACtBK,cAAsB,EACG;EACzB,OAAOL,MAAM,CAACM,SAAS,CAACH,GAAG,CAACE,cAAc,CAAC;AAC5C;AAEO,SAASE,oBAAoBA,CACnCP,MAAsB,EACtBC,UAAsB,EACD;EACrB,OAAOD,MAAM,CAACQ,OAAO,CAACL,GAAG,CAACF,UAAU,CAAC,EAAEQ,eAAe,CAACT,MAAM,CAACU,QAAQ,CAAC;AACxE","ignoreList":[]}

package/lib/commonjs/entitlements/policy.js

@@ -0,0 +1,110 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deriveRenewalState = deriveRenewalState;
+exports.grantsUnderPolicy = grantsUnderPolicy;
+exports.hasExpired = hasExpired;
+/**
+ * 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).
+ */
+
+/**
+ * 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.
+ */
+
+/**
+ * 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.
+ */
+function deriveRenewalState(facts) {
+  if (facts.reportsGraceAndHoldDistinctly && facts.providerRenewalState) {
+    switch (facts.providerRenewalState) {
+      case 'grace':
+        return 'grace';
+      case 'hold':
+        return 'hold';
+      case 'active':
+        return facts.willAutoRenew === false ? 'cancelled_valid' : 'active';
+    }
+  }
+  if (facts.willAutoRenew === false) {
+    // Still inside a paid period with auto-renew off. Genuinely ambiguous
+    // between "cancelled" and "in grace", so report the one that is certainly
+    // true — the period is paid for — and let the app decide how to present it.
+    return 'cancelled_valid';
+  }
+  if (facts.willAutoRenew === true) {
+    return 'active';
+  }
+  return 'indeterminate';
+}
+
+/**
+ * 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.
+ */
+function grantsUnderPolicy(state, policy) {
+  switch (state) {
+    case 'active':
+    case 'cancelled_valid':
+      return true;
+    case 'grace':
+      return policy.gracePolicy === 'grant';
+    case 'hold':
+      return policy.holdPolicy === 'grant';
+    case 'indeterminate':
+      // The store is still reporting the purchase as owned. Withholding here
+      // would revoke from a paying user because of our own uncertainty.
+      return true;
+  }
+}
+
+/** True once a subscription's paid period has genuinely elapsed (FR-048). */
+function hasExpired(expiresAt, now) {
+  return expiresAt !== undefined && expiresAt <= now;
+}
+//# sourceMappingURL=policy.js.map

package/lib/commonjs/entitlements/policy.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["deriveRenewalState","facts","reportsGraceAndHoldDistinctly","providerRenewalState","willAutoRenew","grantsUnderPolicy","state","policy","gracePolicy","holdPolicy","hasExpired","expiresAt","now","undefined"],"sourceRoot":"../../../src","sources":["entitlements/policy.ts"],"mappings":";;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;;AAiBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,kBAAkBA,CAACC,KAAwB,EAAgB;EAC1E,IAAIA,KAAK,CAACC,6BAA6B,IAAID,KAAK,CAACE,oBAAoB,EAAE;IACtE,QAAQF,KAAK,CAACE,oBAAoB;MACjC,KAAK,OAAO;QACX,OAAO,OAAO;MACf,KAAK,MAAM;QACV,OAAO,MAAM;MACd,KAAK,QAAQ;QACZ,OAAOF,KAAK,CAACG,aAAa,KAAK,KAAK,GAAG,iBAAiB,GAAG,QAAQ;IACrE;EACD;EAEA,IAAIH,KAAK,CAACG,aAAa,KAAK,KAAK,EAAE;IAClC;IACA;IACA;IACA,OAAO,iBAAiB;EACzB;EAEA,IAAIH,KAAK,CAACG,aAAa,KAAK,IAAI,EAAE;IACjC,OAAO,QAAQ;EAChB;EAEA,OAAO,eAAe;AACvB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,iBAAiBA,CAACC,KAAmB,EAAEC,MAAyB,EAAW;EAC1F,QAAQD,KAAK;IACZ,KAAK,QAAQ;IACb,KAAK,iBAAiB;MACrB,OAAO,IAAI;IACZ,KAAK,OAAO;MACX,OAAOC,MAAM,CAACC,WAAW,KAAK,OAAO;IACtC,KAAK,MAAM;MACV,OAAOD,MAAM,CAACE,UAAU,KAAK,OAAO;IACrC,KAAK,eAAe;MACnB;MACA;MACA,OAAO,IAAI;EACb;AACD;;AAEA;AACO,SAASC,UAAUA,CAACC,SAA6B,EAAEC,GAAW,EAAW;EAC/E,OAAOD,SAAS,KAAKE,SAAS,IAAIF,SAAS,IAAIC,GAAG;AACnD","ignoreList":[]}