@wovin/core 0.0.0-ciao-mobx-955482e8

package/src/test/perf/query.1m.perf.test.ts

@@ -0,0 +1,94 @@
+/**
+ * 1M applog stress test — static query + live query incremental update.
+ */
+import { describe, it, expect } from 'vitest'
+import type { Applog, ApplogForInsert } from '../../applog/datom-types.ts'
+import { ThreadInMemory } from '../../thread/writeable.ts'
+import { liveQuery, query } from '../../query/basic.ts'
+
+const AGENT = 'stress-agent'
+
+function generateLarge(entityCount: number): Applog[] {
+	const inputs: ApplogForInsert[] = []
+	const types = ['block', 'page', 'image', 'link', 'heading']
+	let ts = Date.now() - entityCount * 6
+
+	for (let i = 0; i < entityCount; i++) {
+		const en = `e${i}`
+		const nextTs = () => new Date(ts++).toISOString()
+		inputs.push({ en, at: 'entity/name', vl: `Entity ${i}`, ag: AGENT, ts: nextTs() } as any)
+		inputs.push({ en, at: 'entity/type', vl: types[i % types.length], ag: AGENT, ts: nextTs() } as any)
+		inputs.push({ en, at: 'entity/status', vl: i % 3 === 0 ? 'active' : 'draft', ag: AGENT, ts: nextTs() } as any)
+		if (i % 2 === 0) {
+			inputs.push({ en, at: 'entity/content', vl: `Content ${i}`, ag: AGENT, ts: nextTs() } as any)
+		}
+		if (i % 4 === 0) {
+			inputs.push({ en, at: 'relation/parent', vl: `e${Math.floor(i / 4)}`, ag: AGENT, ts: nextTs() } as any)
+		}
+	}
+
+	// Already sorted by construction (ts is monotonically increasing)
+	return inputs.map(i => ({ pv: null, ...i })) as Applog[]
+}
+
+describe('1M applog stress test', () => {
+	let db: ReturnType<typeof ThreadInMemory.fromArray>
+
+	it('generate ~1M applogs + load', () => {
+		const start = performance.now()
+		const dataset = generateLarge(200_000)
+		const genTime = performance.now() - start
+
+		const start2 = performance.now()
+		db = ThreadInMemory.fromArray(dataset, 'stress-1m')
+		const loadTime = performance.now() - start2
+
+		console.log(`\n  [1M] Generated ${dataset.length.toLocaleString()} applogs in ${genTime.toFixed(0)}ms`)
+		console.log(`  [1M] ThreadInMemory.fromArray: ${loadTime.toFixed(0)}ms`)
+		console.log(`  [1M] Total thread size: ${db.size.toLocaleString()}`)
+		expect(db.size).toBeGreaterThan(700_000)
+	})
+
+	it('static query() — single step on ~750K applogs', () => {
+		const start = performance.now()
+		const result = query(db, [{ at: 'entity/type', vl: 'block' }])
+		const elapsed = performance.now() - start
+
+		console.log(`  [1M] query() single-step: ${elapsed.toFixed(1)}ms → ${result.nodes.length.toLocaleString()} results`)
+		expect(result.nodes.length).toBe(40_000) // 200K / 5 types
+	})
+
+	it('liveQuery() — setup + single insert propagation on ~750K applogs', () => {
+		// Setup
+		const setupStart = performance.now()
+		const live = liveQuery(db, [{ at: 'entity/type', vl: 'block' }])
+		const setupTime = performance.now() - setupStart
+		const initialCount = live.nodes.length
+
+		console.log(`  [1M] liveQuery() setup: ${setupTime.toFixed(1)}ms → ${initialCount.toLocaleString()} initial results`)
+
+		// Insert one matching applog and measure propagation
+		let eventTime: number | null = null
+		live.subscribe(() => {
+			eventTime = performance.now()
+		})
+
+		const insertStart = performance.now()
+		db.insert([{
+			en: 'new-entity-1m',
+			at: 'entity/type',
+			vl: 'block',
+			ag: AGENT,
+		}])
+		const totalTime = performance.now() - insertStart
+		const subscribeDelta = eventTime ? eventTime - insertStart : null
+
+		const newCount = live.nodes.length
+		console.log(`  [1M] Insert→result updated: ${totalTime.toFixed(3)}ms`)
+		console.log(`  [1M] Insert→subscribe fired: ${subscribeDelta?.toFixed(3) ?? 'N/A'}ms`)
+		console.log(`  [1M] Nodes: ${initialCount.toLocaleString()} → ${newCount.toLocaleString()}`)
+
+		expect(newCount).toBe(initialCount + 1)
+		live.dispose()
+	})
+}, { timeout: 120_000 })

package/src/test/perf/query.perf.test.ts

@@ -0,0 +1,389 @@
+/**
+ * Performance benchmarks for the query engine.
+ *
+ * Run with: npx vitest run src/query/query.perf.test.ts
+ *
+ * Purpose: compare performance between MobX-based (main) and push-based (ciao-mobx)
+ * implementations. Each benchmark uses performance.now() and reports median/p95
+ * across multiple iterations.
+ */
+import { describe, it, expect } from 'vitest'
+import { sortApplogsByTs } from '../../applog/applog-utils.ts'
+import type { Applog, ApplogForInsert } from '../../applog/datom-types.ts'
+import { ThreadInMemory } from '../../thread/writeable.ts'
+import { rollingFilter } from '../../thread/filters.ts'
+import { liveQuery, query, lastWriteWins, withoutDeleted } from '../../query/basic.ts'
+
+// ─── Benchmark Helpers ──────────────────────────────────────────
+
+function benchmarkSync(name: string, fn: () => void, iterations = 100): { median: number; p95: number; min: number } {
+	// Warmup
+	for (let i = 0; i < 3; i++) fn()
+
+	const times: number[] = []
+	for (let i = 0; i < iterations; i++) {
+		const start = performance.now()
+		fn()
+		times.push(performance.now() - start)
+	}
+	times.sort((a, b) => a - b)
+	const median = times[Math.floor(times.length / 2)]
+	const p95 = times[Math.floor(times.length * 0.95)]
+	const min = times[0]
+	console.log(`  [PERF] ${name}: median=${median.toFixed(3)}ms  p95=${p95.toFixed(3)}ms  min=${min.toFixed(3)}ms  (${iterations} runs)`)
+	return { median, p95, min }
+}
+
+// ─── Data Generation ────────────────────────────────────────────
+
+const ENTITY_COUNT = 500
+const TYPES = ['block', 'page', 'image', 'link', 'heading', 'list', 'table']
+const STATUSES = ['draft', 'published', 'archived', 'deleted']
+const AGENT = 'perf-agent'
+
+function generateDataset(entityCount: number): Applog[] {
+	const inputs: ApplogForInsert[] = []
+	let tsCounter = Date.now() - entityCount * 10 // stagger timestamps
+
+	for (let i = 0; i < entityCount; i++) {
+		const en = `e${i}`
+		const ts = new Date(tsCounter).toISOString()
+		tsCounter += 5
+
+		// entity/name
+		inputs.push({ en, at: 'entity/name', vl: `Entity ${i}`, ag: AGENT })
+		// entity/type
+		inputs.push({ en, at: 'entity/type', vl: TYPES[i % TYPES.length], ag: AGENT })
+		// entity/status
+		inputs.push({ en, at: 'entity/status', vl: STATUSES[i % STATUSES.length], ag: AGENT })
+
+		// relation/parent — ~80% of entities have a parent
+		if (i > 0 && i % 5 !== 0) {
+			const parentIdx = Math.floor(i / 5) * 5 // parent is the "section head"
+			inputs.push({ en, at: 'relation/parent', vl: `e${parentIdx}`, ag: AGENT })
+		}
+
+		// Some entities get extra attributes to increase log count
+		if (i % 3 === 0) {
+			inputs.push({ en, at: 'entity/content', vl: `Content for entity ${i} with some text to simulate real data`, ag: AGENT })
+		}
+		if (i % 7 === 0) {
+			inputs.push({ en, at: 'entity/created', vl: new Date(tsCounter - 1000).toISOString(), ag: AGENT })
+		}
+	}
+
+	// Add some deletions (~5%)
+	for (let i = 0; i < entityCount; i++) {
+		if (i % 20 === 0) {
+			inputs.push({ en: `e${i}`, at: 'isDeleted', vl: true, ag: AGENT })
+		}
+	}
+
+	// Add duplicate-attribute writes (for lastWriteWins testing) — ~10% of entities get a second status
+	for (let i = 0; i < entityCount; i++) {
+		if (i % 10 === 0) {
+			inputs.push({ en: `e${i}`, at: 'entity/status', vl: 'updated', ag: AGENT })
+		}
+	}
+
+	const logs = inputs.map(input => ({
+		ts: new Date(tsCounter++).toISOString(),
+		pv: null,
+		ag: input.ag || AGENT,
+		...input,
+	})) as Applog[]
+	sortApplogsByTs(logs)
+	return logs
+}
+
+// ─── Datasets ───────────────────────────────────────────────────
+
+const dataset500 = generateDataset(500)
+const dataset2000 = generateDataset(2000)
+
+console.log(`\n[PERF] Dataset sizes: 500-entity=${dataset500.length} applogs, 2000-entity=${dataset2000.length} applogs\n`)
+
+// ═════════════════════════════════════════════════════════════════
+// BENCHMARKS
+// ═════════════════════════════════════════════════════════════════
+
+describe('query() performance', () => {
+	it('single-step: find all entities by type', () => {
+		const db = ThreadInMemory.fromArray([...dataset2000], 'perf-single-step')
+		const result = benchmarkSync('query single-step (2K entities)', () => {
+			query(db, [{ at: 'entity/type', vl: 'block' }])
+		}, 200)
+		// Sanity: should find ~1/7 of entities
+		const check = query(db, [{ at: 'entity/type', vl: 'block' }])
+		expect(check.nodes.length).toBeGreaterThan(100)
+		expect(result.median).toBeLessThan(500) // generous upper bound
+	})
+
+	it('multi-step: two-step variable binding', () => {
+		const db = ThreadInMemory.fromArray([...dataset2000], 'perf-multi-step')
+		const result = benchmarkSync('query multi-step (2K entities)', () => {
+			query(db, [
+				{ en: '?id', at: 'entity/type', vl: 'block' },
+				{ en: '?id', at: 'entity/status', vl: '?status' },
+			])
+		}, 100)
+		const check = query(db, [
+			{ en: '?id', at: 'entity/type', vl: 'block' },
+			{ en: '?id', at: 'entity/status', vl: '?status' },
+		])
+		expect(check.records.length).toBeGreaterThan(100)
+		expect(result.median).toBeLessThan(1000)
+	})
+
+	it('three-step: entity -> parent -> parent name', () => {
+		const db = ThreadInMemory.fromArray([...dataset500], 'perf-three-step')
+		const result = benchmarkSync('query three-step (500 entities)', () => {
+			query(db, [
+				{ en: '?childId', at: 'entity/type', vl: 'block' },
+				{ en: '?childId', at: 'relation/parent', vl: '?parentId' },
+				{ en: '?parentId', at: 'entity/name', vl: '?parentName' },
+			])
+		}, 50)
+		expect(result.median).toBeLessThan(2000)
+	})
+
+	it('memoization: same query 1000x', () => {
+		const db = ThreadInMemory.fromArray([...dataset2000], 'perf-memo')
+		// First call populates cache
+		query(db, [{ at: 'entity/type', vl: 'block' }])
+
+		const result = benchmarkSync('query memoized cache hit (2K entities)', () => {
+			query(db, [{ at: 'entity/type', vl: 'block' }])
+		}, 1000)
+		// Cache hits should be sub-millisecond
+		expect(result.median).toBeLessThan(1)
+	})
+})
+
+describe('liveQuery() performance', () => {
+	it('setup cost: create live query and get initial results', () => {
+		const result = benchmarkSync('liveQuery setup (2K entities)', () => {
+			const db = ThreadInMemory.fromArray([...dataset2000], 'perf-live-setup')
+			const lq = liveQuery(db, [{ en: '?id', at: 'entity/type', vl: '?type' }])
+			expect(lq.nodes.length).toBeGreaterThan(0)
+			lq.dispose()
+		}, 50)
+		expect(result.median).toBeLessThan(2000)
+	})
+
+	it('incremental update: insert 1 applog into live query', () => {
+		const db = ThreadInMemory.fromArray([...dataset2000], 'perf-live-incr')
+		const lq = liveQuery(db, [{ at: 'entity/type', vl: 'block' }])
+		const initialCount = lq.nodes.length
+
+		let insertCounter = 0
+		const result = benchmarkSync('liveQuery incremental insert (2K entities)', () => {
+			db.insert([{
+				en: `new-entity-${insertCounter++}`,
+				at: 'entity/type',
+				vl: 'block',
+				ag: AGENT,
+			}])
+		}, 200)
+
+		expect(lq.nodes.length).toBeGreaterThan(initialCount)
+		lq.dispose()
+		// Incremental should be fast
+		expect(result.median).toBeLessThan(50)
+	})
+
+	it('incremental update: insert into multi-step live query', () => {
+		const db = ThreadInMemory.fromArray([...dataset500], 'perf-live-multi-incr')
+		const lq = liveQuery(db, [
+			{ en: '?id', at: 'entity/type', vl: 'block' },
+			{ en: '?id', at: 'entity/status', vl: '?status' },
+		])
+		const initialCount = lq.nodes.length
+
+		let insertCounter = 0
+		const result = benchmarkSync('liveQuery multi-step incremental (500 entities)', () => {
+			const en = `new-multi-${insertCounter++}`
+			db.insert([
+				{ en, at: 'entity/type', vl: 'block', ag: AGENT },
+				{ en, at: 'entity/status', vl: 'draft', ag: AGENT },
+			])
+		}, 100)
+
+		expect(lq.nodes.length).toBeGreaterThan(initialCount)
+		lq.dispose()
+		expect(result.median).toBeLessThan(100)
+	})
+
+	it('subscribe event delivery latency', () => {
+		const db = ThreadInMemory.fromArray([...dataset2000], 'perf-live-subscribe')
+		const lq = liveQuery(db, [{ at: 'entity/type', vl: 'block' }])
+		const times: number[] = []
+
+		lq.subscribe(() => {
+			times.push(performance.now())
+		})
+
+		let insertCounter = 0
+		for (let i = 0; i < 100; i++) {
+			const start = performance.now()
+			db.insert([{
+				en: `sub-entity-${insertCounter++}`,
+				at: 'entity/type',
+				vl: 'block',
+				ag: AGENT,
+			}])
+			// times array is populated synchronously by the subscribe callback
+		}
+
+		expect(times).toHaveLength(100)
+		lq.dispose()
+		console.log(`  [PERF] liveQuery subscribe: 100 events delivered synchronously`)
+	})
+})
+
+describe('withoutDeleted() performance', () => {
+	it('initial filtering on large thread', () => {
+		const result = benchmarkSync('withoutDeleted initial (2K entities)', () => {
+			const db = ThreadInMemory.fromArray([...dataset2000], 'perf-wod')
+			const filtered = withoutDeleted(db)
+			expect(filtered.applogs.length).toBeLessThan(dataset2000.length)
+		}, 50)
+		expect(result.median).toBeLessThan(1000)
+	})
+
+	it('incremental: insert deletion into large thread', () => {
+		const db = ThreadInMemory.fromArray([...dataset2000], 'perf-wod-incr')
+		const filtered = withoutDeleted(db)
+		const initialCount = filtered.applogs.length
+
+		let deleteCounter = 0
+		const result = benchmarkSync('withoutDeleted incremental delete (2K entities)', () => {
+			db.insert([{
+				en: `e${100 + deleteCounter++}`, // delete existing entities
+				at: 'isDeleted',
+				vl: true,
+				ag: AGENT,
+			}])
+		}, 100)
+
+		expect(filtered.applogs.length).toBeLessThanOrEqual(initialCount)
+		expect(result.median).toBeLessThan(50)
+	})
+})
+
+describe('lastWriteWins() performance', () => {
+	it('initial deduplication on large thread', () => {
+		const result = benchmarkSync('lastWriteWins initial (2K entities)', () => {
+			const db = ThreadInMemory.fromArray([...dataset2000], 'perf-lww')
+			const lww = lastWriteWins(db)
+			expect(lww.applogs.length).toBeLessThan(dataset2000.length)
+		}, 50)
+		expect(result.median).toBeLessThan(1000)
+	})
+
+	it('incremental: insert overwriting attribute', () => {
+		const db = ThreadInMemory.fromArray([...dataset2000], 'perf-lww-incr')
+		const lww = lastWriteWins(db)
+		const initialCount = lww.applogs.length
+
+		let updateCounter = 0
+		const result = benchmarkSync('lastWriteWins incremental update (2K entities)', () => {
+			db.insert([{
+				en: `e${updateCounter++ % 500}`,
+				at: 'entity/status',
+				vl: `updated-${updateCounter}`,
+				ag: AGENT,
+			}])
+		}, 200)
+
+		// Count should stay roughly the same (overwrites, not additions)
+		expect(lww.applogs.length).toBeLessThanOrEqual(initialCount + 200) // some might be new en+at combos
+		expect(result.median).toBeLessThan(50)
+	})
+})
+
+describe('rollingFilter() performance', () => {
+	it('initial filter on large thread', () => {
+		const result = benchmarkSync('rollingFilter initial (2K entities)', () => {
+			const db = ThreadInMemory.fromArray([...dataset2000], 'perf-rf')
+			const filtered = rollingFilter(db, { at: 'entity/type', vl: 'block' })
+			expect(filtered.applogs.length).toBeGreaterThan(0)
+		}, 50)
+		expect(result.median).toBeLessThan(500)
+	})
+
+	it('incremental: insert matching applog', () => {
+		const db = ThreadInMemory.fromArray([...dataset2000], 'perf-rf-incr')
+		const filtered = rollingFilter(db, { at: 'entity/type', vl: 'block' })
+		const initialCount = filtered.applogs.length
+
+		let insertCounter = 0
+		const result = benchmarkSync('rollingFilter incremental insert (2K entities)', () => {
+			db.insert([{
+				en: `rf-entity-${insertCounter++}`,
+				at: 'entity/type',
+				vl: 'block',
+				ag: AGENT,
+			}])
+		}, 200)
+
+		expect(filtered.applogs.length).toBeGreaterThan(initialCount)
+		expect(result.median).toBeLessThan(50)
+	})
+
+	it('incremental: insert non-matching applog (should be fast no-op)', () => {
+		const db = ThreadInMemory.fromArray([...dataset2000], 'perf-rf-nomatch')
+		const filtered = rollingFilter(db, { at: 'entity/type', vl: 'block' })
+		const initialCount = filtered.applogs.length
+
+		let insertCounter = 0
+		const result = benchmarkSync('rollingFilter non-matching insert (2K entities)', () => {
+			db.insert([{
+				en: `rf-nomatch-${insertCounter++}`,
+				at: 'entity/type',
+				vl: 'image',
+				ag: AGENT,
+			}])
+		}, 200)
+
+		expect(filtered.applogs.length).toBe(initialCount)
+		expect(result.median).toBeLessThan(50)
+	})
+})
+
+describe('combined pipeline performance', () => {
+	it('full pipeline: withoutDeleted -> lastWriteWins -> query', () => {
+		const result = benchmarkSync('full pipeline (500 entities)', () => {
+			const db = ThreadInMemory.fromArray([...dataset500], 'perf-pipeline')
+			const noDeleted = withoutDeleted(db)
+			const lww = lastWriteWins(noDeleted)
+			const qr = query(lww, [
+				{ en: '?id', at: 'entity/type', vl: 'block' },
+				{ en: '?id', at: 'entity/name', vl: '?name' },
+			])
+			expect(qr.records.length).toBeGreaterThan(0)
+		}, 30)
+		expect(result.median).toBeLessThan(3000)
+	})
+
+	it('full pipeline incremental: insert into active pipeline', () => {
+		const db = ThreadInMemory.fromArray([...dataset500], 'perf-pipeline-incr')
+		const noDeleted = withoutDeleted(db)
+		const lww = lastWriteWins(noDeleted)
+		const lq = liveQuery(lww, [{ en: '?id', at: 'entity/type', vl: 'block' }])
+		const initialCount = lq.nodes.length
+
+		let insertCounter = 0
+		const result = benchmarkSync('full pipeline incremental (500 entities)', () => {
+			db.insert([
+				{ en: `pipe-${insertCounter}`, at: 'entity/type', vl: 'block', ag: AGENT },
+				{ en: `pipe-${insertCounter}`, at: 'entity/name', vl: `New ${insertCounter}`, ag: AGENT },
+			])
+			insertCounter++
+		}, 100)
+
+		expect(lq.nodes.length).toBeGreaterThan(initialCount)
+		lq.dispose()
+		expect(result.median).toBeLessThan(100)
+	})
+})

package/src/test/perf/query.realdata.perf.test.ts

@@ -0,0 +1,175 @@
+/**
+ * Real-data performance test — uses exported applogs from a real note3 thread (47K applogs).
+ * Tests real query patterns from note3's reactive.ts.
+ */
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'fs'
+import type { Applog } from '../../applog/datom-types.ts'
+import { sortApplogsByTs } from '../../applog/applog-utils.ts'
+import { ThreadInMemory } from '../../thread/writeable.ts'
+import { liveQuery, liveQueryNot, query, queryNot, queryAndMap, lastWriteWins, withoutDeleted } from '../../query/basic.ts'
+
+// ─── Load real data ─────────────────────────────────────────────
+
+const lines = readFileSync('/repo/tmp/real-applogs.jsonl', 'utf-8').trim().split('\n')
+const raw = lines.map(l => JSON.parse(l)) as Applog[]
+sortApplogsByTs(raw)
+console.log(`\n  [REAL] Loaded ${raw.length.toLocaleString()} real applogs from note3 thread (sorted)`)
+
+// Check what attributes exist
+const attrCounts = new Map<string, number>()
+for (const log of raw) {
+	attrCounts.set(log.at, (attrCounts.get(log.at) || 0) + 1)
+}
+const top = [...attrCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 15)
+console.log(`  [REAL] Top attributes:`, top.map(([at, n]) => `${at}(${n})`).join(', '))
+
+describe('real note3 data — query performance', () => {
+	let db: ThreadInMemory
+	let lww: ReturnType<typeof lastWriteWins>
+	let clean: ReturnType<typeof withoutDeleted>
+
+	it('setup: load + lastWriteWins + withoutDeleted', () => {
+		const t0 = performance.now()
+		db = ThreadInMemory.fromArray([...raw], 'real-note3')
+		const loadTime = performance.now() - t0
+
+		const t1 = performance.now()
+		lww = lastWriteWins(db)
+		const lwwTime = performance.now() - t1
+
+		const t2 = performance.now()
+		clean = withoutDeleted(lww)
+		const wodTime = performance.now() - t2
+
+		console.log(`  [REAL] Load: ${loadTime.toFixed(1)}ms (${db.size.toLocaleString()} applogs)`)
+		console.log(`  [REAL] lastWriteWins: ${lwwTime.toFixed(1)}ms (${db.size.toLocaleString()} → ${lww.size.toLocaleString()})`)
+		console.log(`  [REAL] withoutDeleted: ${wodTime.toFixed(1)}ms (${lww.size.toLocaleString()} → ${clean.size.toLocaleString()})`)
+	})
+
+	// ── Real query 1: all blocks ───────────────────────────────
+	it('all blocks with content (1-step)', () => {
+		const t0 = performance.now()
+		const blocks = query(clean, [
+			{ en: '?blockID', at: 'block/content' },
+		])
+		const elapsed = performance.now() - t0
+		console.log(`  [REAL] all blocks: ${elapsed.toFixed(3)}ms → ${blocks.size} blocks`)
+	})
+
+	// ── Real query 2: useParents (2-step) ──────────────────────
+	it('useParents (2-step): find parent of a block', () => {
+		// Find a block that actually has a parent
+		const relations = query(clean, [
+			{ en: '?relID', at: 'relation/block', vl: '?blockID' },
+			{ en: '?relID', at: 'relation/childOf', vl: '?parentID' },
+		])
+		console.log(`  [REAL] total relations: ${relations.size}`)
+
+		if (relations.size > 0) {
+			const blockID = relations.records[0].blockID
+			const t0 = performance.now()
+			const parents = queryAndMap(clean, [
+				{ en: '?relID', at: 'relation/block', vl: blockID },
+				{ en: '?relID', at: 'relation/childOf', vl: '?parentID' },
+			], 'parentID')
+			const elapsed = performance.now() - t0
+			console.log(`  [REAL] useParents (block=${blockID}): ${elapsed.toFixed(3)}ms → ${(parents as any[]).length} parents`)
+		}
+	})
+
+	// ── Real query 3: useRoots (1-step + queryNot) ─────────────
+	it('useRoots: all blocks, then queryNot(has parent)', () => {
+		const t0 = performance.now()
+		const blocks = query(clean, [
+			{ en: '?blockID', at: 'block/content' },
+		])
+		const queryTime = performance.now() - t0
+
+		const t1 = performance.now()
+		// Single-step suffices: relation entities are deleted when unparenting,
+		// so any relation/block pointing to blockID means it has a parent.
+		const roots = queryNot(clean, blocks, { en: '?relID', at: 'relation/block', vl: '?blockID' })
+		const notTime = performance.now() - t1
+
+		console.log(`  [REAL] useRoots — query blocks: ${queryTime.toFixed(3)}ms → ${blocks.size} blocks`)
+		console.log(`  [REAL] useRoots — queryNot(parent): ${notTime.toFixed(3)}ms → ${roots.size} roots (of ${blocks.size} blocks)`)
+
+		// Debug: if roots == 0 or roots == blocks, investigate
+		if (roots.size === 0 || roots.size === blocks.size) {
+			// Check how many blocks actually have relations
+			const blockIDs = blocks.records.map(r => r.blockID) as string[]
+			const relBlocks = query(clean, [
+				{ en: '?relID', at: 'relation/block', vl: blockIDs.slice(0, 5) },
+			])
+			console.log(`  [REAL] DEBUG: first 5 blocks have ${relBlocks.size} relations`)
+
+			// Check what relation/childOf values exist
+			const childOfs = query(clean, [{ at: 'relation/childOf' }])
+			console.log(`  [REAL] DEBUG: total relation/childOf applogs: ${childOfs.size}`)
+			if (childOfs.size > 0) {
+				const sample = childOfs.nodes.slice(0, 3).map(n => `en=${n.logsOfThisNode.applogs[0]?.en} vl=${n.logsOfThisNode.applogs[0]?.vl}`)
+				console.log(`  [REAL] DEBUG: sample childOf:`, sample)
+			}
+		}
+	})
+
+	// ── Real query 4: 3-step query ────────────────────────────
+	it('3-step: block → relation → parent name', () => {
+		const t0 = performance.now()
+		const result = query(clean, [
+			{ en: '?blockID', at: 'block/content', vl: '?content' },
+			{ en: '?relID', at: 'relation/block', vl: '?blockID' },
+			{ en: '?relID', at: 'relation/childOf', vl: '?parentID' },
+		])
+		const elapsed = performance.now() - t0
+		console.log(`  [REAL] 3-step (block→relation→parent): ${elapsed.toFixed(3)}ms → ${result.size} results`)
+	})
+
+	// ── Live: useRoots reactive + insert ──────────────────────
+	it('liveQuery useRoots + insert', () => {
+		const t0 = performance.now()
+		const liveBlocks = liveQuery(clean, [
+			{ en: '?blockID', at: 'block/content' },
+		])
+		const setupTime = performance.now() - t0
+		const initialBlocks = liveBlocks.size
+
+		const t1 = performance.now()
+		// Single-step: relation entities are deleted on unparent (see useRoots comment above)
+		const liveRoots = liveQueryNot(clean, liveBlocks, { en: '?relID', at: 'relation/block', vl: '?blockID' })
+		const notSetupTime = performance.now() - t1
+		const initialRoots = liveRoots.size
+
+		console.log(`  [REAL] liveQuery blocks setup: ${setupTime.toFixed(1)}ms → ${initialBlocks} blocks`)
+		console.log(`  [REAL] liveQueryNot roots setup: ${notSetupTime.toFixed(1)}ms → ${initialRoots} roots`)
+
+		// Insert a new block
+		const t2 = performance.now()
+		db.insert([{ en: 'new-block-perf', at: 'block/content', vl: 'Perf test block', ag: 'perf-test' }])
+		const insertBlockTime = performance.now() - t2
+
+		console.log(`  [REAL] Insert block: ${insertBlockTime.toFixed(3)}ms`)
+		console.log(`  [REAL]   Blocks: ${initialBlocks} → ${liveBlocks.size}`)
+		console.log(`  [REAL]   Roots: ${initialRoots} → ${liveRoots.size}`)
+
+		// Insert a relation for the new block (should remove from roots)
+		// Note: vl must be a real parent ID (string), not null.
+		// queryNot treats each pattern independently — step 1 ({relation/block, vl: ?blockID})
+		// does the actual exclusion. vl:null in step 2 is a no-op (matches only literal null).
+		const rootsBefore = liveRoots.size
+		const t3 = performance.now()
+		db.insert([
+			{ en: 'rel-perf-1', at: 'relation/block', vl: 'new-block-perf', ag: 'perf-test' },
+			{ en: 'rel-perf-1', at: 'relation/childOf', vl: 'some-parent-id', ag: 'perf-test' },
+		])
+		const insertRelTime = performance.now() - t3
+
+		console.log(`  [REAL] Insert parent relation: ${insertRelTime.toFixed(3)}ms`)
+		console.log(`  [REAL]   Roots: ${rootsBefore} → ${liveRoots.size}`)
+		expect(liveRoots.size).toBe(rootsBefore - 1)
+
+		liveRoots.dispose()
+		liveBlocks.dispose()
+	})
+}, { timeout: 60_000 })