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

package/lib/generators/events.js

@@ -10,25 +10,28 @@
 /** @typedef {import('../../types').Context} Context */
 
 import dayjs from "dayjs";
+import { randomUUID } from "node:crypto";
 import * as u from "../utils/utils.js";
 import { dataLogger as logger } from "../utils/logger.js";
 
 // Keys that must never be nulled by data quality gremlins
 const NULL_EXEMPT_KEYS = new Set(['event', 'time', 'insert_id', 'user_id', 'device_id', 'distinct_id', '_drop', '_anomaly', '_persona']);
 
+
 /**
  * Creates a Mixpanel event with a flat shape
- * @param {Context} context - Context object containing config, defaults, etc.
- * @param {string} distinct_id - User identifier
+ * @param {Context} context
+ * @param {string} distinct_id
  * @param {number} earliestTime - Unix timestamp for earliest possible event time
  * @param {Object} chosenEvent - Event configuration object
  * @param {string[]} [anonymousIds] - Array of anonymous/device IDs
- * @param {string[]} [sessionIds] - Array of session IDs
  * @param {Object} [superProps] - Super properties to add to event
  * @param {Array} [groupKeys] - Group key configurations
- * @param {boolean} [isFirstEvent] - Whether this is the user's first event
- * @param {boolean} [skipDefaults] - Whether to skip adding default properties
- * @returns {Promise<Object>} Generated event object
+ * @param {boolean} [isFirstEvent]
+ * @param {boolean} [skipDefaults]
+ * @param {Object} [featureCtx] - Feature context (persona, worldEvents, dataQuality)
+ * @param {Object} [identityCtx] - Phase 2 identity context ({ stamping, devicePool })
+ * @returns {Promise<Object>}
  */
 export async function makeEvent(
     context,
@@ -36,12 +39,12 @@ export async function makeEvent(
     earliestTime,
     chosenEvent,
     anonymousIds = [],
-    sessionIds = [],
     superProps = {},
     groupKeys = [],
     isFirstEvent = false,
     skipDefaults = false,
-    featureCtx = {}
+    featureCtx = {},
+    identityCtx = null
 ) {
     // Validate required parameters
     if (!distinct_id) throw new Error("no distinct_id");
@@ -89,9 +92,16 @@ export async function makeEvent(
         defaultProps.browser = u.choose(defaults.browsers());
     }
 
-    // Add campaigns with attribution likelihood
-    if (hasCampaigns && chance.bool({ likelihood: 25 })) {
-        defaultProps.campaigns = u.pickRandom(defaults.campaigns());
+    // Add campaigns with attribution likelihood.
+    // When any event has isAttributionEvent, only stamp UTMs on those events (25% chance).
+    // Otherwise, backwards-compat: ~25% of all events get UTMs.
+    if (hasCampaigns) {
+        const shouldStamp = config.hasAttributionFlags
+            ? (chosenEvent.isAttributionEvent && chance.bool({ likelihood: 25 }))
+            : chance.bool({ likelihood: 25 });
+        if (shouldStamp) {
+            defaultProps.campaigns = u.pickRandom(defaults.campaigns());
+        }
     }
     
     // PERFORMANCE: Use pre-computed device pool instead of rebuilding every time
@@ -101,34 +111,41 @@ 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
-    if (anonymousIds.length) {
-        eventTemplate.device_id = u.pickRandom(anonymousIds);
+    // ── Phase 2 identity stamping ──
+    // `identityCtx.stamping` modes:
+    //   "both"        → user_id + device_id (when pool non-empty). DEFAULT.
+    //   "user_only"   → user_id only (post-auth funnel events).
+    //   "device_only" → device_id only (pre-auth funnel events).
+    //   "stitch"      → both (the one stitch event per converted born-in-dataset user).
+    // Callers (funnels.js / user-loop.js) compute the mode based on the user's auth state
+    // and the funnel's `isAuthEvent` placement. Default "both" preserves backwards-compat
+    // for dungeons that don't flag auth events. The legacy 42%-per-event user_id dice is
+    // gone — every event now gets user_id by default.
+    const stamping = (identityCtx && identityCtx.stamping) || 'both';
+    const wantsUser = stamping === 'both' || stamping === 'user_only' || stamping === 'stitch';
+    const wantsDevice = stamping === 'both' || stamping === 'device_only' || stamping === 'stitch';
+    const devicePool = (identityCtx && identityCtx.devicePool) || anonymousIds || [];
+
+    if (wantsDevice && devicePool && devicePool.length) {
+        eventTemplate.device_id = u.pickRandom(devicePool);
     }
-
-    // Session IDs are assigned post-hoc in user-loop.js based on temporal gaps
-
-    // Sometimes add user_id (for attribution modeling)
-    if (!isFirstEvent && chance.bool({ likelihood: 42 })) {
+    if (wantsUser) {
         eventTemplate.user_id = distinct_id;
     }
+    // Session IDs are assigned post-hoc in user-loop.js based on temporal gaps
 
-    // Ensure we have either user_id or device_id
+    // Floor: every event must carry at least one of user_id / device_id (storage layer
+    // rejects events lacking both). If the stamping mode is "device_only" but there's no
+    // device pool, fall back to user_id rather than producing an invalid event.
     if (!eventTemplate.user_id && !eventTemplate.device_id) {
         eventTemplate.user_id = distinct_id;
     }
@@ -171,36 +188,14 @@ export async function makeEvent(
     addGroupProperties(eventTemplate, groupKeys);
 
     // ── Event-level features (applied before hooks, so hooks can override) ──
-    const { userLocation, persona, worldEventsTimeline, resolvedFeatures, resolvedAnomalies, dataQuality: dq, geo: geoConfig, userCampaign } = featureCtx;
-
-    // Feature 6: Attribution — stamp UTM properties on events as touchpoints
-    // Mixpanel attribution analysis needs UTM on EVENTS, not just profiles.
-    // Pattern: first events carry acquisition UTM, later events occasionally carry re-engagement UTM.
-    if (userCampaign) {
-        // ~40% of events carry UTM (simulates page loads, session starts, ad clicks)
-        // First events (isFirstEvent) always carry UTM (acquisition touchpoint)
-        if (isFirstEvent || chance.bool({ likelihood: 40 })) {
-            eventTemplate.utm_source = userCampaign.source;
-            eventTemplate.utm_campaign = userCampaign.name;
-            if (userCampaign.medium) eventTemplate.utm_medium = userCampaign.medium;
-            if (userCampaign.utm_content) eventTemplate.utm_content = userCampaign.utm_content;
-            if (userCampaign.utm_term) eventTemplate.utm_term = userCampaign.utm_term;
-        }
-    }
-
-    // Feature 7: Sticky geo location
-    if (userLocation && geoConfig?.sticky) {
-        // Override the random location with user's sticky location
-        for (const key in userLocation) {
-            eventTemplate[key] = userLocation[key];
-        }
-    }
+    const { userLocation, persona, worldEventsTimeline, dataQuality: dq } = featureCtx;
 
-    // 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
+    // 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();
+    if (worldEventsTimeline && eventTemplate.time) {
+        eventUnix = dayjs(eventTemplate.time).unix();
     }
 
     // Feature 2: World events — inject props for active events at this timestamp
@@ -227,47 +222,6 @@ export async function makeEvent(
         }
     }
 
-    // Feature 8: Progressive feature adoption
-    if (resolvedFeatures && eventUnix !== null) {
-        const daysSinceBegin = (eventUnix - context.FIXED_BEGIN) / 86400;
-        for (const feat of resolvedFeatures) {
-            const affects = feat.affectsEvents;
-            if (affects !== "*" && !(Array.isArray(affects) && affects.includes(eventTemplate.event))) continue;
-            if (daysSinceBegin < feat.launchDay) {
-                if (feat.defaultBefore !== undefined) {
-                    eventTemplate[feat.property] = feat.defaultBefore;
-                }
-            } else {
-                const daysSinceLaunch = daysSinceBegin - feat.launchDay;
-                const { k, midpoint } = feat._resolvedCurve || { k: 0.08, midpoint: 30 };
-                const adoptionProb = 1 / (1 + Math.exp(-k * (daysSinceLaunch - midpoint)));
-                if (chance.bool({ likelihood: Math.min(100, adoptionProb * 100) })) {
-                    eventTemplate[feat.property] = u.pickRandom(feat._adoptedValues);
-                } else if (feat.defaultBefore !== undefined) {
-                    eventTemplate[feat.property] = feat.defaultBefore;
-                } else if (feat.values.length > 0) {
-                    eventTemplate[feat.property] = feat.values[0];
-                }
-            }
-        }
-    }
-
-    // Feature 9: Anomaly extreme values
-    if (resolvedAnomalies && eventTemplate.event) {
-        for (const a of resolvedAnomalies) {
-            if (a.type === 'extreme_value' && a.event === eventTemplate.event && a.property) {
-                if (chance.bool({ likelihood: (a.frequency ?? 0.001) * 100 })) {
-                    const currentVal = eventTemplate[a.property];
-                    if (typeof currentVal === 'number') {
-                        eventTemplate[a.property] = currentVal * (a.multiplier || 10);
-                    }
-                    if (a.tag) eventTemplate._anomaly = a.tag;
-                    if (a.properties) Object.assign(eventTemplate, a.properties);
-                }
-            }
-        }
-    }
-
     // Feature 4: Data quality — null injection and timezone confusion
     if (dq) {
         // Null injection
@@ -292,10 +246,7 @@ export async function makeEvent(
         }
     }
 
-    // Generate unique insert_id
-	const distinctId = eventTemplate.user_id || eventTemplate.device_id || eventTemplate.distinct_id || distinct_id;
-	const tuple = `${eventTemplate.event}-${eventTemplate.time}-${distinctId}`;
-    eventTemplate.insert_id = u.quickHash(tuple);
+	eventTemplate.insert_id = randomUUID();
 
     // Call hook if configured (hooks override everything — they are the final authority)
     const { hook } = config;
@@ -303,7 +254,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

@@ -19,9 +19,17 @@ import { dataLogger as logger } from "../utils/logger.js";
  * @param {Object} profile - User profile object
  * @param {Object} scd - Slowly changing dimensions object
  * @param {Object} [persona] - User's assigned persona
- * @returns {Promise<[Array, boolean]>} Tuple of [events, didConvert]
+ * @param {Object} [featureCtx] - Persona / world-event / data-quality / etc. context.
+ * @param {Object} [attemptMeta] - Phase 2 multi-attempt + identity context. Shape:
+ *   `{ isFirstFunnel, isBorn, attemptsConfig, attemptNumber, totalAttempts, isFinalAttempt,
+ *      truncateBeforeAuth, devicePool }`. When omitted defaults to a single normal attempt
+ *   with no identity stamping overrides (legacy behavior).
+ * @returns {Promise<[Array, boolean, number|null]>} Tuple `[events, didConvert, authTimeMs]`
+ *   where `authTimeMs` is the unix-millisecond timestamp of the stitch event (the first
+ *   `isAuthEvent` step that actually fired in this funnel run), or null if the user did
+ *   not reach the stitch step in this run.
  */
-export async function makeFunnel(context, funnel, user, firstEventTime, profile = {}, scd = {}, persona = null, featureCtx = {}) {
+export async function makeFunnel(context, funnel, user, firstEventTime, profile = {}, scd = {}, persona = null, featureCtx = {}, attemptMeta = null) {
 	if (!funnel) throw new Error("no funnel");
 	if (!user) throw new Error("no user");
 
@@ -29,48 +37,110 @@ export async function makeFunnel(context, funnel, user, firstEventTime, profile
 	const chance = u.getChance();
 	const { hook = async (a) => a } = config;
 
+	// ── Phase 2 attempt + identity context ──
+	// Resolve a defensive default so legacy callers that don't pass attemptMeta still
+	// get a complete shape downstream (hook meta, identity stamping logic).
+	const meta = attemptMeta || {};
+	const attemptInfo = {
+		isFirstFunnel: !!meta.isFirstFunnel,
+		isBorn: meta.isBorn === undefined ? false : !!meta.isBorn,
+		attemptsConfig: meta.attemptsConfig || null,
+		attemptNumber: meta.attemptNumber || 1,
+		totalAttempts: meta.totalAttempts || 1,
+		isFinalAttempt: meta.isFinalAttempt === undefined ? true : !!meta.isFinalAttempt,
+		truncateBeforeAuth: !!meta.truncateBeforeAuth,
+	};
+	const devicePool = meta.devicePool || null;
+
 	// Get session start events if configured
 	const sessionStartEvents = config.events?.filter(a => a.isSessionStartEvent) || [];
 
 	// Clone funnel to avoid mutating the original object
 	funnel = { ...funnel };
 
-	// Experiment handling: if funnel.experiment === true, create 3 variants
+	// Experiment handling: resolved by config-validator into funnel._experiment.
+	// Variant assignment is deterministic per-user (hash of userId + experiment name).
 	let experimentVariant = null;
 	let experimentName = null;
-
-	if (funnel.experiment) {
-		experimentName = funnel.name + ` Experiment` || "Unnamed Funnel";
-
-		// Evenly distribute across 3 variants (33.33% each) using seeded chance
-		const randomValue = chance.floating({ min: 0, max: 1 });
-		if (randomValue < 0.333) {
-			// Variant A: WORSE conversion, slower
-			funnel.conversionRate = Math.max(1, Math.floor(funnel.conversionRate * 0.7));
-			funnel.timeToConvert = Math.max(0.1, funnel.timeToConvert * 1.5);
-			experimentVariant = "A";
-		} else if (randomValue < 0.666) {
-			// Variant B: BETTER conversion, faster
-			funnel.conversionRate = Math.min(100, Math.ceil(funnel.conversionRate * 1.3));
-			funnel.timeToConvert = Math.max(0.1, funnel.timeToConvert * 0.7);
-			experimentVariant = "B";
-		} else {
-			// Variant C: CONTROL - original values (no changes)
-			experimentVariant = "C";
+	let experimentMeta = null;
+
+	let expCfg = funnel._experiment;
+	if (!expCfg && funnel.experiment) {
+		const DEFAULT_VARIANTS = [
+			{ name: 'Variant A', conversionMultiplier: 0.7, ttcMultiplier: 1.5, weight: 1 },
+			{ name: 'Variant B', conversionMultiplier: 1.3, ttcMultiplier: 0.7, weight: 1 },
+			{ name: 'Control', conversionMultiplier: 1.0, ttcMultiplier: 1.0, weight: 1 },
+		];
+		expCfg = { name: (funnel.name ? funnel.name + ' Experiment' : 'Unnamed Experiment'), variants: DEFAULT_VARIANTS, startUnix: null };
+	}
+	if (expCfg) {
+		const isActive = !expCfg.startUnix || firstEventTime >= expCfg.startUnix;
+		if (isActive) {
+			experimentName = expCfg.name;
+			const userId = user.distinct_id || '';
+			const totalWeight = expCfg.variants.reduce((s, v) => s + v.weight, 0);
+			const hashVal = Number(u.quickHash(`${userId}:${experimentName}`)) % totalWeight;
+			let cumWeight = 0;
+			let chosenVariant = expCfg.variants[0];
+			let chosenIdx = 0;
+			for (let vi = 0; vi < expCfg.variants.length; vi++) {
+				cumWeight += expCfg.variants[vi].weight;
+				if (hashVal < cumWeight) { chosenVariant = expCfg.variants[vi]; chosenIdx = vi; break; }
+			}
+			experimentVariant = chosenVariant.name;
+			funnel.conversionRate = Math.min(100, Math.max(1,
+				Math.round((funnel.conversionRate || 50) * chosenVariant.conversionMultiplier)));
+			funnel.timeToConvert = Math.max(0.1,
+				(funnel.timeToConvert || 1) * chosenVariant.ttcMultiplier);
+			funnel._experimentName = experimentName;
+			funnel._experimentVariant = experimentVariant;
+			funnel.sequence = ["$experiment_started", ...funnel.sequence];
+			experimentMeta = {
+				name: experimentName,
+				variantName: experimentVariant,
+				variantIndex: chosenIdx,
+				conversionMultiplier: chosenVariant.conversionMultiplier,
+				ttcMultiplier: chosenVariant.ttcMultiplier,
+				startDate: expCfg.startUnix,
+			};
 		}
+	}
 
-		// Mark that this funnel has experiment metadata (used later)
-		funnel._experimentName = experimentName;
-		funnel._experimentVariant = experimentVariant;
-
-		// Insert $experiment_started at beginning of sequence (clone array to avoid mutation)
-		funnel.sequence = ["$experiment_started", ...funnel.sequence];
+	// Apply persona and world-event modifiers to the funnel BEFORE the hook fires,
+	// so funnel-pre sees the effective rate and has final authority.
+	if (persona && persona.conversionModifier) {
+		funnel.conversionRate = Math.min(100, Math.max(0, Math.round((funnel.conversionRate || 50) * persona.conversionModifier)));
+	}
+	const resolvedWorldEvents = /** @type {import('../../types').ResolvedWorldEvent[]} */ (config.worldEvents);
+	if (resolvedWorldEvents && firstEventTime) {
+		for (const we of resolvedWorldEvents) {
+			if (firstEventTime >= we.startUnix && firstEventTime < we.endUnix && we.conversionModifier !== 1.0) {
+				const seq = funnel.sequence || [];
+				const affects = we.affectsEvents;
+				if (affects === "*" || (Array.isArray(affects) && seq.some(s => affects.includes(s)))) {
+					funnel.conversionRate = Math.min(100, Math.max(0, Math.round((funnel.conversionRate || 50) * we.conversionModifier)));
+				}
+			}
+		}
 	}
 
-	// Call pre-funnel hook
-	await hook(funnel, "funnel-pre", { user, profile, scd, funnel, config, firstEventTime });
+	// funnel-pre hook fires AFTER modifiers — hook has final authority on conversionRate,
+	// props, timeToConvert, and sequence.
+	await hook(funnel, "funnel-pre", {
+		user, profile, scd, funnel, config, firstEventTime,
+		datasetStart: context.DATASET_START_SECONDS,
+		datasetEnd: context.DATASET_END_SECONDS,
+		isFirstFunnel: attemptInfo.isFirstFunnel,
+		isBorn: attemptInfo.isBorn,
+		attemptsConfig: attemptInfo.attemptsConfig,
+		attemptNumber: attemptInfo.attemptNumber,
+		totalAttempts: attemptInfo.totalAttempts,
+		isFinalAttempt: attemptInfo.isFinalAttempt,
+		persona,
+		experiment: experimentMeta,
+	});
 
-	// Extract funnel configuration
+	// Extract funnel configuration (post-hook — hook's mutations are the final word)
 	let {
 		sequence,
 		conversionRate = 50,
@@ -83,7 +153,7 @@ export async function makeFunnel(context, funnel, user, firstEventTime, profile
 		bindPropsIndex = 0
 	} = funnel;
 
-	const { distinct_id, created, anonymousIds = [], sessionIds = [] } = user;
+	const { distinct_id, created, anonymousIds = [] } = user;
 	const { superProps = {}, groupKeys = [] } = config;
 
 	// Choose properties for this funnel instance
@@ -107,57 +177,61 @@ export async function makeFunnel(context, funnel, user, firstEventTime, profile
 		chance
 	);
 
-	// Apply persona conversion modifier (before hook, so hook can override via funnel-pre)
-	if (persona && persona.conversionModifier) {
-		adjustedConversionRate = Math.min(100, Math.max(0, Math.round(adjustedConversionRate * persona.conversionModifier)));
-	}
-
-	// Apply world event conversion modifier if active at firstEventTime
-	const resolvedWorldEvents = /** @type {import('../../types').ResolvedWorldEvent[]} */ (config.worldEvents);
-	if (resolvedWorldEvents && firstEventTime) {
-		for (const we of resolvedWorldEvents) {
-			if (firstEventTime >= we.startUnix && firstEventTime < we.endUnix && we.conversionModifier !== 1.0) {
-				const affects = we.affectsEvents;
-				if (affects === "*" || (Array.isArray(affects) && sequence.some(s => affects.includes(s)))) {
-					adjustedConversionRate = Math.min(100, Math.max(0, Math.round(adjustedConversionRate * we.conversionModifier)));
-				}
-			}
-		}
-	}
-
-	// Apply feature conversion lifts
-	const resolvedFeatures = config.features;
-	if (resolvedFeatures && firstEventTime) {
-		const daysSinceBegin = (firstEventTime - context.FIXED_BEGIN) / 86400;
-		for (const feat of resolvedFeatures) {
-			if (feat.conversionLift && daysSinceBegin >= feat.launchDay) {
-				const daysSinceLaunch = daysSinceBegin - feat.launchDay;
-				const { k, midpoint } = feat._resolvedCurve || { k: 0.08, midpoint: 30 };
-				const adoptionProb = 1 / (1 + Math.exp(-k * (daysSinceLaunch - midpoint)));
-				if (chance.bool({ likelihood: Math.min(100, adoptionProb * 100) })) {
-					adjustedConversionRate = Math.min(100, Math.max(0, Math.round(adjustedConversionRate * feat.conversionLift)));
-				}
-			}
-		}
-	}
-
 	// Determine if user converts and how many steps they'll take
 	// When experiment mode is active, $experiment_started is prepended to sequence
 	// but should not count as a funnel step for conversion purposes
 	const conversionStepCount = expName ? sequence.length - 1 : sequence.length;
-	const { doesUserConvert, numStepsUserWillTake } = determineConversion(
+	let { doesUserConvert, numStepsUserWillTake } = determineConversion(
 		adjustedConversionRate,
 		conversionStepCount,
 		chance
 	);
 
+	// ── Phase 2 identity helpers ──
+	// `firstAuthSeqIdx` is the index in `sequence` (and processedEvents) of the first
+	// step whose event config has `isAuthEvent: true`. Used both for truncating failed
+	// prior attempts (cap before auth) and for picking per-step identity stamping mode
+	// inside isFirstFunnel runs. -1 if no step in this funnel is flagged.
+	const eventsByName = (() => {
+		const map = new Map();
+		for (const e of (config.events || [])) map.set(e.event, e);
+		return map;
+	})();
+	let firstAuthSeqIdx = -1;
+	for (let i = 0; i < sequence.length; i++) {
+		const ev = eventsByName.get(sequence[i]);
+		if (ev && ev.isAuthEvent) { firstAuthSeqIdx = i; break; }
+	}
+	// When experiment mode prepends $experiment_started, the auth index in
+	// `processedEvents` is shifted right by 1.
+	const firstAuthProcessedIdx = firstAuthSeqIdx === -1
+		? -1
+		: (expName ? firstAuthSeqIdx + 1 : firstAuthSeqIdx);
+
+	// Truncated pre-auth attempt: force the user to drop somewhere strictly before the
+	// stitch. If there is no auth step in this funnel, truncation is a no-op (default
+	// flow runs). When firstAuthSeqIdx === 0 there's no pre-auth room — force 0 steps
+	// (the attempt produces nothing for that user).
+	if (attemptInfo.truncateBeforeAuth && firstAuthSeqIdx >= 0 && conversionStepCount > 0) {
+		if (firstAuthSeqIdx === 0) {
+			numStepsUserWillTake = 0;
+		} else {
+			numStepsUserWillTake = chance.integer({ min: 1, max: firstAuthSeqIdx });
+		}
+		doesUserConvert = false;
+	}
+
 	// Get steps user will actually take
 	let funnelStepsUserWillTake;
-	if (expName) {
-		// $experiment_started always fires; conversion only applies to actual funnel steps
-		funnelStepsUserWillTake = [processedEvents[0], ...processedEvents.slice(1, 1 + numStepsUserWillTake)];
+	if (attemptInfo.truncateBeforeAuth && firstAuthSeqIdx === 0) {
+		// Pre-auth truncation with the stitch at index 0 leaves no room before it → no events.
+		funnelStepsUserWillTake = [];
+	} else if (expName) {
+		// $experiment_started always fires; conversion only applies to actual funnel steps.
+		// (Pre-Phase 2 behavior: even when numStepsUserWillTake===0, $experiment_started fires.)
+		funnelStepsUserWillTake = [processedEvents[0], ...processedEvents.slice(1, 1 + Math.max(0, numStepsUserWillTake))];
 	} else {
-		funnelStepsUserWillTake = processedEvents.slice(0, numStepsUserWillTake);
+		funnelStepsUserWillTake = processedEvents.slice(0, Math.max(0, numStepsUserWillTake));
 	}
 
 	// Apply ordering strategy
@@ -187,12 +261,34 @@ export async function makeFunnel(context, funnel, user, firstEventTime, profile
 		userCampaign: featureCtx.userCampaign || null,
 		userLocation: featureCtx.userLocation || null,
 		worldEventsTimeline: featureCtx.worldEventsTimeline || context.config.worldEvents || null,
-		resolvedFeatures: featureCtx.resolvedFeatures || context.config.features || null,
-		resolvedAnomalies: featureCtx.resolvedAnomalies || context.config.anomalies || null,
 		dataQuality: featureCtx.dataQuality || context.config.dataQuality || null,
-		geo: featureCtx.geo || context.config.geo || null,
 	};
 
+	// Pre-compute per-step stamping modes for execution order. For isFirstFunnel + isBorn
+	// runs, the first event in execution order whose config has `isAuthEvent: true` is
+	// the stitch event; events before it stamp `device_only`, events after stamp
+	// `user_only`. For everything else we stamp `both` (current default identity model).
+	const stampingByIndex = new Array(funnelEventsWithTiming.length).fill('both');
+	let runAuthExecIdx = -1;
+	if (attemptInfo.isFirstFunnel && attemptInfo.isBorn) {
+		for (let i = 0; i < funnelEventsWithTiming.length; i++) {
+			const evName = funnelEventsWithTiming[i].event;
+			const cfg = eventsByName.get(evName);
+			if (cfg && cfg.isAuthEvent) { runAuthExecIdx = i; break; }
+		}
+		for (let i = 0; i < funnelEventsWithTiming.length; i++) {
+			if (runAuthExecIdx === -1) {
+				stampingByIndex[i] = 'device_only';
+			} else if (i < runAuthExecIdx) {
+				stampingByIndex[i] = 'device_only';
+			} else if (i === runAuthExecIdx) {
+				stampingByIndex[i] = 'stitch';
+			} else {
+				stampingByIndex[i] = 'user_only';
+			}
+		}
+	}
+
 	// Generate actual events with timing
 	const finalEvents = await generateFunnelEvents(
 		context,
@@ -200,15 +296,33 @@ export async function makeFunnel(context, funnel, user, firstEventTime, profile
 		distinct_id,
 		firstEventTime || dayjs(created).unix(),
 		anonymousIds,
-		sessionIds,
 		groupKeys,
-		funnelFeatureCtx
+		funnelFeatureCtx,
+		{ devicePool, stampingByIndex }
 	);
 
+	// Compute the auth-time of the actual stitch event in execution order, if any.
+	const authTimeMs = runAuthExecIdx >= 0 && finalEvents[runAuthExecIdx]
+		? Date.parse(finalEvents[runAuthExecIdx].time) || null
+		: null;
+
 	// Call post-funnel hook
-	await hook(finalEvents, "funnel-post", { user, profile, scd, funnel, config });
+	await hook(finalEvents, "funnel-post", {
+		user, profile, scd, funnel, config,
+		firstEventTime,
+		datasetStart: context.DATASET_START_SECONDS,
+		datasetEnd: context.DATASET_END_SECONDS,
+		isFirstFunnel: attemptInfo.isFirstFunnel,
+		isBorn: attemptInfo.isBorn,
+		attemptsConfig: attemptInfo.attemptsConfig,
+		attemptNumber: attemptInfo.attemptNumber,
+		totalAttempts: attemptInfo.totalAttempts,
+		isFinalAttempt: attemptInfo.isFinalAttempt,
+		persona,
+		experiment: experimentMeta,
+	});
 
-	return [finalEvents, doesUserConvert];
+	return [finalEvents, doesUserConvert, authTimeMs];
 }
 
 /**
@@ -394,14 +508,15 @@ function addTimingOffsets(events, timeToConvert, numSteps) {
 
 /**
  * Generates actual events with proper timing
- * @param {Context} context - Context object
- * @param {Array} eventsWithTiming - Events with timing information
- * @param {string} distinct_id - User ID
- * @param {number} earliestTime - Base timestamp
- * @param {Array} anonymousIds - Anonymous IDs
- * @param {Array} sessionIds - Session IDs
- * @param {Array} groupKeys - Group keys
- * @returns {Promise<Array>} Generated events
+ * @param {Context} context
+ * @param {Array} eventsWithTiming
+ * @param {string} distinct_id
+ * @param {number} earliestTime
+ * @param {Array} anonymousIds
+ * @param {Array} groupKeys
+ * @param {Object} [featureCtx] - Feature context (persona, worldEvents, dataQuality)
+ * @param {Object} [identityArgs] - Phase 2 identity args ({ stampingByIndex, devicePool })
+ * @returns {Promise<Array>}
  */
 async function generateFunnelEvents(
 	context,
@@ -409,25 +524,29 @@ async function generateFunnelEvents(
 	distinct_id,
 	earliestTime,
 	anonymousIds,
-	sessionIds,
 	groupKeys,
-	featureCtx = {}
+	featureCtx = {},
+	identityArgs = null
 ) {
 	let funnelStartTime;
+	const stampingByIndex = (identityArgs && identityArgs.stampingByIndex) || null;
+	const devicePool = (identityArgs && identityArgs.devicePool) || null;
 
 	const finalEvents = await Promise.all(eventsWithTiming.map(async (event, index) => {
+		const stamping = stampingByIndex ? stampingByIndex[index] : 'both';
+		const identityCtx = (devicePool || stamping !== 'both') ? { stamping, devicePool } : null;
 		const newEvent = await makeEvent(
 			context,
 			distinct_id,
 			earliestTime,
 			event,
 			anonymousIds,
-			sessionIds,
 			{},
 			groupKeys,
-			false,  // Let all funnel events use TimeSoup for proper time distribution
 			false,
-			featureCtx
+			false,
+			featureCtx,
+			identityCtx
 		);
 
 		if (index === 0) {
@@ -446,8 +565,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()) {