@encorekit/web-sdk 2.0.3 → 2.0.6

package/types/core/OfferManager.d.ts

@@ -10,17 +10,43 @@ export declare class OfferManager {
     #private;
     constructor(apiClient: APIClient, userId: string, analyticsClient?: AnalyticsClient);
     /**
-     * Fetch offers from API with optional caching
+     * Fetch offers from API with optional caching.
+     *
+     * `maxPostbackTimeMs` (strict-unlock mode only) narrows the eligible set to
+     * campaigns whose postback latency fits the verification window. Because it
+     * changes WHICH offers come back, such a fetch neither reads nor writes the
+     * cache: a cached optimistic-mode set would leak unverifiable campaigns into a
+     * strict presentation, and caching the narrowed set would starve a later
+     * optimistic one. Matches iOS.
      */
-    fetchOffers(userAttributes: UserAttributes, useCache?: boolean, placementId?: string): Promise<{
+    fetchOffers(userAttributes: UserAttributes, useCache?: boolean, placementId?: string, maxPostbackTimeMs?: number): Promise<{
         offers: OfferModel[];
     }>;
     /**
      * Begin a new presentation session. `variantId` is the SDUI variant this
      * presentation renders — stamped onto every event the session emits — and
      * `useCase` is retained so the page-lifecycle flush can stamp it too.
+     *
+     * `presentationId` is the ATTEMPT's id, minted by the caller before the flow
+     * started, so the events emitted here carry the same id as the ones emitted
+     * before a presentation session existed at all. Minting one here when the caller
+     * has none keeps this class usable standalone; Encore.ts always passes one.
+     */
+    /**
+     * `presentationId` is optional and the caller almost never passes it. `show()` mints
+     * the id before its first gate, so a presentation that never reaches this method
+     * still has one to report under; passing it here is what keeps that early id and the
+     * presentation's own id the same value. Absent a caller-supplied one this still mints,
+     * which is the behaviour every non-`show()` entry point relies on.
+     */
+    beginPresentation(variantId?: string, useCase?: UseCase, placementId?: string, presentationId?: string): string;
+    /**
+     * The live presentation's placement label, or undefined when the publisher gave
+     * none. Exposed for the strict-unlock pending record, which has to persist the
+     * dimension at claim time because the presentation holding it is gone by the time a
+     * cross-session verification lands.
      */
-    beginPresentation(variantId?: string, useCase?: UseCase, placementId?: string): string;
+    get placementId(): string | undefined;
     /** The live presentation's id, or null between presentations. */
     get presentationId(): string | null;
     /**

package/types/core/OfferManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OfferManager.d.ts","sourceRoot":"","sources":["../../src/core/OfferManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAMpE,qBAAa,YAAY;;gBAkDX,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,eAAe;IAOnF;;OAEG;IACG,WAAW,CACf,cAAc,EAAE,cAAc,EAC9B,QAAQ,UAAO,EACf,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC;QAAE,MAAM,EAAE,UAAU,EAAE,CAAA;KAAE,CAAC;IAmCpC;;;;OAIG;IACH,iBAAiB,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM;IAatF,iEAAiE;IACjE,IAAI,cAAc,IAAI,MAAM,GAAG,IAAI,CAElC;IAiBD;;OAEG;IACH,mBAAmB,CACjB,KAAK,EAAE,UAAU,EACjB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,OAAO,GAChB,IAAI;IA8CP;;OAEG;IACH,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAQxC;;OAEG;IACH,iBAAiB,CACf,KAAK,EAAE,UAAU,EACjB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,OAAO,GAChB,IAAI;IAoBP;;OAEG;IACH,kBAAkB,CAChB,KAAK,EAAE,UAAU,EACjB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,aAAa,CAAC,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,OAAO,GAChB,IAAI;IAqBP;;OAEG;IACH,eAAe,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI;IA+FhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,qBAAqB,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI;IAwCjE,kEAAkE;IAClE,OAAO,IAAI,IAAI;IAKf;;OAEG;IACG,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAsB9E;;OAEG;IACH,UAAU,IAAI,IAAI;IAMlB;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;CAKhC"}
+{"version":3,"file":"OfferManager.d.ts","sourceRoot":"","sources":["../../src/core/OfferManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAMpE,qBAAa,YAAY;;gBAkDX,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,eAAe;IAOnF;;;;;;;;;OASG;IACG,WAAW,CACf,cAAc,EAAE,cAAc,EAC9B,QAAQ,UAAO,EACf,WAAW,CAAC,EAAE,MAAM,EACpB,iBAAiB,CAAC,EAAE,MAAM,GACzB,OAAO,CAAC;QAAE,MAAM,EAAE,UAAU,EAAE,CAAA;KAAE,CAAC;IA8CpC;;;;;;;;;OASG;IACH;;;;;;OAMG;IACH,iBAAiB,CACf,SAAS,CAAC,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,OAAO,EACjB,WAAW,CAAC,EAAE,MAAM,EACpB,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM;IAaT;;;;;OAKG;IACH,IAAI,WAAW,IAAI,MAAM,GAAG,SAAS,CAEpC;IAED,iEAAiE;IACjE,IAAI,cAAc,IAAI,MAAM,GAAG,IAAI,CAElC;IAiBD;;OAEG;IACH,mBAAmB,CACjB,KAAK,EAAE,UAAU,EACjB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,OAAO,GAChB,IAAI;IA8CP;;OAEG;IACH,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAQxC;;OAEG;IACH,iBAAiB,CACf,KAAK,EAAE,UAAU,EACjB,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,OAAO,GAChB,IAAI;IAoBP;;OAEG;IACH,kBAAkB,CAChB,KAAK,EAAE,UAAU,EACjB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,aAAa,CAAC,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,OAAO,GAChB,IAAI;IAqBP;;OAEG;IACH,eAAe,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI;IA+FhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,qBAAqB,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI;IAwCjE,kEAAkE;IAClE,OAAO,IAAI,IAAI;IAKf;;OAEG;IACG,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAsB9E;;OAEG;IACH,UAAU,IAAI,IAAI;IAMlB;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;CAKhC"}

package/types/core/PlacementBuilder.d.ts

@@ -2,16 +2,29 @@
  * Placement Builder
  * Fluent API for configuring and presenting offers
  */
-import type { PlacementBuilder as IPlacementBuilder, PlacementOptions, ShowResult, NotGrantedReason, UseCase } from '../types';
+import type { PlacementBuilder as IPlacementBuilder, PlacementOptions, RedeemResult, ShowResult, NotGrantedReason, UseCase } from '../types';
 export type PresentationExecutor = (options?: PlacementOptions) => Promise<ShowResult>;
+export type RedemptionExecutor = (placementId: string) => Promise<RedeemResult>;
 export declare class PlacementBuilder implements IPlacementBuilder {
     #private;
-    constructor(id: string, executor: PresentationExecutor, options?: PlacementOptions);
+    constructor(id: string, executor: PresentationExecutor, options: PlacementOptions | undefined, redeemer: RedemptionExecutor);
     /**
      * Set this placement's use case (default `'reduceChurn'`) — the same `.useCase(...)` step
      * the native SDKs expose, so a cross-platform integration reads the same here.
      */
     useCase(useCase: UseCase): PlacementBuilder;
+    /**
+     * Override the sheet's headline for this presentation — the same
+     * `.headline(...)` step the native SDKs expose.
+     *
+     * Identical in effect to passing `headline` in {@link PlacementOptions}: the
+     * per-call override beats the backend-resolved copy, which beats the built-in
+     * fallback. A blank or whitespace-only value falls THROUGH to the resolved copy
+     * rather than blanking the sheet, so it can never erase shipped copy.
+     */
+    headline(text: string): PlacementBuilder;
+    /** Counterpart to {@link headline}: same precedence, same blank-falls-through rule. */
+    subheadline(text: string): PlacementBuilder;
     /**
      * Set callback for when user declines or offer not granted
      */
@@ -27,5 +40,16 @@ export declare class PlacementBuilder implements IPlacementBuilder {
      * PlacementOptions, supplied to `placement()` or through the builder steps.
      */
     show(): Promise<ShowResult>;
+    /**
+     * Redeem the claim made at this placement — phase 2 of the deferred flow.
+     *
+     * The id passed on is the builder's own; whether that SCOPES the lookup is the
+     * redeemer's call, because only a publisher-set id has claims filed under it (a
+     * minted one never reaches the wire). See {@link IPlacementBuilder.redeem}.
+     *
+     * Errors are already values on the redeem path, so there is nothing to catch —
+     * unlike show(), which wraps a whole presentation.
+     */
+    redeem(): Promise<RedeemResult>;
 }
 //# sourceMappingURL=PlacementBuilder.d.ts.map

package/types/core/PlacementBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PlacementBuilder.d.ts","sourceRoot":"","sources":["../../src/core/PlacementBuilder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,gBAAgB,IAAI,iBAAiB,EACrC,gBAAgB,EAChB,UAAU,EACV,gBAAgB,EAChB,OAAO,EACR,MAAM,UAAU,CAAC;AAIlB,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,CAAC,EAAE,gBAAgB,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;AAEvF,qBAAa,gBAAiB,YAAW,iBAAiB;;gBAO5C,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,oBAAoB,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAMlF;;;OAGG;IACH,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,gBAAgB;IAK3C;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,GAAG,gBAAgB;IAK5E;;OAEG;IACH,oBAAoB,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,GAAG,gBAAgB;IAK9E;;;;;OAKG;IACG,IAAI,IAAI,OAAO,CAAC,UAAU,CAAC;CA6ClC"}
+{"version":3,"file":"PlacementBuilder.d.ts","sourceRoot":"","sources":["../../src/core/PlacementBuilder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,gBAAgB,IAAI,iBAAiB,EACrC,gBAAgB,EAChB,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,OAAO,EACR,MAAM,UAAU,CAAC;AAIlB,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,CAAC,EAAE,gBAAgB,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;AACvF,MAAM,MAAM,kBAAkB,GAAG,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;AAEhF,qBAAa,gBAAiB,YAAW,iBAAiB;;gBAatD,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,oBAAoB,EAC9B,OAAO,EAAE,gBAAgB,GAAG,SAAS,EACrC,QAAQ,EAAE,kBAAkB;IAQ9B;;;OAGG;IACH,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,gBAAgB;IAK3C;;;;;;;;OAQG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB;IAKxC,uFAAuF;IACvF,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB;IAK3C;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,GAAG,gBAAgB;IAK5E;;OAEG;IACH,oBAAoB,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,GAAG,gBAAgB;IAK9E;;;;;OAKG;IACG,IAAI,IAAI,OAAO,CAAC,UAAU,CAAC;IA8CjC;;;;;;;;;OASG;IACG,MAAM,IAAI,OAAO,CAAC,YAAY,CAAC;CAItC"}

package/types/core/StrictUnlock.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Strict-unlock mode constants.
+ *
+ * One source of truth so the verification poll window and the `maxPostbackTimeMs`
+ * offer filter cannot drift apart — the same reason iOS ties them together in
+ * `StrictUnlock.swift`: serving an offer whose postback SLA cannot plausibly land
+ * inside the window the poller is willing to wait guarantees a claim that never
+ * verifies in session.
+ */
+/** How long a verification poll waits before giving up. Mirrors iOS's 15s. */
+export declare const POLL_TIMEOUT_MS = 15000;
+/** Sent as `maxPostbackTimeMs` on `/offers/search` — strict mode only. */
+export declare const MAX_POSTBACK_TIME_MS = 15000;
+/**
+ * How long a pending claim is retried across sessions before it is dropped. Past
+ * this the campaign's postback window is long gone and the row will never verify.
+ * Mirrors iOS's `StrictUnlockReconciler.maxAge`.
+ */
+export declare const RECONCILE_MAX_AGE_MS: number;
+//# sourceMappingURL=StrictUnlock.d.ts.map

package/types/core/StrictUnlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrictUnlock.d.ts","sourceRoot":"","sources":["../../src/core/StrictUnlock.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,8EAA8E;AAC9E,eAAO,MAAM,eAAe,QAAS,CAAC;AAEtC,0EAA0E;AAC1E,eAAO,MAAM,oBAAoB,QAAkB,CAAC;AAEpD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAAuB,CAAC"}

package/types/core/StrictUnlockReconciler.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Strict Unlock Reconciler
+ *
+ * Owns the persistence and the poll primitive for a strict-mode claim awaiting
+ * advertiser verification. WHEN a pass runs (claim time, page load, foreground) is
+ * wired in Encore.ts — this class deliberately knows nothing about lifecycle, the
+ * same split iOS draws between `StrictUnlockReconciler` and its composition root.
+ *
+ * Persist-to-storage shape follows SignalManager's, applied to a single pending
+ * claim rather than a queue: only the MOST RECENT claim needs tracking, so a new
+ * notePending() simply overwrites — matching iOS, which keeps one pending id.
+ */
+import type { StorageManager } from './StorageManager';
+import type { APIClient } from '../api/APIClient';
+import type { UseCase, VerificationStatus } from '../types';
+export interface PendingClaim {
+    transactionId: string;
+    /** ISO 8601. */
+    recordedAt: string;
+    /**
+     * Whether verifying this claim should send the entitlement grant signal. Stored
+     * rather than recomputed because the reconcile pass runs on a page load that has
+     * no offer, no placement and no use case in scope — the claim's own record is the
+     * only thing that still knows. Absent on a record written before this field
+     * existed, and read as false: a missing grant is recoverable, an unearned one is
+     * not.
+     */
+    grantsEntitlement?: boolean;
+    /**
+     * The placement and use case the claim was made under, persisted for the same
+     * reason `grantsEntitlement` is: the sheet that knew them is gone by the time a
+     * cross-session verification lands, and the claim's own record is the only thing
+     * that still does.
+     *
+     * Without them the reconciled `sdk_offer_verified` is the ONE conversion signal
+     * that cannot be sliced — strict-mode verifications would sit outside every
+     * per-use-case and per-placement conversion split, which is precisely the
+     * comparison strict mode exists to be measured by. Mirrors iOS, which persists
+     * both beside the transaction id (swift#123, `StrictUnlockReconciler.notePending`).
+     *
+     * Both optional and both absent on a record written before this field existed.
+     * Absent stays absent on the event rather than being reconstructed — a guessed
+     * dimension is worse than a missing one, because it looks like coverage.
+     */
+    placementId?: string;
+    useCase?: UseCase;
+}
+export declare class StrictUnlockReconciler {
+    #private;
+    constructor(storage: StorageManager, apiClient: APIClient, userId: string);
+    /**
+     * Re-key onto a new identity, CARRYING the pending claim over.
+     *
+     * SignalManager, the sibling this class's persistence follows, drops its queue
+     * on the same event. This deliberately differs: identify() is an ALIAS on the
+     * backend (`identifyUser(previousUserId, userId)` — the anonymous id is merged
+     * into the real one, not replaced by a different person), so a claim made
+     * seconds earlier belongs to the very same user, and abandoning it would mean
+     * their unlock silently never lands. reset() is the destructive path, and it
+     * clears storage before this runs, so nothing carries over there.
+     */
+    setUserId(userId: string): void;
+    /**
+     * Record a claim as awaiting verification. Called as soon as the transaction id
+     * exists and BEFORE the advertiser redirect opens, so a tab closed one moment
+     * later is still recoverable on a later page load.
+     */
+    notePending(transactionId: string, options?: {
+        grantsEntitlement?: boolean;
+        placementId?: string;
+        useCase?: UseCase;
+    }): void;
+    /** Forget the pending claim — verified, dropped as stale, or malformed. */
+    clearPending(): void;
+    /**
+     * The pending claim, or null when there is none. A malformed record, an
+     * unusable id, or one older than {@link RECONCILE_MAX_AGE_MS} is DROPPED here
+     * rather than returned, so a bad record can never wedge the reconcile pass into
+     * re-reading it every foreground for a week.
+     *
+     * A `recordedAt` in the future is treated as unusable too: the clock it was
+     * written against is not the clock reading it (a device clock correction, a
+     * hand-edited value), and a negative age would otherwise never age out.
+     */
+    getPending(): PendingClaim | null;
+    /**
+     * Poll for verification, bounded by `timeoutMs` — defaulting to the shared
+     * {@link POLL_TIMEOUT_MS} so a claim-time poll and a reconcile-pass poll wait the
+     * same window unless a caller has a reason to differ. Never throws: a network
+     * failure reads as 'pending', i.e. try again next foreground.
+     */
+    verify(transactionId: string, timeoutMs?: number): Promise<VerificationStatus>;
+}
+//# sourceMappingURL=StrictUnlockReconciler.d.ts.map

package/types/core/StrictUnlockReconciler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrictUnlockReconciler.d.ts","sourceRoot":"","sources":["../../src/core/StrictUnlockReconciler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAIlD,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAa5D,MAAM,WAAW,YAAY;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;;;OAOG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;;;;;;;;;;;OAeG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,qBAAa,sBAAsB;;gBAKrB,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM;IAMzE;;;;;;;;;;OAUG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAQ/B;;;;OAIG;IACH,WAAW,CACT,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE;QAAE,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,GACjF,IAAI;IAgBP,2EAA2E;IAC3E,YAAY,IAAI,IAAI;IAKpB;;;;;;;;;OASG;IACH,UAAU,IAAI,YAAY,GAAG,IAAI;IAsCjC;;;;;OAKG;IACG,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,GAAE,MAAwB,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAiBtG"}

package/types/core/TransactionStore.d.ts

@@ -1,35 +1,79 @@
 /**
  * TransactionStore
  *
- * Local persistence for the two-phase (transaction -> redeem) flow. Backed by
- * StorageManager (localStorage-first), it holds:
- *  - transactions:     transactionId -> Transaction
- *  - placements: placementId -> transactionId  (the per-placement live-transaction map)
- *  - latest:     transactionId of the most recently created transaction
+ * Local record of claims awaiting redemption. Holds:
+ *  - transactions: transactionId -> Transaction
+ *  - placements:   placementId -> transactionId (the per-placement live-claim map)
+ *  - latest:       the most recently created transaction
  *
- * This is the fast path; the server transaction record (keyed by app_account_id, carrying
- * placementId) is the durable source of truth for cross-page / post-localStorage-loss
- * recovery. Expired or redeemed transactions are filtered out of the lookups.
+ * The BACKING is injected, and that is the whole of the difference between the two
+ * deferred behaviours: `deferred` writes through StorageManager and survives a
+ * reload; `deferredWhileAlive` writes to a plain object that dies with the page.
+ * Both then resolve, prune and expire identically — one implementation, so the
+ * session-scoped mode cannot quietly drift from the durable one.
+ *
+ * The server transaction record (keyed by app_account_id) remains the durable
+ * source of truth for cross-device recovery; this is the fast path.
+ *
+ * Expired and redeemed claims are filtered out of the RESOLVING lookups —
+ * `getLatest` and `getByPlacement`, the two that answer "what can be redeemed
+ * now". `getByTransactionId` deliberately does not filter: it answers "what is on
+ * record for this exact id", so it can report that a claim was redeemed.
+ *
+ * That report is not durable, and callers must not treat it as one: `#prune` drops
+ * redeemed and expired entries on the NEXT write, so a redeemed claim is readable
+ * only until then. The store is a cache of what is still actionable, not a ledger.
  */
 import type { Transaction } from '../types';
 import type { StorageManager } from './StorageManager';
+interface TransactionStoreState {
+    transactions: Record<string, Transaction>;
+    placements: Record<string, string>;
+    latest: string | null;
+}
+/** Where a store keeps its state. The only thing the two behaviours disagree on. */
+export interface TransactionBacking {
+    read(): TransactionStoreState | null;
+    write(state: TransactionStoreState): void;
+}
+/**
+ * A claim's creation time in ms, with an unparseable one pinned to 0 (oldest).
+ *
+ * Sorting on a raw `getTime()` puts NaN into the comparator, and a comparator that
+ * returns NaN makes the whole ordering implementation-defined — so ONE undateable
+ * record could change which claim is picked as "latest" among perfectly good ones.
+ * Deterministic beats correct-looking here: this store already defends against
+ * corrupted state, and the ordering has to be defended in the same breath.
+ */
+export declare function createdAtMs(transaction: {
+    createdAt: string;
+}): number;
+/** Durable: localStorage via StorageManager. Survives the page load. */
+export declare function persistentBacking(storage: StorageManager): TransactionBacking;
+/**
+ * Session-scoped: a closure. Deliberately touches NO storage API at all — not the
+ * key, not StorageManager — so `deferredWhileAlive` cannot leak a claim to disk
+ * through a shared code path.
+ */
+export declare function ephemeralBacking(): TransactionBacking;
 export declare class TransactionStore {
     #private;
-    constructor(storage: StorageManager);
+    constructor(backing: TransactionBacking);
     /** Persist a new transaction, updating the placement map and the latest pointer. */
     save(transaction: Transaction): void;
-    /** Resolve a transaction by exact transaction id (any status). */
+    /** Resolve a transaction by exact id (any status). */
     getByTransactionId(transactionId: string): Transaction | null;
     /**
-     * Resolve the LIVE transaction made at a placement. Returns null if none/expired/redeemed —
+     * The LIVE transaction claimed at a placement. Null if none/expired/redeemed —
      * never crosses to another placement's transaction.
      */
     getByPlacement(placementId: string): Transaction | null;
-    /** Resolve the single most-recent LIVE transaction for this user (the flat redeem() fallback). */
+    /** The single most-recent LIVE transaction (the flat redeem() fallback). */
     getLatest(): Transaction | null;
     /** Mark a transaction redeemed (idempotent). Frees its placement slot. */
     markRedeemed(transactionId: string): void;
-    /** Clear all transactions (used by reset()). */
+    /** Clear every transaction (reset()). */
     clear(): void;
 }
+export {};
 //# sourceMappingURL=TransactionStore.d.ts.map

package/types/core/TransactionStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransactionStore.d.ts","sourceRoot":"","sources":["../../src/core/TransactionStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAavD,qBAAa,gBAAgB;;gBAGf,OAAO,EAAE,cAAc;IAwBnC,oFAAoF;IACpF,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;IAepC,kEAAkE;IAClE,kBAAkB,CAAC,aAAa,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAI7D;;;OAGG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAQvD,kGAAkG;IAClG,SAAS,IAAI,WAAW,GAAG,IAAI;IAa/B,0EAA0E;IAC1E,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;IA8BzC,gDAAgD;IAChD,KAAK,IAAI,IAAI;CAGd"}
+{"version":3,"file":"TransactionStore.d.ts","sourceRoot":"","sources":["../../src/core/TransactionStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAKvD,UAAU,qBAAqB;IAC7B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAC1C,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED,oFAAoF;AACpF,MAAM,WAAW,kBAAkB;IACjC,IAAI,IAAI,qBAAqB,GAAG,IAAI,CAAC;IACrC,KAAK,CAAC,KAAK,EAAE,qBAAqB,GAAG,IAAI,CAAC;CAC3C;AAID;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,WAAW,EAAE;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAGtE;AA2BD,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,kBAAkB,CAK7E;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,kBAAkB,CAQrD;AAED,qBAAa,gBAAgB;;gBAGf,OAAO,EAAE,kBAAkB;IAwDvC,oFAAoF;IACpF,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;IAepC,sDAAsD;IACtD,kBAAkB,CAAC,aAAa,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAI7D;;;OAGG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAQvD,4EAA4E;IAC5E,SAAS,IAAI,WAAW,GAAG,IAAI;IAa/B,0EAA0E;IAC1E,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;IA2BzC,yCAAyC;IACzC,KAAK,IAAI,IAAI;CAGd"}

package/types/core/VerificationPoller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VerificationPoller.d.ts","sourceRoot":"","sources":["../../src/core/VerificationPoller.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAGnD,MAAM,WAAW,yBAAyB;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;CACxB;AAED,qBAAa,kBAAkB;;gBAUjB,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,yBAAyB;IAMpE;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAkBzC;;OAEG;IACH,IAAI,IAAI,IAAI;CAkFb"}
+{"version":3,"file":"VerificationPoller.d.ts","sourceRoot":"","sources":["../../src/core/VerificationPoller.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAInD,MAAM,WAAW,yBAAyB;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;CACxB;AAED,qBAAa,kBAAkB;;gBAYjB,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,yBAAyB;IAMpE;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAkBzC;;OAEG;IACH,IAAI,IAAI,IAAI;CAqGb"}

package/types/core/claimBehavior.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `claimBehavior` — what a claim does with the advertiser handoff.
+ *
+ * 🔴 NOT A PUBLISHER OPTION. This is data on the VARIANT, the same way the reward
+ * sheet's copy and button actions are: `RewardActions.ts` tracks its variant's
+ * actions by symbol because web has no SDUI engine, and this file tracks the
+ * variant's claim behaviour the same way. It is deliberately absent from
+ * `PlacementOptions` and from `configure()` — 2.0.1's `redemptionMode` was a
+ * config knob, and making zero-config behaviour depend on a knob is what let a
+ * default flip break every integration that never set one.
+ *
+ *   immediate           redirect inside the click gesture; nothing is persisted.
+ *   deferred            persist the claim, hold the primer, redirect from redeem()
+ *                       — which may run on a LATER PAGE LOAD.
+ *   deferredWhileAlive  hold the claim in memory for this session only; never
+ *                       touch storage. Gone on reload, by design.
+ *
+ * The defaults below are the built-in variants' values and restore pre-2.0.2
+ * zero-config behaviour: `reduceChurn` is deferred (the host runs its own
+ * conversion, then redeems), `rewardUsers` is immediate (matching swift).
+ */
+import type { UseCase } from '../types';
+export type ClaimBehavior = 'immediate' | 'deferred' | 'deferredWhileAlive';
+/** Whether a behaviour keeps the claim past the click — i.e. redeem() has work. */
+export declare function isDeferred(behavior: ClaimBehavior): boolean;
+/** The behaviour for a presentation: the variant's value, else the built-in default. */
+export declare function claimBehaviorFor(useCase: UseCase, variantValues?: unknown): ClaimBehavior;
+//# sourceMappingURL=claimBehavior.d.ts.map

package/types/core/claimBehavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claimBehavior.d.ts","sourceRoot":"","sources":["../../src/core/claimBehavior.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAExC,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,UAAU,GAAG,oBAAoB,CAAC;AAE5E,mFAAmF;AACnF,wBAAgB,UAAU,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAE3D;AAmCD,wFAAwF;AACxF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,CAAC,EAAE,OAAO,GAAG,aAAa,CAEzF"}

package/types/core/errorContext.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Where an error happened, as the backend's error-reporting taxonomy.
+ *
+ * The eleven values are copied verbatim from the Swift and Android SDKs. The
+ * backend fingerprints an issue as `[errorType, context]`, so a value invented
+ * here would split one cross-platform defect into a separate issue per
+ * platform instead of grouping it.
+ *
+ * Before this, web sent free prose ('Show flow error', 'Offer flow error'),
+ * which fingerprinted against nothing the other two SDKs emit.
+ *
+ * Deliberately not exported from `index.ts`: it is an internal wire vocabulary,
+ * not something a publisher passes in. Add a value here only together with the
+ * same value in Swift and Android.
+ */
+export declare const ERROR_CONTEXTS: readonly ["configuration", "present_offer_initialization", "fetch_offer_data", "start_transaction", "log_impression", "fetch_entitlements", "verify_transaction", "grant_signal", "api_request", "outbox", "analytics"];
+export type ErrorContext = (typeof ERROR_CONTEXTS)[number];
+//# sourceMappingURL=errorContext.d.ts.map

package/types/core/errorContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorContext.d.ts","sourceRoot":"","sources":["../../src/core/errorContext.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,yNAYjB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/types/core/errorType.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The `errorType` half of the error-report fingerprint.
+ *
+ * The backend groups a Sentry issue by `[errorType, context]`, so this value
+ * has to mean the same thing on every SDK. Swift and Android both emit it from
+ * a sealed `EncoreError` hierarchy via `typeIdentifier`. web reported
+ * `error.constructor.name` instead, which is `"Error"` for essentially
+ * everything, so web errors grouped by `context` alone and could never join
+ * their iOS and Android counterparts.
+ *
+ * What was missing was never a taxonomy. web already has `ErrorCode`, and
+ * `APIClient` already attaches it to the errors it throws. This maps that
+ * existing structure onto the shared wire vocabulary.
+ *
+ * Deliberately NOT a rewrite into a sealed hierarchy. That is still worth doing
+ * (it would make the type intrinsic to the error rather than derived at the
+ * boundary, so a throw from outside `APIClient` would carry it too), and it
+ * remains its own ticket. This closes the fingerprint gap without waiting for
+ * it.
+ */
+/**
+ * The wire vocabulary, identical to Swift's and Android's `typeIdentifier`.
+ * A value invented here would split one defect into a separate issue per
+ * platform, which is the whole thing this exists to prevent.
+ */
+export declare const ERROR_TYPES: readonly ["network_error", "persistence_error", "http_error", "api_error", "decoding_error", "not_configured", "invalid_api_key", "invalid_url", "domain_error"];
+export type ErrorTypeIdentifier = (typeof ERROR_TYPES)[number];
+/**
+ * The server's own error code and status, for a report's metadata.
+ *
+ * Grouping is canonical across platforms; this is how the detail survives that.
+ * A backend `UNAUTHORIZED` and a backend `OFFER_EXPIRED` both group as
+ * `api_error`, and stay distinguishable by this field in Cloud Logging, or as
+ * an indexed tag if the backend ever promotes it.
+ */
+export declare function serverDetailOf(error: unknown): Record<string, string>;
+/**
+ * Deliberately NOT mapped, and this is the subtle half.
+ *
+ * `UNAUTHORIZED` and `NOT_FOUND` arrive as `data.code` in a server error body,
+ * so they describe the SERVER's verdict, not a client-side condition. Swift and
+ * Android turn any intelligible server rejection into `api_error`, and reserve
+ * `invalid_api_key` for their own client-side key validation. Mapping them here
+ * made the same backend 401 fingerprint as `[invalid_api_key, api_request]` on
+ * web and `[api_error, api_request]` on mobile, which is precisely the split
+ * this vocabulary exists to prevent.
+ *
+ * They fall through to `api_error`. The server's own code is not lost: it is
+ * echoed into the report as `serverCode`, where it segments without changing
+ * how anything groups.
+ */
+/**
+ * Resolves an unknown caught value to a shared `errorType`.
+ *
+ * Total by construction: anything unrecognised is `domain_error`, matching how
+ * Swift and Android wrap a foreign throwable. Reporting must never throw.
+ */
+export declare function errorTypeOf(error: unknown): ErrorTypeIdentifier;
+//# sourceMappingURL=errorType.d.ts.map

package/types/core/errorType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorType.d.ts","sourceRoot":"","sources":["../../src/core/errorType.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH;;;;GAIG;AACH,eAAO,MAAM,WAAW,kKAUd,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAyB/D;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWrE;AAED;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,mBAAmB,CA8B/D"}

package/types/core/hostDisplay.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Host display nouns + the deferred flow's composed copy.
+ *
+ * The nouns name the PUBLISHER's product (the host), as distinct from the
+ * advertiser on the offer. They are resolved fresh at each screen from the
+ * then-current remote config — nothing about them is persisted on a transaction,
+ * which stores transactional facts only.
+ *
+ * Everything the primer and redemption screens say is composed here. The screens
+ * never concatenate nouns themselves, so one sentence has one source.
+ *
+ * Absent nouns are NEVER an error. 2.0.1 failed the whole presentation with a
+ * CONFIGURATION_ERROR when the app icon was unset; an SDK that refuses to present
+ * because a logo is missing is worse than one that presents a quieter sentence.
+ * The screens degrade instead — see PrimerScreen's 'holding' variant.
+ */
+export interface HostDisplay {
+    appDisplayName?: string;
+    /** Composed, display-only, e.g. "1 month". Never parsed back into a number. */
+    trialPeriod?: string;
+    logoUrl?: string;
+}
+/** The remote values the nouns resolve from. All optional — the fetch may not have landed. */
+export interface RemoteHostSource {
+    appName?: string;
+    entitlementValue?: string;
+    entitlementUnit?: string;
+    /** `/config` `ui.values.media.appstoreIcon`. */
+    appIconUrl?: string;
+    /** `entitlements.native.durationDays` — the trial-end line's only input. */
+    trialDurationDays?: number;
+}
+/** Resolve the host nouns. Every field independently optional. */
+export declare function resolveHostDisplay(source: RemoteHostSource): HostDisplay;
+/** The deferred flow's sentences, each with exactly one definition. */
+export declare const displayCopy: {
+    readonly primerTitle: (app: string, trial?: string) => string;
+    readonly primerSubtitle: (app: string) => string;
+    readonly primerCta: (app: string, trial?: string) => string;
+    /** The holding story: the host is unnamed, so the sentence is about the reward. */
+    readonly holdingTitle: () => string;
+    readonly holdingSubtitle: (advertiser?: string) => string;
+    readonly holdingCta: () => string;
+    readonly s2Title: (app: string, trial?: string) => string;
+    readonly s2Subtitle: (app: string) => string;
+    /** Host-row detail composed from the remote durationDays and the redemption moment. */
+    readonly s2HostDetail: (trialEnd: Date) => string;
+    readonly s2Cta: () => string;
+};
+//# sourceMappingURL=hostDisplay.d.ts.map

package/types/core/hostDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostDisplay.d.ts","sourceRoot":"","sources":["../../src/core/hostDisplay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,WAAW,WAAW;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+EAA+E;IAC/E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,8FAA8F;AAC9F,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gDAAgD;IAChD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4EAA4E;IAC5E,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AA+BD,kEAAkE;AAClE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,gBAAgB,GAAG,WAAW,CASxE;AAED,uEAAuE;AACvE,eAAO,MAAM,WAAW;gCACH,MAAM,UAAU,MAAM,KAAG,MAAM;mCAE5B,MAAM,KAAG,MAAM;8BAEpB,MAAM,UAAU,MAAM,KAAG,MAAM;IAEhD,mFAAmF;iCACjE,MAAM;4CACO,MAAM,KAAG,MAAM;+BAI9B,MAAM;4BACP,MAAM,UAAU,MAAM,KAAG,MAAM;+BAI5B,MAAM,KAAG,MAAM;IACjC,uFAAuF;sCAC9D,IAAI,KAAG,MAAM;0BAM3B,MAAM;CACT,CAAC"}

package/types/core/useCase.d.ts

@@ -58,5 +58,26 @@ export declare function fromWireUseCase(wire: string | null | undefined): UseCas
  * resolved from the config response's `useCases` map at show()-time and fails closed
  * as `no_template`, not `INVALID_REQUEST`.
  */
+/** Whether `value` is one of the recognised use cases. The allow-list, as a guard. */
+export declare function isSupportedUseCase(value: unknown): value is UseCase;
+/**
+ * The use case to REPORT for an attempt, given whatever the caller passed.
+ *
+ * `sdk_show_entered` is emitted at the very top of `show()`, above `checkUseCase`, so
+ * it is the one event that can see a value validation has not yet rejected. Its
+ * `use_case` feeds a closed cross-SDK enum dimension, and web must not be the SDK that
+ * widens it with a publisher's typo: a free-text value there does not error, it just
+ * creates a junk partition alongside the real ones in every per-use-case rollup.
+ *
+ * So an unrecognised value reports as the default, exactly as an omitted one does. The
+ * attempt is going to abort a few lines later either way, and the integration error is
+ * already reported through `onError`, the logger and `#reportError` — three channels
+ * that name the bad value, which the analytics dimension deliberately does not.
+ *
+ * Not a substitute for `checkUseCase`: this decides what to REPORT, that decides
+ * whether to PROCEED. Using this one to gate would silently serve the paywall for a
+ * typo, which is the exact fail-open `checkUseCase` exists to prevent.
+ */
+export declare function reportableUseCase(value: unknown): UseCase;
 export declare function checkUseCase(value: unknown): EncoreError | null;
 //# sourceMappingURL=useCase.d.ts.map

package/types/core/useCase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCase.d.ts","sourceRoot":"","sources":["../../src/core/useCase.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAa,KAAK,WAAW,EAAE,KAAK,OAAO,EAAE,MAAM,UAAU,CAAC;AAErE;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,oBAAoB,GAAG,oBAAoB,CAAC;AAuBtE,8EAA8E;AAC9E,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,CAE3D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAGpF;AAOD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI,CAS/D"}
+{"version":3,"file":"useCase.d.ts","sourceRoot":"","sources":["../../src/core/useCase.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAa,KAAK,WAAW,EAAE,KAAK,OAAO,EAAE,MAAM,UAAU,CAAC;AAErE;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,oBAAoB,GAAG,oBAAoB,CAAC;AAuBtE,8EAA8E;AAC9E,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,CAE3D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAGpF;AAOD;;;;;;;;;;;;;;;;;GAiBG;AACH,sFAAsF;AACtF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAEnE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEzD;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI,CAS/D"}

package/types/core/version.d.ts

@@ -1,3 +1,3 @@
 /** SDK version — single source of truth (also kept in sync with package.json via scripts/update-version.sh) */
-export declare const SDK_VERSION = "2.0.3";
+export declare const SDK_VERSION = "2.0.6";
 //# sourceMappingURL=version.d.ts.map

package/types/experiments/ExposureOutbox.d.ts

@@ -2,36 +2,12 @@
  * Reliable delivery for the NCL exposure event — the A/B denominator.
  *
  * Exposure MUST survive tab-close, so unlike the fire-and-forget AnalyticsClient
- * this path is storage-backed and retried.
- *
- * Delivery primitive: `fetch(url, { keepalive: true })` — NOT `navigator.sendBeacon`.
- * The ingest endpoint authenticates on the `X-Analytics-Key` request header, and
- * sendBeacon cannot set headers (a beacon would arrive unauthenticated). keepalive
- * fetch survives document unload like a beacon AND carries the auth header.
- *
- * Reliability model:
- *   - enqueue: persist the envelope, then keepalive-POST; remove on 2xx.
- *   - flush:   replay every persisted envelope (on SDK init + on pagehide /
- *              visibilitychange:hidden) so a send that died with the tab retries.
- *   - envelopes carry a STABLE event_id → retries are idempotent backend-side.
- *   - an in-memory in-flight set avoids duplicate concurrent sends.
- *   - all storage / window / document access is SSR- and failure-guarded (fail-open).
+ * this path is storage-backed and retried. See `ReliableOutbox` for the shared
+ * mechanism (keepalive fetch, persist-then-send, lifecycle-triggered flush).
  */
-import type { AnalyticsEvent } from '../analytics/models';
+import { ReliableOutbox } from '../analytics/ReliableOutbox';
 import type { StorageManager } from '../core/StorageManager';
-export declare class ExposureOutbox {
-    #private;
+export declare class ExposureOutbox extends ReliableOutbox {
     constructor(apiKey: string, analyticsBaseURL: string, storage: StorageManager);
-    /**
-     * Persist an exposure event and attempt delivery. `eventId` must be stable for a
-     * given (user, epoch) so retries de-duplicate backend-side. Returns whether the
-     * envelope durably landed in the configured storage tier: a quota-driven
-     * fallback-to-memory write is invisible to a fresh read, so the caller can avoid
-     * marking the epoch logged (and re-enqueue on the next trigger) instead of
-     * silently dropping the exposure.
-     */
-    enqueue(event: AnalyticsEvent, eventId: string): boolean;
-    /** Replay every persisted envelope (init recovery + unload flush). */
-    flush(): void;
 }
 //# sourceMappingURL=ExposureOutbox.d.ts.map

package/types/experiments/ExposureOutbox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ExposureOutbox.d.ts","sourceRoot":"","sources":["../../src/experiments/ExposureOutbox.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,qBAAqB,CAAC;AAEzE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAK7D,qBAAa,cAAc;;gBAMb,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc;IAO7E;;;;;;;OAOG;IACH,OAAO,CAAC,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO;IAaxD,sEAAsE;IACtE,KAAK,IAAI,IAAI;CAoDd"}
+{"version":3,"file":"ExposureOutbox.d.ts","sourceRoot":"","sources":["../../src/experiments/ExposureOutbox.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAI7D,qBAAa,cAAe,SAAQ,cAAc;gBACpC,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc;CAG9E"}