@sigil-dev/grimoire 0.5.0 → 0.6.1

package/src/server/plugins.ts

@@ -0,0 +1,119 @@
+import type { RouteTree } from "../routing/scanner";
+import type {
+	BuildResult,
+	CoordinatorContext,
+	GrimoirePlugin,
+	LoadContext,
+	Route,
+	Server,
+	WorkerDescriptor,
+	WorkerEnv,
+} from "../types";
+
+// Fire-and-forget hooks routed through runHook.
+// onRequest and onRouteRender are intentionally excluded: they have distinct
+// calling conventions (middleware chain / inline transform loop) handled in index.ts.
+// Keep HookArgs in sync with GrimoirePlugin in types.ts.
+type HookArgs = {
+	onStart: [server: Server];
+	onStop: [reason: "shutdown" | "restart"];
+	onBuildStart: [];
+	onBuildEnd: [result: BuildResult];
+	onRouteLoad: [route: Route, context: LoadContext];
+	onCoordinatorStart: [ctx: CoordinatorContext];
+	onWorkerReady: [worker: WorkerDescriptor];
+	onWorkerDeath: [worker: WorkerDescriptor, reason: "crash" | "intentional"];
+};
+type FireAndForgetHook = keyof HookArgs;
+
+export async function runHook<K extends FireAndForgetHook>(
+	plugins: GrimoirePlugin[],
+	hook: K,
+	...args: HookArgs[K]
+): Promise<void> {
+	for (const plugin of plugins) {
+		const fn = plugin[hook] as ((...a: any[]) => any) | undefined;
+		await fn?.(...args);
+	}
+}
+
+export async function runRequestHooks(
+	plugins: GrimoirePlugin[],
+	req: Request,
+	final: () => Promise<Response>,
+): Promise<Response> {
+	const chain = plugins
+		.filter((p) => p.onRequest)
+		.reduceRight(
+			(next, plugin) => async () => plugin.onRequest!(req, next),
+			final,
+		);
+	return chain();
+}
+
+/**
+ * Calls onWorkerSpawn on ALL plugins and merges results.
+ * env is combined (later plugins override earlier on conflict).
+ * name is last-write-wins.
+ */
+export async function runWorkerSpawn(
+	plugins: GrimoirePlugin[],
+	worker: WorkerDescriptor,
+): Promise<WorkerEnv> {
+	const merged: WorkerEnv = { env: {} };
+	for (const plugin of plugins) {
+		const result = await plugin.onWorkerSpawn?.(worker);
+		//@ts-expect-error WTF TS? its result? meaning its not gonna do anything if null.
+		if (result?.env) Object.assign(merged.env!, result.env);
+		//@ts-expect-error WTF TS? its result? meaning its not gonna do anything if null.
+		if (result?.name) merged.name = result.name;
+	}
+	return merged;
+}
+
+/**
+ * First plugin to return a non-null string wins.
+ * Returns null if no plugin handles it — coordinator uses default.
+ */
+export async function runSerializeLocals(
+	plugins: GrimoirePlugin[],
+	locals: App.Locals,
+): Promise<string | null> {
+	for (const plugin of plugins) {
+		const result = await plugin.serializeLocals?.(locals);
+		if (result != null) return result;
+	}
+	return null;
+}
+
+/**
+ * First plugin to return non-null wins.
+ * Returns null if no plugin handles it — worker uses default.
+ */
+export async function runDeserializeLocals(
+	plugins: GrimoirePlugin[],
+	raw: string,
+): Promise<App.Locals | null> {
+	for (const plugin of plugins) {
+		const result = await plugin.deserializeLocals?.(raw);
+		if (result != null) return result;
+	}
+	return null;
+}
+
+/**
+ * First plugin to return a WorkerDescriptor wins.
+ * Returns null if no plugin handles it — coordinator uses default routing.
+ */
+export async function runRouteRequest(
+	plugins: GrimoirePlugin[],
+	req: Request,
+	workers: WorkerDescriptor[],
+	routes: RouteTree,
+): Promise<WorkerDescriptor | null> {
+	for (const plugin of plugins) {
+		const result = await plugin.routeRequest?.(req, workers, routes);
+		if (result != null) return result;
+	}
+	return null;
+}

package/src/server/worker.ts

@@ -0,0 +1,59 @@
+import { join } from "node:path";
+import type { GrimoireConfig, GrimoirePlugin, WorkerMode } from "../types";
+import { createServer } from "./index";
+import { runDeserializeLocals } from "./plugins";
+
+export interface WorkerOptions {
+	config: GrimoireConfig;
+	plugins: GrimoirePlugin[];
+	secret: string;
+	mode: WorkerMode;
+}
+
+export async function startWorker(options: WorkerOptions) {
+	const { secret, plugins } = options;
+
+	const workerAuthPlugin: GrimoirePlugin = {
+		name: "__grimoire-worker-auth",
+		async onRequest(req, next) {
+			if (req.headers.get("X-Grimoire-Internal") !== secret) {
+				return new Response("Forbidden", { status: 403 });
+			}
+			return next();
+		},
+	};
+
+	return createServer({
+		...options.config,
+		plugins: [workerAuthPlugin, ...plugins],
+		_skipBuild: true,
+	});
+}
+
+// bootstrap when spawned by coordinator
+if (process.env.GRIMOIRE_INTERNAL_SECRET) {
+	const secret = process.env.GRIMOIRE_INTERNAL_SECRET;
+	const port = Number(process.env.GRIMOIRE_WORKER_PORT ?? 3001);
+	const cwd = process.cwd();
+
+	let config: GrimoireConfig = {};
+	try {
+		const mod = await import(join(cwd, "sigil.config.ts"));
+		config = mod.default ?? {};
+	} catch {}
+
+	let finalConfig: GrimoireConfig = { ...config, port, host: "127.0.0.1" };
+	const plugins = finalConfig.plugins ?? [];
+	for (const plugin of plugins) {
+		finalConfig = plugin.config?.(finalConfig) ?? finalConfig;
+	}
+
+	await startWorker({
+		config: finalConfig,
+		plugins,
+		secret,
+		mode: (process.env.GRIMOIRE_MODE ?? "full") as WorkerMode,
+	});
+
+	process.send?.({ ready: true });
+}

package/src/{typegen.ts → typegen/index.ts}

@@ -1,6 +1,6 @@
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative } from "node:path";
-import type { RouteFile, RouteTree } from "./scanner";
+import type { RouteFile, RouteTree } from "../routing/scanner.ts";
 
 export interface TypegenConfig {
 	projectRoot: string;
@@ -111,7 +111,10 @@ function generateTypesForGroup(group: RouteGroup, outFileDir: string): string {
 			`  : Record<string, never>;`,
 			"",
 		);
-		lines.push(`export type PageProps = { data: PageData; params: Params };`, "");
+		lines.push(
+			`export type PageProps = { data: PageData; params: Params };`,
+			"",
+		);
 		// PageServerLoad — annotate parameter, NOT return type, to preserve inference
 		lines.push(
 			`/** Annotate the load() parameter only — not the return type — or PageData loses its concrete keys. */`,

package/src/types.ts

@@ -1,3 +1,14 @@
+import type { ServerWebSocket } from "bun";
+import type { RouteFile, RouteTree } from "./routing/scanner";
+
+/// <reference types="bun-types">
+declare global {
+	namespace App {
+		// augment in your own project
+		interface Locals {}
+	}
+}
+
 export interface Route {
 	path: string; // /blog/:slug
 	params: Record<string, string>;
@@ -77,6 +88,8 @@ export interface GrimoirePlugin {
 	// config
 	config?: (config: GrimoireConfig) => GrimoireConfig | undefined;
 
+	// process lifecycle
+
 	/**
 	 * Runs AFTER Sigil/Babel compilation. Receives compiled JS, not source TSX.
 	 * Suitable for string-level transforms (import rewriting, comment injection, etc.).
@@ -86,6 +99,67 @@ export interface GrimoirePlugin {
 		code: string,
 		id: string,
 	): string | null | undefined | Promise<string | null | undefined>;
+
+	/**
+	 * Fires once after all workers are spawned and ready.
+	 * Use for coordinator-level setup (e.g. opening a shared store).
+	 */
+	onCoordinatorStart?(ctx: CoordinatorContext): void | Promise<void>;
+
+	/**
+	 * Fires for each worker before Bun.spawn is called.
+	 * Return WorkerEnv to inject env vars or set the worker name.
+	 * ALL plugins are called and results are merged.
+	 */
+	// biome-ignore lint/suspicious/noConfusingVoidType: doesn't have to return a thing.
+	onWorkerSpawn?(
+		worker: WorkerDescriptor,
+	): WorkerEnv | void | Promise<WorkerEnv | void>;
+
+	/**
+	 * Fires when a worker process is up and accepting requests.
+	 */
+	onWorkerReady?(worker: WorkerDescriptor): void | Promise<void>;
+
+	/**
+	 * Fires when a worker process exits.
+	 * reason "crash" = unexpected exit, "intentional" = coordinator stopped it.
+	 * Use for cleanup or respawn logic (see plugin-scale).
+	 */
+	onWorkerDeath?(
+		worker: WorkerDescriptor,
+		reason: "crash" | "intentional",
+	): void | Promise<void>;
+
+	// ── Locals boundary ────────────────────────────────────────
+
+	/**
+	 * Called by coordinator before forwarding a request to a worker.
+	 * Return a serialized string representation of locals.
+	 * First plugin to return non-null wins. Default: signed JSON header.
+	 */
+	serializeLocals?(locals: App.Locals): string | Promise<string>;
+
+	/**
+	 * Called by worker on receiving a forwarded request.
+	 * Return the deserialized locals object.
+	 * First plugin to return non-null wins. Default: verify + JSON.parse.
+	 */
+	deserializeLocals?(raw: string): App.Locals | Promise<App.Locals>;
+
+	// ── Routing policy ─────────────────────────────────────────
+
+	/**
+	 * Called by coordinator to decide which worker handles a request.
+	 * First plugin to return non-null wins.
+	 * Default: ws routes → consistent hash, everything else → round robin.
+	 * routes is the full RouteTree so plugins can make route-aware decisions.
+	 */
+	routeRequest?(
+		req: Request,
+		workers: WorkerDescriptor[],
+		routes: RouteTree,
+	): WorkerDescriptor | Promise<WorkerDescriptor>;
 }
 
 export interface GrimoireConfig {
@@ -95,6 +169,7 @@ export interface GrimoireConfig {
 	routes?: string; // glob, default 'src/routes/**';
 	dev?: boolean;
 	vitePort?: number;
+	_skipBuild?: boolean;
 }
 
 export function defineConfig(config: GrimoireConfig): GrimoireConfig {
@@ -104,12 +179,16 @@ export function defineConfig(config: GrimoireConfig): GrimoireConfig {
 /** Generic load type for +page.server.ts. For per-route typed params import PageServerLoad from './$types'. */
 export type PageServerLoad<
 	P extends Record<string, string> = Record<string, string>,
-> = (ctx: TypedLoadContext<P>) => Record<string, unknown> | Promise<Record<string, unknown>>;
+> = (
+	ctx: TypedLoadContext<P>,
+) => Record<string, unknown> | Promise<Record<string, unknown>>;
 
 /** Generic load type for +layout.server.ts. For per-route typed params import LayoutServerLoad from './$types'. */
 export type LayoutServerLoad<
 	P extends Record<string, string> = Record<string, string>,
-> = (ctx: TypedLoadContext<P>) => Record<string, unknown> | Promise<Record<string, unknown>>;
+> = (
+	ctx: TypedLoadContext<P>,
+) => Record<string, unknown> | Promise<Record<string, unknown>>;
 
 /** Generic handler type for +server.ts API routes. For per-route typed params import RequestHandler from './$types'. */
 export type RequestHandler<
@@ -124,6 +203,58 @@ export type RequestHandler<
 export interface WsRouteHandler<T = Record<string, unknown>> {
 	open?(ws: ServerWebSocket<T>): void | Promise<void>;
 	message?(ws: ServerWebSocket<T>, data: string | Buffer): void | Promise<void>;
-	close?(ws: ServerWebSocket<T>, code: number, reason?: string): void | Promise<void>;
+	close?(
+		ws: ServerWebSocket<T>,
+		code: number,
+		reason?: string,
+	): void | Promise<void>;
 	drain?(ws: ServerWebSocket<T>): void | Promise<void>;
 }
+
+// ***BIG ONE***
+
+/**
+ * Built-in worker modes understood by the coordinator.
+ * Plugins may define custom modes via WorkerMode.
+ */
+export type BuiltinWorkerMode = "api" | "frontend" | "ws" | "full";
+
+/**
+ * Open union — (string & {}) preserves autocomplete for built-in
+ * values while allowing plugin-defined modes like "db" or "queue".
+ */
+export type WorkerMode = BuiltinWorkerMode | (string & {});
+
+/**
+ * Describes a single worker process managed by the coordinator.
+ * Coordinator derives behavior from routes, not mode string —
+ * mode is informational and for plugin use only.
+ */
+export interface WorkerDescriptor {
+	mode: WorkerMode;
+	index: number; // index within this mode (api-0, api-1...)
+	globalIndex: number; // index across all workers
+	internalUrl: string; // coordinator → worker base URL
+	name?: string; // set by namepool or onWorkerSpawn
+	routes: RouteFile[]; // route slice assigned by coordinator
+	pid?: number; // set after Bun.spawn
+}
+
+/**
+ * Return value of onWorkerSpawn. All plugins are called and results
+ * are merged — env from all plugins is combined, last name wins.
+ */
+export interface WorkerEnv {
+	env?: Record<string, string>;
+	name?: string;
+}
+
+/**
+ * Passed to onCoordinatorStart once the coordinator is fully initialized.
+ */
+export interface CoordinatorContext {
+	workers: WorkerDescriptor[];
+	port: number;
+	secret: string; // ephemeral signing secret, generated per-run
+	routes: RouteTree;
+}

package/test/context.test.ts

@@ -1,7 +1,7 @@
 // packages/grimoire/src/context.test.ts
 import { describe, expect, test } from "bun:test";
 import { createContext, getContext, setContext } from "@sigil-dev/runtime";
-import { runWithContext } from "../src/context";
+import { runWithContext } from "../src/server/context";
 
 const UserKey = createContext<string>();
 const ThemeKey = createContext<string>();

package/test/fail.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { fail, isFailResult } from "../src/fail";
+import { fail, isFailResult } from "../src/sentinels/fail.ts";
 
 describe("fail()", () => {
 	test("returns a FailResult with status and data", () => {

package/test/headers.test.ts

@@ -22,7 +22,9 @@ describe("securityHeaders()", () => {
 		const headers = await runPlugin({});
 		expect(headers.get("X-Content-Type-Options")).toBe("nosniff");
 		expect(headers.get("X-Frame-Options")).toBe("DENY");
-		expect(headers.get("Referrer-Policy")).toBe("strict-origin-when-cross-origin");
+		expect(headers.get("Referrer-Policy")).toBe(
+			"strict-origin-when-cross-origin",
+		);
 		expect(headers.get("Permissions-Policy")).toBe(
 			"camera=(), microphone=(), geolocation=()",
 		);
@@ -31,7 +33,9 @@ describe("securityHeaders()", () => {
 
 	test("applies CSP by default", async () => {
 		const headers = await runPlugin({});
-		expect(headers.get("Content-Security-Policy")).toContain("default-src 'self'");
+		expect(headers.get("Content-Security-Policy")).toContain(
+			"default-src 'self'",
+		);
 	});
 
 	test("allows overriding individual headers", async () => {

package/test/hydration.test.ts

@@ -38,7 +38,7 @@ function runHydrate(routes: Record<string, (props: any) => any>) {
 	}
 }
 
-// simulate initRouter (same logic as client-router.ts)
+// simulate initRouter (same logic as router.ts)
 let clickHandlerAttached = false;
 function initRouter(routes: Record<string, (props: any) => any>) {
 	document.addEventListener("click", () => {});

package/test/middleware.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
-import { sequence, createHooks } from "../src/hooks";
-import { createCookies } from "../src/cookie-utils";
-import type { Handle, RequestEvent } from "../src/hooks";
+import { createCookies } from "../src/server/cookie-utils";
+import type { Handle, RequestEvent } from "../src/server/hooks";
+import { createHooks, sequence } from "../src/server/hooks";
 
 function fakeEvent(overrides?: Partial<RequestEvent>): RequestEvent {
 	return {
@@ -147,7 +147,11 @@ describe("sequence()", () => {
 			return resolve(event);
 		};
 
-		await sequence(a, b, c)({
+		await sequence(
+			a,
+			b,
+			c,
+		)({
 			event: fakeEvent(),
 			resolve: async () => new Response("OK"),
 		});

package/test/preload.ts

@@ -1,5 +1,5 @@
 import { sigil } from "@sigil-dev/compiler/bun";
-import { registerSSRPlugin } from "../src/ssrPlugin";
+import { registerSSRPlugin } from "../src/rendering/ssrPlugin";
 
 registerSSRPlugin();
 Bun.plugin(sigil({ mode: "ssr" }));

package/test/redirect-error.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { redirect, isRedirectResult } from "../src/redirect";
-import { error, isErrorResult } from "../src/error";
+import { error, isErrorResult } from "../src/sentinels/error.ts";
+import { isRedirectResult, redirect } from "../src/sentinels/redirect.ts";
 
 describe("redirect()", () => {
 	test("throws a RedirectResult", () => {

package/test/rendering.test.ts

@@ -2,9 +2,9 @@ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { mkdir, rm, writeFile } from "fs/promises";
 import { tmpdir as osTmpDir } from "os";
 import { join } from "path";
-import { renderRoute } from "../src/renderer";
-import { matchRoute } from "../src/router";
-import { scanRoutes } from "../src/scanner";
+import { renderRoute } from "../src/rendering";
+import { matchRoute } from "../src/routing/router";
+import { scanRoutes } from "../src/routing/scanner";
 
 /** Read a streaming Response body into a single string */
 async function readStream(res: Response): Promise<string> {
@@ -235,7 +235,10 @@ describe("renderRoute", () => {
 	test("load return value is passed as the data prop (SvelteKit convention)", async () => {
 		const tree = await scanRoutes(tmpDir);
 		const matched = matchRoute(tree, new URL("http://localhost/blog"));
-		const res = await renderRoute(matched!, new Request("http://localhost/blog"));
+		const res = await renderRoute(
+			matched!,
+			new Request("http://localhost/blog"),
+		);
 		const html = await readStream(res);
 		// blog/+page.server.ts returns { title: "My Blog" }
 		// blog/+page.tsx receives { data: { title: "My Blog" } } — not spread
@@ -251,7 +254,10 @@ describe("renderRoute", () => {
 	test("redirect() from load returns 3xx with Location header", async () => {
 		const tree = await scanRoutes(tmpDir);
 		const matched = matchRoute(tree, new URL("http://localhost/redirect-page"));
-		const res = await renderRoute(matched!, new Request("http://localhost/redirect-page"));
+		const res = await renderRoute(
+			matched!,
+			new Request("http://localhost/redirect-page"),
+		);
 		expect(res.status).toBe(302);
 		expect(res.headers.get("Location")).toBe("/login");
 	});
@@ -301,7 +307,10 @@ describe("renderRoute", () => {
 	test("+layout.server.ts load data is passed to the layout component", async () => {
 		const tree = await scanRoutes(tmpDir);
 		const matched = matchRoute(tree, new URL("http://localhost/dashboard"));
-		const res = await renderRoute(matched!, new Request("http://localhost/dashboard"));
+		const res = await renderRoute(
+			matched!,
+			new Request("http://localhost/dashboard"),
+		);
 		const html = await readStream(res);
 		expect(html).toContain('class="dash"');
 		expect(html).toContain('data-user="admin"');

package/test/routing.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { matchRoute } from "../src/router";
-import type { RouteFile, RouteTree } from "../src/scanner";
+import { matchRoute } from "../src/routing/router";
+import type { RouteFile, RouteTree } from "../src/routing/scanner";
 
 const makeRoute = (path: string, type: RouteFile["type"]): RouteFile => ({
 	path,

package/test/scanning.test.ts

@@ -2,7 +2,7 @@ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { mkdir, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
-import { filePathToRoutePath, scanRoutes } from "../src/scanner";
+import { filePathToRoutePath, scanRoutes } from "../src/routing/scanner";
 
 describe("File scanning", () => {
 	test("index.tsx → /", () => {
@@ -57,8 +57,14 @@ describe("File scanning", () => {
 	});
 
 	test("about/index.tsx, about/+page.tsx, and about.tsx all resolve to /about", () => {
-		const index = filePathToRoutePath("/app/routes/about/index.tsx", "/app/routes");
-		const page = filePathToRoutePath("/app/routes/about/+page.tsx", "/app/routes");
+		const index = filePathToRoutePath(
+			"/app/routes/about/index.tsx",
+			"/app/routes",
+		);
+		const page = filePathToRoutePath(
+			"/app/routes/about/+page.tsx",
+			"/app/routes",
+		);
 		const bare = filePathToRoutePath("/app/routes/about.tsx", "/app/routes");
 		expect(index.pattern).toBe("/about");
 		expect(page.pattern).toBe("/about");
@@ -66,13 +72,19 @@ describe("File scanning", () => {
 	});
 
 	test("+server.ts resolves to the same path as +page.tsx", () => {
-		const server = filePathToRoutePath("/app/routes/api/items/+server.ts", "/app/routes");
+		const server = filePathToRoutePath(
+			"/app/routes/api/items/+server.ts",
+			"/app/routes",
+		);
 		expect(server.pattern).toBe("/api/items");
 	});
 
 	test("+error.tsx resolves to its directory path", () => {
 		const root = filePathToRoutePath("/app/routes/+error.tsx", "/app/routes");
-		const nested = filePathToRoutePath("/app/routes/blog/+error.tsx", "/app/routes");
+		const nested = filePathToRoutePath(
+			"/app/routes/blog/+error.tsx",
+			"/app/routes",
+		);
 		expect(root.pattern).toBe("/");
 		expect(nested.pattern).toBe("/blog");
 	});
@@ -94,15 +106,24 @@ describe("Duplicate route detection", () => {
 		const dir = join(tmpDir, "dup-pages");
 		await mkdir(join(dir, "about"), { recursive: true });
 		await writeFile(join(dir, "about.tsx"), "export default () => null");
-		await writeFile(join(dir, "about", "index.tsx"), "export default () => null");
+		await writeFile(
+			join(dir, "about", "index.tsx"),
+			"export default () => null",
+		);
 		await expect(scanRoutes(dir)).rejects.toThrow('Duplicate page at "/about"');
 	});
 
 	test("+page.tsx and +page.server.ts at the same path do NOT conflict", async () => {
 		const dir = join(tmpDir, "no-conflict");
 		await mkdir(join(dir, "blog"), { recursive: true });
-		await writeFile(join(dir, "blog", "+page.tsx"), "export default () => null");
-		await writeFile(join(dir, "blog", "+page.server.ts"), "export async function load() {}");
+		await writeFile(
+			join(dir, "blog", "+page.tsx"),
+			"export default () => null",
+		);
+		await writeFile(
+			join(dir, "blog", "+page.server.ts"),
+			"export async function load() {}",
+		);
 		await expect(scanRoutes(dir)).resolves.toBeDefined();
 	});
 
@@ -112,7 +133,10 @@ describe("Duplicate route detection", () => {
 		// Bun glob finds all files; we simulate two +server files at same path via subdirs
 		// Use two different nesting depths that produce the same URL
 		await mkdir(join(dir, "api2"), { recursive: true });
-		await writeFile(join(dir, "api2", "+server.ts"), "export async function GET() {}");
+		await writeFile(
+			join(dir, "api2", "+server.ts"),
+			"export async function GET() {}",
+		);
 		await mkdir(join(dir, "api2", "index"), { recursive: true });
 		// Can't easily duplicate +server.ts via nesting — test the named-file vs +server collision instead
 		// Two +server.ts under different folder structures that map to same URL isn't possible without
@@ -134,7 +158,12 @@ describe("Duplicate route detection", () => {
 		const dir = join(tmpDir, "dup-mixed");
 		await mkdir(join(dir, "contact"), { recursive: true });
 		await writeFile(join(dir, "contact.tsx"), "export default () => null");
-		await writeFile(join(dir, "contact", "+page.tsx"), "export default () => null");
-		await expect(scanRoutes(dir)).rejects.toThrow('Duplicate page at "/contact"');
+		await writeFile(
+			join(dir, "contact", "+page.tsx"),
+			"export default () => null",
+		);
+		await expect(scanRoutes(dir)).rejects.toThrow(
+			'Duplicate page at "/contact"',
+		);
 	});
 });