@ak--47/dungeon-master 1.0.0

package/lib/generators/product-lookup.js

@@ -0,0 +1,262 @@
+/**
+ * Product Lookup Table Generator
+ * Creates a comprehensive product catalog with unique IDs
+ * @module product-lookup
+ */
+
+import Chance from 'chance';
+import { GENERATION_PATTERNS } from '../templates/phrases.js';
+
+/**
+ * Generate a unique product lookup table
+ * @param {number} count - Number of products to generate
+ * @param {string} seed - Seed for reproducible results
+ * @returns {Map<string, Object>} Map of product_id to product details
+ */
+export function generateProductLookup(count = 10000, seed = 'product-catalog') {
+	const chance = new Chance(seed);
+	const productMap = new Map();
+	
+	// Get all product categories
+	const categories = GENERATION_PATTERNS.store_products;
+	const categoryNames = Object.keys(categories);
+	
+	// Flatten all products with their categories
+	const allProducts = [];
+	for (const [categoryKey, products] of Object.entries(categories)) {
+		const categoryName = getCategoryDisplayName(categoryKey);
+		products.forEach(productName => {
+			allProducts.push({
+				name: productName,
+				category: categoryName,
+				categoryKey: categoryKey
+			});
+		});
+	}
+	
+	// Brand names for variety
+	const brands = [
+		"TechPro", "HomeEssentials", "FitLife", "StyleCo", "BeautyPlus",
+		"OfficeMax", "EcoGoods", "PremiumChoice", "ValueBrand", "GenericCo",
+		"ProGear", "UltraLife", "SmartHome", "ActiveWear", "LuxeBeauty",
+		"WorkSpace", "GreenLiving", "EliteChoice", "BudgetBuy", "QualityFirst",
+		"TechnoEdge", "HomeComfort", "FitnessPro", "FashionForward", "GlowUp",
+		"OfficeElite", "EarthFriendly", "PremiumPro", "SmartBuy", "TopTier",
+		"InnoTech", "CozyHome", "PowerFit", "TrendSet", "PureBeauty",
+		"DeskMaster", "NaturalChoice", "LuxuryLine", "BestValue", "PrimeSelect"
+	];
+	
+	// Generate products
+	for (let i = 0; i < count; i++) {
+		const productId = `PROD-${String(i + 1).padStart(6, '0')}`;
+		
+		// Select a base product (reuse and vary)
+		const baseProduct = chance.pickone(allProducts);
+		
+		// Add variation to product name for uniqueness
+		let productName = baseProduct.name;
+		if (chance.bool({ likelihood: 30 })) {
+			// Add color/size/model variations
+			const variations = [
+				` - ${chance.pickone(['Black', 'White', 'Blue', 'Red', 'Gray', 'Silver', 'Gold', 'Rose Gold', 'Navy', 'Green'])}`,
+				` - ${chance.pickone(['Small', 'Medium', 'Large', 'X-Large', 'One Size'])}`,
+				` - ${chance.pickone(['Pro', 'Plus', 'Lite', 'Max', 'Mini', 'Ultra', 'Premium', 'Basic', 'Deluxe'])}`,
+				` (${chance.pickone(['2024 Model', '2025 Edition', 'Updated Version', 'Gen 2', 'v2.0', 'Series 2'])})`,
+				` - ${chance.integer({ min: 1, max: 50 })} Pack`
+			];
+			
+			if (chance.bool({ likelihood: 60 })) {
+				productName += chance.pickone(variations);
+			}
+		}
+		
+		// Generate price based on category
+		const priceRange = getPriceRange(baseProduct.categoryKey);
+		const basePrice = chance.floating({ 
+			min: priceRange.min, 
+			max: priceRange.max, 
+			fixed: 2 
+		});
+		
+		// Generate rating
+		const rating = chance.weighted(
+			[5, 4.5, 4, 3.5, 3, 2.5, 2, 1.5, 1],
+			[35, 25, 20, 10, 5, 3, 1, 0.5, 0.5]
+		);
+		
+		// Stock levels
+		const stockLevel = chance.weighted(
+			[500, 250, 100, 50, 25, 0],
+			[40, 25, 20, 10, 4, 1]
+		);
+		
+		const product = {
+			product_id: productId,
+			name: productName,
+			brand: chance.pickone(brands),
+			category: baseProduct.category,
+			subcategory: baseProduct.categoryKey,
+			price: basePrice,
+			msrp: chance.bool({ likelihood: 40 }) ? basePrice * chance.floating({ min: 1.1, max: 1.5, fixed: 2 }) : basePrice,
+			rating: rating,
+			review_count: chance.integer({ min: 0, max: 5000 }),
+			stock_level: stockLevel,
+			stock_status: getStockStatus(stockLevel),
+			sku: `SKU-${chance.string({ length: 8, pool: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789' })}`,
+			weight_oz: chance.floating({ min: 0.5, max: 50, fixed: 2 }),
+			is_featured: chance.bool({ likelihood: 10 }),
+			is_bestseller: chance.bool({ likelihood: 15 }),
+			is_new_arrival: chance.bool({ likelihood: 20 }),
+			is_on_sale: chance.bool({ likelihood: 25 }),
+			discount_percent: chance.bool({ likelihood: 25 }) ? chance.integer({ min: 5, max: 50 }) : 0,
+			shipping_eligible: chance.bool({ likelihood: 90 }),
+			free_shipping: chance.bool({ likelihood: 40 }),
+			prime_eligible: chance.bool({ likelihood: 60 }),
+			returnable: chance.bool({ likelihood: 85 }),
+			warranty_months: chance.pickone([0, 3, 6, 12, 24, 36]),
+			release_date: chance.date({ 
+				year: chance.integer({ min: 2020, max: 2025 })
+			}).toISOString().split('T')[0],
+			supplier_id: `SUP-${chance.integer({ min: 1, max: 500 })}`,
+			tags: generateTags(baseProduct.categoryKey, chance)
+		};
+		
+		productMap.set(productId, product);
+	}
+	
+	return productMap;
+}
+
+/**
+ * Convert a product lookup Map to a plain object for export
+ */
+export function productLookupToObject(productMap) {
+	const obj = {};
+	for (const [id, product] of productMap.entries()) {
+		obj[id] = product;
+	}
+	return obj;
+}
+
+/**
+ * Get a random product from the lookup
+ */
+export function getRandomProduct(productMap, chance) {
+	const keys = Array.from(productMap.keys());
+	const randomKey = chance.pickone(keys);
+	return productMap.get(randomKey);
+}
+
+/**
+ * Get products by category
+ */
+export function getProductsByCategory(productMap, category) {
+	return Array.from(productMap.values()).filter(p => p.category === category);
+}
+
+/**
+ * Get products by price range
+ */
+export function getProductsByPriceRange(productMap, minPrice, maxPrice) {
+	return Array.from(productMap.values()).filter(p => p.price >= minPrice && p.price <= maxPrice);
+}
+
+/**
+ * Search products by name
+ */
+export function searchProducts(productMap, query) {
+	const lowerQuery = query.toLowerCase();
+	return Array.from(productMap.values()).filter(p => 
+		p.name.toLowerCase().includes(lowerQuery) ||
+		p.brand.toLowerCase().includes(lowerQuery) ||
+		p.category.toLowerCase().includes(lowerQuery)
+	);
+}
+
+// Helper functions
+
+function getCategoryDisplayName(categoryKey) {
+	const displayNames = {
+		electronics: 'Electronics',
+		home_kitchen: 'Home & Kitchen',
+		clothing: 'Clothing',
+		beauty: 'Beauty & Personal Care',
+		sports: 'Sports & Outdoors',
+		books: 'Books & Media',
+		toys: 'Toys & Games',
+		pet_supplies: 'Pet Supplies',
+		office: 'Office Supplies',
+		baby: 'Baby Products',
+		automotive: 'Automotive',
+		garden: 'Garden & Outdoor'
+	};
+	return displayNames[categoryKey] || categoryKey;
+}
+
+function getPriceRange(categoryKey) {
+	const ranges = {
+		electronics: { min: 9.99, max: 799.99 },
+		home_kitchen: { min: 4.99, max: 399.99 },
+		clothing: { min: 9.99, max: 199.99 },
+		beauty: { min: 3.99, max: 89.99 },
+		sports: { min: 7.99, max: 299.99 },
+		books: { min: 4.99, max: 49.99 },
+		toys: { min: 5.99, max: 149.99 },
+		pet_supplies: { min: 3.99, max: 99.99 },
+		office: { min: 1.99, max: 499.99 },
+		baby: { min: 4.99, max: 299.99 },
+		automotive: { min: 9.99, max: 199.99 },
+		garden: { min: 5.99, max: 249.99 }
+	};
+	return ranges[categoryKey] || { min: 9.99, max: 99.99 };
+}
+
+function getStockStatus(stockLevel) {
+	if (stockLevel === 0) return 'Out of Stock';
+	if (stockLevel < 10) return 'Low Stock';
+	if (stockLevel < 50) return 'Limited Stock';
+	return 'In Stock';
+}
+
+function generateTags(categoryKey, chance) {
+	const commonTags = ['popular', 'trending', 'recommended', 'verified', 'quality'];
+	const categoryTags = {
+		electronics: ['tech', 'gadget', 'smart', 'wireless', 'digital'],
+		home_kitchen: ['home', 'kitchen', 'cooking', 'storage', 'organization'],
+		clothing: ['fashion', 'apparel', 'style', 'comfort', 'casual'],
+		beauty: ['skincare', 'makeup', 'grooming', 'wellness', 'organic'],
+		sports: ['fitness', 'outdoor', 'active', 'training', 'exercise'],
+		books: ['reading', 'literature', 'educational', 'entertainment'],
+		toys: ['kids', 'fun', 'educational', 'creative', 'play'],
+		pet_supplies: ['pets', 'animals', 'care', 'feeding', 'play'],
+		office: ['work', 'productivity', 'organization', 'supplies'],
+		baby: ['infant', 'nursery', 'feeding', 'safety', 'care'],
+		automotive: ['car', 'vehicle', 'maintenance', 'accessories'],
+		garden: ['outdoor', 'plants', 'gardening', 'landscaping']
+	};
+	
+	const tags = [];
+	const catTags = categoryTags[categoryKey] || [];
+	
+	// Add 2-4 category tags
+	for (let i = 0; i < chance.integer({ min: 2, max: 4 }); i++) {
+		const tag = chance.pickone(catTags);
+		if (!tags.includes(tag)) tags.push(tag);
+	}
+	
+	// Maybe add a common tag
+	if (chance.bool({ likelihood: 40 })) {
+		tags.push(chance.pickone(commonTags));
+	}
+	
+	return tags;
+}
+
+export default {
+	generateProductLookup,
+	productLookupToObject,
+	getRandomProduct,
+	getProductsByCategory,
+	getProductsByPriceRange,
+	searchProducts
+};

package/lib/generators/product-names.js

@@ -0,0 +1,195 @@
+/**
+ * E-commerce Product Name Generator
+ * Generates realistic product names for store inventories, reviews, and search queries
+ * @module product-names
+ */
+
+import { createTextGenerator } from './text.js';
+
+// Product Review Generator - For customer reviews mentioning specific products
+export const productReviewGen = createTextGenerator({
+	style: "review",
+	tone: "pos",
+	intensity: "medium",
+	formality: "casual",
+	keywords: {
+		products: [
+			// Electronics
+			"Wireless Bluetooth Headphones", "USB-C Charging Cable", "Portable Power Bank 20000mAh",
+			"Smart Watch Series 7", "Wireless Gaming Mouse", "4K Webcam Pro",
+			"Bluetooth Speaker Waterproof", "Ring Light for Streaming",
+			
+			// Home & Kitchen
+			"Stainless Steel Cookware Set", "Air Fryer 6 Quart Digital", "Instant Pot 8 Quart",
+			"Coffee Maker Programmable", "Blender High Speed 1200W",
+			
+			// Clothing
+			"Men's Cotton T-Shirt Basic", "Women's Yoga Pants High Waist", "Athletic Shorts",
+			"Sneakers Running Lightweight", "Fleece Jacket Zip Up"
+		],
+		features: [
+			"battery life", "sound quality", "build quality", "comfort", "durability",
+			"ease of use", "design", "value for money", "performance", "fit",
+			"material quality", "charging speed", "connectivity", "portability",
+			"warranty", "customer service", "packaging", "instructions",
+			"compatibility", "functionality", "aesthetics", "weight",
+			"size options", "color accuracy", "temperature control", "noise level"
+		],
+		positive_aspects: [
+			"works great", "perfect for my needs", "exceeded expectations",
+			"highly recommend", "best purchase ever", "worth every penny",
+			"can't live without it", "game changer", "solid quality",
+			"does exactly what it claims", "super reliable", "love it so far",
+			"impressed with quality", "fast shipping too", "great value"
+		],
+		negative_aspects: [
+			"a bit pricey", "could be better", "takes getting used to",
+			"wish it had more features", "broke after a month", "not as advertised",
+			"quality could be improved", "too bulky", "battery drains quickly",
+			"doesn't fit well", "cheaply made", "stopped working"
+		]
+	},
+	mixedSentiment: true,
+	authenticityLevel: 0.6,
+	typos: true,
+	typoRate: 0.03,
+	min: 50,
+	max: 200,
+	includeMetadata: false
+});
+
+// Product Search Query Generator - For realistic search terms
+export const productSearchGen = createTextGenerator({
+	style: "search",
+	tone: "neu",
+	formality: "casual",
+	keywords: {
+		products: [
+			"headphones", "charging cable", "power bank", "smart watch", "gaming mouse",
+			"webcam", "speaker", "ring light", "cookware set", "air fryer",
+			"instant pot", "coffee maker", "blender", "yoga pants", "running shoes",
+			"fleece jacket", "facial cleanser", "moisturizer", "shampoo", "toothbrush",
+			"yoga mat", "dumbbells", "water bottle", "camping tent", "sleeping bag",
+			"notebook", "pens", "desk chair", "monitor stand", "baby monitor"
+		],
+		attributes: [
+			"wireless", "bluetooth", "USB-C", "waterproof", "portable", "lightweight",
+			"rechargeable", "adjustable", "foldable", "compact", "ergonomic",
+			"stainless steel", "non-stick", "organic", "eco-friendly", "sustainable",
+			"durable", "heavy duty", "professional", "premium", "budget",
+			"best rated", "top seller", "on sale", "discounted", "clearance"
+		],
+		modifiers: [
+			"cheap", "affordable", "best", "good quality", "reliable",
+			"for beginners", "professional grade", "commercial", "industrial",
+			"for small spaces", "travel size", "family size", "bulk",
+			"name brand", "generic", "off brand", "authentic", "genuine",
+			"refurbished", "open box", "like new", "gently used"
+		]
+	},
+	typos: true,
+	typoRate: 0.05,
+	min: 2,
+	max: 40,
+	includeMetadata: false
+});
+
+// Product Comparison Generator - For side-by-side product comparisons
+export const productComparisonGen = createTextGenerator({
+	style: "feedback",
+	tone: "neu",
+	formality: "business",
+	keywords: {
+		products: [
+			"Wireless Bluetooth Headphones", "Air Fryer 6 Quart Digital",
+			"Smart Watch Series 7", "Coffee Maker Programmable",
+			"Yoga Mat Non-Slip 6mm", "Instant Pot 8 Quart"
+		],
+		comparison_terms: [
+			"compared to", "versus", "better than", "not as good as",
+			"similar to", "different from", "cheaper alternative to",
+			"premium version of", "budget option for", "upgraded from"
+		],
+		metrics: [
+			"price point", "durability", "features", "warranty coverage",
+			"brand reputation", "user reviews", "availability",
+			"customer support", "build quality", "performance metrics"
+		]
+	},
+	authenticityLevel: 0.7,
+	specificityLevel: 0.8,
+	min: 100,
+	max: 300,
+	includeMetadata: false
+});
+
+// Product Question Generator - For Q&A sections
+export const productQuestionGen = createTextGenerator({
+	style: "forum",
+	tone: "neu",
+	formality: "casual",
+	keywords: {
+		products: [
+			"Smart Watch Series 7", "Air Fryer 6 Quart", "Wireless Headphones",
+			"Yoga Mat", "Power Bank", "Instant Pot", "Bluetooth Speaker"
+		],
+		question_starters: [
+			"Does this work with", "Is this compatible with", "Can I use this for",
+			"Will this fit", "How long does", "What's the difference between",
+			"Is this better than", "Should I get", "Any recommendations for",
+			"Has anyone tried", "Is it worth", "Does anyone know if"
+		],
+		concerns: [
+			"battery life", "warranty", "return policy", "shipping time",
+			"compatibility", "size", "color options", "durability",
+			"maintenance", "cleaning", "storage", "safety",
+			"noise level", "power consumption", "assembly required"
+		]
+	},
+	typos: true,
+	typoRate: 0.04,
+	min: 20,
+	max: 100,
+	includeMetadata: false
+});
+
+// Product Description Generator - For store listings
+export const productDescriptionGen = createTextGenerator({
+	style: "feedback",
+	tone: "pos",
+	formality: "business",
+	keywords: {
+		products: [
+			"Premium Wireless Headphones", "Professional Air Fryer", "Advanced Smart Watch",
+			"Deluxe Coffee Maker", "Ultra Comfort Yoga Mat", "Multi-Function Instant Pot"
+		],
+		features: [
+			"state-of-the-art technology", "innovative design", "superior quality",
+			"advanced features", "user-friendly interface", "premium materials",
+			"long-lasting durability", "exceptional performance", "modern aesthetics",
+			"versatile functionality", "energy efficient", "space-saving design",
+			"easy maintenance", "comprehensive warranty", "fast setup",
+			"multiple settings", "customizable options", "safety certified"
+		],
+		benefits: [
+			"saves time", "improves efficiency", "enhances experience",
+			"provides convenience", "offers flexibility", "ensures reliability",
+			"delivers results", "maximizes value", "simplifies tasks",
+			"reduces effort", "increases productivity", "optimizes performance"
+		]
+	},
+	authenticityLevel: 0.5,
+	specificityLevel: 0.7,
+	min: 80,
+	max: 250,
+	includeMetadata: false
+});
+
+// Export all generators
+export default {
+	productReviewGen,
+	productSearchGen,
+	productComparisonGen,
+	productQuestionGen,
+	productDescriptionGen
+};

package/lib/generators/profiles.js

@@ -0,0 +1,93 @@
+/**
+ * Profile generator module
+ * Creates user and group profiles with realistic properties
+ */
+
+/** @typedef {import('../../types').Context} Context */
+
+import * as u from "../utils/utils.js";
+import { dataLogger as logger } from "../utils/logger.js";
+
+/**
+ * Creates a user or group profile by choosing from available property values
+ * @param {Context} context - Context object containing config, defaults, etc.
+ * @param {Object} props - Properties to include in the profile
+ * @param {Object} defaults - Default values to merge with props
+ * @returns {Promise<Object>} Generated profile object
+ */
+export async function makeProfile(context, props = {}, defaults = {}) {
+    // Update operation counter
+    context.incrementOperations();
+    
+    // Keys that should not be processed with the choose function
+    const keysToNotChoose = ["anonymousIds", "sessionIds"];
+
+    // Start with defaults
+    const profile = { ...defaults };
+
+    // Process default values first
+    for (const key in profile) {
+        if (keysToNotChoose.includes(key)) continue;
+        
+        try {
+            profile[key] = u.choose(profile[key]);
+        } catch (e) {
+            logger.error({ err: e, key }, `Error processing default property ${key}`);
+            // Keep original value on error
+        }
+    }
+
+    // Process provided props (these override defaults)
+    for (const key in props) {
+        try {
+            profile[key] = u.choose(props[key]);
+        } catch (e) {
+            logger.error({ err: e, key }, `Error processing property ${key}`);
+            // Keep original value on error
+        }
+    }
+
+    return profile;
+}
+
+/**
+ * Creates a user profile with typical user properties
+ * @param {Context} context - Context object
+ * @param {Object} userProps - User-specific properties
+ * @param {Object} baseProfile - Base profile to extend
+ * @returns {Promise<Object>} Generated user profile
+ */
+export async function makeUserProfile(context, userProps = {}, baseProfile = {}) {
+    const { config } = context;
+    
+    // Combine user props with any configured user properties
+    const combinedProps = {
+        ...config.userProps,
+        ...userProps
+    };
+    
+    return makeProfile(context, combinedProps, baseProfile);
+}
+
+/**
+ * Creates a group profile with group-specific properties
+ * @param {Context} context - Context object
+ * @param {string} groupKey - Group identifier
+ * @param {Object} groupProps - Group-specific properties
+ * @param {Object} baseProfile - Base profile to extend
+ * @returns {Promise<Object>} Generated group profile
+ */
+export async function makeGroupProfile(context, groupKey, groupProps = {}, baseProfile = {}) {
+    const { config } = context;
+    
+    // Get group properties from config for this specific group
+    const configGroupProps = config.groupProps?.[groupKey] || {};
+    
+    // Combine with provided props
+    const combinedProps = {
+        ...configGroupProps,
+        ...groupProps,
+    };
+    
+    return makeProfile(context, combinedProps, baseProfile);
+}

package/lib/generators/scd.js

@@ -0,0 +1,124 @@
+/**
+ * Slowly Changing Dimensions (SCD) generator module
+ * Creates time-series data showing how properties change over time
+ */
+
+/** @typedef {import('../../types').Context} Context */
+
+import dayjs from "dayjs";
+import * as u from "../utils/utils.js";
+import { makeProfile } from "./profiles.js";
+
+/**
+ * Creates SCD (Slowly Changing Dimensions) entries for a given property
+ * @param {Context} context - Context object containing config, defaults, etc.
+ * @param {Array|Object} scdProp - SCD property configuration or simple array of values
+ * @param {string} scdKey - Key name for the SCD property
+ * @param {string} distinct_id - User/entity identifier
+ * @param {number} mutations - Number of mutations to create
+ * @param {string | number} created - Creation timestamp for the entity
+ * @returns {Promise<Array>} Array of SCD entries
+ */
+export async function makeSCD(context, scdProp, scdKey, distinct_id, mutations, created) {
+    // Convert simple array to full configuration object
+    if (Array.isArray(scdProp)) {
+        scdProp = { 
+            values: scdProp, 
+            frequency: 'week', 
+            max: 10, 
+            timing: 'fuzzy', 
+            type: 'user' 
+        };
+    }
+	if (typeof created === 'number') created = dayjs.unix(created).toISOString();
+    
+    const {
+        frequency = 'day',     // Default to daily frequency
+        max = 10,             // Default max mutations
+        timing = 'fuzzy',     // Default to fuzzy timing
+        values,
+        type = "user"
+    } = scdProp;
+    
+    // Return empty array if no values provided
+    if (!values || (Array.isArray(values) && values.length === 0) ||
+        (typeof values === 'object' && Object.keys(values).length === 0)) {
+        return [];
+    }
+
+    const scdEntries = [];
+    let lastInserted = dayjs(created);
+    const now = dayjs();
+    const deltaDays = now.diff(lastInserted, "day");
+    const uuidKeyName = type === 'user' ? 'distinct_id' : type;
+    let lastStartTime = null; // Track for monotonic ordering
+
+    for (let i = 0; i < mutations; i++) {
+        // Stop if we've reached the current time
+        if (lastInserted.isAfter(now)) break;
+
+        // Create profile with the SCD property
+        const scd = await makeProfile(context, { [scdKey]: values }, { [uuidKeyName]: distinct_id });
+
+        // Create SCD entry with all required properties
+        const scdEntry = {
+            ...scd,
+            [uuidKeyName]: scd.distinct_id || distinct_id,
+            startTime: null,
+            insertTime: null,
+            time: null // Required field for Mixpanel SCD import
+        };
+
+        // Set start time based on timing strategy
+        if (timing === 'fixed') {
+            switch (frequency) {
+                case "day":
+                    scdEntry.startTime = lastInserted.add(1, "day").startOf('day').toISOString();
+                    break;
+                case "week":
+                    scdEntry.startTime = lastInserted.add(1, "week").startOf('week').toISOString();
+                    break;
+                case "month":
+                    scdEntry.startTime = lastInserted.add(1, "month").startOf('month').toISOString();
+                    break;
+                case "year":
+                    scdEntry.startTime = lastInserted.add(1, "year").startOf('year').toISOString();
+                    break;
+            }
+        }
+
+        if (timing === 'fuzzy') {
+            scdEntry.startTime = lastInserted.toISOString();
+        }
+
+        // Enforce monotonic ordering — startTime must advance
+        if (lastStartTime && scdEntry.startTime && scdEntry.startTime <= lastStartTime) {
+            scdEntry.startTime = dayjs(lastStartTime).add(1, "second").toISOString();
+        }
+        lastStartTime = scdEntry.startTime;
+
+        // Set insert time (slightly after start time)
+        const insertTime = dayjs(scdEntry.startTime).add(u.integer(1, 9000), "seconds");
+        scdEntry.insertTime = insertTime.toISOString();
+
+        // Set the time field for Mixpanel SCD import (uses startTime)
+        scdEntry.time = scdEntry.startTime;
+
+        // Only add entry if all required properties are set
+        if (scdEntry.startTime && scdEntry.insertTime && scdEntry.time) {
+            scdEntries.push(scdEntry);
+        }
+
+        // Advance time for next entry — scale step size to available range
+        if (deltaDays > 1) {
+            const advance = Math.max(1, u.integer(0, Math.ceil(deltaDays / mutations)));
+            lastInserted = dayjs(scdEntry.startTime).add(advance, "day");
+        } else {
+            // Short range: advance by hours instead of days
+            const advance = Math.max(1, u.integer(1, 12));
+            lastInserted = dayjs(scdEntry.startTime).add(advance, "hour");
+        }
+    }
+
+    return scdEntries;
+}