viberag 0.7.0 → 0.8.0

package/scripts/memory/README.md

@@ -0,0 +1,172 @@
+# Memory Diagnostics Scripts
+
+This folder contains repeatable memory diagnostics for daemon + MCP search/indexing workloads.
+
+Reference ADR: `adr/018-adr-memory-lifecycle-and-regression-guardrails.md`
+
+## Scripts
+
+### `profile.mjs`
+
+Purpose:
+
+- Repeated in-process memory profiling for chunking and indexing loops.
+- Useful for post-GC drift checks while iterating on lifecycle fixes.
+
+Run:
+
+```bash
+npm run memory:profile
+```
+
+Optional env:
+
+- `VIBERAG_MEM_RUNS` (default `3`)
+- `VIBERAG_MEM_ITERATIONS` (default `200`)
+
+Notes:
+
+- Uses `--expose-gc` via npm script.
+- Prints JSON samples (`rssMB`, `heapUsedMB`, `externalMB`, `arrayBuffersMB`).
+
+### `isolate-intent-growth.mjs`
+
+Purpose:
+
+- Reproduces memory behavior per search intent on a fresh daemon process.
+- Kills daemon between scenarios to avoid cross-run contamination.
+- Captures before/after RSS from both `ps` and daemon status.
+
+Run:
+
+```bash
+npm run memory:isolate
+```
+
+Useful env:
+
+- `VIBERAG_ISOLATE_QUERY`
+- `VIBERAG_ISOLATE_INTENTS` (comma-separated, e.g. `exact_text,concept`)
+- `VIBERAG_ISOLATE_K` (clamped to `1..100`)
+- `VIBERAG_ISOLATE_EXPLAIN` (`1` or `0`)
+- `VIBERAG_ISOLATE_REQUEST_TIMEOUT_MS`
+- `VIBERAG_ISOLATE_POST_SAMPLE_DELAY_MS`
+- `VIBERAG_ISOLATE_VMMAP_TRIGGER_MB`
+
+Example:
+
+```bash
+VIBERAG_ISOLATE_QUERY='indexing memory lifecycle ownership contract cleanup' \
+VIBERAG_ISOLATE_INTENTS='exact_text' \
+VIBERAG_ISOLATE_K=100 \
+npm run memory:isolate
+```
+
+### `stress-search-growth.mjs`
+
+Purpose:
+
+- High-concurrency search stress test with periodic memory sampling.
+- Supports optional indexing churn and safety guards.
+
+Run:
+
+```bash
+npm run memory:stress
+```
+
+Safety defaults:
+
+- Hard guard: `VIBERAG_STRESS_MAX_RSS_MB=10240` (10 GB)
+- Soft guard: `VIBERAG_STRESS_SOFT_RSS_MB=8192` (80% of hard cap by default)
+- On guard trigger, script cancels work and requests daemon shutdown.
+
+Key env:
+
+- `VIBERAG_STRESS_SECONDS`
+- `VIBERAG_STRESS_PARALLELISM`
+- `VIBERAG_STRESS_MAX_IN_FLIGHT`
+- `VIBERAG_STRESS_K` (clamped to `1..100`)
+- `VIBERAG_STRESS_MAX_RSS_MB`
+- `VIBERAG_STRESS_SOFT_RSS_MB`
+- `VIBERAG_STRESS_GUARD_KILL` (`1` default, `0` disables SIGTERM fallback)
+- `VIBERAG_STRESS_INDEX_CHURN_SECONDS`
+- `VIBERAG_STRESS_INDEX_FORCE`
+
+### `watch-reindex-stress.mjs`
+
+Purpose:
+
+- Sustained watcher-driven reindex stress via parallel continuous file edits.
+- Simulates real file-change churn with high write rates over many probe files.
+- Tracks daemon RSS/external memory, watcher pending queue pressure, and index update cadence.
+- Includes hard/soft RSS guards to avoid host OOM during investigation.
+
+Run:
+
+```bash
+npm run memory:watch-stress
+```
+
+Key env:
+
+- `VIBERAG_WATCH_STRESS_SECONDS` (default `60`)
+- `VIBERAG_WATCH_STRESS_WRITERS` (default `48`)
+- `VIBERAG_WATCH_STRESS_FILES` (default `96`)
+- `VIBERAG_WATCH_STRESS_WRITE_INTERVAL_MS` (default `0`)
+- `VIBERAG_WATCH_STRESS_CONTENT_KB` (default `2`)
+- `VIBERAG_WATCH_STRESS_SAMPLE_MS` (default `500`)
+- `VIBERAG_WATCH_STRESS_MAX_RSS_MB` (default `10240`)
+- `VIBERAG_WATCH_STRESS_SOFT_RSS_MB` (default `80%` of max)
+- `VIBERAG_WATCH_STRESS_CLEAN_START` (`1` by default, kills existing daemon first)
+- `VIBERAG_WATCH_STRESS_TARGET_DIR` (default `source/daemon/__watch_stress_probe`)
+
+Example:
+
+```bash
+VIBERAG_WATCH_STRESS_SECONDS=60 \
+VIBERAG_WATCH_STRESS_WRITERS=64 \
+VIBERAG_WATCH_STRESS_FILES=128 \
+VIBERAG_WATCH_STRESS_MAX_RSS_MB=10240 \
+npm run memory:watch-stress
+```
+
+## Testing Daemon Memory Alerts
+
+You can force local alerting by lowering daemon monitor thresholds via env vars.
+
+Supported daemon monitor env vars:
+
+- `VIBERAG_MEMORY_MONITOR_POLL_INTERVAL_MS` (default `3000`)
+- `VIBERAG_MEMORY_MONITOR_THRESHOLD_MB` (default `4096`)
+- `VIBERAG_MEMORY_MONITOR_RECOVERY_MB` (default `3584`)
+- `VIBERAG_MEMORY_MONITOR_GROWTH_THRESHOLD_MB` (default `1024`)
+- `VIBERAG_MEMORY_MONITOR_GROWTH_WINDOW_MS` (default `10000`)
+- `VIBERAG_MEMORY_MONITOR_MIN_REPORT_INTERVAL_MS` (default `10000`)
+- `VIBERAG_MEMORY_MONITOR_MAX_REPORTS_PER_DAY` (default `20`)
+
+Example (force threshold alerts at normal RSS):
+
+```bash
+VIBERAG_MEMORY_MONITOR_THRESHOLD_MB=200 \
+VIBERAG_MEMORY_MONITOR_RECOVERY_MB=150 \
+VIBERAG_STRESS_SECONDS=10 \
+VIBERAG_STRESS_PARALLELISM=1 \
+VIBERAG_STRESS_MAX_IN_FLIGHT=1 \
+npm run memory:stress
+```
+
+Expected signal:
+
+- Daemon log line like:
+  `Memory monitor triggered Sentry report (threshold) at rss=...MB`
+
+## Output Files
+
+Generated run logs are written to `scripts/memory/out/` as JSONL.
+
+- `isolate-intent-growth-*.jsonl`
+- `stress-search-growth-*.jsonl`
+- `watch-reindex-stress-*.jsonl`
+
+These generated files are intentionally gitignored. Keep `scripts/memory/out/.gitkeep` tracked so the folder exists by default.

package/scripts/memory/isolate-intent-growth.mjs

@@ -0,0 +1,348 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {execFile as execFileCb} from 'node:child_process';
+import {promisify} from 'node:util';
+import {fileURLToPath} from 'node:url';
+
+const execFile = promisify(execFileCb);
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(SCRIPT_DIR, '..', '..');
+const DAEMON_ENTRY = path.join(REPO_ROOT, 'dist/daemon/index.js');
+const OUTPUT_DIR = path.join(REPO_ROOT, 'scripts/memory/out');
+
+const QUERY =
+	process.env['VIBERAG_ISOLATE_QUERY'] ??
+	'indexing memory lifecycle ownership contract cleanup';
+const K = Math.max(
+	1,
+	Math.min(100, Number(process.env['VIBERAG_ISOLATE_K'] ?? '100')),
+);
+const EXPLAIN = process.env['VIBERAG_ISOLATE_EXPLAIN'] !== '0';
+const REQUEST_TIMEOUT_MS = Number(
+	process.env['VIBERAG_ISOLATE_REQUEST_TIMEOUT_MS'] ?? '30000',
+);
+const POST_SAMPLE_DELAY_MS = Number(
+	process.env['VIBERAG_ISOLATE_POST_SAMPLE_DELAY_MS'] ?? '1500',
+);
+const VMAP_TRIGGER_MB = Number(
+	process.env['VIBERAG_ISOLATE_VMMAP_TRIGGER_MB'] ?? '1500',
+);
+const INTENTS = (
+	process.env['VIBERAG_ISOLATE_INTENTS'] ??
+	'definition,concept,usage,exact_text,similar_code,auto'
+)
+	.split(',')
+	.map(intent => intent.trim())
+	.filter(Boolean);
+
+if (INTENTS.length === 0) {
+	throw new Error('VIBERAG_ISOLATE_INTENTS produced an empty intent list.');
+}
+
+function sleep(ms) {
+	return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function nowIso() {
+	return new Date().toISOString();
+}
+
+function compactError(error) {
+	if (error instanceof Error) return `${error.name}: ${error.message}`;
+	return String(error);
+}
+
+function mbFromKb(kb) {
+	return Number((kb / 1024).toFixed(1));
+}
+
+async function withTimeout(promise, timeoutMs, label) {
+	const timeout = new Promise((_, reject) => {
+		setTimeout(() => {
+			reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+	});
+	return Promise.race([promise, timeout]);
+}
+
+async function listDaemonRows() {
+	const {stdout} = await execFile('ps', [
+		'-axo',
+		'pid=,rss=,vsz=,%cpu=,%mem=,state=,etime=,command=',
+	]);
+	const rows = [];
+	for (const line of stdout.split('\n')) {
+		if (!line.includes(DAEMON_ENTRY)) continue;
+		const match = line.match(
+			/^\s*(\d+)\s+(\d+)\s+(\d+)\s+([0-9.]+)\s+([0-9.]+)\s+(\S+)\s+(\S+)\s+(.+)$/,
+		);
+		if (!match) continue;
+		rows.push({
+			pid: Number(match[1]),
+			rssMB: mbFromKb(Number(match[2])),
+			vszMB: mbFromKb(Number(match[3])),
+			cpuPercent: Number(match[4]),
+			memPercent: Number(match[5]),
+			state: match[6],
+			etime: match[7],
+			command: match[8],
+		});
+	}
+	return rows;
+}
+
+async function killDaemonProcesses() {
+	const initial = await listDaemonRows();
+	if (initial.length === 0) {
+		await cleanupStaleRunArtifacts();
+		return {killed: [], zombieLike: []};
+	}
+
+	const killed = [];
+	for (const row of initial) {
+		try {
+			process.kill(row.pid, 'SIGTERM');
+			killed.push({pid: row.pid, signal: 'SIGTERM'});
+		} catch {}
+	}
+	await sleep(500);
+
+	const afterTerm = await listDaemonRows();
+	for (const row of afterTerm) {
+		try {
+			process.kill(row.pid, 'SIGKILL');
+			killed.push({pid: row.pid, signal: 'SIGKILL'});
+		} catch {}
+	}
+	await sleep(500);
+
+	const stillThere = await listDaemonRows();
+	if (stillThere.length === 0) {
+		await cleanupStaleRunArtifacts();
+	}
+	return {killed, zombieLike: stillThere.map(row => row.pid)};
+}
+
+async function cleanupStaleRunArtifacts() {
+	const {getDaemonLockPath, getDaemonPidPath, getDaemonSocketPath} =
+		await import(path.join(REPO_ROOT, 'dist/daemon/lib/constants.js'));
+	const stalePaths = [
+		getDaemonLockPath(REPO_ROOT),
+		getDaemonPidPath(REPO_ROOT),
+		getDaemonSocketPath(REPO_ROOT),
+	];
+	for (const stalePath of stalePaths) {
+		try {
+			await fs.rm(stalePath, {force: true, recursive: true});
+		} catch {}
+	}
+}
+
+function summarizeResult(result) {
+	if (!result || typeof result !== 'object') {
+		return {bytes: 0, groups: null};
+	}
+	let bytes = 0;
+	try {
+		bytes = JSON.stringify(result).length;
+	} catch {}
+
+	const groups = result.groups ?? {};
+	return {
+		bytes,
+		groups: {
+			definitions: Array.isArray(groups.definitions)
+				? groups.definitions.length
+				: 0,
+			files: Array.isArray(groups.files) ? groups.files.length : 0,
+			blocks: Array.isArray(groups.blocks) ? groups.blocks.length : 0,
+			usages: Array.isArray(groups.usages) ? groups.usages.length : 0,
+		},
+	};
+}
+
+async function captureVmmapSummary(pid) {
+	try {
+		const {stdout} = await withTimeout(
+			execFile('vmmap', ['-summary', String(pid)]),
+			5000,
+			'vmmap',
+		);
+		const lines = stdout.split('\n');
+		const picked = lines.filter(
+			line =>
+				line.includes('Physical footprint') ||
+				line.includes('MALLOC') ||
+				line.includes('VM_ALLOCATE') ||
+				line.includes('MALLOC_NANO') ||
+				line.includes('TOTAL'),
+		);
+		return picked.slice(0, 120);
+	} catch (error) {
+		return [`vmmap_error: ${compactError(error)}`];
+	}
+}
+
+const {DaemonClient} = await import(
+	path.join(REPO_ROOT, 'dist/client/index.js')
+);
+
+await fs.mkdir(OUTPUT_DIR, {recursive: true});
+const runId = nowIso().replace(/[:.]/g, '-');
+const outputFile = path.join(
+	OUTPUT_DIR,
+	`isolate-intent-growth-${runId}.jsonl`,
+);
+
+async function writeRow(row) {
+	await fs.appendFile(outputFile, `${JSON.stringify(row)}\n`, 'utf8');
+}
+
+const header = {
+	ts: nowIso(),
+	label: 'run.start',
+	query: QUERY,
+	intents: INTENTS,
+	k: K,
+	explain: EXPLAIN,
+	requestTimeoutMs: REQUEST_TIMEOUT_MS,
+	postSampleDelayMs: POST_SAMPLE_DELAY_MS,
+	vmmapTriggerMB: VMAP_TRIGGER_MB,
+	outputFile,
+};
+console.log(JSON.stringify(header));
+await writeRow(header);
+
+const summary = [];
+
+for (const intent of INTENTS) {
+	const scenarioStart = Date.now();
+	const cleanupBefore = await killDaemonProcesses();
+	const client = new DaemonClient({
+		projectRoot: REPO_ROOT,
+		autoStart: true,
+		connectTimeout: 30_000,
+		clientSource: 'mcp',
+	});
+
+	let baselineStatus = null;
+	let baselinePs = null;
+	let searchOutcome = null;
+	let postStatus = null;
+	let postPs = null;
+	let postDelayStatus = null;
+	let vmmapSummary = null;
+	let error = null;
+
+	try {
+		await withTimeout(client.connect(), 30_000, 'connect');
+		baselineStatus = await client.status();
+		baselinePs = (await listDaemonRows())[0] ?? null;
+
+		const searchStarted = Date.now();
+		try {
+			const result = await withTimeout(
+				client.search(QUERY, {intent, k: K, explain: EXPLAIN}),
+				REQUEST_TIMEOUT_MS,
+				`search:${intent}`,
+			);
+			searchOutcome = {
+				ok: true,
+				durationMs: Date.now() - searchStarted,
+				...summarizeResult(result),
+			};
+		} catch (searchError) {
+			searchOutcome = {
+				ok: false,
+				durationMs: Date.now() - searchStarted,
+				error: compactError(searchError),
+			};
+		}
+
+		try {
+			postStatus = await client.status();
+		} catch (statusError) {
+			error = `post_status: ${compactError(statusError)}`;
+		}
+		postPs = (await listDaemonRows())[0] ?? null;
+
+		await sleep(POST_SAMPLE_DELAY_MS);
+		try {
+			postDelayStatus = await client.status();
+		} catch {}
+
+		const observedPostRss = Math.max(
+			postStatus?.memory?.rssMB ?? 0,
+			postPs?.rssMB ?? 0,
+		);
+		if (observedPostRss >= VMAP_TRIGGER_MB && postPs?.pid) {
+			vmmapSummary = await captureVmmapSummary(postPs.pid);
+		}
+	} catch (scenarioError) {
+		error = compactError(scenarioError);
+	} finally {
+		await client.disconnect().catch(() => {});
+	}
+
+	const cleanupAfter = await killDaemonProcesses();
+	const row = {
+		ts: nowIso(),
+		label: 'scenario.result',
+		intent,
+		durationMs: Date.now() - scenarioStart,
+		baseline: {
+			pid: baselinePs?.pid ?? null,
+			rssMBPs: baselinePs?.rssMB ?? null,
+			rssMBStatus: baselineStatus?.memory?.rssMB ?? null,
+			heapUsedMBStatus: baselineStatus?.memory?.heapUsedMB ?? null,
+			externalMBStatus: baselineStatus?.memory?.externalMB ?? null,
+		},
+		search: searchOutcome,
+		post: {
+			pid: postPs?.pid ?? null,
+			rssMBPs: postPs?.rssMB ?? null,
+			rssMBStatus: postStatus?.memory?.rssMB ?? null,
+			heapUsedMBStatus: postStatus?.memory?.heapUsedMB ?? null,
+			externalMBStatus: postStatus?.memory?.externalMB ?? null,
+			indexingStatus: postStatus?.indexing?.status ?? null,
+		},
+		postDelayed: {
+			rssMBStatus: postDelayStatus?.memory?.rssMB ?? null,
+			heapUsedMBStatus: postDelayStatus?.memory?.heapUsedMB ?? null,
+			externalMBStatus: postDelayStatus?.memory?.externalMB ?? null,
+		},
+		cleanupBefore,
+		cleanupAfter,
+		vmmapSummary,
+		error,
+	};
+
+	summary.push(row);
+	console.log(JSON.stringify(row));
+	await writeRow(row);
+}
+
+const final = {
+	ts: nowIso(),
+	label: 'run.summary',
+	outputFile,
+	results: summary.map(row => {
+		const start =
+			Math.max(row.baseline.rssMBPs ?? 0, row.baseline.rssMBStatus ?? 0) || 0;
+		const end = Math.max(row.post.rssMBPs ?? 0, row.post.rssMBStatus ?? 0) || 0;
+		return {
+			intent: row.intent,
+			ok: row.search?.ok ?? false,
+			searchDurationMs: row.search?.durationMs ?? null,
+			searchError: row.search?.error ?? null,
+			startMB: start,
+			endMB: end,
+			growthMB: Number((end - start).toFixed(1)),
+		};
+	}),
+};
+console.log(JSON.stringify(final));
+await writeRow(final);

package/scripts/memory/out/.gitkeep

@@ -0,0 +1 @@
+

package/scripts/memory/profile.mjs

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(SCRIPT_DIR, '..', '..');
+const RUNS = Number(process.env['VIBERAG_MEM_RUNS'] ?? '3');
+const ITERATIONS = Number(process.env['VIBERAG_MEM_ITERATIONS'] ?? '200');
+
+const {Chunker} = await import(
+	path.join(REPO_ROOT, 'dist/daemon/lib/chunker/index.js')
+);
+const {IndexingServiceV2} = await import(
+	path.join(REPO_ROOT, 'dist/daemon/services/v2/indexing.js')
+);
+const {createConfigForProvider, saveConfig} = await import(
+	path.join(REPO_ROOT, 'dist/daemon/lib/config.js')
+);
+
+class DummyEmbeddingProvider {
+	constructor(dimensions) {
+		this.dimensions = dimensions;
+		this.initialized = false;
+	}
+
+	async initialize() {
+		this.initialized = true;
+	}
+
+	async embed(texts) {
+		if (!this.initialized) {
+			await this.initialize();
+		}
+		return texts.map((text, index) => {
+			const seed = ((text.length + index * 7) % 97) / 100;
+			const out = new Array(this.dimensions);
+			for (let i = 0; i < out.length; i += 1) out[i] = seed;
+			return out;
+		});
+	}
+
+	async embedSingle(text) {
+		const [vector] = await this.embed([text]);
+		return vector;
+	}
+
+	close() {
+		this.initialized = false;
+	}
+}
+
+function mb(value) {
+	return Number((value / (1024 * 1024)).toFixed(1));
+}
+
+function memory(label) {
+	const usage = process.memoryUsage();
+	const sample = {
+		label,
+		time: new Date().toISOString(),
+		rssMB: mb(usage.rss),
+		heapUsedMB: mb(usage.heapUsed),
+		externalMB: mb(usage.external),
+		arrayBuffersMB: mb(usage.arrayBuffers),
+	};
+	console.log(JSON.stringify(sample));
+	return sample;
+}
+
+function forceGc() {
+	if (typeof global.gc !== 'function') {
+		return;
+	}
+	global.gc();
+	global.gc();
+}
+
+async function createSyntheticProject() {
+	const root = await fs.mkdtemp(
+		path.join(os.tmpdir(), 'viberag-memory-profile-'),
+	);
+	const projectRoot = path.join(root, 'project');
+	const homeRoot = path.join(root, 'home');
+	process.env['VIBERAG_HOME'] = homeRoot;
+
+	await fs.mkdir(projectRoot, {recursive: true});
+	await fs.mkdir(homeRoot, {recursive: true});
+	await fs.cp(
+		path.join(REPO_ROOT, 'source'),
+		path.join(projectRoot, 'source'),
+		{
+			recursive: true,
+		},
+	);
+
+	const config = createConfigForProvider('gemini');
+	config.watch = {...config.watch, enabled: false};
+	config.extensions = ['.ts', '.tsx', '.js', '.mjs', '.cjs'];
+	await saveConfig(projectRoot, config);
+
+	return {projectRoot, homeRoot, dimensions: config.embeddingDimensions};
+}
+
+async function runChunkerScenario(projectRoot) {
+	console.log(JSON.stringify({section: 'chunker'}));
+	const filePath = path.join(projectRoot, 'source/daemon/lib/chunker/index.ts');
+	const source = await fs.readFile(filePath, 'utf8');
+
+	const chunker = new Chunker();
+	await chunker.initialize();
+
+	forceGc();
+	memory('chunker.before');
+
+	for (let i = 0; i < RUNS; i += 1) {
+		for (let j = 0; j < ITERATIONS; j += 1) {
+			chunker.analyzeFile(filePath, source, {
+				chunkMaxSize: 2000,
+				definitionMaxChunkSize: Number.MAX_SAFE_INTEGER,
+				refs: {
+					identifier_mode: 'symbolish',
+					max_occurrences_per_token: 0,
+					include_string_literals: false,
+				},
+			});
+		}
+		forceGc();
+		memory(`chunker.iter${i}`);
+	}
+
+	chunker.close();
+	forceGc();
+	memory('chunker.afterClose');
+}
+
+async function runIndexScenario(projectRoot, dimensions) {
+	console.log(JSON.stringify({section: 'indexing'}));
+	for (let i = 0; i < RUNS; i += 1) {
+		forceGc();
+		memory(`index.before.${i}`);
+
+		const indexer = new IndexingServiceV2(projectRoot, {
+			embeddings: new DummyEmbeddingProvider(dimensions),
+		});
+		const started = Date.now();
+		const stats = await indexer.index({force: true});
+		memory(`index.after.${i}`);
+		indexer.close();
+
+		forceGc();
+		memory(`index.afterClose.${i}`);
+		console.log(
+			JSON.stringify({
+				label: `index.stats.${i}`,
+				durationMs: Date.now() - started,
+				filesIndexed: stats.filesIndexed,
+				symbolRowsUpserted: stats.symbolRowsUpserted,
+				chunkRowsUpserted: stats.chunkRowsUpserted,
+				embeddingsComputed: stats.embeddingsComputed,
+			}),
+		);
+	}
+}
+
+if (typeof global.gc !== 'function') {
+	console.error(
+		'[memory-profile] Run with --expose-gc for reliable post-GC comparisons.',
+	);
+}
+
+const setup = await createSyntheticProject();
+console.log(
+	JSON.stringify({
+		label: 'setup',
+		...setup,
+		runs: RUNS,
+		iterations: ITERATIONS,
+	}),
+);
+
+await runChunkerScenario(setup.projectRoot);
+await runIndexScenario(setup.projectRoot, setup.dimensions);
+
+forceGc();
+memory('done');