@njinlabs/njin 0.5.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@njinlabs/njin",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "A modern framework for building company profiles, landing pages, and content-driven websites.",
   "type": "module",
   "keywords": ["bun", "elysia", "surrealdb", "edgejs", "cms", "framework"],
@@ -29,6 +29,7 @@
     "./config": "./src/core/config.ts",
     "./boot": "./src/core/boot.ts",
     "./banner": "./src/core/banner.ts",
+    "./worker": "./src/core/worker.ts",
     "./adapters/*": "./src/core/adapters/*.ts"
   },
   "devDependencies": {

package/src/cli/build-assets.ts

@@ -0,0 +1,38 @@
+import { existsSync } from "node:fs";
+import { cp, mkdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+
+// Shared staging steps between `njin build` (compiled binary) and `njin build:worker`
+// (bundled JS entry) — both produce the same `out/public`, `out/src/views`, `out/_admin`
+// layout; only the server artifact itself differs.
+export const stageBuildAssets = async (root: string, outDir: string): Promise<void> => {
+  await rm(outDir, { recursive: true, force: true });
+  await mkdir(outDir, { recursive: true });
+
+  // Vite build — outDir is forced here regardless of what the project's own
+  // vite.config.ts says, so the build always lands in a predictable place.
+  const { build } = await import("vite");
+  await build({
+    configFile: join(root, "vite.config.ts"),
+    build: { outDir: join(outDir, "public"), emptyOutDir: true },
+  });
+  console.log("✓ Built client assets -> out/public");
+
+  // view.ts resolves views from process.cwd()/src/views at runtime, so the build
+  // output preserves that same relative layout instead of flattening it.
+  const viewsDir = join(root, "src/views");
+  if (existsSync(viewsDir)) {
+    await cp(viewsDir, join(outDir, "src/views"), { recursive: true });
+    console.log("✓ Copied views -> out/src/views");
+  } else {
+    console.log("• No src/views found — skipped");
+  }
+
+  const adminDir = join(root, "_admin");
+  if (existsSync(adminDir)) {
+    await cp(adminDir, join(outDir, "_admin"), { recursive: true });
+    console.log("✓ Copied admin panel -> out/_admin");
+  } else {
+    console.log("• No _admin found — skipped");
+  }
+};

package/src/cli/build-worker.ts

@@ -0,0 +1,96 @@
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { stageBuildAssets } from "./build-assets";
+
+const root = process.cwd();
+const outDir = join(root, "out");
+
+console.log("Building worker for production...\n");
+
+await stageBuildAssets(root, outDir);
+
+// Unlike `njin build`, this targets `bun out/worker.js` (or `new Worker("out/worker.js")`)
+// running from inside the project tree (not a self-contained binary), so node_modules is
+// always reachable via Bun's normal upward directory resolution — no need for build.ts's
+// native-binding/geoip path patching for the two packages that do stay external below.
+const entryPath = join(root, ".njin-worker-entry.ts");
+const configPath = join(root, "config.ts").replace(/\\/g, "/");
+
+try {
+  await Bun.write(
+    entryPath,
+    `import config from ${JSON.stringify(configPath)};
+import { loadConfig } from "@njinlabs/njin/config";
+
+// Both env vars must be set for real, and before the dynamic import() of boot below: static
+// imports are hoisted and evaluated before this file's own body runs, so view.ts (reached
+// transitively through that import) would otherwise still see NODE_ENV unset. Same reasoning
+// as dev.ts/start.ts.
+//
+// NODE_ENV in particular is also baked in at build time via the "define" option below —
+// @njinlabs/njin's own source (view.ts's dev/production check included) is bundled directly
+// into worker.js (see the explicit "external" list below), not left as a separate runtime
+// import, specifically because a Bun Worker thread does not reliably propagate an in-script
+// process.env mutation across a module resolved from a genuinely external package — this
+// runtime assignment is belt-and-suspenders for anything that still reads it at runtime
+// (e.g. NJIN_WORKER, now read from the same bundled scope elysia.ts lives in).
+process.env.NODE_ENV = "production";
+process.env.NJIN_WORKER = "1";
+
+// Defaults rootDir to wherever this bundle itself physically ends up at runtime — not
+// process.cwd() (a supervisor process's Worker threads all share its cwd, so a runtime cwd
+// fallback would resolve src/views, _admin, public, and upload dirs against the wrong
+// directory), and not a literal build-time path baked in as a string constant either (that
+// would keep pointing at this build's own source tree even after out/worker.js — and the
+// public/src/views/_admin siblings staged alongside it — get copied somewhere else
+// entirely, e.g. into a supervisor's per-client clients/<host>/ directory). import.meta.dir
+// inside a Bun-bundled file resolves to that file's own real location at runtime, so it
+// stays correct no matter where the bundle is moved.
+await loadConfig({ ...config, rootDir: config.rootDir ?? import.meta.dir });
+
+const { boot } = await import("@njinlabs/njin/boot");
+
+// No printBanner() here — headless has no port/admin URL to show. serveWorker()'s own
+// "ready" postMessage() (src/core/worker.ts) is the supervisor's readiness signal instead.
+await boot();
+`,
+  );
+
+  const result = await Bun.build({
+    entrypoints: [entryPath],
+    outdir: outDir,
+    naming: "worker.js",
+    target: "bun",
+    // @njinlabs/njin's own source bundles directly into worker.js (see the comment in the
+    // generated entry above for why) — only the two packages that genuinely can't survive
+    // bundling stay external, same reasoning build.ts already documents for its own build:
+    // vite is dev-only (dead code once NODE_ENV is baked in as "production" below, but its own
+    // internal lazy import("esbuild") isn't installed as a real dependency) and @surrealdb/node
+    // is a native binding whose loader resolves its .node file relative to its own real
+    // file location — bundled, that location would become worker.js's, breaking the lookup.
+    // geoip-lite is external for a related reason: it resolves its .dat files via
+    // path.resolve(__dirname, '../data/'), and Bun bakes __dirname into bundled output as the
+    // literal build-time path (see build.ts) — fine on the exact machine that ran this build,
+    // but not guaranteed if out/ is copied elsewhere before running. Staying external keeps
+    // its own real file location intact.
+    // Unlike build.ts's compiled-binary case, none of these three need a copy/patch step here:
+    // worker.js still runs from inside a real project tree, so external resolution just finds
+    // the real node_modules/{vite,@surrealdb/node,geoip-lite} (vite is dev only, never
+    // actually reached).
+    external: ["vite", "@surrealdb/node", "geoip-lite"],
+    define: {
+      "process.env.NODE_ENV": JSON.stringify("production"),
+    },
+  });
+
+  if (!result.success) {
+    console.error("\n✗ Build failed");
+    for (const message of result.logs) console.error(message);
+    process.exit(1);
+  }
+
+  console.log("\n✓ Bundled worker -> out/worker.js");
+  console.log('\nRun it as a Worker thread:\n  new Worker("./out/worker.js")');
+} finally {
+  await rm(entryPath, { force: true });
+}

package/src/cli/build.ts

@@ -1,43 +1,15 @@
 import type { BunPlugin } from "bun";
-import { existsSync } from "node:fs";
 import { cp, mkdir, rm } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { stageBuildAssets } from "./build-assets";
 
 const root = process.cwd();
 const outDir = join(root, "out");
 
 console.log("Building for production...\n");
 
-await rm(outDir, { recursive: true, force: true });
-await mkdir(outDir, { recursive: true });
-
-// Vite build — outDir is forced here regardless of what the project's own
-// vite.config.ts says, so `njin build` always lands in a predictable place.
-const { build } = await import("vite");
-await build({
-  configFile: join(root, "vite.config.ts"),
-  build: { outDir: join(outDir, "public"), emptyOutDir: true },
-});
-console.log("✓ Built client assets -> out/public");
-
-// view.ts resolves views from process.cwd()/src/views at runtime, so the build
-// output preserves that same relative layout instead of flattening it.
-const viewsDir = join(root, "src/views");
-if (existsSync(viewsDir)) {
-  await cp(viewsDir, join(outDir, "src/views"), { recursive: true });
-  console.log("✓ Copied views -> out/src/views");
-} else {
-  console.log("• No src/views found — skipped");
-}
-
-const adminDir = join(root, "_admin");
-if (existsSync(adminDir)) {
-  await cp(adminDir, join(outDir, "_admin"), { recursive: true });
-  console.log("✓ Copied admin panel -> out/_admin");
-} else {
-  console.log("• No _admin found — skipped");
-}
+await stageBuildAssets(root, outDir);
 
 // surreal.ts only imports @surrealdb/node dynamically, on the embedded-db.path branch — so a
 // project whose resolved db.path is remote (ws/wss/http/https) never needs its native binding

package/src/cli/index.ts

@@ -14,15 +14,19 @@ switch (command) {
   case "build":
     await import("./build");
     break;
+  case "build:worker":
+    await import("./build-worker");
+    break;
   case "update":
     await import("./update");
     break;
   default:
-    console.log(`Usage: njin <create|dev|build|start|update>
+    console.log(`Usage: njin <create|dev|build|build:worker|start|update>
 
   create <dir>  Scaffold a new project (defaults to current directory)
   dev           Run the dev server (Vite HMR + live reload)
   build         Build for production -> ./out (public/, _admin/, views/, server)
+  build:worker  Build a headless worker for production -> ./out (public/, _admin/, views/, worker.js)
   start         Run from source in production mode (no compile)
   update        Update @njinlabs/njin to the latest version and refresh _admin/`);
     process.exit(command ? 1 : 0);

package/src/core/adapters/bun_filesystem.ts

@@ -1,7 +1,8 @@
 import type { FileAdapter } from "../../modules/file";
 import { init } from "@paralleldrive/cuid2";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import z from "zod";
+import { getConfig } from "../config";
 import { sanitizeFileName } from "../path_guard";
 
 const createId = init({
@@ -21,7 +22,10 @@ const bunFilesystemAdapter = ({ dir = "./uploads" }: { dir?: string } = {}): Fil
 
       const name = `${fileName}_${createId()}.${exts.join(".")}`;
 
-      await Bun.write(join(dir, name), await file.arrayBuffer());
+      // resolve(), not join() — dir is normally project-relative ("./uploads"), but an
+      // already-absolute dir (as tests pass directly) must win outright rather than get
+      // nested under rootDir.
+      await Bun.write(join(resolve(getConfig().rootDir, dir), name), await file.arrayBuffer());
 
       return {
         meta: null,
@@ -31,7 +35,7 @@ const bunFilesystemAdapter = ({ dir = "./uploads" }: { dir?: string } = {}): Fil
         url: `/uploads/${name}`,
       };
     },
-    unlink: (file) => Bun.file(join(dir, file.name)).delete(),
+    unlink: (file) => Bun.file(join(resolve(getConfig().rootDir, dir), file.name)).delete(),
   };
 };
 

package/src/core/banner.ts

@@ -30,7 +30,7 @@ export type BootSummary = {
 export const printBanner = ({ mode }: BootSummary): void => {
   const config = getConfig();
   const port = config.port;
-  const adminEntry = join(process.cwd(), "_admin", "index.html");
+  const adminEntry = join(config.rootDir, "_admin", "index.html");
   const hasAdmin = existsSync(adminEntry);
 
   const rows: [string, string][] = [

package/src/core/config.ts

@@ -36,6 +36,12 @@ export type HelperFactory = () => Promise<{ default: Helper }>;
 
 export type NjinConfig = {
   port?: number;
+  // Base directory every project-relative path (src/views, _admin, public, upload dirs)
+  // resolves against. Defaults to process.cwd() — only needs overriding by a build step
+  // (see build-worker.ts) that bakes in an absolute path for a runtime whose cwd isn't
+  // reliably the project root, e.g. multiple `new Worker(...)` instances sharing one
+  // supervisor process's cwd.
+  rootDir?: string;
   db?: {
     path?: string;
     namespace?: string;
@@ -62,6 +68,7 @@ export type NjinConfig = {
 
 export type ResolvedConfig = {
   port: number;
+  rootDir: string;
   db: { path: string; namespace: string; database: string; auth?: { username: string; password: string } | string };
   img: { hosts: string[] };
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -126,6 +133,7 @@ export const loadConfig = async (preloaded?: NjinConfig): Promise<void> => {
   // prefix fails the same way it already does today — naturally, at runtime.
   resolved = {
     port: userConfig.port ?? 3000,
+    rootDir: userConfig.rootDir ?? process.cwd(),
     db: {
       path: userConfig.db?.path ?? "rocksdb://data",
       namespace: userConfig.db?.namespace ?? "general",

package/src/core/worker.ts

@@ -0,0 +1,147 @@
+import type { AnyElysia } from "elysia";
+import logger from "../modules/logger";
+
+// This project's tsconfig only loads lib "DOM" (not "DOM.Iterable"/webworker), which ships no
+// DedicatedWorkerGlobalScope type. Bun's own docs recommend this exact local override — reusing
+// the DOM `Worker` interface's shape (postMessage/onmessage) as a stand-in for the worker-side
+// global, since both expose the same members. Scoped to this module only (not global) because
+// this file has imports/exports.
+declare var self: Worker;
+
+// Wire protocol between a supervisor thread (`new Worker("out/worker.js")`, spawned/terminated
+// on its own schedule) and this headless njin instance running inside that worker. The
+// supervisor owns request routing/load-balancing — this module only speaks the message shapes
+// below over `self.postMessage`/`self.onmessage`.
+export type WorkerRequestMessage = {
+  type: "request";
+  id: string;
+  method: string;
+  url: string;
+  headers: [string, string][];
+  body: ArrayBuffer | null;
+};
+
+export type WorkerShutdownMessage = {
+  type: "shutdown";
+};
+
+export type WorkerInboundMessage = WorkerRequestMessage | WorkerShutdownMessage;
+
+export type WorkerResponseMessage = {
+  type: "response";
+  id: string;
+  status: number;
+  headers: [string, string][];
+  body: ArrayBuffer | null;
+};
+
+export type WorkerErrorMessage = {
+  type: "error";
+  id: string;
+  message: string;
+};
+
+export type WorkerReadyMessage = {
+  type: "ready";
+};
+
+export type WorkerOutboundMessage = WorkerResponseMessage | WorkerErrorMessage | WorkerReadyMessage;
+
+// Bounds how long shutdown waits for in-flight requests to finish before exiting anyway —
+// the supervisor can terminate a worker at any time, so this is a safety net, not the
+// expected path.
+const SHUTDOWN_DRAIN_TIMEOUT_MS = 10_000;
+const SHUTDOWN_POLL_INTERVAL_MS = 50;
+
+const isRequestMessage = (raw: unknown): raw is WorkerRequestMessage =>
+  typeof raw === "object" && raw !== null && (raw as { type?: unknown }).type === "request";
+
+const isShutdownMessage = (raw: unknown): raw is WorkerShutdownMessage =>
+  typeof raw === "object" && raw !== null && (raw as { type?: unknown }).type === "shutdown";
+
+// Pure request/response conversion, split out from serveWorker()'s self/postMessage wiring
+// so it can be unit tested directly without spinning up a real Worker thread.
+export const buildResponseMessage = async (app: AnyElysia, msg: WorkerRequestMessage): Promise<WorkerResponseMessage> => {
+  const request = new Request(msg.url, {
+    method: msg.method,
+    headers: msg.headers,
+    body: msg.body ?? undefined,
+  });
+
+  const response = await app.handle(request);
+  const body = await response.arrayBuffer();
+
+  // lib.dom (without lib.dom.iterable) doesn't type Headers as iterable, so build the
+  // array via forEach rather than a for...of/spread over response.headers directly.
+  const headers: [string, string][] = [];
+  response.headers.forEach((value, key) => headers.push([key, value]));
+
+  return {
+    type: "response",
+    id: msg.id,
+    status: response.status,
+    headers,
+    body: body.byteLength > 0 ? body : null,
+  };
+};
+
+// Worker-mode replacement for `app.listen()` — wired in by elysia.ts's spin() when
+// NJIN_WORKER=1. Requests arrive as postMessage()s from the supervisor thread instead of
+// real socket connections; app.handle() is the same Elysia entrypoint either way.
+export const serveWorker = (app: AnyElysia): void => {
+  if (Bun.isMainThread) {
+    throw new Error('serveWorker() must run inside a Worker thread (new Worker("out/worker.js")), not the main thread.');
+  }
+
+  let inFlight = 0;
+  let shuttingDown = false;
+
+  const handleRequest = async (msg: WorkerRequestMessage): Promise<void> => {
+    if (shuttingDown) {
+      self.postMessage({ type: "error", id: msg.id, message: "worker is shutting down" } satisfies WorkerErrorMessage);
+      return;
+    }
+
+    inFlight++;
+    try {
+      self.postMessage(await buildResponseMessage(app, msg));
+    } catch (error) {
+      logger().error(error);
+      self.postMessage({
+        type: "error",
+        id: msg.id,
+        message: error instanceof Error ? error.message : "Unknown error",
+      } satisfies WorkerErrorMessage);
+    } finally {
+      inFlight--;
+    }
+  };
+
+  // No OS signal equivalent per-thread — the supervisor asks for a graceful shutdown by
+  // posting { type: "shutdown" } instead of sending SIGTERM/SIGINT to a whole process.
+  const shutdown = (): void => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+
+    const start = Date.now();
+    const poll = setInterval(() => {
+      if (inFlight === 0 || Date.now() - start > SHUTDOWN_DRAIN_TIMEOUT_MS) {
+        clearInterval(poll);
+        // Scoped to this worker thread only — confirmed in Bun's own docs — the supervisor's
+        // main thread and any sibling workers keep running.
+        process.exit(0);
+      }
+    }, SHUTDOWN_POLL_INTERVAL_MS);
+  };
+
+  self.onmessage = (event: MessageEvent<unknown>) => {
+    const raw = event.data;
+    if (isRequestMessage(raw)) {
+      void handleRequest(raw);
+    } else if (isShutdownMessage(raw)) {
+      shutdown();
+    }
+  };
+
+  self.postMessage({ type: "ready" } satisfies WorkerReadyMessage);
+};

package/src/modules/admin.ts

@@ -1,11 +1,14 @@
+import { getConfig } from "../core/config";
 import { makeModule } from "../core/module";
 import { resolveSafePath } from "../core/path_guard";
 import Elysia from "elysia";
 import { join } from "node:path";
 import elysia from "./elysia";
 
-const adminDir = join(process.cwd(), "_admin");
-const indexFile = () => Bun.file(join(adminDir, "index.html"));
+// Lazy, not a top-level const — this file's static import runs before module.ts's own
+// `await loadConfig()`, so getConfig() isn't populated yet at that point.
+const adminDir = () => join(getConfig().rootDir, "_admin");
+const indexFile = () => Bun.file(join(adminDir(), "index.html"));
 
 const admin = makeModule(() => {
   const fn = () => {};
@@ -22,7 +25,7 @@ const admin = makeModule(() => {
           return indexFile();
         }
 
-        const requested = resolveSafePath(adminDir, decoded);
+        const requested = resolveSafePath(adminDir(), decoded);
         if (!requested) return indexFile();
 
         const file = Bun.file(requested);

package/src/modules/elysia.ts

@@ -2,6 +2,7 @@ import cors from "@elysia/cors";
 import { getConfig } from "../core/config";
 import { UniqueConstraintError } from "../core/model";
 import { makeModule } from "../core/module";
+import { serveWorker } from "../core/worker";
 import Elysia, { status, ValidationError, type AnyElysia } from "elysia";
 import logger from "./logger";
 
@@ -73,8 +74,15 @@ const elysia = makeModule(() => {
     return {
       // No startup log here — the CLI prints one consolidated banner after every
       // module has finished booting (src/core/banner.ts), instead of one line per module.
+      // Worker mode (NJIN_WORKER=1, set by the generated `njin build:worker` entry) skips
+      // the real socket entirely — requests arrive via postMessage() from a supervisor-owned
+      // Worker thread instead (see src/core/worker.ts).
       spin: () => {
-        app.listen(getConfig().port);
+        if (process.env.NJIN_WORKER === "1") {
+          serveWorker(app);
+        } else {
+          app.listen(getConfig().port);
+        }
       },
     };
   };

package/src/modules/file.ts

@@ -3,7 +3,7 @@ import type { makeModel } from "../core/model";
 import { makeModule } from "../core/module";
 import { resolveSafePath } from "../core/path_guard";
 import Elysia from "elysia";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { RecordId } from "surrealdb";
 import z from "zod";
 import auth from "./auth";
@@ -95,7 +95,9 @@ const file = makeModule(() => {
     const adapterDir = getConfig().adapters.file.dir;
 
     if (adapterDir) {
-      const uploadsDir = join(process.cwd(), adapterDir);
+      // resolve(), not join() — adapterDir is normally project-relative, but an
+      // already-absolute dir must win outright rather than get nested under rootDir.
+      const uploadsDir = resolve(getConfig().rootDir, adapterDir);
 
       const uploadsController = new Elysia().get("/uploads/*", async ({ params }) => {
         // Elysia leaves wildcard params percent-encoded — decode before touching the filesystem.

package/src/modules/surreal.ts

@@ -61,6 +61,16 @@ const surreal = makeModule(() => {
 
     db = new Surreal({ engines });
     await db.connect(dbConfig.path, { authentication: dbConfig.auth });
+
+    // Explicit DEFINE, not left to auto-create-on-USE — that only happens for a
+    // root-authenticated connection, and isn't guaranteed across SurrealDB versions/configs.
+    // Needed for multi-tenant setups where several njin instances share one remote SurrealDB,
+    // each isolated into its own namespace (embedded engines are unaffected either way — a
+    // private local file always has implicit owner access). DEFINE DATABASE must run inside
+    // the namespace it belongs to, hence the two-step USE.
+    await db.query(`DEFINE NAMESPACE IF NOT EXISTS \`${dbConfig.namespace}\`;`);
+    await db.use({ namespace: dbConfig.namespace });
+    await db.query(`DEFINE DATABASE IF NOT EXISTS \`${dbConfig.database}\`;`);
     await db.use({ namespace: dbConfig.namespace, database: dbConfig.database });
 
     return {

package/src/modules/view.ts

@@ -7,7 +7,11 @@ import { join } from "path";
 import elysia from "./elysia";
 
 const isDev = process.env.NODE_ENV !== "production";
-const publicDir = join(process.cwd(), "public");
+// Lazy, not a top-level const — this module's static import runs (as a side effect of
+// module.ts importing it) before module.ts's own `await loadConfig()` line, so getConfig()
+// isn't populated yet at that point. Every call site below only runs from inside fn.init()
+// or a request handler, both well after loadConfig() has resolved.
+const publicDir = () => join(getConfig().rootDir, "public");
 
 type ViteManifestChunk = {
   file: string;
@@ -46,7 +50,7 @@ export const buildViteGlobal = async (): Promise<ViteGlobal> => {
     };
   }
 
-  const manifestFile = Bun.file(join(publicDir, "manifest.json"));
+  const manifestFile = Bun.file(join(publicDir(), "manifest.json"));
 
   if (!(await manifestFile.exists())) {
     return {
@@ -78,9 +82,10 @@ const view = makeModule(() => {
   const fn = () => edge;
 
   fn.init = async () => {
-    // process.cwd()-based, not import.meta.dir — once view.ts lives inside node_modules/njin,
-    // import.meta.dir would point at the package's own location, not the consuming project's views.
-    const viewsDir = join(process.cwd(), "src/views");
+    // getConfig().rootDir-based, not import.meta.dir — once view.ts lives inside
+    // node_modules/njin, import.meta.dir would point at the package's own location, not
+    // the consuming project's views.
+    const viewsDir = join(getConfig().rootDir, "src/views");
     const pagesDir = join(viewsDir, "pages");
 
     edge.mount(viewsDir);
@@ -111,7 +116,7 @@ const view = makeModule(() => {
 
     if (!isDev) {
       controller.get("/assets/*", async ({ params }) => {
-        const file = Bun.file(join(publicDir, "assets", params["*"]));
+        const file = Bun.file(join(publicDir(), "assets", params["*"]));
         if (!(await file.exists())) return new Response("Not Found", { status: 404 });
         return file;
       });
@@ -180,7 +185,7 @@ const view = makeModule(() => {
     // Catch-all — must be registered last so specific routes take priority
     controller.get("/*", async ({ path }) => {
       if (!isDev) {
-        const staticFile = Bun.file(join(publicDir, path));
+        const staticFile = Bun.file(join(publicDir(), path));
         if (await staticFile.exists()) return staticFile;
       }