@sigil-dev/grimoire 0.4.0 → 0.6.0

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

@@ -1,28 +1,28 @@
-import { isFailResult } from "./fail";
-import { isErrorResult } from "./error";
-import type { Handle, InitFunction, RequestEvent, ResolveFunction } from "./hooks";
-import { isRedirectResult } from "./redirect";
+import type { ServerWebSocket } from "bun";
+import { renderRoute } from "../rendering";
+import { registerSSRPlugin } from "../rendering/ssrPlugin";
+import { findClosestError, matchRoute } from "../routing/router";
+import { isErrorResult } from "../sentinels/error.ts";
+import { isFailResult } from "../sentinels/fail.ts";
+import { isRedirectResult } from "../sentinels/redirect.ts";
+import type { GrimoireConfig, WsRouteHandler } from "../types";
+import { buildProject } from "./build";
 import { createCookies } from "./cookie-utils";
-import { sigil } from "@sigil-dev/compiler/bun";
-import { mkdir } from "fs/promises";
-import { isAbsolute, join } from "path";
-import { generateManifest } from "./manifest-gen";
-import { runHook, runRequestHooks } from "./plugins";
-import { renderRoute } from "./renderer";
-import { findClosestError, matchRoute } from "./router";
-import { scanRoutes } from "./scanner";
-import { registerSSRPlugin } from "./ssrPlugin";
-import { transformRoutes } from "./transform-routes";
-import { generateTypes } from "./typegen";
-import type { GrimoireConfig } from "./types";
+import type {
+	Handle,
+	InitFunction,
+	RequestEvent,
+	ResolveFunction,
+} from "./hooks";
+import { runDeserializeLocals, runHook, runRequestHooks } from "./plugins";
 
 /**
- * Try to load hooks.server.ts from the project root.
+ * Try to load hooks.index.ts from the project root.
  */
 async function loadHooks(
 	projectRoot: string,
 ): Promise<{ handle?: Handle; init?: InitFunction }> {
-	const hooksPath = join(projectRoot, "hooks.server.ts");
+	const hooksPath = `${projectRoot}/hooks.server.ts`;
 	try {
 		const mod = await import(hooksPath);
 		return { handle: mod.handle, init: mod.init };
@@ -32,91 +32,49 @@ async function loadHooks(
 	}
 }
 
+interface _WsInternalData {
+	params: Record<string, string>;
+	// always present at runtime — optional only to satisfy TypeScript;
+	// upgrade block gates on mod.websocket before calling server.upgrade()
+	__handler?: WsRouteHandler<any>;
+	[key: string]: unknown;
+}
+
 export async function createServer(config: GrimoireConfig = {}) {
+	// run config hooks
+	let finalConfig = config;
+	const earlyPlugins = config.plugins ?? [];
+	for (const plugin of earlyPlugins) {
+		finalConfig = plugin.config?.(finalConfig) ?? finalConfig;
+	}
 
-	registerSSRPlugin();
+	//w timings????
 	const {
 		port = 3000,
 		host = "localhost",
 		plugins = [],
 		routes = "src/routes",
-	} = config;
-
-	// run config hooks
-	let finalConfig = config;
-	for (const plugin of plugins) {
-		finalConfig = plugin.config?.(finalConfig) ?? finalConfig;
+		_skipBuild = false,
+	} = finalConfig;
+
+	registerSSRPlugin(plugins);
+	let tree: any;
+	if (!config._skipBuild) {
+		const { result, tree: _tree } = await buildProject(finalConfig, plugins);
+		if (!result.success) throw new Error("Grimoire: build failed");
+		tree = _tree;
+	} else {
+		// worker — build already done by loom, just scan routes
+		const { isAbsolute, join } = await import("node:path");
+		const { scanRoutes } = await import("../routing/scanner");
+		const routesDir = isAbsolute(routes) ? routes : join(process.cwd(), routes);
+		tree = await scanRoutes(routesDir, process.cwd());
 	}
 
-	// scan routes once at startup
-	const routesDir = isAbsolute(routes)
-		? routes.replace(/\0/g, "")
-		: join(process.cwd(), routes).replace(/\0/g, "");
-	const tree = await scanRoutes(routesDir, process.cwd());
-
-	await mkdir(join(process.cwd(), ".grimoire"), { recursive: true });
-
-	await generateTypes(tree, {
-		projectRoot: process.cwd(),
-		routesDir,
-		outDir: join(process.cwd(), ".grimoire/types"),
-	});
-
-	const compiledDir = join(process.cwd(), ".grimoire/compiled");
-	await mkdir(compiledDir, { recursive: true });
-
-	// Bun 1.3.13 bug: Bun.build's native parser runs before onLoad hooks fire,
-	// so .tsx files with TS syntax crash the bundler even with a sigil plugin.
-	// Fix: pre-transform route files to plain JS before Bun.build sees them,
-	// then generate per-mode manifests pointing at the compiled .js files.
-	const pageRoutes = tree.routes.filter(
-		(r) => r.type === "page" || r.type === "simple",
+	// Load hooks.index.ts
+	const { handle: hooksHandle, init: hooksInit } = await loadHooks(
+		process.cwd(),
 	);
-	const [hydrateFiles, domFiles] = await Promise.all([
-		transformRoutes(pageRoutes, compiledDir, "hydrate"),
-		transformRoutes(pageRoutes, compiledDir, "dom"),
-	]);
-
-	const hydrateManifest = join(process.cwd(), ".grimoire/_routes.hydrate.js");
-	const domManifest = join(process.cwd(), ".grimoire/_routes.dom.js");
-	await Promise.all([
-		Bun.write(hydrateManifest, generateManifest(pageRoutes, hydrateFiles)),
-		Bun.write(domManifest, generateManifest(pageRoutes, domFiles)),
-	]);
-
-	const makeRoutesPlugin = (manifestPath: string) => ({
-		name: "grimoire-routes",
-		setup(build: any) {
-			build.onResolve({ filter: /^#grimoire-routes$/ }, () => ({
-				path: manifestPath,
-			}));
-		},
-	});
-
-	const [hydrateResult, domResult] = await Promise.all([
-		Bun.build({
-			entrypoints: [join(import.meta.dir, "./hydrate.ts")],
-			outdir: join(process.cwd(), "public/__grimoire__"),
-			plugins: [sigil({ mode: "hydrate" }), makeRoutesPlugin(hydrateManifest)],
-		}),
-		Bun.build({
-			entrypoints: [join(import.meta.dir, "./client.ts")],
-			outdir: join(process.cwd(), "public/__grimoire__"),
-			plugins: [sigil({ mode: "dom" }), makeRoutesPlugin(domManifest)],
-		}),
-	]);
-
-	if (!hydrateResult.success) {
-		for (const log of hydrateResult.logs) console.error(log);
-		throw new Error("Grimoire: hydrate bundle build failed");
-	}
-	if (!domResult.success) {
-		for (const log of domResult.logs) console.error(log);
-		throw new Error("Grimoire: dom bundle build failed");
-	}
-
-	// Load hooks.server.ts
-	const { handle: hooksHandle, init: hooksInit } = await loadHooks(process.cwd());
 
 	// Run init hook if present
 	await hooksInit?.();
@@ -125,12 +83,19 @@ export async function createServer(config: GrimoireConfig = {}) {
 		port,
 		hostname: host,
 		fetch: async (req) => {
+			// Shared locals object for this request — same reference across all route handlers.
+			// hooks.index.ts handle() runs via resolve() for page routes only.
+			// For server/WebSocket routes, auth must use cookies/headers in upgrade().
+			// If this request came from a coordinator, deserialize its locals
+			const rawLocals = req.headers.get("X-Grimoire-Locals");
+			const locals: App.Locals = rawLocals
+				? ((await runDeserializeLocals(plugins, rawLocals)) ?? {})
+				: {};
+
 			return runRequestHooks(plugins, req, async () => {
 				const url = new URL(req.url);
 
-				const publicFile = Bun.file(
-					join(process.cwd(), "public", url.pathname),
-				);
+				const publicFile = Bun.file(`${process.cwd()}/public${url.pathname}`);
 				if (await publicFile.exists()) {
 					return new Response(publicFile);
 				}
@@ -150,14 +115,47 @@ export async function createServer(config: GrimoireConfig = {}) {
 					return new Response("Not Found", { status: 404 });
 				}
 
-				// API routes — no hooks
+				// API routes (+server.ts)
 				if (matched.route.type === "server") {
 					const mod = await import(matched.route.filePath);
+
+					// WebSocket upgrade path
+					const isWsUpgrade =
+						req.headers.get("upgrade")?.toLowerCase() === "websocket";
+					if (isWsUpgrade && mod.websocket) {
+						let extraData: Record<string, unknown> = {};
+						if (mod.upgrade) {
+							try {
+								const result = await mod.upgrade({
+									request: req,
+									params: matched.params,
+									url,
+									locals,
+								});
+								if (result && typeof result === "object") extraData = result;
+							} catch {
+								return new Response("Upgrade Required", { status: 426 });
+							}
+						}
+						const wsData: _WsInternalData = {
+							params: matched.params,
+							__handler: mod.websocket,
+							...extraData,
+						};
+						//@ts-expect-error i dont know what you are talking about please
+						if (server.upgrade(req, { data: wsData })) {
+							// Bun sends the 101 response — return undefined to signal no HTTP response
+							return undefined as unknown as Response;
+						}
+						return new Response("Upgrade Required", { status: 426 });
+					}
+
+					// HTTP method dispatch
 					const handler = mod[req.method];
 					if (!handler) {
 						return new Response("Method Not Allowed", { status: 405 });
 					}
-					return handler({ request: req, params: matched.params, url });
+					return handler({ request: req, params: matched.params, url, locals });
 				}
 
 				const HTTP_METHODS = [
@@ -179,7 +177,7 @@ export async function createServer(config: GrimoireConfig = {}) {
 					request: req,
 					url,
 					params: matched.params,
-					locals: {},
+					locals,
 					cookies,
 					setHeaders: (headers) => Object.assign(setHeadersMap, headers),
 				};
@@ -187,7 +185,10 @@ export async function createServer(config: GrimoireConfig = {}) {
 				// Resolve function: runs the actual page/form action logic
 				const resolve: ResolveFunction = async (evt) => {
 					// form actions
-					if (matched.pageServer && HTTP_METHODS.includes(evt.request.method as any)) {
+					if (
+						matched.pageServer &&
+						HTTP_METHODS.includes(evt.request.method as any)
+					) {
 						const mod = await import(matched.pageServer.filePath);
 						const handler = mod[evt.request.method];
 						if (handler) {
@@ -207,17 +208,25 @@ export async function createServer(config: GrimoireConfig = {}) {
 									});
 								}
 								if (isErrorResult(e)) {
-									const isApi = evt.request.headers.get("accept")?.includes("application/json");
+									const isApi = evt.request.headers
+										.get("accept")
+										?.includes("application/json");
 									if (isApi) {
 										return Response.json(
 											{ error: true, status: e.status, message: e.message },
 											{ status: e.status },
 										);
 									}
-									const errorPage = findClosestError(tree.errors, evt.url.pathname);
+									const errorPage = findClosestError(
+										tree.errors,
+										evt.url.pathname,
+									);
 									if (errorPage) {
 										const errMod = await import(errorPage.filePath);
-										const html = errMod.default({ status: e.status, message: e.message });
+										const html = errMod.default({
+											status: e.status,
+											message: e.message,
+										});
 										return new Response(html, {
 											status: e.status,
 											headers: { "Content-Type": "text/html" },
@@ -248,7 +257,14 @@ export async function createServer(config: GrimoireConfig = {}) {
 					}
 
 					// page routes
-					const response = await renderRoute(matched, evt.request, tree.errors, undefined, evt.locals);
+					const response = await renderRoute(
+						matched,
+						evt.request,
+						tree.errors,
+						undefined,
+						evt.locals,
+						plugins,
+					);
 
 					if (evt.request.headers.get("x-grimoire-navigate") === "1") {
 						return response;
@@ -288,7 +304,10 @@ export async function createServer(config: GrimoireConfig = {}) {
 
 				// Apply setHeaders
 				const setCookieHeaders = cookies.toHeaders();
-				if (setCookieHeaders.length > 0 || Object.keys(setHeadersMap).length > 0) {
+				if (
+					setCookieHeaders.length > 0 ||
+					Object.keys(setHeadersMap).length > 0
+				) {
 					const headers = new Headers(response.headers);
 					for (const [k, v] of Object.entries(setHeadersMap)) {
 						headers.set(k, v);
@@ -306,8 +325,37 @@ export async function createServer(config: GrimoireConfig = {}) {
 				return response;
 			});
 		},
+		websocket: {
+			open(ws: ServerWebSocket<_WsInternalData>) {
+				ws.data.__handler?.open?.(ws);
+			},
+			message(ws: ServerWebSocket<_WsInternalData>, data: string | Buffer) {
+				ws.data.__handler?.message?.(ws, data);
+			},
+			close(
+				ws: ServerWebSocket<_WsInternalData>,
+				code: number,
+				reason?: string,
+			) {
+				ws.data.__handler?.close?.(ws, code, reason);
+			},
+			drain(ws: ServerWebSocket<_WsInternalData>) {
+				ws.data.__handler?.drain?.(ws);
+			},
+		},
 	});
 
+	let stopping = false;
+	const handleShutdown = async () => {
+		if (stopping) return;
+		stopping = true;
+		await runHook(plugins, "onStop", "shutdown");
+		server.stop();
+		process.exit(0);
+	};
+	process.on("SIGINT", handleShutdown);
+	process.on("SIGTERM", handleShutdown);
+
 	await runHook(plugins, "onStart", {
 		port: server.port,
 		hostname: server.hostname,

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 = 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. */`,
@@ -139,7 +142,7 @@ function generateTypesForGroup(group: RouteGroup, outFileDir: string): string {
 	} else {
 		lines.push(
 			`export type PageData = Record<string, never>;`,
-			`export type PageProps = { params: Params };`,
+			`export type PageProps = { data: PageData; params: Params };`,
 			`export type PageServerLoad = never;`,
 			`export type Actions = Record<string, never>;`,
 			"",
@@ -161,7 +164,7 @@ function generateTypesForGroup(group: RouteGroup, outFileDir: string): string {
 	}
 
 	lines.push(
-		`export type LayoutProps = LayoutData & { params: Params; children?: unknown };`,
+		`export type LayoutProps = { data: LayoutData; params: Params; children?: unknown };`,
 		`export type LayoutServerLoad = (ctx: {`,
 		`  params: Params;`,
 		`  request: Request;`,
@@ -186,6 +189,27 @@ function generateTypesForGroup(group: RouteGroup, outFileDir: string): string {
 			`    locals: App.Locals;`,
 			`  }) => Response | Promise<Response>;`,
 			`};`,
+			``,
+			`export type UpgradeContext = {`,
+			`  request: Request;`,
+			`  params: Params;`,
+			`  url: URL;`,
+			`  locals: App.Locals;`,
+			`};`,
+			``,
+			`type _UpgradeReturn = "upgrade" extends keyof _SRV`,
+			`  ? _SRV["upgrade"] extends (...args: any[]) => any`,
+			`    ? Awaited<ReturnType<_SRV["upgrade"]>>`,
+			`    : {}`,
+			`  : {};`,
+			`export type WsData = { params: Params } & Omit<_UpgradeReturn, "__handler">;`,
+			``,
+			`export type WebSocketHandler = {`,
+			`  open?(ws: ServerWebSocket<WsData>): void | Promise<void>;`,
+			`  message?(ws: ServerWebSocket<WsData>, data: string | Buffer): void | Promise<void>;`,
+			`  close?(ws: ServerWebSocket<WsData>, code: number, reason?: string): void | Promise<void>;`,
+			`  drain?(ws: ServerWebSocket<WsData>): void | Promise<void>;`,
+			`};`,
 			"",
 		);
 	}
@@ -210,6 +234,59 @@ function generateAmbient(): string {
 		"  interface Locals extends Record<string, unknown> {}",
 		"}",
 		"",
+		"// Available in all route files without import.",
+		"// Params default to Record<string,string>; for per-route typed params import from './$types'.",
+		"// Note: using these globals widens return types — PageData loses concrete keys.",
+		"// For precise data inference annotate load() with PageServerLoad from './$types'.",
+		"",
+		"type PageServerLoad<",
+		"  P extends Record<string, string> = Record<string, string>",
+		"> = (ctx: {",
+		"  params: P;",
+		"  request: Request;",
+		"  url: URL;",
+		"  locals: App.Locals;",
+		"}) => Record<string, unknown> | Promise<Record<string, unknown>>;",
+		"",
+		"type LayoutServerLoad<",
+		"  P extends Record<string, string> = Record<string, string>",
+		"> = (ctx: {",
+		"  params: P;",
+		"  request: Request;",
+		"  url: URL;",
+		"  locals: App.Locals;",
+		"}) => Record<string, unknown> | Promise<Record<string, unknown>>;",
+		"",
+		"type RequestHandler<",
+		"  P extends Record<string, string> = Record<string, string>",
+		"> = (ctx: {",
+		"  params: P;",
+		"  request: Request;",
+		"  url: URL;",
+		"  locals: App.Locals;",
+		"}) => Response | Promise<Response>;",
+		"",
+		"type PageProps<",
+		"  D extends Record<string, unknown> = Record<string, unknown>,",
+		"  P extends Record<string, string> = Record<string, string>",
+		"> = { data: D; params: P };",
+		"",
+		"type LayoutProps<",
+		"  D extends Record<string, unknown> = Record<string, unknown>,",
+		"  P extends Record<string, string> = Record<string, string>",
+		"> = { data: D; params: P; children?: unknown };",
+		"",
+		"type ErrorProps = { status: number; message: string };",
+		"",
+		"type UpgradeContext<",
+		"  P extends Record<string, string> = Record<string, string>",
+		"> = {",
+		"  params: P;",
+		"  request: Request;",
+		"  url: URL;",
+		"  locals: App.Locals;",
+		"};",
+		"",
 	].join("\n");
 }