diff --git a/experiments/README.md b/experiments/README.md
new file mode 100644
index 0000000..f56e504
--- /dev/null
+++ b/experiments/README.md
@@ -0,0 +1,23 @@
+# Experiments
+
+This directory is the checked-in record of performance and representation experiments.
+It exists so the repo keeps the paper trail next to the code instead of scattering
+methods, results, and conclusions across chat logs or temporary files.
+
+Each study keeps the same minimum set of material:
+
+- a study-level README that explains the problem, the decision rule, and the current status
+- a protocol document that explains how to rerun the study deterministically
+- one subdirectory per approach or control condition
+- machine-readable artifacts under each approach's `artifacts/` directory
+- plain-English notes that explain the hypothesis, method, observations, and conclusion
+
+The current study is [event-shape-study/README.md](event-shape-study/README.md).
+
+Use these rules when adding new work here:
+
+1. Record the question before collecting new data.
+2. Keep the collection commands deterministic and write them down.
+3. Store raw machine-readable artifacts before writing summaries.
+4. Separate observations from conclusions so later readers can challenge the interpretation.
+5. Leave enough context that another maintainer could rerun the same study without guessing.
\ No newline at end of file
diff --git a/experiments/event-shape-study/methods.md b/experiments/event-shape-study/methods.md
new file mode 100644
index 0000000..3b4ab46
--- /dev/null
+++ b/experiments/event-shape-study/methods.md
@@ -0,0 +1,143 @@
+# Event Shape Methods
+
+This study keeps each candidate self-contained so the code under test does not move around
+between runs. Every approach directory can include its own `code/` snapshot, its own
+artifacts, and its own notes. That keeps the benchmark input, the benchmark harness, and
+the parser code aligned with the exact candidate being measured.
+
+## What gets measured
+
+Each recorded report captures two things:
+
+- timing samples from the approach-local `event_shape_bench.ts`
+- retained-memory samples from the approach-local `event_shape_memory.ts`
+
+Both commands run in fresh processes. The report preserves the raw samples so later
+bootstrap analysis does not need to reconstruct data from summary text.
+
+## Snapshot-local recording
+
+Record one approach with the study-local recorder:
+
+```bash
+mise x deno@latest -- deno run --allow-run=mise,git --allow-read --allow-write \
+  --no-lock \
+  experiments/event-shape-study/tools/record_approach_artifacts.ts \
+  --approach-dir=current-baseline \
+  --variant=current-baseline \
+  --runs=10 \
+  --memory-repeats=5
+```
+
+That command writes `artifacts/report.json`, `artifacts/recording.json`, and
+`artifacts/commands.txt` inside the approach directory.
+
+The lower-level collector still exists when you only want a report file:
+
+```bash
+mise x deno@latest -- deno run --allow-run=mise,git --allow-read --allow-write \
+  --no-lock \
+  experiments/event-shape-study/tools/collect_approach_report.ts \
+  --approach-dir=current-baseline \
+  --variant=current-baseline \
+  --runs=10 \
+  --memory-repeats=5 \
+  --out=experiments/event-shape-study/current-baseline/artifacts/report.json
+```
+
+Record and compare a candidate against the baseline:
+
+```bash
+mise x deno@latest -- deno run --allow-run=mise,git --allow-read --allow-write \
+  --no-lock \
+  experiments/event-shape-study/tools/record_approach_artifacts.ts \
+  --approach-dir=planned-flat-eager-event-shape \
+  --variant=planned-flat-eager-event-shape \
+  --runs=10 \
+  --memory-repeats=5 \
+  --baseline-report=experiments/event-shape-study/current-baseline/artifacts/report.json
+```
+
+The recorder writes `comparison.json` and `comparison.txt` automatically when a baseline
+report is supplied.
+
+You can still run the comparator directly when you want to inspect two existing reports:
+
+```bash
+mise x deno@latest -- deno run --allow-read \
+  --no-lock \
+  experiments/event-shape-study/tools/compare_reports.ts \
+  experiments/event-shape-study/current-baseline/artifacts/report.json \
+  experiments/event-shape-study/planned-flat-eager-event-shape/artifacts/report.json
+```
+
+## Deterministic cross-candidate run
+
+The study also records an explicit round-robin schedule so baseline and candidate reports
+are collected in a fixed order with the exact commands written to disk.
+
+```bash
+mise x deno@latest -- deno run --allow-run=mise,git --allow-read --allow-write \
+  --no-lock \
+  experiments/event-shape-study/tools/run_cross_candidate_schedule.ts \
+  --baseline=current-baseline \
+  --approaches=current-baseline,planned-flat-eager-event-shape \
+  --rounds=1 \
+  --runs=10 \
+  --memory-repeats=5 \
+  --run-label=2026-05-16-baseline-vs-flat-eager-round-robin-01
+```
+
+That command writes:
+
+- `cross-candidate-runs/<label>/schedule.json` with the fixed order and artifact paths
+- `cross-candidate-runs/<label>/commands.txt` with the exact commands used
+- per-round reports under `cross-candidate-runs/<label>/reports/`
+- baseline-versus-candidate comparisons under `cross-candidate-runs/<label>/comparisons/`
+
+## Large-input stress runs
+
+The standard ledger is good for significance testing, but it does not represent the kind of
+large-input stress you called out, such as hundreds of MiB or about `1 GiB` of source text.
+Those runs live in a separate stress-report path so they do not distort the standard report
+budget or the acceptance gate.
+
+The checked-in archive currently keeps one cheaper large-input smoke artifact per approach at
+`16 MiB` under `artifacts/stress-mixed-16MiB.json`. That gives every candidate one comparable
+large-string result in-repo while leaving `1 GiB` collection as an explicit heavyweight follow-up.
+
+Collect a `1 GiB` mixed-article stress report for one approach:
+
+```bash
+mise x deno@latest -- deno run --no-lock --allow-read --allow-write --allow-sys \
+  --v8-flags=--expose-gc \
+  experiments/event-shape-study/tools/collect_large_input_stress_report.ts \
+  --approach-dir=current-baseline \
+  --variant=current-baseline \
+  --scenario=mixed-article \
+  --size-mib=1024 \
+  --repeats=3 \
+  --out=experiments/event-shape-study/current-baseline/artifacts/stress-mixed-1GiB.json
+```
+
+Available scenarios are:
+
+- `plain-paragraphs` for low token density and long prose
+- `mixed-article` for a more realistic mix of headings, links, templates, tables, and refs
+- `pathological-recovery` for malformed input that stays in recovery-heavy paths
+
+These reports are for scale behavior and survivability. The current acceptance rule still
+comes from the standard smaller-input study ledger.
+
+## Decision rule
+
+The acceptance rule stays the same across all approaches:
+
+1. The target timing median must improve by at least `+5%`.
+2. Critical timing cases must not regress by more than `-3%`.
+3. Memory should not regress overall.
+4. Significance uses bootstrap confidence intervals, bootstrap p-values, and Holm adjustment at $\alpha = 0.05$.
+
+The study records rejected candidates on purpose. A rejected approach still matters if it
+shows which object-layout ideas help only a little, help only memory, or hurt the parser in
+ways that microbenchmarks alone would miss.
\ No newline at end of file
diff --git a/experiments/event-shape-study/protocol.md b/experiments/event-shape-study/protocol.md
new file mode 100644
index 0000000..b9220cb
--- /dev/null
+++ b/experiments/event-shape-study/protocol.md
@@ -0,0 +1,140 @@
+# Event Shape Protocol
+
+## Problem
+
+The parser emits a large number of event objects. That makes event shape a real cost
+center for both CPU time and memory retention. Small local wins can be noise, and some
+object-shape changes improve one path while hurting the actual parse workflows that users
+care about. This protocol exists so each candidate is tested the same way.
+
+## Goals
+
+- measure event-representation candidates against the same baseline
+- preserve raw samples, not just summaries
+- keep the collection process deterministic and easy to rerun
+- reject candidates that help microbenchmarks but hurt parse or session workflows
+- keep the notes approachable enough that maintainers can challenge the result later
+
+## Non-goals
+
+- this is not a claim that the current benchmark set is the final word on all workloads
+- this study does not try to prove cross-machine absolute speed claims
+- this protocol does not replace broader parser correctness testing
+
+## Constraints
+
+- the parser contract cannot change: event nesting, UTF-16 offsets, determinism, and never-throw behavior must stay intact
+- the repo currently runs Deno through `mise x deno@latest -- ...` in this container
+- timing and retained-memory data must be stored inside the repo once a run is part of the study record
+
+## Method
+
+The study now keeps the code under test inside each approach directory. That makes the
+measured parser, the benchmark harness, and the retained-memory harness travel together as a
+single snapshot.
+
+```text
+approach-local code snapshot
+  -> collect_approach_report.ts
+  -> artifacts/report.json
+  -> compare_reports.ts
+  -> artifacts/comparison.json
+  -> human notes in the approach README
+
+optional round-robin schedule
+  -> run_cross_candidate_schedule.ts
+  -> cross-candidate-runs/<label>/...
+```
+
+`collect_approach_report.ts` runs the approach-local benchmark and retained-memory harness in
+fresh processes and preserves the raw samples in JSON. `compare_reports.ts` then compares
+baseline and candidate reports with bootstrap confidence intervals, bootstrap p-values, and
+Holm adjustment.
+
+## Deterministic workflow
+
+Record one approach with the study-local recorder:
+
+```bash
+mise x deno@latest -- deno run --allow-run=mise,git --allow-read --allow-write \
+  --no-lock \
+  experiments/event-shape-study/tools/record_approach_artifacts.ts \
+  --approach-dir=current-baseline \
+  --variant=current-baseline \
+  --runs=10 \
+  --memory-repeats=5
+```
+
+The recorder writes the report plus recording metadata and exact commands into the
+approach's `artifacts/` directory.
+
+If you only need the raw report file, use the study-local collector:
+
+```bash
+mise x deno@latest -- deno run --allow-run=mise,git --allow-read --allow-write \
+  --no-lock \
+  experiments/event-shape-study/tools/collect_approach_report.ts \
+  --approach-dir=current-baseline \
+  --variant=current-baseline \
+  --runs=10 \
+  --memory-repeats=5 \
+  --out=experiments/event-shape-study/current-baseline/artifacts/report.json
+```
+
+Record a candidate against the baseline:
+
+```bash
+mise x deno@latest -- deno run --allow-run=mise,git --allow-read --allow-write \
+  --no-lock \
+  experiments/event-shape-study/tools/record_approach_artifacts.ts \
+  --approach-dir=planned-flat-eager-event-shape \
+  --variant=planned-flat-eager-event-shape \
+  --runs=10 \
+  --memory-repeats=5 \
+  --baseline-report=experiments/event-shape-study/current-baseline/artifacts/report.json
+```
+
+Generate a deterministic baseline-then-candidate schedule:
+
+```bash
+mise x deno@latest -- deno run --allow-run=mise,git --allow-read --allow-write \
+  --no-lock \
+  experiments/event-shape-study/tools/run_cross_candidate_schedule.ts \
+  --baseline=current-baseline \
+  --approaches=current-baseline,planned-flat-eager-event-shape \
+  --rounds=1 \
+  --runs=10 \
+  --memory-repeats=5 \
+  --run-label=2026-05-16-baseline-vs-flat-eager-round-robin-01
+```
+
+The study-local tools write the collector output into the approach directory and, for the
+round-robin workflow, store the exact commands and ordering under the run label.
+
+## Statistical rule
+
+The acceptance rule is deliberately strict:
+
+1. The median across the target timing cases must improve by at least 5%.
+2. No critical timing case may regress by more than 3% with Holm-adjusted significance.
+3. Memory should not regress overall.
+4. The repo only keeps a candidate change if the approach clears that bar.
+
+This is a study of practical wins, not a search for tiny directional changes.
+
+## Notes discipline
+
+Each approach README should separate these parts clearly:
+
+- hypothesis: what should change and why
+- methodology: what was run and what was held constant
+- observations: what the artifacts show, without spinning the result
+- conclusion: keep, reject, or continue
+- code under test: the touched files or planned files
+
+## Current limitations
+
+The current workflow is deterministic and machine-readable, but it still has two limits.
+It does not yet replicate runs across multiple host machines, and it does not yet bundle an
+external archival package such as a DOI-ready release artifact. Those are follow-up steps if
+the study grows into an external paper.
\ No newline at end of file
diff --git a/experiments/event-shape-study/tools/collect_approach_report.ts b/experiments/event-shape-study/tools/collect_approach_report.ts
new file mode 100644
index 0000000..852b677
--- /dev/null
+++ b/experiments/event-shape-study/tools/collect_approach_report.ts
@@ -0,0 +1,410 @@
+/**
+ * Collect one event-shape report from an approach-local code snapshot.
+ */
+
+import { dirname, fromFileUrl, join, relative } from 'jsr:@std/path';
+
+type NumericSummary = {
+	samples: number[];
+	mean: number;
+	median: number;
+	minimum: number;
+	maximum: number;
+	stdev: number;
+};
+
+type TimingRun = {
+	index: number;
+	benchmarks: Record<string, number>;
+};
+
+type MemoryRun = {
+	index: number;
+	inputs: Record<string, Record<string, number>>;
+};
+
+type EnvironmentMetadata = {
+	uname: string;
+	deno_version: string;
+	lscpu_summary: Record<string, string>;
+	git_worktree_clean: boolean;
+};
+
+type DesignMetadata = {
+	timing_command: string;
+	memory_command: string;
+	approach_dir: string;
+	code_dir: string;
+	independent_process_per_run: true;
+	raw_samples_preserved: true;
+	bootstrap_ready: true;
+	notes: string[];
+};
+
+type EventShapeReport = {
+	schema_version: 1;
+	variant: string;
+	branch: string;
+	commit: string;
+	generated_at: string;
+	runs: number;
+	memory_repeats: number;
+	timing_unit: 'microseconds_per_iter';
+	memory_unit: 'bytes';
+	environment: EnvironmentMetadata;
+	design: DesignMetadata;
+	timing: {
+		per_run: TimingRun[];
+		summary: Record<string, NumericSummary>;
+	};
+	memory: {
+		per_run: MemoryRun[];
+		summary: Record<string, Record<string, NumericSummary>>;
+	};
+};
+
+const STUDY_ROOT = fromFileUrl(new URL('../', import.meta.url));
+const REPO_ROOT = fromFileUrl(new URL('../../../', import.meta.url));
+
+function resolveOutputPath(raw_path: string): string {
+	return raw_path.startsWith('/') ? raw_path : join(REPO_ROOT, raw_path);
+}
+
+function getFlag(name: string): string | undefined {
+	return Deno.args.find((arg) => arg.startsWith(`--${name}=`))?.slice(name.length + 3);
+}
+
+function requireFlag(name: string): string {
+	const value = getFlag(name);
+	if (value === undefined || value.length === 0) {
+		throw new Error(`missing required --${name}=... flag`);
+	}
+	return value;
+}
+
+function parsePositiveIntFlag(name: string, fallback: number): number {
+	const raw = getFlag(name);
+
+	if (raw === undefined) {
+		return fallback;
+	}
+
+	const value = Number(raw);
+	if (!Number.isInteger(value) || value <= 0) {
+		throw new Error(`expected --${name} to be a positive integer, got: ${raw}`);
+	}
+
+	return value;
+}
+
+function stripAnsi(value: string): string {
+	return value.replace(/\x1B\[[0-9;]*[A-Za-z]/g, '');
+}
+
+function toMicroseconds(value: number, unit: string): number {
+	switch (unit) {
+		case 'ns':
+			return value / 1000;
+		case 'µs':
+			return value;
+		case 'ms':
+			return value * 1000;
+		case 's':
+			return value * 1000 * 1000;
+		default:
+			throw new Error(`unsupported timing unit: ${unit}`);
+	}
+}
+
+function parseTimingOutput(output: string): Record<string, number> {
+	const benchmarks: Record<string, number> = {};
+	const pattern = /^(?<name>.+?)\s{2,}(?<avg>[0-9]+(?:\.[0-9]+)?)\s*(?<unit>ns|µs|ms|s)\/iter\b/u;
+
+	for (const line of stripAnsi(output).split('\n')) {
+		const match = pattern.exec(line.trimEnd());
+		if (match?.groups === undefined) {
+			continue;
+		}
+
+		benchmarks[match.groups.name] = toMicroseconds(
+			Number(match.groups.avg),
+			match.groups.unit,
+		);
+	}
+
+	if (Object.keys(benchmarks).length === 0) {
+		throw new Error('failed to parse any timing benchmarks from local event_shape_bench.ts output');
+	}
+
+	return benchmarks;
+}
+
+function parseMemoryOutput(output: string): Record<string, Record<string, number>> {
+	const parsed = JSON.parse(output) as {
+		inputs: Array<{
+			name: string;
+			cases: Array<{
+				name: string;
+				median_bytes: number;
+			}>;
+		}>;
+	};
+
+	const inputs: Record<string, Record<string, number>> = {};
+
+	for (const input of parsed.inputs) {
+		inputs[input.name] = {};
+
+		for (const case_result of input.cases) {
+			inputs[input.name]![case_result.name] = case_result.median_bytes;
+		}
+	}
+
+	return inputs;
+}
+
+function mean(values: readonly number[]): number {
+	return values.reduce((total, value) => total + value, 0) / values.length;
+}
+
+function median(values: readonly number[]): number {
+	const sorted = [...values].sort((left, right) => left - right);
+	const middle = Math.floor(sorted.length / 2);
+
+	if (sorted.length % 2 === 0) {
+		return (sorted[middle - 1]! + sorted[middle]!) / 2;
+	}
+
+	return sorted[middle]!;
+}
+
+function stdev(values: readonly number[]): number {
+	if (values.length === 1) {
+		return 0;
+	}
+
+	const avg = mean(values);
+	const variance = values.reduce((total, value) => {
+		const delta = value - avg;
+		return total + delta * delta;
+	}, 0) / (values.length - 1);
+
+	return Math.sqrt(variance);
+}
+
+function summarizeSamples(samples: readonly number[]): NumericSummary {
+	return {
+		samples: [...samples],
+		mean: mean(samples),
+		median: median(samples),
+		minimum: Math.min(...samples),
+		maximum: Math.max(...samples),
+		stdev: stdev(samples),
+	};
+}
+
+async function runCommand(cwd: string, args: string[]): Promise<string> {
+	const command = new Deno.Command('mise', {
+		args,
+		cwd,
+		stdout: 'piped',
+		stderr: 'piped',
+		env: {
+			NODE_DISABLE_COLORS: '1',
+		},
+	});
+	const output = await command.output();
+	const stdout = new TextDecoder().decode(output.stdout);
+	const stderr = new TextDecoder().decode(output.stderr);
+
+	if (!output.success) {
+		throw new Error(`command failed: mise ${args.join(' ')}\n${stdout}\n${stderr}`);
+	}
+
+	return stdout;
+}
+
+async function readGitValue(args: string[]): Promise<string> {
+	return stripAnsi(await runCommand(REPO_ROOT, args)).trim();
+}
+
+function summarizeLscpu(output: string): Record<string, string> {
+	const interesting_keys = new Set([
+		'Architecture',
+		'CPU(s)',
+		'Core(s) per socket',
+		'Thread(s) per core',
+		'Socket(s)',
+		'Vendor ID',
+		'Model name',
+		'CPU max MHz',
+		'CPU(s) scaling MHz',
+	]);
+	const summary: Record<string, string> = {};
+
+	for (const line of stripAnsi(output).split('\n')) {
+		const separator = line.indexOf(':');
+		if (separator === -1) {
+			continue;
+		}
+
+		const key = line.slice(0, separator).trim();
+		if (!interesting_keys.has(key)) {
+			continue;
+		}
+
+		summary[key] = line.slice(separator + 1).trim();
+	}
+
+	return summary;
+}
+
+function summarizeTimingRuns(runs: readonly TimingRun[]): Record<string, NumericSummary> {
+	const by_name = new Map<string, number[]>();
+
+	for (const run of runs) {
+		for (const [name, value] of Object.entries(run.benchmarks)) {
+			const samples = by_name.get(name) ?? [];
+			samples.push(value);
+			by_name.set(name, samples);
+		}
+	}
+
+	return Object.fromEntries(
+		Array.from(by_name.entries()).map(([name, samples]) => [name, summarizeSamples(samples)]),
+	);
+}
+
+function summarizeMemoryRuns(runs: readonly MemoryRun[]): Record<string, Record<string, NumericSummary>> {
+	const by_input = new Map<string, Map<string, number[]>>();
+
+	for (const run of runs) {
+		for (const [input_name, cases] of Object.entries(run.inputs)) {
+			const input_map = by_input.get(input_name) ?? new Map<string, number[]>();
+
+			for (const [case_name, value] of Object.entries(cases)) {
+				const samples = input_map.get(case_name) ?? [];
+				samples.push(value);
+				input_map.set(case_name, samples);
+			}
+
+			by_input.set(input_name, input_map);
+		}
+	}
+
+	return Object.fromEntries(
+		Array.from(by_input.entries()).map(([input_name, case_map]) => [
+			input_name,
+			Object.fromEntries(
+				Array.from(case_map.entries()).map(([case_name, samples]) => [case_name, summarizeSamples(samples)]),
+			),
+		]),
+	);
+}
+
+const approach_dir_flag = requireFlag('approach-dir');
+const approach_dir = join(STUDY_ROOT, approach_dir_flag);
+const code_dir = join(approach_dir, 'code');
+const runs = parsePositiveIntFlag('runs', 10);
+const memory_repeats = parsePositiveIntFlag('memory-repeats', 5);
+const variant = getFlag('variant') ?? approach_dir_flag.split('/').at(-1)!;
+const out_raw = getFlag('out');
+const out_path = out_raw === undefined ? undefined : resolveOutputPath(out_raw);
+
+const timing_runs: TimingRun[] = [];
+const memory_runs: MemoryRun[] = [];
+
+const timing_command = 'mise x deno@latest -- deno bench --no-lock --allow-sys --allow-env=NODE_DISABLE_COLORS --v8-flags=--expose-gc event_shape_bench.ts';
+const memory_command = `mise x deno@latest -- deno run --no-lock --allow-sys --v8-flags=--expose-gc event_shape_memory.ts --repeats=${memory_repeats} --format=json`;
+
+const environment: EnvironmentMetadata = {
+	uname: await readGitValue(['x', 'deno@latest', '--', 'uname', '-srvmo']),
+	deno_version: await readGitValue(['x', 'deno@latest', '--', 'deno', '--version']),
+	lscpu_summary: summarizeLscpu(await runCommand(REPO_ROOT, ['x', 'deno@latest', '--', 'lscpu'])),
+	git_worktree_clean: (await readGitValue(['x', 'deno@latest', '--', 'git', 'status', '--porcelain'])).length === 0,
+};
+
+const design: DesignMetadata = {
+	timing_command,
+	memory_command,
+	approach_dir: relative(REPO_ROOT, approach_dir),
+	code_dir: relative(REPO_ROOT, code_dir),
+	independent_process_per_run: true,
+	raw_samples_preserved: true,
+	bootstrap_ready: true,
+	notes: [
+		'Each timing run executes the approach-local event_shape_bench.ts in a fresh process.',
+		'Each memory run executes the approach-local event_shape_memory.ts in a fresh process with explicit repeats.',
+		'All code under test lives inside the approach-local code snapshot to reduce cross-approach variation from root-directory edits.',
+	],
+};
+
+for (let index = 0; index < runs; index++) {
+	const timing_output = await runCommand(code_dir, [
+		'x',
+		'deno@latest',
+		'--',
+		'deno',
+		'bench',
+		'--no-lock',
+		'--allow-sys',
+		'--allow-env=NODE_DISABLE_COLORS',
+		'--v8-flags=--expose-gc',
+		'event_shape_bench.ts',
+	]);
+	timing_runs.push({
+		index,
+		benchmarks: parseTimingOutput(timing_output),
+	});
+
+	const memory_output = await runCommand(code_dir, [
+		'x',
+		'deno@latest',
+		'--',
+		'deno',
+		'run',
+		'--no-lock',
+		'--allow-sys',
+		'--v8-flags=--expose-gc',
+		'event_shape_memory.ts',
+		`--repeats=${memory_repeats}`,
+		'--format=json',
+	]);
+	memory_runs.push({
+		index,
+		inputs: parseMemoryOutput(memory_output),
+	});
+}
+
+const report: EventShapeReport = {
+	schema_version: 1,
+	variant,
+	branch: await readGitValue(['x', 'deno@latest', '--', 'git', 'branch', '--show-current']),
+	commit: await readGitValue(['x', 'deno@latest', '--', 'git', 'rev-parse', 'HEAD']),
+	generated_at: new Date().toISOString(),
+	runs,
+	memory_repeats,
+	timing_unit: 'microseconds_per_iter',
+	memory_unit: 'bytes',
+	environment,
+	design,
+	timing: {
+		per_run: timing_runs,
+		summary: summarizeTimingRuns(timing_runs),
+	},
+	memory: {
+		per_run: memory_runs,
+		summary: summarizeMemoryRuns(memory_runs),
+	},
+};
+
+const serialized = `${JSON.stringify(report, null, 2)}\n`;
+
+if (out_path === undefined) {
+	console.log(serialized);
+	Deno.exit(0);
+}
+
+await Deno.mkdir(dirname(out_path), { recursive: true });
+await Deno.writeTextFile(out_path, serialized);
+console.log(`wrote ${relative(REPO_ROOT, out_path)}`);
diff --git a/experiments/event-shape-study/tools/collect_large_input_stress_report.ts b/experiments/event-shape-study/tools/collect_large_input_stress_report.ts
new file mode 100644
index 0000000..2759c2b
--- /dev/null
+++ b/experiments/event-shape-study/tools/collect_large_input_stress_report.ts
@@ -0,0 +1,339 @@
+/**
+ * Collect a large-input stress report from one approach-local code snapshot.
+ *
+ * This tool exists because the standard event-shape ledger focuses on smaller,
+ * repeatable benchmark sizes that are cheap to rerun many times. Large-input
+ * stress runs answer a different question: how the parser behaves when callers
+ * hand it very large source strings, such as hundreds of MiB or about 1 GiB.
+ *
+ * The report intentionally stays separate from the main study acceptance ledger.
+ * It is for scale behavior, survivability, and large-workload diagnostics rather
+ * than the standard significance gate.
+ */
+
+import { dirname, fromFileUrl, join, relative } from 'jsr:@std/path';
+
+type NumericSummary = {
+	samples: number[];
+	mean: number;
+	median: number;
+	minimum: number;
+	maximum: number;
+	stdev: number;
+};
+
+type StressSample = {
+	index: number;
+	elapsed_ms: number;
+	heap_delta_bytes: number;
+	checksum: number;
+};
+
+type StressCaseSummary = {
+	name: string;
+	samples: StressSample[];
+	elapsed_ms: NumericSummary;
+	heap_delta_bytes: NumericSummary;
+};
+
+type StressReport = {
+	schema_version: 1;
+	variant: string;
+	approach_dir: string;
+	generated_at: string;
+	scenario: string;
+	size_bytes: number;
+	size_mib: number;
+	repeats: number;
+	environment: {
+		deno_version: string;
+		platform: string;
+	};
+	cases: StressCaseSummary[];
+	notes: string[];
+};
+
+type ApproachModule = {
+	events(input: string): Iterable<unknown>;
+	parse(input: string): { children: unknown[] };
+	parseWithDiagnostics(input: string): {
+		tree: { children: unknown[] };
+		diagnostics: unknown[];
+	};
+};
+
+type StressCase = {
+	name: string;
+	run: (approach: ApproachModule, input: string) => number;
+};
+
+type ScenarioDefinition = {
+	name: string;
+	description: string;
+	build: (size_bytes: number) => string;
+};
+
+type GcCapableGlobal = typeof globalThis & {
+	gc?: () => void;
+};
+
+const STUDY_ROOT = fromFileUrl(new URL('../', import.meta.url));
+const REPO_ROOT = fromFileUrl(new URL('../../../', import.meta.url));
+
+const PLAIN_UNIT = [
+	'Observational archives preserve calibration notes, weather corrections, and provenance language across long paragraphs of ordinary prose.',
+	'This fixture keeps token density low so large-input runs represent the boring text-heavy documents that still cost a lot to scan and parse.',
+	'',
+].join(' ');
+
+const MIXED_UNIT = [
+	'== Heading ==',
+	"A [[Main Page|home]] link with ''italic'' and '''bold'''.",
+	'* Bullet item',
+	'# Ordered item',
+	'{|',
+	'! Header !! Count',
+	'|-',
+	'| {{Item|name=Alpha}} || 42',
+	'|}',
+	'<ref name="cite-1">Example &amp; entity</ref>',
+	'__TOC__',
+	'',
+].join('\n');
+
+const PATHOLOGICAL_UNIT = [
+	'[[[[{{{{<!--',
+	'__BROKEN_',
+	'<ref name="n">',
+	"'''''",
+	'&broken',
+	'{|',
+	'|-',
+	'| [[Page|{{T|x}}]] || <span class="x">text',
+	'',
+].join('\n');
+
+const SCENARIOS: readonly ScenarioDefinition[] = [
+	{
+		name: 'plain-paragraphs',
+		description: 'Long ordinary prose with low token density.',
+		build(size_bytes) {
+			return repeatToMinimumSize(`${PLAIN_UNIT}\n\n`, size_bytes);
+		},
+	},
+	{
+		name: 'mixed-article',
+		description: 'A repeated mix of headings, links, templates, tables, and refs.',
+		build(size_bytes) {
+			return repeatToMinimumSize(`${MIXED_UNIT}\n`, size_bytes);
+		},
+	},
+	{
+		name: 'pathological-recovery',
+		description: 'Repeated malformed markup that stresses recovery paths.',
+		build(size_bytes) {
+			return repeatToMinimumSize(`${PATHOLOGICAL_UNIT}\n`, size_bytes);
+		},
+	},
+] as const;
+
+const STRESS_CASES: readonly StressCase[] = [
+	{
+		name: 'events() streamed count',
+		run(approach, input) {
+			let count = 0;
+			for (const _event of approach.events(input)) {
+				count++;
+			}
+
+			return count;
+		},
+	},
+	{
+		name: 'parse() child count',
+		run(approach, input) {
+			return approach.parse(input).children.length;
+		},
+	},
+	{
+		name: 'parseWithDiagnostics() tree+diagnostics count',
+		run(approach, input) {
+			const result = approach.parseWithDiagnostics(input);
+			return result.tree.children.length + result.diagnostics.length;
+		},
+	},
+] as const;
+
+function getFlag(name: string): string | undefined {
+	return Deno.args.find((arg) => arg.startsWith(`--${name}=`))?.slice(name.length + 3);
+}
+
+function requireFlag(name: string): string {
+	const value = getFlag(name);
+	if (value === undefined || value.length === 0) {
+		throw new Error(`missing required --${name}=... flag`);
+	}
+
+	return value;
+}
+
+function parsePositiveIntFlag(name: string, fallback: number): number {
+	const raw = getFlag(name);
+	if (raw === undefined) {
+		return fallback;
+	}
+
+	const value = Number(raw);
+	if (!Number.isInteger(value) || value <= 0) {
+		throw new Error(`expected --${name} to be a positive integer, got: ${raw}`);
+	}
+
+	return value;
+}
+
+function repeatToMinimumSize(unit: string, minimum_size: number): string {
+	const repeat = Math.ceil(minimum_size / unit.length);
+	return unit.repeat(repeat).slice(0, minimum_size);
+}
+
+function mean(values: readonly number[]): number {
+	return values.reduce((total, value) => total + value, 0) / values.length;
+}
+
+function median(values: readonly number[]): number {
+	const sorted = [...values].sort((left, right) => left - right);
+	const middle = Math.floor(sorted.length / 2);
+
+	if (sorted.length % 2 === 0) {
+		return (sorted[middle - 1]! + sorted[middle]!) / 2;
+	}
+
+	return sorted[middle]!;
+}
+
+function stdev(values: readonly number[]): number {
+	if (values.length === 1) {
+		return 0;
+	}
+
+	const avg = mean(values);
+	const variance = values.reduce((total, value) => {
+		const delta = value - avg;
+		return total + delta * delta;
+	}, 0) / (values.length - 1);
+
+	return Math.sqrt(variance);
+}
+
+function summarizeSamples(samples: readonly number[]): NumericSummary {
+	return {
+		samples: [...samples],
+		mean: mean(samples),
+		median: median(samples),
+		minimum: Math.min(...samples),
+		maximum: Math.max(...samples),
+		stdev: stdev(samples),
+	};
+}
+
+function forceGc(): void {
+	const gc_capable_global = globalThis as GcCapableGlobal;
+
+	for (let index = 0; index < 3; index++) {
+		gc_capable_global.gc?.();
+	}
+}
+
+function heapUsed(): number {
+	forceGc();
+	return Deno.memoryUsage().heapUsed;
+}
+
+async function loadApproachModule(approach_dir: string): Promise<ApproachModule> {
+	const module_url = new URL(`../${approach_dir}/code/mod.ts`, import.meta.url);
+	return await import(module_url.href) as ApproachModule;
+}
+
+function findScenario(name: string): ScenarioDefinition {
+	const scenario = SCENARIOS.find((entry) => entry.name === name);
+	if (scenario === undefined) {
+		throw new Error(`unknown --scenario value: ${name}`);
+	}
+
+	return scenario;
+}
+
+function measureCase(case_def: StressCase, approach: ApproachModule, input: string, index: number): StressSample {
+	const before = heapUsed();
+	const start = performance.now();
+	const checksum = case_def.run(approach, input);
+	const elapsed_ms = performance.now() - start;
+	const after = heapUsed();
+
+	return {
+		index,
+		elapsed_ms,
+		heap_delta_bytes: after - before,
+		checksum,
+	};
+}
+
+const approach_dir = requireFlag('approach-dir');
+const variant = getFlag('variant') ?? approach_dir.split('/').at(-1)!;
+const scenario_name = getFlag('scenario') ?? 'mixed-article';
+const repeats = parsePositiveIntFlag('repeats', 3);
+const size_mib = parsePositiveIntFlag('size-mib', 1024);
+const out_raw = getFlag('out');
+const out_path = out_raw === undefined ? undefined : join(REPO_ROOT, out_raw);
+
+const scenario = findScenario(scenario_name);
+const size_bytes = size_mib * 1024 * 1024;
+const input = scenario.build(size_bytes);
+const approach = await loadApproachModule(approach_dir);
+
+const cases: StressCaseSummary[] = STRESS_CASES.map((case_def) => {
+	const samples: StressSample[] = [];
+
+	for (let index = 0; index < repeats; index++) {
+		samples.push(measureCase(case_def, approach, input, index));
+	}
+
+	return {
+		name: case_def.name,
+		samples,
+		elapsed_ms: summarizeSamples(samples.map((sample) => sample.elapsed_ms)),
+		heap_delta_bytes: summarizeSamples(samples.map((sample) => sample.heap_delta_bytes)),
+	};
+});
+
+const report: StressReport = {
+	schema_version: 1,
+	variant,
+	approach_dir,
+	generated_at: new Date().toISOString(),
+	scenario: scenario.name,
+	size_bytes,
+	size_mib,
+	repeats,
+	environment: {
+		deno_version: `deno ${Deno.version.deno} / v8 ${Deno.version.v8} / typescript ${Deno.version.typescript}`,
+		platform: `${Deno.build.arch}-${Deno.build.os}`,
+	},
+	cases,
+	notes: [
+		'Large-input stress runs are intentionally separate from the main acceptance ledger.',
+		'String sizes are generated on demand so the study can run MiB-scale and GiB-scale scenarios without checking giant fixtures into the repo.',
+		`Scenario description: ${scenario.description}`,
+	],
+};
+
+const serialized = `${JSON.stringify(report, null, 2)}\n`;
+
+if (out_path === undefined) {
+	console.log(serialized);
+	Deno.exit(0);
+}
+
+await Deno.mkdir(dirname(out_path), { recursive: true });
+await Deno.writeTextFile(out_path, serialized);
+console.log(`wrote ${relative(REPO_ROOT, out_path)}`);
\ No newline at end of file
diff --git a/experiments/event-shape-study/tools/compare_reports.ts b/experiments/event-shape-study/tools/compare_reports.ts
new file mode 100644
index 0000000..d5d252c
--- /dev/null
+++ b/experiments/event-shape-study/tools/compare_reports.ts
@@ -0,0 +1,416 @@
+/**
+ * Compare one baseline event-shape report against one or more candidate reports.
+ */
+
+type NumericSummary = {
+	samples: number[];
+	mean: number;
+	median: number;
+	minimum: number;
+	maximum: number;
+	stdev: number;
+};
+
+type EventShapeReport = {
+	variant: string;
+	branch: string;
+	commit: string;
+	timing: {
+		summary: Record<string, NumericSummary>;
+	};
+	memory: {
+		summary: Record<string, Record<string, NumericSummary>>;
+	};
+};
+
+type MetricComparison = {
+	name: string;
+	family: 'timing' | 'memory';
+	estimate: number;
+	ci_lower: number;
+	ci_upper: number;
+	p_value: number;
+	adjusted_p_value: number;
+	significant_better: boolean;
+	significant_worse: boolean;
+};
+
+type CandidateDecision = {
+	variant: string;
+	path: string;
+	target_timing_median: number;
+	memory_median: number;
+	worst_critical_timing: number;
+	significant_target_wins: number;
+	significant_memory_wins: number;
+	significant_critical_regressions: number;
+	recommended: boolean;
+	top_timing_wins: MetricComparison[];
+	top_memory_wins: MetricComparison[];
+	critical_regressions: MetricComparison[];
+};
+
+const TARGET_TIMING_CASES = [
+	'events() no position access: same-size plain (~8 KB)',
+	'events() no position access: same-size mixed (~8 KB)',
+	'events() no position access: same-size pathological (~8 KB)',
+	'events() offsets only: same-size mixed (~8 KB)',
+	'events() offsets only: same-size pathological (~8 KB)',
+	'events() retained array only: same-size mixed (~8 KB)',
+	'events() retained array only: synthetic article (~35-45 KB)',
+	'session.events() warm retained array: same-size mixed (~8 KB)',
+	'session.events() warm retained array: synthetic article (~35-45 KB)',
+] as const;
+
+const CRITICAL_TIMING_CASES = [
+	'parse(): same-size mixed (~8 KB)',
+	'parseWithDiagnostics(): same-size pathological (~8 KB)',
+	'session.parse() cold: same-size mixed (~8 KB)',
+	'session.parse() warm: same-size mixed (~8 KB)',
+	'session.parseWithDiagnostics() cold: same-size pathological (~8 KB)',
+	'session.parseWithDiagnostics() warm: same-size pathological (~8 KB)',
+	'parse(): synthetic article (~35-45 KB)',
+	'session.parse() warm: synthetic article (~35-45 KB)',
+	'session.parseWithDiagnostics() warm: synthetic article (~35-45 KB)',
+] as const;
+
+function parseFloatFlag(name: string, fallback: number): number {
+	const raw = Deno.args.find((arg) => arg.startsWith(`--${name}=`))?.slice(name.length + 3);
+
+	if (raw === undefined) {
+		return fallback;
+	}
+
+	const value = Number(raw);
+	if (!Number.isFinite(value)) {
+		throw new Error(`expected --${name} to be numeric, got: ${raw}`);
+	}
+
+	return value;
+}
+
+function parseIntFlag(name: string, fallback: number): number {
+	const raw = Deno.args.find((arg) => arg.startsWith(`--${name}=`))?.slice(name.length + 3);
+
+	if (raw === undefined) {
+		return fallback;
+	}
+
+	const value = Number(raw);
+	if (!Number.isInteger(value) || value <= 0) {
+		throw new Error(`expected --${name} to be a positive integer, got: ${raw}`);
+	}
+
+	return value;
+}
+
+function parseFormat(): 'text' | 'json' {
+	const raw = Deno.args.find((arg) => arg.startsWith('--format='))?.slice('--format='.length);
+
+	if (raw === undefined) {
+		return 'text';
+	}
+
+	if (raw === 'text' || raw === 'json') {
+		return raw;
+	}
+
+	throw new Error(`expected --format=text or --format=json, got: ${raw}`);
+}
+
+function positionalPaths(): string[] {
+	return Deno.args.filter((arg) => !arg.startsWith('--'));
+}
+
+function median(values: readonly number[]): number {
+	const sorted = [...values].sort((left, right) => left - right);
+	const middle = Math.floor(sorted.length / 2);
+
+	if (sorted.length % 2 === 0) {
+		return (sorted[middle - 1]! + sorted[middle]!) / 2;
+	}
+
+	return sorted[middle]!;
+}
+
+function mean(values: readonly number[]): number {
+	return values.reduce((total, value) => total + value, 0) / values.length;
+}
+
+function percentile(values: readonly number[], ratio: number): number {
+	const sorted = [...values].sort((left, right) => left - right);
+	const index = (sorted.length - 1) * ratio;
+	const lower = Math.floor(index);
+	const upper = Math.ceil(index);
+
+	if (lower === upper) {
+		return sorted[lower]!;
+	}
+
+	const weight = index - lower;
+	return sorted[lower]! * (1 - weight) + sorted[upper]! * weight;
+}
+
+function createRng(seed: number): () => number {
+	let state = seed >>> 0;
+
+	return () => {
+		state ^= state << 13;
+		state ^= state >>> 17;
+		state ^= state << 5;
+		return (state >>> 0) / 0x1_0000_0000;
+	};
+}
+
+function sampleWithReplacement(values: readonly number[], rng: () => number): number[] {
+	const sample: number[] = [];
+
+	for (let index = 0; index < values.length; index++) {
+		sample.push(values[Math.floor(rng() * values.length)]!);
+	}
+
+	return sample;
+}
+
+function relativeImprovement(baseline: number, candidate: number): number {
+	return (baseline - candidate) / baseline;
+}
+
+function compareSamples(
+	name: string,
+	family: 'timing' | 'memory',
+	baseline_samples: readonly number[],
+	candidate_samples: readonly number[],
+	bootstrap_iterations: number,
+): MetricComparison {
+	const estimate = relativeImprovement(
+		median(baseline_samples),
+		median(candidate_samples),
+	);
+	const rng = createRng(name.length * 2654435761);
+	const distribution: number[] = [];
+
+	for (let index = 0; index < bootstrap_iterations; index++) {
+		const baseline_bootstrap = sampleWithReplacement(baseline_samples, rng);
+		const candidate_bootstrap = sampleWithReplacement(candidate_samples, rng);
+		distribution.push(relativeImprovement(mean(baseline_bootstrap), mean(candidate_bootstrap)));
+	}
+
+	const ci_lower = percentile(distribution, 0.025);
+	const ci_upper = percentile(distribution, 0.975);
+	const non_positive = distribution.filter((value) => value <= 0).length / distribution.length;
+	const non_negative = distribution.filter((value) => value >= 0).length / distribution.length;
+	const p_value = Math.min(1, 2 * Math.min(non_positive, non_negative));
+
+	return {
+		name,
+		family,
+		estimate,
+		ci_lower,
+		ci_upper,
+		p_value,
+		adjusted_p_value: p_value,
+		significant_better: false,
+		significant_worse: false,
+	};
+}
+
+function applyHolmAdjustment(
+	comparisons: readonly MetricComparison[],
+	alpha: number,
+): MetricComparison[] {
+	const ordered = comparisons
+		.map((comparison, index) => ({ comparison, index }))
+		.sort((left, right) => left.comparison.p_value - right.comparison.p_value);
+	const adjusted: MetricComparison[] = Array.from(comparisons, (comparison) => ({ ...comparison }));
+	let running_max = 0;
+
+	for (const [rank, entry] of ordered.entries()) {
+		const multiplier = ordered.length - rank;
+		const holm_value = Math.min(1, entry.comparison.p_value * multiplier);
+		running_max = Math.max(running_max, holm_value);
+		const estimate = adjusted[entry.index]!.estimate;
+		adjusted[entry.index] = {
+			...adjusted[entry.index]!,
+			adjusted_p_value: running_max,
+			significant_better: estimate > 0 && running_max <= alpha,
+			significant_worse: estimate < 0 && running_max <= alpha,
+		};
+	}
+
+	return adjusted;
+}
+
+function readReport(path: string): Promise<EventShapeReport> {
+	return Deno.readTextFile(path).then((value) => JSON.parse(value) as EventShapeReport);
+}
+
+function formatPercent(value: number): string {
+	return `${value >= 0 ? '+' : ''}${(value * 100).toFixed(2)}%`;
+}
+
+function sortBestFirst(left: MetricComparison, right: MetricComparison): number {
+	return right.estimate - left.estimate;
+}
+
+function sortWorstFirst(left: MetricComparison, right: MetricComparison): number {
+	return left.estimate - right.estimate;
+}
+
+function evaluateCandidate(
+	path: string,
+	baseline: EventShapeReport,
+	candidate: EventShapeReport,
+	minimum_improvement: number,
+	maximum_regression: number,
+	bootstrap_iterations: number,
+	alpha: number,
+): CandidateDecision {
+	const target_timing = TARGET_TIMING_CASES.map((name) => compareSamples(
+		name,
+		'timing',
+		baseline.timing.summary[name]!.samples,
+		candidate.timing.summary[name]!.samples,
+		bootstrap_iterations,
+	));
+
+	const critical_timing = CRITICAL_TIMING_CASES.map((name) => compareSamples(
+		name,
+		'timing',
+		baseline.timing.summary[name]!.samples,
+		candidate.timing.summary[name]!.samples,
+		bootstrap_iterations,
+	));
+	const adjusted_timing = applyHolmAdjustment([...target_timing, ...critical_timing], alpha);
+	const adjusted_target_timing = adjusted_timing.slice(0, target_timing.length);
+	const adjusted_critical_timing = adjusted_timing.slice(target_timing.length);
+
+	const memory_comparisons: MetricComparison[] = [];
+
+	for (const [input_name, cases] of Object.entries(baseline.memory.summary)) {
+		for (const [case_name, summary] of Object.entries(cases)) {
+			memory_comparisons.push(compareSamples(
+				`${input_name} :: ${case_name}`,
+				'memory',
+				summary.samples,
+				candidate.memory.summary[input_name]![case_name]!.samples,
+				bootstrap_iterations,
+			));
+		}
+	}
+	const adjusted_memory = applyHolmAdjustment(memory_comparisons, alpha);
+
+	const significant_target_wins = adjusted_target_timing.filter((item) => item.significant_better && item.estimate >= minimum_improvement).length;
+	const significant_memory_wins = adjusted_memory.filter((item) => item.significant_better && item.estimate > 0).length;
+	const significant_critical_regressions = adjusted_critical_timing.filter((item) => item.significant_worse && item.estimate <= -maximum_regression).length;
+	const target_timing_median = median(adjusted_target_timing.map((item) => item.estimate));
+	const memory_median = median(adjusted_memory.map((item) => item.estimate));
+	const worst_critical_timing = Math.min(...adjusted_critical_timing.map((item) => item.estimate));
+
+	return {
+		variant: candidate.variant,
+		path,
+		target_timing_median,
+		memory_median,
+		worst_critical_timing,
+		significant_target_wins,
+		significant_memory_wins,
+		significant_critical_regressions,
+		recommended: target_timing_median >= minimum_improvement
+			&& worst_critical_timing > -maximum_regression
+			&& significant_critical_regressions === 0
+			&& memory_median >= 0,
+		top_timing_wins: adjusted_target_timing.filter((item) => item.estimate > 0).sort(sortBestFirst).slice(0, 3),
+		top_memory_wins: adjusted_memory.filter((item) => item.estimate > 0).sort(sortBestFirst).slice(0, 3),
+		critical_regressions: adjusted_critical_timing.filter((item) => item.estimate < 0).sort(sortWorstFirst).slice(0, 3),
+	};
+}
+
+const minimum_improvement = parseFloatFlag('min-improvement', 0.05);
+const maximum_regression = parseFloatFlag('max-regression', 0.03);
+const bootstrap_iterations = parseIntFlag('bootstrap', 5000);
+const alpha = parseFloatFlag('alpha', 0.05);
+const format = parseFormat();
+const paths = positionalPaths();
+
+if (paths.length < 2) {
+	throw new Error('expected at least two report paths: baseline first, then one or more candidate reports');
+}
+
+const [baseline_path, ...candidate_paths] = paths;
+const baseline = await readReport(baseline_path!);
+const candidates = await Promise.all(candidate_paths.map(async (path) => ({
+	path,
+	report: await readReport(path),
+})));
+
+const decisions = candidates
+	.map(({ path, report }) => evaluateCandidate(
+		path,
+		baseline,
+		report,
+		minimum_improvement,
+		maximum_regression,
+		bootstrap_iterations,
+		alpha,
+	))
+	.sort((left, right) => {
+		if (left.recommended !== right.recommended) {
+			return Number(right.recommended) - Number(left.recommended);
+		}
+
+		if (left.target_timing_median !== right.target_timing_median) {
+			return right.target_timing_median - left.target_timing_median;
+		}
+
+		return right.memory_median - left.memory_median;
+	});
+
+if (format === 'json') {
+	console.log(JSON.stringify({
+		baseline: {
+			variant: baseline.variant,
+			branch: baseline.branch,
+			commit: baseline.commit,
+			path: baseline_path,
+		},
+		minimum_improvement,
+		maximum_regression,
+		bootstrap_iterations,
+		alpha,
+		decisions,
+	}, null, 2));
+	Deno.exit(0);
+}
+
+console.log(`baseline: ${baseline.variant} (${baseline.branch} ${baseline.commit.slice(0, 8)})`);
+console.log(`decision rule: target median >= ${formatPercent(minimum_improvement)}, critical regressions > ${formatPercent(-maximum_regression)} disallowed, Holm-adjusted alpha=${alpha.toFixed(3)}`);
+
+for (const decision of decisions) {
+	console.log(`\n${decision.variant}: ${decision.recommended ? 'recommended' : 'not recommended'}`);
+	console.log(`report: ${decision.path}`);
+	console.log(`target timing median: ${formatPercent(decision.target_timing_median)} (${decision.significant_target_wins}/${TARGET_TIMING_CASES.length} significant wins)`);
+	console.log(`memory median: ${formatPercent(decision.memory_median)} (${decision.significant_memory_wins} significant wins)`);
+	console.log(`worst critical timing: ${formatPercent(decision.worst_critical_timing)} (${decision.significant_critical_regressions} significant regressions)`);
+
+	if (decision.top_timing_wins.length > 0) {
+		console.log('top timing wins:');
+		for (const item of decision.top_timing_wins) {
+			console.log(`- ${item.name}: ${formatPercent(item.estimate)} [${formatPercent(item.ci_lower)}, ${formatPercent(item.ci_upper)}], p_adj=${item.adjusted_p_value.toExponential(2)}`);
+		}
+	}
+
+	if (decision.top_memory_wins.length > 0) {
+		console.log('top memory wins:');
+		for (const item of decision.top_memory_wins) {
+			console.log(`- ${item.name}: ${formatPercent(item.estimate)} [${formatPercent(item.ci_lower)}, ${formatPercent(item.ci_upper)}], p_adj=${item.adjusted_p_value.toExponential(2)}`);
+		}
+	}
+
+	if (decision.critical_regressions.length > 0) {
+		console.log('critical timing risks:');
+		for (const item of decision.critical_regressions) {
+			console.log(`- ${item.name}: ${formatPercent(item.estimate)} [${formatPercent(item.ci_lower)}, ${formatPercent(item.ci_upper)}], p_adj=${item.adjusted_p_value.toExponential(2)}`);
+		}
+	}
+}
diff --git a/experiments/event-shape-study/tools/record_approach_artifacts.ts b/experiments/event-shape-study/tools/record_approach_artifacts.ts
new file mode 100644
index 0000000..8d2d2da
--- /dev/null
+++ b/experiments/event-shape-study/tools/record_approach_artifacts.ts
@@ -0,0 +1,225 @@
+/**
+ * Record one approach-local artifact bundle for the event-shape study.
+ *
+ * This helper keeps the archive workflow inside the study directory. It runs the
+ * snapshot-local collector, optionally compares the result against a baseline report,
+ * and writes the machine-readable metadata and exact commands into the approach's
+ * own `artifacts/` directory.
+ */
+
+import { basename, fromFileUrl, join, relative } from 'jsr:@std/path';
+
+type RecordingMetadata = {
+	study: 'event-shape';
+	variant: string;
+	experiment_dir: string;
+	report_path: string;
+	comparison_json?: string;
+	comparison_text?: string;
+	baseline_report?: string;
+	generated_at: string;
+	runs: number;
+	memory_repeats: number;
+	minimum_improvement: number;
+	maximum_regression: number;
+	bootstrap_iterations: number;
+	alpha: number;
+	branch: string;
+	commit: string;
+	commands: string[];
+};
+
+const STUDY_ROOT = fromFileUrl(new URL('../', import.meta.url));
+const REPO_ROOT = fromFileUrl(new URL('../../../', import.meta.url));
+
+function getFlag(name: string): string | undefined {
+	return Deno.args.find((arg) => arg.startsWith(`--${name}=`))?.slice(name.length + 3);
+}
+
+function requireFlag(name: string): string {
+	const value = getFlag(name);
+	if (value === undefined || value.length === 0) {
+		throw new Error(`missing required --${name}=... flag`);
+	}
+
+	return value;
+}
+
+function parsePositiveIntFlag(name: string, fallback: number): number {
+	const raw = getFlag(name);
+	if (raw === undefined) {
+		return fallback;
+	}
+
+	const value = Number(raw);
+	if (!Number.isInteger(value) || value <= 0) {
+		throw new Error(`expected --${name} to be a positive integer, got: ${raw}`);
+	}
+
+	return value;
+}
+
+function parseFloatFlag(name: string, fallback: number): number {
+	const raw = getFlag(name);
+	if (raw === undefined) {
+		return fallback;
+	}
+
+	const value = Number(raw);
+	if (!Number.isFinite(value)) {
+		throw new Error(`expected --${name} to be numeric, got: ${raw}`);
+	}
+
+	return value;
+}
+
+function stripAnsi(value: string): string {
+	return value.replace(/\x1B\[[0-9;]*[A-Za-z]/g, '');
+}
+
+async function runCommand(args: string[], cwd = REPO_ROOT): Promise<string> {
+	const command = new Deno.Command('mise', {
+		args,
+		cwd,
+		stdout: 'piped',
+		stderr: 'piped',
+		env: {
+			NODE_DISABLE_COLORS: '1',
+		},
+	});
+	const output = await command.output();
+	const stdout = new TextDecoder().decode(output.stdout);
+	const stderr = new TextDecoder().decode(output.stderr);
+
+	if (!output.success) {
+		throw new Error(`command failed: mise ${args.join(' ')}\n${stdout}\n${stderr}`);
+	}
+
+	return stdout;
+}
+
+async function readGitValue(args: string[]): Promise<string> {
+	const command = new Deno.Command('git', {
+		args,
+		cwd: REPO_ROOT,
+		stdout: 'piped',
+		stderr: 'piped',
+	});
+	const output = await command.output();
+	const stdout = new TextDecoder().decode(output.stdout);
+	const stderr = new TextDecoder().decode(output.stderr);
+
+	if (!output.success) {
+		throw new Error(`command failed: git ${args.join(' ')}\n${stdout}\n${stderr}`);
+	}
+
+	return stripAnsi(stdout).trim();
+}
+
+const approach_dir = requireFlag('approach-dir');
+const variant = getFlag('variant') ?? basename(approach_dir);
+const runs = parsePositiveIntFlag('runs', 10);
+const memory_repeats = parsePositiveIntFlag('memory-repeats', 5);
+const minimum_improvement = parseFloatFlag('min-improvement', 0.05);
+const maximum_regression = parseFloatFlag('max-regression', 0.03);
+const bootstrap_iterations = parsePositiveIntFlag('bootstrap', 5000);
+const alpha = parseFloatFlag('alpha', 0.05);
+const baseline_report = getFlag('baseline-report');
+
+const experiment_dir = join(STUDY_ROOT, approach_dir);
+const artifacts_dir = join(experiment_dir, 'artifacts');
+const report_path = join(artifacts_dir, 'report.json');
+const comparison_json = join(artifacts_dir, 'comparison.json');
+const comparison_text = join(artifacts_dir, 'comparison.txt');
+const recording_path = join(artifacts_dir, 'recording.json');
+const commands_path = join(artifacts_dir, 'commands.txt');
+
+await Deno.mkdir(artifacts_dir, { recursive: true });
+
+const collect_args = [
+	'x',
+	'deno@latest',
+	'--',
+	'deno',
+	'run',
+	'--no-lock',
+	'--allow-run=mise,git',
+	'--allow-read',
+	'--allow-write',
+	'experiments/event-shape-study/tools/collect_approach_report.ts',
+	`--approach-dir=${approach_dir}`,
+	`--variant=${variant}`,
+	`--runs=${runs}`,
+	`--memory-repeats=${memory_repeats}`,
+	`--out=${relative(REPO_ROOT, report_path)}`,
+];
+
+const commands = [`mise ${collect_args.join(' ')}`];
+await runCommand(collect_args);
+
+let relative_baseline_report: string | undefined;
+let relative_comparison_json: string | undefined;
+let relative_comparison_text: string | undefined;
+
+if (baseline_report !== undefined) {
+	const resolved_baseline_report = join(REPO_ROOT, baseline_report);
+	relative_baseline_report = relative(REPO_ROOT, resolved_baseline_report);
+	const compare_base_args = [
+		'x',
+		'deno@latest',
+		'--',
+		'deno',
+		'run',
+		'--no-lock',
+		'--allow-read',
+		'experiments/event-shape-study/tools/compare_reports.ts',
+		`--min-improvement=${minimum_improvement}`,
+		`--max-regression=${maximum_regression}`,
+		`--bootstrap=${bootstrap_iterations}`,
+		`--alpha=${alpha}`,
+	];
+	const compare_json_args = [
+		...compare_base_args,
+		'--format=json',
+		relative_baseline_report,
+		relative(REPO_ROOT, report_path),
+	];
+	const compare_text_args = [
+		...compare_base_args,
+		'--format=text',
+		relative_baseline_report,
+		relative(REPO_ROOT, report_path),
+	];
+
+	await Deno.writeTextFile(comparison_json, await runCommand(compare_json_args));
+	await Deno.writeTextFile(comparison_text, await runCommand(compare_text_args));
+	commands.push(`mise ${compare_json_args.join(' ')}`);
+	commands.push(`mise ${compare_text_args.join(' ')}`);
+	relative_comparison_json = relative(REPO_ROOT, comparison_json);
+	relative_comparison_text = relative(REPO_ROOT, comparison_text);
+}
+
+const recording: RecordingMetadata = {
+	study: 'event-shape',
+	variant,
+	experiment_dir: relative(REPO_ROOT, experiment_dir),
+	report_path: relative(REPO_ROOT, report_path),
+	comparison_json: relative_comparison_json,
+	comparison_text: relative_comparison_text,
+	baseline_report: relative_baseline_report,
+	generated_at: new Date().toISOString(),
+	runs,
+	memory_repeats,
+	minimum_improvement,
+	maximum_regression,
+	bootstrap_iterations,
+	alpha,
+	branch: await readGitValue(['branch', '--show-current']),
+	commit: await readGitValue(['rev-parse', 'HEAD']),
+	commands,
+};
+
+await Deno.writeTextFile(recording_path, `${JSON.stringify(recording, null, 2)}\n`);
+await Deno.writeTextFile(commands_path, `${commands.join('\n')}\n`);
+
+console.log(`wrote ${relative(REPO_ROOT, recording_path)}`);
\ No newline at end of file
diff --git a/experiments/event-shape-study/tools/run_cross_candidate_schedule.ts b/experiments/event-shape-study/tools/run_cross_candidate_schedule.ts
new file mode 100644
index 0000000..8d7f941
--- /dev/null
+++ b/experiments/event-shape-study/tools/run_cross_candidate_schedule.ts
@@ -0,0 +1,217 @@
+/**
+ * Run a deterministic round-robin collection schedule across approach-local code snapshots.
+ */
+
+import { fromFileUrl, join, relative } from 'jsr:@std/path';
+
+type ScheduleEntry = {
+	round: number;
+	order: number;
+	approach: string;
+	report_path: string;
+	comparison_json?: string;
+	comparison_text?: string;
+};
+
+type ScheduleOutput = {
+	study: 'event-shape';
+	baseline: string;
+	approaches: string[];
+	rounds: number;
+	runs_per_report: number;
+	memory_repeats: number;
+	minimum_improvement: number;
+	maximum_regression: number;
+	bootstrap_iterations: number;
+	alpha: number;
+	entries: ScheduleEntry[];
+	commands: string[];
+};
+
+const STUDY_ROOT = fromFileUrl(new URL('../', import.meta.url));
+const REPO_ROOT = fromFileUrl(new URL('../../../', import.meta.url));
+
+function getFlag(name: string): string | undefined {
+	return Deno.args.find((arg) => arg.startsWith(`--${name}=`))?.slice(name.length + 3);
+}
+
+function requireFlag(name: string): string {
+	const value = getFlag(name);
+	if (value === undefined || value.length === 0) {
+		throw new Error(`missing required --${name}=... flag`);
+	}
+	return value;
+}
+
+function parsePositiveIntFlag(name: string, fallback: number): number {
+	const raw = getFlag(name);
+	if (raw === undefined) {
+		return fallback;
+	}
+
+	const value = Number(raw);
+	if (!Number.isInteger(value) || value <= 0) {
+		throw new Error(`expected --${name} to be a positive integer, got: ${raw}`);
+	}
+
+	return value;
+}
+
+function parseFloatFlag(name: string, fallback: number): number {
+	const raw = getFlag(name);
+	if (raw === undefined) {
+		return fallback;
+	}
+
+	const value = Number(raw);
+	if (!Number.isFinite(value)) {
+		throw new Error(`expected --${name} to be numeric, got: ${raw}`);
+	}
+
+	return value;
+}
+
+function parseApproaches(): string[] {
+	const raw = requireFlag('approaches');
+	return raw.split(',').map((value) => value.trim()).filter((value) => value.length > 0);
+}
+
+function rotate<T>(values: readonly T[], offset: number): T[] {
+	const pivot = offset % values.length;
+	return [...values.slice(pivot), ...values.slice(0, pivot)];
+}
+
+async function runCommand(args: string[], cwd = REPO_ROOT): Promise<string> {
+	const command = new Deno.Command('mise', {
+		args,
+		cwd,
+		stdout: 'piped',
+		stderr: 'piped',
+		env: {
+			NODE_DISABLE_COLORS: '1',
+		},
+	});
+	const output = await command.output();
+	const stdout = new TextDecoder().decode(output.stdout);
+	const stderr = new TextDecoder().decode(output.stderr);
+
+	if (!output.success) {
+		throw new Error(`command failed: mise ${args.join(' ')}\n${stdout}\n${stderr}`);
+	}
+
+	return stdout;
+}
+
+const baseline = requireFlag('baseline');
+const approaches = parseApproaches();
+const rounds = parsePositiveIntFlag('rounds', 1);
+const runs = parsePositiveIntFlag('runs', 10);
+const memory_repeats = parsePositiveIntFlag('memory-repeats', 5);
+const minimum_improvement = parseFloatFlag('min-improvement', 0.05);
+const maximum_regression = parseFloatFlag('max-regression', 0.03);
+const bootstrap_iterations = parsePositiveIntFlag('bootstrap', 5000);
+const alpha = parseFloatFlag('alpha', 0.05);
+const run_label = requireFlag('run-label');
+const run_dir = join(STUDY_ROOT, 'cross-candidate-runs', run_label);
+const reports_dir = join(run_dir, 'reports');
+const comparisons_dir = join(run_dir, 'comparisons');
+
+await Deno.mkdir(reports_dir, { recursive: true });
+await Deno.mkdir(comparisons_dir, { recursive: true });
+
+const commands: string[] = [];
+const entries: ScheduleEntry[] = [];
+
+for (let round = 0; round < rounds; round++) {
+	const round_order = rotate(approaches, round);
+
+	for (const [order, approach] of round_order.entries()) {
+		const report_path = join(reports_dir, `round-${String(round + 1).padStart(2, '0')}--${approach}.json`);
+		const collect_args = [
+			'x',
+			'deno@latest',
+			'--',
+			'deno',
+			'run',
+			'--no-lock',
+			'--allow-run=mise,git',
+			'--allow-read',
+			'--allow-write',
+			'experiments/event-shape-study/tools/collect_approach_report.ts',
+			`--approach-dir=${approach}`,
+			`--variant=${approach}`,
+			`--runs=${runs}`,
+			`--memory-repeats=${memory_repeats}`,
+			`--out=${relative(REPO_ROOT, report_path)}`,
+		];
+		await runCommand(collect_args);
+		commands.push(`mise ${collect_args.join(' ')}`);
+
+		const entry: ScheduleEntry = {
+			round: round + 1,
+			order: order + 1,
+			approach,
+			report_path: relative(REPO_ROOT, report_path),
+		};
+
+		if (approach !== baseline) {
+			const baseline_report = join(reports_dir, `round-${String(round + 1).padStart(2, '0')}--${baseline}.json`);
+			const comparison_json = join(comparisons_dir, `round-${String(round + 1).padStart(2, '0')}--${baseline}--vs--${approach}.json`);
+			const comparison_text = join(comparisons_dir, `round-${String(round + 1).padStart(2, '0')}--${baseline}--vs--${approach}.txt`);
+			const compare_base_args = [
+				'x',
+				'deno@latest',
+				'--',
+				'deno',
+				'run',
+				'--no-lock',
+				'--allow-read',
+				'experiments/event-shape-study/tools/compare_reports.ts',
+				`--min-improvement=${minimum_improvement}`,
+				`--max-regression=${maximum_regression}`,
+				`--bootstrap=${bootstrap_iterations}`,
+				`--alpha=${alpha}`,
+			];
+			const compare_json_args = [
+				...compare_base_args,
+				'--format=json',
+				relative(REPO_ROOT, baseline_report),
+				relative(REPO_ROOT, report_path),
+			];
+			const compare_text_args = [
+				...compare_base_args,
+				'--format=text',
+				relative(REPO_ROOT, baseline_report),
+				relative(REPO_ROOT, report_path),
+			];
+			await Deno.writeTextFile(comparison_json, await runCommand(compare_json_args));
+			await Deno.writeTextFile(comparison_text, await runCommand(compare_text_args));
+			commands.push(`mise ${compare_json_args.join(' ')}`);
+			commands.push(`mise ${compare_text_args.join(' ')}`);
+			entry.comparison_json = relative(REPO_ROOT, comparison_json);
+			entry.comparison_text = relative(REPO_ROOT, comparison_text);
+		}
+
+		entries.push(entry);
+	}
+}
+
+const output: ScheduleOutput = {
+	study: 'event-shape',
+	baseline,
+	approaches,
+	rounds,
+	runs_per_report: runs,
+	memory_repeats,
+	minimum_improvement,
+	maximum_regression,
+	bootstrap_iterations,
+	alpha,
+	entries,
+	commands,
+};
+
+await Deno.writeTextFile(join(run_dir, 'schedule.json'), `${JSON.stringify(output, null, 2)}\n`);
+await Deno.writeTextFile(join(run_dir, 'commands.txt'), `${commands.join('\n')}\n`);
+
+console.log(`wrote ${relative(REPO_ROOT, join(run_dir, 'schedule.json'))}`);