@btst/stack 3.0.0-rc.2 → 3.0.0-rc.3

package/src/__tests__/managed-origin-hydration.browser.test.tsx

@@ -0,0 +1,163 @@
+// @vitest-environment jsdom
+import {
+	dehydrate,
+	QueryClient,
+	QueryClientProvider,
+} from "@tanstack/react-query";
+import type { ReactNode } from "react";
+import { renderToString } from "react-dom/server";
+import { describe, expect, it, vi } from "vitest";
+import { z } from "zod";
+import { defineAuthorizationContract } from "../authorization";
+import { createClientStack } from "../client";
+import { StackProvider, useStack } from "../context";
+import { createNextLayout } from "../next/server";
+import { defineClientPlugin, defineRoute } from "../plugins/client";
+import { createReactRouterPage } from "../react-router";
+import { createTanStackPageOptions } from "../tanstack";
+
+const frameworkState = vi.hoisted(() => ({
+	queryClient: undefined as QueryClient | undefined,
+	reactRouterLoaderData: undefined as unknown,
+}));
+
+vi.mock("next/headers", () => ({
+	headers: async () => new Headers(),
+}));
+
+vi.mock("react-router", async (importOriginal) => ({
+	...(await importOriginal<typeof import("react-router")>()),
+	useLoaderData: () => frameworkState.reactRouterLoaderData,
+}));
+
+vi.mock("@tanstack/react-router", async (importOriginal) => ({
+	...(await importOriginal<typeof import("@tanstack/react-router")>()),
+	useParams: () => ({ _splat: "probe" }),
+	useRouteContext: () => ({ queryClient: frameworkState.queryClient }),
+}));
+
+const managedApiOrigin = "https://api.managed.example";
+const siteOrigin = "https://app.example";
+const browserFallbackOrigin = "https://app.example";
+
+function OriginProbe() {
+	return <span data-testid="runtime-origin">{useStack().api?.baseURL}</span>;
+}
+
+function createOriginStack(
+	queryClient: QueryClient,
+	apiOrigin: string,
+	useProviderOrigin: boolean,
+) {
+	const PageComponent = useProviderOrigin
+		? OriginProbe
+		: () => <span data-testid="runtime-origin">{browserFallbackOrigin}</span>;
+	return createClientStack({
+		api: { baseURL: apiOrigin, basePath: "/api/data" },
+		site: { baseURL: siteOrigin, basePath: "/pages" },
+		queryClient,
+		plugins: {
+			probe: defineClientPlugin({
+				id: "probe",
+				resolve: () => ({
+					routes: () => ({
+						probe: defineRoute("/probe", { page: PageComponent }),
+					}),
+				}),
+			}),
+		},
+	});
+}
+
+function renderManagedProvider(
+	queryClient: QueryClient,
+	stack: ReturnType<typeof createOriginStack>,
+	children: ReactNode,
+) {
+	return renderToString(
+		<QueryClientProvider client={queryClient}>
+			<StackProvider stack={stack}>{children}</StackProvider>
+		</QueryClientProvider>,
+	);
+}
+
+describe("managed API origin hydration", () => {
+	it("threads the distinct server origin through the Next client provider", async () => {
+		const queryClient = new QueryClient();
+		const contract = defineAuthorizationContract({
+			identity: z.object({ id: z.string() }),
+			permissions: [] as const,
+		});
+		const layout = createNextLayout({
+			auth: { contract, getIdentityFromHeaders: () => null },
+			resolveClientOrigins: () => ({
+				apiOrigin: managedApiOrigin,
+				siteOrigin,
+			}),
+			ClientLayout: ({ children, clientOrigins }) => {
+				if (!clientOrigins) throw new Error("Expected hydrated client origins");
+				const stack = createOriginStack(
+					queryClient,
+					clientOrigins.apiOrigin,
+					true,
+				);
+				return (
+					<QueryClientProvider client={queryClient}>
+						<StackProvider stack={stack}>
+							<OriginProbe />
+							{children}
+						</StackProvider>
+					</QueryClientProvider>
+				);
+			},
+		});
+
+		const html = renderToString(await layout.Layout({}));
+
+		expect(html).toContain(managedApiOrigin);
+		expect(html).not.toContain(`>${browserFallbackOrigin}<`);
+	});
+
+	it.each(["React Router", "TanStack Start"])(
+		"keeps the provider stack during %s hydration and navigation renders",
+		(framework) => {
+			const queryClient = new QueryClient();
+			frameworkState.queryClient = queryClient;
+			frameworkState.reactRouterLoaderData = {
+				path: "/probe",
+				dehydratedState: dehydrate(queryClient),
+			};
+			const providerStack = createOriginStack(
+				queryClient,
+				managedApiOrigin,
+				true,
+			);
+			const browserFallbackStack = createOriginStack(
+				queryClient,
+				browserFallbackOrigin,
+				false,
+			);
+			const getBrowserFallbackStack = vi.fn(() => browserFallbackStack);
+			const Component =
+				framework === "React Router"
+					? createReactRouterPage({
+							getStackClient: getBrowserFallbackStack,
+							getQueryClient: () => queryClient,
+						}).Component
+					: createTanStackPageOptions({
+							getStackClient: getBrowserFallbackStack,
+							getQueryClient: () => queryClient,
+						}).component;
+
+			const html = renderManagedProvider(
+				queryClient,
+				providerStack,
+				<Component />,
+			);
+
+			expect(html).toContain(managedApiOrigin);
+			expect(html).not.toContain(browserFallbackOrigin);
+			expect(getBrowserFallbackStack).not.toHaveBeenCalled();
+		},
+	);
+});

package/src/__tests__/media-query-keys.test.ts

@@ -13,49 +13,105 @@ import {
 } from "../plugins/media/query-keys";
 import { ROOT_FOLDER_QUERY_VALUE } from "../plugins/media/schemas";
 
+const ENDPOINT = {
+	baseURL: "https://media.example.com",
+	basePath: "/api/data",
+};
+
 describe("media resource query keys", () => {
 	it("matches the shared asset-list builder and normalizes search", () => {
 		const client = vi.fn() as any;
 		const queries = createMediaQueryKeys(client);
 		const params = { folderId: "photos", query: "  beach  ", limit: 40 };
 
-		expect([...queries.mediaAssets.list(params).queryKey]).toEqual([
-			...MEDIA_QUERY_KEYS.assetsList(params),
-		]);
+		expect([
+			...queries.mediaAssets.list(params, undefined, ENDPOINT).queryKey,
+		]).toEqual([...MEDIA_QUERY_KEYS.assetsList(params, undefined, ENDPOINT)]);
 		expect(assetListDiscriminator(params).query).toBe("beach");
 	});
 
+	it("aligns SSR/browser keys for the hydrated identity", () => {
+		const client = vi.fn() as any;
+		const queries = createMediaQueryKeys(client);
+		const identity = { id: "member-a", role: "member" };
+		const params = { limit: 40 };
+
+		expect(
+			queries.mediaAssets.list(params, identity, ENDPOINT).queryKey,
+		).toEqual(MEDIA_QUERY_KEYS.assetsList(params, identity, ENDPOINT));
+		expect(
+			queries.mediaFolders.list(null, identity, ENDPOINT).queryKey,
+		).toEqual(MEDIA_QUERY_KEYS.foldersList(null, identity, ENDPOINT));
+	});
+
+	it("partitions asset and folder lists by Media origin and mount path", () => {
+		const client = vi.fn() as any;
+		const queries = createMediaQueryKeys(client);
+		const otherOrigin = { ...ENDPOINT, baseURL: "https://other.example.com" };
+		const otherPath = { ...ENDPOINT, basePath: "/media-api" };
+
+		for (const endpoint of [otherOrigin, otherPath]) {
+			expect(
+				queries.mediaAssets.list({}, undefined, ENDPOINT).queryKey,
+			).not.toEqual(queries.mediaAssets.list({}, undefined, endpoint).queryKey);
+			expect(
+				queries.mediaFolders.list(undefined, undefined, ENDPOINT).queryKey,
+			).not.toEqual(
+				queries.mediaFolders.list(undefined, undefined, endpoint).queryKey,
+			);
+		}
+		expect(
+			JSON.stringify(
+				queries.mediaAssets.list({}, undefined, ENDPOINT).queryKey,
+			),
+		).toBe(
+			JSON.stringify(MEDIA_QUERY_KEYS.assetsList({}, undefined, ENDPOINT)),
+		);
+		const noisyEndpoint = {
+			...ENDPOINT,
+			headers: { authorization: "Bearer server-secret" },
+			credentials: "include",
+		};
+		const serializedKey = JSON.stringify(
+			MEDIA_QUERY_KEYS.assetsList({}, undefined, noisyEndpoint),
+		);
+		expect(serializedKey).not.toContain("server-secret");
+		expect(serializedKey).not.toContain("credentials");
+	});
+
 	it("uses distinct keys for all folders, root folders, and a parent", () => {
 		const client = vi.fn() as any;
 		const queries = createMediaQueryKeys(client);
 
-		expect([...queries.mediaFolders.list(undefined).queryKey]).toEqual([
-			...MEDIA_QUERY_KEYS.foldersList(undefined),
-		]);
-		expect([...queries.mediaFolders.list(null).queryKey]).toEqual([
-			...MEDIA_QUERY_KEYS.foldersList(null),
+		expect([
+			...queries.mediaFolders.list(undefined, undefined, ENDPOINT).queryKey,
+		]).toEqual([
+			...MEDIA_QUERY_KEYS.foldersList(undefined, undefined, ENDPOINT),
 		]);
-		expect(queries.mediaFolders.list(undefined).queryKey).not.toEqual(
-			queries.mediaFolders.list(null).queryKey,
+		expect([
+			...queries.mediaFolders.list(null, undefined, ENDPOINT).queryKey,
+		]).toEqual([...MEDIA_QUERY_KEYS.foldersList(null, undefined, ENDPOINT)]);
+		expect(
+			queries.mediaFolders.list(undefined, undefined, ENDPOINT).queryKey,
+		).not.toEqual(
+			queries.mediaFolders.list(null, undefined, ENDPOINT).queryKey,
 		);
-		expect([...queries.mediaFolders.list("parent-1").queryKey]).toEqual([
-			"mediaFolders",
-			"list",
-			"parent-1",
-		]);
+		expect([
+			...queries.mediaFolders.list("parent-1", undefined, ENDPOINT).queryKey,
+		]).toEqual(MEDIA_QUERY_KEYS.foldersList("parent-1", undefined, ENDPOINT));
 	});
 
 	it("sends the root sentinel only for an explicit null parent", async () => {
 		const client = vi.fn().mockResolvedValue({ data: [] }) as any;
 		const queries = createMediaQueryKeys(client);
 
-		await queries.mediaFolders.list(undefined).queryFn();
+		await queries.mediaFolders.list(undefined, undefined, ENDPOINT).queryFn();
 		expect(client).toHaveBeenLastCalledWith(
 			"/media/folders",
 			expect.objectContaining({ query: {} }),
 		);
 
-		await queries.mediaFolders.list(null).queryFn();
+		await queries.mediaFolders.list(null, undefined, ENDPOINT).queryFn();
 		expect(client).toHaveBeenLastCalledWith(
 			"/media/folders",
 			expect.objectContaining({
@@ -64,6 +120,24 @@ describe("media resource query keys", () => {
 		);
 	});
 
+	it("normalizes relative asset URLs in the server-safe query pipeline", async () => {
+		const client = vi.fn().mockResolvedValue({
+			data: {
+				items: [{ url: "/uploads/asset.jpg" }],
+				total: 1,
+			},
+		}) as any;
+		const queries = createMediaQueryKeys(client);
+
+		const result = await queries.mediaAssets
+			.list({}, undefined, ENDPOINT)
+			.queryFn();
+
+		expect(result.items[0]?.url).toBe(
+			"https://media.example.com/uploads/asset.jpg",
+		);
+	});
+
 	it("stops infinite pagination after all rows are loaded", () => {
 		const nextPageParam = mediaResources.mediaAssets.queries.list.nextPageParam;
 		const first = { items: new Array(20), total: 25 };

package/src/__tests__/notify-provider.test.tsx

@@ -3,6 +3,7 @@ import { act } from "react";
 import { createRoot, type Root } from "react-dom/client";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { StackProvider, useNotify, type StackNotifyProvider } from "../context";
+import { createEmptyTestClientStack } from "./client-stack-test-utils";
 
 (globalThis as any).IS_REACT_ACT_ENVIRONMENT = true;
 
@@ -55,7 +56,7 @@ describe("useNotify", () => {
 			return null;
 		}
 		await render(
-			<StackProvider basePath="/pages">
+			<StackProvider stack={createEmptyTestClientStack()}>
 				<Probe />
 			</StackProvider>,
 		);
@@ -81,7 +82,7 @@ describe("useNotify", () => {
 
 		await render(
 			<StackProvider
-				basePath="/pages"
+				stack={createEmptyTestClientStack()}
 				notify={{ success: customSuccess, error: customError }}
 			>
 				<Probe />

package/src/__tests__/package-metadata.test.ts

@@ -1,6 +1,14 @@
+import { execFile } from "node:child_process";
 import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
 import { resolve } from "node:path";
+import { promisify } from "node:util";
+import { createMemoryAdapter } from "@btst/adapter-memory";
+import type { DatabaseDefinition } from "@btst/db";
 import { describe, expect, it } from "vitest";
+import { z } from "zod";
+
+const execFileAsync = promisify(execFile);
 
 describe("published dependency alignment", () => {
 	it("uses the Better DB release that shares the Better Auth 1.6.16 cohort", async () => {
@@ -19,3 +27,289 @@ describe("published dependency alignment", () => {
 		expect(manifest.peerDependencies?.["better-call"]).toBe("1.3.6");
 	});
 });
+
+describe("published canonical stack constructors", () => {
+	it("exposes only canonical names through ESM, CJS, declarations and typesVersions", async () => {
+		const manifest = JSON.parse(
+			await readFile(resolve("package.json"), "utf8"),
+		) as {
+			exports?: Record<string, unknown>;
+			typesVersions?: Record<string, Record<string, string[]>>;
+		};
+		expect(manifest.exports).toHaveProperty("./api");
+		expect(manifest.exports).toHaveProperty("./client");
+		expect(manifest.exports).toHaveProperty("./client/hooks");
+		expect(manifest.typesVersions?.["*"]?.api).toEqual([
+			"./dist/api/index.d.ts",
+		]);
+		expect(manifest.typesVersions?.["*"]?.client).toEqual([
+			"./dist/client/index.d.ts",
+		]);
+		expect(manifest.typesVersions?.["*"]?.["client/hooks"]).toEqual([
+			"./dist/client/hooks/index.d.ts",
+		]);
+
+		const apiDeclaration = await readFile(
+			resolve("dist/api/index.d.ts"),
+			"utf8",
+		);
+		const clientDeclaration = await readFile(
+			resolve("dist/client/index.d.ts"),
+			"utf8",
+		);
+		const apiCjsDeclaration = await readFile(
+			resolve("dist/api/index.d.cts"),
+			"utf8",
+		);
+		const clientCjsDeclaration = await readFile(
+			resolve("dist/client/index.d.cts"),
+			"utf8",
+		);
+		const clientEsm = await readFile(resolve("dist/client/index.mjs"), "utf8");
+		const clientCjs = await readFile(resolve("dist/client/index.cjs"), "utf8");
+		const pluginClientEsm = await readFile(
+			resolve("dist/plugins/client/index.mjs"),
+			"utf8",
+		);
+		const pluginClientCjs = await readFile(
+			resolve("dist/plugins/client/index.cjs"),
+			"utf8",
+		);
+		for (const serverSafeClientEntry of [
+			clientEsm,
+			clientCjs,
+			pluginClientEsm,
+			pluginClientCjs,
+		]) {
+			expect(serverSafeClientEntry).not.toContain("hooks/use-list-state");
+			expect(serverSafeClientEntry).not.toMatch(/from ['\"]react['\"]/);
+			expect(serverSafeClientEntry).not.toContain('require("react")');
+		}
+		for (const declaration of [apiDeclaration, apiCjsDeclaration]) {
+			expect(declaration).toContain("function createBackendStack");
+			expect(declaration).toContain("BackendStackConfig");
+			expect(declaration).toContain("BackendStack<");
+			expect(declaration).not.toContain("const stack:");
+			expect(declaration).not.toContain("BackendLib");
+		}
+		for (const declaration of [clientDeclaration, clientCjsDeclaration]) {
+			expect(declaration).toContain("function createClientStack");
+			expect(declaration).toContain("ClientStackConfig");
+			expect(declaration).toContain("ClientStack<");
+			expect(declaration).not.toContain("createStackClient");
+			expect(declaration).not.toContain("ClientLib");
+		}
+
+		const apiSpecifier = "@btst/stack/api";
+		const clientSpecifier = "@btst/stack/client";
+		const clientHooksSpecifier = "@btst/stack/client/hooks";
+		const esmApi = await import(apiSpecifier);
+		const esmClient = await import(clientSpecifier);
+		const esmClientHooks = await import(clientHooksSpecifier);
+		const require = createRequire(import.meta.url);
+		const cjsApi = require(apiSpecifier);
+		const cjsClient = require(clientSpecifier);
+		const cjsClientHooks = require(clientHooksSpecifier);
+
+		expect(esmApi.createBackendStack).toBeTypeOf("function");
+		expect(esmClient.createClientStack).toBeTypeOf("function");
+		expect(cjsApi.createBackendStack).toBeTypeOf("function");
+		expect(cjsClient.createClientStack).toBeTypeOf("function");
+		expect("stack" in esmApi).toBe(false);
+		expect("createStackClient" in esmClient).toBe(false);
+		expect("stack" in cjsApi).toBe(false);
+		expect("createStackClient" in cjsClient).toBe(false);
+		expect(esmClient.useListState).toBeUndefined();
+		expect(cjsClient.useListState).toBeUndefined();
+		expect(esmClientHooks.useListState).toBeTypeOf("function");
+		expect(cjsClientHooks.useListState).toBeTypeOf("function");
+
+		await execFileAsync(
+			process.execPath,
+			[
+				require.resolve("typescript/lib/tsc.js"),
+				"--project",
+				"consumer-tests/constructor-exports/tsconfig.json",
+			],
+			{ cwd: resolve(".") },
+		);
+		await execFileAsync(
+			process.execPath,
+			[
+				require.resolve("typescript/lib/tsc.js"),
+				"--project",
+				"consumer-tests/constructor-exports/tsconfig.cjs.json",
+			],
+			{ cwd: resolve(".") },
+		);
+	}, 30_000);
+
+	it("preserves prototype-like canonical IDs across public backend surfaces", async () => {
+		const apiSpecifier = "@btst/stack/api";
+		const pluginApiSpecifier = "@btst/stack/plugins/api";
+		const authorizationSpecifier = "@btst/stack/authorization";
+		const [{ createBackendStack }, pluginApi, authorization] =
+			await Promise.all([
+				import(apiSpecifier),
+				import(pluginApiSpecifier),
+				import(authorizationSpecifier),
+			]);
+		const permissions = authorization.definePermissions("prototype-id", {
+			echo: authorization.permission(),
+		});
+		const echo = pluginApi.defineOperation({
+			access: "public",
+			input: z.object({ value: z.string() }),
+			permission: permissions.echo,
+			facts: () => undefined,
+			execute: ({ input }: { input: { value: string } }) => input.value,
+		});
+		let observedContext:
+			| {
+					pluginRoutes: Record<string, Record<string, unknown>>;
+					endpointInventory?: Array<{ pluginName: string }>;
+			  }
+			| undefined;
+		let observedRouteOperations: Record<string, unknown> | undefined;
+		const prototypePlugin = pluginApi.defineBackendPlugin({
+			id: "__proto__",
+			dbPlugin: pluginApi.createDbPlugin("prototype-id-db", {}),
+			operations: () => ({ echo }),
+			infrastructureRoutes: {
+				health: {
+					access: "public",
+					rationale: "Exercises public stack composition in the package test.",
+				},
+			},
+			routes: (
+				_adapter: unknown,
+				context: typeof observedContext,
+				operations: Record<string, any>,
+			) => {
+				observedContext = context;
+				observedRouteOperations = operations;
+				return {
+					health: pluginApi.createEndpoint(
+						"/prototype-id",
+						{ method: "GET" },
+						async () => ({ ok: true }),
+					),
+				};
+			},
+			raw: () => ({ id: () => "__proto__" }),
+		});
+		const registrations: Record<string, unknown> = {
+			["__proto__"]: prototypePlugin,
+		};
+
+		const stack = createBackendStack({
+			plugins: registrations,
+			adapter: (db: DatabaseDefinition) => createMemoryAdapter(db)({}),
+		});
+		const requestApi = stack.forRequest(
+			new Request("https://app.example.com/api"),
+		).operations;
+
+		expect(Object.getPrototypeOf(stack.raw)).toBeNull();
+		expect(Object.hasOwn(stack.raw, "__proto__")).toBe(true);
+		expect(stack.raw.__proto__.id()).toBe("__proto__");
+		expect(Object.getPrototypeOf(stack.trusted)).toBeNull();
+		expect(Object.getPrototypeOf(stack.trusted.__proto__)).toBeNull();
+		expect(Object.getPrototypeOf(requestApi)).toBeNull();
+		expect(Object.getPrototypeOf(requestApi.__proto__)).toBeNull();
+		expect(Object.getPrototypeOf(observedContext?.pluginRoutes)).toBeNull();
+		expect(Object.getPrototypeOf(observedRouteOperations)).toBeNull();
+		expect(observedContext?.endpointInventory?.[0]?.pluginName).toBe(
+			"__proto__",
+		);
+		expect(stack.trusted.__proto__.echo).toBeTypeOf("function");
+		expect(requestApi.__proto__.echo).toBeTypeOf("function");
+	}, 30_000);
+});
+
+describe("published backend plugin factories", () => {
+	it("preserves all eight factory contracts through ESM, CJS and declarations", async () => {
+		const storageAdapter = {
+			type: "local" as const,
+			upload: async (_buffer: Buffer, { filename }: { filename: string }) => ({
+				url: `https://files.example/${filename}`,
+			}),
+			delete: async () => undefined,
+		};
+		const factories = [
+			{
+				specifier: "@btst/stack/plugins/ai-chat/api",
+				exportName: "aiChatBackendPlugin",
+				id: "aiChat",
+				args: [{ model: {} }],
+			},
+			{
+				specifier: "@btst/stack/plugins/blog/api",
+				exportName: "blogBackendPlugin",
+				id: "blog",
+				args: [],
+			},
+			{
+				specifier: "@btst/stack/plugins/cms/api",
+				exportName: "cmsBackendPlugin",
+				id: "cms",
+				args: [{ contentTypes: [] }],
+			},
+			{
+				specifier: "@btst/stack/plugins/comments/api",
+				exportName: "commentsBackendPlugin",
+				id: "comments",
+				args: [],
+			},
+			{
+				specifier: "@btst/stack/plugins/form-builder/api",
+				exportName: "formBuilderBackendPlugin",
+				id: "formBuilder",
+				args: [],
+			},
+			{
+				specifier: "@btst/stack/plugins/kanban/api",
+				exportName: "kanbanBackendPlugin",
+				id: "kanban",
+				args: [],
+			},
+			{
+				specifier: "@btst/stack/plugins/media/api",
+				exportName: "mediaBackendPlugin",
+				id: "media",
+				args: [{ storageAdapter }],
+			},
+			{
+				specifier: "@btst/stack/plugins/open-api/api",
+				exportName: "openApiBackendPlugin",
+				id: "openApi",
+				args: [],
+			},
+		] as const;
+		const require = createRequire(import.meta.url);
+
+		for (const factory of factories) {
+			const esm = (await import(factory.specifier)) as Record<
+				string,
+				(...args: any[]) => { id: string }
+			>;
+			const cjs = require(factory.specifier) as Record<
+				string,
+				(...args: any[]) => { id: string }
+			>;
+			expect(esm[factory.exportName]?.(...factory.args).id).toBe(factory.id);
+			expect(cjs[factory.exportName]?.(...factory.args).id).toBe(factory.id);
+		}
+
+		for (const project of [
+			"consumer-tests/backend-factories/tsconfig.json",
+			"consumer-tests/backend-factories/tsconfig.cjs.json",
+		]) {
+			await execFileAsync(
+				process.execPath,
+				[require.resolve("typescript/lib/tsc.js"), "--project", project],
+				{ cwd: resolve(".") },
+			);
+		}
+	}, 30_000);
+});

package/src/__tests__/page-component-overrides.test.tsx

@@ -1,5 +1,4 @@
 import { describe, it, expect } from "vitest";
-import { defineClientPlugin } from "../plugins/client";
 import type { ComponentType, ReactElement } from "react";
 import { defineRoute, defineRoutes } from "@btst/yar";
 
@@ -38,8 +37,8 @@ function createTestPlugin(config: {
 		detail?: ComponentType<{ params: { id: string } }>;
 	};
 }) {
-	return defineClientPlugin({
-		name: "test",
+	return {
+		id: "test",
 		routes: () =>
 			defineRoutes(
 				{
@@ -50,7 +49,7 @@ function createTestPlugin(config: {
 				},
 				{ pages: config.pageComponents },
 			),
-	});
+	};
 }
 
 describe("pageComponents overrides", () => {