@namzu/sdk 14.0.7 → 15.0.0

package/src/store/session/__tests__/memory.test.ts

@@ -1,402 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { TenantIsolationError } from '../../../session/errors.js'
-import type { AgentId, SessionId, TenantId, UserId } from '../../../types/ids/index.js'
-import { createUserMessage } from '../../../types/message/index.js'
-import type { ActorRef } from '../../../types/session/actor.js'
-import type { ThreadId } from '../../../types/session/ids.js'
-import type { SubSession } from '../../../types/session/sub-session.js'
-import { InMemorySessionStore } from '../memory.js'
-
-const TEST_THREAD_ID = 'thd_test' as ThreadId
-
-function userActor(tenantId: TenantId): ActorRef {
-	return { kind: 'user', userId: 'usr_a' as UserId, tenantId }
-}
-
-function agentActor(tenantId: TenantId, parent?: ActorRef): ActorRef {
-	return {
-		kind: 'agent',
-		agentId: 'agt_a' as AgentId,
-		tenantId,
-		...(parent !== undefined && { parentActor: parent }),
-	}
-}
-
-const tenantA = 'tnt_alpha' as TenantId
-const tenantB = 'tnt_beta' as TenantId
-
-async function seed(store: InMemorySessionStore, tenantId: TenantId) {
-	const project = await store.createProject({ tenantId, name: 'p1' }, tenantId)
-	const session = await store.createSession(
-		{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: userActor(tenantId) },
-		tenantId,
-	)
-	return { project, session }
-}
-
-describe('InMemorySessionStore', () => {
-	it('creates and retrieves a project + session', async () => {
-		const store = new InMemorySessionStore()
-		const { project, session } = await seed(store, tenantA)
-
-		expect(await store.getProject(project.id, tenantA)).toMatchObject({ id: project.id })
-		expect(await store.getSession(session.id, tenantA)).toMatchObject({ id: session.id })
-		expect(session.status).toBe('idle')
-		expect(session.ownerVersion).toBe(0)
-	})
-
-	it('rejects cross-tenant project reads with TenantIsolationError', async () => {
-		const store = new InMemorySessionStore()
-		const { project } = await seed(store, tenantA)
-
-		await expect(store.getProject(project.id, tenantB)).rejects.toBeInstanceOf(TenantIsolationError)
-	})
-
-	it('rejects cross-tenant session reads with TenantIsolationError', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seed(store, tenantA)
-
-		await expect(store.getSession(session.id, tenantB)).rejects.toBeInstanceOf(TenantIsolationError)
-	})
-
-	it('rejects cross-tenant updateSession (payload tenant mismatch)', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seed(store, tenantA)
-
-		// Mutate tenantId to tenantB in the payload while supplying tenantA to the
-		// call — the call authorizes via the requested tenant, but the mismatched
-		// payload must reject.
-		const forged = { ...session, tenantId: tenantB }
-		await expect(store.updateSession(forged, tenantA)).rejects.toBeInstanceOf(TenantIsolationError)
-	})
-
-	it('round-trips a session update (status + ownerVersion)', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seed(store, tenantA)
-
-		await store.updateSession({ ...session, status: 'active', ownerVersion: 1 }, tenantA)
-		const reloaded = await store.getSession(session.id, tenantA)
-		expect(reloaded).not.toBeNull()
-		expect(reloaded?.status).toBe('active')
-		expect(reloaded?.ownerVersion).toBe(1)
-	})
-
-	it('drill returns children and root-to-self ancestry', async () => {
-		const store = new InMemorySessionStore()
-		const { project, session: root } = await seed(store, tenantA)
-
-		// Create a child session + link via sub-session.
-		const child = await store.createSession(
-			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor(tenantA) },
-			tenantA,
-		)
-		const sub = await store.createSubSession(
-			{
-				parentSessionId: root.id,
-				childSessionId: child.id,
-				kind: 'agent_spawn',
-				spawnedBy: userActor(tenantA),
-			},
-			tenantA,
-		)
-
-		const view = await store.drill(root.id, tenantA)
-		expect(view).not.toBeNull()
-		expect(view?.children.map((c) => c.id)).toEqual([sub.id])
-		expect(view?.ancestry).toEqual([root.id])
-
-		const childView = await store.drill(child.id, tenantA)
-		expect(childView?.ancestry).toEqual([root.id, child.id])
-		expect(childView?.children).toEqual([])
-	})
-
-	it('loadMessages returns [] before any append and persists in insertion order', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seed(store, tenantA)
-
-		expect(await store.loadMessages(session.id, tenantA)).toEqual([])
-
-		const id1 = await store.appendMessage(session.id, createUserMessage('first'), tenantA)
-		const id2 = await store.appendMessage(session.id, createUserMessage('second'), tenantA)
-		expect(id1).not.toBe(id2)
-
-		const loaded = await store.loadMessages(session.id, tenantA)
-		expect(loaded.map((m) => m.content)).toEqual(['first', 'second'])
-	})
-
-	it('rejects cross-tenant appendMessage / loadMessages', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seed(store, tenantA)
-
-		await expect(
-			store.appendMessage(session.id, createUserMessage('x'), tenantB),
-		).rejects.toBeInstanceOf(TenantIsolationError)
-		await expect(store.loadMessages(session.id, tenantB)).rejects.toBeInstanceOf(
-			TenantIsolationError,
-		)
-	})
-
-	it('getChildren / getAncestry ignore other-tenant sub-sessions', async () => {
-		const store = new InMemorySessionStore()
-		const { project: pA, session: rootA } = await seed(store, tenantA)
-		const { project: pB, session: rootB } = await seed(store, tenantB)
-
-		const childA = await store.createSession(
-			{ threadId: TEST_THREAD_ID, projectId: pA.id, currentActor: agentActor(tenantA) },
-			tenantA,
-		)
-		await store.createSubSession(
-			{
-				parentSessionId: rootA.id,
-				childSessionId: childA.id,
-				kind: 'agent_spawn',
-				spawnedBy: userActor(tenantA),
-			},
-			tenantA,
-		)
-
-		const childB = await store.createSession(
-			{ threadId: TEST_THREAD_ID, projectId: pB.id, currentActor: agentActor(tenantB) },
-			tenantB,
-		)
-		await store.createSubSession(
-			{
-				parentSessionId: rootB.id,
-				childSessionId: childB.id,
-				kind: 'agent_spawn',
-				spawnedBy: userActor(tenantB),
-			},
-			tenantB,
-		)
-
-		// Tenant A's view must not see tenant B's sub-sessions.
-		const aChildren = await store.getChildren(rootA.id, tenantA)
-		expect(aChildren).toHaveLength(1)
-		expect(aChildren[0]?.childSessionId).toBe(childA.id)
-
-		const bChildren = await store.getChildren(rootB.id, tenantB)
-		expect(bChildren).toHaveLength(1)
-		expect(bChildren[0]?.childSessionId).toBe(childB.id)
-	})
-
-	it('drill returns null for missing sessions', async () => {
-		const store = new InMemorySessionStore()
-		const missing = 'ses_missing' as SessionId
-		expect(await store.drill(missing, tenantA)).toBeNull()
-	})
-
-	it('ancestry walker rejects cycles (corrupted store)', async () => {
-		const store = new InMemorySessionStore()
-		const { project, session: rootA } = await seed(store, tenantA)
-		const sessionB = await store.createSession(
-			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor(tenantA) },
-			tenantA,
-		)
-
-		// A→B
-		await store.createSubSession(
-			{
-				parentSessionId: rootA.id,
-				childSessionId: sessionB.id,
-				kind: 'agent_spawn',
-				spawnedBy: userActor(tenantA),
-			},
-			tenantA,
-		)
-		// B→A  (cycle — the write path does not yet enforce acyclicity;
-		//      the walker must detect corruption rather than infinite-loop.)
-		await store.createSubSession(
-			{
-				parentSessionId: sessionB.id,
-				childSessionId: rootA.id,
-				kind: 'agent_spawn',
-				spawnedBy: userActor(tenantA),
-			},
-			tenantA,
-		)
-
-		await expect(store.getAncestry(rootA.id, tenantA)).rejects.toMatchObject({
-			name: 'AncestryCycleError',
-		})
-	})
-
-	it('deleteSession is idempotent (missing session → no throw)', async () => {
-		const store = new InMemorySessionStore()
-		// Never seeded — just assert no throw.
-		await expect(store.deleteSession('ses_missing' as SessionId, tenantA)).resolves.toBeUndefined()
-	})
-
-	it('deleteSession rejects cross-tenant', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seed(store, tenantA)
-		await expect(store.deleteSession(session.id, tenantB)).rejects.toBeInstanceOf(
-			TenantIsolationError,
-		)
-	})
-
-	it('deleteSession rejects while sub-sessions are still attached (deny-by-default: no implicit cascade)', async () => {
-		const store = new InMemorySessionStore()
-		const { project, session: root } = await seed(store, tenantA)
-		const child = await store.createSession(
-			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor(tenantA) },
-			tenantA,
-		)
-		await store.createSubSession(
-			{
-				parentSessionId: root.id,
-				childSessionId: child.id,
-				kind: 'agent_spawn',
-				spawnedBy: userActor(tenantA),
-			},
-			tenantA,
-		)
-
-		await expect(store.deleteSession(root.id, tenantA)).rejects.toThrow(/attached sub-sessions/)
-	})
-
-	it('deleteSession removes session + messages + summary (after children deleted)', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seed(store, tenantA)
-		await store.appendMessage(session.id, createUserMessage('x'), tenantA)
-
-		await store.deleteSession(session.id, tenantA)
-		expect(await store.getSession(session.id, tenantA)).toBeNull()
-		expect(await store.loadMessages(session.id, tenantA)).toEqual([])
-	})
-
-	it('deleteSubSession is idempotent and rejects cross-tenant', async () => {
-		const store = new InMemorySessionStore()
-		const { project, session: root } = await seed(store, tenantA)
-		const child = await store.createSession(
-			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor(tenantA) },
-			tenantA,
-		)
-		const sub = await store.createSubSession(
-			{
-				parentSessionId: root.id,
-				childSessionId: child.id,
-				kind: 'agent_spawn',
-				spawnedBy: userActor(tenantA),
-			},
-			tenantA,
-		)
-
-		await expect(store.deleteSubSession(sub.id, tenantB)).rejects.toBeInstanceOf(
-			TenantIsolationError,
-		)
-
-		await store.deleteSubSession(sub.id, tenantA)
-		expect(await store.getSubSession(sub.id, tenantA)).toBeNull()
-		// Second call — idempotent.
-		await expect(store.deleteSubSession(sub.id, tenantA)).resolves.toBeUndefined()
-	})
-
-	it('orderChildren yields deterministic ordering by spawnedAt then id', async () => {
-		const store = new InMemorySessionStore()
-		const { project, session: root } = await seed(store, tenantA)
-
-		const c1 = await store.createSession(
-			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor(tenantA) },
-			tenantA,
-		)
-		const c2 = await store.createSession(
-			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor(tenantA) },
-			tenantA,
-		)
-
-		const s1 = await store.createSubSession(
-			{
-				parentSessionId: root.id,
-				childSessionId: c1.id,
-				kind: 'agent_spawn',
-				spawnedBy: userActor(tenantA),
-			},
-			tenantA,
-		)
-		const s2 = await store.createSubSession(
-			{
-				parentSessionId: root.id,
-				childSessionId: c2.id,
-				kind: 'agent_spawn',
-				spawnedBy: userActor(tenantA),
-			},
-			tenantA,
-		)
-
-		const children = await store.getChildren(root.id, tenantA)
-		const ids = children.map((s: SubSession) => s.id)
-		expect(new Set(ids)).toEqual(new Set([s1.id, s2.id]))
-	})
-
-	describe('listSessions(threadId, tenantId)', () => {
-		const threadX = 'thd_x' as ThreadId
-		const threadY = 'thd_y' as ThreadId
-
-		it('returns [] when the thread has no sessions', async () => {
-			const store = new InMemorySessionStore()
-			expect(await store.listSessions(threadX, tenantA)).toEqual([])
-		})
-
-		it('returns only sessions whose threadId matches, for the caller tenant', async () => {
-			const store = new InMemorySessionStore()
-			const project = await store.createProject({ tenantId: tenantA, name: 'p' }, tenantA)
-
-			const sX1 = await store.createSession(
-				{ threadId: threadX, projectId: project.id, currentActor: userActor(tenantA) },
-				tenantA,
-			)
-			const sX2 = await store.createSession(
-				{ threadId: threadX, projectId: project.id, currentActor: userActor(tenantA) },
-				tenantA,
-			)
-			// Same project, different thread — must not appear.
-			await store.createSession(
-				{ threadId: threadY, projectId: project.id, currentActor: userActor(tenantA) },
-				tenantA,
-			)
-
-			const listed = await store.listSessions(threadX, tenantA)
-			expect(listed.map((s) => s.id).sort()).toEqual([sX1.id, sX2.id].sort())
-		})
-
-		it('orders results by createdAt ascending', async () => {
-			const store = new InMemorySessionStore()
-			const project = await store.createProject({ tenantId: tenantA, name: 'p' }, tenantA)
-
-			const first = await store.createSession(
-				{ threadId: threadX, projectId: project.id, currentActor: userActor(tenantA) },
-				tenantA,
-			)
-			// Nudge clock for deterministic ordering; in-memory uses `new Date()`.
-			await new Promise((r) => setTimeout(r, 2))
-			const second = await store.createSession(
-				{ threadId: threadX, projectId: project.id, currentActor: userActor(tenantA) },
-				tenantA,
-			)
-
-			const listed = await store.listSessions(threadX, tenantA)
-			expect(listed.map((s) => s.id)).toEqual([first.id, second.id])
-		})
-
-		it('silently skips cross-tenant sessions sharing the same threadId', async () => {
-			// Thread ids are tenant-scoped in practice but nothing at the type
-			// level prevents the same string identifier being reused across
-			// tenants — the listing must filter by tenant without erroring.
-			const store = new InMemorySessionStore()
-			const pA = await store.createProject({ tenantId: tenantA, name: 'pa' }, tenantA)
-			const pB = await store.createProject({ tenantId: tenantB, name: 'pb' }, tenantB)
-
-			const own = await store.createSession(
-				{ threadId: threadX, projectId: pA.id, currentActor: userActor(tenantA) },
-				tenantA,
-			)
-			await store.createSession(
-				{ threadId: threadX, projectId: pB.id, currentActor: userActor(tenantB) },
-				tenantB,
-			)
-
-			const listed = await store.listSessions(threadX, tenantA)
-			expect(listed.map((s) => s.id)).toEqual([own.id])
-		})
-	})
-})

package/src/store/task/__tests__/an-edge-that-already-exists-is-not-news.test.ts

@@ -1,115 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-
-import type { RunId } from '../../../types/ids/index.js'
-import type { TaskEvent, TaskStore } from '../../../types/task/index.js'
-import { DiskTaskStore } from '../disk.js'
-import { InMemoryTaskStore } from '../memory.js'
-
-/**
- * The two stores disagreed about what `task.updated` means.
- *
- * `block()` is idempotent on both — it guards each array against a duplicate
- * entry — but only the disk store guarded the *announcement*. Calling
- * `block(a, b)` twice emitted two `task.updated` events from the in-memory
- * store and one from the disk store, which is the one a host runs in
- * production. So a host rebuilding a dependency graph from the stream did
- * redundant work against the reference implementation and not the durable one,
- * and a host counting events to detect change saw change where there was none.
- *
- * The disk store's behaviour is the correct one and the in-memory store now
- * matches it: an edge that already existed is not news.
- *
- * Both are driven from the same cases here, because a reference implementation
- * that disagrees with the durable one is worse than having only one — the
- * disagreement is invisible until a host swaps stores in production.
- */
-
-const RUN = 'run_edge' as RunId
-
-const dirs: string[] = []
-afterEach(async () => {
-	await Promise.all(dirs.map((d) => rm(d, { recursive: true, force: true })))
-	dirs.length = 0
-})
-
-async function diskStore(): Promise<TaskStore> {
-	const dir = await mkdtemp(join(tmpdir(), 'namzu-edge-'))
-	dirs.push(dir)
-	return new DiskTaskStore({ baseDir: dir, defaultRunId: RUN })
-}
-
-const IMPLEMENTATIONS: ReadonlyArray<readonly [string, () => Promise<TaskStore>]> = [
-	['in memory', async () => new InMemoryTaskStore()],
-	['on disk', diskStore],
-]
-
-describe.each(IMPLEMENTATIONS)('an edge that already exists is not news (%s)', (_n, build) => {
-	async function twoTasks(store: TaskStore) {
-		const blocker = await store.create({ runId: RUN, subject: 'blocker' })
-		const blocked = await store.create({ runId: RUN, subject: 'blocked' })
-		return { blocker, blocked }
-	}
-
-	function recordUpdates(store: TaskStore): TaskEvent[] {
-		const seen: TaskEvent[] = []
-		store.on((event) => {
-			if (event.type === 'task.updated') seen.push(event)
-		})
-		return seen
-	}
-
-	it('announces both ends when the edge is written', async () => {
-		// The control: without it, "no second announcement" could be passing
-		// because nothing announces at all.
-		const store = await build()
-		const { blocker, blocked } = await twoTasks(store)
-		const seen = recordUpdates(store)
-
-		await store.block(blocker.id, blocked.id)
-
-		expect(seen.map((e) => e.taskId)).toEqual([blocker.id, blocked.id])
-	})
-
-	it('says nothing the second time', async () => {
-		const store = await build()
-		const { blocker, blocked } = await twoTasks(store)
-		await store.block(blocker.id, blocked.id)
-		const seen = recordUpdates(store)
-
-		await store.block(blocker.id, blocked.id)
-
-		expect(seen).toEqual([])
-	})
-
-	it('still records the edge exactly once after a repeated call', async () => {
-		// Suppressing the event must not become suppressing the write, and the
-		// arrays must not grow a duplicate.
-		const store = await build()
-		const { blocker, blocked } = await twoTasks(store)
-
-		await store.block(blocker.id, blocked.id)
-		await store.block(blocker.id, blocked.id)
-
-		expect((await store.get(blocker.id))?.blocks).toEqual([blocked.id])
-		expect((await store.get(blocked.id))?.blockedBy).toEqual([blocker.id])
-	})
-
-	it('announces a repair when only one side of the edge was missing', async () => {
-		// A half-edge is the case the early return must not swallow: one array
-		// already names the other and its counterpart does not. Both ends are
-		// one fact, so both are announced even though only one array grew.
-		const store = await build()
-		const { blocker, blocked } = await twoTasks(store)
-		await store.block(blocker.id, blocked.id)
-		// Reverse direction: `blocked` has not yet been recorded as blocking
-		// `blocker`, so this is a new edge, not the existing one.
-		const seen = recordUpdates(store)
-
-		await store.block(blocked.id, blocker.id)
-
-		expect(seen.map((e) => e.taskId)).toEqual([blocked.id, blocker.id])
-	})
-})

package/src/store/task/__tests__/disk-concurrency.test.ts

@@ -1,118 +0,0 @@
-import { mkdtempSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-import type { RunId } from '../../../types/ids/index.js'
-import { generateRunId } from '../../../utils/id.js'
-import { DiskTaskStore } from '../disk.js'
-
-describe('DiskTaskStore — concurrency regressions', () => {
-	let baseDir: string
-	let runId: RunId
-	let store: DiskTaskStore
-
-	beforeEach(() => {
-		baseDir = mkdtempSync(join(tmpdir(), 'namzu-task-concurrency-'))
-		runId = generateRunId()
-		store = new DiskTaskStore({ baseDir, defaultRunId: runId })
-	})
-
-	afterEach(() => {
-		rmSync(baseDir, { recursive: true, force: true })
-	})
-
-	it('does not deadlock when two deletes race on mutually-referencing tasks', async () => {
-		const a = await store.create({ runId, subject: 'A' })
-		const b = await store.create({ runId, subject: 'B' })
-
-		// Establish bidirectional edge: A blocks B AND B blocks A.
-		// (Nonsensical semantically, but the store allows it and the lock logic
-		// must not deadlock.)
-		await store.block(a.id, b.id)
-		await store.block(b.id, a.id)
-
-		// Race the two deletes. The pre-fix implementation (lock this → iterate
-		// related → lock each) could acquire A→B from one call and B→A from the
-		// other, deadlocking. withLocks() sorts IDs canonically so both calls
-		// acquire [A, B] in the same order.
-		const withTimeout = <T>(p: Promise<T>, ms: number): Promise<T> =>
-			Promise.race([
-				p,
-				new Promise<never>((_resolve, reject) =>
-					setTimeout(() => reject(new Error('timeout — likely deadlocked')), ms),
-				),
-			])
-
-		const [resA, resB] = await withTimeout(
-			Promise.all([store.delete(a.id), store.delete(b.id)]),
-			2000,
-		)
-		expect(resA).toBe(true)
-		expect(resB).toBe(true)
-		expect(await store.get(a.id)).toBeUndefined()
-		expect(await store.get(b.id)).toBeUndefined()
-	})
-
-	it('serializes concurrent same-ID updates (withLock race regression)', async () => {
-		const task = await store.create({ runId, subject: 'shared' })
-
-		// update()'s metadata merge does `{ ...task.metadata, ...updates.metadata }`
-		// inside withLock. If withLock serializes correctly, every update's key
-		// survives into the final metadata (each sees the latest merged state).
-		// If withLock had the race bug, two concurrent updates would both read
-		// the SAME snapshot, each add their one key, and one update's key would
-		// be overwritten when the second committed — yielding < N keys in the
-		// final metadata.
-		const n = 20
-		await Promise.all(
-			Array.from({ length: n }, (_v, i) =>
-				store.update(task.id, { metadata: { [`k${i}`]: true } }),
-			),
-		)
-
-		const final = await store.get(task.id)
-		const keys = Object.keys(final?.metadata ?? {})
-		expect(keys).toHaveLength(n)
-		for (let i = 0; i < n; i++) {
-			expect(final?.metadata?.[`k${i}`]).toBe(true)
-		}
-	})
-
-	it('establishes bidirectional edge atomically under create()', async () => {
-		const blocker = await store.create({ runId, subject: 'blocker' })
-
-		// Race: create a child with blockedBy=[blocker] while concurrently
-		// deleting the blocker. Either outcome is acceptable (child created
-		// and blocker still present in its blocks list, OR blocker gone and
-		// child created with dangling reference), but we must NEVER see
-		// blocker still present WITHOUT having child in its blocks list.
-		const tasks = await Promise.all([
-			store.create({ runId, subject: 'child', blockedBy: [blocker.id] }),
-			// No delete here — keep the create edge test focused. The point is
-			// that after create() resolves, the blocker's blocks list contains
-			// the new task ID atomically.
-		])
-		const child = tasks[0]
-
-		const blockerAfter = await store.get(blocker.id)
-		expect(blockerAfter).toBeDefined()
-		expect(blockerAfter?.blocks).toContain(child.id)
-		expect(child.blockedBy).toContain(blocker.id)
-	})
-
-	it('block() skips gracefully when one task disappeared before lock acquired', async () => {
-		const a = await store.create({ runId, subject: 'A' })
-		const b = await store.create({ runId, subject: 'B' })
-
-		// Delete B, then try to block a → b. The findTask pre-check passes for a
-		// but fails for b, so block() returns early (silent no-op per existing
-		// contract).
-		await store.delete(b.id)
-
-		// block() should not throw and A's blocks list should remain empty.
-		await store.block(a.id, b.id)
-
-		const aAfter = await store.get(a.id)
-		expect(aAfter?.blocks).not.toContain(b.id)
-	})
-})