make-mp-data 2.1.11 → 3.0.1

package/lib/core/config-validator.js

@@ -11,7 +11,6 @@
 import dayjs from "dayjs";
 import { makeName } from "ak-tools";
 import * as u from "../utils/utils.js";
-import os from "os";
 
 /**
  * Infers funnels from the provided events
@@ -21,7 +20,10 @@ import os from "os";
 function inferFunnels(events) {
 	const createdFunnels = [];
 	const firstEvents = events.filter((e) => e.isFirstEvent).map((e) => e.event);
-	const usageEvents = events.filter((e) => !e.isFirstEvent).map((e) => e.event);
+	const strictEvents = events.filter((e) => e.isStrictEvent).map((e) => e.event);
+	const usageEvents = events
+		.filter((e) => !e.isFirstEvent && !e.isStrictEvent)
+		.map((e) => e.event);
 	const numFunnelsToCreate = Math.ceil(usageEvents.length);
 
 	/** @type {import('../../types.js').Funnel} */
@@ -55,8 +57,8 @@ function inferFunnels(events) {
 	for (let i = 1; i < numFunnelsToCreate; i++) {
 		/** @type {import('../../types.js').Funnel} */
 		const funnel = { ...u.deepClone(funnelTemplate) };
-		funnel.conversionRate = u.integer(25, 75);
-		funnel.timeToConvert = u.integer(1, 10);
+		funnel.conversionRate = u.integer(10, 50);
+		funnel.timeToConvert = u.integer(24, 72);
 		funnel.weight = u.integer(1, 10);
 		const sequence = u.shuffleArray(usageEvents).slice(0, u.integer(2, usageEvents.length));
 		funnel.sequence = sequence;
@@ -75,6 +77,10 @@ function inferFunnels(events) {
 export function validateDungeonConfig(config) {
 	const chance = u.getChance();
 
+	// Transform SCD props to regular props if credentials are missing
+	// This MUST happen BEFORE we extract values from the config
+	transformSCDPropsWithoutCredentials(config);
+
 	// Extract configuration with defaults
 	let {
 		seed,
@@ -101,6 +107,7 @@ export function validateDungeonConfig(config) {
 		region = "US",
 		writeToDisk = false,
 		verbose = true,
+		makeChart = false,
 		soup = {},
 		hook = (record) => record,
 		hasAdSpend = false,
@@ -115,7 +122,8 @@ export function validateDungeonConfig(config) {
 		alsoInferFunnels = false,
 		name = "",
 		batchSize = 2_500_000,
-		concurrency = 1
+		concurrency = 1,
+		strictEventCount = false
 	} = config;
 
 	// Allow concurrency override from config (default is now 1)
@@ -123,6 +131,12 @@ export function validateDungeonConfig(config) {
 		concurrency = 1;
 	}
 
+	// Force concurrency to 1 when strictEventCount is enabled
+	// This ensures the bailout check works correctly without race conditions
+	if (strictEventCount && concurrency !== 1) {
+		concurrency = 1;
+	}
+
 	// Ensure defaults for deep objects
 	if (!config.superProps) config.superProps = superProps;
 	if (!config.userProps || Object.keys(config?.userProps || {})) config.userProps = userProps;
@@ -140,6 +154,31 @@ export function validateDungeonConfig(config) {
 		name = makeName();
 	}
 
+	// Convert string hook to function
+	if (typeof hook === 'string') {
+		try {
+			// Use eval in a controlled manner to convert the string to a function
+			// The string should be: function(record, type, meta) { ... }
+			// eslint-disable-next-line no-eval
+			hook = eval(`(${hook})`);
+
+			// Validate it's actually a function
+			if (typeof hook !== 'function') {
+				throw new Error('Hook string did not evaluate to a function');
+			}
+		} catch (error) {
+			console.warn(`\u26a0\ufe0f Failed to convert hook string to function: ${error.message}`);
+			console.warn('Using default pass-through hook');
+			hook = (record) => record;
+		}
+	}
+
+	// Ensure hook is a function
+	if (typeof hook !== 'function') {
+		console.warn('\u26a0\ufe0f Hook is not a function, using default pass-through hook');
+		hook = (record) => record;
+	}
+
 	// Validate events
 	if (!events || !events.length) events = [{ event: "foo" }, { event: "bar" }, { event: "baz" }];
 
@@ -177,6 +216,8 @@ export function validateDungeonConfig(config) {
 			else {
 				evWeight = 1;
 			}
+			// Clamp weight to reasonable range (1-10) and ensure integer
+			evWeight = Math.max(1, Math.min(Math.floor(evWeight) || 1, 10));
 			return Array(evWeight).fill(event);
 		}));
 
@@ -241,7 +282,9 @@ export function validateDungeonConfig(config) {
 		hasAndroidDevices,
 		hasDesktopDevices,
 		hasIOSDevices,
-		name
+		name,
+		makeChart,
+		strictEventCount
 	};
 
 	return validatedConfig;
@@ -270,4 +313,76 @@ export function validateRequiredConfig(config) {
 	return true;
 }
 
-export { inferFunnels };
+/**
+ * Transforms SCD properties to regular user/group properties when service account credentials are missing
+ * ONLY applies to UI jobs - programmatic usage always generates SCD files
+ * @param {Partial<Dungeon>} config - Configuration object
+ * @returns {void} Modifies config in place
+ */
+function transformSCDPropsWithoutCredentials(config) {
+	const { serviceAccount, projectId, serviceSecret, scdProps, isUIJob, token } = config;
+
+	// If no SCD props configured, nothing to validate
+	if (!scdProps || Object.keys(scdProps).length === 0) {
+		return;
+	}
+
+	// If we have all credentials, SCD import can proceed
+	if (serviceAccount && projectId && serviceSecret) {
+		return;
+	}
+
+	// Missing credentials - handle based on job type
+	if (!isUIJob) {
+		// For programmatic/CLI usage, throw an error if trying to send SCDs to Mixpanel without credentials
+		if (token) {
+			throw new Error(
+				'Configuration error: SCD properties are configured but service credentials are missing.\n' +
+				'To import SCD data to Mixpanel, you must provide:\n' +
+				'  - serviceAccount: Your Mixpanel service account username\n' +
+				'  - serviceSecret: Your Mixpanel service account secret\n' +
+				'  - projectId: Your Mixpanel project ID\n' +
+				'Without these credentials, SCD data cannot be imported to Mixpanel.'
+			);
+		}
+		// If not sending to Mixpanel (no token), allow generation for testing
+		return;
+	}
+
+	// UI job without credentials - convert SCD props to regular props
+	console.log('\u26a0\ufe0f  Service account credentials missing - converting SCD properties to static properties');
+
+	// Ensure userProps and groupProps exist
+	if (!config.userProps) config.userProps = {};
+	if (!config.groupProps) config.groupProps = {};
+
+	// Process each SCD property
+	for (const [propKey, scdProp] of Object.entries(scdProps)) {
+		const { type = "user", values } = scdProp;
+
+		// Skip if no values
+		if (!values || JSON.stringify(values) === "{}" || JSON.stringify(values) === "[]") {
+			continue;
+		}
+
+		// Determine if this is a user or group property
+		if (type === "user") {
+			// Add to userProps
+			config.userProps[propKey] = values;
+			console.log(`  \u2713 Converted user SCD property: ${propKey}`);
+		} else {
+			// Add to groupProps for the specific group type
+			if (!config.groupProps[type]) {
+				config.groupProps[type] = {};
+			}
+			config.groupProps[type][propKey] = values;
+			console.log(`  \u2713 Converted group SCD property: ${propKey} (${type})`);
+		}
+	}
+
+	// Clear out scdProps since we've converted everything
+	config.scdProps = {};
+	console.log('\u2713 SCD properties converted to static properties\n');
+}
+
+export { inferFunnels, transformSCDPropsWithoutCredentials };

package/lib/core/context.js

@@ -73,8 +73,7 @@ function createRuntimeState() {
 		eventCount: 0,
 		userCount: 0,
 		isBatchMode: false,
-		verbose: false,
-		isCLI: false
+		verbose: false
 	};
 }
 
@@ -82,10 +81,10 @@ function createRuntimeState() {
  * Context factory that creates a complete context object for data generation
  * @param {Dungeon} config - Validated configuration object
  * @param {Storage|null} storage - Storage containers (optional, can be set later)
- * @param {boolean} [isCliMode] - Whether running in CLI mode (optional, will detect if not provided)
+ * @param {boolean} [_unusedCliMode] - Deprecated parameter (no longer used)
  * @returns {Context} Context object containing all state and dependencies
  */
-export function createContext(config, storage = null, isCliMode = null) {
+export function createContext(config, storage = null, _unusedCliMode = null) {
 	// Import campaign data (could be made configurable)
 	const campaignData = campaigns;
 
@@ -98,8 +97,6 @@ export function createContext(config, storage = null, isCliMode = null) {
 	// Set runtime flags from config
 	runtime.verbose = config.verbose || false;
 	runtime.isBatchMode = config.batchSize && config.batchSize < config.numEvents;
-	runtime.isCLI = isCliMode !== null ? isCliMode : (process.argv[1]?.endsWith('index.js') || process.argv[1]?.endsWith('entry.js') || false);
-	if (runtime.isCLI) runtime.verbose = true; // Always verbose in CLI mode
 
 	const context = {
 		config,
@@ -150,28 +147,24 @@ export function createContext(config, storage = null, isCliMode = null) {
 			return runtime.isBatchMode;
 		},
 
-		isCLI() {
-			return runtime.isCLI;
-		},
-
 		// Time helper methods
 		getTimeShift() {
-			const actualNow = dayjs().add(2, "day");
+			const actualNow = dayjs().add(1, "day");
 			return actualNow.diff(dayjs.unix(this.FIXED_NOW), "seconds");
 		},
 
 		getDaysShift() {
-			const actualNow = dayjs().add(2, "day");
+			const actualNow = dayjs().add(1, "day");
 			return actualNow.diff(dayjs.unix(this.FIXED_NOW), "days");
 		},
 
 		// Time constants (previously globals)
 		FIXED_NOW: global.FIXED_NOW,
 		FIXED_BEGIN: global.FIXED_BEGIN,
-		
+
 		// PERFORMANCE: Pre-calculated time shift (instead of calculating per-event)
 		TIME_SHIFT_SECONDS: (() => {
-			const actualNow = dayjs().add(2, "day");
+			const actualNow = dayjs().add(1, "day");
 			return actualNow.diff(dayjs.unix(global.FIXED_NOW), "seconds");
 		})(),
 	};

package/lib/core/storage.js

@@ -13,6 +13,7 @@ import pLimit from 'p-limit';
 import os from "os";
 import path from "path";
 import * as u from "../utils/utils.js";
+import { dataLogger as logger } from "../utils/logger.js";
 
 /**
  * Creates a hooked array that transforms data on push and handles batching/disk writes
@@ -32,16 +33,15 @@ export async function createHookArray(arr = [], opts) {
 	} = opts || {};
 
 	const FILE_CONN = pLimit(concurrency);
-	const { 
-		config = {}, 
-		runtime = { 
-			operations: 0, 
-			eventCount: 0, 
-			userCount: 0, 
-			isBatchMode: false, 
-			verbose: false, 
-			isCLI: false 
-		} 
+	const {
+		config = {},
+		runtime = {
+			operations: 0,
+			eventCount: 0,
+			userCount: 0,
+			isBatchMode: false,
+			verbose: false
+		}
 	} = context;
 	const BATCH_SIZE = config.batchSize || 1_000_000;
 	const NODE_ENV = process.env.NODE_ENV || "unknown";
@@ -65,7 +65,7 @@ export async function createHookArray(arr = [], opts) {
 	}
 
 	function getWritePath() {
-		const gzipSuffix = (config.gzip && !writeDir?.startsWith('gs://')) ? '.gz' : '';
+		const gzipSuffix = (config.gzip) ? '.gz' : '';
 		
 		if (isBatchMode) {
 			if (writeDir?.startsWith('gs://')) return `${writeDir}/${filepath}-part-${batch.toString()}.${format}${gzipSuffix}`;
@@ -78,17 +78,24 @@ export async function createHookArray(arr = [], opts) {
 	}
 
 	function getWriteDir() {
-		return path.join(writeDir, `${filepath}.${format}`);
+		return writeDir;
 	}
 
 	async function transformThenPush(item, meta) {
 		if (item === null || item === undefined) return false;
 		if (typeof item === 'object' && Object.keys(item).length === 0) return false;
 
+		// Skip hook for types already hooked in generators/orchestrators to prevent double-firing
+		// Types hooked upstream: "event" (events.js), "user" (user-loop.js), "scd" (user-loop.js)
+		// Types only hooked here: "mirror", "ad-spend", "group", "lookup"
+		const alreadyHooked = type === "event" || type === "user" || type === "scd";
+
 		// Performance optimization: skip hook overhead for passthrough hooks
-		const isPassthroughHook = hook.toString().includes('return record') || hook.length === 1;
+		// Only treat as passthrough if the function body is trivially simple (just returns its argument)
+		const hookStr = hook.toString();
+		const isPassthroughHook = hook.length === 1 || /^\s*function\s*\([^)]*\)\s*\{\s*return\s+\w+;?\s*\}\s*$/.test(hookStr) || /^\s*\(?[^)]*\)?\s*=>\s*\w+\s*$/.test(hookStr);
 
-		if (isPassthroughHook) {
+		if (alreadyHooked || isPassthroughHook) {
 			// Fast path for passthrough hooks - no transformation needed
 			if (Array.isArray(item)) {
 				arr.push(...item);
@@ -99,25 +106,43 @@ export async function createHookArray(arr = [], opts) {
 			// Slow path for actual transformation hooks
 			const allMetaData = { ...rest, ...meta };
 
+			// Helper to validate events have required properties
+			// Note: event-type hooks are handled in the fast path (alreadyHooked),
+			// so this only runs for storage-only hook types (mirror, ad-spend, group, lookup)
+			const isValidEvent = (e) => {
+				if (!e || typeof e !== 'object') return false;
+				return true;
+			};
+
 			if (Array.isArray(item)) {
 				for (const i of item) {
 					try {
 						const enriched = await hook(i, type, allMetaData);
-						if (Array.isArray(enriched)) enriched.forEach(e => arr.push(e));
-						else arr.push(enriched);
+						if (Array.isArray(enriched)) {
+							enriched.forEach(e => {
+								if (isValidEvent(e)) arr.push(e);
+							});
+						} else if (isValidEvent(enriched)) {
+							arr.push(enriched);
+						}
 					} catch (e) {
-						console.error(`\n\nyour hook had an error\n\n`, e);
-						arr.push(i);
+						logger.error({ err: e }, 'Hook error during batch processing');
+						if (isValidEvent(i)) arr.push(i);
 					}
 				}
 			} else {
 				try {
 					const enriched = await hook(item, type, allMetaData);
-					if (Array.isArray(enriched)) enriched.forEach(e => arr.push(e));
-					else arr.push(enriched);
+					if (Array.isArray(enriched)) {
+						enriched.forEach(e => {
+							if (isValidEvent(e)) arr.push(e);
+						});
+					} else if (isValidEvent(enriched)) {
+						arr.push(enriched);
+					}
 				} catch (e) {
-					console.error(`\n\nyour hook had an error\n\n`, e);
-					arr.push(item);
+					logger.error({ err: e }, 'Hook error during single item processing');
+					if (isValidEvent(item)) arr.push(item);
 				}
 			}
 		}
@@ -135,8 +160,8 @@ export async function createHookArray(arr = [], opts) {
 				const dataToWrite = [...arr];
 				// Clear the array immediately to prevent race conditions
 				arr.length = 0;
-				
-				// Write to disk (this is now synchronous from the perspective of batch management)
+
+				// Write to disk/cloud - always blocking to prevent OOM
 				const writeResult = await FILE_CONN(() => writeToDisk(dataToWrite, { writePath }));
 				return writeResult;
 			} finally {
@@ -151,8 +176,11 @@ export async function createHookArray(arr = [], opts) {
 		const { writePath } = options;
 		let writeResult;
 
-		if (config.verbose) {
+		const isDev = process.env.NODE_ENV !== 'production';
+		if (config.verbose && isDev) {
 			console.log(`\n\twriting ${writePath}\n`);
+		} else if (config.verbose) {
+			logger.info({ path: writePath }, `Writing ${writePath}`);
 		}
 
 		const streamOptions = {
@@ -277,6 +305,7 @@ export class StorageManager {
 		// Initialize SCD tables if configured
 		if (config.scdProps && Object.keys(config.scdProps).length > 0) {
 			for (const scdKey of Object.keys(config.scdProps)) {
+				const scdConfig = config.scdProps[scdKey];
 				const scdArray = await createHookArray([], {
 					hook: config.hook,
 					type: "scd",
@@ -286,6 +315,9 @@ export class StorageManager {
 					context: this.context
 				});
 				scdArray.scdKey = scdKey;
+				// Store entity type (user or group) from config
+				const entityType = (typeof scdConfig === 'object' && scdConfig.type) ? scdConfig.type : 'user';
+				scdArray.entityType = entityType;
 				storage.scdTableData.push(scdArray);
 			}
 		}

package/lib/generators/adspend.js

@@ -18,20 +18,20 @@ import * as u from "../utils/utils.js";
 export async function makeAdSpend(context, day, campaigns = null) {
     // Update operation counter
     context.incrementOperations();
-    
+
     // Use campaigns from context if not provided
     const campaignConfigs = campaigns || context.campaigns;
-    
+
     if (!campaignConfigs || campaignConfigs.length === 0) {
         return [];
     }
-    
+
     const chance = u.getChance();
     const adSpendEvents = [];
-    
+
     for (const network of campaignConfigs) {
         const networkCampaigns = network.utm_campaign;
-        
+
         for (const campaign of networkCampaigns) {
             // Skip organic campaigns
             if (campaign === "$organic") continue;
@@ -105,28 +105,28 @@ export function validateCampaigns(campaigns) {
     if (!Array.isArray(campaigns)) {
         throw new Error("Campaigns must be an array");
     }
-    
+
     for (const network of campaigns) {
         if (!network.utm_source || !Array.isArray(network.utm_source)) {
             throw new Error("Each campaign network must have utm_source array");
         }
-        
+
         if (!network.utm_campaign || !Array.isArray(network.utm_campaign)) {
             throw new Error("Each campaign network must have utm_campaign array");
         }
-        
+
         if (!network.utm_medium || !Array.isArray(network.utm_medium)) {
             throw new Error("Each campaign network must have utm_medium array");
         }
-        
+
         if (!network.utm_content || !Array.isArray(network.utm_content)) {
             throw new Error("Each campaign network must have utm_content array");
         }
-        
+
         if (!network.utm_term || !Array.isArray(network.utm_term)) {
             throw new Error("Each campaign network must have utm_term array");
         }
     }
-    
+
     return true;
-}
+}

package/lib/generators/events.js

@@ -11,6 +11,7 @@
 
 import dayjs from "dayjs";
 import * as u from "../utils/utils.js";
+import { dataLogger as logger } from "../utils/logger.js";
 
 /**
  * Creates a Mixpanel event with a flat shape
@@ -136,7 +137,7 @@ export async function makeEvent(
             try {
                 eventTemplate[key] = u.choose(chosenEvent.properties[key]);
             } catch (e) {
-                console.error(`error with ${key} in ${chosenEvent.event} event`, e);
+                logger.error({ err: e, key, event: chosenEvent.event }, `Error processing property ${key} in ${chosenEvent.event} event`);
                 // Continue processing other properties
             }
         }
@@ -150,7 +151,7 @@ export async function makeEvent(
             try {
                 eventTemplate[key] = u.choose(superProps[key]);
             } catch (e) {
-                console.error(`error with ${key} in super props`, e);
+                logger.error({ err: e, key }, `Error processing super property ${key}`);
                 // Continue processing other properties
             }
         }
@@ -256,12 +257,12 @@ function addGroupProperties(eventTemplate, groupKeys) {
 
         // Empty array for group events means all events get the group property
         if (!groupEvents.length) {
-            eventTemplate[groupKey] = u.pick(u.weighNumRange(1, groupCardinality));
+            eventTemplate[groupKey] = String(u.pick(u.weighNumRange(1, groupCardinality)));
         }
-        
+
         // Only add group property if event is in the specified group events
         if (groupEvents.includes(eventTemplate.event)) {
-            eventTemplate[groupKey] = u.pick(u.weighNumRange(1, groupCardinality));
+            eventTemplate[groupKey] = String(u.pick(u.weighNumRange(1, groupCardinality)));
         }
     }
 }

package/lib/generators/funnels.js

@@ -8,6 +8,7 @@
 import dayjs from "dayjs";
 import * as u from "../utils/utils.js";
 import { makeEvent } from "./events.js";
+import { dataLogger as logger } from "../utils/logger.js";
 
 /**
  * Creates a funnel (sequence of events) for a user with conversion logic
@@ -78,6 +79,7 @@ export async function makeFunnel(context, funnel, user, firstEventTime, profile
 		requireRepeats = false,
 		_experimentName: expName,
 		_experimentVariant: expVariant,
+		bindPropsIndex = 0
 	} = funnel;
 
 	const { distinct_id, created, anonymousIds = [], sessionIds = [] } = user;
@@ -89,12 +91,12 @@ export async function makeFunnel(context, funnel, user, firstEventTime, profile
 		try {
 			chosenFunnelProps[key] = u.choose(chosenFunnelProps[key]);
 		} catch (e) {
-			console.error(`error with ${key} in ${funnel.sequence.join(" > ")} funnel`, e);
+			logger.error({ err: e, key, funnel: funnel.sequence.join(" > ") }, `Error processing property ${key} in funnel`);
 		}
 	}
 
 	// Build event specifications for funnel steps
-	const funnelPossibleEvents = buildFunnelEvents(context, sequence, chosenFunnelProps, expName, expVariant);
+	const funnelPossibleEvents = buildFunnelEvents(context, sequence, chosenFunnelProps, bindPropsIndex, expName, expVariant);
 
 	// Handle repeat logic and conversion rate adjustment
 	const { processedEvents, adjustedConversionRate } = processEventRepeats(
@@ -158,14 +160,15 @@ export async function makeFunnel(context, funnel, user, firstEventTime, profile
  * @param {Context} context - Context object
  * @param {Array} sequence - Array of event names
  * @param {Object} chosenFunnelProps - Properties to apply to all events
+ * @param {number} bindPropsIndex - Index at which to bind properties (if applicable)
  * @param {string} [experimentName] - Name of experiment (if experiment is enabled)
  * @param {string} [experimentVariant] - Variant name (A, B, or C)
  * @returns {Array} Array of event specifications
  */
-function buildFunnelEvents(context, sequence, chosenFunnelProps, experimentName, experimentVariant) {
+function buildFunnelEvents(context, sequence, chosenFunnelProps, bindPropsIndex, experimentName, experimentVariant) {
 	const { config } = context;
 
-	return sequence.map((eventName) => {
+	return sequence.map((eventName, currentIndex) => {
 		// Handle $experiment_started event specially
 		if (eventName === "$experiment_started" && experimentName && experimentVariant) {
 			return {
@@ -191,13 +194,21 @@ function buildFunnelEvents(context, sequence, chosenFunnelProps, experimentName,
 			try {
 				eventSpec.properties[key] = u.choose(eventSpec.properties[key]);
 			} catch (e) {
-				console.error(`error with ${key} in ${eventSpec.event} event`, e);
+				logger.error({ err: e, key, event: eventSpec.event }, `Error processing property ${key} in ${eventSpec.event} event`);
 			}
 		}
 
 		// Merge funnel properties (no need to delete properties since we're creating a new object)
 		eventSpec.properties = { ...eventSpec.properties, ...chosenFunnelProps };
 
+
+		if (bindPropsIndex && currentIndex < bindPropsIndex) {
+			// Remove funnel properties that were added but should not be bound yet
+			for (const key in chosenFunnelProps) {
+				delete eventSpec.properties[key];
+			}
+		}
+
 		return eventSpec;
 	});
 }
@@ -361,19 +372,30 @@ async function generateFunnelEvents(
 		);
 
 		if (index === 0) {
-			funnelStartTime = dayjs(newEvent.time);
+			const parsedTime = dayjs(newEvent.time);
+			// Validate the first event's time - if invalid, use TimeSoup-generated time as-is
+			funnelStartTime = parsedTime.isValid() ? parsedTime : null;
+			delete newEvent.relativeTimeMs;
+			return newEvent;
+		}
+
+		// If funnelStartTime is invalid, just use the TimeSoup-generated time from makeEvent
+		if (!funnelStartTime || !funnelStartTime.isValid()) {
 			delete newEvent.relativeTimeMs;
 			return newEvent;
 		}
 
 		try {
-			newEvent.time = dayjs(funnelStartTime)
-				.add(event.relativeTimeMs, "milliseconds")
-				.toISOString();
+			const computedTime = dayjs(funnelStartTime).add(event.relativeTimeMs, "milliseconds");
+			if (computedTime.isValid()) {
+				newEvent.time = computedTime.toISOString();
+			}
+			// If invalid, keep the TimeSoup-generated time from makeEvent
 			delete newEvent.relativeTimeMs;
 			return newEvent;
 		} catch (e) {
-			console.error("Error setting funnel event time:", e);
+			// Graceful fallback: keep the TimeSoup-generated time from makeEvent
+			delete newEvent.relativeTimeMs;
 			return newEvent;
 		}
 	}));