@chordcommerce/analytics 1.23.1 → 1.24.1

package/README.md

@@ -121,8 +121,16 @@ export const cartFormatter: CartFormatter<StorefrontCart> = (props) => {
 addSourceMiddleware(func: AnalyticsMiddleware)
 
 Registers a middleware function to modify event properties before they are
-sent to analytics providers. Middleware functions are executed
-synchronously in the order they were added during event tracking.
+sent to analytics providers. Middleware functions are invoked in the order they
+were added during event tracking, and each one's properties are merged into the
+event in that order.
+
+A middleware may be synchronous or asynchronous. Synchronous middleware is never
+awaited, so it adds no delay to event delivery. Asynchronous middleware is
+awaited before the event is sent, capped at one second — a middleware that has
+not resolved by then is abandoned, a warning is logged, and the event is sent
+without its properties. A middleware that throws or rejects is logged and
+skipped. A middleware never prevents an event from being sent.
 
 Parameters
 
@@ -135,6 +143,15 @@ The middleware function can return:
 
 - Partial<EventProperties> - Properties to merge into the event payload
 - void - No additional properties to add
+- A Promise of either of the above - Awaited before the event is sent
+
+The `payload` argument carries `payload.obj` (the event's properties, name and
+page context) plus `payload.userId` and `payload.anonymousId` as the CDP
+currently knows them — either may be undefined.
+
+Note that middleware contributes properties by **returning** them. Mutating the
+`payload` argument has no effect; `next` is accepted for signature
+compatibility and does nothing.
 
 Useage Example
 
@@ -156,6 +173,15 @@ Useage Example
       timestamp: Date.now()
     };
   });
+
+  // Asynchronous middleware: the event waits for the lookup, up to one second.
+  analytics.addSourceMiddleware(async ({ payload }) => {
+    if (payload.obj.event !== 'Order Completed') return;
+
+    const isNewCustomer = await fetchIsNewCustomer();
+
+    return { is_new_customer: isNewCustomer ? 1 : 0 };
+  });
 ```
 
 ## API Reference

package/dist/cjs/client/index.d.ts

@@ -71,6 +71,7 @@ export declare class ChordAnalytics<T extends ObjectTypes = ObjectTypes> {
     setDebugMode: (enabled: boolean) => void;
     cdp: () => AnyAnalytics;
     ccdp: () => AnyAnalytics;
+    private currentUser;
     logger: (message?: any, ...optionalParams: any[]) => void;
     isResetting: () => boolean;
     private waitForReadyState;

package/dist/cjs/client/index.js

@@ -249,6 +249,32 @@ var ChordAnalytics = /** @class */ (function () {
                 return null;
             return (window === null || window === void 0 ? void 0 : window["_".concat(namespace)]) || (0, cdp_js_1.cdpQueue)(namespace);
         };
+        /*
+         * The current user and anonymous ids as the CDP knows them.
+         *
+         * Exposed to source middleware, which on Segment could read these from the
+         * event facade. Either CDP may be absent or may not implement `user()`, so
+         * every step is guarded and an unknown id is simply undefined.
+         */
+        this.currentUser = function () {
+            var read = function (analytics) {
+                var _a, _b, _c;
+                try {
+                    var user = (_a = analytics === null || analytics === void 0 ? void 0 : analytics.user) === null || _a === void 0 ? void 0 : _a.call(analytics);
+                    if (!user)
+                        return undefined;
+                    var userId = (_b = user.userId) !== null && _b !== void 0 ? _b : undefined;
+                    var anonymousId = (_c = user.anonymousId) !== null && _c !== void 0 ? _c : undefined;
+                    if (userId === undefined && anonymousId === undefined)
+                        return undefined;
+                    return { userId: userId, anonymousId: anonymousId };
+                }
+                catch (_d) {
+                    return undefined;
+                }
+            };
+            return read(_this.ccdp()) || read(_this.cdp()) || {};
+        };
         /*
          * Log a message to the console if `options.enableLogging` is true.
          */
@@ -510,44 +536,77 @@ var ChordAnalytics = /** @class */ (function () {
          * Internal method to actually send a track event to CDP.
          */
         this.sendTrackEvent = function (event, props, options) { return __awaiter(_this, void 0, void 0, function () {
-            var formattedProps, middlewareProps, searchParams_1, urlSearchParams, searchData_1, finalEventProps;
+            var formattedProps, middlewareProps, searchParams_1, urlSearchParams, searchData_1, _a, userId_1, anonymousId_1, invoke, settle, returned, results, _b, finalEventProps;
             var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         formattedProps = this.options.stripNull && props ? (0, utils_js_1.pruneNullValues)(props) : props;
                         middlewareProps = {};
-                        if (this.middleware.length > 0) {
-                            searchParams_1 = typeof window !== 'undefined' ? window.location.search : '';
-                            urlSearchParams = new URLSearchParams(searchParams_1);
-                            searchData_1 = Object.fromEntries(urlSearchParams.entries());
-                            // process middleware synchronously
-                            this.middleware.forEach(function (func) {
-                                try {
-                                    var result = func({
-                                        payload: {
-                                            obj: {
-                                                properties: props,
-                                                event: event,
-                                                context: {
-                                                    page: {
-                                                        search: searchParams_1,
-                                                        searchParams: searchData_1,
-                                                    },
+                        if (!(this.middleware.length > 0)) return [3 /*break*/, 4];
+                        searchParams_1 = typeof window !== 'undefined' ? window.location.search : '';
+                        urlSearchParams = new URLSearchParams(searchParams_1);
+                        searchData_1 = Object.fromEntries(urlSearchParams.entries());
+                        _a = this.currentUser(), userId_1 = _a.userId, anonymousId_1 = _a.anonymousId;
+                        invoke = function (func) {
+                            try {
+                                return func({
+                                    payload: {
+                                        userId: userId_1,
+                                        anonymousId: anonymousId_1,
+                                        obj: {
+                                            properties: props,
+                                            event: event,
+                                            context: {
+                                                page: {
+                                                    search: searchParams_1,
+                                                    searchParams: searchData_1,
                                                 },
                                             },
                                         },
-                                        next: function (_) { return _; },
-                                    });
-                                    if (result && typeof result === 'object') {
-                                        middlewareProps = __assign(__assign({}, middlewareProps), result);
-                                    }
-                                }
-                                catch (error) {
-                                    console.warn('Middleware error:', error);
+                                    },
+                                    next: function (_) { return _; },
+                                });
+                            }
+                            catch (error) {
+                                console.warn('Middleware error:', error);
+                                return undefined;
+                            }
+                        };
+                        settle = function (returned) {
+                            if (!(0, utils_js_1.isPromise)(returned))
+                                return returned;
+                            return (0, utils_js_1.withTimeout)(returned, utils_js_1.MIDDLEWARE_TIMEOUT_MS)
+                                .then(function (settled) {
+                                if (settled === utils_js_1.TIMED_OUT) {
+                                    console.warn("Middleware timed out after ".concat(utils_js_1.MIDDLEWARE_TIMEOUT_MS, "ms; its properties were dropped"));
+                                    return undefined;
                                 }
+                                return settled;
+                            })
+                                .catch(function (error) {
+                                console.warn('Middleware error:', error);
+                                return undefined;
                             });
-                        }
+                        };
+                        returned = this.middleware.map(invoke);
+                        if (!returned.some(utils_js_1.isPromise)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, Promise.all(returned.map(settle))];
+                    case 1:
+                        _b = _c.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _b = returned;
+                        _c.label = 3;
+                    case 3:
+                        results = _b;
+                        results.forEach(function (result) {
+                            if (result && typeof result === 'object') {
+                                middlewareProps = __assign(__assign({}, middlewareProps), result);
+                            }
+                        });
+                        _c.label = 4;
+                    case 4:
                         finalEventProps = __assign(__assign(__assign({}, formattedProps), middlewareProps), { meta: this.meta() });
                         if (this.options.debug) {
                             this.validate(event, finalEventProps).forEach(function (valid) {
@@ -585,8 +644,8 @@ var ChordAnalytics = /** @class */ (function () {
                                     resolve();
                                 }
                             })];
-                    case 1:
-                        _a.sent();
+                    case 5:
+                        _c.sent();
                         return [2 /*return*/];
                 }
             });

package/dist/cjs/types/client.d.ts

@@ -88,10 +88,23 @@ type MiddlewarePayload = {
             page: PageContext;
         };
     };
+    /**
+     * The current user and anonymous ids, read from the CDP at send time.
+     * Segment's middleware payload exposes these as `userId()`/`anonymousId()`
+     * methods on a facade; they are plain values here.
+     */
+    userId?: string;
+    anonymousId?: string;
 };
 type MiddlewareArgs = {
     payload: MiddlewarePayload;
     next: <T>(arg: T) => T;
 };
-export type AnalyticsMiddleware = (args: MiddlewareArgs) => Partial<EventProperties> | void;
+export type MiddlewareResult = Partial<EventProperties> | void;
+/**
+ * A source middleware may be synchronous or asynchronous. An asynchronous one
+ * is awaited before the event is dispatched, bounded by a timeout — see
+ * `addSourceMiddleware` in the README.
+ */
+export type AnalyticsMiddleware = (args: MiddlewareArgs) => MiddlewareResult | Promise<MiddlewareResult>;
 export {};

package/dist/cjs/utils.d.ts

@@ -1,2 +1,21 @@
 import type { EventProperties } from './types/index.js';
 export declare const pruneNullValues: (props: EventProperties) => EventProperties;
+/**
+ * How long a single asynchronous source middleware may take before its
+ * contribution is abandoned.
+ *
+ * Middleware runs on the path to the CDP, so an unbounded wait would let one
+ * slow lookup hold up delivery indefinitely. `Order Completed` in particular
+ * fires on a confirmation page shoppers close, so a late event is a lost one.
+ */
+export declare const MIDDLEWARE_TIMEOUT_MS = 1000;
+/** Returned by {@link withTimeout} when the promise did not settle in time. */
+export declare const TIMED_OUT: unique symbol;
+export declare const isPromise: (value: unknown) => value is Promise<unknown>;
+/**
+ * Resolve `promise`, or {@link TIMED_OUT} if it has not settled within `ms`.
+ *
+ * The timer is cleared either way, so a promise that settles quickly does not
+ * leave a pending timeout behind.
+ */
+export declare const withTimeout: <T>(promise: Promise<T>, ms: number) => Promise<typeof TIMED_OUT | T>;

package/dist/cjs/utils.js

@@ -1,6 +1,42 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pruneNullValues = void 0;
+exports.withTimeout = exports.isPromise = exports.TIMED_OUT = exports.MIDDLEWARE_TIMEOUT_MS = exports.pruneNullValues = void 0;
 var pruneNullValues = function (props) {
     if (typeof props !== 'object' || props === null)
         return props;
@@ -23,3 +59,45 @@ var pruneNullValues = function (props) {
     return props;
 };
 exports.pruneNullValues = pruneNullValues;
+/**
+ * How long a single asynchronous source middleware may take before its
+ * contribution is abandoned.
+ *
+ * Middleware runs on the path to the CDP, so an unbounded wait would let one
+ * slow lookup hold up delivery indefinitely. `Order Completed` in particular
+ * fires on a confirmation page shoppers close, so a late event is a lost one.
+ */
+exports.MIDDLEWARE_TIMEOUT_MS = 1000;
+/** Returned by {@link withTimeout} when the promise did not settle in time. */
+exports.TIMED_OUT = Symbol('timed-out');
+var isPromise = function (value) {
+    return typeof (value === null || value === void 0 ? void 0 : value.then) === 'function';
+};
+exports.isPromise = isPromise;
+/**
+ * Resolve `promise`, or {@link TIMED_OUT} if it has not settled within `ms`.
+ *
+ * The timer is cleared either way, so a promise that settles quickly does not
+ * leave a pending timeout behind.
+ */
+var withTimeout = function (promise, ms) { return __awaiter(void 0, void 0, void 0, function () {
+    var timer, timeout;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                timeout = new Promise(function (resolve) {
+                    timer = setTimeout(function () { return resolve(exports.TIMED_OUT); }, ms);
+                });
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, , 3, 4]);
+                return [4 /*yield*/, Promise.race([promise, timeout])];
+            case 2: return [2 /*return*/, _a.sent()];
+            case 3:
+                clearTimeout(timer);
+                return [7 /*endfinally*/];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+exports.withTimeout = withTimeout;

package/dist/client/index.d.ts

@@ -71,6 +71,7 @@ export declare class ChordAnalytics<T extends ObjectTypes = ObjectTypes> {
     setDebugMode: (enabled: boolean) => void;
     cdp: () => AnyAnalytics;
     ccdp: () => AnyAnalytics;
+    private currentUser;
     logger: (message?: any, ...optionalParams: any[]) => void;
     isResetting: () => boolean;
     private waitForReadyState;

package/dist/client/index.js

@@ -11,7 +11,7 @@ import { addCdpSnippet, cdpQueue } from './cdp.js';
 import { addCdpConsent } from './consent/index.js';
 import { claimConsentEmit, commitConsentEmit, forgetConsent, releaseConsentEmit, } from './consent/persistence.js';
 import { eventSchemas } from '../validators/index.js';
-import { pruneNullValues } from '../utils.js';
+import { isPromise, MIDDLEWARE_TIMEOUT_MS, pruneNullValues, TIMED_OUT, withTimeout, } from '../utils.js';
 const DEBUG_MODE_STORAGE_KEY = 'chordcommerce/analytics/debug';
 const CONSENT_QUEUE_STORAGE_KEY = 'chordcommerce/analytics/consent-queue';
 const CONSENT_QUEUE_TTL_MS = 5 * 60 * 1000; // 5 minutes
@@ -198,6 +198,32 @@ export class ChordAnalytics {
                 return null;
             return (window === null || window === void 0 ? void 0 : window[`_${namespace}`]) || cdpQueue(namespace);
         };
+        /*
+         * The current user and anonymous ids as the CDP knows them.
+         *
+         * Exposed to source middleware, which on Segment could read these from the
+         * event facade. Either CDP may be absent or may not implement `user()`, so
+         * every step is guarded and an unknown id is simply undefined.
+         */
+        this.currentUser = () => {
+            const read = (analytics) => {
+                var _a, _b, _c;
+                try {
+                    const user = (_a = analytics === null || analytics === void 0 ? void 0 : analytics.user) === null || _a === void 0 ? void 0 : _a.call(analytics);
+                    if (!user)
+                        return undefined;
+                    const userId = (_b = user.userId) !== null && _b !== void 0 ? _b : undefined;
+                    const anonymousId = (_c = user.anonymousId) !== null && _c !== void 0 ? _c : undefined;
+                    if (userId === undefined && anonymousId === undefined)
+                        return undefined;
+                    return { userId, anonymousId };
+                }
+                catch (_d) {
+                    return undefined;
+                }
+            };
+            return read(this.ccdp()) || read(this.cdp()) || {};
+        };
         /*
          * Log a message to the console if `options.enableLogging` is true.
          */
@@ -404,11 +430,13 @@ export class ChordAnalytics {
                 const searchParams = typeof window !== 'undefined' ? window.location.search : '';
                 const urlSearchParams = new URLSearchParams(searchParams);
                 const searchData = Object.fromEntries(urlSearchParams.entries());
-                // process middleware synchronously
-                this.middleware.forEach((func) => {
+                const { userId, anonymousId } = this.currentUser();
+                const invoke = (func) => {
                     try {
-                        const result = func({
+                        return func({
                             payload: {
+                                userId,
+                                anonymousId,
                                 obj: {
                                     properties: props,
                                     event,
@@ -422,12 +450,44 @@ export class ChordAnalytics {
                             },
                             next: (_) => _,
                         });
-                        if (result && typeof result === 'object') {
-                            middlewareProps = Object.assign(Object.assign({}, middlewareProps), result);
-                        }
                     }
                     catch (error) {
                         console.warn('Middleware error:', error);
+                        return undefined;
+                    }
+                };
+                /**
+                 * Give an asynchronous middleware until MIDDLEWARE_TIMEOUT_MS to produce
+                 * its properties. Neither a timeout nor a rejection is allowed to reach
+                 * the caller: a middleware must never cost the event.
+                 */
+                const settle = (returned) => {
+                    if (!isPromise(returned))
+                        return returned;
+                    return withTimeout(returned, MIDDLEWARE_TIMEOUT_MS)
+                        .then((settled) => {
+                        if (settled === TIMED_OUT) {
+                            console.warn(`Middleware timed out after ${MIDDLEWARE_TIMEOUT_MS}ms; its properties were dropped`);
+                            return undefined;
+                        }
+                        return settled;
+                    })
+                        .catch((error) => {
+                        console.warn('Middleware error:', error);
+                        return undefined;
+                    });
+                };
+                // Every middleware is invoked in registration order, as before. Only if
+                // one actually returned a promise is anything awaited -- so a set of
+                // purely synchronous middleware reaches the CDP on the same tick it
+                // always has, and callers that never await `track()` are unaffected.
+                const returned = this.middleware.map(invoke);
+                const results = returned.some(isPromise)
+                    ? yield Promise.all(returned.map(settle))
+                    : returned;
+                results.forEach((result) => {
+                    if (result && typeof result === 'object') {
+                        middlewareProps = Object.assign(Object.assign({}, middlewareProps), result);
                     }
                 });
             }

package/dist/types/client.d.ts

@@ -88,10 +88,23 @@ type MiddlewarePayload = {
             page: PageContext;
         };
     };
+    /**
+     * The current user and anonymous ids, read from the CDP at send time.
+     * Segment's middleware payload exposes these as `userId()`/`anonymousId()`
+     * methods on a facade; they are plain values here.
+     */
+    userId?: string;
+    anonymousId?: string;
 };
 type MiddlewareArgs = {
     payload: MiddlewarePayload;
     next: <T>(arg: T) => T;
 };
-export type AnalyticsMiddleware = (args: MiddlewareArgs) => Partial<EventProperties> | void;
+export type MiddlewareResult = Partial<EventProperties> | void;
+/**
+ * A source middleware may be synchronous or asynchronous. An asynchronous one
+ * is awaited before the event is dispatched, bounded by a timeout — see
+ * `addSourceMiddleware` in the README.
+ */
+export type AnalyticsMiddleware = (args: MiddlewareArgs) => MiddlewareResult | Promise<MiddlewareResult>;
 export {};

package/dist/utils.d.ts

@@ -1,2 +1,21 @@
 import type { EventProperties } from './types/index.js';
 export declare const pruneNullValues: (props: EventProperties) => EventProperties;
+/**
+ * How long a single asynchronous source middleware may take before its
+ * contribution is abandoned.
+ *
+ * Middleware runs on the path to the CDP, so an unbounded wait would let one
+ * slow lookup hold up delivery indefinitely. `Order Completed` in particular
+ * fires on a confirmation page shoppers close, so a late event is a lost one.
+ */
+export declare const MIDDLEWARE_TIMEOUT_MS = 1000;
+/** Returned by {@link withTimeout} when the promise did not settle in time. */
+export declare const TIMED_OUT: unique symbol;
+export declare const isPromise: (value: unknown) => value is Promise<unknown>;
+/**
+ * Resolve `promise`, or {@link TIMED_OUT} if it has not settled within `ms`.
+ *
+ * The timer is cleared either way, so a promise that settles quickly does not
+ * leave a pending timeout behind.
+ */
+export declare const withTimeout: <T>(promise: Promise<T>, ms: number) => Promise<typeof TIMED_OUT | T>;

package/dist/utils.js

@@ -1,3 +1,12 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 export const pruneNullValues = (props) => {
     if (typeof props !== 'object' || props === null)
         return props;
@@ -19,3 +28,33 @@ export const pruneNullValues = (props) => {
     }
     return props;
 };
+/**
+ * How long a single asynchronous source middleware may take before its
+ * contribution is abandoned.
+ *
+ * Middleware runs on the path to the CDP, so an unbounded wait would let one
+ * slow lookup hold up delivery indefinitely. `Order Completed` in particular
+ * fires on a confirmation page shoppers close, so a late event is a lost one.
+ */
+export const MIDDLEWARE_TIMEOUT_MS = 1000;
+/** Returned by {@link withTimeout} when the promise did not settle in time. */
+export const TIMED_OUT = Symbol('timed-out');
+export const isPromise = (value) => typeof (value === null || value === void 0 ? void 0 : value.then) === 'function';
+/**
+ * Resolve `promise`, or {@link TIMED_OUT} if it has not settled within `ms`.
+ *
+ * The timer is cleared either way, so a promise that settles quickly does not
+ * leave a pending timeout behind.
+ */
+export const withTimeout = (promise, ms) => __awaiter(void 0, void 0, void 0, function* () {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(TIMED_OUT), ms);
+    });
+    try {
+        return yield Promise.race([promise, timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+});

package/package.json

@@ -1,8 +1,18 @@
 {
   "name": "@chordcommerce/analytics",
   "description": "Chord Commerce event tracking",
-  "version": "1.23.1",
+  "version": "1.24.1",
   "author": "Chord Commerce <help@chord.co> (https://www.chord.co)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chordcommerce/chord-pixel.git",
+    "directory": "packages/core"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "@chordcommerce:registry": "https://registry.npmjs.org/",
+    "provenance": false
+  },
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",