@ak--47/dungeon-master 1.3.0 → 1.3.1

package/dungeons/vertical/travel.js

@@ -16,9 +16,6 @@ import * as v from "ak-tools";
 
 dayjs.extend(utc);
 const chance = u.initChance(SEED);
-const NOW = dayjs();
-const DATASET_START = NOW.subtract(num_days, "days");
-
 /** @typedef  {import("../../types").Dungeon} Config */
 
 const hotelIds = v.range(1, 200).map(() => `HTL_${v.uid(6)}`);
@@ -48,7 +45,16 @@ const destinationCities = ["New York", "London", "Paris", "Tokyo", "Barcelona",
 
 /**
  * ═══════════════════════════════════════════════════════════════
- * ANALYTICS HOOKS (8 hooks)
+ * ANALYTICS HOOKS (10 hooks)
+ *
+ * NOTE: All cohort effects are HIDDEN — no flag stamping. Discoverable via
+ * raw-prop breakdowns (booking_window, day, segment) or behavioral cohorts.
+ *
+ * Adds 9. BOOKING TIME-TO-CONVERT (Business 1.35x faster, Budget 1.25x slower)
+ *      [funnel-post: visible only in Mixpanel funnel median TTC; cross-event
+ *      MIN→MIN SQL queries do NOT show this]
+ * and 10. HOTEL-VIEWED MAGIC NUMBER (sweet 5-10 → +30% nightly_rate;
+ * over 11+ → drop 35% of bookings).
  * ═══════════════════════════════════════════════════════════════
  *
  * ───────────────────────────────────────────────────────────────
@@ -206,7 +212,9 @@ const destinationCities = ["New York", "London", "Paris", "Tokyo", "Barcelona",
 const config = {
 	token,
 	seed: SEED,
-	numDays: num_days,
+	datasetStart: "2026-01-01T00:00:00Z",
+	datasetEnd: "2026-04-28T23:59:59Z",
+	// numDays: num_days,
 	avgEventsPerUserPerDay: avg_events_per_user_per_day,
 	numUsers: num_users,
 	hasAnonIds: false,
@@ -639,11 +647,25 @@ const config = {
 			}
 		}
 
-		// ── HOOK 8: REPEAT DESTINATION CLUSTERING (funnel-pre) ─
-		// conversionRate modifications moved to everything hook (event filtering)
-		// to avoid dilution by organic events
-		if (type === "funnel-pre") {
-			// prop-setting only; no conversionRate changes
+		// HOOK 9 (T2C): BOOKING TIME-TO-CONVERT (funnel-post)
+		// Business travelers complete the Search-to-Book funnel 1.35x faster
+		// (factor 0.74); leisure_family/budget customers 1.25x slower (1.25).
+		if (type === "funnel-post") {
+			const segment = meta?.profile?.customer_segment;
+			if (Array.isArray(record) && record.length > 1) {
+				const factor = (
+					segment === "business_traveler" ? 0.74 :
+					segment === "budget_hunter" || segment === "leisure_family" ? 1.25 :
+					1.0
+				);
+				if (factor !== 1.0) {
+					for (let i = 1; i < record.length; i++) {
+						const prev = dayjs(record[i - 1].time);
+						const newGap = Math.round(dayjs(record[i].time).diff(prev) * factor);
+						record[i].time = prev.add(newGap, "milliseconds").toISOString();
+					}
+				}
+			}
 		}
 
 		// ── HOOK 1: WEEKEND LEISURE SURGE ────────────
@@ -686,10 +708,11 @@ const config = {
 			});
 
 			// ── HOOK 2: ADVANCE BOOKING DISCOUNT ─────
+			const datasetEndForBooking = dayjs.unix(meta.datasetEnd);
 			events.forEach(e => {
 				if (e.event === "booking completed") {
 					const eventTime = dayjs(e.time);
-					const daysUntilEnd = NOW.diff(eventTime, "days");
+					const daysUntilEnd = datasetEndForBooking.diff(eventTime, "days");
 					if (daysUntilEnd > 21) {
 						e.booking_window = "advance";
 						e.nightly_rate = Math.floor((e.nightly_rate || 150) * 0.8);
@@ -705,12 +728,11 @@ const config = {
 			// business_traveler or luxury_seeker to simulate their lower funnel
 			// conversion (was conversionRate * 1.3 / 1.15 in funnel-pre)
 			const segment = profile && profile.customer_segment;
-			if (segment !== "business_traveler" && segment !== "luxury_seeker") {
+			if (segment !== "business_traveler" && segment !== "luxury_seeker"
+					&& chance.bool({ likelihood: 25 })) {
 				for (let i = events.length - 1; i >= 0; i--) {
 					if (events[i].event === "booking completed") {
-						if (chance.bool({ likelihood: 25 })) {
-							events.splice(i, 1);
-						}
+						events.splice(i, 1);
 					}
 				}
 			}
@@ -776,7 +798,8 @@ const config = {
 				}
 			}
 
-			// ── HOOK 6: REVIEW QUALITY BY STAY RATING ────────
+			// HOOK 6: REVIEW QUALITY BY STAY RATING — high avg ratings get
+			// review_length 1.5x; low avg ratings get 0.5x. Mutates raw prop.
 			let totalRating = 0;
 			let ratingCount = 0;
 			events.forEach(e => {
@@ -796,6 +819,26 @@ const config = {
 				}
 			});
 
+			// HOOK 10: HOTEL-VIEWED MAGIC NUMBER (in-funnel, no flags)
+			// Sweet 5-10 hotel-viewed events → +30% on booking nightly_rate
+			// (decisive comparison shoppers book higher-tier rooms).
+			// Over 11+ → drop 35% of booking-completed events (analysis
+			// paralysis blocks conversion).
+			const hotelViews = events.filter(e => e.event === "hotel viewed").length;
+			if (hotelViews >= 5 && hotelViews <= 10) {
+				events.forEach(e => {
+					if (e.event === "booking completed" && typeof e.nightly_rate === "number") {
+						e.nightly_rate = Math.round(e.nightly_rate * 1.3);
+					}
+				});
+			} else if (hotelViews >= 11) {
+				for (let i = events.length - 1; i >= 0; i--) {
+					if (events[i].event === "booking completed" && chance.bool({ likelihood: 35 })) {
+						events.splice(i, 1);
+					}
+				}
+			}
+
 			return record;
 		}
 

package/index.js

@@ -25,7 +25,7 @@ import { makeMirror } from './lib/generators/mirror.js';
 import { makeGroupProfile, makeProfile } from './lib/generators/profiles.js';
 
 // Utilities
-import { initChance } from './lib/utils/utils.js';
+import { initChance, setDatasetNow } from './lib/utils/utils.js';
 
 // External dependencies
 import dayjs from "dayjs";
@@ -33,12 +33,8 @@ import utc from "dayjs/plugin/utc.js";
 import { timer } from 'ak-tools';
 import { dataLogger as logger } from './lib/utils/logger.js';
 
-// Initialize dayjs and time constants
+// Initialize dayjs (window anchors are now resolved per-config in config-validator)
 dayjs.extend(utc);
-const FIXED_NOW = dayjs('2024-02-02').unix();
-global.FIXED_NOW = FIXED_NOW;
-let FIXED_BEGIN = dayjs.unix(FIXED_NOW).subtract(90, 'd').unix();
-global.FIXED_BEGIN = FIXED_BEGIN;
 
 
 /**
@@ -134,18 +130,21 @@ async function runDungeon(config) {
 			initChance(config.seed);
 		}
 
-		// Step 1: Validate and enrich configuration
+		// Step 1: Validate and enrich configuration (resolves dataset window)
 		validatedConfig = validateDungeonConfig(config);
 
-		// Compute FIXED_BEGIN from validated numDays
-		const configNumDays = validatedConfig.numDays || 30;
-		const fixedBegin = dayjs.unix(FIXED_NOW).subtract(configNumDays, 'd').unix();
+		// validateDungeonConfig always resolves these to unix seconds, but the
+		// public Dungeon type accepts string | number on input. Narrow here.
+		const fixedNow = /** @type {number} */ (validatedConfig.datasetEnd);
+		const fixedBegin = /** @type {number} */ (validatedConfig.datasetStart);
 
-		// Keep globals for backwards compatibility with tests/dungeons that read them
-		global.FIXED_BEGIN = fixedBegin;
+		// Anchor the wall-clock-free reference used by date()/day() helpers in
+		// dungeon configs. Without this, those factories produce values relative
+		// to process-start, which leaks wall-clock time into the output.
+		setDatasetNow(fixedNow);
 
 		// Step 2: Create context with validated config (pass time constants explicitly)
-		const context = createContext(validatedConfig, null, { fixedNow: FIXED_NOW, fixedBegin });
+		const context = createContext(validatedConfig, null, { fixedNow, fixedBegin });
 
 		// Step 3: Initialize storage containers
 		const storageManager = new StorageManager(context);
@@ -237,11 +236,12 @@ async function generateAdSpendData(context) {
 	const { config, storage } = context;
 	const { numDays } = config;
 
-	const timeShift = context.TIME_SHIFT_SECONDS;
 	for (let day = 0; day < numDays; day++) {
-		const fixedDay = dayjs.unix(context.FIXED_BEGIN).add(day, 'day').unix();
-		const shiftedDay = Math.min(fixedDay + timeShift, context.MAX_TIME);
-		const targetDay = dayjs.unix(shiftedDay).toISOString();
+		const dayUnix = Math.min(
+			dayjs.unix(context.FIXED_BEGIN).add(day, 'day').unix(),
+			context.FIXED_NOW
+		);
+		const targetDay = dayjs.unix(dayUnix).toISOString();
 		const adSpendEvents = await makeAdSpend(context, targetDay);
 
 		if (adSpendEvents.length > 0) {

package/lib/core/config-validator.js

@@ -14,8 +14,80 @@ import * as u from "../utils/utils.js";
 import { resolveSoup } from "../templates/soup-presets.js";
 import { resolveMacro } from "../templates/macro-presets.js";
 
-/** Fixed reference point for time calculations (2024-02-02) */
-const FIXED_NOW = dayjs('2024-02-02').unix();
+/**
+ * Resolve dataset window from config. Returns { datasetStartUnix, datasetEndUnix, numDays }.
+ * Three modes:
+ *   1. Both `datasetStart` AND `datasetEnd` provided → pin window. Recompute numDays from the
+ *      window (ignore any user-supplied numDays — warn on conflict). Bit-exact deterministic.
+ *   2. Neither provided → fall back to (today_start - numDays, today_start). Deterministic
+ *      within a single calendar day; slides across days. Warn once.
+ *   3. Exactly one provided → throw.
+ *
+ * Accepts ISO strings, unix seconds, or anything dayjs() can parse.
+ *
+ * @param {*} datasetStart
+ * @param {*} datasetEnd
+ * @param {number} [userNumDays]
+ * @returns {{ datasetStartUnix: number, datasetEndUnix: number, numDays: number }}
+ */
+function resolveDatasetWindow(datasetStart, datasetEnd, userNumDays) {
+	const hasStart = datasetStart !== undefined && datasetStart !== null;
+	const hasEnd = datasetEnd !== undefined && datasetEnd !== null;
+
+	if (hasStart !== hasEnd) {
+		throw new Error(
+			`datasetStart and datasetEnd must be specified together (got datasetStart=${datasetStart}, datasetEnd=${datasetEnd}). ` +
+			`Provide both to pin the window, or neither to fall back to numDays.`
+		);
+	}
+
+	if (hasStart && hasEnd) {
+		const startUnix = parseToUnix(datasetStart, 'datasetStart');
+		const endUnix = parseToUnix(datasetEnd, 'datasetEnd');
+		if (endUnix <= startUnix) {
+			throw new Error(`datasetEnd (${datasetEnd}) must be after datasetStart (${datasetStart}).`);
+		}
+		const derivedNumDays = Math.max(1, Math.round((endUnix - startUnix) / 86400));
+		if (userNumDays !== undefined && userNumDays !== null && userNumDays !== derivedNumDays) {
+			console.warn(
+				`⚠️  datasetStart/datasetEnd take precedence; user-supplied numDays=${userNumDays} ignored, derived numDays=${derivedNumDays}.`
+			);
+		}
+		return { datasetStartUnix: startUnix, datasetEndUnix: endUnix, numDays: derivedNumDays };
+	}
+
+	// Fallback: anchor to today's start-of-day, walk back numDays
+	const fallbackNumDays = (typeof userNumDays === 'number' && userNumDays > 0) ? userNumDays : 30;
+	const todayStart = dayjs().startOf('day').unix();
+	const fallbackStart = todayStart - fallbackNumDays * 86400;
+	console.warn(
+		`⚠️  No 'datasetStart'/'datasetEnd' set — dataset window anchored to today's date and will shift across runs. Pin both for full determinism.`
+	);
+	return { datasetStartUnix: fallbackStart, datasetEndUnix: todayStart, numDays: fallbackNumDays };
+}
+
+/**
+ * Parse a value (ISO string, unix seconds, dayjs-parseable) into unix seconds.
+ * Throws if the value can't be parsed into a valid date.
+ * @param {*} value
+ * @param {string} fieldName
+ * @returns {number}
+ */
+function parseToUnix(value, fieldName) {
+	// Treat numbers as unix seconds (or unix milliseconds if too large)
+	if (typeof value === 'number') {
+		if (!Number.isFinite(value) || value <= 0) {
+			throw new Error(`${fieldName} must be a positive finite number (got ${value}).`);
+		}
+		// Heuristic: > 10^12 means milliseconds, otherwise seconds
+		return value > 1e12 ? Math.floor(value / 1000) : Math.floor(value);
+	}
+	const parsed = dayjs(value);
+	if (!parsed.isValid()) {
+		throw new Error(`${fieldName} could not be parsed as a date (got ${JSON.stringify(value)}).`);
+	}
+	return parsed.unix();
+}
 
 /**
  * Infers funnels from the provided events
@@ -168,18 +240,18 @@ export function validateDungeonConfig(config) {
 		throw new Error(`numDays must be a positive number (got ${config.numDays})`);
 	}
 
-	// Setting up "TIME"
-	if (epochStart && !numDays) numDays = dayjs.unix(epochEnd).diff(dayjs.unix(epochStart), "day");
-	if (!epochStart && numDays) epochStart = dayjs.unix(epochEnd).subtract(numDays, "day").unix();
-	if (epochStart && numDays) { } // noop
-	if (!epochStart && !numDays) {
-		throw new Error("Either epochStart or numDays must be provided");
-	}
+	// ── Resolve dataset window ──
+	// Preferred path: explicit datasetStart + datasetEnd → pinned, deterministic window.
+	// Fallback: numDays only → today_start - numDays back (sliding, warn-emitted).
+	const windowResolution = resolveDatasetWindow(config.datasetStart, config.datasetEnd, config.numDays);
+	const datasetStartUnix = windowResolution.datasetStartUnix;
+	const datasetEndUnix = windowResolution.datasetEndUnix;
+	numDays = windowResolution.numDays;
 
-	// Final sanity check (e.g. epochStart/epochEnd produced a non-positive numDays).
-	if (!Number.isFinite(numDays) || numDays <= 0) {
-		throw new Error(`numDays must be a positive number (got ${numDays})`);
-	}
+	// Mirror window into legacy epoch* surface (still consumed by inferFunnels callers
+	// and any external code that read these from validated config).
+	epochStart = datasetStartUnix;
+	epochEnd = datasetEndUnix;
 
 	// Resolve event-rate primitive: avgEventsPerUserPerDay is the canonical knob.
 	// numEvents is supported as a fallback (legacy + total-volume target). Whichever
@@ -349,7 +421,7 @@ export function validateDungeonConfig(config) {
 	// Feature 2: World Events
 	let worldEvents = config.worldEvents || null;
 	if (worldEvents) {
-		worldEvents = resolveWorldEvents(worldEvents, numDays);
+		worldEvents = resolveWorldEvents(worldEvents, datasetStartUnix);
 	}
 
 	// Feature 3: Engagement Decay
@@ -391,7 +463,7 @@ export function validateDungeonConfig(config) {
 	// Feature 9: Anomalies
 	let anomalies = config.anomalies || null;
 	if (anomalies) {
-		anomalies = resolveAnomalies(anomalies, numDays);
+		anomalies = resolveAnomalies(anomalies, datasetStartUnix);
 	}
 
 	// Build final config object
@@ -407,6 +479,8 @@ export function validateDungeonConfig(config) {
 		avgEventsPerUserPerDay,
 		epochStart,
 		epochEnd,
+		datasetStart: datasetStartUnix,
+		datasetEnd: datasetEndUnix,
 		events: validatedEvents,
 		superProps,
 		userProps,
@@ -551,12 +625,11 @@ function validatePersonas(personas) {
 /**
  * Resolves world events to absolute timestamps
  * @param {import('../../types').WorldEvent[]} worldEvents
- * @param {number} numDays
+ * @param {number} beginUnix - Dataset start (unix seconds)
  * @returns {import('../../types').ResolvedWorldEvent[]}
  */
-function resolveWorldEvents(worldEvents, numDays) {
+function resolveWorldEvents(worldEvents, beginUnix) {
 	if (!Array.isArray(worldEvents) || worldEvents.length === 0) return null;
-	const beginUnix = dayjs.unix(FIXED_NOW).subtract(numDays, 'day').unix();
 
 	return worldEvents.map(we => {
 		const startUnix = beginUnix + (we.startDay * 86400);
@@ -720,12 +793,11 @@ function resolveFeatures(features, numDays) {
 /**
  * Resolves anomaly configs with absolute timestamps
  * @param {import('../../types').AnomalyConfig[]} anomalies
- * @param {number} numDays
+ * @param {number} beginUnix - Dataset start (unix seconds)
  * @returns {import('../../types').AnomalyConfig[]}
  */
-function resolveAnomalies(anomalies, numDays) {
+function resolveAnomalies(anomalies, beginUnix) {
 	if (!Array.isArray(anomalies) || anomalies.length === 0) return null;
-	const beginUnix = dayjs.unix(FIXED_NOW).subtract(numDays, 'day').unix();
 	return anomalies.map(a => {
 		if (!a.type) throw new Error('Each anomaly must have a type');
 		if (!a.event) throw new Error('Each anomaly must have an event name');

package/lib/core/context.js

@@ -156,30 +156,16 @@ export function createContext(config, storage = null, timeConstants = {}) {
 			return runtime.isBatchMode;
 		},
 
-		// Time helper methods
-		getTimeShift() {
-			const actualNow = dayjs().subtract(1, "hour");
-			return actualNow.diff(dayjs.unix(this.FIXED_NOW), "seconds");
-		},
-
-		getDaysShift() {
-			const actualNow = dayjs().subtract(1, "hour");
-			return actualNow.diff(dayjs.unix(this.FIXED_NOW), "days");
-		},
-
-		// Time constants (passed explicitly from index.js; global fallback only for direct test usage)
-		FIXED_NOW: timeConstants.fixedNow || global.FIXED_NOW,
-		FIXED_BEGIN: timeConstants.fixedBegin || global.FIXED_BEGIN,
-
-		// PERFORMANCE: Pre-calculated time shift (instead of calculating per-event)
-		TIME_SHIFT_SECONDS: (() => {
-			const fixedNow = timeConstants.fixedNow || global.FIXED_NOW;
-			const actualNow = dayjs().subtract(1, "hour");
-			return actualNow.diff(dayjs.unix(fixedNow), "seconds");
-		})(),
-
-		// Max timestamp (unix seconds) — clamp here to prevent future events
-		MAX_TIME: dayjs().unix(),
+		// Dataset window anchors (resolved by config-validator). FIXED_BEGIN and
+		// FIXED_NOW are the authoritative window — events are generated directly
+		// inside this range, no time-shift step. DATASET_*_SECONDS are aliases
+		// kept for the existing `meta.datasetStart`/`meta.datasetEnd` hook surface.
+		// Resolution: explicit timeConstants override, otherwise pull from validated config.
+		// validateDungeonConfig always normalizes datasetStart/datasetEnd to unix seconds.
+		FIXED_NOW: /** @type {number} */ (timeConstants.fixedNow || config.datasetEnd),
+		FIXED_BEGIN: /** @type {number} */ (timeConstants.fixedBegin || config.datasetStart),
+		get DATASET_START_SECONDS() { return this.FIXED_BEGIN; },
+		get DATASET_END_SECONDS() { return this.FIXED_NOW; },
 	};
 
 	return context;

package/lib/core/storage.js

@@ -111,7 +111,12 @@ export async function createHookArray(arr = [], opts) {
 			}
 		} else {
 			// Slow path for actual transformation hooks
-			const allMetaData = { ...rest, ...meta };
+			const allMetaData = {
+				...rest,
+				...meta,
+				datasetStart: context?.DATASET_START_SECONDS,
+				datasetEnd: context?.DATASET_END_SECONDS
+			};
 
 			// Helper to validate events have required properties
 			// Note: event-type hooks are handled in the fast path (alreadyHooked),

package/lib/generators/events.js

@@ -101,19 +101,13 @@ export async function makeEvent(
 
     // Set event time using TimeSoup for realistic distribution
     if (earliestTime) {
-        let shiftedTimestamp;
+        let unixTime;
         if (isFirstEvent) {
-            shiftedTimestamp = earliestTime + context.TIME_SHIFT_SECONDS;
+            unixTime = earliestTime;
         } else {
-            // TimeSoup returns unix seconds; shift and convert to ISO once
-            const soupTimestamp = u.TimeSoup(earliestTime, context.FIXED_NOW, peaks, deviation, mean, dayOfWeekWeights, hourOfDayWeights, context.TIME_SHIFT_SECONDS);
-            shiftedTimestamp = soupTimestamp + context.TIME_SHIFT_SECONDS;
+            unixTime = u.TimeSoup(earliestTime, context.FIXED_NOW, peaks, deviation, mean, dayOfWeekWeights, hourOfDayWeights);
         }
-        // Drop events that would land in the future (Mixpanel rewrites these to "now", causing pile-ups)
-        if (shiftedTimestamp > context.MAX_TIME) {
-            eventTemplate._drop = true;
-        }
-        eventTemplate.time = dayjs.unix(Math.min(shiftedTimestamp, context.MAX_TIME)).toISOString();
+        eventTemplate.time = dayjs.unix(unixTime).toISOString();
     }
 
     // Add anonymous identifiers
@@ -196,11 +190,12 @@ export async function makeEvent(
         }
     }
 
-    // Perf 1: Compute eventUnix once for all time-based checks
-    // Subtracts TIME_SHIFT to convert real time back to FIXED time (world events/features use FIXED time)
+    // Perf 1: Compute eventUnix once for all time-based checks. World events &
+    // features were resolved against the dataset window (no shift), and event
+    // times now also live in that same window — direct unix conversion works.
     let eventUnix = null;
     if ((worldEventsTimeline || resolvedFeatures) && eventTemplate.time) {
-        eventUnix = dayjs(eventTemplate.time).subtract(context.TIME_SHIFT_SECONDS, 'seconds').unix();
+        eventUnix = dayjs(eventTemplate.time).unix();
     }
 
     // Feature 2: World events — inject props for active events at this timestamp
@@ -303,7 +298,9 @@ export async function makeEvent(
         const hookedEvent = await hook(eventTemplate, "event", {
             user: { distinct_id },
             config,
-            persona: featureCtx.persona || null
+            persona: featureCtx.persona || null,
+            datasetStart: context.DATASET_START_SECONDS,
+            datasetEnd: context.DATASET_END_SECONDS
         });
         // If hook returns a modified event, use it; otherwise use original
         if (hookedEvent && typeof hookedEvent === 'object') {

package/lib/generators/funnels.js

@@ -68,7 +68,11 @@ export async function makeFunnel(context, funnel, user, firstEventTime, profile
 	}
 
 	// Call pre-funnel hook
-	await hook(funnel, "funnel-pre", { user, profile, scd, funnel, config, firstEventTime });
+	await hook(funnel, "funnel-pre", {
+		user, profile, scd, funnel, config, firstEventTime,
+		datasetStart: context.DATASET_START_SECONDS,
+		datasetEnd: context.DATASET_END_SECONDS
+	});
 
 	// Extract funnel configuration
 	let {
@@ -206,7 +210,11 @@ export async function makeFunnel(context, funnel, user, firstEventTime, profile
 	);
 
 	// Call post-funnel hook
-	await hook(finalEvents, "funnel-post", { user, profile, scd, funnel, config });
+	await hook(finalEvents, "funnel-post", {
+		user, profile, scd, funnel, config,
+		datasetStart: context.DATASET_START_SECONDS,
+		datasetEnd: context.DATASET_END_SECONDS
+	});
 
 	return [finalEvents, doesUserConvert];
 }
@@ -446,8 +454,8 @@ async function generateFunnelEvents(
 
 		try {
 			let computedTime = dayjs(funnelStartTime).add(event.relativeTimeMs, "milliseconds");
-			// Drop events that would land in the future
-			if (context.MAX_TIME && computedTime.unix() > context.MAX_TIME) {
+			// Drop events that would land past the dataset window
+			if (context.FIXED_NOW && computedTime.unix() > context.FIXED_NOW) {
 				newEvent._drop = true;
 			}
 			if (computedTime.isValid()) {

package/lib/generators/mirror.js

@@ -22,8 +22,9 @@ export async function makeMirror(context) {
     if (!mirrorProps || Object.keys(mirrorProps).length === 0) {
         return; // No mirror properties configured
     }
-    
-    const now = dayjs();
+
+    // Anchor to the resolved dataset end (not wall-clock) so mirror behavior is deterministic.
+    const now = context.FIXED_NOW ? dayjs.unix(context.FIXED_NOW) : dayjs();
 
     for (const oldEvent of eventData) {
         let newEvent = null;

package/lib/generators/product-names.js

@@ -119,7 +119,7 @@ export const productComparisonGen = createTextGenerator({
 	authenticityLevel: 0.7,
 	specificityLevel: 0.8,
 	min: 100,
-	max: 300,
+	max: 254,  // capped at Mixpanel string property limit
 	includeMetadata: false
 });
 

package/lib/generators/scd.js

@@ -48,7 +48,8 @@ export async function makeSCD(context, scdProp, scdKey, distinct_id, mutations,
 
     const scdEntries = [];
     let lastInserted = dayjs(created);
-    const now = dayjs();
+    // Anchor to the resolved dataset end (not wall-clock) so SCD count is deterministic.
+    const now = context.FIXED_NOW ? dayjs.unix(context.FIXED_NOW) : dayjs();
     const deltaDays = now.diff(lastInserted, "day");
     const uuidKeyName = type === 'user' ? 'distinct_id' : type;
     let lastStartTime = null; // Track for monotonic ordering

package/lib/generators/text.js

@@ -524,7 +524,7 @@ class OrganicTextGenerator {
             intensity: 'medium',
             formality: 'casual',
             min: 100,
-            max: 500,
+            max: 254,  // default capped at Mixpanel string property limit; override per-generator if needed
             seed: null,
             keywords: null,
             keywordDensity: 0.15,