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

package/lib/core/config-validator.js

@@ -30,7 +30,7 @@ import { resolveMacro } from "../templates/macro-presets.js";
  * @param {number} [userNumDays]
  * @returns {{ datasetStartUnix: number, datasetEndUnix: number, numDays: number }}
  */
-function resolveDatasetWindow(datasetStart, datasetEnd, userNumDays) {
+function resolveDatasetWindow(datasetStart, datasetEnd, userNumDays, verbose = false) {
 	const hasStart = datasetStart !== undefined && datasetStart !== null;
 	const hasEnd = datasetEnd !== undefined && datasetEnd !== null;
 
@@ -48,7 +48,7 @@ function resolveDatasetWindow(datasetStart, datasetEnd, userNumDays) {
 			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) {
+		if (verbose && userNumDays !== undefined && userNumDays !== null && userNumDays !== derivedNumDays) {
 			console.warn(
 				`⚠️  datasetStart/datasetEnd take precedence; user-supplied numDays=${userNumDays} ignored, derived numDays=${derivedNumDays}.`
 			);
@@ -60,7 +60,7 @@ function resolveDatasetWindow(datasetStart, datasetEnd, userNumDays) {
 	const fallbackNumDays = (typeof userNumDays === 'number' && userNumDays > 0) ? userNumDays : 30;
 	const todayStart = dayjs().startOf('day').unix();
 	const fallbackStart = todayStart - fallbackNumDays * 86400;
-	console.warn(
+	if (verbose) 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 };
@@ -145,6 +145,106 @@ function inferFunnels(events) {
 	return createdFunnels;
 }
 
+/**
+ * Config keys removed from the engine in 1.4. Silently stripped by
+ * `validateDungeonConfig` with a single warning per dungeon. To recreate any of these
+ * patterns, use hooks (see `lib/hook-patterns/*`).
+ */
+const KILLED_CONFIG_KEYS = ['subscription', 'attribution', 'geo', 'features', 'anomalies'];
+
+/**
+ * Strip killed config keys in place, log one deprecation warning per dungeon.
+ * @param {Partial<Dungeon>} config
+ */
+function stripKilledConfigKeys(config) {
+	const found = KILLED_CONFIG_KEYS.filter(k => config[k] !== undefined && config[k] !== null);
+	if (!found.length) return;
+	for (const k of found) delete config[k];
+	if (config.verbose) {
+		console.warn(
+			`⚠️  dungeon-master 1.4 removed engine support for: ${found.join(', ')}. ` +
+			`These config keys are silently ignored. Recreate via hooks (see lib/hook-patterns/* once Phase 4 lands).`
+		);
+	}
+}
+
+/**
+ * Validate `Funnel.attempts` config in place. Coerces missing/invalid bounds so callers
+ * downstream don't have to re-defend. Throws on logically invalid configs (max < min).
+ * @param {import('../../types.js').Funnel[]} funnels
+ */
+function validateAttempts(funnels) {
+	for (const f of funnels) {
+		if (!f || !f.attempts) continue;
+		const a = f.attempts;
+		const min = Number.isFinite(a.min) ? Math.max(0, Math.floor(a.min)) : 0;
+		const max = Number.isFinite(a.max) ? Math.max(0, Math.floor(a.max)) : min;
+		if (max < min) {
+			throw new Error(`Funnel "${f.name || f.sequence?.join(' > ')}" attempts.max (${a.max}) must be >= attempts.min (${a.min})`);
+		}
+		a.min = min;
+		a.max = max;
+		if (a.conversionRate !== undefined) {
+			if (!Number.isFinite(a.conversionRate)) {
+				throw new Error(`Funnel "${f.name || f.sequence?.join(' > ')}" attempts.conversionRate must be a finite number 0-100`);
+			}
+			a.conversionRate = Math.max(0, Math.min(100, a.conversionRate));
+		}
+	}
+}
+
+/**
+ * Normalize `Funnel.experiment` in place. `true` → default 3-variant config.
+ * Object → validated and resolved. Stores `funnel._experiment` for downstream.
+ * @param {import('../../types.js').Funnel[]} funnels
+ * @param {number} datasetEndUnix
+ */
+function normalizeExperiments(funnels, datasetEndUnix) {
+	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 },
+	];
+	for (const f of funnels) {
+		if (!f || !f.experiment) continue;
+		const raw = f.experiment === true ? {} : f.experiment;
+		const name = raw.name || (f.name ? f.name + ' Experiment' : 'Unnamed Experiment');
+		const variants = (raw.variants && raw.variants.length)
+			? raw.variants.map(v => ({
+				name: v.name || 'Unnamed Variant',
+				conversionMultiplier: Number.isFinite(v.conversionMultiplier) ? Math.max(0.01, v.conversionMultiplier) : 1.0,
+				ttcMultiplier: Number.isFinite(v.ttcMultiplier) ? Math.max(0.01, v.ttcMultiplier) : 1.0,
+				weight: Number.isFinite(v.weight) && v.weight > 0 ? v.weight : 1,
+			}))
+			: DEFAULT_VARIANTS;
+		const startDays = Number.isFinite(raw.startDaysBeforeEnd) && raw.startDaysBeforeEnd > 0
+			? raw.startDaysBeforeEnd : 0;
+		const startUnix = startDays > 0 ? datasetEndUnix - startDays * 86400 : null;
+		f._experiment = { name, variants, startUnix };
+	}
+}
+
+/**
+ * Resolve `avgDevicePerUser` per Section 3.3 rules. Returns the integer device count
+ * the engine should use (0 = no device_id stamping at all, 1+ = pool size).
+ *
+ * @param {Partial<Dungeon>} config
+ * @returns {number}
+ */
+function resolveDevicesPerUser(config) {
+	const raw = config.avgDevicePerUser;
+	const hasAnon = config.hasAnonIds === true;
+	if (raw === undefined || raw === null) {
+		return hasAnon ? 1 : 0;
+	}
+	if (!Number.isFinite(raw)) {
+		return hasAnon ? 1 : 0;
+	}
+	const n = Math.round(raw);
+	if (n <= 0) return hasAnon ? 1 : 0;
+	return n;
+}
+
 /**
  * Validates and enriches a dungeon configuration object
  * @param {Partial<Dungeon>} config - Raw configuration object
@@ -153,6 +253,9 @@ function inferFunnels(events) {
 export function validateDungeonConfig(config) {
 	const chance = u.getChance();
 
+	// Phase 1 — strip killed config keys before anything else reads them.
+	stripKilledConfigKeys(config);
+
 	// Transform SCD props to regular props if credentials are missing
 	// This MUST happen BEFORE we extract values from the config
 	transformSCDPropsWithoutCredentials(config);
@@ -243,7 +346,7 @@ export function validateDungeonConfig(config) {
 	// ── 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 windowResolution = resolveDatasetWindow(config.datasetStart, config.datasetEnd, config.numDays, verbose);
 	const datasetStartUnix = windowResolution.datasetStartUnix;
 	const datasetEndUnix = windowResolution.datasetEndUnix;
 	numDays = windowResolution.numDays;
@@ -275,7 +378,7 @@ export function validateDungeonConfig(config) {
 	// only avgEventsPerUserPerDay would never trigger auto-batch.
 	if (numEvents >= 2_000_000 && config.batchSize === undefined) {
 		batchSize = 1_000_000;
-		console.warn(`⚠️  Auto-enabling batch mode: numEvents (${numEvents.toLocaleString()}) >= 2M. Using batchSize of ${batchSize.toLocaleString()}.`);
+		if (verbose) console.warn(`⚠️  Auto-enabling batch mode: numEvents (${numEvents.toLocaleString()}) >= 2M. Using batchSize of ${batchSize.toLocaleString()}.`);
 	}
 
 	// Resolve soup presets (intra-week / intra-day shape — must happen after numDays is computed)
@@ -319,7 +422,7 @@ export function validateDungeonConfig(config) {
 				throw new Error('Hook string did not evaluate to a function');
 			}
 		} catch (error) {
-			if (config.verbose !== false) {
+			if (verbose) {
 				console.warn(`\u26a0\ufe0f Failed to convert hook string to function: ${error.message}`);
 				console.warn('Using default pass-through hook');
 			}
@@ -329,7 +432,7 @@ export function validateDungeonConfig(config) {
 
 	// Ensure hook is a function
 	if (typeof hook !== 'function') {
-		if (config.verbose !== false) console.warn('\u26a0\ufe0f Hook is not a function, using default pass-through hook');
+		if (verbose) console.warn('\u26a0\ufe0f Hook is not a function, using default pass-through hook');
 		hook = (record) => record;
 	}
 
@@ -436,35 +539,31 @@ export function validateDungeonConfig(config) {
 		dataQuality = validateDataQuality(dataQuality);
 	}
 
-	// Feature 5: Subscription
-	let subscription = config.subscription || null;
-	if (subscription) {
-		subscription = validateSubscription(subscription);
-	}
+	// Phase 1: validate Funnel.attempts on every funnel (additive — most have none).
+	validateAttempts(funnels);
 
-	// Feature 6: Attribution
-	let attribution = config.attribution || null;
-	if (attribution) {
-		attribution = validateAttribution(attribution, numDays);
-	}
+	// Normalize experiment configs: true → default 3-variant, object → validated.
+	normalizeExperiments(funnels, datasetEndUnix);
 
-	// Feature 7: Geo
-	let geo = config.geo || null;
-	if (geo) {
-		geo = validateGeo(geo);
-	}
+	// Phase 1: resolve multi-device config. `avgDevicePerUser` is the canonical knob;
+	// `hasAnonIds: true` aliases to 1. Default 0 = no device_id stamping (legacy).
+	const avgDevicePerUser = resolveDevicesPerUser(config);
+	// Keep hasAnonIds in sync — downstream code (utils.generateUser) still reads it.
+	// Setting it true here when avgDevicePerUser >= 1 lets the legacy device-pool
+	// generation in `person()` continue to allocate `anonymousIds[]` for the user.
+	const hasAnonIdsResolved = avgDevicePerUser >= 1;
 
-	// Feature 8: Features (progressive adoption)
-	let features = config.features || null;
-	if (features) {
-		features = resolveFeatures(features, numDays);
+	// Warn if isAuthEvent is set but avgDevicePerUser=0 — pre-auth device_only
+	// stamping degrades to user_id via the floor guard, defeating the identity model.
+	if (verbose && avgDevicePerUser === 0 && validatedEvents.some(e => e.isAuthEvent)) {
+		console.warn(
+			`⚠️  isAuthEvent requires avgDevicePerUser >= 1 to produce pre-auth anonymous events. ` +
+			`Set avgDevicePerUser or hasAnonIds: true.`
+		);
 	}
 
-	// Feature 9: Anomalies
-	let anomalies = config.anomalies || null;
-	if (anomalies) {
-		anomalies = resolveAnomalies(anomalies, datasetStartUnix);
-	}
+	// Precompute whether any event has isAttributionEvent for UTM stamping logic.
+	const hasAttributionFlags = validatedEvents.some(e => e.isAttributionEvent);
 
 	// Build final config object
 	const validatedConfig = {
@@ -489,7 +588,8 @@ export function validateDungeonConfig(config) {
 		groupKeys,
 		groupProps,
 		lookupTables,
-		hasAnonIds,
+		hasAnonIds: hasAnonIdsResolved,
+		avgDevicePerUser,
 		hasSessionIds,
 		sessionTimeout: (typeof sessionTimeout === 'number' && sessionTimeout > 0) ? sessionTimeout : 30,
 		format,
@@ -501,6 +601,7 @@ export function validateDungeonConfig(config) {
 		hook,
 		hasAdSpend,
 		hasCampaigns,
+		hasAttributionFlags,
 		hasLocation,
 		hasAvatar,
 		isAnonymous,
@@ -515,16 +616,17 @@ export function validateDungeonConfig(config) {
 		bornRecentBias,
 		percentUsersBornInDataset,
 		preExistingSpread,
-		// Advanced features
+		// Advanced features (kept after 1.4)
 		personas,
 		worldEvents,
 		engagementDecay,
 		dataQuality,
-		subscription,
-		attribution,
-		geo,
-		features,
-		anomalies
+		// Killed in 1.4 — set to null so hooks/external code that reads these get a falsy value.
+		subscription: null,
+		attribution: null,
+		geo: null,
+		features: null,
+		anomalies: null
 	};
 
 	return validatedConfig;
@@ -689,131 +791,8 @@ function validateDataQuality(dq) {
 	return dq;
 }
 
-/**
- * Validates subscription config
- * @param {import('../../types').Subscription} sub
- * @returns {import('../../types').Subscription}
- */
-function validateSubscription(sub) {
-	if (!sub.plans || !Array.isArray(sub.plans) || sub.plans.length === 0) {
-		throw new Error('subscription.plans must be a non-empty array');
-	}
-	const hasDefault = sub.plans.some(p => p.default);
-	if (!hasDefault) sub.plans[0].default = true;
-	if (!sub.lifecycle) sub.lifecycle = {};
-	const lc = sub.lifecycle;
-	if (lc.trialToPayRate === undefined) lc.trialToPayRate = 0.3;
-	if (lc.upgradeRate === undefined) lc.upgradeRate = 0.1;
-	if (lc.downgradeRate === undefined) lc.downgradeRate = 0.03;
-	if (lc.churnRate === undefined) lc.churnRate = 0.05;
-	if (lc.winBackRate === undefined) lc.winBackRate = 0.1;
-	if (lc.winBackDelay === undefined) lc.winBackDelay = 30;
-	if (lc.paymentFailureRate === undefined) lc.paymentFailureRate = 0.02;
-	if (!sub.events) sub.events = {};
-	const ev = sub.events;
-	if (!ev.trialStarted) ev.trialStarted = "trial started";
-	if (!ev.subscribed) ev.subscribed = "subscription started";
-	if (!ev.upgraded) ev.upgraded = "plan upgraded";
-	if (!ev.downgraded) ev.downgraded = "plan downgraded";
-	if (!ev.renewed) ev.renewed = "subscription renewed";
-	if (!ev.cancelled) ev.cancelled = "subscription cancelled";
-	if (!ev.paymentFailed) ev.paymentFailed = "payment failed";
-	if (!ev.wonBack) ev.wonBack = "subscription reactivated";
-	return sub;
-}
-
-/**
- * Validates attribution config
- * @param {import('../../types').Attribution} attr
- * @param {number} numDays
- * @returns {import('../../types').Attribution}
- */
-function validateAttribution(attr, numDays) {
-	if (!attr.campaigns || !Array.isArray(attr.campaigns)) {
-		throw new Error('attribution.campaigns must be an array');
-	}
-	if (attr.model === undefined) attr.model = "last_touch";
-	if (attr.window === undefined) attr.window = 7;
-	if (attr.organicRate === undefined) attr.organicRate = 0.4;
-	for (const c of attr.campaigns) {
-		if (!c.name) throw new Error('Each attribution campaign must have a name');
-		if (!c.source) throw new Error(`Attribution campaign "${c.name}" must have a source`);
-		if (!c.activeDays) throw new Error(`Attribution campaign "${c.name}" must have activeDays [start, end]`);
-		if (!c.dailyBudget) c.dailyBudget = [50, 200];
-		if (c.acquisitionRate === undefined) c.acquisitionRate = 0.02;
-	}
-	return attr;
-}
-
-/**
- * Validates geo config
- * @param {import('../../types').GeoConfig} geo
- * @returns {import('../../types').GeoConfig}
- */
-function validateGeo(geo) {
-	if (geo.sticky === undefined) geo.sticky = false;
-	if (geo.regions && !Array.isArray(geo.regions)) throw new Error('geo.regions must be an array');
-	if (geo.regionalLaunches && !Array.isArray(geo.regionalLaunches)) throw new Error('geo.regionalLaunches must be an array');
-	return geo;
-}
-
-/**
- * Resolves feature configs with logistic curve parameters
- * @param {import('../../types').FeatureConfig[]} features
- * @param {number} numDays
- * @returns {import('../../types').FeatureConfig[]}
- */
-function resolveFeatures(features, numDays) {
-	if (!Array.isArray(features) || features.length === 0) return null;
-	const curvePresets = {
-		fast: { k: 0.3, midpoint: 7 },
-		slow: { k: 0.08, midpoint: 30 },
-		instant: { k: 10, midpoint: 0 }
-	};
-	return features.map(f => {
-		if (!f.name) throw new Error('Each feature must have a name');
-		if (f.launchDay === undefined) throw new Error(`Feature "${f.name}" must have a launchDay`);
-		if (!f.property) throw new Error(`Feature "${f.name}" must have a property`);
-		if (!f.values || !Array.isArray(f.values) || f.values.length === 0) {
-			throw new Error(`Feature "${f.name}" must have a non-empty values array`);
-		}
-		if (!f.affectsEvents) f.affectsEvents = "*";
-		if (!f.adoptionCurve) f.adoptionCurve = "slow";
-		if (typeof f.adoptionCurve === 'string') {
-			f._resolvedCurve = curvePresets[f.adoptionCurve] || curvePresets.slow;
-		} else {
-			f._resolvedCurve = f.adoptionCurve;
-		}
-		// Pre-compute adopted values to avoid array allocation in hot loop
-		f._adoptedValues = f.values.length > 1 ? f.values.slice(1) : f.values;
-		return f;
-	});
-}
-
-/**
- * Resolves anomaly configs with absolute timestamps
- * @param {import('../../types').AnomalyConfig[]} anomalies
- * @param {number} beginUnix - Dataset start (unix seconds)
- * @returns {import('../../types').AnomalyConfig[]}
- */
-function resolveAnomalies(anomalies, beginUnix) {
-	if (!Array.isArray(anomalies) || anomalies.length === 0) return null;
-	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');
-		const resolved = { ...a };
-		if (a.day !== undefined) {
-			resolved._startUnix = beginUnix + (a.day * 86400);
-			if (a.duration) {
-				resolved._endUnix = resolved._startUnix + (a.duration * 86400);
-			} else if (a.window) {
-				resolved._endUnix = resolved._startUnix + (a.window * 86400);
-			} else {
-				resolved._endUnix = resolved._startUnix + 86400; // default 1 day
-			}
-		}
-		return resolved;
-	});
-}
+// validateSubscription / validateAttribution / validateGeo / resolveFeatures /
+// resolveAnomalies were removed in 1.4 along with their respective config keys.
+// `stripKilledConfigKeys` deletes the inputs before they reach the validator body.
 
 export { inferFunnels, transformSCDPropsWithoutCredentials };

package/lib/core/storage.js

@@ -50,6 +50,7 @@ export async function createHookArray(arr = [], opts) {
 	let writeDir;
 	let isBatchMode = runtime.isBatchMode || false;
 	let isWriting = false; // Prevent concurrent writes
+	const writtenFiles = [];
 
 	// Determine write directory
 	const dataFolder = path.resolve("./data");
@@ -175,6 +176,7 @@ export async function createHookArray(arr = [], opts) {
 
 				// Write to disk/cloud - always blocking to prevent OOM
 				const writeResult = await FILE_CONN(() => writeToDisk(dataToWrite, { writePath }));
+				writtenFiles.push(writePath);
 				return writeResult;
 			} finally {
 				isWriting = false; // Release the lock
@@ -231,6 +233,7 @@ export async function createHookArray(arr = [], opts) {
 				const dataToWrite = [...arr];
 				arr.length = 0; // Clear array after copying data
 				await FILE_CONN(() => writeToDisk(dataToWrite, { writePath }));
+				writtenFiles.push(writePath);
 				// Data now lives on disk, not in arr — mirror what transformThenPush
 				// does when crossing BATCH_SIZE so the Mixpanel sender knows to read
 				// from disk instead of from the (now empty) in-memory array.
@@ -249,6 +252,7 @@ export async function createHookArray(arr = [], opts) {
 	enrichedArray.flush = flush;
 	enrichedArray.getWriteDir = getWriteDir;
 	enrichedArray.getWritePath = getWritePath;
+	enrichedArray.getWrittenFiles = () => [...writtenFiles];
 
 	// Add additional properties from rest
 	for (const key in rest) {
@@ -384,7 +388,7 @@ export class StorageManager {
 			const batchSize = config.batchSize || 1_000_000;
 			const numEvents = config.numEvents || 0;
 
-			if (batchSize < numEvents) {
+			if (batchSize < numEvents && config.verbose) {
 				console.warn(
 					`⚠️  writeToDisk is false but batchSize (${batchSize.toLocaleString()}) < numEvents (${numEvents.toLocaleString()}). ` +
 					`Batch files will be written to disk temporarily to avoid OOM. ` +

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
@@ -110,19 +120,32 @@ export async function makeEvent(
         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;
     }
@@ -165,36 +188,13 @@ 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. 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.
+    // 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) {
+    if (worldEventsTimeline && eventTemplate.time) {
         eventUnix = dayjs(eventTemplate.time).unix();
     }
 
@@ -222,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
@@ -287,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;