@sigil-dev/grimoire 0.7.7 → 0.8.2

package/package.json

@@ -3,7 +3,7 @@
   "module": "index.ts",
   "type": "module",
   "private": false,
-  "version": "0.7.7",
+  "version": "0.8.2",
   "exports": {
     ".": "./index.ts",
     "./server": "./server.ts",
@@ -14,7 +14,8 @@
     "./vite": "./src/integrations/vite.ts",
     "./bun": "./src/rendering/ssrPlugin.ts",
     "./env/public": "./src/env/public.ts",
-    "./env/private": "./src/env/private.ts"
+    "./env/private": "./src/env/private.ts",
+    "./logger": "./src/logger/index.ts"
   },
   "bin": {
     "grimoire": "src/sync.ts"
@@ -32,13 +33,13 @@
     "vite": "^8.0.16"
   },
   "peerDependencies": {
-    "@sigil-dev/compiler": "0.7.7",
-    "@sigil-dev/runtime": "0.7.7",
+    "@sigil-dev/compiler": "0.8.2",
+    "@sigil-dev/runtime": "0.8.2",
     "typescript": "^5"
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "@sigil-dev/compiler": "0.7.7",
-    "@sigil-dev/runtime": "0.7.7"
+    "@sigil-dev/compiler": "0.8.2",
+    "@sigil-dev/runtime": "0.8.2"
   }
 }

package/server.ts

@@ -1,3 +1,4 @@
+export { log } from "./src/logger/instance.ts";
 export { scanRoutes } from "./src/routing/scanner";
 export { createServer } from "./src/server";
 export { buildProject } from "./src/server/build";

package/src/client/router.ts

@@ -10,7 +10,7 @@ let disposeCurrentPage: (() => void) | null = null;
 let currentPath = location.pathname;
 
 // C1: Navigation hooks
-let beforeNavigateCb: ((url: URL) => boolean | void) | null = null;
+let beforeNavigateCb: ((url: URL) => boolean | undefined) | null = null;
 let onNavigateCb: ((url: URL) => void) | null = null;
 let afterNavigateCb: ((url: URL) => void) | null = null;
 
@@ -36,7 +36,7 @@ export async function hmrRerender(): Promise<void> {
 
 // (globalThis as any).__grimoire_rerender__ = hmrRerender;
 
-export function beforeNavigate(cb: (url: URL) => boolean | void): void {
+export function beforeNavigate(cb: (url: URL) => boolean | undefined): void {
 	beforeNavigateCb = cb;
 }
 
@@ -120,7 +120,7 @@ function buildRouteTree(state: typeof lastState): any {
 			(l) =>
 				l.path === "/" ||
 				pattern === l.path ||
-				pattern.startsWith(l.path + "/"),
+				pattern.startsWith(`${l.path}/`),
 		)
 		.sort((a, b) => a.path.length - b.path.length);
 
@@ -212,6 +212,7 @@ export async function navigate(path: string) {
 	document.title = head?.title ?? document.title;
 	document.getElementById("grimoire-root")?.replaceChildren(rootNode);
 	currentPath = path;
+	history.pushState(null, "", path);
 	restoreScrollPosition(path);
 	afterNavigateCb?.(url);
 }

package/src/dev/compile-module.ts

@@ -1,13 +1,10 @@
 import { existsSync } from "node:fs";
-import { dirname, extname, join, relative } from "node:path";
+import { dirname, join, relative } from "node:path";
 import { pathToFileURL } from "node:url";
-import type { DevGraph } from "./graph";
-import { normalizePath } from "./paths";
 
 const RUNTIME_URL = "/__grimoire__/runtime.js";
 const MODULES_BASE = "/__grimoire__/m/";
 const DEPS_BASE = "/__grimoire__/dep/";
-
 /**
  * Rewrite a single import specifier to a browser-servable URL.
  * project-relative → /__grimoire__/m/...
@@ -72,7 +69,7 @@ function rewriteImports(
 ): string {
 	return code.replace(
 		/(from\s+|import\s+)(["'])([^"']+)\2/g,
-		(match, keyword, quote, specifier) => {
+		(_match, keyword, quote, specifier) => {
 			const rewritten = rewriteSpecifier(specifier, filePath, projectRoot);
 			return `${keyword}${quote}${rewritten}${quote}`;
 		},
@@ -119,11 +116,6 @@ export async function compileForBrowser(
 		plugins: [[sigilPlugin, { mode: "dom", hash }]],
 		filename: filePath,
 	});
-
-	console.log(
-		"[compile] babel output first 500 chars:",
-		babelResult?.code?.slice(0, 500),
-	);
 	// strip TypeScript types
 	const transpiler = new Bun.Transpiler({ loader: "ts", target: "browser" });
 	let js = transpiler.transformSync(babelResult?.code ?? "");
@@ -157,13 +149,12 @@ export async function compileForBrowser(
 	// inject scoped CSS at runtime
 	if (css) {
 		//biome-ignore lint: bro shut up already
-		js =
-			`if (typeof document !== 'undefined' && !document.getElementById('sigil-${hash}')) {
+		js = `if (typeof document !== 'undefined' && !document.getElementById('sigil-${hash}')) {
   const __s = document.createElement('style');
   __s.id = 'sigil-${hash}';
   __s.textContent = ${JSON.stringify(css)};
   document.head.appendChild(__s);
-}\n` + js;
+}\n${js}`;
 	}
 
 	// rewrite imports to browser-servable URLs

package/src/dev/hmr-server.ts

@@ -1,11 +1,14 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join, relative } from "node:path";
 import type { ServerWebSocket } from "bun";
+import { log } from "../logger/instance";
 import { compileForBrowser } from "./compile-module";
 import type { DevGraph } from "./graph";
 import { normalizePath } from "./paths";
 import { safeRead } from "./watcher";
 
+const logger = log.scope("hmr");
+
 export class HmrServer {
 	private clients = new Set<ServerWebSocket<any>>();
 	private v = 0;
@@ -31,7 +34,7 @@ export class HmrServer {
 	}
 
 	reload() {
-		console.log("[sigil hmr] sending reload to", this.clients.size, "clients");
+		logger.info("sending reload to", this.clients.size, "clients");
 		this.batch([{ kind: "reload" }]);
 	}
 
@@ -69,7 +72,7 @@ export async function compileAndSwap(
 	graph: DevGraph,
 	hmr: HmrServer,
 	projectRoot: string,
-	routeTree: any,
+	_routeTree: any,
 ): Promise<void> {
 	const key = normalizePath(filePath);
 	const node = graph.get(key);
@@ -105,7 +108,7 @@ export async function compileAndSwap(
 
 		if (!routeFile) {
 			// no route found — fall back to reload
-			console.log("[sigil hmr] no route affected, reloading");
+			logger.info("no route affected, reloading");
 			hmr.reload();
 			return;
 		}
@@ -114,7 +117,7 @@ export async function compileAndSwap(
 		const clientPath = relative(projectRoot, filePath).replace(/\\/g, "/");
 		const modUrl = `${clientPath}.js`;
 
-		console.log("[sigil hmr] compiled:", filePath, `v=${v}`);
+		logger.info(`compiled: ${filePath}, v=${v}`);
 
 		const payloads: object[] = [];
 
@@ -144,10 +147,7 @@ export async function compileAndSwap(
 				patterns: otherRoutes.map((r) => r.path),
 			});
 		}
-		console.log(
-			"[sigil hmr] sending batch:",
-			JSON.stringify(payloads, null, 2),
-		);
+		logger.info("sending batch:", JSON.stringify(payloads, null, 2));
 		hmr.batch(payloads);
 	} catch (e: any) {
 		const loc = extractLoc(e, filePath);
@@ -161,7 +161,7 @@ export async function handleChange(
 	filePath: string,
 	graph: DevGraph,
 	hmr: HmrServer,
-	srcDir: string,
+	_srcDir: string,
 	projectRoot: string,
 	routeTree: any,
 ): Promise<void> {
@@ -177,11 +177,11 @@ export async function handleChange(
 	}
 	const node = graph.get(key);
 	if (!node) {
-		console.log("[sigil hmr] unknown file, reloading:", filePath);
+		logger.info("unknown file, reloading:", filePath);
 		hmr.reload();
 		return;
 	}
 
-	console.log("[sigil hmr] changed:", filePath);
+	logger.info("changed:", filePath);
 	await compileAndSwap(filePath, graph, hmr, projectRoot, routeTree);
 }

package/src/dev/runtime-bundle.ts

@@ -1,5 +1,8 @@
-import { existsSync, mkdirSync } from "node:fs";
+import { mkdirSync } from "node:fs";
 import { join } from "node:path";
+import { log } from "../logger/instance";
+
+const logger = log.scope("runtime-bundle");
 
 export async function ensureRuntimeBundle(projectRoot: string): Promise<void> {
 	const outDir = join(projectRoot, "public/__grimoire__");
@@ -8,7 +11,7 @@ export async function ensureRuntimeBundle(projectRoot: string): Promise<void> {
 	// runtime
 	const runtimeOut = join(outDir, "runtime.js");
 	if (!(await Bun.file(runtimeOut).exists())) {
-		console.log("[sigil hmr] bundling runtime...");
+		logger.debug("bundling runtime...");
 		const result = await Bun.build({
 			entrypoints: [
 				join(projectRoot, "node_modules/@sigil-dev/runtime/index.ts"),
@@ -20,8 +23,8 @@ export async function ensureRuntimeBundle(projectRoot: string): Promise<void> {
 			minify: false,
 		});
 		if (!result.success)
-			console.error("[sigil hmr] runtime bundle failed:", result.logs);
-		else console.log("[sigil hmr] runtime bundled");
+			logger.error("[sigil hmr] runtime bundle failed:", result.logs);
+		else logger.debug("[sigil hmr] runtime bundled");
 	}
 
 	// grimoire client
@@ -45,5 +48,5 @@ export async function ensureRuntimeBundle(projectRoot: string): Promise<void> {
     export const afterNavigate = (cb) => window.__grimoire_afterNavigate__?.(cb);
     `.trim(),
 	);
-	console.log("[sigil hmr] grimoire client shim written");
+	logger.info("grimoire client shim written");
 }

package/src/integrations/vite.ts

@@ -22,7 +22,7 @@ export function grimoire(options: { routes?: string } = {}): Plugin {
 				: join(process.cwd(), options.routes ?? "src/routes");
 
 			// client entry
-			vite.middlewares.use("/__grimoire__/client.js", async (req, res) => {
+			vite.middlewares.use("/__grimoire__/client.js", async (_req, res) => {
 				const result = await vite.transformRequest(CLIENT_ENTRY);
 				if (!result) {
 					res.statusCode = 404;

package/src/logger/index.ts

@@ -0,0 +1,6 @@
+// src/logger/index.ts
+
+export * from "./logger.ts";
+export * from "./request-middleware.ts";
+export * from "./transports.ts";
+export * from "./types.ts";

package/src/logger/instance.ts

@@ -0,0 +1,6 @@
+import { Logger } from "./logger.ts";
+import { ConsoleTransport } from "./transports.ts";
+
+export const log = new Logger("grimoire", {
+	transports: [new ConsoleTransport()],
+});

package/src/logger/logger.ts

@@ -0,0 +1,113 @@
+// packages/grimoire/src/logger/logger.ts
+
+import type {
+	LogEntry,
+	LoggerOptions,
+	LogLevel,
+	LogTransport,
+	ScopedLogger,
+} from "./types.ts";
+import { LOG_LEVELS } from "./types.ts";
+
+export class Logger implements ScopedLogger {
+	private transports: LogTransport[];
+	private minLevel: number;
+	private filter?: (entry: LogEntry) => boolean;
+	private _scope: string;
+	private _worker?: string;
+	private _requestId?: string;
+
+	constructor(scope: string, options: LoggerOptions = {}, worker?: string) {
+		this._scope = scope;
+		this._worker = worker;
+		this.transports = options.transports ?? [];
+		this.minLevel =
+			LOG_LEVELS[
+				options.level ??
+					(process.env.LOG_LEVEL as LogLevel | undefined) ??
+					"info"
+			] ?? LOG_LEVELS.info;
+		this.filter = options.filter;
+	}
+
+	// called by loom coordinator after forking workers
+	setWorker(name: string) {
+		this._worker = name;
+	}
+
+	private write(level: LogLevel, message: string, ...args: unknown[]) {
+		if (LOG_LEVELS[level] < this.minLevel) return;
+
+		const data =
+			args.length === 0 ? undefined : args.length === 1 ? args[0] : args;
+
+		const entry: LogEntry = {
+			level,
+			scope: this._scope,
+			message,
+			data,
+			timestamp: Date.now(),
+			worker: this._worker,
+			requestId: this._requestId,
+		};
+
+		if (this.filter && !this.filter(entry)) return;
+		for (const t of this.transports) {
+			try {
+				t.write(entry);
+			} catch {}
+		}
+	}
+
+	debug(message: string, ...args: unknown[]) {
+		this.write("debug", message, ...args);
+	}
+	info(message: string, ...args: unknown[]) {
+		this.write("info", message, ...args);
+	}
+	warn(message: string, ...args: unknown[]) {
+		this.write("warn", message, ...args);
+	}
+	error(message: string, ...args: unknown[]) {
+		this.write("error", message, ...args);
+	}
+	fatal(message: string, ...args: unknown[]) {
+		this.write("fatal", message, ...args);
+	}
+
+	scope(name: string): ScopedLogger {
+		const child = new Logger(
+			`${this._scope}:${name}`,
+			{
+				transports: this.transports,
+				level: Object.keys(LOG_LEVELS).find(
+					(k) => LOG_LEVELS[k as LogLevel] === this.minLevel,
+				) as LogLevel,
+				filter: this.filter,
+			},
+			this._worker,
+		);
+		child._requestId = this._requestId;
+		return child;
+	}
+
+	withRequest(requestId: string): ScopedLogger {
+		const child = new Logger(
+			this._scope,
+			{
+				transports: this.transports,
+				level: Object.keys(LOG_LEVELS).find(
+					(k) => LOG_LEVELS[k as LogLevel] === this.minLevel,
+				) as LogLevel,
+				filter: this.filter,
+			},
+			this._worker,
+		);
+		child._requestId = requestId;
+		return child;
+	}
+
+	addTransport(t: LogTransport) {
+		this.transports.push(t);
+	}
+}

package/src/logger/request-middleware.ts

@@ -0,0 +1,24 @@
+// packages/grimoire/src/logger/request-middleware.ts
+// Injected automatically by Grimoire before hooks.server.ts runs.
+
+import crypto from "node:crypto";
+import type { Logger } from "./logger.ts";
+import type { ScopedLogger } from "./types.ts";
+
+declare module "@sigil-dev/grimoire" {
+	interface RequestLocals {
+		log: ScopedLogger;
+	}
+}
+
+export function createRequestMiddleware(root: Logger) {
+	return function requestMiddleware(
+		_req: Request,
+		locals: Record<string, unknown>,
+	) {
+		// 8-char hex ID — short enough to read in a terminal
+		const requestId = crypto.randomUUID().slice(0, 8);
+		locals.log = root.withRequest(requestId);
+		(locals.log as any)._requestId = requestId;
+	};
+}

package/src/logger/transports.ts

@@ -0,0 +1,117 @@
+// packages/grimoire/src/logger/transports.ts
+
+import { appendFileSync } from "node:fs";
+import type { LogEntry, LogTransport } from "./types.ts";
+
+// ── colours (only applied when stdout is a TTY) ──────────────────────────────
+
+const isTTY = process.stdout.isTTY;
+const c = isTTY
+	? {
+			reset: "\x1b[0m",
+			dim: "\x1b[2m",
+			bold: "\x1b[1m",
+			debug: "\x1b[90m", // grey
+			info: "\x1b[36m", // cyan
+			warn: "\x1b[33m", // yellow
+			error: "\x1b[31m", // red
+			fatal: "\x1b[35m", // magenta
+			scope: "\x1b[34m", // blue
+			req: "\x1b[32m", // green
+		}
+	: (Object.fromEntries(
+			[
+				"reset",
+				"dim",
+				"bold",
+				"debug",
+				"info",
+				"warn",
+				"error",
+				"fatal",
+				"scope",
+				"req",
+			].map((k) => [k, ""]),
+		) as Record<string, string>);
+
+const LEVEL_LABEL: Record<string, string> = {
+	debug: "DBG",
+	info: "INF",
+	warn: "WRN",
+	error: "ERR",
+	fatal: "FTL",
+};
+
+function ts(timestamp: number): string {
+	return new Date(timestamp).toISOString().slice(11, 23); // HH:mm:ss.ms
+}
+
+function formatData(data: unknown): string {
+	if (data === undefined) return "";
+	if (data instanceof Error) return `\n    ${data.stack ?? data.message}`;
+	if (typeof data !== "object" || data === null) return `  ${String(data)}`;
+
+	// flat key=value for simple objects, JSON block only for nested/complex
+	const entries = Object.entries(data as Record<string, unknown>);
+	const isFlat = entries.every(([, v]) => typeof v !== "object" || v === null);
+	if (isFlat) {
+		return `  ${entries.map(([k, v]) => `${colors.dim(`${k}=`)}${v}`).join("  ")}`;
+	}
+	// nested — indent but don't pretty-print the whole thing
+	return `\n    ${JSON.stringify(data).replace(/,/g, ", ")}`;
+}
+
+// ── ConsoleTransport ─────────────────────────────────────────────────────────
+
+export class ConsoleTransport implements LogTransport {
+	write(entry: LogEntry) {
+		const levelColor = c[entry.level] ?? c.info;
+		const label = LEVEL_LABEL[entry.level] ?? entry.level.toUpperCase();
+
+		const worker = entry.worker ? `${c.dim}[${entry.worker}]${c.reset} ` : "";
+		const requestId = entry.requestId
+			? `${c.req}#${entry.requestId.slice(0, 8)}${c.reset} `
+			: "";
+		const scope = `${c.scope}${entry.scope}${c.reset}`;
+		const time = `${c.dim}${ts(entry.timestamp)}${c.reset}`;
+		const lvl = `${levelColor}${c.bold}${label}${c.reset}`;
+		const msg = entry.message;
+		const data = formatData(entry.data);
+
+		const line = `${time} ${lvl} ${worker}${requestId}${scope}  ${msg}${data}`;
+
+		if (entry.level === "error" || entry.level === "fatal") {
+			process.stderr.write(`${line}\n`);
+		} else {
+			process.stdout.write(`${line}\n`);
+		}
+	}
+}
+
+// ── FileTransport ────────────────────────────────────────────────────────────
+// Writes newline-delimited JSON for ingestion by log collectors.
+
+export class FileTransport implements LogTransport {
+	constructor(private path: string) {}
+
+	write(entry: LogEntry) {
+		try {
+			appendFileSync(this.path, `${JSON.stringify(entry)}\n`);
+		} catch {
+			// if the file write fails we can't really do anything useful
+		}
+	}
+}
+
+// ── NullTransport ────────────────────────────────────────────────────────────
+// For tests — captures entries instead of printing them.
+
+export class NullTransport implements LogTransport {
+	readonly entries: LogEntry[] = [];
+	write(entry: LogEntry) {
+		this.entries.push(entry);
+	}
+	clear() {
+		this.entries.length = 0;
+	}
+}

package/src/logger/types.ts

@@ -0,0 +1,39 @@
+export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal";
+
+export const LOG_LEVELS: Record<LogLevel, number> = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3,
+	fatal: 4,
+};
+
+export interface LogEntry {
+	level: LogLevel;
+	scope: string;
+	message: string;
+	data?: unknown;
+	timestamp: number;
+	worker?: string; // injected by loom, e.g. "violet"
+	requestId?: string; // injected per-request by middleware
+}
+
+export interface LogTransport {
+	write(entry: LogEntry): void | Promise<void>;
+}
+
+export interface ScopedLogger {
+	debug(message: string, ...args: unknown[]): void;
+	info(message: string, ...args: unknown[]): void;
+	warn(message: string, ...args: unknown[]): void;
+	error(message: string, ...args: unknown[]): void;
+	fatal(message: string, ...args: unknown[]): void;
+	scope(name: string): ScopedLogger;
+	withRequest(requestId: string): ScopedLogger;
+}
+
+export interface LoggerOptions {
+	transports?: LogTransport[];
+	level?: LogLevel;
+	filter?: (entry: LogEntry) => boolean;
+}

package/src/rendering/hydrate.ts

@@ -1,5 +1,3 @@
-//@ts-expect-error compiler generated
-
 import {
 	claim,
 	getHydrationNodes,
@@ -7,6 +5,7 @@ import {
 	popHydrationNodes,
 	pushHydrationNodes,
 } from "@sigil-dev/runtime";
+//@ts-expect-error compiler generated
 import { layouts, routes } from "#grimoire-routes";
 import {
 	afterNavigate,
@@ -39,7 +38,7 @@ if (stateEl) {
 					(l: any) =>
 						l.path === "/" ||
 						state.pattern === l.path ||
-						state.pattern.startsWith(l.path + "/"),
+						state.pattern.startsWith(`${l.path}/`),
 				)
 				.sort((a: any, b: any) => a.path.length - b.path.length);
 

package/src/rendering/index.ts

@@ -1,5 +1,5 @@
+import { randomBytes } from "node:crypto";
 import { SafeHtml } from "@sigil-dev/runtime";
-import { randomBytes } from "crypto";
 import { findClosestError, type MatchedRoute } from "../routing/router";
 import type { RouteFile } from "../routing/scanner";
 import { isErrorResult } from "../sentinels/error.ts";

package/src/rendering/ssrPlugin.ts

@@ -1,8 +1,10 @@
 import { createHash } from "node:crypto";
 import { transformSync } from "@babel/core";
 import sigilPlugin from "@sigil-dev/compiler/babel";
+import { log } from "../logger/instance";
 import type { GrimoirePlugin } from "../types";
 
+const logger = log.scope("scope");
 let registered = false;
 
 export function registerSSRPlugin(plugins: GrimoirePlugin[] = []) {
@@ -27,7 +29,7 @@ export function registerSSRPlugin(plugins: GrimoirePlugin[] = []) {
 
 			build.onLoad({ filter: /\.tsx?$/ }, async ({ path }) => {
 				if (path.includes("index.tsx"))
-					console.log("[ssr-plugin] onLoad:", path);
+					logger.debug("[ssr-plugin] onLoad:", path);
 				const source = await Bun.file(path).text();
 
 				// node_modules and .grimoire files are plain TypeScript (no sigil JSX).
@@ -40,7 +42,7 @@ export function registerSSRPlugin(plugins: GrimoirePlugin[] = []) {
 				}
 
 				if (process.env.SIGIL_VERBOSE) {
-					console.log("[sigil-ssr] XFORM:", path);
+					logger.debug("[sigil-ssr] XFORM:", path);
 				}
 				const hash = createHash("md5").update(path).digest("hex").slice(0, 8);
 				const result = transformSync(source, {

package/src/routing/router.ts

@@ -34,7 +34,7 @@ export function matchRoute(tree: RouteTree, url: URL): MatchedRoute | null {
 		const layoutMatches = (l: RouteFile) =>
 			l.path === "/" ||
 			route.path === l.path ||
-			route.path.startsWith(l.path + "/");
+			route.path.startsWith(`${l.path}/`);
 
 		const layouts = tree.layouts
 			.filter((l) => l.type === "layout" && layoutMatches(l))
@@ -64,7 +64,7 @@ export function findClosestError(
 	while (segments.length >= 0) {
 		const prefix = `/${segments.join("/")}`;
 		const error = errors.find(
-			(e) => e.path === prefix || e.path === prefix + "/",
+			(e) => e.path === prefix || e.path === `${prefix}/`,
 		);
 		if (error) return error;
 		if (segments.length === 0) break;

package/src/routing/scanner.ts

@@ -81,7 +81,7 @@ export async function scanRoutes(
 		else if (name === "+error") type = "error";
 		else type = "simple";
 
-		const clientPath = "/" + relative(viteRoot, filePath).replace(/\\/g, "/");
+		const clientPath = `/${relative(viteRoot, filePath).replace(/\\/g, "/")}`;
 
 		const routeFile: RouteFile = {
 			path: pattern,

package/src/routing/transform-routes.ts

@@ -1,6 +1,6 @@
+import { basename, dirname, join, relative, resolve } from "node:path";
 import { transformSync } from "@babel/core";
 import sigilPlugin from "@sigil-dev/compiler/babel";
-import { basename, dirname, join, relative, resolve } from "path";
 import type { GrimoirePlugin } from "../types";
 import type { RouteFile } from "./scanner";
 

package/src/server/build.ts

@@ -1,7 +1,7 @@
+import { mkdir } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { cwd } from "node:process";
 import { sigil } from "@sigil-dev/compiler/bun";
-import { mkdir } from "fs/promises";
-import { isAbsolute, join } from "path";
-import { cwd } from "process";
 import { normalizePath } from "../dev/paths";
 import { generateManifest } from "../routing/manifest-gen";
 import type { RouteTree } from "../routing/scanner";

package/src/server/coordinator.ts

@@ -1,12 +1,11 @@
+import { join } from "node:path";
 import { type Subprocess, spawn } from "bun";
-import { join } from "path";
 import { matchRoute } from "../routing/router";
 import { type RouteFile, type RouteTree, scanRoutes } from "../routing/scanner";
 import type {
 	CoordinatorContext,
 	GrimoireConfig,
 	GrimoirePlugin,
-	Route,
 	WorkerDescriptor,
 	WorkerMode,
 } from "../types";
@@ -194,7 +193,7 @@ export async function startCoordinator(options: CoordinatorOptions) {
 						runHook(plugins, "onWorkerReady", descriptor);
 					}
 				},
-				onExit(proc, exitCode) {
+				onExit(_proc, exitCode) {
 					const intentional = stopping;
 					runHook(
 						plugins,
@@ -204,7 +203,7 @@ export async function startCoordinator(options: CoordinatorOptions) {
 					);
 					if (!intentional) {
 						console.error(
-							`[grimoire] worker ${descriptor.name ?? descriptor.mode + "-" + descriptor.index} crashed (exit ${exitCode}), respawning...`,
+							`[grimoire] worker ${descriptor.name ?? `${descriptor.mode}-${descriptor.index}`} crashed (exit ${exitCode}), respawning...`,
 						);
 						// respawn: same descriptor, same port
 						// (simplified — plugin-scale can override this behavior)
@@ -296,7 +295,7 @@ function defaultSerialize(locals: App.Locals, secret: string): string {
 	return Buffer.from(JSON.stringify({ payload, sig })).toString("base64");
 }
 
-function defaultDeserialize(raw: string, secret: string): App.Locals {
+function _defaultDeserialize(raw: string, secret: string): App.Locals {
 	const { payload, sig } = JSON.parse(Buffer.from(raw, "base64").toString());
 	const expected = new Bun.CryptoHasher("sha256")
 		.update(secret + payload)

package/src/server/index.ts

@@ -6,6 +6,7 @@ import { HMR_CLIENT_SOURCE } from "../dev/hmr-client.ts";
 import { HmrServer, handleChange } from "../dev/hmr-server.ts";
 import { makeDevLoader } from "../dev/loader.ts";
 import { startWatcher } from "../dev/watcher.ts";
+import { log } from "../logger/instance.ts";
 import { renderRoute } from "../rendering";
 import { registerSSRPlugin } from "../rendering/ssrPlugin";
 import { findClosestError, matchRoute } from "../routing/router";
@@ -13,7 +14,7 @@ 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, rebuildForChange } from "./build";
+import { buildProject } from "./build";
 import { createCookies } from "./cookie-utils";
 import type {
 	Handle,
@@ -25,6 +26,7 @@ import type {
 } from "./hooks";
 import { runDeserializeLocals, runHook, runRequestHooks } from "./plugins";
 
+const logger = log.scope("server");
 /**
  * Try to load hooks.server.ts from the project root.
  */
@@ -226,33 +228,29 @@ export async function createServer(config: GrimoireConfig = {}) {
 
 				const depsDir = join(process.cwd(), ".grimoire/deps");
 				mkdirSync(depsDir, { recursive: true });
-				const outFile = join(depsDir, depName + ".js");
+				const outFile = join(depsDir, `${depName}.js`);
 
 				if (!(await Bun.file(outFile).exists())) {
-					console.log("[sigil hmr] bundling dep:", pkgName);
+					logger.debug("bundling dep:", pkgName);
 					try {
 						const entry = Bun.resolveSync(pkgName, process.cwd());
 						const result = await Bun.build({
 							entrypoints: [entry],
 							outdir: depsDir,
-							naming: depName + ".js",
+							naming: `${depName}.js`,
 							target: "browser",
 							format: "esm",
 							minify: false,
 							external: ["@sigil-dev/runtime"],
 						});
 						if (!result.success) {
-							console.error(
-								"[sigil hmr] dep bundle failed:",
-								pkgName,
-								result.logs,
-							);
+							logger.error("dep bundle failed:", pkgName, result.logs);
 							return new Response(
 								`throw new Error("failed to bundle dep: ${pkgName}")`,
 								{ headers: { "Content-Type": "application/javascript" } },
 							);
 						}
-						console.log("[sigil hmr] bundled dep:", pkgName);
+						logger.debug("bundled dep:", pkgName);
 					} catch (e: any) {
 						return new Response(
 							`throw new Error("dep not found: ${pkgName}: ${e.message}")`,
@@ -648,6 +646,6 @@ export async function createServer(config: GrimoireConfig = {}) {
 		hostname: server.hostname,
 		stop: () => server.stop(),
 	});
-	console.log(`Grimoire running at http://${host}:${port}`);
+	// console.log(`Grimoire running at http://${host}:${port}`);
 	return server;
 }

package/src/server/worker.ts

@@ -1,7 +1,6 @@
 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;

package/test/context.test.ts

@@ -1,10 +1,10 @@
 // packages/grimoire/src/context.test.ts
-import { describe, expect, test } from "bun:test";
+import { expect, test } from "bun:test";
 import { createContext, getContext, setContext } from "@sigil-dev/runtime";
 import { runWithContext } from "../src/server/context";
 
 const UserKey = createContext<string>();
-const ThemeKey = createContext<string>();
+const _ThemeKey = createContext<string>();
 
 // 1. Basic: does it work at all
 test("getContext returns value set in same context", async () => {

package/test/hydration.test.ts

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

package/test/middleware.test.ts

@@ -42,7 +42,7 @@ describe("sequence()", () => {
 		const handler = sequence(a, b);
 		const res = await handler({
 			event: fakeEvent(),
-			resolve: async (evt) => new Response("OK"),
+			resolve: async (_evt) => new Response("OK"),
 		});
 
 		expect(order).toEqual(["a-before", "b-before", "b-after", "a-after"]);

package/test/rendering.test.ts

@@ -1,7 +1,7 @@
 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 { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir as osTmpDir } from "node:os";
+import { join } from "node:path";
 import { renderRoute } from "../src/rendering";
 import { matchRoute } from "../src/routing/router";
 import { scanRoutes } from "../src/routing/scanner";

package/test/scanning.test.ts

@@ -1,7 +1,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 { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { filePathToRoutePath, scanRoutes } from "../src/routing/scanner";
 
 describe("File scanning", () => {

package/test/server.test.ts

@@ -1,7 +1,7 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { mkdir, writeFile } from "fs/promises";
-import { tmpdir } from "os";
-import { join } from "path";
+import { mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { createServer } from "../src/server";
 
 // ── Sandbox note ─────────────────────────────────────────────────────────────

package/test/transform-routes.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "fs/promises";
-import { tmpdir } from "os";
-import { join } from "path";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import type { RouteFile } from "../src/routing/scanner";
 import { transformRoutes } from "../src/routing/transform-routes";