@ak--47/dungeon-master 1.8.1 → 1.8.2

package/.claude/skills/verify-dungeon/references/alignment-contract.md

@@ -1,5 +1,31 @@
 # 1.8.1 verification contract
 
+## 1.8.2 live verification update
+
+The [1.8.2 guide](../../../../docs/guides/1.8.2-upgrade-guide.md) and repository
+`tests/alignment/live/REPORT.md` extend this contract with retained live comparisons.
+The 1.8.1 audit below remains historical. It used selected source-derived contracts;
+1.8.2 also imports isolated datasets and compares native Mixpanel query results.
+Public options and defaults remain unchanged.
+
+Automatic verifier identity now derives from emitted both-ID events. Explicit
+`buildIdentityMap(profiles)` overrides retain their compatibility behavior.
+List-valued held-property expansion and supported HPC/session report combinations
+have source and live fixtures. Non-UTC/DST and custom session-exclusion variants
+still need separate verification.
+
+Import success is not query readiness. Reconcile totals and identity before
+accepting comparisons. Historical anonymous events can join later without another
+import. Every live test must use a run property and disjoint run identities.
+Retain incomplete responses and do other work before a bounded retry.
+
+Distinguish raw per-user count histograms, UTC calendar activity, and rolling
+Frequency/Addiction. The default local calendar algorithm is not a universal
+Mixpanel frequency rule. Lifetime attribution endpoints require conversion/lookback
+eligibility; conflicting values with tied timestamps are not stable across ingest.
+`minCohort` now enforces conservative independent-user lower bounds, including
+custom callbacks. Unknown evidence caps a passing verdict instead of counting rows.
+
 Use this contract when authoring, verifying, provisioning, or presenting a dungeon.
 The [1.8.1 guide](../../../../docs/guides/1.8.1-upgrade-guide.md) describes the
 release. The local repository's `tests/alignment/REPORT.md` and
@@ -17,8 +43,8 @@ a numeric property, a mean with a median, or conversion with event volume to
 rescue a failed story. Supplementary diagnostics must keep their own labels.
 
 Local checks prove selected source-derived contracts, not universal Mixpanel
-parity. The audit read analytics source without compiling or executing it. It
-did not run live differential queries. Macro/soup interactions, table surfaces,
+parity. The 1.8.1 audit read analytics source without compiling or executing it.
+That audit did not run live differential queries. Macro/soup interactions, table surfaces,
 arbitrary hooks, parallel execution, and several counting variants remain gaps.
 
 ## Separate a measured effect from enough evidence
@@ -52,8 +78,8 @@ and preserve its original failed evidence.
 - Derive sessions from the full resolved user stream before HPC partitioning.
   Local defaults are UTC, a 30-minute idle timeout, and a 24-hour maximum.
   `session_id` is a diagnostic or explicit legacy mode, not the default truth.
-  Non-UTC projects, list-valued HPC, and project-specific hidden/excluded session
-  events remain outside this proof.
+  Non-UTC projects and project-specific hidden/excluded session events remain
+  outside the live proof. List-valued HPC has 1.8.2 source and live fixtures.
 - Profile device pools alone establish no identity mapping evidence. The public
   `buildIdentityMap(profiles)` helper retains profile-based compatibility behavior.
   For emitted-identity proof, derive links from valid ordinary both-ID events,

package/.claude/skills/verify-dungeon/references/counting-semantics.md

@@ -210,9 +210,11 @@ emulateBreakdown(events, {
 });
 ```
 
-Without an explicit map, the compatibility path can call `buildIdentityMap(profiles)`
-(reads `device_ids`, then `anonymousIds`). Label that profile-derived assumption;
-it cannot prove that an identity link survived generation or ingest.
+In 1.8.2, automatic mapping uses emitted both-ID records before report filtering.
+The public `buildIdentityMap(profiles)` helper still reads profile pools when a
+caller explicitly requests that override. It cannot prove that a link survived
+generation or ingest. Imported historical identity can become query-visible later;
+verify readiness before accepting a local/live comparison.
 
 ## Time-series verification (timeBucket)
 

package/CHANGELOG.md

@@ -2,6 +2,47 @@
 
 All notable changes to `@ak--47/dungeon-master`.
 
+## 1.8.2 - 2026-09-13
+
+### Fixed
+
+- Build automatic verifier identity maps from emitted both-ID events. Profile
+  device pools no longer create links by themselves. Explicit identity maps
+  retain their existing behavior; conflicting authenticated events retain their user.
+- Pass supported held-property session funnels through the report wrapper. Keep
+  implicit one-session windows when applying matching dungeon funnel defaults.
+- Expand list-valued held properties into separate funnel histories, including
+  repeated cursor visits and full-stream session boundaries.
+- Preserve prior attribution touches across time buckets, ignore unstamped
+  touches, and retain conversions with no matching touch in the unknown segment.
+- Make `minCohort` use conservative independent-user evidence. Repeated period
+  rows cannot inflate populations, and custom assertions receive the same guard.
+- Include declared global properties on synthetic experiment exposure events,
+  so run and segment filters retain both exposures and outcomes.
+- Make funnel-frequency drop decisions independent of random insertion IDs.
+
+### Verified
+
+- Add opt-in live comparisons through the actual importer and Mixpanel query
+  layer, with run-isolated identities, import budgets, retained query payloads,
+  exact local/live comparisons, fixed seeds, and neutral controls.
+- Verify selected generated conversion, TTC, retention, volume, weight, incident,
+  frequency, aggregate, attribution, session, and Flows effects against live reports.
+- Separate ingestion readiness from import acceptance. Historical identity links
+  can become visible later; one retained fixture converged without another import.
+
+### Compatibility
+
+Public exports, signatures, options, and defaults remain unchanged. Corrected
+counts and seeded hook outcomes can differ from 1.8.1. Explicit profile-map
+overrides and totals' `reentry: false` default remain supported. Calendar-day
+activity, rolling frequency, and raw event-count histograms are separate reports.
+Finite-lookback attribution, ambiguous tied touches, non-UTC project settings,
+and arbitrary combinations remain subject to the documented limits.
+
+See the [upgrade guide](docs/guides/1.8.2-upgrade-guide.md) and the repository's
+live alignment report for measured scope. This entry does not indicate npm publication.
+
 ## 1.8.1 — 2026-09-12
 
 ### Fixed

package/HOOKS.md

@@ -1,9 +1,9 @@
 # HOOKS.md -- Hook Encyclopedia
 
-Hook reference and recipe catalog for dungeon-master. Every recipe is calibrated
-against Mixpanel's actual counting semantics (greedy single-pass funnels,
-distinct-period frequency, null-aware aggregation, capped attribution) — see
-[Section 2](#2-how-mixpanel-counts-things) before adapting any pattern.
+Hook reference and recipe catalog for dungeon-master. Recipes have different
+counting and evidence requirements. Read [Section 2](#2-how-mixpanel-counts-things)
+before adapting a pattern, then verify the exact report on the emitted dataset.
+The [1.8.2 guide](docs/guides/1.8.2-upgrade-guide.md) records live-tested scope and limits.
 
 ---
 
@@ -172,20 +172,28 @@ verification emulator (`@ak--47/dungeon-master/verify`) now matches these
 rules; old recipes that ignored them will look correct on the dataset but
 fail when verified or queried in Mixpanel.
 
-### 2.1 Frequency reports count DISTINCT PERIODS, not total events
+### 2.1 Frequency depends on the selected report
 
-Mixpanel's frequency distribution / cohort-by-event-count reports count
-**distinct time periods** (default: days) on which the user fired the
-event. Two purchases on the same day = frequency **1**, not 2.
+Three measurements require different checks:
+
+- **Raw per-user event count:** two purchases on one day count as two. Insights
+  per-user count histograms and frequency breakdowns using total event count use
+  this axis. `applyFrequencyByFrequency` scales this target count.
+- **Distinct calendar-day activity:** those purchases count as one active day.
+  `countDistinctPeriods` defaults to UTC calendar buckets (`ui-bucket`), and
+  `binBy: 'distinctDays'` uses the same rule. This default is retained for
+  compatibility; it is not a universal Mixpanel frequency-report rule.
+- **Rolling Frequency/Addiction:** an event counts when it is at least one
+  selected unit after the last counted event. Histories reset per report interval.
+  Two events around midnight can occupy two calendar days but one rolling period.
 
 Two related rules exist (v1.6 names them for what they are; the old
 `'calendar'` / `'rolling'` names remain as silent aliases, unknown names
 now throw):
 
 - **`algorithm: 'ui-bucket'`** (default in our verifier):
-  `COUNT(DISTINCT date_trunc(unit, time))` in UTC. Matches what the Mixpanel
-  UI shows and what [`injectOnNewDays`](lib/hook-helpers/inject.js) uses
-  internally.
+  `COUNT(DISTINCT date_trunc(unit, time))` in UTC. This is also what
+  [`injectOnNewDays`](lib/hook-helpers/inject.js) uses internally.
 - **`algorithm: 'mixpanel-rolling'`**: the C++
   `addiction_query.cpp` rule `qtz_time >= last_counted + seconds_for_unit`
   (`addiction_query_update_history`, `addiction_query.cpp:363-374`) — what
@@ -193,8 +201,8 @@ now throw):
   boundaries (events at 23:59 + 00:01 next day = 1 rolling period, 2
   calendar periods).
 
-Use the default (`ui-bucket`) for hooks. Use `'mixpanel-rolling'` only
-when verifying behavior that explicitly depends on the C++ implementation.
+Choose the algorithm from the requested report. Do not replace a raw-count
+histogram with active-day counts, or use calendar days to claim rolling parity.
 
 **The actual Frequency report shape** is `frequencyHistogram(events,
 { event, unit, intervalDays, profiles })` (v1.6): per report interval, a
@@ -205,19 +213,19 @@ zero bucket (`addiction_query.cpp:546-573`). Array length is
 `ceil(interval / unit)` (`unit.c:108-113`). Use it when a dungeon targets
 the Frequency report itself rather than a frequency-derived cohort.
 
-**Implication for hooks:** `scaleEventCount(record, "Buy", 3)` clones 3x as
-many Buy events at sub-second offsets — they all land on the same calendar
-day, so the user moves **zero bins** in Mixpanel's frequency report. Use
+**Implication for hooks:** `scaleEventCount(record, "Buy", 3)` targets 3x as
+many Buy events at one-second offsets. This changes raw-count histogram bins.
+It generally does not add active days or rolling periods. Use
 [`injectOnNewDays`](lib/hook-helpers/inject.js) when the goal is to move
-users between frequency bins. Both `injectOnNewDays` and the default
+users between calendar-day activity bins. Both `injectOnNewDays` and the default
 `countDistinctPeriods` algorithm use calendar-bucket math, so they agree
 at boundaries.
 
 One second is also below Mixpanel's 30-minute session gap, so the default
 spread cannot create a new session either. The full list of metrics a default
-`scaleEventCount` call **cannot** move: active days per user, DAU, stickiness
-(DAU÷MAU), sessions per user, frequency bins, and retention. It moves event
-volume, and nothing else.
+`scaleEventCount` call does not reliably move: active days per user, DAU,
+stickiness (DAU/MAU), sessions per user, rolling frequency, and retention.
+At dataset edges, clones can be clipped. Verify surviving counts separately.
 
 As of v1.6.4 you can pass `{ spreadDays: N }` to scatter the clones across the
 next N days instead:
@@ -363,7 +371,7 @@ sampling.
 
 ### 2.5 Active-day distribution is config-first
 
-Mixpanel frequency reports count distinct days (§2.1). The v1.5 engine
+Distinct-day activity is a separate measurement from raw counts (§2.1). The engine
 exposes `Dungeon.avgActiveDaysPerUser` as the canonical primitive for this
 shape. Set it at the config level and the engine concentrates each user's
 events onto a sampled subset of days drawn from `normal(mean=N, sd=N/3)`,
@@ -876,15 +884,12 @@ Reference: `flows_query.cpp:988-994` (next-anchor-only), `flows.cpp:680-717`
 
 ### New principles from the emulator alignment
 
-21. **Distinct-day vs total-event binning.** Frequency-distribution reports in
-    Mixpanel count distinct days (Section 2.1). For any hook whose verification
-    target is a frequency report, use [`binByDistinctPeriods`](lib/verify/counting.js)
-    instead of `binUsersByEventCount`. For hooks targeting raw event counts
-    (Insights `total events`, `events per user`), `binUsersByEventCount` is
-    still correct.
+21. **Match the bin to the report.** Use `binUsersByEventCount` for raw event
+  counts and `binByDistinctPeriods` for calendar-day activity. Use rolling
+  counting for the Frequency/Addiction report. Section 2.1 distinguishes them.
 
-22. **`scaleEventCount` does not move users between frequency bins.** Cloning
-    Buy events at sub-second offsets places them on the same calendar day and
+22. **`scaleEventCount` changes raw-count bins.** Cloning
+  Buy events at one-second offsets usually places them on the same calendar day and
     inside the same 30-minute session window, so distinct days, sessions, DAU,
     stickiness, and retention are all unchanged. It moves event volume only. To
     shift any of the others, pass `{ spreadDays: N }` (v1.6.4) or use
@@ -898,11 +903,10 @@ Reference: `flows_query.cpp:988-994` (next-anchor-only), `flows.cpp:680-717`
     after the prior step's timestamp (with margin > 2 seconds for the grace
     window).
 
-24. **Attribution stamping is capped at 10 touchpoints.** When biasing
-    `firstTouch` attribution by stamping touchpoint events, ≤10 touches per
-    user enter the candidate pool. Stamping 50 weighted Touch events per
-    user gives the same answer as stamping 10. Aim for sparse, distinct
-    touches with deterministic weight ratios.
+24. **Separate stamping caps from attribution reads.** The generator defaults
+  to ten stamped touches per user. Mixpanel first/last reads are uncapped
+  within their conversion-bounded lookback. Distinct touch timestamps avoid
+  ambiguous attribution when different values tie at the first or last time.
 
 25. **Null-aware aggregation removes the need to "fill" defaults.** Don't
     coalesce missing numeric properties to 0 to keep AVG sane — Mixpanel
@@ -1741,6 +1745,13 @@ touch with a seeded weighted pick (models: `firstTouch`, `lastTouch`,
 `both`). It never stamps unstamped events, so total touch count is
 unchanged.
 
+The helper selects lifetime endpoints. A report reads eligible touches before
+each conversion and inside its lookback. The lifetime-last touch can occur after
+the conversion; the lifetime-first can expire. Neither endpoint is a general
+conversion-aware guarantee. Pass a deliberately eligible stream to the existing
+helper or implement that selection in the hook, then verify the requested report.
+Conflicting sources at an equal timestamp have no stable cross-ingestion order.
+
 ---
 
 #### 4.27 Active-Day Cohort Engineering (v1.5)

package/README.md

@@ -18,6 +18,10 @@ i built this because i needed it. and after using it across hundreds of customer
 npm install @ak--47/dungeon-master
 ```
 
+1.8.2 adds live counting verification and fixes identity, session-funnel,
+attribution, and experiment-filter defects. See the
+[upgrade guide](docs/guides/1.8.2-upgrade-guide.md) for compatibility and tested limits.
+
 ## quick start
 
 ```javascript

package/docs/guides/1.8.2-upgrade-guide.md

@@ -0,0 +1,110 @@
+# 1.8.2 upgrade guide
+
+1.8.2 fixes verifier counting and experiment-filter defects found while importing
+synthetic datasets and querying them in Mixpanel. Public exports, signatures,
+options, and defaults remain unchanged. No new runtime dependency is required.
+
+After publication:
+
+```sh
+npm install @ak--47/dungeon-master@1.8.2
+```
+
+This guide describes a release candidate. A branch, PR, or passing test does not
+publish a package.
+
+## identity requires emitted evidence
+
+Automatic verification links a device only when an emitted event contains both
+`device_id` and `user_id`. A profile device pool alone cannot create a link.
+Ordinary event names work; linking is not restricted to an auth-named event.
+
+`buildIdentityMap(profiles)` remains unchanged for explicit caller overrides.
+Pass that map only when it represents trusted identity knowledge. Automatic
+mapping preserves an explicit authenticated user on a conflicting device event.
+Original-merge projects, B2B identity rules, external mapping history, and all
+ingestion validation policies are not fully emulated.
+
+Historical anonymous events may join their user after the import receipt returns.
+The live verification run observed that delay and later verified the same fixture
+without sending it again. Check event totals and identity readiness before accepting
+a funnel comparison. No sender ordering change or fixed sleep claims to solve this.
+
+## report wrappers use the supported counting code
+
+Held-property funnels now support session counting through `funnelFrequency`.
+Matching dungeon defaults no longer inject a millisecond conversion window into
+an implicit one-session report. List-valued held properties expand into per-value
+histories while preserving full-stream session boundaries.
+
+Scalar-only held-property keys retain their existing behavior. Mixed list/scalar
+keys use the source-derived string representation. Explicit list-only mode,
+extreme value formatting, and engine cardinality caps remain outside this API.
+
+Totals still defaults to `reentry: false`. Set `reentry: true` when comparing
+repeated histories with Mixpanel general totals. Session tests use UTC and the
+default thirty-minute inactivity timeout. Project exclusions and non-UTC/DST
+variants require separate proof.
+
+## passing stories need enough independent users
+
+`minCohort` no longer sums overlapping period populations or treats arbitrary rows
+as independent users. It uses a conservative lower bound and applies to custom
+callbacks too. Missing denominator evidence caps an otherwise passing result at
+`WEAK`, with an explanation. Assertions without `minCohort` retain their behavior.
+
+This can expose previously optimistic story verdicts. Inspect the selected users,
+entrants, converters, or mature retention cohorts. Do not lower the threshold just
+to restore a green verdict.
+
+## exposure events retain global filters
+
+Synthetic `$experiment_started` events now include declared `superProps`, including
+context-aware values. Experiment name and variant fields remain authoritative.
+Run-isolated experiment queries therefore retain the exposure and outcome rows.
+This can change seeded output when global property generation consumes randomness.
+Same-version deterministic runs still exclude only fresh `insert_id` values.
+
+Funnel-frequency keep/drop decisions now use stable event fields instead of random
+insertion IDs. Their outcome can change from 1.8.1 but is reproducible on rerun.
+
+## frequency and attribution have distinct contracts
+
+Raw event-count histograms, calendar-day activity, and rolling Frequency/Addiction
+reports are separate measurements. `applyFrequencyByFrequency` scales raw target
+event counts. Its existing `binBy: 'distinctDays'` default only selects the cohort
+axis; it does not make clones add new active days. Use explicit report settings.
+
+`attributedBy` now ignores null or absent touch values, retains touchless conversions
+as `unknown`, and preserves earlier touches across conversion time buckets.
+The public default still selects the first conversion per user; `perConversion:
+'all'` evaluates every conversion. The API has no finite-lookback argument.
+
+`applyAttributedBySource` retains lifetime endpoint selection. Verify that the
+selected endpoint is inside each intended conversion's lookback. Distinct touch
+timestamps are required for reproducible conflicting source order. Same-time
+ties and backend transition compression can differ from raw event-array order.
+
+## verified scope and remaining work
+
+The repository's `tests/alignment/live/REPORT.md` records source revision, run IDs,
+queries, counts, practical effects, neutral controls, and historical failures.
+The local analytics checkout supplied counting contracts; live Mixpanel queries
+tested their behavior on imported data. The C++ engine was not built locally.
+
+Evidence covers selected generated conversion, TTC, retention, volume, weights,
+incidents, raw-count frequency, numeric aggregates, attribution, sessions, and
+Flows. It does not establish every configuration cross-product, literal retention
+probability calibration, arbitrary hook behavior, warehouse deployment, or every
+project setting. Capacity and ambiguous-order limits remain explicit.
+
+Repository gates preserve data and deny network access:
+
+```sh
+node tests/alignment/run.mjs
+node tests/alignment/run.mjs --sweep --timeout-ms=600000
+```
+
+Live scripts are opt-in and require project-specific authorization and credentials.
+They are excluded from the npm package. Do not use the default pruning test setup
+while retained live datasets are still needed.

package/lib/generators/funnels.js

@@ -520,6 +520,7 @@ function buildFunnelEvents(context, sequence, chosenFunnelProps, bindPropsIndex,
 			return {
 				event: "$experiment_started",
 				properties: {
+					...config.superProps,
 					"Experiment name": experimentName,
 					"Variant name": experimentVariant
 				}

package/lib/hook-patterns/attributed-by-source.js

@@ -43,9 +43,10 @@ import { getChance } from '../utils/utils.js';
  *   last touch BEFORE THE CONVERSION EVENT (lookback bounded by the
  *   conversion timestamp — get_last_value, whoval/read.cpp:643-655). If the
  *   user has stamped touches AFTER their conversion, the touch this pattern
- *   biases is not the one the report reads. `firstTouch` (the default) has
- *   no such gap: the lifetime-first touch is exactly what FIRST reads.
- *   Conversion-aware target selection is planned for 1.6.1.
+ *   biases is not the one the report reads. `firstTouch` also requires the
+ *   lifetime-first touch to remain inside the report's lookback. Callers must
+ *   select eligible history when a conversion-bounded report is intended.
+ *   Equal-time conflicting values have no stable cross-ingestion ordering.
  * @returns {{ overwritten: number, touches: number }} `touches` = stamped
  *   events found; `overwritten` = touches whose value was replaced.
  */

package/lib/hook-patterns/funnel-frequency-breakdown.js

@@ -66,14 +66,11 @@ export function applyFunnelFrequencyBreakdown(allUserEvents, _profile, funnelEve
 	}
 	if (!stepName) return { bin, droppedFinal: false };
 
-	// Deterministic drop decision without consuming the seeded RNG stream:
-	// hash the funnel's first insert_id (fallback: time) through
-	// simpleHashFloat — FNV-1a over the full string, quantized to 1/1000 —
-	// and drop when the hash lands under (1 - keepRate). Per-funnel stable,
-	// so reruns with the same seed drop the same funnels.
 	const dropProb = 1 - keepRate;
-	const seed = funnelEvents[0] && (funnelEvents[0].insert_id || funnelEvents[0].time) || '';
-	const det = simpleHashFloat(String(seed));
+	const anchor = funnelEvents[0] || {};
+	const seed = JSON.stringify([anchor.user_id || anchor.device_id || anchor.distinct_id || '',
+		anchor.event || '', anchor.time || '', stepName]);
+	const det = simpleHashFloat(seed);
 	if (det < dropProb) {
 		const before = funnelEvents.length;
 		dropEventsWhere(funnelEvents, e => e && e.event === stepName);

package/lib/verify/counting.js

@@ -12,7 +12,7 @@
 
 import { toMs } from '../hook-helpers/_internal.js';
 import { matchesWhere } from './coerce.js';
-import { buildIdentityMap, resolveUserId } from './identity.js';
+import { buildEventIdentityMap, resolveUserId } from './identity.js';
 
 const SECONDS_PER_UNIT = {
 	hour: 3600,
@@ -27,8 +27,8 @@ const SECONDS_PER_UNIT = {
  * them for what they are:
  *
  * 1. **`'ui-bucket'`** (default): `COUNT(DISTINCT date_trunc(unit, time))`
- *    in UTC — calendar-bucket counting, the shape the Mixpanel UI presents
- *    in frequency distribution charts.
+ *    in UTC. This measures calendar activity and remains the compatibility
+ *    default; raw-count histograms and rolling frequency use other rules.
  *
  * 2. **`'mixpanel-rolling'`**: the addiction_query.cpp rule,
  *    `qtz_time >= interval->last_counted + seconds_for_unit(unit)`
@@ -39,8 +39,7 @@ const SECONDS_PER_UNIT = {
  *    calendar days.
  *
  * **The default does NOT match addiction_query.cpp's rolling rule.** It is
- * kept because it matches what users see in report buckets, and because it
- * aligns with `injectOnNewDays` (which classifies days by
+ * retained for compatibility with `injectOnNewDays` (which classifies days by
  * `Math.floor(t / DAY_MS)`); mixing the two algorithms makes the atom and
  * verifier disagree at boundaries. For the actual Frequency report output
  * shape (per-interval rolling counters + histogram), use
@@ -69,8 +68,6 @@ export function countDistinctPeriods(events, eventName, unit = 'day', options =
 	const unitMs = seconds * 1000;
 
 	if (algorithm === 'ui-bucket') {
-		// Calendar bucket — UTC floor by unit. Matches what Mixpanel's UI
-		// shows and what `injectOnNewDays` uses internally.
 		const buckets = new Set();
 		for (const t of matches) buckets.add(Math.floor(t / unitMs));
 		return buckets.size;
@@ -500,13 +497,13 @@ export function binByDistinctPeriods(events, eventName, bins, unit = 'day', opti
  * @param {string} [options.event] - Event name to count. Required at runtime — throws if missing.
  * @param {('hour'|'day'|'week')} [options.unit='day'] - Rolling unit.
  * @param {number} [options.intervalDays] - Report interval length in days (positive integer). Required at runtime.
- * @param {Object[]} [options.profiles] - Profiles for device→user identity resolution.
+ * @param {Object[]} [options.profiles] - Accepted for compatibility; identity uses emitted both-ID events.
  * @returns {Array<{ interval: string, histogram: number[] }>} One row per
  *   interval (label = ISO date of the interval start); `histogram[i]` =
  *   number of users with rolling count `i + 1` in that interval.
  */
 export function frequencyHistogram(events, options = {}) {
-	const { event, unit = 'day', intervalDays, profiles } = options;
+	const { event, unit = 'day', intervalDays } = options;
 	if (typeof event !== 'string' || !event) {
 		throw new Error('frequencyHistogram: event is required');
 	}
@@ -517,7 +514,7 @@ export function frequencyHistogram(events, options = {}) {
 	}
 	if (!Array.isArray(events) || !events.length) return [];
 
-	const identityMap = profiles ? buildIdentityMap(profiles) : undefined;
+	const identityMap = buildEventIdentityMap(events);
 	let minMs = Infinity, maxMs = -Infinity;
 	const matches = [];
 	for (const e of events) {

package/lib/verify/emulate-breakdown.js

@@ -23,7 +23,7 @@
 
 import { toMs } from '../hook-helpers/_internal.js';
 import { evaluateFunnel, evaluateFunnelHPC, evaluateAnyOrderCompletion } from './funnel-engine.js';
-import { buildIdentityMap, resolveUserId } from './identity.js';
+import { buildEventIdentityMap, resolveUserId } from './identity.js';
 import { coerceToBreakdownKey, breakdownSegmentKey, matchesWhere } from './coerce.js';
 import { filterFirstTimeEver } from './first-time.js';
 import { sessionize } from './sessionize.js';
@@ -277,18 +277,7 @@ export function emulateBreakdown(events, config) {
 	if (!Array.isArray(events)) throw new Error('emulateBreakdown: events must be an array');
 	if (!config || !config.type) throw new Error('emulateBreakdown: config.type is required');
 
-	// Auto-build identity map ONCE when profiles supplied. Threads through every
-	// breakdown type AND every time-bucket recursive call so pre-auth (device_id
-	// only) events resolve to the same canonical user as post-auth (user_id)
-	// events. Hoisted above the timeBucket dispatch to avoid rebuilding the
-	// map per-bucket on large datasets.
-	const identityMap = config.identityMap
-		|| (Array.isArray(config.profiles)
-			&& config.profiles.some(p =>
-				p && ((Array.isArray(p.device_ids) && p.device_ids.length)
-					|| (Array.isArray(p.anonymousIds) && p.anonymousIds.length)))
-			? buildIdentityMap(config.profiles)
-			: undefined);
+	const identityMap = config.identityMap || buildEventIdentityMap(events);
 
 	// v1.5: time-bucketed wrapper. Partition events by UTC bucket, run the
 	// underlying breakdown per partition, tag rows with `period`.
@@ -318,12 +307,35 @@ export function emulateBreakdown(events, config) {
 			throw new Error('emulateBreakdown: type "topPaths" does not compose with timeBucket — flows aggregate one path universe over the range');
 		}
 		const range = config.timeBucketRange || {};
-		const buckets = partitionByTimeBucket(events, config.timeBucket, range);
+		const bucketEvents = config.type === 'attributedBy'
+			? events.filter(event => event && event.event === config.conversionEvent)
+			: events;
+		const buckets = partitionByTimeBucket(bucketEvents, config.timeBucket, range);
 		// Pass the pre-built identityMap into recursive calls so the auto-build
 		// branch above is a no-op per bucket (would otherwise rebuild N times).
 		const inner = { ...config, timeBucket: undefined, timeBucketRange: undefined, identityMap };
 		const out = [];
 
+		if (config.type === 'attributedBy') {
+			attributedBy([], {
+				conversionEvent: config.conversionEvent,
+				attributionEvent: config.attributionEvent,
+				attributionProperty: config.attributionProperty,
+				model: config.model,
+				perConversion: config.perConversion,
+				identityMap,
+			});
+			for (const { period } of buckets) {
+				const rows = attributedBy(events, /** @type {*} */ (inner), bucketBoundsMs(period, config.timeBucket));
+				if (rows.length) {
+					for (const row of rows) out.push({ period, ...row });
+				} else {
+					out.push({ period, _empty: true });
+				}
+			}
+			return out;
+		}
+
 		// v1.6.0 (P1.6.5): step-0-anchored trend types. Mixpanel evaluates each
 		// trend interval as "step 0 in [start, stop); steps 1+ in
 		// [start, stop + conversion window)" (funnel_query.cpp:1398-1401), and
@@ -483,13 +495,6 @@ function funnelFrequency(events, { steps, breakdownByFrequencyOf, conversionWind
 	if ((isTotalsMode || holdPropertyConstant) && !isSequentialOrder) {
 		throw new Error(`funnelFrequency: countMode '${countMode}' / holdPropertyConstant require a sequential funnel order (got '${funnelOrder}')`);
 	}
-	// HPC buckets events by property value BEFORE evaluation (evaluateFunnelHPC),
-	// but Mixpanel derives session boundaries from the user's FULL event stream —
-	// sessionizing each bucket independently would merge across the gaps left by
-	// removed events and produce wrong ordinals. Refuse rather than mis-count.
-	if (holdPropertyConstant && (countMode === 'sessions' || conversionWindow)) {
-		throw new Error('funnelFrequency: holdPropertyConstant cannot combine with session-count conversion windows — session boundaries derive from the full event stream, but HPC evaluates per-property-value event subsets');
-	}
 
 	const userEvents = groupByUser(events, identityMap);
 	const result = [];
@@ -787,29 +792,43 @@ function attributedBy(events, {
 	model = 'firstTouch',
 	perConversion = 'first',
 	identityMap,
-}) {
+}, conversionRange = null) {
 	if (!conversionEvent || !attributionEvent || !attributionProperty) {
 		throw new Error('attributedBy requires conversionEvent, attributionEvent, attributionProperty');
 	}
 	if (perConversion !== 'first' && perConversion !== 'all') {
 		throw new Error(`attributedBy: unknown perConversion "${perConversion}" — use 'first' or 'all'`);
 	}
+	// Attribution is unbounded over supplied history; this API has no finite
+	// lookback. The private bucket interval limits conversions, never touches.
+	// Backend transitions also compress case-insensitive equal values within
+	// 30 minutes (value/transitions.cpp, whoval/util.cpp). This raw-value model
+	// does not emulate that compression, which can retain earlier string casing.
 	const userEvents = groupByUser(events, identityMap);
 	const counts = new Map();
 	for (const [, evs] of userEvents) {
 		const sorted = sortByTime(evs);
+		const inRange = sorted.filter(event => {
+			if (!event || event.event !== conversionEvent) return false;
+			const time = toMs(event.time);
+			return !conversionRange || (time >= conversionRange.startMs && time < conversionRange.endMs);
+		});
 		const conversions = perConversion === 'all'
-			? sorted.filter(e => e && e.event === conversionEvent)
-			: sorted.filter(e => e && e.event === conversionEvent).slice(0, 1);
+			? inRange
+			: inRange.slice(0, 1);
 		for (const conversion of conversions) {
 			const conversionTime = toMs(conversion.time);
-			const allTouches = sorted.filter(e =>
-				e && e.event === attributionEvent && toMs(e.time) <= conversionTime
+			// attribution.py's defined-property filter excludes null and undefined;
+			// whoval/read.cpp first/last include the conversion timestamp.
+			const allTouches = sorted.filter(event =>
+				event && event.event === attributionEvent && event[attributionProperty] != null
+					&& toMs(event.time) <= conversionTime
 			);
-			if (!allTouches.length) continue;
 			const touch = model === 'lastTouch' ? allTouches[allTouches.length - 1] : allTouches[0];
-			const v = touch[attributionProperty] ?? 'unknown';
-			counts.set(v, (counts.get(v) || 0) + 1);
+			// Backend missing attribution is undefined. Preserve this API's existing
+			// 'unknown' label, not coerceToBreakdownKey's general 'undefined' label.
+			const value = touch?.[attributionProperty] ?? 'unknown';
+			counts.set(value, (counts.get(value) || 0) + 1);
 		}
 	}
 	return [...counts.entries()].map(([source, count]) => ({

package/lib/verify/funnel-engine.js

@@ -187,7 +187,7 @@
 
 import { toMs } from '../hook-helpers/_internal.js';
 import { sessionOrdinals } from './sessionize.js';
-import { matchesWhere } from './coerce.js';
+import { coerceToBreakdownKey, matchesWhere } from './coerce.js';
 
 const OUT_OF_ORDER_MS = 2000;
 const DAY_MS = 86400 * 1000;
@@ -1016,13 +1016,21 @@ function evaluateFunnelWithContext(events, steps, options, fullStreamOrdinals) {
  * group and drop off in another simultaneously). Session windows derive
  * ordinals from the full user stream before routing events to HPC buckets.
  *
- * Reference: `funnel_query.cpp` lines 749-784 (`aggregate_hash_get_key_cursor`).
+ * Analytics 717286d2: backend/arb/reader/queries/funnel_query.cpp:749
+ * processes each key from backend/libquery/aggregate.cpp:36,113. Ordinary
+ * HPC expands lists one level and accepts scalars. Both use value_to_string
+ * (backend/libquery/value/value.c:184), not typed breakdown/filter equality.
+ * Empty lists emit no visits; null/missing items use the "undefined" label.
+ * Duplicate labels share a history but retain cursor visits, which can
+ * advance repeated steps (funnel_query.cpp:1257; funnels/history.cpp:387).
  *
- * **Limitation (v1.5.0):** scalar HPC values only. Mixpanel's
- * `aggregate_hash_get_key_cursor` iterates *each value* of a list-valued
- * property, exploding into N sub-funnels per event. List-valued HPC keys are
- * not supported here — events with non-scalar `holdProperty` values will
- * stringify and bucket incorrectly.
+ * Compatibility: all-scalar streams retain raw keys and omit null/missing
+ * values. List-bearing streams use string labels for all routed values.
+ * This property-name API does not expose the separate explicit-list mode,
+ * which rejects non-lists (aggregate.cpp:126). Events and their copy-data
+ * properties remain unchanged; only the routing key is normalized.
+ * The shared label helper does not reproduce ARB's numeric %.16g fallback,
+ * structured-value serialization/truncation, or aggregate cardinality cap.
  *
  * @param {Array<Object>} events
  * @param {FunnelStep[]} steps
@@ -1044,6 +1052,11 @@ export function evaluateFunnelHPC(events, steps, holdProperty, options = {}) {
 	const fullStreamOrdinals = options.countMode === 'sessions' || options.conversionWindow?.unit === 'sessions'
 		? sessionOrdinals((events || []).filter(ev => ev && typeof ev.event === 'string'))
 		: undefined;
+	const hasListValues = (events || []).some(ev => ev && typeof ev.event === 'string' && Array.isArray(ev[holdProperty]));
+	const heldValues = (value) => {
+		if (!hasListValues) return value == null ? [] : [value];
+		return (Array.isArray(value) ? value : [value]).map(coerceToBreakdownKey);
+	};
 
 	// Bucket events by HPC value. The step-0 events define the universe of
 	// HPC values for this user; later events only populate buckets whose
@@ -1053,18 +1066,18 @@ export function evaluateFunnelHPC(events, steps, holdProperty, options = {}) {
 		if (!ev || typeof ev.event !== 'string') continue;
 		// Step-0 events seed the bucket on their own value.
 		if (ev.event === step0Name) {
-			const v = ev[holdProperty];
-			if (v === undefined || v === null) continue;
-			if (!valueBuckets.has(v)) valueBuckets.set(v, []);
-			valueBuckets.get(v).push(ev);
+			for (const value of heldValues(ev[holdProperty])) {
+				if (!valueBuckets.has(value)) valueBuckets.set(value, []);
+				valueBuckets.get(value).push(ev);
+			}
 		}
 	}
 	// Now route every event with a known HPC value into its bucket.
 	for (const ev of events || []) {
 		if (!ev || typeof ev.event !== 'string' || ev.event === step0Name) continue;
-		const v = ev[holdProperty];
-		if (v === undefined || v === null) continue;
-		if (valueBuckets.has(v)) valueBuckets.get(v).push(ev);
+		for (const value of heldValues(ev[holdProperty])) {
+			if (valueBuckets.has(value)) valueBuckets.get(value).push(ev);
+		}
 	}
 
 	const out = new Map();

package/lib/verify/identity.js

@@ -1,15 +1,13 @@
 /**
- * Identity resolution for verifier — builds a device→user map from profiles
- * and resolves a canonical user id per event. Mirrors Mixpanel's ID merge
- * semantics: pre-auth events stamped with `device_id` and post-auth events
- * stamped with `user_id` belong to the same canonical identity.
+ * Identity resolution for verifier. Automatic links come from emitted
+ * both-ID events; profile pools are only an explicit caller override.
  *
- * Reference: `mixpanel/analytics` — identity merge / profiles `device_ids`
- * inversion. We invert each profile's `device_ids` array into a flat
- * `Map<device_id, canonical_user_id>` so query-time event grouping resolves
- * pre-auth touches alongside post-auth events.
+ * Reference: analytics identity-manager v3 lookup_and_update_handler.go
+ * and identity/device_and_user_records.go at 717286d2d3ed03e9e3f9cb4346e4c6b2e561fb9a.
  */
 
+const emittedIdentityMap = Symbol('emittedIdentityMap');
+
 /**
  * Build a `Map<device_id, canonical_user_id>` by inverting each profile's
  * device-pool array. Reads `device_ids` first, falling back to the legacy
@@ -41,12 +39,36 @@ export function buildIdentityMap(profiles) {
 	return map;
 }
 
+/**
+ * Build automatic device-to-user links from the full emitted stream.
+ * Event names do not gate linking. The first valid pair for a device wins;
+ * v3 does not reassign an already-linked device to a conflicting user.
+ * User IDs with the reserved $device: prefix cannot establish a link.
+ *
+ * @param {Array<Object>} events
+ * @returns {Map<string, string>}
+ */
+export function buildEventIdentityMap(events) {
+	const map = new Map();
+	Object.defineProperty(map, emittedIdentityMap, { value: true });
+	if (!Array.isArray(events)) return map;
+	for (const event of events) {
+		const deviceId = event?.device_id;
+		const userId = event?.user_id;
+		if (typeof deviceId !== 'string' || !deviceId.trim()
+			|| typeof userId !== 'string' || !userId.trim()
+			|| userId.startsWith('$device:') || map.has(deviceId)) continue;
+		map.set(deviceId, userId);
+	}
+	return map;
+}
+
 /**
  * Resolve the canonical user id for an event. Lookup order:
  *   1. `event.distinct_id` — Mixpanel's canonical post-merge identifier. When
  *      a downstream pipeline has already stitched the cluster, this is the
  *      ground truth; never override it.
- *   2. `identityMap.get(event.device_id)` — device→user merge from profile inversion.
+ *   2. `identityMap.get(event.device_id)` — emitted link or explicit override.
  *   3. `event.user_id` — already authed (pre-merge analog of distinct_id).
  *   4. `event.device_id` — anonymous fallback.
  *
@@ -70,6 +92,7 @@ export function buildIdentityMap(profiles) {
 export function resolveUserId(event, identityMap) {
 	if (!event) return undefined;
 	if (event.distinct_id) return event.distinct_id;
+	if (event.user_id && identityMap && Object.getOwnPropertyDescriptor(identityMap, emittedIdentityMap)) return event.user_id;
 	if (identityMap && event.device_id) {
 		const merged = identityMap.get(event.device_id);
 		if (merged) return merged;

package/lib/verify/story-runner.js

@@ -20,9 +20,9 @@
  * neutral. For 'between' the wanted side is where the band's midpoint sits
  * relative to the neutral point.
  *
- * Cohort size per named selection: sum of `user_count` over the selected rows
- * when any row carries one, else the row count. The SMALLEST selection is
- * compared against `minCohort`.
+ * Cohort evidence per selection is an independent-user lower bound: sum only
+ * proven disjoint bins within a period, then take the largest period. Other
+ * user counts use the largest row. Missing evidence caps passes at WEAK.
  */
 
 import { emulateBreakdown } from './emulate-breakdown.js';
@@ -166,11 +166,59 @@ function resolveRef(ref, selected) {
 	return sum;
 }
 
-function cohortOf(rows) {
-	if (rows.some(r => typeof r.user_count === 'number')) {
-		return rows.reduce((s, r) => s + (typeof r.user_count === 'number' ? r.user_count : 0), 0);
+function cohortOf(rows, breakdown, sourceRows) {
+	if (!Array.isArray(rows)) return null;
+	let evidenceRows = (rows || []).filter(row => row && !row._empty);
+	if (!evidenceRows.length) return null;
+	const isCount = value => Number.isSafeInteger(value) && value >= 0;
+	const hasPeriod = row => typeof row.period === 'string' && row.period.length > 0;
+	let column = 'user_count';
+	let binColumns = [];
+	if (breakdown.type === 'funnelFrequency') {
+		if (breakdown.countMode !== undefined && breakdown.countMode !== 'uniques') return null;
+		const periodRequired = breakdown.timeBucket !== undefined || evidenceRows.some(row => row.period !== undefined);
+		if (evidenceRows.some(row => !isCount(row.step_index) || !isCount(row.breakdown_freq)
+			|| (periodRequired && !hasPeriod(row)))) return null;
+		const binKey = row => JSON.stringify([row.period, row.breakdown_freq]);
+		const selectedBins = new Set(evidenceRows.map(binKey));
+		evidenceRows = (sourceRows || []).filter(row => row && !row._empty && row.step_index === 0
+			&& isCount(row.breakdown_freq) && (row.period === undefined || hasPeriod(row))
+			&& selectedBins.has(binKey(row)));
+		if (new Set(evidenceRows.map(binKey)).size !== selectedBins.size) return null;
+		column = 'conversions';
+		binColumns = ['breakdown_freq'];
+	} else if (breakdown.type === 'eventBreakdown') {
+		column = 'total_users';
+	} else if (breakdown.type === 'uniques') {
+		if (breakdown.countType !== undefined && breakdown.countType !== 'unique') return null;
+		column = 'uniques';
+	} else if (breakdown.type === 'retention') {
+		column = 'cohort_size';
+	} else if (breakdown.type === 'frequencyByFrequency') {
+		binColumns = ['metric_freq', 'breakdown_freq'];
+	} else if (breakdown.type === 'aggregatePerUser') {
+		binColumns = ['breakdown_freq'];
 	}
-	return rows.length;
+	if (evidenceRows.some(row => !isCount(row[column]))) return null;
+	const largestRow = evidenceRows.reduce((largest, row) => Math.max(largest, row[column]), 0);
+	const periodRequired = breakdown.timeBucket !== undefined || evidenceRows.some(row => row.period !== undefined);
+	if (!binColumns.length || evidenceRows.some(row => binColumns.some(bin => !isCount(row[bin]))
+		|| (periodRequired && !hasPeriod(row)))) return largestRow;
+	const periods = new Map();
+	for (const row of evidenceRows) {
+		if (!periods.has(row.period)) periods.set(row.period, new Map());
+		const bins = periods.get(row.period);
+		const key = JSON.stringify(binColumns.map(bin => row[bin]));
+		bins.set(key, Math.max(bins.get(key) || 0, row[column]));
+	}
+	let largestPeriod = 0;
+	for (const bins of periods.values()) {
+		let total = 0;
+		for (const count of bins.values()) total += count;
+		if (!Number.isSafeInteger(total)) return largestRow;
+		largestPeriod = Math.max(largestPeriod, total);
+	}
+	return largestPeriod;
 }
 
 // ── verdicts ────────────────────────────────────────────────────────────────
@@ -243,40 +291,55 @@ const fmt = (n) => (typeof n === 'number' && Number.isFinite(n)) ? (Math.abs(n)
  */
 export function evaluateAssertion(rows, assertion, ctx) {
 	try {
+		const minCohort = assertion.minCohort;
+		let result, selected, cohorts;
 		if (typeof assertion.assert === 'function') {
+			if (typeof minCohort === 'number') {
+				selected = assertion.select === undefined ? { all: rows } : selectRows(rows, assertion.select);
+				cohorts = Object.values(selected).map(selection => cohortOf(selection, assertion.breakdown, rows));
+			}
 			/** @type {{ pass?: boolean, detail?: string, verdict?: import('../../types').StoryVerdict }} */
 			const res = assertion.assert(rows, ctx) || {};
 			if (res.verdict && VERDICT_RANK[res.verdict] !== undefined) {
-				return { verdict: res.verdict, observed: null, detail: res.detail || 'custom assert' };
+				result = { verdict: res.verdict, observed: null, detail: res.detail || 'custom assert' };
+			} else {
+				result = res.pass
+					? { verdict: 'STRONG', observed: null, detail: res.detail || 'custom assert passed' }
+					: { verdict: 'NONE', observed: null, detail: res.detail || 'custom assert failed' };
 			}
-			return res.pass
-				? { verdict: 'STRONG', observed: null, detail: res.detail || 'custom assert passed' }
-				: { verdict: 'NONE', observed: null, detail: res.detail || 'custom assert failed' };
-		}
-		const parsed = parseMetric(assertion.expect.metric);
-		const selected = selectRows(rows, assertion.select);
-		const left = resolveRef(parsed.left, selected);
-		let observed, neutral;
-		if (parsed.kind === 'single') {
-			observed = left; neutral = null;
 		} else {
-			const right = resolveRef(parsed.right, selected);
-			if (parsed.kind === 'ratio') {
-				if (right === 0) throw new Error('ratio denominator is 0');
-				observed = left / right; neutral = 1;
+			const parsed = parseMetric(assertion.expect.metric);
+			selected = selectRows(rows, assertion.select);
+			const left = resolveRef(parsed.left, selected);
+			let observed, neutral;
+			if (parsed.kind === 'single') {
+				observed = left; neutral = null;
 			} else {
-				observed = left - right; neutral = 0;
+				const right = resolveRef(parsed.right, selected);
+				if (parsed.kind === 'ratio') {
+					if (right === 0) throw new Error('ratio denominator is 0');
+					observed = left / right; neutral = 1;
+				} else {
+					observed = left - right; neutral = 0;
+				}
 			}
+			const { verdict, detail } = verdictFor(observed, assertion.expect, neutral);
+			result = { verdict, observed, detail };
 		}
-		let { verdict, detail } = verdictFor(observed, assertion.expect, neutral);
-		if (typeof assertion.minCohort === 'number' && VERDICT_RANK[verdict] > VERDICT_RANK.WEAK) {
-			const smallest = Math.min(...Object.values(selected).map(cohortOf));
-			if (smallest < assertion.minCohort) {
-				verdict = 'WEAK';
-				detail += ` — capped: smallest cohort ${smallest} < minCohort ${assertion.minCohort}`;
+		if (typeof minCohort === 'number' && VERDICT_RANK[result.verdict] > VERDICT_RANK.WEAK) {
+			cohorts ??= Object.values(selected).map(selection => cohortOf(selection, assertion.breakdown, rows));
+			if (!cohorts.length || cohorts.some(cohort => cohort === null)) {
+				result.verdict = 'WEAK';
+				result.detail += ` - capped: insufficient evidence for minCohort ${minCohort}; independent-user denominator unavailable`;
+			} else {
+				const smallest = Math.min(...cohorts);
+				if (smallest < minCohort) {
+					result.verdict = 'WEAK';
+					result.detail += ` - capped: insufficient evidence; smallest independent-user lower bound ${smallest} < minCohort ${minCohort}`;
+				}
 			}
 		}
-		return { verdict, observed, detail };
+		return result;
 	} catch (err) {
 		return { verdict: 'NONE', observed: null, detail: `error: ${err.message}` };
 	}

package/lib/verify/verify-dungeon.js

@@ -21,6 +21,7 @@
 
 import DUNGEON_MASTER from '../../index.js';
 import { emulateBreakdown } from './emulate-breakdown.js';
+import { buildEventIdentityMap } from './identity.js';
 import { validateSchema } from './schema-validator.js';
 
 /**
@@ -83,7 +84,7 @@ export function applyFunnelDefaults(breakdownArgs, funnels, profiles) {
 			// is the author choosing a window — injecting conversionWindowMs on top
 			// would trip evaluateFunnel's mutual-exclusion throw. Only inject when
 			// NEITHER window form is present.
-			if (args.conversionWindowMs === undefined && args.conversionWindow === undefined && Number.isFinite(matched.conversionWindowDays)) {
+			if (args.countMode !== 'sessions' && args.conversionWindowMs === undefined && args.conversionWindow === undefined && Number.isFinite(matched.conversionWindowDays)) {
 				args.conversionWindowMs = matched.conversionWindowDays * 86400000;
 			}
 			if (args.funnelOrder === undefined && matched.order) {
@@ -137,6 +138,7 @@ export async function verifyDungeon(config, checks, overrides) {
 	}
 	const events = Array.isArray(result.eventData) ? result.eventData : Array.from(result.eventData);
 	const profiles = Array.isArray(result.userProfilesData) ? result.userProfilesData : Array.from(result.userProfilesData);
+	const identityMap = buildEventIdentityMap(events);
 	// v1.6.2: schema-check against the config the run actually used. `config` may be a
 	// PATH STRING (no fields at all → every property reads as unexpected), and even for
 	// an object input a v1.5.1 dungeon keeps `hasAndroidDevices` / `hasBrowser` under
@@ -155,6 +157,7 @@ export async function verifyDungeon(config, checks, overrides) {
 	for (const check of checks) {
 		try {
 			const breakdownArgs = applyFunnelDefaults(check.breakdown, validatedFunnels, profiles);
+			if (breakdownArgs.identityMap === undefined) breakdownArgs.identityMap = identityMap;
 			const rows = emulateBreakdown(events, breakdownArgs);
 			const verdict = check.assert(rows, ctx);
 			results.push({ name: check.name, pass: !!verdict.pass, detail: verdict.detail, rows });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ak--47/dungeon-master",
-	"version": "1.8.1",
+	"version": "1.8.2",
 	"description": "generate fancy datasets",
 	"type": "module",
 	"main": "index.js",

package/scripts/verify-stories.mjs

@@ -38,8 +38,8 @@ import { parse as parseCsv } from 'csv-parse';
 import generate from '../index.js';
 import { extractComments } from '../lib/core/extract-comments.js';
 import { validateDungeonConfig } from '../lib/core/config-validator.js';
+import { buildEventIdentityMap } from '../lib/verify/identity.js';
 import {
-	buildIdentityMap,
 	VERDICT_RANK,
 	validateStories,
 	validateSchema,
@@ -149,7 +149,7 @@ if (inMemory) {
 		? await evaluateStories(stories, events, {
 			profiles,
 			funnels: Array.isArray(validated.funnels) ? validated.funnels : [],
-			identityMap: buildIdentityMap(profiles),
+			identityMap: buildEventIdentityMap(events),
 			warehouseRows,
 			warehouseSpecs,
 			datasetStart: validated.datasetStart,
@@ -187,7 +187,7 @@ if (inMemory) {
 	// here and use the RETURN value — as of v1.6.2 validateDungeonConfig does not
 	// enrich the object you hand it.
 	const validated = validateDungeonConfig({ ...config, token: '' });
-	const identityMap = buildIdentityMap(profiles);
+	const identityMap = buildEventIdentityMap(events);
 	schemaPass = !!validateSchema(events, validated)?.pass;
 	const warehouseSpecs = Object.fromEntries((validated.warehouseMetrics || []).map((spec) => [spec.name, spec]));
 	const warehouseManifest = loadWarehouseManifest(prefixPath);