make-mp-data 3.0.2 → 3.0.4

package/lib/orchestrators/mixpanel-sender.js

@@ -6,7 +6,6 @@
 /** @typedef {import('../../types').Context} Context */
 
 import dayjs from "dayjs";
-import path from "path";
 import { comma, ls, rm } from "ak-tools";
 import * as u from "../utils/utils.js";
 import mp from "mixpanel-import";
@@ -22,8 +21,6 @@ export async function sendToMixpanel(context) {
 		adSpendData,
 		eventData,
 		groupProfilesData,
-		lookupTableData,
-		mirrorEventData,
 		scdTableData,
 		userProfilesData,
 		groupEventData
@@ -41,35 +38,36 @@ export async function sendToMixpanel(context) {
 
 	const importResults = { events: {}, users: {}, groups: [] };
 	const isBATCH_MODE = context.isBatchMode();
-	const NODE_ENV = process.env.NODE_ENV || "unknown";
+	_verbose = config.verbose !== false;
 
 	/** @type {import('mixpanel-import').Creds} */
 	const creds = { token };
 	const mpImportFormat = format === "json" ? "jsonl" : "csv";
 
-	const isDev = NODE_ENV !== 'production';
-
 	/** @type {import('mixpanel-import').Options} */
 	const commonOpts = {
 		region,
 		fixData: true,
-		verbose: isDev,
+		verbose: false,
 		forceStream: true,
 		strict: true,
 		epochEnd: dayjs().unix(),
 		dryRun: false,
 		abridged: false,
 		fixJson: false,
-		showProgress: isDev,
+		showProgress: !!config.verbose,
 		streamFormat: mpImportFormat,
 		workers: 35
 	};
 
+	log(`\n${'─'.repeat(50)}`);
+	log(`  Importing data to Mixpanel (${region})`);
+	log(`${'─'.repeat(50)}\n`);
+
 	// Import events
 	if (eventData?.length > 0 || isBATCH_MODE) {
-		log(`importing events to mixpanel...\n`);
+		log(`  Events`);
 		let eventDataToImport = u.deepClone(eventData);
-		// Check if we need to read from disk files instead of memory
 		const shouldReadFromFiles = isBATCH_MODE || (writeToDisk && eventData && eventData.length === 0);
 		if (shouldReadFromFiles && eventData?.getWriteDir) {
 			const writeDir = eventData.getWriteDir();
@@ -81,15 +79,14 @@ export async function sendToMixpanel(context) {
 			recordType: "event",
 			...commonOpts,
 		});
-		log(`\tsent ${comma(imported.success)} events\n`);
+		log(`  -> ${comma(imported.success)} events sent\n`);
 		importResults.events = imported;
 	}
 
 	// Import user profiles
 	if (userProfilesData?.length > 0 || isBATCH_MODE) {
-		log(`importing user profiles to mixpanel...\n`);
+		log(`  User Profiles`);
 		let userProfilesToImport = u.deepClone(userProfilesData);
-		// Check if we need to read from disk files instead of memory
 		const shouldReadFromFiles = isBATCH_MODE || (writeToDisk && userProfilesData && userProfilesData.length === 0);
 		if (shouldReadFromFiles && userProfilesData?.getWriteDir) {
 			const writeDir = userProfilesData.getWriteDir();
@@ -101,15 +98,14 @@ export async function sendToMixpanel(context) {
 			recordType: "user",
 			...commonOpts,
 		});
-		log(`\tsent ${comma(imported.success)} user profiles\n`);
+		log(`  -> ${comma(imported.success)} user profiles sent\n`);
 		importResults.users = imported;
 	}
 
 	// Import ad spend data
 	if (adSpendData?.length > 0 || isBATCH_MODE) {
-		log(`importing ad spend data to mixpanel...\n`);
+		log(`  Ad Spend`);
 		let adSpendDataToImport = u.deepClone(adSpendData);
-		// Check if we need to read from disk files instead of memory
 		const shouldReadFromFiles = isBATCH_MODE || (writeToDisk && adSpendData && adSpendData.length === 0);
 		if (shouldReadFromFiles && adSpendData?.getWriteDir) {
 			const writeDir = adSpendData.getWriteDir();
@@ -121,7 +117,7 @@ export async function sendToMixpanel(context) {
 			recordType: "event",
 			...commonOpts,
 		});
-		log(`\tsent ${comma(imported.success)} ad spend events\n`);
+		log(`  -> ${comma(imported.success)} ad spend events sent\n`);
 		importResults.adSpend = imported;
 	}
 
@@ -130,9 +126,8 @@ export async function sendToMixpanel(context) {
 		for (const groupEntity of groupProfilesData) {
 			if (!groupEntity || groupEntity.length === 0) continue;
 			const groupKey = groupEntity?.groupKey;
-			log(`importing ${groupKey} profiles to mixpanel...\n`);
+			log(`  Group Profiles (${groupKey})`);
 			let groupProfilesToImport = u.deepClone(groupEntity);
-			// Check if we need to read from disk files instead of memory
 			const shouldReadFromFiles = isBATCH_MODE || (writeToDisk && groupEntity.length === 0);
 			if (shouldReadFromFiles && groupEntity?.getWriteDir) {
 				const writeDir = groupEntity.getWriteDir();
@@ -145,16 +140,15 @@ export async function sendToMixpanel(context) {
 				...commonOpts,
 				groupKey,
 			});
-			log(`\tsent ${comma(imported.success)} ${groupKey} profiles\n`);
+			log(`  -> ${comma(imported.success)} ${groupKey} profiles sent\n`);
 			importResults.groups.push(imported);
 		}
 	}
 
 	// Import group events
 	if (groupEventData?.length > 0) {
-		log(`importing group events to mixpanel...\n`);
+		log(`  Group Events`);
 		let groupEventDataToImport = u.deepClone(groupEventData);
-		// Check if we need to read from disk files instead of memory
 		const shouldReadFromFiles = isBATCH_MODE || (writeToDisk && groupEventData.length === 0);
 		if (shouldReadFromFiles && groupEventData?.getWriteDir) {
 			const writeDir = groupEventData.getWriteDir();
@@ -167,33 +161,28 @@ export async function sendToMixpanel(context) {
 			...commonOpts,
 			strict: false
 		});
-		log(`\tsent ${comma(imported.success)} group events\n`);
+		log(`  -> ${comma(imported.success)} group events sent\n`);
 		importResults.groupEvents = imported;
 	}
 
 	// Import SCD data (requires service account)
 	if (serviceAccount && projectId && serviceSecret) {
 		if (scdTableData && Array.isArray(scdTableData) && scdTableData.length > 0) {
-			log(`importing SCD data to mixpanel...\n`);
 			for (const scdEntity of scdTableData) {
 				const scdKey = scdEntity?.scdKey;
 				const entityType = scdEntity?.entityType || 'user';
-				log(`importing ${scdKey} SCD data to mixpanel...\n`);
+				log(`  SCD: ${scdKey}`);
 				let scdDataToImport = u.deepClone(scdEntity);
-				// Check if we need to read from disk files instead of memory
 				const shouldReadFromFiles = isBATCH_MODE || (writeToDisk && scdEntity && scdEntity.length === 0);
 				if (shouldReadFromFiles && scdEntity?.getWriteDir) {
 					const writeDir = scdEntity.getWriteDir();
 					const files = await ls(writeDir);
 					// @ts-ignore
 					scdDataToImport = files.filter(f => f.includes(`-${scdKey}-SCD`))?.pop();
-
 				}
 
-				// Derive the data type from the actual SCD data
-				// todo: we can do better type inference here we don't need to visit the file
 				/** @type {"string" | "number" | "boolean"} */
-			let scdType = 'string'; // default to string
+				let scdType = 'string';
 				const scdExamplesValues = context.config.scdProps[Object.keys(context.config.scdProps).find(k => k === scdKey)].values;
 				if (scdExamplesValues) {
 					if (typeof scdExamplesValues[0] === 'number') {
@@ -203,8 +192,6 @@ export async function sendToMixpanel(context) {
 					}
 				}
 
-
-
 				/** @type {import('mixpanel-import').Options} */
 				const options = {
 					recordType: "scd",
@@ -215,12 +202,10 @@ export async function sendToMixpanel(context) {
 					...commonOpts,
 				};
 
-				// For group SCDs, add the groupKey
 				if (entityType !== "user") {
 					options.groupKey = entityType;
 				}
 
-				// SCD data is sketch and it shouldn't fail the whole import
 				try {
 					const imported = await mp(
 						{
@@ -232,16 +217,18 @@ export async function sendToMixpanel(context) {
 						scdDataToImport,
 						options
 					);
-					log(`\tsent ${comma(imported.success)} ${scdKey} SCD data\n`);
+					log(`  -> ${comma(imported.success)} ${scdKey} SCD entries sent\n`);
 					importResults[`${scdKey}_scd`] = imported;
 				} catch (err) {
-					log(`\tfailed to import ${scdKey} SCD data: ${err.message}\n`);
+					log(`  !! failed: ${scdKey} SCD — ${err.message}\n`);
 					importResults[`${scdKey}_scd`] = { success: 0, failed: 0, error: err.message };
 				}
 			}
 		}
 	}
 
+	log(`${'─'.repeat(50)}\n`);
+
 	// Clean up batch files if needed
 	if (!writeToDisk && isBATCH_MODE) {
 		const writeDir = eventData?.getWriteDir?.() || userProfilesData?.getWriteDir?.();
@@ -265,9 +252,10 @@ export async function sendToMixpanel(context) {
 }
 
 /**
- * Simple logging function
+ * Logging function that respects verbose config
  * @param {string} message - Message to log
  */
+let _verbose = true;
 function log(message) {
-	console.log(message);
+	if (_verbose) console.log(message);
 }

package/lib/orchestrators/user-loop.js

@@ -23,7 +23,7 @@ import { makeSCD } from "../generators/scd.js";
 export async function userLoop(context) {
 	const { config, storage, defaults } = context;
 	const chance = u.getChance();
-	const concurrency = config?.concurrency || Math.min(os.cpus().length * 2, 16);
+	const concurrency = config?.concurrency ?? 1;
 	const USER_CONN = pLimit(concurrency);
 
 	const {
@@ -55,8 +55,19 @@ export async function userLoop(context) {
 	// Track if we've already logged the strict event count message
 	let hasLoggedStrictCountReached = false;
 
+	// Handle graceful shutdown on SIGINT (Ctrl+C)
+	let cancelled = false;
+	const onSigint = () => {
+		cancelled = true;
+		if (verbose) console.log(`\n\nStopping generation (Ctrl+C)...\n`);
+	};
+	process.on('SIGINT', onSigint);
+
 	for (let i = 0; i < numUsers; i++) {
 		const userPromise = USER_CONN(async () => {
+			// Bail out if cancelled
+			if (cancelled) return;
+
 			// Bail out early if strictEventCount is enabled and we've hit numEvents
 			if (strictEventCount && context.getEventCount() >= numEvents) {
 				if (verbose && !hasLoggedStrictCountReached) {
@@ -148,18 +159,22 @@ export async function userLoop(context) {
 
 			const userSCD = {};
 			for (const [index, key] of scdTableKeys.entries()) {
-				const { max = 100 } = scdProps[key];
+				const { max = 10 } = scdProps[key];
 				const mutations = chance.integer({ min: 1, max });
-				const changes = await makeSCD(context, scdProps[key], key, distinct_id, mutations, created);
+				let changes = await makeSCD(context, scdProps[key], key, distinct_id, mutations, created);
 				userSCD[key] = changes;
 
-				await config.hook(changes, "scd-pre", {
+				const hookResult = await config.hook(changes, "scd-pre", {
 					profile,
 					type: 'user',
 					scd: { [key]: scdProps[key] },
 					config,
 					allSCDs: userSCD
 				});
+				if (Array.isArray(hookResult)) {
+					changes = hookResult;
+					userSCD[key] = changes;
+				}
 			}
 
 			let numEventsThisUserWillPreform = Math.floor(chance.normal({
@@ -184,39 +199,74 @@ export async function userLoop(context) {
 			const secondsInDay = 86400;
 			const noise = () => chance.integer({ min: 0, max: secondsInDay });
 			let usersEvents = [];
+			let userConverted = true;
+
+			// Pre-compute weighted events array for standalone event selection
+			const weightedEvents = config.events.reduce((acc, event) => {
+				const w = Math.max(1, Math.min(Math.floor(event.weight) || 1, 10));
+				for (let i = 0; i < w; i++) acc.push(event);
+				return acc;
+			}, []);
+
+			// Build churn event lookup: { eventName: returnLikelihood }
+			const churnEvents = new Map();
+			for (const ev of config.events) {
+				if (ev.isChurnEvent) {
+					churnEvents.set(ev.event, ev.returnLikelihood ?? 0);
+				}
+			}
 
 			// PATH FOR USERS BORN IN DATASET AND PERFORMING FIRST FUNNEL
 			if (firstFunnels.length && userIsBornInDataset) {
 				const firstFunnel = chance.pickone(firstFunnels, user);
 				const firstTime = adjustedCreated.subtract(noise(), 'seconds').unix();
-				const [data, userConverted] = await makeFunnel(context, firstFunnel, user, firstTime, profile, userSCD);
+				const [data, converted] = await makeFunnel(context, firstFunnel, user, firstTime, profile, userSCD);
+				userConverted = converted;
 
 				const timeShift = context.getTimeShift();
 				userFirstEventTime = dayjs(data[0].time).subtract(timeShift, 'seconds').unix();
 				numEventsPreformed += data.length;
 				usersEvents = usersEvents.concat(data);
-
-				if (!userConverted) {
-					return;
-				}
 			} else {
 				userFirstEventTime = adjustedCreated.subtract(noise(), 'seconds').unix();
 			}
 
-			// ALL SUBSEQUENT FUNNELS
+			// ALL SUBSEQUENT EVENTS (funnels for converted users, standalone for all)
+			let userChurned = false;
 			while (numEventsPreformed < numEventsThisUserWillPreform) {
-				if (usageFunnels.length) {
+				let newEvents;
+				if (usageFunnels.length && userConverted) {
 					const currentFunnel = chance.pickone(usageFunnels);
-					const [data, userConverted] = await makeFunnel(context, currentFunnel, user, userFirstEventTime, profile, userSCD);
+					const [data, converted] = await makeFunnel(context, currentFunnel, user, userFirstEventTime, profile, userSCD);
 					numEventsPreformed += data.length;
-					usersEvents = usersEvents.concat(data);
+					newEvents = data;
 				} else {
-					const data = await makeEvent(context, distinct_id, userFirstEventTime, u.pick(config.events), user.anonymousIds, user.sessionIds, {}, config.groupKeys, true);
+					const data = await makeEvent(context, distinct_id, userFirstEventTime, u.pick(weightedEvents), user.anonymousIds, user.sessionIds, {}, config.groupKeys, true);
 					numEventsPreformed++;
-					usersEvents = usersEvents.concat(data);
+					newEvents = [data];
+				}
+				usersEvents = usersEvents.concat(newEvents);
+
+				// Check for churn events — if user churned, they may stop generating
+				if (churnEvents.size > 0) {
+					const eventsToCheck = Array.isArray(newEvents[0]) ? newEvents.flat() : newEvents;
+					for (const ev of eventsToCheck) {
+						if (ev.event && churnEvents.has(ev.event)) {
+							const returnLikelihood = churnEvents.get(ev.event);
+							const userReturns = returnLikelihood > 0 && chance.bool({ likelihood: returnLikelihood * 100 });
+							if (!userReturns) {
+								userChurned = true;
+								break;
+							}
+						}
+					}
+					if (userChurned) break;
 				}
 			}
 
+			// Remove events flagged as future timestamps (before dungeon hooks see them)
+			usersEvents = usersEvents.filter(e => !e._drop);
+
 			// Hook for processing all user events
 			if (config.hook) {
 				const newEvents = await config.hook(usersEvents, "everything", {
@@ -255,6 +305,9 @@ export async function userLoop(context) {
 
 	// Wait for all users to complete
 	await Promise.all(userPromises);
+
+	// Clean up SIGINT handler
+	process.removeListener('SIGINT', onSigint);
 }
 
 

package/lib/templates/phrases.js

@@ -3,6 +3,8 @@
  * Contains real human speech patterns, not templates
  */
 
+import { getChance } from '../utils/utils.js';
+
 // ============= Core Phrase Bank =============
 
 export const PHRASE_BANK = {
@@ -1970,17 +1972,18 @@ export const PHRASE_BANK = {
     
     // Helper function for ticket IDs
     TICKET_ID: () => {
+        const c = getChance();
         const prefix = ['TKT', 'CASE', 'REQ', 'INC', 'BUG'];
-        const p = prefix[Math.floor(Math.random() * prefix.length)];
-        const num = Math.floor(10000 + Math.random() * 90000);
+        const p = c.pickone(prefix);
+        const num = c.integer({ min: 10000, max: 99999 });
         return `${p}-${num}`;
     },
-    
+
     // Helper functions for random values
-    RAND5: () => Math.floor(10000 + Math.random() * 90000),
+    RAND5: () => getChance().integer({ min: 10000, max: 99999 }),
     RAND_ERROR: () => {
         const errors = ["404 Not Found", "500 Internal Server Error", "403 Forbidden", "Connection Timeout"];
-        return errors[Math.floor(Math.random() * errors.length)];
+        return getChance().pickone(errors);
     }
 };
 

package/lib/utils/function-registry.js

@@ -224,6 +224,23 @@ export const FUNCTION_REGISTRY = {
 		description: 'Generate Android device ID'
 	},
 
+	// Commonly used utility functions from dungeons
+	pickAWinner: {
+		minArgs: 1,
+		maxArgs: 2,
+		description: 'Pick from array with power-law weighting (most common values first)'
+	},
+	weighChoices: {
+		minArgs: 1,
+		maxArgs: 1,
+		description: 'Weight choices by frequency in array (more duplicates = higher weight)'
+	},
+	decimal: {
+		minArgs: 0,
+		maxArgs: 3,
+		description: 'Generate random decimal (min, max, fixed decimal places)'
+	},
+
 	// Special function for arrow functions
 	arrow: {
 		minArgs: 1,

package/lib/utils/utils.js

@@ -2,7 +2,6 @@ import fs from 'fs';
 import Chance from 'chance';
 import readline from 'readline';
 import { comma, uid } from 'ak-tools';
-import { spawn } from 'child_process';
 import dayjs from 'dayjs';
 import utc from 'dayjs/plugin/utc.js';
 import path from 'path';
@@ -474,7 +473,7 @@ function companyName(words = 2, separator = " ") {
 	const cycle = [industryAdjectives, companyNouns];
 	for (let i = 0; i < words; i++) {
 		const index = i % cycle.length;
-		const word = cycle[index][Math.floor(Math.random() * cycle[index].length)];
+		const word = cycle[index][getChance().integer({ min: 0, max: cycle[index].length - 1 })];
 		if (name === "") {
 			name = word;
 		} else {
@@ -873,9 +872,8 @@ function shuffleArray(array) {
 
 function pickRandom(array) {
 	if (!array || array.length === 0) return undefined;
-	// PERFORMANCE: Use Math.random() instead of chance.integer() for simple cases
-	const randomIndex = Math.floor(Math.random() * array.length);
-	return array[randomIndex];
+	const chance = getChance();
+	return chance.pickone(array);
 }
 
 function shuffleExceptFirst(array) {
@@ -1129,15 +1127,6 @@ function progress(arrayOfArrays) {
 	process.stdout.write(finalMessage);
 }
 
-function openFinder(path, callback) {
-	path = path || '/';
-	let p = spawn('open', [path]);
-	p.on('error', (err) => {
-		p.kill();
-		return callback(err);
-	});
-};
-
 function getUniqueKeys(data) {
 	const keysSet = new Set();
 	data.forEach(item => {
@@ -1186,57 +1175,20 @@ let soupHits = 0;
  * @param  {number} [latestTime]
  * @param  {number} [peaks=5]
  */
+/**
+ * Generates a timestamp within a time range using clustered normal distributions.
+ * Divides the range into `peaks` chunks, picks one randomly, then samples within it.
+ * Returns unix seconds (not ISO string) for performance — caller converts once.
+ */
 function TimeSoup(earliestTime, latestTime, peaks = 5, deviation = 2, mean = 0) {
-	if (!earliestTime) earliestTime = global.FIXED_BEGIN ? global.FIXED_BEGIN : dayjs().subtract(30, 'd').unix(); // 30 days ago
-	if (!latestTime) latestTime = global.FIXED_NOW ? global.FIXED_NOW : dayjs().unix();
-	const chance = getChance();
-	const totalRange = latestTime - earliestTime;
-	const chunkSize = totalRange / peaks;
-
-	// Select a random chunk based on the number of peaks
-	const peakIndex = integer(0, peaks - 1);
-	const chunkStart = earliestTime + peakIndex * chunkSize;
-	const chunkEnd = chunkStart + chunkSize;
-	const chunkMid = (chunkStart + chunkEnd) / 2;
-
-	// Generate a single timestamp within this chunk using a normal distribution centered at chunkMid
-	let offset;
-	let iterations = 0;
-	let isValidTime = false;
-	do {
-		iterations++;
-		soupHits++;
-		offset = chance.normal({ mean: mean, dev: chunkSize / deviation });
-		isValidTime = validTime(chunkMid + offset, earliestTime, latestTime);
-		if (iterations > 25000) {
-			throw `${iterations} iterations... exceeded`;
-		}
-	} while (chunkMid + offset < chunkStart || chunkMid + offset > chunkEnd);
-
-	try {
-		return dayjs.unix(chunkMid + offset).toISOString();
-	}
-
-	catch (e) {
-		//escape hatch
-		// console.log('BAD TIME', e?.message);
-		if (NODE_ENV === 'dev') debugger;
-		return dayjs.unix(integer(earliestTime, latestTime)).toISOString();
-	}
-}
-
-
-function NewTimeSoup(earliestTime, latestTime, peaks = 5, deviation = 2, mean = 0) {
-	if (!earliestTime) earliestTime = global.FIXED_BEGIN ? global.FIXED_BEGIN : dayjs().subtract(30, 'd').unix(); // 30 days ago
+	if (!earliestTime) earliestTime = global.FIXED_BEGIN ? global.FIXED_BEGIN : dayjs().subtract(30, 'd').unix();
 	if (!latestTime) latestTime = global.FIXED_NOW ? global.FIXED_NOW : dayjs().unix();
 	const chance = getChance();
 	let totalRange = latestTime - earliestTime;
 	if (totalRange <= 0 || earliestTime > latestTime) {
-		//just flip earliest and latest
-		let tempEarly = latestTime;
-		let tempLate = earliestTime;
-		earliestTime = tempEarly;
-		latestTime = tempLate;
+		const temp = latestTime;
+		latestTime = earliestTime;
+		earliestTime = temp;
 		totalRange = latestTime - earliestTime;
 	}
 	const chunkSize = totalRange / peaks;
@@ -1247,29 +1199,15 @@ function NewTimeSoup(earliestTime, latestTime, peaks = 5, deviation = 2, mean =
 	const chunkEnd = chunkStart + chunkSize;
 	const chunkMid = (chunkStart + chunkEnd) / 2;
 
-	// Optimized timestamp generation - clamp to valid range instead of looping
+	// Generate offset from normal distribution, clamp to chunk boundaries
 	const maxDeviation = chunkSize / deviation;
-	let offset = chance.normal({ mean: mean, dev: maxDeviation });
-
-	// Clamp to chunk boundaries to prevent infinite loops
+	const offset = chance.normal({ mean: mean, dev: maxDeviation });
 	const proposedTime = chunkMid + offset;
 	const clampedTime = Math.max(chunkStart, Math.min(chunkEnd, proposedTime));
-
-	// Ensure it's within the overall valid range
 	const finalTime = Math.max(earliestTime, Math.min(latestTime, clampedTime));
 
-	// Update soup hits counter (keep for compatibility)
 	soupHits++;
-
-	try {
-		return dayjs.unix(finalTime).toISOString();
-	}
-
-	catch (e) {
-		//escape hatch
-		// console.log('BAD TIME', e?.message);
-		return dayjs.unix(integer(earliestTime, latestTime)).toISOString();
-	}
+	return finalTime;
 }
 
 
@@ -1406,11 +1344,6 @@ function wrapFunc(obj, func, recursion = 0, parentKey = null, grandParentKey = n
 
 // }
 
-const chance = getChance();
-function odds(num) {
-	return chance.bool({ likelihood: num });
-}
-
 /**
  * makes a random-sized array of emojis
  * @param  {number} max=10
@@ -1505,7 +1438,6 @@ export {
 	initChance,
 	getChance,
 	decimal,
-	odds,
 	validTime,
 	validEvent,
 
@@ -1515,7 +1447,6 @@ export {
 	weighNumRange,
 	progress,
 	range,
-	openFinder,
 	getUniqueKeys,
 	person,
 	pickAWinner,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "make-mp-data",
-	"version": "3.0.2",
+	"version": "3.0.4",
 	"description": "builds all mixpanel primitives for a given project",
 	"type": "module",
 	"main": "index.js",
@@ -18,6 +18,7 @@
 	"scripts": {
 		"post": "npm publish",
 		"test": "NODE_ENV=test vitest run",
+		"test:coverage": "NODE_ENV=test vitest run --coverage",
 		"typecheck": "tsc --noEmit",
 		"dev": "nodemon scratch.mjs --ignore ./data/*",
 		"prune": "rm -f ./data/* && rm -f ./tmp/* && rm -f vscode-profile-*",
@@ -69,6 +70,7 @@
 		"yargs": "^17.7.2"
 	},
 	"devDependencies": {
+		"@vitest/coverage-v8": "^2.1.9",
 		"@vitest/ui": "^2.1.9",
 		"nodemon": "^3.1.3",
 		"typescript": "^5.6.0",