@selvajs/platform 0.14.2 → 0.15.0-beta.1

package/src/testing/suites/shareLinkStoreSuite.ts

@@ -1,203 +0,0 @@
-/**
- * Adapter conformance suite for IShareLinkStore.
- *
- * Covers create + get + list, hash lookup, revocation semantics, and the
- * atomic check-and-increment that enforces the per-link cap. Adapters that
- * use real DB tables seed a parent definition through `createScope`; the
- * local adapter can stub.
- */
-
-import { describe, it, expect } from 'vitest';
-import type { IShareLinkStore } from '../../shareLinks/interface.js';
-import type { ShareLink } from '../../shareLinks/types.js';
-import { makeCtx, makeUuid } from './helpers.js';
-import type { RequestContext } from '../../context.js';
-
-// Suite-wide token map. `scopeFor` populates it; `ctx` auto-attaches the
-// matching token so DB-side auth (Supabase RLS) sees the right user.
-const tokens = new Map<string, string>();
-
-function ctx(
-	userId: string,
-	opts: {
-		actingOrgId?: string;
-		platformPermissions?: RequestContext['platformPermissions'];
-		orgPermissions?: RequestContext['orgPermissions'];
-	} = {}
-): RequestContext {
-	return makeCtx(userId, { ...opts, sessionToken: tokens.get(userId) });
-}
-
-export interface ShareLinkTestScope {
-	/** Owner of the parent definition. Used as `createdBy`. */
-	ownerId: string;
-	/**
-	 * Optional access token for `ownerId`. Required for adapters with DB-side
-	 * auth (Supabase RLS); local providers ignore it.
-	 */
-	ownerSessionToken?: string;
-	/** Existing definition the conformance suite mints links against. */
-	definitionId: string;
-	/** A second definition id for cross-definition isolation tests. */
-	otherDefinitionId: string;
-}
-
-export interface ShareLinkStoreConformanceOptions {
-	name: string;
-	createStore: () => Promise<IShareLinkStore> | IShareLinkStore;
-	/**
-	 * Seed any parent rows the adapter requires (FK-enforced backends seed a
-	 * `definitions` row + parent project). Local adapters can return stub ids.
-	 */
-	createScope?: () => Promise<ShareLinkTestScope> | ShareLinkTestScope;
-}
-
-const DEFAULT_SCOPE: ShareLinkTestScope = {
-	ownerId: 'user-1',
-	definitionId: 'def-1',
-	otherDefinitionId: 'def-2'
-};
-
-function link(scope: ShareLinkTestScope, overrides: Partial<ShareLink> = {}): ShareLink {
-	const now = new Date().toISOString();
-	return {
-		id: overrides.id ?? makeUuid(),
-		definitionId: overrides.definitionId ?? scope.definitionId,
-		channel: overrides.channel ?? 'live',
-		tokenHash: overrides.tokenHash ?? `hash-${makeUuid()}`,
-		name: overrides.name,
-		createdBy: overrides.createdBy ?? scope.ownerId,
-		createdAt: overrides.createdAt ?? now,
-		expiresAt: overrides.expiresAt ?? null,
-		revokedAt: overrides.revokedAt ?? null,
-		allowSolve: overrides.allowSolve ?? true,
-		maxSolves: overrides.maxSolves === undefined ? null : overrides.maxSolves,
-		solveCount: overrides.solveCount ?? 0
-	};
-}
-
-export function runShareLinkStoreConformance(opts: ShareLinkStoreConformanceOptions): void {
-	const { name, createStore, createScope } = opts;
-	const scopeFor = async (): Promise<ShareLinkTestScope> => {
-		const s = createScope ? await createScope() : DEFAULT_SCOPE;
-		if (s.ownerSessionToken) tokens.set(s.ownerId, s.ownerSessionToken);
-		return s;
-	};
-
-	describe(`IShareLinkStore conformance: ${name}`, () => {
-		it('create + getById round-trips', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			const l = link(scope);
-			await store.create(ctx(scope.ownerId), l);
-			const got = await store.getById(ctx(scope.ownerId), l.id);
-			expect(got?.id).toBe(l.id);
-			expect(got?.tokenHash).toBe(l.tokenHash);
-			expect(got?.allowSolve).toBe(true);
-		});
-
-		it('listByDefinition returns links for that definition only, newest first', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			const a = link(scope, { createdAt: '2026-04-01T00:00:00.000Z' });
-			const b = link(scope, { createdAt: '2026-04-02T00:00:00.000Z' });
-			const other = link(scope, { definitionId: scope.otherDefinitionId });
-			await store.create(ctx(scope.ownerId), a);
-			await store.create(ctx(scope.ownerId), b);
-			await store.create(ctx(scope.ownerId), other);
-
-			const page = await store.listByDefinition(ctx(scope.ownerId), scope.definitionId);
-			expect(page.items.map((l) => l.id)).toEqual([b.id, a.id]);
-		});
-
-		it('getByTokenHash returns the matching link', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			const l = link(scope, { tokenHash: 'unique-hash' });
-			await store.create(ctx(scope.ownerId), l);
-			const got = await store.getByTokenHash(ctx(scope.ownerId), 'unique-hash');
-			expect(got?.id).toBe(l.id);
-		});
-
-		it('getByTokenHash returns null for unknown hash', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			const got = await store.getByTokenHash(ctx(scope.ownerId), 'nonexistent');
-			expect(got).toBeNull();
-		});
-
-		it('revoke sets revokedAt; subsequent listByDefinition excludes it', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			const l = link(scope);
-			await store.create(ctx(scope.ownerId), l);
-			await store.revoke(ctx(scope.ownerId), l.id);
-
-			const page = await store.listByDefinition(ctx(scope.ownerId), scope.definitionId);
-			expect(page.items.map((x) => x.id)).not.toContain(l.id);
-		});
-
-		it('revoke makes getByTokenHash return null', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			const l = link(scope, { tokenHash: 'will-revoke' });
-			await store.create(ctx(scope.ownerId), l);
-			await store.revoke(ctx(scope.ownerId), l.id);
-
-			const got = await store.getByTokenHash(ctx(scope.ownerId), 'will-revoke');
-			expect(got).toBeNull();
-		});
-
-		it('revoke is idempotent (no error on double-revoke)', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			const l = link(scope);
-			await store.create(ctx(scope.ownerId), l);
-			await store.revoke(ctx(scope.ownerId), l.id);
-			await store.revoke(ctx(scope.ownerId), l.id); // should not throw
-		});
-
-		it('tryIncrementSolveCount with null cap always increments', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			const l = link(scope, { maxSolves: null });
-			await store.create(ctx(scope.ownerId), l);
-
-			expect(await store.tryIncrementSolveCount(ctx(scope.ownerId), l.id)).toBe(1);
-			expect(await store.tryIncrementSolveCount(ctx(scope.ownerId), l.id)).toBe(2);
-
-			const after = await store.getById(ctx(scope.ownerId), l.id);
-			expect(after?.solveCount).toBe(2);
-		});
-
-		it('tryIncrementSolveCount enforces a cap', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			const l = link(scope, { maxSolves: 2 });
-			await store.create(ctx(scope.ownerId), l);
-
-			expect(await store.tryIncrementSolveCount(ctx(scope.ownerId), l.id)).toBe(1);
-			expect(await store.tryIncrementSolveCount(ctx(scope.ownerId), l.id)).toBe(2);
-			expect(await store.tryIncrementSolveCount(ctx(scope.ownerId), l.id)).toBeNull();
-
-			const after = await store.getById(ctx(scope.ownerId), l.id);
-			expect(after?.solveCount).toBe(2);
-		});
-
-		it('tryIncrementSolveCount returns null for revoked links', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			const l = link(scope, { maxSolves: null });
-			await store.create(ctx(scope.ownerId), l);
-			await store.revoke(ctx(scope.ownerId), l.id);
-
-			expect(await store.tryIncrementSolveCount(ctx(scope.ownerId), l.id)).toBeNull();
-		});
-
-		it('tryIncrementSolveCount returns null for unknown id', async () => {
-			const store = await createStore();
-			const scope = await scopeFor();
-			expect(await store.tryIncrementSolveCount(ctx(scope.ownerId), makeUuid())).toBeNull();
-		});
-	});
-}

package/src/testing/suites/solveMetricSinkSuite.ts

@@ -1,135 +0,0 @@
-/**
- * Adapter conformance suite for the solve-metric-sink contract.
- *
- * Unlike `IEventSink`, an `ISolveMetricSink` is not driven by store mutations —
- * the compute route calls `record()` directly, once per solve attempt. So this
- * suite is a round-trip: hand a `SolveMetric` to the sink, then read the row
- * back through an adapter-supplied `readRows` and assert the persisted shape.
- *
- * It also pins the contract's hard guarantee: `record` MUST NOT throw, even on
- * a backend failure — the compute route depends on that to keep serving the
- * response after a solve.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import type { ISolveMetricSink, SolveMetric, RequestContext } from '../../index.js';
-
-/**
- * Adapter's view of a persisted metric, normalized back to the `SolveMetric`
- * shape plus the recorded `actorId`. Implementations map their column names
- * onto these fields so the suite stays storage-agnostic.
- */
-export interface RecordedSolveMetric extends SolveMetric {
-	/** The actor the sink derived from the `RequestContext` it was handed. */
-	actorId: string;
-}
-
-export interface SolveMetricSinkConformanceOptions {
-	name: string;
-	/** Build a fresh sink against the adapter's backend. */
-	createSink: () => Promise<ISolveMetricSink> | ISolveMetricSink;
-	/** Read every persisted metric back, normalized to `RecordedSolveMetric`. */
-	readRows: () => Promise<RecordedSolveMetric[]>;
-	/**
-	 * Build a sink whose backing store is broken so writes fail. Used to prove
-	 * `record` swallows errors. Omit if the adapter can't simulate a failure;
-	 * the throw-safety test is skipped when absent.
-	 */
-	createFailingSink?: () => Promise<ISolveMetricSink> | ISolveMetricSink;
-	/** Optional per-test cleanup (truncate the metrics table, etc.). */
-	cleanup?: () => Promise<void> | void;
-}
-
-function sysCtx(userId: string): RequestContext {
-	return { userId, platformPermissions: [], orgPermissions: [], system: true };
-}
-
-function baseMetric(overrides: Partial<SolveMetric> = {}): SolveMetric {
-	return {
-		definitionUrl: 'local:00000000-0000-0000-0000-0000000000aa',
-		definitionId: '00000000-0000-0000-0000-0000000000aa',
-		versionId: '00000000-0000-0000-0000-0000000000bb',
-		channel: 'live',
-		orgId: '00000000-0000-0000-0000-0000000000cc',
-		durationMs: 123.5,
-		ok: true,
-		failureKind: 'ok',
-		errorCount: 0,
-		warningCount: 0,
-		...overrides
-	};
-}
-
-export function runSolveMetricSinkConformance(opts: SolveMetricSinkConformanceOptions): void {
-	const { name, createSink, readRows, createFailingSink, cleanup } = opts;
-
-	describe(`ISolveMetricSink conformance: ${name}`, () => {
-		let sink: ISolveMetricSink;
-
-		beforeEach(async () => {
-			sink = await createSink();
-		});
-
-		afterEach(async () => {
-			if (cleanup) await cleanup();
-		});
-
-		it('persists a successful solve with all fields intact', async () => {
-			const metric = baseMetric();
-			await sink.record(sysCtx('user-1'), metric);
-
-			const rows = await readRows();
-			expect(rows).toHaveLength(1);
-			expect(rows[0]).toMatchObject({ ...metric, actorId: 'user-1' });
-		});
-
-		it('records the actor from the RequestContext', async () => {
-			await sink.record(sysCtx('user-xyz'), baseMetric());
-			const rows = await readRows();
-			expect(rows[0].actorId).toBe('user-xyz');
-		});
-
-		it('falls back to "system" when the context has no user id', async () => {
-			await sink.record(sysCtx(''), baseMetric());
-			const rows = await readRows();
-			expect(rows[0].actorId).toBe('system');
-		});
-
-		it('persists a failed solve with its failureKind and zero duration', async () => {
-			await sink.record(
-				sysCtx('user-1'),
-				baseMetric({ ok: false, failureKind: 'timeout', durationMs: 0 })
-			);
-			const rows = await readRows();
-			expect(rows[0]).toMatchObject({ ok: false, failureKind: 'timeout', durationMs: 0 });
-		});
-
-		it('persists error/warning counts on an otherwise-ok solve', async () => {
-			await sink.record(sysCtx('user-1'), baseMetric({ errorCount: 2, warningCount: 5 }));
-			const rows = await readRows();
-			expect(rows[0]).toMatchObject({ ok: true, errorCount: 2, warningCount: 5 });
-		});
-
-		it('persists null definition/version/org for remote-URL solves', async () => {
-			await sink.record(
-				sysCtx('user-1'),
-				baseMetric({
-					definitionUrl: 'https://example.com/def.gh',
-					definitionId: null,
-					versionId: null,
-					orgId: null
-				})
-			);
-			const rows = await readRows();
-			expect(rows[0]).toMatchObject({ definitionId: null, versionId: null, orgId: null });
-		});
-
-		if (createFailingSink) {
-			it('does not throw when the backing write fails', async () => {
-				const failing = await createFailingSink();
-				// The contract: record swallows the failure and resolves.
-				await expect(failing.record(sysCtx('user-1'), baseMetric())).resolves.toBeUndefined();
-			});
-		}
-	});
-}

package/src/testing/suites/storageProviderSuite.ts

@@ -1,175 +0,0 @@
-/**
- * Adapter conformance suite for IStorageProvider.
- *
- * Tests blob storage operations (get, put, delete, deletePrefix, getPublicUrl)
- * to ensure all adapters behave identically.
- */
-
-import { describe, it, expect } from 'vitest';
-import type { IStorageProvider } from '../../storage/interface.js';
-
-export interface StorageProviderConformanceOptions {
-	/** Name to show in test output (e.g. "local-filesystem"). */
-	name: string;
-	/** Factory that returns a fresh, empty storage per test. */
-	createStorage: () => Promise<IStorageProvider> | IStorageProvider;
-}
-
-function bytes(text: string): Uint8Array {
-	return new TextEncoder().encode(text);
-}
-
-export function runStorageProviderConformance(opts: StorageProviderConformanceOptions): void {
-	const { name, createStorage } = opts;
-
-	describe(`IStorageProvider conformance: ${name}`, () => {
-		it('put + get returns the stored data', async () => {
-			const storage = await createStorage();
-			const data = bytes('Hello, World!');
-			await storage.put('test/file.txt', data);
-			const got = await storage.get('test/file.txt');
-			expect(got).toEqual(data);
-		});
-
-		it('get returns null for missing path', async () => {
-			const storage = await createStorage();
-			const got = await storage.get('nonexistent/path.txt');
-			expect(got).toBeNull();
-		});
-
-		it('put overwrites existing file', async () => {
-			const storage = await createStorage();
-			const data1 = bytes('First');
-			const data2 = bytes('Second');
-			await storage.put('test/file.txt', data1);
-			await storage.put('test/file.txt', data2);
-			const got = await storage.get('test/file.txt');
-			expect(got).toEqual(data2);
-		});
-
-		it('put creates nested directories', async () => {
-			const storage = await createStorage();
-			const data = bytes('nested');
-			await storage.put('a/b/c/d/file.txt', data);
-			const got = await storage.get('a/b/c/d/file.txt');
-			expect(got).toEqual(data);
-		});
-
-		it('delete removes a file', async () => {
-			const storage = await createStorage();
-			await storage.put('test/file.txt', bytes('data'));
-			await storage.delete('test/file.txt');
-			const got = await storage.get('test/file.txt');
-			expect(got).toBeNull();
-		});
-
-		it('delete is a no-op for missing file', async () => {
-			const storage = await createStorage();
-			await storage.delete('nonexistent/file.txt');
-			// Should not throw
-		});
-
-		it('deletePrefix removes all files matching prefix', async () => {
-			const storage = await createStorage();
-			await storage.put('definitions/guid-1/file.gh', bytes('def1'));
-			await storage.put('definitions/guid-1/meta.json', bytes('{}'));
-			await storage.put('definitions/guid-2/file.gh', bytes('def2'));
-
-			await storage.deletePrefix('definitions/guid-1/');
-
-			const file1 = await storage.get('definitions/guid-1/file.gh');
-			const meta1 = await storage.get('definitions/guid-1/meta.json');
-			const file2 = await storage.get('definitions/guid-2/file.gh');
-
-			expect(file1).toBeNull();
-			expect(meta1).toBeNull();
-			expect(file2).toBeTruthy();
-		});
-
-		it('deletePrefix with no matches is a no-op', async () => {
-			const storage = await createStorage();
-			await storage.put('other/file.txt', bytes('data'));
-			await storage.deletePrefix('nonexistent/');
-			// Should not throw
-		});
-
-		it('getPublicUrl returns a non-empty string', async () => {
-			const storage = await createStorage();
-			const url = storage.getPublicUrl('test/file.txt');
-			expect(url).toBeTruthy();
-		});
-
-		it('getPublicUrl is consistent for same path', async () => {
-			const storage = await createStorage();
-			const url1 = storage.getPublicUrl('test/file.txt');
-			const url2 = storage.getPublicUrl('test/file.txt');
-			expect(url1).toBe(url2);
-		});
-
-		it('getPublicUrl differs for different paths', async () => {
-			const storage = await createStorage();
-			const url1 = storage.getPublicUrl('test/file1.txt');
-			const url2 = storage.getPublicUrl('test/file2.txt');
-			expect(url1).not.toBe(url2);
-		});
-
-		it('handles binary data correctly', async () => {
-			const storage = await createStorage();
-			const binary = new Uint8Array([0x00, 0x01, 0x02, 0xff, 0xfe, 0xfd]);
-			await storage.put('binary/data.bin', binary);
-			const got = await storage.get('binary/data.bin');
-			expect(got).toEqual(binary);
-		});
-
-		it('handles large data', async () => {
-			const storage = await createStorage();
-			const large = new Uint8Array(1024 * 1024); // 1 MB
-			for (let i = 0; i < large.length; i++) {
-				large[i] = i % 256;
-			}
-			await storage.put('large/file.bin', large);
-			const got = await storage.get('large/file.bin');
-			expect(got).toEqual(large);
-		});
-
-		it('put with contentType is stored', async () => {
-			const storage = await createStorage();
-			const data = bytes('{"type":"octet"}');
-			await storage.put('files/test.bin', data, 'application/octet-stream');
-			const got = await storage.get('files/test.bin');
-			expect(got).toEqual(data);
-		});
-
-		// ============================================================================
-		// Image transcoding
-		// ============================================================================
-		//
-		// Every adapter MUST run uploads through the shared `transcodeImageIfNeeded`
-		// helper so cover images, archive thumbnails, etc. land as WebP regardless
-		// of what the user uploaded. Otherwise a provider that skipped this would
-		// produce a pipeline that looks correct until someone uploads a PNG.
-
-		it('transcodes png input to webp (path rewritten, magic bytes flipped)', async () => {
-			const storage = await createStorage();
-			// Minimal valid 1×1 transparent PNG — the canonical 67-byte fixture.
-			const pngBytes = Uint8Array.from([
-				0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44,
-				0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f,
-				0x15, 0xc4, 0x89, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9c, 0x63, 0x00,
-				0x01, 0x00, 0x00, 0x05, 0x00, 0x01, 0x0d, 0x0a, 0x2d, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x49,
-				0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82
-			]);
-			await storage.put('covers/tiny.png', pngBytes, 'image/png');
-
-			// Image transcoding rewrites the path to .webp — the original path is empty.
-			const atPng = await storage.get('covers/tiny.png');
-			expect(atPng).toBeNull();
-
-			// At the webp path we get a valid RIFF/WEBP container.
-			const atWebp = await storage.get('covers/tiny.webp');
-			expect(atWebp).toBeTruthy();
-			expect(atWebp?.slice(0, 4)).toEqual(bytes('RIFF'));
-			expect(atWebp?.slice(8, 12)).toEqual(bytes('WEBP'));
-		});
-	});
-}

package/src/testing/suites/userProfileStoreSuite.ts

@@ -1,134 +0,0 @@
-/**
- * Adapter conformance suite for IUserProfileStore.
- *
- * Tests the user-profile mutations (display name, starred definitions,
- * recent runs) that used to live on IAuthProvider. Adapters must seed
- * a real user before each test since profile mutations target a userId.
- */
-
-import { describe, it, expect } from 'vitest';
-import type { IUserProfileStore } from '../../userProfile/interface.js';
-import type { AuthUser } from '../../auth/index.js';
-import type { RecentRun } from '../../userProfile/index.js';
-import { SYSTEM_CONTEXT } from '../../context.js';
-import { makeUuid } from './helpers.js';
-
-// Profile mutations need a ctx scoped to the target user (Permissions.md §9 +
-// the `IUserProfileStore` JSDoc auth-boundary note). The conformance suite
-// uses SYSTEM_CONTEXT throughout so it doesn't need to mint per-user ctxs;
-// the per-user authorization is exercised in adapter-specific tests.
-const ctx = SYSTEM_CONTEXT;
-
-export interface UserProfileStoreConformanceOptions {
-	/** Name to show in test output. */
-	name: string;
-	/**
-	 * Factory that returns a fresh, empty store and a `seedUser(email)` helper
-	 * that creates a real user the test can mutate. The helper is provider-
-	 * specific because IUserProfileStore itself doesn't create users.
-	 */
-	createStore: () => Promise<{
-		store: IUserProfileStore;
-		seedUser: (email: string) => Promise<AuthUser>;
-	}>;
-}
-
-export function runUserProfileStoreConformance(opts: UserProfileStoreConformanceOptions): void {
-	const { name, createStore } = opts;
-
-	describe(`IUserProfileStore conformance: ${name}`, () => {
-		it('getProfile returns null for unknown user', async () => {
-			const { store } = await createStore();
-			const profile = await store.getProfile(ctx, makeUuid());
-			expect(profile).toBeNull();
-		});
-
-		it('getProfile returns a profile for a seeded user', async () => {
-			const { store, seedUser } = await createStore();
-			const user = await seedUser('get@example.com');
-			const profile = await store.getProfile(ctx, user.id);
-			expect(profile).toBeTruthy();
-			expect(profile?.userId).toBe(user.id);
-			expect(profile?.starredDefinitions).toEqual([]);
-			expect(profile?.recentRuns).toEqual([]);
-		});
-
-		it('getProfiles batch-loads seeded users and skips unknowns', async () => {
-			const { store, seedUser } = await createStore();
-			const a = await seedUser('a-batch@example.com');
-			const b = await seedUser('b-batch@example.com');
-			const ghost = makeUuid();
-			const profiles = await store.getProfiles(ctx, [a.id, b.id, ghost]);
-			const ids = new Set(profiles.map((p) => p.userId));
-			expect(ids.has(a.id)).toBe(true);
-			expect(ids.has(b.id)).toBe(true);
-			expect(ids.has(ghost)).toBe(false);
-		});
-
-		it('updateProfile changes displayName and getProfile returns it', async () => {
-			const { store, seedUser } = await createStore();
-			const user = await seedUser('p@example.com');
-			const result = await store.updateProfile(ctx, user.id, { displayName: 'Felix' });
-			expect(result).toBe('ok');
-			const profile = await store.getProfile(ctx, user.id);
-			expect(profile?.displayName).toBe('Felix');
-		});
-
-		it('updateProfile returns not_found for unknown user', async () => {
-			const { store } = await createStore();
-			const result = await store.updateProfile(ctx, makeUuid(), { displayName: 'X' });
-			expect(result).toBe('not_found');
-		});
-
-		it('starDefinition + unstarDefinition round-trip reflects in profile', async () => {
-			const { store, seedUser } = await createStore();
-			const user = await seedUser('star@example.com');
-			const defId = makeUuid();
-			expect(await store.starDefinition(ctx, user.id, defId)).toBe('ok');
-			expect((await store.getProfile(ctx, user.id))?.starredDefinitions).toContain(defId);
-			expect(await store.unstarDefinition(ctx, user.id, defId)).toBe('ok');
-			expect((await store.getProfile(ctx, user.id))?.starredDefinitions).not.toContain(defId);
-		});
-
-		it('starDefinition is idempotent (no duplicates)', async () => {
-			const { store, seedUser } = await createStore();
-			const user = await seedUser('idem@example.com');
-			const defId = makeUuid();
-			expect(await store.starDefinition(ctx, user.id, defId)).toBe('ok');
-			expect(await store.starDefinition(ctx, user.id, defId)).toBe('ok');
-			const profile = await store.getProfile(ctx, user.id);
-			const occurrences = profile?.starredDefinitions.filter((d) => d === defId).length;
-			expect(occurrences).toBe(1);
-		});
-
-		it('recordRun returns ok and profile surfaces the entry', async () => {
-			const { store, seedUser } = await createStore();
-			const user = await seedUser('runs@example.com');
-			const run: RecentRun = {
-				definitionId: makeUuid(),
-				runId: makeUuid(),
-				definitionName: 'D',
-				timestamp: new Date().toISOString()
-			};
-			expect(await store.recordRun(ctx, user.id, run)).toBe('ok');
-			const profile = await store.getProfile(ctx, user.id);
-			expect(profile?.recentRuns.some((r) => r.runId === run.runId)).toBe(true);
-		});
-
-		it('recordRun returns not_found for unknown user', async () => {
-			const { store } = await createStore();
-			const run: RecentRun = {
-				definitionId: makeUuid(),
-				runId: makeUuid(),
-				definitionName: 'D',
-				timestamp: new Date().toISOString()
-			};
-			expect(await store.recordRun(ctx, makeUuid(), run)).toBe('not_found');
-		});
-
-		it('starDefinition returns not_found for unknown user', async () => {
-			const { store } = await createStore();
-			expect(await store.starDefinition(ctx, makeUuid(), makeUuid())).toBe('not_found');
-		});
-	});
-}

package/src/userProfile/index.ts

@@ -1,3 +0,0 @@
-export type { IUserProfileStore } from './interface.js';
-export type { UserProfile, RecentRun } from './types.js';
-export { emptyProfile } from './types.js';