@mangostudio/cli-darwin-arm64 0.1.0 → 0.1.1-canary.00a342c

package/cursor-sidecar/node_modules/@fastify/busboy/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@fastify/busboy",
+  "version": "2.1.1",
+  "private": false,
+  "author": "Brian White <mscdex@mscdex.net>",
+  "contributors": [
+    {
+      "name": "Igor Savin",
+      "email": "kibertoad@gmail.com",
+      "url": "https://github.com/kibertoad"
+    },
+    {
+      "name": "Aras Abbasi",
+      "email": "aras.abbasi@gmail.com",
+      "url": "https://github.com/uzlopak"
+    }
+  ],
+  "description": "A streaming parser for HTML form data for node.js",
+  "main": "lib/main",
+  "type": "commonjs",
+  "types": "lib/main.d.ts",
+  "scripts": {
+    "bench:busboy": "cd benchmarks && npm install && npm run benchmark-fastify",
+    "bench:dicer": "node bench/dicer/dicer-bench-multipart-parser.js",
+    "coveralls": "nyc report --reporter=lcov",
+    "lint": "npm run lint:standard",
+    "lint:everything": "npm run lint && npm run test:types",
+    "lint:fix": "standard --fix",
+    "lint:standard": "standard --verbose | snazzy",
+    "test:mocha": "tap",
+    "test:types": "tsd",
+    "test:coverage": "nyc npm run test",
+    "test": "npm run test:mocha"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "devDependencies": {
+    "@types/node": "^20.1.0",
+    "busboy": "^1.0.0",
+    "photofinish": "^1.8.0",
+    "snazzy": "^9.0.0",
+    "standard": "^17.0.0",
+    "tap": "^16.3.8",
+    "tinybench": "^2.5.1",
+    "tsd": "^0.30.0",
+    "typescript": "^5.0.2"
+  },
+  "keywords": [
+    "uploads",
+    "forms",
+    "multipart",
+    "form-data"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fastify/busboy.git"
+  },
+  "tsd": {
+    "directory": "test/types",
+    "compilerOptions": {
+      "esModuleInterop": false,
+      "module": "commonjs",
+      "target": "ES2017"
+    }
+  },
+  "standard": {
+    "globals": [
+      "describe",
+      "it"
+    ],
+    "ignore": [
+      "bench"
+    ]
+  },
+  "files": [
+    "README.md",
+    "LICENSE",
+    "lib/*",
+    "deps/encoding/*",
+    "deps/dicer/lib",
+    "deps/streamsearch/",
+    "deps/dicer/LICENSE"
+  ]
+}

package/cursor-sidecar/node_modules/@statsig/client-core/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@statsig/client-core",
+  "version": "3.31.0",
+  "license": "ISC",
+  "homepage": "https://github.com/statsig-io/js-client-monorepo",
+  "repository": {
+    "type": "git",
+    "url": "github:statsig-io/js-client-monorepo",
+    "directory": "packages/client-core"
+  },
+  "dependencies": {},
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "typings": "./src/index.d.ts"
+}

package/cursor-sidecar/node_modules/@statsig/client-core/src/$_StatsigGlobal.d.ts

@@ -0,0 +1,19 @@
+import { StatsigClientInterface } from './ClientInterfaces';
+export type StatsigGlobal = {
+    [key: string]: unknown;
+    instances?: Record<string, StatsigClientInterface>;
+    firstInstance?: StatsigClientInterface;
+    acInstances?: Record<string, unknown>;
+    srInstances?: Record<string, unknown>;
+    firstSRInstance?: unknown;
+    instance: (sdkKey?: string) => StatsigClientInterface | undefined;
+};
+declare global {
+    let __STATSIG__: StatsigGlobal | undefined;
+    interface Window {
+        __STATSIG__: StatsigGlobal | undefined;
+    }
+}
+export declare const _getStatsigGlobal: () => StatsigGlobal;
+export declare const _getStatsigGlobalFlag: (flag: string) => unknown;
+export declare const _getInstance: (sdkKey: string) => StatsigClientInterface | undefined;

package/cursor-sidecar/node_modules/@statsig/client-core/src/$_StatsigGlobal.js

@@ -0,0 +1,41 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._getInstance = exports._getStatsigGlobalFlag = exports._getStatsigGlobal = void 0;
+const Log_1 = require("./Log");
+const _getStatsigGlobal = () => {
+    // Avoid ReferenceError, which is happening with Cloudflare pages
+    try {
+        return typeof __STATSIG__ !== 'undefined' ? __STATSIG__ : statsigGlobal;
+    }
+    catch (e) {
+        return statsigGlobal;
+    }
+};
+exports._getStatsigGlobal = _getStatsigGlobal;
+const _getStatsigGlobalFlag = (flag) => {
+    return (0, exports._getStatsigGlobal)()[flag];
+};
+exports._getStatsigGlobalFlag = _getStatsigGlobalFlag;
+const _getInstance = (sdkKey) => {
+    const gbl = (0, exports._getStatsigGlobal)();
+    if (!sdkKey) {
+        if (gbl.instances && Object.keys(gbl.instances).length > 1) {
+            Log_1.Log.warn('Call made to Statsig global instance without an SDK key but there is more than one client instance. If you are using mulitple clients, please specify the SDK key.');
+        }
+        return gbl.firstInstance;
+    }
+    return gbl.instances && gbl.instances[sdkKey];
+};
+exports._getInstance = _getInstance;
+const GLOBAL_KEY = '__STATSIG__';
+const _window = typeof window !== 'undefined' ? window : {};
+const _global = typeof global !== 'undefined' ? global : {};
+const _globalThis = typeof globalThis !== 'undefined' ? globalThis : {};
+const statsigGlobal = (_c = (_b = (_a = _window[GLOBAL_KEY]) !== null && _a !== void 0 ? _a : _global[GLOBAL_KEY]) !== null && _b !== void 0 ? _b : _globalThis[GLOBAL_KEY]) !== null && _c !== void 0 ? _c : {
+    instance: exports._getInstance,
+};
+_window[GLOBAL_KEY] = statsigGlobal;
+_global[GLOBAL_KEY] = statsigGlobal;
+_globalThis[GLOBAL_KEY] = statsigGlobal;

package/cursor-sidecar/node_modules/@statsig/client-core/src/CacheKey.d.ts

@@ -0,0 +1,4 @@
+import { StatsigUser } from './StatsigUser';
+export type CustomCacheKeyGenerator = (sdkKey: string, user: StatsigUser) => string;
+export declare function _getUserStorageKey(sdkKey: string, user: StatsigUser, customKeyGenerator?: CustomCacheKeyGenerator): string;
+export declare function _getStorageKey(sdkKey: string, user?: StatsigUser, customKeyGenerator?: CustomCacheKeyGenerator): string;

package/cursor-sidecar/node_modules/@statsig/client-core/src/CacheKey.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._getStorageKey = exports._getUserStorageKey = void 0;
+const Hashing_1 = require("./Hashing");
+function _getUserStorageKey(sdkKey, user, customKeyGenerator) {
+    var _a;
+    if (customKeyGenerator) {
+        return customKeyGenerator(sdkKey, user);
+    }
+    const cids = user && user.customIDs ? user.customIDs : {};
+    const parts = [
+        `uid:${(_a = user === null || user === void 0 ? void 0 : user.userID) !== null && _a !== void 0 ? _a : ''}`,
+        `cids:${Object.keys(cids)
+            .sort((leftKey, rightKey) => leftKey.localeCompare(rightKey))
+            .map((key) => `${key}-${cids[key]}`)
+            .join(',')}`,
+        `k:${sdkKey}`,
+    ];
+    return (0, Hashing_1._DJB2)(parts.join('|'));
+}
+exports._getUserStorageKey = _getUserStorageKey;
+function _getStorageKey(sdkKey, user, customKeyGenerator) {
+    if (user) {
+        return _getUserStorageKey(sdkKey, user, customKeyGenerator);
+    }
+    return (0, Hashing_1._DJB2)(`k:${sdkKey}`);
+}
+exports._getStorageKey = _getStorageKey;

package/cursor-sidecar/node_modules/@statsig/client-core/src/ClientInterfaces.d.ts

@@ -0,0 +1,62 @@
+import { DownloadConfigSpecsResponse } from './DownloadConfigSpecsResponse';
+import { ErrorBoundary } from './ErrorBoundary';
+import { DynamicConfigEvaluationOptions, ExperimentEvaluationOptions, FeatureGateEvaluationOptions, LayerEvaluationOptions, ParameterStoreEvaluationOptions } from './EvaluationOptions';
+import { AnyInitializeResponse, ClientInitializeResponseOptions } from './InitializeResponse';
+import { StatsigSession } from './SessionID';
+import { StatsigClientEventEmitterInterface } from './StatsigClientEventEmitter';
+import { EvaluationsDataAdapter, SpecsDataAdapter } from './StatsigDataAdapter';
+import { StatsigEvent } from './StatsigEvent';
+import { AnyStatsigOptions, StatsigRuntimeMutableOptions } from './StatsigOptionsCommon';
+import { DynamicConfig, Experiment, FeatureGate, Layer, ParameterStore } from './StatsigTypes';
+import { StatsigUpdateDetails } from './StatsigUpdateDetails';
+import { StatsigUser } from './StatsigUser';
+import { Flatten } from './TypingUtils';
+export interface StatsigClientCommonInterface extends StatsigClientEventEmitterInterface {
+    initializeSync(): StatsigUpdateDetails;
+    initializeAsync(): Promise<StatsigUpdateDetails>;
+    shutdown(): Promise<void>;
+    flush(): Promise<void>;
+    updateRuntimeOptions(options: StatsigRuntimeMutableOptions): void;
+}
+export type CommonContext = {
+    sdkKey: string;
+    options: AnyStatsigOptions;
+    errorBoundary: ErrorBoundary;
+    session: StatsigSession;
+    stableID: string | null;
+    sdkInstanceID: string;
+};
+export type OnDeviceEvaluationsContext = CommonContext & {
+    values: DownloadConfigSpecsResponse | null;
+};
+export interface OnDeviceEvaluationsInterface extends StatsigClientCommonInterface {
+    readonly dataAdapter: SpecsDataAdapter;
+    getContext(): OnDeviceEvaluationsContext;
+    checkGate(name: string, user: StatsigUser, options?: FeatureGateEvaluationOptions): boolean;
+    getFeatureGate(name: string, user: StatsigUser, options?: FeatureGateEvaluationOptions): FeatureGate;
+    getDynamicConfig(name: string, user: StatsigUser, options?: DynamicConfigEvaluationOptions): DynamicConfig;
+    getExperiment(name: string, user: StatsigUser, options?: ExperimentEvaluationOptions): Experiment;
+    getLayer(name: string, user: StatsigUser, options?: LayerEvaluationOptions): Layer;
+    logEvent(event: StatsigEvent, user: StatsigUser): void;
+    logEvent(eventName: string, user: StatsigUser, value?: string | number, metadata?: Record<string, string>): void;
+    getClientInitializeResponse(user: StatsigUser, options?: ClientInitializeResponseOptions): AnyInitializeResponse | null;
+}
+export type PrecomputedEvaluationsContext = Flatten<CommonContext & {
+    values: AnyInitializeResponse | null;
+    user: StatsigUser;
+}>;
+export interface PrecomputedEvaluationsInterface extends StatsigClientCommonInterface {
+    readonly dataAdapter: EvaluationsDataAdapter;
+    getContext(): PrecomputedEvaluationsContext;
+    updateUserSync(user: StatsigUser): StatsigUpdateDetails;
+    updateUserAsync(user: StatsigUser): Promise<StatsigUpdateDetails>;
+    checkGate(name: string, options?: FeatureGateEvaluationOptions): boolean;
+    getFeatureGate(name: string, options?: FeatureGateEvaluationOptions): FeatureGate;
+    getDynamicConfig(name: string, options?: DynamicConfigEvaluationOptions): DynamicConfig;
+    getExperiment(name: string, options?: ExperimentEvaluationOptions): Experiment;
+    getLayer(name: string, options?: LayerEvaluationOptions): Layer;
+    getParameterStore(name: string, options?: ParameterStoreEvaluationOptions): ParameterStore;
+    logEvent(event: StatsigEvent): void;
+    logEvent(eventName: string, value?: string | number, metadata?: Record<string, string>): void;
+}
+export type StatsigClientInterface = OnDeviceEvaluationsInterface | PrecomputedEvaluationsInterface;

package/cursor-sidecar/node_modules/@statsig/client-core/src/ClientInterfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cursor-sidecar/node_modules/@statsig/client-core/src/DataAdapterCore.d.ts

@@ -0,0 +1,29 @@
+import { NetworkCore } from './NetworkCore';
+import { DataAdapterAsyncOptions, DataAdapterResult, DataSource } from './StatsigDataAdapter';
+import { AnyStatsigOptions } from './StatsigOptionsCommon';
+import { StatsigUser, StatsigUserInternal } from './StatsigUser';
+export declare abstract class DataAdapterCore {
+    private _adapterName;
+    protected _cacheSuffix: string;
+    protected _options: AnyStatsigOptions | null;
+    private _sdkKey;
+    private _inMemoryCache;
+    private _lastModifiedStoreKey;
+    private _cacheLimit;
+    protected constructor(_adapterName: string, _cacheSuffix: string);
+    attach(sdkKey: string, options: AnyStatsigOptions | null, _network: NetworkCore | null): void;
+    getDataSync(user?: StatsigUser | undefined): DataAdapterResult | null;
+    setData(data: string, user?: StatsigUser): void;
+    protected _getIsCacheValueValid(current: DataAdapterResult): boolean;
+    protected _getDataAsyncImpl(current: DataAdapterResult | null, user?: StatsigUserInternal, options?: DataAdapterAsyncOptions): Promise<DataAdapterResult | null>;
+    protected _prefetchDataImpl(user?: StatsigUser, options?: DataAdapterAsyncOptions): Promise<void>;
+    protected abstract _fetchFromNetwork(current: string | null, user?: StatsigUser, options?: DataAdapterAsyncOptions, isCacheValidFor204?: boolean): Promise<string | null>;
+    protected abstract _getCacheKey(user?: StatsigUserInternal): string;
+    protected abstract _isCachedResultValidFor204(result: DataAdapterResult, user: StatsigUser | undefined): boolean;
+    private _fetchAndPrepFromNetwork;
+    protected _getSdkKey(): string;
+    private _loadFromCache;
+    private _writeToCache;
+    private _runLocalStorageCacheEviction;
+}
+export declare function _makeDataAdapterResult(source: DataSource, data: string, stableID: string | null, user?: StatsigUser): DataAdapterResult;

package/cursor-sidecar/node_modules/@statsig/client-core/src/DataAdapterCore.js

@@ -0,0 +1,216 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._makeDataAdapterResult = exports.DataAdapterCore = void 0;
+const Log_1 = require("./Log");
+const StableID_1 = require("./StableID");
+const StatsigUser_1 = require("./StatsigUser");
+const StorageProvider_1 = require("./StorageProvider");
+const TypedJsonParse_1 = require("./TypedJsonParse");
+const CACHE_LIMIT = 10;
+const MAX_CACHE_WRITE_ATTEMPTS = 8;
+class DataAdapterCore {
+    constructor(_adapterName, _cacheSuffix) {
+        this._adapterName = _adapterName;
+        this._cacheSuffix = _cacheSuffix;
+        this._options = null;
+        this._sdkKey = null;
+        this._cacheLimit = CACHE_LIMIT;
+        this._lastModifiedStoreKey = `statsig.last_modified_time.${_cacheSuffix}`;
+        this._inMemoryCache = new InMemoryCache();
+    }
+    attach(sdkKey, options, _network) {
+        this._sdkKey = sdkKey;
+        this._options = options;
+    }
+    getDataSync(user) {
+        const normalized = user && (0, StatsigUser_1._normalizeUser)(user, this._options);
+        const cacheKey = this._getCacheKey(normalized);
+        const inMem = this._inMemoryCache.get(cacheKey, normalized);
+        if (inMem && this._getIsCacheValueValid(inMem)) {
+            return inMem;
+        }
+        const cache = this._loadFromCache(cacheKey);
+        if (cache && this._getIsCacheValueValid(cache)) {
+            this._inMemoryCache.add(cacheKey, cache, this._cacheLimit);
+            return this._inMemoryCache.get(cacheKey, normalized);
+        }
+        return null;
+    }
+    setData(data, user) {
+        const normalized = user && (0, StatsigUser_1._normalizeUser)(user, this._options);
+        const cacheKey = this._getCacheKey(normalized);
+        this._inMemoryCache.add(cacheKey, _makeDataAdapterResult('Bootstrap', data, null, normalized), this._cacheLimit);
+    }
+    _getIsCacheValueValid(current) {
+        return (current.stableID == null ||
+            current.stableID === StableID_1.StableID.get(this._getSdkKey()));
+    }
+    _getDataAsyncImpl(current, user, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!StorageProvider_1.Storage.isReady()) {
+                yield StorageProvider_1.Storage.isReadyResolver();
+            }
+            const cache = current !== null && current !== void 0 ? current : this.getDataSync(user);
+            const ops = [this._fetchAndPrepFromNetwork(cache, user, options)];
+            if (options === null || options === void 0 ? void 0 : options.timeoutMs) {
+                ops.push(new Promise((r) => setTimeout(r, options.timeoutMs)).then(() => {
+                    Log_1.Log.debug('Fetching latest value timed out');
+                    return null;
+                }));
+            }
+            return yield Promise.race(ops);
+        });
+    }
+    _prefetchDataImpl(user, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const normalized = user && (0, StatsigUser_1._normalizeUser)(user, this._options);
+            const cacheKey = this._getCacheKey(normalized);
+            const result = yield this._getDataAsyncImpl(null, normalized, options);
+            if (result) {
+                this._inMemoryCache.add(cacheKey, Object.assign(Object.assign({}, result), { source: 'Prefetch' }), this._cacheLimit);
+            }
+        });
+    }
+    _fetchAndPrepFromNetwork(cachedResult, user, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const cachedData = (_a = cachedResult === null || cachedResult === void 0 ? void 0 : cachedResult.data) !== null && _a !== void 0 ? _a : null;
+            const isCacheValidFor204 = cachedResult != null &&
+                this._isCachedResultValidFor204(cachedResult, user);
+            const latest = yield this._fetchFromNetwork(cachedData, user, options, isCacheValidFor204);
+            if (!latest) {
+                Log_1.Log.debug('No response returned for latest value');
+                return null;
+            }
+            const response = (0, TypedJsonParse_1._typedJsonParse)(latest, 'has_updates', 'Response');
+            const sdkKey = this._getSdkKey();
+            const stableID = StableID_1.StableID.get(sdkKey);
+            let result = null;
+            if ((response === null || response === void 0 ? void 0 : response.has_updates) === true) {
+                result = _makeDataAdapterResult('Network', latest, stableID, user);
+            }
+            else if (cachedData && (response === null || response === void 0 ? void 0 : response.has_updates) === false) {
+                result = _makeDataAdapterResult('NetworkNotModified', cachedData, stableID, user);
+            }
+            else {
+                return null;
+            }
+            const cacheKey = this._getCacheKey(user);
+            this._inMemoryCache.add(cacheKey, result, this._cacheLimit);
+            this._writeToCache(cacheKey, result);
+            return result;
+        });
+    }
+    _getSdkKey() {
+        if (this._sdkKey != null) {
+            return this._sdkKey;
+        }
+        Log_1.Log.error(`${this._adapterName} is not attached to a Client`);
+        return '';
+    }
+    _loadFromCache(cacheKey) {
+        var _a;
+        const cache = (_a = StorageProvider_1.Storage.getItem) === null || _a === void 0 ? void 0 : _a.call(StorageProvider_1.Storage, cacheKey);
+        if (cache == null) {
+            return null;
+        }
+        const result = (0, TypedJsonParse_1._typedJsonParse)(cache, 'source', 'Cached Result');
+        return result ? Object.assign(Object.assign({}, result), { source: 'Cache' }) : null;
+    }
+    _writeToCache(cacheKey, result) {
+        const resultString = JSON.stringify(result);
+        for (let i = 0; i < MAX_CACHE_WRITE_ATTEMPTS; i++) {
+            try {
+                StorageProvider_1.Storage.setItem(cacheKey, resultString);
+                break;
+            }
+            catch (error) {
+                if (!(error instanceof Error) ||
+                    !(error.toString().includes('QuotaExceededError') ||
+                        error.toString().includes('QUOTA_EXCEEDED_ERR')) ||
+                    this._cacheLimit <= 1) {
+                    throw error;
+                }
+                this._cacheLimit = Math.ceil(this._cacheLimit / 2);
+                this._runLocalStorageCacheEviction(cacheKey, this._cacheLimit - 1);
+            }
+        }
+        this._runLocalStorageCacheEviction(cacheKey);
+    }
+    _runLocalStorageCacheEviction(cacheKey, cacheLimit = this._cacheLimit) {
+        var _a;
+        const lastModifiedTimeMap = (_a = (0, StorageProvider_1._getObjectFromStorage)(this._lastModifiedStoreKey)) !== null && _a !== void 0 ? _a : {};
+        lastModifiedTimeMap[cacheKey] = Date.now();
+        const evictableKeys = _getEvictableKeys(lastModifiedTimeMap, cacheLimit);
+        for (const evictable of evictableKeys) {
+            delete lastModifiedTimeMap[evictable];
+            StorageProvider_1.Storage.removeItem(evictable);
+        }
+        (0, StorageProvider_1._setObjectInStorage)(this._lastModifiedStoreKey, lastModifiedTimeMap);
+    }
+}
+exports.DataAdapterCore = DataAdapterCore;
+function _makeDataAdapterResult(source, data, stableID, user) {
+    return {
+        source,
+        data,
+        receivedAt: Date.now(),
+        stableID,
+        fullUserHash: (0, StatsigUser_1._getFullUserHash)(user),
+    };
+}
+exports._makeDataAdapterResult = _makeDataAdapterResult;
+class InMemoryCache {
+    constructor() {
+        this._data = {};
+    }
+    get(cacheKey, user) {
+        var _a;
+        const result = this._data[cacheKey];
+        const cached = result === null || result === void 0 ? void 0 : result.stableID;
+        const provided = (_a = user === null || user === void 0 ? void 0 : user.customIDs) === null || _a === void 0 ? void 0 : _a.stableID;
+        if (provided && cached && provided !== cached) {
+            Log_1.Log.warn("'StatsigUser.customIDs.stableID' mismatch");
+            return null;
+        }
+        return result;
+    }
+    add(cacheKey, value, cacheLimit) {
+        const evictableKeys = _getEvictableKeys(this._data, cacheLimit - 1);
+        for (const evictable of evictableKeys) {
+            delete this._data[evictable];
+        }
+        this._data[cacheKey] = value;
+    }
+    merge(values) {
+        this._data = Object.assign(Object.assign({}, this._data), values);
+    }
+}
+function _getEvictableKeys(data, limit) {
+    const keys = Object.keys(data);
+    if (keys.length <= limit) {
+        return [];
+    }
+    if (limit === 0) {
+        return keys;
+    }
+    return keys
+        .sort((keyA, keyB) => {
+        const valueA = data[keyA];
+        const valueB = data[keyB];
+        if (typeof valueA === 'object' && typeof valueB === 'object') {
+            return valueA.receivedAt - valueB.receivedAt;
+        }
+        return valueA - valueB;
+    })
+        .slice(0, keys.length - limit);
+}

package/cursor-sidecar/node_modules/@statsig/client-core/src/Diagnostics.d.ts

@@ -0,0 +1,67 @@
+import { EvaluationDetails } from './EvaluationTypes';
+import { EventLogger } from './EventLogger';
+import { NetworkConfigCommon, StatsigOptionsCommon } from './StatsigOptionsCommon';
+import { StatsigUserInternal } from './StatsigUser';
+export type KeyType = 'initialize' | 'overall';
+export type StepType = 'process' | 'network_request';
+export type ActionType = 'start' | 'end';
+export interface Marker {
+    key: KeyType;
+    action: ActionType;
+    timestamp: number;
+    step?: StepType;
+    statusCode?: number;
+    success?: boolean;
+    url?: string;
+    idListCount?: number;
+    sdkRegion?: string | null;
+    markerID?: string;
+    attempt?: number;
+    isRetry?: boolean;
+    configName?: string;
+    message?: string | null;
+    evaluationDetails?: EvaluationDetails;
+    error?: Record<string, unknown>;
+    isDelta?: boolean;
+}
+export declare const Diagnostics: {
+    _getMarkers: (sdkKey: string) => Marker[] | undefined;
+    _markInitOverallStart: (sdkKey: string) => void;
+    _markInitOverallEnd: (sdkKey: string, success: boolean, evaluationDetails?: EvaluationDetails) => void;
+    _markInitNetworkReqStart: (sdkKey: string, data: InitializeDataType['networkRequest']['start']) => void;
+    _markInitNetworkReqEnd: (sdkKey: string, data: InitializeDataType['networkRequest']['end']) => void;
+    _markInitProcessStart: (sdkKey: string) => void;
+    _markInitProcessEnd: (sdkKey: string, data: InitializeDataType['process']['end']) => void;
+    _clearMarkers: (sdkKey: string) => void;
+    _formatError(e: unknown): Record<string, unknown> | undefined;
+    _getDiagnosticsData(res: Response | null, attempt: number, body: string, e?: unknown): {
+        success: boolean;
+        isDelta?: boolean;
+        sdkRegion?: string | null;
+        statusCode?: number;
+        attempt: number;
+        error?: Record<string, unknown>;
+    };
+    _enqueueDiagnosticsEvent(user: StatsigUserInternal | null, logger: EventLogger, sdk: string, options: StatsigOptionsCommon<NetworkConfigCommon> | null): number;
+};
+interface InitializeDataType {
+    process: {
+        end: {
+            success: boolean;
+        };
+    };
+    networkRequest: {
+        start: {
+            attempt: number;
+        };
+        end: {
+            success: boolean;
+            attempt: number;
+            isDelta?: boolean;
+            sdkRegion?: string | null;
+            statusCode?: number;
+            error?: Record<string, unknown>;
+        };
+    };
+}
+export {};