@namiml/sdk-core 3.4.1-dev.202605280043 → 3.4.1-dev.202605300006

package/dist/index.cjs

@@ -98,7 +98,7 @@ const {
 // version — stamped by scripts/version.sh
 NAMI_SDK_VERSION: exports.NAMI_SDK_VERSION = "3.4.1", 
 // full package version including dev suffix — stamped by scripts/version.sh
-NAMI_SDK_PACKAGE_VERSION: exports.NAMI_SDK_PACKAGE_VERSION = "3.4.1-dev.202605280043", 
+NAMI_SDK_PACKAGE_VERSION: exports.NAMI_SDK_PACKAGE_VERSION = "3.4.1-dev.202605300006", 
 // environments
 PRODUCTION: exports.PRODUCTION = "production", DEVELOPMENT: exports.DEVELOPMENT = "development", 
 // error messages
@@ -7041,6 +7041,10 @@ exports.NamiCampaignRuleType = void 0;
     NamiCampaignRuleType["UNKNOWN"] = "unknown";
     NamiCampaignRuleType["URL"] = "url";
 })(exports.NamiCampaignRuleType || (exports.NamiCampaignRuleType = {}));
+// NamiCampaignManagerStatic interface + const proxy live in
+// `src/managers/campaign.ts`. They must stay out of this file: PaywallState
+// type-imports from here, and pulling in the manager class triggers a
+// constructor chain that runs before PaywallState finishes loading. See NAM-1207.
 
 /**
  * Get initial paywalls from storage service.
@@ -8677,12 +8681,12 @@ SessionService.instance = new SessionService();
  * @class NamiPurchaseManager
  * Provides methods for managing all aspects of a purchase in the Nami SDK.
  */
-class NamiPurchaseManager {
+let NamiPurchaseManager$2 = class NamiPurchaseManager {
     static allPurchases() {
         return [];
     }
-}
-NamiPurchaseManager.instance = new NamiPurchaseManager();
+};
+NamiPurchaseManager$2.instance = new NamiPurchaseManager$2();
 
 var en = {
 	nami_day: "day",
@@ -11741,7 +11745,7 @@ const createNamiEntitlements = (entitlements) => {
     const namiEntitlements = activeEntitlements();
     if (!entitlements)
         return namiEntitlements;
-    NamiPurchaseManager.allPurchases().forEach((namiPurchase) => {
+    NamiPurchaseManager$2.allPurchases().forEach((namiPurchase) => {
         applyEntitlementActivation(namiPurchase);
     });
     const entitlementsToSkus = skuMapFromEntitlements(entitlements);
@@ -12222,7 +12226,7 @@ function isEqual(objA, objB) {
     return isEqual$1(normA, normB);
 }
 
-class NamiProfileManager {
+let NamiProfileManager$1 = class NamiProfileManager {
     constructor() {
         this.load();
     }
@@ -12295,8 +12299,8 @@ class NamiProfileManager {
         this.logoutLocal();
         await this.logoutRemote();
     }
-}
-NamiProfileManager.instance = new NamiProfileManager();
+};
+NamiProfileManager$1.instance = new NamiProfileManager$1();
 
 var _Nami_isInitialized;
 // NamiFlowManager is intentionally NOT imported at top level — it
@@ -12334,13 +12338,13 @@ class Nami {
         __classPrivateFieldSet(Nami.instance, _Nami_isInitialized, false, "f");
         // In-memory singleton state that previously survived reset and
         // bled into the next configure() cycle.
-        NamiProfileManager.instance.setExternalId(undefined);
+        NamiProfileManager$1.instance.setExternalId(undefined);
         PaywallState.reset();
         NamiAPI.reset();
         CampaignRuleRepository.instance.reset();
         // Lazy import to avoid a load-order cycle (NamiFlowManager imports
         // back to this module for `Nami.instance.maxLogging`).
-        const { NamiFlowManager } = await Promise.resolve().then(function () { return NamiFlowManager$1; });
+        const { NamiFlowManager } = await Promise.resolve().then(function () { return NamiFlowManager$3; });
         NamiFlowManager.reset();
         // Give platform adapters a chance to drop their own state
         // (e.g. Expo's UI adapter holds listener refs from PaywallView).
@@ -12447,20 +12451,6 @@ class Nami {
 _Nami_isInitialized = new WeakMap();
 Nami.instance = new Nami();
 
-exports.LaunchCampaignError = void 0;
-(function (LaunchCampaignError) {
-    LaunchCampaignError["DEFAULT_CAMPAIGN_NOT_FOUND"] = "Default campaign not found";
-    LaunchCampaignError["LABELED_CAMPAIGN_NOT_FOUND"] = "Labeled campaign not found";
-    LaunchCampaignError["CAMPAIGN_DATA_NOT_FOUND"] = "Campaign data not found";
-    LaunchCampaignError["PAYWALL_ALREADY_DISPLAYED"] = "Paywall is already being displayed";
-    LaunchCampaignError["SDK_NOT_INITIALIZED"] = "SDK has not been initialized";
-    LaunchCampaignError["PAYWALL_COULD_NOT_DISPLAY"] = "Failed to display paywall";
-    LaunchCampaignError["URL_CAMPAIGN_NOT_FOUND"] = "URL campaign not found";
-    LaunchCampaignError["PRODUCT_DATA_NOT_FOUND"] = "Product data not found";
-    LaunchCampaignError["PRODUCT_GROUPS_NOT_FOUND"] = "Product groups not found";
-    LaunchCampaignError["FLOW_SCREEN_DATA_UNAVILABLE"] = "Flow unavailable due to missing screen data";
-})(exports.LaunchCampaignError || (exports.LaunchCampaignError = {}));
-
 const VALID_STYLES = new Set(['fullscreen', 'sheet', 'compact_sheet', 'modal']);
 function getEffectiveWebStyle(style) {
     if (!style || !VALID_STYLES.has(style))
@@ -12512,6 +12502,20 @@ exports.NamiPaywallAction = void 0;
     NamiPaywallAction["UNKNOWN"] = "UNKNOWN";
 })(exports.NamiPaywallAction || (exports.NamiPaywallAction = {}));
 
+exports.LaunchCampaignError = void 0;
+(function (LaunchCampaignError) {
+    LaunchCampaignError["DEFAULT_CAMPAIGN_NOT_FOUND"] = "Default campaign not found";
+    LaunchCampaignError["LABELED_CAMPAIGN_NOT_FOUND"] = "Labeled campaign not found";
+    LaunchCampaignError["CAMPAIGN_DATA_NOT_FOUND"] = "Campaign data not found";
+    LaunchCampaignError["PAYWALL_ALREADY_DISPLAYED"] = "Paywall is already being displayed";
+    LaunchCampaignError["SDK_NOT_INITIALIZED"] = "SDK has not been initialized";
+    LaunchCampaignError["PAYWALL_COULD_NOT_DISPLAY"] = "Failed to display paywall";
+    LaunchCampaignError["URL_CAMPAIGN_NOT_FOUND"] = "URL campaign not found";
+    LaunchCampaignError["PRODUCT_DATA_NOT_FOUND"] = "Product data not found";
+    LaunchCampaignError["PRODUCT_GROUPS_NOT_FOUND"] = "Product groups not found";
+    LaunchCampaignError["FLOW_SCREEN_DATA_UNAVILABLE"] = "Flow unavailable due to missing screen data";
+})(exports.LaunchCampaignError || (exports.LaunchCampaignError = {}));
+
 const NamiFlowStepType = {
     ENTRY: 'entry',
     SCREEN: 'screen',
@@ -13255,7 +13259,7 @@ exports.AccountStateAction = void 0;
     AccountStateAction["NAMI_DEVICE_ID_CLEARED"] = "nami_device_id_cleared";
 })(exports.AccountStateAction || (exports.AccountStateAction = {}));
 
-class NamiFlowManager {
+let NamiFlowManager$2 = class NamiFlowManager {
     static get instance() {
         if (!NamiFlowManager._instance) {
             NamiFlowManager._instance = new NamiFlowManager();
@@ -13284,11 +13288,50 @@ class NamiFlowManager {
         i.lastAnimatedFlowProgress = new Map();
         i.navGraphCache = new WeakMap();
     }
+    /**
+     * Registers a handoff step handler and returns an unsubscribe callback.
+     *
+     * The returned callback clears the registered handler only if it is still
+     * the active one (identity-check guard). This protects against React 18
+     * StrictMode dev-mode double-mount where a stale unsubscribe from the
+     * first effect could fire after a second effect has already registered.
+     *
+     * Passing `undefined` clears the current handler immediately (preserved
+     * for backward compatibility with the 3.3.x escape hatch). The returned
+     * callback in that case is a no-op identity-check that will never fire.
+     *
+     * Aligns with the rest of the SDK's register*Handler family: all
+     * NamiPaywallManager / NamiCampaignManager / NamiCustomerManager handler
+     * registration methods return `Callback`. See NAM-1219.
+     */
     static registerStepHandoff(handoffStepHandler) {
         this.instance.handoffStepHandler = handoffStepHandler;
+        const captured = handoffStepHandler;
+        return () => {
+            if (this.instance.handoffStepHandler === captured) {
+                this.instance.handoffStepHandler = undefined;
+            }
+        };
     }
+    /**
+     * Registers an event handler and returns an unsubscribe callback.
+     *
+     * The returned callback clears the registered handler only if it is still
+     * the active one (identity-check guard). See `registerStepHandoff` for the
+     * full rationale.
+     *
+     * Passing `undefined` clears the current handler immediately.
+     *
+     * See NAM-1219.
+     */
     static registerEventHandler(eventHandler) {
         this.instance.eventHandler = eventHandler;
+        const captured = eventHandler;
+        return () => {
+            if (this.instance.eventHandler === captured) {
+                this.instance.eventHandler = undefined;
+            }
+        };
     }
     static resume() {
         const { flowOpen, currentFlow } = NamiFlowManager.instance;
@@ -13565,11 +13608,11 @@ class NamiFlowManager {
     static getCurrentFlowStepAutoAdvanceDelay() {
         return this.instance.getCurrentFlowStepAutoAdvanceDelay();
     }
-}
+};
 
-var NamiFlowManager$1 = /*#__PURE__*/Object.freeze({
+var NamiFlowManager$3 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    NamiFlowManager: NamiFlowManager
+    NamiFlowManager: NamiFlowManager$2
 });
 
 const SHOULD_SHOW_LOADING_INDICATOR = false;
@@ -13591,7 +13634,7 @@ const isAsyncLoginLogoutDisabled = () => {
  * @class NamiCustomerManager
  * Provides methods for managing customer-related functionality.
  */
-class NamiCustomerManager {
+let NamiCustomerManager$2 = class NamiCustomerManager {
     constructor() {
         this.emitter = NamiEventEmitter.getInstance();
         NamiConditionEvaluator.shared.registerNamespaceResolver("UserTags", (identifier) => {
@@ -13618,7 +13661,7 @@ class NamiCustomerManager {
      * @returns {boolean} Returns true if the customer is logged in, false otherwise.
      */
     static isLoggedIn() {
-        return NamiProfileManager.instance.isLoggedIn();
+        return NamiProfileManager$1.instance.isLoggedIn();
     }
     /**
      * Returns the external ID of the currently logged in user.
@@ -13629,7 +13672,7 @@ class NamiCustomerManager {
         if (!this.instance.isSDKInitialized) {
             logger.debug(exports.SDK_NOT_INITIALIZED);
         }
-        return NamiProfileManager.instance.getExternalId();
+        return NamiProfileManager$1.instance.getExternalId();
     }
     /**
      * Logs in a customer with the specified ID.
@@ -13652,10 +13695,10 @@ class NamiCustomerManager {
             // Default sync/fast path: update local state, notify handlers, and fire
             // lifecycle immediately. Dispatch the underlying API call and entitlement
             // refresh fire-and-forget — failures are logged but do not surface.
-            NamiProfileManager.instance.loginLocal(externalId);
+            NamiProfileManager$1.instance.loginLocal(externalId);
             this.invokeStateHandler(exports.AccountStateAction.LOGIN, true);
-            if (NamiFlowManager.instance.flowOpen) {
-                const currentFlow = NamiFlowManager.instance.currentFlow;
+            if (NamiFlowManager$2.instance.flowOpen) {
+                const currentFlow = NamiFlowManager$2.instance.currentFlow;
                 const currentStep = currentFlow?.currentFlowStep;
                 if (currentStep) {
                     if (Nami.instance.maxLogging) {
@@ -13664,7 +13707,7 @@ class NamiCustomerManager {
                     currentFlow.executeLifecycle(currentStep, NamiReservedActions.LOGIN_SUCCESS);
                 }
             }
-            void NamiProfileManager.instance.loginRemote(externalId).catch((err) => {
+            void NamiProfileManager$1.instance.loginRemote(externalId).catch((err) => {
                 logger.error('[NamiCustomerManager] async login API failed', err);
             });
             void EntitlementRepository.instance.fetchActiveEntitlements().catch((err) => {
@@ -13673,11 +13716,11 @@ class NamiCustomerManager {
             return;
         }
         try {
-            await NamiProfileManager.instance.login(externalId);
+            await NamiProfileManager$1.instance.login(externalId);
             await EntitlementRepository.instance.fetchActiveEntitlements();
             this.invokeStateHandler(exports.AccountStateAction.LOGIN, true);
-            if (NamiFlowManager.instance.flowOpen) {
-                const currentFlow = NamiFlowManager.instance.currentFlow;
+            if (NamiFlowManager$2.instance.flowOpen) {
+                const currentFlow = NamiFlowManager$2.instance.currentFlow;
                 const currentStep = currentFlow?.currentFlowStep;
                 if (currentStep) {
                     if (Nami.instance.maxLogging) {
@@ -13689,8 +13732,8 @@ class NamiCustomerManager {
         }
         catch (error) {
             this.invokeStateHandler(exports.AccountStateAction.LOGIN, false, error);
-            if (NamiFlowManager.instance.flowOpen) {
-                const currentFlow = NamiFlowManager.instance.currentFlow;
+            if (NamiFlowManager$2.instance.flowOpen) {
+                const currentFlow = NamiFlowManager$2.instance.currentFlow;
                 const currentStep = currentFlow?.currentFlowStep;
                 if (currentStep) {
                     if (Nami.instance.maxLogging) {
@@ -13721,10 +13764,10 @@ class NamiCustomerManager {
             // Default sync/fast path: clear local state, notify handlers, and fire
             // lifecycle immediately. Dispatch the underlying API call and entitlement
             // refresh fire-and-forget — failures are logged but do not surface.
-            NamiProfileManager.instance.logoutLocal();
+            NamiProfileManager$1.instance.logoutLocal();
             this.invokeStateHandler(exports.AccountStateAction.LOGOUT, true);
-            if (NamiFlowManager.instance.flowOpen) {
-                const currentFlow = NamiFlowManager.instance.currentFlow;
+            if (NamiFlowManager$2.instance.flowOpen) {
+                const currentFlow = NamiFlowManager$2.instance.currentFlow;
                 const currentStep = currentFlow?.currentFlowStep;
                 if (currentStep) {
                     if (Nami.instance.maxLogging) {
@@ -13733,7 +13776,7 @@ class NamiCustomerManager {
                     currentFlow.executeLifecycle(currentStep, NamiReservedActions.LOGOUT_SUCCESS);
                 }
             }
-            void NamiProfileManager.instance.logoutRemote().catch((err) => {
+            void NamiProfileManager$1.instance.logoutRemote().catch((err) => {
                 logger.error('[NamiCustomerManager] async logout API failed', err);
             });
             void EntitlementRepository.instance.fetchActiveEntitlements().catch((err) => {
@@ -13742,11 +13785,11 @@ class NamiCustomerManager {
             return;
         }
         try {
-            await NamiProfileManager.instance.logout();
+            await NamiProfileManager$1.instance.logout();
             await EntitlementRepository.instance.fetchActiveEntitlements();
             this.invokeStateHandler(exports.AccountStateAction.LOGOUT, true);
-            if (NamiFlowManager.instance.flowOpen) {
-                const currentFlow = NamiFlowManager.instance.currentFlow;
+            if (NamiFlowManager$2.instance.flowOpen) {
+                const currentFlow = NamiFlowManager$2.instance.currentFlow;
                 const currentStep = currentFlow?.currentFlowStep;
                 if (currentStep) {
                     currentFlow.executeLifecycle(currentStep, NamiReservedActions.LOGOUT_SUCCESS);
@@ -13755,8 +13798,8 @@ class NamiCustomerManager {
         }
         catch (error) {
             this.invokeStateHandler(exports.AccountStateAction.LOGOUT, false, error);
-            if (NamiFlowManager.instance.flowOpen) {
-                const currentFlow = NamiFlowManager.instance.currentFlow;
+            if (NamiFlowManager$2.instance.flowOpen) {
+                const currentFlow = NamiFlowManager$2.instance.currentFlow;
                 const currentStep = currentFlow?.currentFlowStep;
                 if (currentStep) {
                     currentFlow.executeLifecycle(currentStep, NamiReservedActions.LOGOUT_FAILURE);
@@ -13865,8 +13908,8 @@ class NamiCustomerManager {
             PaywallState.setCustomerAttribute({ [key]: value });
             logger.debug(`This customer attribute you set is now available for paywall personalization using the smart text variable: ${key}`);
         }
-        if (NamiFlowManager.instance.flowOpen) {
-            const currentFlow = NamiFlowManager.instance.currentFlow;
+        if (NamiFlowManager$2.instance.flowOpen) {
+            const currentFlow = NamiFlowManager$2.instance.currentFlow;
             if (currentFlow) {
                 const currentStep = currentFlow.currentFlowStep;
                 if (currentStep) {
@@ -14040,8 +14083,8 @@ class NamiCustomerManager {
             ]);
         }
     }
-}
-NamiCustomerManager.instance = new NamiCustomerManager();
+};
+NamiCustomerManager$2.instance = new NamiCustomerManager$2();
 
 class BasicNamiFlow {
     constructor(flowObject = {}) {
@@ -14478,7 +14521,7 @@ class NamiFlow extends BasicNamiFlow {
                     if (action.parameters) {
                         PaywallState.setUserTags(action.parameters);
                         Object.entries(action.parameters).forEach(([key, value]) => {
-                            NamiCustomerManager.setCustomerAttribute(key, value);
+                            NamiCustomerManager$2.setCustomerAttribute(key, value);
                         });
                     }
                     break;
@@ -14625,7 +14668,7 @@ class NamiFlow extends BasicNamiFlow {
  * @class NamiCampaignManager
  * Provides methods for managing all aspects of a campaign.
  */
-class NamiCampaignManager {
+let NamiCampaignManager$2 = class NamiCampaignManager {
     constructor() {
         this.emitter = NamiEventEmitter.getInstance();
     }
@@ -14855,8 +14898,115 @@ class NamiCampaignManager {
         }
         return { type, value };
     }
-}
-NamiCampaignManager.instance = new NamiCampaignManager();
+};
+NamiCampaignManager$2.instance = new NamiCampaignManager$2();
+
+// Re-export the class itself, typed as the narrow public interface. The
+// runtime value IS the class (same object identity), so `jest.spyOn(...)`
+// in tests intercepts the same method that internal callers reach via
+// direct class import — no method-call indirection. The public `.d.ts`
+// however only sees the `NamiCampaignManagerStatic` surface: no
+// `.instance`, no `register()`-internal helpers, no private statics.
+// Renderer/test code that needs the unrestricted class imports from
+// `_internal` namespace on `@namiml/sdk-core` (NAM-1217). See NAM-1207.
+const NamiCampaignManager$1 = NamiCampaignManager$2;
+
+// Re-export the class itself, typed as the narrow public interface. Same
+// object identity as the underlying class so jest.spyOn works. See
+// `src/managers/campaign.ts` and NAM-1207 for the full rationale.
+const NamiCustomerManager$1 = NamiCustomerManager$2;
+
+/**
+ * @class NamiEntitlementManager
+ * Contains all methods and objects to work with entitlements in the SDK.
+ */
+let NamiEntitlementManager$2 = class NamiEntitlementManager {
+    constructor() {
+        this.emitter = NamiEventEmitter.getInstance();
+    }
+    /**
+     * @returns {NamiEntitlement[]} A list of currently active entitlements
+     */
+    static active() {
+        if (!hasPurchaseManagement()) {
+            return createNamiEntitlements();
+        }
+        return activeEntitlements();
+    }
+    /**
+     * Checks if a Nami Control Center defined Entitlement has at least one backing purchase
+     * and it's not expired.
+     *
+     * @param referenceId - entitlement referenceId
+     * @returns {boolean} True if the entitlement is active for given referenceId, false otherwise.
+     */
+    static isEntitlementActive(referenceId) {
+        if (!hasPurchaseManagement("NamiEntitlementManager.isEntitlementActive")) {
+            return false;
+        }
+        return this.active().some((entitlement) => entitlement.referenceId == referenceId);
+    }
+    /**
+     * Asks Nami to fetch the latest active entitlements
+     *
+     * @returns {Promise<NamiEntitlement[]>} A promise that resolves to a list of NamiEntitlement
+     */
+    static async refresh() {
+        if (!this.instance.sdkInitialized) {
+            throw new SDKNotInitializedError();
+        }
+        if (!hasPurchaseManagement("NamiEntitlementManager.refresh")) {
+            return [];
+        }
+        await EntitlementRepository.instance.fetchActiveEntitlements();
+        return activeEntitlements();
+    }
+    /**
+     * When there has been an update received to the active entitlements,
+     * the Nami SDK will provide notification of that event through
+     * this callback with list of active [NamiEntitlement]
+     *
+     * @param {NamiActiveEntitlementsHandler} handler - The callback function that will be invoked when the campaign list is updated.
+     * @returns {Callback} A function that can be called to unregister the handler.
+     */
+    static registerActiveEntitlementsHandler(handler) {
+        if (hasPurchaseManagement("NamiEntitlementManager.registerActiveEntitlementsHandler")) {
+            this.instance.emitter.addListener(exports.AVAILABLE_ACTIVE_ENTITLEMENTS_CHANGED, handler);
+            return () => {
+                this.instance.emitter.removeListener(exports.AVAILABLE_ACTIVE_ENTITLEMENTS_CHANGED, handler);
+            };
+        }
+    }
+    /**
+     *  Clear any provisional entitlement grants, which are entitlements issued on-device only.
+     *  Useful for development and purchase testing. Not recommended to be called in production.
+     */
+    static clearProvisionalEntitlementGrants() {
+        let entitlements = activeEntitlements();
+        entitlements = entitlements.filter((entitlement) => {
+            return entitlement.expires && entitlement.expires > new Date().valueOf();
+        });
+        storageService.setNamiEntitlements(exports.LOCAL_NAMI_ENTITLEMENTS, entitlements);
+        this.instance.emitter.emit(exports.AVAILABLE_ACTIVE_ENTITLEMENTS_CHANGED);
+    }
+    /**
+     * Private Instance Methods
+     */
+    get sdkInitialized() {
+        return Nami.instance.isInitialized;
+    }
+};
+NamiEntitlementManager$2.instance = new NamiEntitlementManager$2();
+
+// Re-export the class itself, typed as the narrow public interface. Same
+// object identity as the underlying class so jest.spyOn works. See
+// `src/managers/campaign.ts` and NAM-1207.
+const NamiEntitlementManager$1 = NamiEntitlementManager$2;
+
+// Re-export the class itself, typed as the narrow public interface. Same
+// object identity as the underlying class so jest.spyOn works. See
+// `src/managers/campaign.ts` and NAM-1207.
+const NamiFlowManager$1 = NamiFlowManager$2;
 
 const postConversion = async (transactionInfo) => {
     if (isAnonymousMode()) {
@@ -14875,7 +15025,7 @@ const postConversion = async (transactionInfo) => {
  * @class NamiPaywallManager
  * Provides methods for managing all aspects of a paywall in the Nami SDK.
  */
-class NamiPaywallManager {
+let NamiPaywallManager$2 = class NamiPaywallManager {
     constructor() {
         this.emitter = NamiEventEmitter.getInstance();
     }
@@ -14958,14 +15108,14 @@ class NamiPaywallManager {
     static async buySkuComplete(purchase) {
         // clear loading indicator
         PaywallState.setPurchaseInProgress(false);
-        if (NamiFlowManager.instance.flowOpen) {
-            const flow = NamiFlowManager.instance.currentFlow;
+        if (NamiFlowManager$2.instance.flowOpen) {
+            const flow = NamiFlowManager$2.instance.currentFlow;
             const currentStep = flow?.currentFlowStep;
             if (flow && currentStep) {
                 flow.executeLifecycle(currentStep, NamiReservedActions.PURCHASE_SUCCESS);
             }
         }
-        if (NamiCustomerManager.inAnonymousMode()) {
+        if (NamiCustomerManager$2.inAnonymousMode()) {
             logger.debug("Skipping purchase validation - anonymous mode");
             return;
         }
@@ -15046,142 +15196,19 @@ class NamiPaywallManager {
     get sdkInitialized() {
         return Nami.instance.isInitialized;
     }
-}
-NamiPaywallManager.instance = new NamiPaywallManager();
-NamiPaywallManager.emitter = NamiEventEmitter.getInstance();
+};
+NamiPaywallManager$2.instance = new NamiPaywallManager$2();
+NamiPaywallManager$2.emitter = NamiEventEmitter.getInstance();
 
-/**
- * @class NamiEntitlementManager
- * Contains all methods and objects to work with entitlements in the SDK.
- */
-class NamiEntitlementManager {
-    constructor() {
-        this.emitter = NamiEventEmitter.getInstance();
-    }
-    /**
-     * @returns {NamiEntitlement[]} A list of currently active entitlements
-     */
-    static active() {
-        if (!hasPurchaseManagement()) {
-            return createNamiEntitlements();
-        }
-        return activeEntitlements();
-    }
-    /**
-     * Checks if a Nami Control Center defined Entitlement has at least one backing purchase
-     * and it's not expired.
-     *
-     * @param referenceId - entitlement referenceId
-     * @returns {boolean} True if the entitlement is active for given referenceId, false otherwise.
-     */
-    static isEntitlementActive(referenceId) {
-        if (!hasPurchaseManagement("NamiEntitlementManager.isEntitlementActive")) {
-            return false;
-        }
-        return this.active().some((entitlement) => entitlement.referenceId == referenceId);
-    }
-    /**
-     * Asks Nami to fetch the latest active entitlements
-     *
-     * @returns {Promise<NamiEntitlement[]>} A promise that resolves to a list of NamiEntitlement
-     */
-    static async refresh() {
-        if (!this.instance.sdkInitialized) {
-            throw new SDKNotInitializedError();
-        }
-        if (!hasPurchaseManagement("NamiEntitlementManager.refresh")) {
-            return [];
-        }
-        await EntitlementRepository.instance.fetchActiveEntitlements();
-        return activeEntitlements();
-    }
-    /**
-     * When there has been an update received to the active entitlements,
-     * the Nami SDK will provide notification of that event through
-     * this callback with list of active [NamiEntitlement]
-     *
-     * @param {NamiActiveEntitlementsHandler} handler - The callback function that will be invoked when the campaign list is updated.
-     * @returns {Callback} A function that can be called to unregister the handler.
-     */
-    static registerActiveEntitlementsHandler(handler) {
-        if (hasPurchaseManagement("NamiEntitlementManager.registerActiveEntitlementsHandler")) {
-            this.instance.emitter.addListener(exports.AVAILABLE_ACTIVE_ENTITLEMENTS_CHANGED, handler);
-            return () => {
-                this.instance.emitter.removeListener(exports.AVAILABLE_ACTIVE_ENTITLEMENTS_CHANGED, handler);
-            };
-        }
-    }
-    /**
-     *  Clear any provisional entitlement grants, which are entitlements issued on-device only.
-     *  Useful for development and purchase testing. Not recommended to be called in production.
-     */
-    static clearProvisionalEntitlementGrants() {
-        let entitlements = activeEntitlements();
-        entitlements = entitlements.filter((entitlement) => {
-            return entitlement.expires && entitlement.expires > new Date().valueOf();
-        });
-        storageService.setNamiEntitlements(exports.LOCAL_NAMI_ENTITLEMENTS, entitlements);
-        this.instance.emitter.emit(exports.AVAILABLE_ACTIVE_ENTITLEMENTS_CHANGED);
-    }
-    /**
-     * Private Instance Methods
-     */
-    get sdkInitialized() {
-        return Nami.instance.isInitialized;
-    }
-}
-NamiEntitlementManager.instance = new NamiEntitlementManager();
+// Re-export the class itself, typed as the narrow public interface. Same
+// object identity as the underlying class so jest.spyOn works. See
+// `src/managers/campaign.ts` and NAM-1207.
+const NamiPaywallManager$1 = NamiPaywallManager$2;
 
-({
-    /**
-     * Registers a handler to be invoked when a flow step triggers a handoff event.
-     *
-     * This allows you to intercept a handoff step in a Nami Flow and execute custom logic
-     *
-     * @param handoffStepHandler - A callback function that will be called when a handoff occurs.
-     * It receives the `handoffTag` string (identifying the step) and an optional `handoffData`
-     * object with additional context. If `undefined`, the current handler is cleared.
-     *
-     */
-    registerStepHandoff: NamiFlowManager.registerStepHandoff.bind(NamiFlowManager),
-    /**
-     * Registers a handler to be invoked when events are emitted.
-     *
-     * This enables you to use your own custom event tracking.
-     *
-     * @param eventHandler - A callback function that will be called when an event occurs.
-     * The argument is a key-value object containing event data.
-     * If `undefined`, the current handler is cleared
-     *
-     */
-    registerEventHandler: NamiFlowManager.registerEventHandler.bind(NamiFlowManager),
-    /**
-     * Resumes the Nami Flow after a handoff has been completed.
-     *
-     * This should be called by once any custom logic associated with
-     * a handoff has completed.
-     * It signals to continue to the next step in the flow sequence.
-     */
-    resume: NamiFlowManager.resume.bind(NamiFlowManager),
-    /**
-     * Finishes the current flow programmatically.
-     *
-     * This can be used to end the flow at any point, typically after a handoff or custom logic.
-     */
-    finish: NamiFlowManager.finish.bind(NamiFlowManager),
-    /**
-     * Pauses the current flow.
-     *
-     * This can be used to temporarily halt the flow, typically in response to user input or other events.
-     */
-    pause: NamiFlowManager.pause.bind(NamiFlowManager),
-    /**
-     * Checks if a flow is currently open.
-     *
-     * @returns {boolean} - True if a flow is open, false otherwise.
-     */
-    isFlowOpen: NamiFlowManager.isFlowOpen.bind(NamiFlowManager),
-});
+// Re-export the class itself, typed as the narrow public interface. Same
+// object identity as the underlying class so jest.spyOn works. See
+// `src/managers/campaign.ts` and NAM-1207.
+const NamiPurchaseManager$1 = NamiPurchaseManager$2;
 
 const BorderMap = {
     upperLeft: 'border-top-left-radius',
@@ -64696,6 +64723,53 @@ function namiBuySKU(skuRefId) {
     return result;
 }
 
+/**
+ * Source of the `_internal` namespace re-exported from `index.ts` — typed
+ * escape hatch for the underlying manager classes.
+ *
+ * The public surface at `@namiml/sdk-core` (and `@namiml/web-sdk`) exposes each
+ * manager as a narrow const proxy of documented methods only. Renderer code and
+ * tests that need the singleton (`Foo.instance`), private event emitters, or
+ * internal helper statics that aren't part of the documented public API import
+ * the classes via the `_internal` namespace on `@namiml/sdk-core` — which
+ * re-exports the values declared here with their wider class types.
+ *
+ * **Critical bundle behavior.** Every runtime value here is imported from
+ * `'./index'` (the package's root entry). When index.ts re-exports this module
+ * as `export * as _internal from './internal'`, the values flow through the
+ * same module identity as the root entry — no duplication. Adapters registered
+ * via the documented public surface remain visible to code reached through the
+ * `_internal` namespace, because both paths reference the same module-scoped
+ * `_adapters` map in `adapters/index.ts`. See NAM-1207 (PR #340 + PR #342) for
+ * the singleton-split regression history that motivated this indirection, and
+ * NAM-1217 for the move from the `/internal` subpath to a root namespace.
+ *
+ * Not part of the public contract. Method signatures here can change between
+ * minor releases. If you depend on something here as a third-party integrator,
+ * file a ticket asking for a documented public equivalent — that's a signal we
+ * should widen the public surface, not a license to track this entry point.
+ */
+// Runtime values are the same class identities the root entry holds — cast
+// widens the type from the narrow public proxy back to the class.
+const NamiCampaignManager = NamiCampaignManager$1;
+const NamiCustomerManager = NamiCustomerManager$1;
+const NamiPaywallManager = NamiPaywallManager$1;
+const NamiEntitlementManager = NamiEntitlementManager$1;
+const NamiFlowManager = NamiFlowManager$1;
+const NamiPurchaseManager = NamiPurchaseManager$1;
+const NamiProfileManager = NamiProfileManager$1;
+
+var internal = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    NamiCampaignManager: NamiCampaignManager,
+    NamiCustomerManager: NamiCustomerManager,
+    NamiEntitlementManager: NamiEntitlementManager,
+    NamiFlowManager: NamiFlowManager,
+    NamiPaywallManager: NamiPaywallManager,
+    NamiProfileManager: NamiProfileManager,
+    NamiPurchaseManager: NamiPurchaseManager
+});
+
 exports.APIError = APIError;
 exports.AnonymousCDPError = AnonymousCDPError;
 exports.AnonymousLoginError = AnonymousLoginError;
@@ -64724,18 +64798,17 @@ exports.NAMI_STORAGE_KEYS = NAMI_STORAGE_KEYS;
 exports.Nami = Nami;
 exports.NamiAPI = NamiAPI;
 exports.NamiAnimationType = NamiAnimationType;
-exports.NamiCampaignManager = NamiCampaignManager;
+exports.NamiCampaignManager = NamiCampaignManager$1;
 exports.NamiConditionEvaluator = NamiConditionEvaluator;
-exports.NamiCustomerManager = NamiCustomerManager;
-exports.NamiEntitlementManager = NamiEntitlementManager;
+exports.NamiCustomerManager = NamiCustomerManager$1;
+exports.NamiEntitlementManager = NamiEntitlementManager$1;
 exports.NamiEventEmitter = NamiEventEmitter;
 exports.NamiFlow = NamiFlow;
-exports.NamiFlowManager = NamiFlowManager;
+exports.NamiFlowManager = NamiFlowManager$1;
 exports.NamiFlowStepType = NamiFlowStepType;
-exports.NamiPaywallManager = NamiPaywallManager;
+exports.NamiPaywallManager = NamiPaywallManager$1;
 exports.NamiPaywallManagerEvents = exports.PaywallManagerEvents;
-exports.NamiProfileManager = NamiProfileManager;
-exports.NamiPurchaseManager = NamiPurchaseManager;
+exports.NamiPurchaseManager = NamiPurchaseManager$1;
 exports.NamiRefs = NamiRefs;
 exports.NamiReservedActions = NamiReservedActions;
 exports.NotFoundError = NotFoundError;
@@ -64750,6 +64823,8 @@ exports.SHOULD_SHOW_LOADING_INDICATOR = SHOULD_SHOW_LOADING_INDICATOR;
 exports.SessionService = SessionService;
 exports.SimpleEventTarget = SimpleEventTarget;
 exports.StorageService = StorageService;
+exports._NamiProfileManager = NamiProfileManager$1;
+exports._internal = internal;
 exports.activateEntitlementByPurchase = activateEntitlementByPurchase;
 exports.activeEntitlements = activeEntitlements;
 exports.aggregateScreenreaderText = aggregateScreenreaderText;