@blotoutio/providers-app-lovin-sdk 1.71.1 → 1.72.0

package/index.cjs.js

@@ -1,5 +1,35 @@
 'use strict';
 
+/**
+ * AppLovin's `user_data.zip` is documented as "The user's billing zip code. Use
+ * only the first 5 digits for US zip codes", so a ZIP+4 arriving from a billing
+ * address is truncated to its first five digits.
+ *
+ * Only for US values. A blind five-character slice would corrupt every other
+ * postal format — UK `SW1A 1AA` becomes `SW1A `, Canadian `K1A 0B1` becomes
+ * `K1A 0` — so anything else passes through as given.
+ *
+ * Shared by the cdn and sdk paths so both send the same value.
+ */
+const getNormalizedZip = (zip, country) => {
+    var _a;
+    const trimmed = zip === null || zip === void 0 ? void 0 : zip.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    // ISO 3166 per the same spec; `USA` is accepted because billing addresses
+    // supply both spellings.
+    const isUS = ['US', 'USA'].includes((_a = country === null || country === void 0 ? void 0 : country.trim().toUpperCase()) !== null && _a !== void 0 ? _a : '');
+    // The country is optional on both call paths, and the ZIP+4 shape belongs to
+    // no other postal format, so a value in that shape is truncated even when no
+    // country accompanies it.
+    const isZipPlusFour = /^\d{5}-?\d{4}$/.test(trimmed);
+    if (!isUS && !isZipPlusFour) {
+        return trimmed;
+    }
+    return trimmed.replace(/\D/g, '').slice(0, 5) || undefined;
+};
+
 const packageName = 'appLovin';
 
 const t = [
@@ -121,6 +151,20 @@ const getSession = (key) => {
     }
 };
 
+const getIsNewCustomerFlag = async (getData) => {
+    const { isNewCustomer } = await new Promise((resolve) => getData(['isNewCustomer'], resolve));
+    return isNewCustomer ? isNewCustomer === 'true' : undefined;
+};
+// Reads the isNewCustomer flag already persisted in the browser's session KV
+// (written by the `data` API call, which runs before the Purchase event). Lets
+// callers use the local value and avoid a redundant edge round-trip; returns
+// undefined when the value has not been stored yet so the caller can fall back.
+const getIsNewCustomerFromBrowser = (destination) => {
+    const kv = getData(destination, 'session')['kv'];
+    const isNewCustomer = kv === null || kv === void 0 ? void 0 : kv['isNewCustomer'];
+    return isNewCustomer ? isNewCustomer === 'true' : undefined;
+};
+
 /**
  * Known ad-network click ID query parameters and the human-readable provider
  * label each one maps to. Used by the CDN worker to resolve `inSessionTouch`
@@ -158,6 +202,18 @@ const CLICK_IDS = [
     { param: 'duel_a', label: 'Duel' }, // Duel referral/advocacy
 ];
 
+/**
+ * Checks whether a value is a plain JavaScript object (created via `{}` or `new Object()`).
+ * Returns false for arrays, class instances, null, and objects with modified prototypes.
+ * Note: Objects created with `Object.create(null)` will return false.
+ */
+const isPlainObject = (value) => {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    return Object.getPrototypeOf(value) === Object.prototype;
+};
+
 const expand = (str) => str.split(',').flatMap((entry) => {
     if (!entry.includes('-')) {
         return entry;
@@ -223,6 +279,18 @@ const normalizeEmail = (email) => {
     return trimmedEmail;
 };
 
+function tryParse(json, fallbackValue) {
+    try {
+        if (json) {
+            return JSON.parse(json);
+        }
+    }
+    catch {
+        /* do nothing */
+    }
+    return fallbackValue;
+}
+
 /**
  * ISO-3166 2-leter country codes and their names
  * @see https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
@@ -569,6 +637,78 @@ new Set([
     ...caProvinces.keys(),
 ]);
 
+/**
+ * Self-describing JSON compaction codec (`packMappings` / `unpackMappings`).
+ *
+ * Worker variables have a 5KB-per-variable limit, and objects waste most of it
+ * repeating long field names on every row. `packMappings` rewrites every object
+ * key (at any depth) to a short auto-derived token and carries a single embedded
+ * legend, so the long name is stored once. `unpackMappings` reverses it using
+ * that legend alone — there is NO external key-map to maintain per provider.
+ *
+ * Works on ANY JSON value: a mapping array (the common case), a single plain
+ * object, nested structures, or primitives all round-trip.
+ *
+ * The wire format is a versioned envelope:
+ *   { "~": 1, "k": { <short>: <long>, ... }, "d": <transformed value> }
+ *
+ * Guarantees (all covered by tests):
+ * - `unpackMappings(packMappings(x))` deep-equals `x` with empty fields removed,
+ *   for any JSON value (objects, arrays, nesting, primitives).
+ * - Short keys are always unique — long names sharing a prefix are disambiguated
+ *   automatically, so `packMappings` never loses or merges a field.
+ * - `unpackMappings` returns legacy plain JSON (no envelope) unchanged, so values
+ *   written before compaction keep decoding; invalid/empty input → `undefined`.
+ *
+ * The building blocks (`isEmptyValue`, `deriveShortKey`, `encodeMappings`,
+ * `decodeMappings`, `isMappingEnvelope`) are exported as pure functions so each
+ * is independently testable.
+ */
+const CODEC_VERSION = 1;
+const VERSION_KEY = '~';
+const LEGEND_KEY = 'k';
+const DATA_KEY = 'd';
+/**
+ * Pure inverse of `encodeMappings`: rewrites every object key back to its long
+ * name via the legend (unknown keys pass through). Arrays and primitives pass
+ * through structurally.
+ */
+const decodeMappings = (data, legend) => {
+    var _a;
+    if (Array.isArray(data)) {
+        return data.map((item) => decodeMappings(item, legend));
+    }
+    if (isPlainObject(data)) {
+        const result = {};
+        for (const [key, val] of Object.entries(data)) {
+            result[(_a = legend[key]) !== null && _a !== void 0 ? _a : key] = decodeMappings(val, legend);
+        }
+        return result;
+    }
+    return data;
+};
+/** True when a parsed value is a `packMappings` envelope (vs. legacy plain JSON). */
+const isMappingEnvelope = (value) => isPlainObject(value) &&
+    value[VERSION_KEY] === CODEC_VERSION &&
+    isPlainObject(value[LEGEND_KEY]) &&
+    DATA_KEY in value;
+function unpackMappings(text, fallback) {
+    const parsed = tryParse(text);
+    if (parsed === undefined || parsed === null) {
+        return fallback;
+    }
+    if (isMappingEnvelope(parsed)) {
+        return decodeMappings(parsed[DATA_KEY], parsed[LEGEND_KEY]);
+    }
+    // A versioned envelope this reader can't decode (e.g. a future CODEC_VERSION
+    // written by a newer UI while this worker still lags). Returning the raw
+    // `{~,k,d}` object would be silent corruption, so fall back instead.
+    if (isPlainObject(parsed) && VERSION_KEY in parsed) {
+        return fallback;
+    }
+    return parsed;
+}
+
 /**
  * Exact utm_source normalization (lowercase key → canonical name).
  *
@@ -691,24 +831,17 @@ new Set([
 ]);
 
 // eslint-disable-next-line @nx/enforce-module-boundaries
-const getParsedCategoryId = (category) => {
-    try {
-        const parsed = JSON.parse(category);
-        return parsed.value;
-    }
-    catch (error) {
-        logger.error(`Error parsing category: ${category}`, error);
-        return undefined;
-    }
-};
+// The same helpers as the cdn copy in cdn/src/lib/utils.ts, so a malformed
+// mapping fails identically on both sides. `unpackMappings` yields the fallback
+// for input that parses to `null`, and the array guard covers valid JSON that
+// is not an array; either would otherwise reach `.map` and throw, which in
+// browser SDK code takes the whole tag down.
+const getParsedCategoryId = (category) => { var _a; return (_a = tryParse(category)) === null || _a === void 0 ? void 0 : _a.value; };
 const getCategories = (categoryMapping) => {
-    let categoryMappings = [];
-    try {
-        categoryMappings = JSON.parse(categoryMapping || '[]');
-    }
-    catch {
+    const categoryMappings = unpackMappings(categoryMapping, []);
+    if (!Array.isArray(categoryMappings)) {
         logger.error('Unable to parse category mappings');
-        categoryMappings = [];
+        return new Map();
     }
     return new Map(categoryMappings.map(({ storeCategory, appLovinCategory }) => [
         storeCategory.toLowerCase(),
@@ -745,6 +878,13 @@ const getEventUserData = (userId, data) => {
             userData.phone = normalizedPhone;
         }
     }
+    const zip = getNormalizedZip(data.zip, data.country_code);
+    if (zip) {
+        userData.zip = zip;
+    }
+    if (data.country_code) {
+        userData.country_code = data.country_code;
+    }
     return userData;
 };
 /**
@@ -756,9 +896,10 @@ const getEventUserData = (userId, data) => {
  * @param defaultCategory - JSON string containing default category configuration with label and value
  * @param categoryMapping - JSON string containing array of category mappings
  * @param userId - The explicit user ID to use in event user_data
+ * @param isNewCustomer - New/returning buyer flag, applied to Purchase only
  * @returns EventData payload if the event is supported, undefined otherwise
  */
-const getEventData = ({ eventName, userData, data, defaultCategory, categoryMapping, userId, }) => {
+const getEventData = ({ eventName, userData, data, defaultCategory, categoryMapping, userId, isNewCustomer, }) => {
     var _a, _b, _c;
     const categories = getCategories(categoryMapping);
     const defaultCategoryId = getParsedCategoryId(defaultCategory);
@@ -857,6 +998,9 @@ const getEventData = ({ eventName, userData, data, defaultCategory, categoryMapp
                     shipping: (_b = data.shippingCost) !== null && _b !== void 0 ? _b : 0,
                     tax: (_c = data.taxCost) !== null && _c !== void 0 ? _c : 0,
                     user_data: getEventUserData(userId, userData),
+                    ...(typeof isNewCustomer === 'boolean' && {
+                        measurement: { is_new_customer: isNewCustomer },
+                    }),
                 },
             };
         }
@@ -903,9 +1047,14 @@ const getEventData = ({ eventName, userData, data, defaultCategory, categoryMapp
     }
 };
 
-const tag = ({ data, eventName, eventId, manifestVariables, userId, destination, }) => {
+const getString = (kv, key) => {
+    const value = kv === null || kv === void 0 ? void 0 : kv[key];
+    return typeof value === 'string' && value ? value : undefined;
+};
+const tag = ({ data, eventName, eventId, manifestVariables, userId, destination, getEdgeData, }) => {
+    var _a, _b;
     const payload = {
-        sdkVersion: "1.71.1" ,
+        sdkVersion: "1.72.0" ,
     };
     if (window.axon && manifestVariables['enableBrowser'] === '1') {
         try {
@@ -914,28 +1063,68 @@ const tag = ({ data, eventName, eventId, manifestVariables, userId, destination,
             // email/phone usually arrive via the data API (stored in session KV),
             // not on the event payload itself.
             const kv = getData(destination, 'session')['kv'];
+            // Same identity set the CAPI attaches server-side, so the browser pixel
+            // is not the weaker of the two paths on a shopper we already know.
             const userData = { user_id: userId };
-            const email = (data === null || data === void 0 ? void 0 : data['email']) || (kv === null || kv === void 0 ? void 0 : kv['email']);
-            if (email && typeof email === 'string') {
+            // Checked per source rather than after the `||`, so a non-string on the
+            // payload cannot displace a valid string in KV.
+            const email = (_a = getString(data, 'email')) !== null && _a !== void 0 ? _a : getString(kv, 'email');
+            if (email) {
                 userData.email = email;
             }
-            const phone = (data === null || data === void 0 ? void 0 : data['phone']) || (kv === null || kv === void 0 ? void 0 : kv['phone']);
-            if (phone && typeof phone === 'string') {
+            const phone = (_b = getString(data, 'phone')) !== null && _b !== void 0 ? _b : getString(kv, 'phone');
+            if (phone) {
                 userData.phone = phone;
             }
-            const event = getEventData({
-                eventName,
-                userData,
-                data,
-                defaultCategory,
-                categoryMapping,
-                userId,
-            });
-            if (!event) {
-                logger.log(`[${packageName}] ${eventName} not supported`);
-                return;
+            const zip = getString(kv, 'zip');
+            if (zip) {
+                userData.zip = zip;
+            }
+            const country = getString(kv, 'country');
+            if (country) {
+                userData.country_code = country;
+            }
+            const send = (isNewCustomer) => {
+                var _a;
+                const event = getEventData({
+                    eventName,
+                    userData,
+                    data,
+                    defaultCategory,
+                    categoryMapping,
+                    userId,
+                    isNewCustomer,
+                });
+                if (!event) {
+                    logger.log(`[${packageName}] ${eventName} not supported`);
+                    return;
+                }
+                (_a = window.axon) === null || _a === void 0 ? void 0 : _a.call(window, 'track', event.name, event.data, { dedupe_id: eventId });
+            };
+            if (eventName !== 'Purchase') {
+                send();
+                return payload;
+            }
+            // Prefer the flag already saved in the browser (the Shopify pixel's
+            // `data` call writes it just before Purchase). Only query the edge when
+            // the browser value is missing.
+            const browserValue = destination
+                ? getIsNewCustomerFromBrowser(destination)
+                : undefined;
+            if (typeof browserValue === 'boolean') {
+                send(browserValue);
+            }
+            else if (getEdgeData) {
+                getIsNewCustomerFlag(getEdgeData)
+                    // The fallback is the rejection handler rather than a trailing
+                    // `catch`, so only a failed lookup sends without the flag; a `send`
+                    // that throws must not be retried into a duplicate pixel call.
+                    .then(send, () => send())
+                    .catch((error) => logger.error(error));
+            }
+            else {
+                send();
             }
-            window.axon('track', event.name, event.data, { dedupe_id: eventId });
         }
         catch (e) {
             logger.error(e);

package/index.js

@@ -1,6 +1,36 @@
 var ProvidersAppLovinSdk = (function () {
     'use strict';
 
+    /**
+     * AppLovin's `user_data.zip` is documented as "The user's billing zip code. Use
+     * only the first 5 digits for US zip codes", so a ZIP+4 arriving from a billing
+     * address is truncated to its first five digits.
+     *
+     * Only for US values. A blind five-character slice would corrupt every other
+     * postal format — UK `SW1A 1AA` becomes `SW1A `, Canadian `K1A 0B1` becomes
+     * `K1A 0` — so anything else passes through as given.
+     *
+     * Shared by the cdn and sdk paths so both send the same value.
+     */
+    const getNormalizedZip = (zip, country) => {
+        var _a;
+        const trimmed = zip === null || zip === void 0 ? void 0 : zip.trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        // ISO 3166 per the same spec; `USA` is accepted because billing addresses
+        // supply both spellings.
+        const isUS = ['US', 'USA'].includes((_a = country === null || country === void 0 ? void 0 : country.trim().toUpperCase()) !== null && _a !== void 0 ? _a : '');
+        // The country is optional on both call paths, and the ZIP+4 shape belongs to
+        // no other postal format, so a value in that shape is truncated even when no
+        // country accompanies it.
+        const isZipPlusFour = /^\d{5}-?\d{4}$/.test(trimmed);
+        if (!isUS && !isZipPlusFour) {
+            return trimmed;
+        }
+        return trimmed.replace(/\D/g, '').slice(0, 5) || undefined;
+    };
+
     const packageName = 'appLovin';
 
     const t = [
@@ -122,6 +152,20 @@ var ProvidersAppLovinSdk = (function () {
         }
     };
 
+    const getIsNewCustomerFlag = async (getData) => {
+        const { isNewCustomer } = await new Promise((resolve) => getData(['isNewCustomer'], resolve));
+        return isNewCustomer ? isNewCustomer === 'true' : undefined;
+    };
+    // Reads the isNewCustomer flag already persisted in the browser's session KV
+    // (written by the `data` API call, which runs before the Purchase event). Lets
+    // callers use the local value and avoid a redundant edge round-trip; returns
+    // undefined when the value has not been stored yet so the caller can fall back.
+    const getIsNewCustomerFromBrowser = (destination) => {
+        const kv = getData(destination, 'session')['kv'];
+        const isNewCustomer = kv === null || kv === void 0 ? void 0 : kv['isNewCustomer'];
+        return isNewCustomer ? isNewCustomer === 'true' : undefined;
+    };
+
     /**
      * Known ad-network click ID query parameters and the human-readable provider
      * label each one maps to. Used by the CDN worker to resolve `inSessionTouch`
@@ -159,6 +203,18 @@ var ProvidersAppLovinSdk = (function () {
         { param: 'duel_a', label: 'Duel' }, // Duel referral/advocacy
     ];
 
+    /**
+     * Checks whether a value is a plain JavaScript object (created via `{}` or `new Object()`).
+     * Returns false for arrays, class instances, null, and objects with modified prototypes.
+     * Note: Objects created with `Object.create(null)` will return false.
+     */
+    const isPlainObject = (value) => {
+        if (typeof value !== 'object' || value === null) {
+            return false;
+        }
+        return Object.getPrototypeOf(value) === Object.prototype;
+    };
+
     const expand = (str) => str.split(',').flatMap((entry) => {
         if (!entry.includes('-')) {
             return entry;
@@ -224,6 +280,18 @@ var ProvidersAppLovinSdk = (function () {
         return trimmedEmail;
     };
 
+    function tryParse(json, fallbackValue) {
+        try {
+            if (json) {
+                return JSON.parse(json);
+            }
+        }
+        catch {
+            /* do nothing */
+        }
+        return fallbackValue;
+    }
+
     /**
      * ISO-3166 2-leter country codes and their names
      * @see https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
@@ -570,6 +638,78 @@ var ProvidersAppLovinSdk = (function () {
         ...caProvinces.keys(),
     ]);
 
+    /**
+     * Self-describing JSON compaction codec (`packMappings` / `unpackMappings`).
+     *
+     * Worker variables have a 5KB-per-variable limit, and objects waste most of it
+     * repeating long field names on every row. `packMappings` rewrites every object
+     * key (at any depth) to a short auto-derived token and carries a single embedded
+     * legend, so the long name is stored once. `unpackMappings` reverses it using
+     * that legend alone — there is NO external key-map to maintain per provider.
+     *
+     * Works on ANY JSON value: a mapping array (the common case), a single plain
+     * object, nested structures, or primitives all round-trip.
+     *
+     * The wire format is a versioned envelope:
+     *   { "~": 1, "k": { <short>: <long>, ... }, "d": <transformed value> }
+     *
+     * Guarantees (all covered by tests):
+     * - `unpackMappings(packMappings(x))` deep-equals `x` with empty fields removed,
+     *   for any JSON value (objects, arrays, nesting, primitives).
+     * - Short keys are always unique — long names sharing a prefix are disambiguated
+     *   automatically, so `packMappings` never loses or merges a field.
+     * - `unpackMappings` returns legacy plain JSON (no envelope) unchanged, so values
+     *   written before compaction keep decoding; invalid/empty input → `undefined`.
+     *
+     * The building blocks (`isEmptyValue`, `deriveShortKey`, `encodeMappings`,
+     * `decodeMappings`, `isMappingEnvelope`) are exported as pure functions so each
+     * is independently testable.
+     */
+    const CODEC_VERSION = 1;
+    const VERSION_KEY = '~';
+    const LEGEND_KEY = 'k';
+    const DATA_KEY = 'd';
+    /**
+     * Pure inverse of `encodeMappings`: rewrites every object key back to its long
+     * name via the legend (unknown keys pass through). Arrays and primitives pass
+     * through structurally.
+     */
+    const decodeMappings = (data, legend) => {
+        var _a;
+        if (Array.isArray(data)) {
+            return data.map((item) => decodeMappings(item, legend));
+        }
+        if (isPlainObject(data)) {
+            const result = {};
+            for (const [key, val] of Object.entries(data)) {
+                result[(_a = legend[key]) !== null && _a !== void 0 ? _a : key] = decodeMappings(val, legend);
+            }
+            return result;
+        }
+        return data;
+    };
+    /** True when a parsed value is a `packMappings` envelope (vs. legacy plain JSON). */
+    const isMappingEnvelope = (value) => isPlainObject(value) &&
+        value[VERSION_KEY] === CODEC_VERSION &&
+        isPlainObject(value[LEGEND_KEY]) &&
+        DATA_KEY in value;
+    function unpackMappings(text, fallback) {
+        const parsed = tryParse(text);
+        if (parsed === undefined || parsed === null) {
+            return fallback;
+        }
+        if (isMappingEnvelope(parsed)) {
+            return decodeMappings(parsed[DATA_KEY], parsed[LEGEND_KEY]);
+        }
+        // A versioned envelope this reader can't decode (e.g. a future CODEC_VERSION
+        // written by a newer UI while this worker still lags). Returning the raw
+        // `{~,k,d}` object would be silent corruption, so fall back instead.
+        if (isPlainObject(parsed) && VERSION_KEY in parsed) {
+            return fallback;
+        }
+        return parsed;
+    }
+
     /**
      * Exact utm_source normalization (lowercase key → canonical name).
      *
@@ -692,24 +832,17 @@ var ProvidersAppLovinSdk = (function () {
     ]);
 
     // eslint-disable-next-line @nx/enforce-module-boundaries
-    const getParsedCategoryId = (category) => {
-        try {
-            const parsed = JSON.parse(category);
-            return parsed.value;
-        }
-        catch (error) {
-            logger.error(`Error parsing category: ${category}`, error);
-            return undefined;
-        }
-    };
+    // The same helpers as the cdn copy in cdn/src/lib/utils.ts, so a malformed
+    // mapping fails identically on both sides. `unpackMappings` yields the fallback
+    // for input that parses to `null`, and the array guard covers valid JSON that
+    // is not an array; either would otherwise reach `.map` and throw, which in
+    // browser SDK code takes the whole tag down.
+    const getParsedCategoryId = (category) => { var _a; return (_a = tryParse(category)) === null || _a === void 0 ? void 0 : _a.value; };
     const getCategories = (categoryMapping) => {
-        let categoryMappings = [];
-        try {
-            categoryMappings = JSON.parse(categoryMapping || '[]');
-        }
-        catch {
+        const categoryMappings = unpackMappings(categoryMapping, []);
+        if (!Array.isArray(categoryMappings)) {
             logger.error('Unable to parse category mappings');
-            categoryMappings = [];
+            return new Map();
         }
         return new Map(categoryMappings.map(({ storeCategory, appLovinCategory }) => [
             storeCategory.toLowerCase(),
@@ -746,6 +879,13 @@ var ProvidersAppLovinSdk = (function () {
                 userData.phone = normalizedPhone;
             }
         }
+        const zip = getNormalizedZip(data.zip, data.country_code);
+        if (zip) {
+            userData.zip = zip;
+        }
+        if (data.country_code) {
+            userData.country_code = data.country_code;
+        }
         return userData;
     };
     /**
@@ -757,9 +897,10 @@ var ProvidersAppLovinSdk = (function () {
      * @param defaultCategory - JSON string containing default category configuration with label and value
      * @param categoryMapping - JSON string containing array of category mappings
      * @param userId - The explicit user ID to use in event user_data
+     * @param isNewCustomer - New/returning buyer flag, applied to Purchase only
      * @returns EventData payload if the event is supported, undefined otherwise
      */
-    const getEventData = ({ eventName, userData, data, defaultCategory, categoryMapping, userId, }) => {
+    const getEventData = ({ eventName, userData, data, defaultCategory, categoryMapping, userId, isNewCustomer, }) => {
         var _a, _b, _c;
         const categories = getCategories(categoryMapping);
         const defaultCategoryId = getParsedCategoryId(defaultCategory);
@@ -858,6 +999,9 @@ var ProvidersAppLovinSdk = (function () {
                         shipping: (_b = data.shippingCost) !== null && _b !== void 0 ? _b : 0,
                         tax: (_c = data.taxCost) !== null && _c !== void 0 ? _c : 0,
                         user_data: getEventUserData(userId, userData),
+                        ...(typeof isNewCustomer === 'boolean' && {
+                            measurement: { is_new_customer: isNewCustomer },
+                        }),
                     },
                 };
             }
@@ -904,9 +1048,14 @@ var ProvidersAppLovinSdk = (function () {
         }
     };
 
-    const tag = ({ data, eventName, eventId, manifestVariables, userId, destination, }) => {
+    const getString = (kv, key) => {
+        const value = kv === null || kv === void 0 ? void 0 : kv[key];
+        return typeof value === 'string' && value ? value : undefined;
+    };
+    const tag = ({ data, eventName, eventId, manifestVariables, userId, destination, getEdgeData, }) => {
+        var _a, _b;
         const payload = {
-            sdkVersion: "1.71.1" ,
+            sdkVersion: "1.72.0" ,
         };
         if (window.axon && manifestVariables['enableBrowser'] === '1') {
             try {
@@ -915,28 +1064,68 @@ var ProvidersAppLovinSdk = (function () {
                 // email/phone usually arrive via the data API (stored in session KV),
                 // not on the event payload itself.
                 const kv = getData(destination, 'session')['kv'];
+                // Same identity set the CAPI attaches server-side, so the browser pixel
+                // is not the weaker of the two paths on a shopper we already know.
                 const userData = { user_id: userId };
-                const email = (data === null || data === void 0 ? void 0 : data['email']) || (kv === null || kv === void 0 ? void 0 : kv['email']);
-                if (email && typeof email === 'string') {
+                // Checked per source rather than after the `||`, so a non-string on the
+                // payload cannot displace a valid string in KV.
+                const email = (_a = getString(data, 'email')) !== null && _a !== void 0 ? _a : getString(kv, 'email');
+                if (email) {
                     userData.email = email;
                 }
-                const phone = (data === null || data === void 0 ? void 0 : data['phone']) || (kv === null || kv === void 0 ? void 0 : kv['phone']);
-                if (phone && typeof phone === 'string') {
+                const phone = (_b = getString(data, 'phone')) !== null && _b !== void 0 ? _b : getString(kv, 'phone');
+                if (phone) {
                     userData.phone = phone;
                 }
-                const event = getEventData({
-                    eventName,
-                    userData,
-                    data,
-                    defaultCategory,
-                    categoryMapping,
-                    userId,
-                });
-                if (!event) {
-                    logger.log(`[${packageName}] ${eventName} not supported`);
-                    return;
+                const zip = getString(kv, 'zip');
+                if (zip) {
+                    userData.zip = zip;
+                }
+                const country = getString(kv, 'country');
+                if (country) {
+                    userData.country_code = country;
+                }
+                const send = (isNewCustomer) => {
+                    var _a;
+                    const event = getEventData({
+                        eventName,
+                        userData,
+                        data,
+                        defaultCategory,
+                        categoryMapping,
+                        userId,
+                        isNewCustomer,
+                    });
+                    if (!event) {
+                        logger.log(`[${packageName}] ${eventName} not supported`);
+                        return;
+                    }
+                    (_a = window.axon) === null || _a === void 0 ? void 0 : _a.call(window, 'track', event.name, event.data, { dedupe_id: eventId });
+                };
+                if (eventName !== 'Purchase') {
+                    send();
+                    return payload;
+                }
+                // Prefer the flag already saved in the browser (the Shopify pixel's
+                // `data` call writes it just before Purchase). Only query the edge when
+                // the browser value is missing.
+                const browserValue = destination
+                    ? getIsNewCustomerFromBrowser(destination)
+                    : undefined;
+                if (typeof browserValue === 'boolean') {
+                    send(browserValue);
+                }
+                else if (getEdgeData) {
+                    getIsNewCustomerFlag(getEdgeData)
+                        // The fallback is the rejection handler rather than a trailing
+                        // `catch`, so only a failed lookup sends without the flag; a `send`
+                        // that throws must not be retried into a duplicate pixel call.
+                        .then(send, () => send())
+                        .catch((error) => logger.error(error));
+                }
+                else {
+                    send();
                 }
-                window.axon('track', event.name, event.data, { dedupe_id: eventId });
             }
             catch (e) {
                 logger.error(e);

package/index.mjs

@@ -1,3 +1,33 @@
+/**
+ * AppLovin's `user_data.zip` is documented as "The user's billing zip code. Use
+ * only the first 5 digits for US zip codes", so a ZIP+4 arriving from a billing
+ * address is truncated to its first five digits.
+ *
+ * Only for US values. A blind five-character slice would corrupt every other
+ * postal format — UK `SW1A 1AA` becomes `SW1A `, Canadian `K1A 0B1` becomes
+ * `K1A 0` — so anything else passes through as given.
+ *
+ * Shared by the cdn and sdk paths so both send the same value.
+ */
+const getNormalizedZip = (zip, country) => {
+    var _a;
+    const trimmed = zip === null || zip === void 0 ? void 0 : zip.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    // ISO 3166 per the same spec; `USA` is accepted because billing addresses
+    // supply both spellings.
+    const isUS = ['US', 'USA'].includes((_a = country === null || country === void 0 ? void 0 : country.trim().toUpperCase()) !== null && _a !== void 0 ? _a : '');
+    // The country is optional on both call paths, and the ZIP+4 shape belongs to
+    // no other postal format, so a value in that shape is truncated even when no
+    // country accompanies it.
+    const isZipPlusFour = /^\d{5}-?\d{4}$/.test(trimmed);
+    if (!isUS && !isZipPlusFour) {
+        return trimmed;
+    }
+    return trimmed.replace(/\D/g, '').slice(0, 5) || undefined;
+};
+
 const packageName = 'appLovin';
 
 const t = [
@@ -119,6 +149,20 @@ const getSession = (key) => {
     }
 };
 
+const getIsNewCustomerFlag = async (getData) => {
+    const { isNewCustomer } = await new Promise((resolve) => getData(['isNewCustomer'], resolve));
+    return isNewCustomer ? isNewCustomer === 'true' : undefined;
+};
+// Reads the isNewCustomer flag already persisted in the browser's session KV
+// (written by the `data` API call, which runs before the Purchase event). Lets
+// callers use the local value and avoid a redundant edge round-trip; returns
+// undefined when the value has not been stored yet so the caller can fall back.
+const getIsNewCustomerFromBrowser = (destination) => {
+    const kv = getData(destination, 'session')['kv'];
+    const isNewCustomer = kv === null || kv === void 0 ? void 0 : kv['isNewCustomer'];
+    return isNewCustomer ? isNewCustomer === 'true' : undefined;
+};
+
 /**
  * Known ad-network click ID query parameters and the human-readable provider
  * label each one maps to. Used by the CDN worker to resolve `inSessionTouch`
@@ -156,6 +200,18 @@ const CLICK_IDS = [
     { param: 'duel_a', label: 'Duel' }, // Duel referral/advocacy
 ];
 
+/**
+ * Checks whether a value is a plain JavaScript object (created via `{}` or `new Object()`).
+ * Returns false for arrays, class instances, null, and objects with modified prototypes.
+ * Note: Objects created with `Object.create(null)` will return false.
+ */
+const isPlainObject = (value) => {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    return Object.getPrototypeOf(value) === Object.prototype;
+};
+
 const expand = (str) => str.split(',').flatMap((entry) => {
     if (!entry.includes('-')) {
         return entry;
@@ -221,6 +277,18 @@ const normalizeEmail = (email) => {
     return trimmedEmail;
 };
 
+function tryParse(json, fallbackValue) {
+    try {
+        if (json) {
+            return JSON.parse(json);
+        }
+    }
+    catch {
+        /* do nothing */
+    }
+    return fallbackValue;
+}
+
 /**
  * ISO-3166 2-leter country codes and their names
  * @see https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
@@ -567,6 +635,78 @@ new Set([
     ...caProvinces.keys(),
 ]);
 
+/**
+ * Self-describing JSON compaction codec (`packMappings` / `unpackMappings`).
+ *
+ * Worker variables have a 5KB-per-variable limit, and objects waste most of it
+ * repeating long field names on every row. `packMappings` rewrites every object
+ * key (at any depth) to a short auto-derived token and carries a single embedded
+ * legend, so the long name is stored once. `unpackMappings` reverses it using
+ * that legend alone — there is NO external key-map to maintain per provider.
+ *
+ * Works on ANY JSON value: a mapping array (the common case), a single plain
+ * object, nested structures, or primitives all round-trip.
+ *
+ * The wire format is a versioned envelope:
+ *   { "~": 1, "k": { <short>: <long>, ... }, "d": <transformed value> }
+ *
+ * Guarantees (all covered by tests):
+ * - `unpackMappings(packMappings(x))` deep-equals `x` with empty fields removed,
+ *   for any JSON value (objects, arrays, nesting, primitives).
+ * - Short keys are always unique — long names sharing a prefix are disambiguated
+ *   automatically, so `packMappings` never loses or merges a field.
+ * - `unpackMappings` returns legacy plain JSON (no envelope) unchanged, so values
+ *   written before compaction keep decoding; invalid/empty input → `undefined`.
+ *
+ * The building blocks (`isEmptyValue`, `deriveShortKey`, `encodeMappings`,
+ * `decodeMappings`, `isMappingEnvelope`) are exported as pure functions so each
+ * is independently testable.
+ */
+const CODEC_VERSION = 1;
+const VERSION_KEY = '~';
+const LEGEND_KEY = 'k';
+const DATA_KEY = 'd';
+/**
+ * Pure inverse of `encodeMappings`: rewrites every object key back to its long
+ * name via the legend (unknown keys pass through). Arrays and primitives pass
+ * through structurally.
+ */
+const decodeMappings = (data, legend) => {
+    var _a;
+    if (Array.isArray(data)) {
+        return data.map((item) => decodeMappings(item, legend));
+    }
+    if (isPlainObject(data)) {
+        const result = {};
+        for (const [key, val] of Object.entries(data)) {
+            result[(_a = legend[key]) !== null && _a !== void 0 ? _a : key] = decodeMappings(val, legend);
+        }
+        return result;
+    }
+    return data;
+};
+/** True when a parsed value is a `packMappings` envelope (vs. legacy plain JSON). */
+const isMappingEnvelope = (value) => isPlainObject(value) &&
+    value[VERSION_KEY] === CODEC_VERSION &&
+    isPlainObject(value[LEGEND_KEY]) &&
+    DATA_KEY in value;
+function unpackMappings(text, fallback) {
+    const parsed = tryParse(text);
+    if (parsed === undefined || parsed === null) {
+        return fallback;
+    }
+    if (isMappingEnvelope(parsed)) {
+        return decodeMappings(parsed[DATA_KEY], parsed[LEGEND_KEY]);
+    }
+    // A versioned envelope this reader can't decode (e.g. a future CODEC_VERSION
+    // written by a newer UI while this worker still lags). Returning the raw
+    // `{~,k,d}` object would be silent corruption, so fall back instead.
+    if (isPlainObject(parsed) && VERSION_KEY in parsed) {
+        return fallback;
+    }
+    return parsed;
+}
+
 /**
  * Exact utm_source normalization (lowercase key → canonical name).
  *
@@ -689,24 +829,17 @@ new Set([
 ]);
 
 // eslint-disable-next-line @nx/enforce-module-boundaries
-const getParsedCategoryId = (category) => {
-    try {
-        const parsed = JSON.parse(category);
-        return parsed.value;
-    }
-    catch (error) {
-        logger.error(`Error parsing category: ${category}`, error);
-        return undefined;
-    }
-};
+// The same helpers as the cdn copy in cdn/src/lib/utils.ts, so a malformed
+// mapping fails identically on both sides. `unpackMappings` yields the fallback
+// for input that parses to `null`, and the array guard covers valid JSON that
+// is not an array; either would otherwise reach `.map` and throw, which in
+// browser SDK code takes the whole tag down.
+const getParsedCategoryId = (category) => { var _a; return (_a = tryParse(category)) === null || _a === void 0 ? void 0 : _a.value; };
 const getCategories = (categoryMapping) => {
-    let categoryMappings = [];
-    try {
-        categoryMappings = JSON.parse(categoryMapping || '[]');
-    }
-    catch {
+    const categoryMappings = unpackMappings(categoryMapping, []);
+    if (!Array.isArray(categoryMappings)) {
         logger.error('Unable to parse category mappings');
-        categoryMappings = [];
+        return new Map();
     }
     return new Map(categoryMappings.map(({ storeCategory, appLovinCategory }) => [
         storeCategory.toLowerCase(),
@@ -743,6 +876,13 @@ const getEventUserData = (userId, data) => {
             userData.phone = normalizedPhone;
         }
     }
+    const zip = getNormalizedZip(data.zip, data.country_code);
+    if (zip) {
+        userData.zip = zip;
+    }
+    if (data.country_code) {
+        userData.country_code = data.country_code;
+    }
     return userData;
 };
 /**
@@ -754,9 +894,10 @@ const getEventUserData = (userId, data) => {
  * @param defaultCategory - JSON string containing default category configuration with label and value
  * @param categoryMapping - JSON string containing array of category mappings
  * @param userId - The explicit user ID to use in event user_data
+ * @param isNewCustomer - New/returning buyer flag, applied to Purchase only
  * @returns EventData payload if the event is supported, undefined otherwise
  */
-const getEventData = ({ eventName, userData, data, defaultCategory, categoryMapping, userId, }) => {
+const getEventData = ({ eventName, userData, data, defaultCategory, categoryMapping, userId, isNewCustomer, }) => {
     var _a, _b, _c;
     const categories = getCategories(categoryMapping);
     const defaultCategoryId = getParsedCategoryId(defaultCategory);
@@ -855,6 +996,9 @@ const getEventData = ({ eventName, userData, data, defaultCategory, categoryMapp
                     shipping: (_b = data.shippingCost) !== null && _b !== void 0 ? _b : 0,
                     tax: (_c = data.taxCost) !== null && _c !== void 0 ? _c : 0,
                     user_data: getEventUserData(userId, userData),
+                    ...(typeof isNewCustomer === 'boolean' && {
+                        measurement: { is_new_customer: isNewCustomer },
+                    }),
                 },
             };
         }
@@ -901,9 +1045,14 @@ const getEventData = ({ eventName, userData, data, defaultCategory, categoryMapp
     }
 };
 
-const tag = ({ data, eventName, eventId, manifestVariables, userId, destination, }) => {
+const getString = (kv, key) => {
+    const value = kv === null || kv === void 0 ? void 0 : kv[key];
+    return typeof value === 'string' && value ? value : undefined;
+};
+const tag = ({ data, eventName, eventId, manifestVariables, userId, destination, getEdgeData, }) => {
+    var _a, _b;
     const payload = {
-        sdkVersion: "1.71.1" ,
+        sdkVersion: "1.72.0" ,
     };
     if (window.axon && manifestVariables['enableBrowser'] === '1') {
         try {
@@ -912,28 +1061,68 @@ const tag = ({ data, eventName, eventId, manifestVariables, userId, destination,
             // email/phone usually arrive via the data API (stored in session KV),
             // not on the event payload itself.
             const kv = getData(destination, 'session')['kv'];
+            // Same identity set the CAPI attaches server-side, so the browser pixel
+            // is not the weaker of the two paths on a shopper we already know.
             const userData = { user_id: userId };
-            const email = (data === null || data === void 0 ? void 0 : data['email']) || (kv === null || kv === void 0 ? void 0 : kv['email']);
-            if (email && typeof email === 'string') {
+            // Checked per source rather than after the `||`, so a non-string on the
+            // payload cannot displace a valid string in KV.
+            const email = (_a = getString(data, 'email')) !== null && _a !== void 0 ? _a : getString(kv, 'email');
+            if (email) {
                 userData.email = email;
             }
-            const phone = (data === null || data === void 0 ? void 0 : data['phone']) || (kv === null || kv === void 0 ? void 0 : kv['phone']);
-            if (phone && typeof phone === 'string') {
+            const phone = (_b = getString(data, 'phone')) !== null && _b !== void 0 ? _b : getString(kv, 'phone');
+            if (phone) {
                 userData.phone = phone;
             }
-            const event = getEventData({
-                eventName,
-                userData,
-                data,
-                defaultCategory,
-                categoryMapping,
-                userId,
-            });
-            if (!event) {
-                logger.log(`[${packageName}] ${eventName} not supported`);
-                return;
+            const zip = getString(kv, 'zip');
+            if (zip) {
+                userData.zip = zip;
+            }
+            const country = getString(kv, 'country');
+            if (country) {
+                userData.country_code = country;
+            }
+            const send = (isNewCustomer) => {
+                var _a;
+                const event = getEventData({
+                    eventName,
+                    userData,
+                    data,
+                    defaultCategory,
+                    categoryMapping,
+                    userId,
+                    isNewCustomer,
+                });
+                if (!event) {
+                    logger.log(`[${packageName}] ${eventName} not supported`);
+                    return;
+                }
+                (_a = window.axon) === null || _a === void 0 ? void 0 : _a.call(window, 'track', event.name, event.data, { dedupe_id: eventId });
+            };
+            if (eventName !== 'Purchase') {
+                send();
+                return payload;
+            }
+            // Prefer the flag already saved in the browser (the Shopify pixel's
+            // `data` call writes it just before Purchase). Only query the edge when
+            // the browser value is missing.
+            const browserValue = destination
+                ? getIsNewCustomerFromBrowser(destination)
+                : undefined;
+            if (typeof browserValue === 'boolean') {
+                send(browserValue);
+            }
+            else if (getEdgeData) {
+                getIsNewCustomerFlag(getEdgeData)
+                    // The fallback is the rejection handler rather than a trailing
+                    // `catch`, so only a failed lookup sends without the flag; a `send`
+                    // that throws must not be retried into a duplicate pixel call.
+                    .then(send, () => send())
+                    .catch((error) => logger.error(error));
+            }
+            else {
+                send();
             }
-            window.axon('track', event.name, event.data, { dedupe_id: eventId });
         }
         catch (e) {
             logger.error(e);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blotoutio/providers-app-lovin-sdk",
-  "version": "1.71.1",
+  "version": "1.72.0",
   "description": "App Lovin Browser SDK for EdgeTag",
   "author": "Blotout",
   "license": "MIT",