owebjs 1.5.5-dev → 1.5.8-dev

package/dist/utils/assignRoutes.js

@@ -2,7 +2,7 @@ import {
   __name
 } from "../chunk-SHUYVCID.js";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
+import { pathToFileURL } from "node:url";
 import { buildRoutePath, buildRouteURL } from './utils.js';
 import { walk } from './walk.js';
 import { error, success, warn } from './logger.js';
@@ -13,27 +13,51 @@ import { WebSocketRoute } from '../structures/WebSocketRoute.js';
 import { FastifyWebSocketAdapter } from '../structures/FastifyWebSocketAdapter.js';
 import { formatSSE } from './utils.js';
 const websocketRoutes = {};
-const registeredWebSockets = /* @__PURE__ */ new Set();
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-let matcherOverrides = {};
-let routeFunctions = {
+const WS_REGISTRY_KEY = "ws:registered-routes";
+const createMethodMap = /* @__PURE__ */ __name(() => ({
   get: {},
   post: {},
   put: {},
   delete: {},
   patch: {},
   options: {}
-};
-const temporaryRequests = {
-  get: {},
-  post: {},
-  put: {},
-  delete: {},
-  patch: {},
-  options: {}
-};
+}), "createMethodMap");
+let matcherOverrides = {};
+let routeFunctions = createMethodMap();
+let temporaryRequests = createMethodMap();
 let routesCache = [];
-const compiledRoutes = {};
+let compiledRoutes = {};
+function normalizeFsPath(filePath) {
+  return path.resolve(filePath).replaceAll("\\", "/").toLowerCase();
+}
+__name(normalizeFsPath, "normalizeFsPath");
+async function importFreshModule(filePath, source) {
+  const resolvedHref = pathToFileURL(path.resolve(filePath)).href;
+  const cacheBuster = `?t=${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  if (source?.length && !/['"]\.\.?\//.test(source)) {
+    const stampedSource = `${source}
+//# sourceURL=${resolvedHref}${cacheBuster}`;
+    const dataUrl = `data:text/javascript;base64,${Buffer.from(stampedSource, "utf-8").toString("base64")}`;
+    try {
+      return await import(dataUrl);
+    } catch {
+    }
+  }
+  return import(resolvedHref + cacheBuster);
+}
+__name(importFreshModule, "importFreshModule");
+function resetRuntimeCaches(oweb) {
+  matcherOverrides = {};
+  routeFunctions = createMethodMap();
+  temporaryRequests = createMethodMap();
+  routesCache = [];
+  compiledRoutes = {};
+  for (const key of Object.keys(websocketRoutes)) {
+    delete websocketRoutes[key];
+  }
+  oweb._internalKV.delete(WS_REGISTRY_KEY);
+}
+__name(resetRuntimeCaches, "resetRuntimeCaches");
 function removeExtension(filePath) {
   const lastDotIndex = filePath.lastIndexOf(".");
   if (lastDotIndex !== -1) {
@@ -91,8 +115,7 @@ const applyMatcherHMR = /* @__PURE__ */ __name(async (oweb, op, workingDir, fall
     success(`Matcher ${filePath} compiled and reloaded in ${end}ms`, "HMR");
   } else {
     const start = Date.now();
-    const newFilePath = filePath.replaceAll("\\", "/");
-    const packageURL = new URL(path.resolve(newFilePath), `file://${__dirname}`).pathname.replaceAll("\\", "/");
+    const packageURL = pathToFileURL(path.resolve(filePath)).href;
     const cacheBuster = `?t=${Date.now()}`;
     def = (await import(packageURL + cacheBuster)).default;
     const end = Date.now() - start;
@@ -103,6 +126,7 @@ const applyMatcherHMR = /* @__PURE__ */ __name(async (oweb, op, workingDir, fall
   }
 }, "applyMatcherHMR");
 const applyRouteHMR = /* @__PURE__ */ __name(async (oweb, op, workingDir, fallbackDir, path2, content) => {
+  const normalizedChangedPath = normalizeFsPath(path2);
   if (path2.endsWith("hooks.js") || path2.endsWith("hooks.ts")) {
     warn(`Hot Module Replacement is not supported for hooks. Restart the server for changes to take effect.`, "HMR");
     return;
@@ -118,14 +142,30 @@ const applyRouteHMR = /* @__PURE__ */ __name(async (oweb, op, workingDir, fallba
     const files = await walk(workingDir, [], fallbackDir);
     const routes = await generateRoutes(files, path2);
     routesCache = routes;
-    const f = routes.find((x) => x.fileInfo.filePath == path2);
-    if (f?.fn?.prototype instanceof WebSocketRoute) {
+    const f = routes.find((x) => normalizeFsPath(x.fileInfo.filePath) === normalizedChangedPath);
+    if (!f) {
+      warn(`HMR could not resolve route metadata for file ${path2}`, "HMR");
+      return;
+    }
+    if (!path2.endsWith(".ts") && content.length) {
+      const fresh = await importFreshModule(path2, content);
+      if (fresh?.default) {
+        f.fn = fresh.default;
+      }
+    }
+    if (f.fn?.prototype instanceof WebSocketRoute) {
       assignSpecificRoute(oweb, f);
       const end2 = Date.now() - start;
       success(`WebSocket Route ${f.url} created in ${end2}ms`, "HMR");
       return;
     }
-    temporaryRequests[f.method.toLowerCase()][f.url] = inner(oweb, f);
+    const method = f.method.toLowerCase();
+    const nextHandler = inner(oweb, f);
+    if (routeFunctions[method][f.url]) {
+      routeFunctions[method][f.url] = nextHandler;
+    } else {
+      temporaryRequests[method][f.url] = nextHandler;
+    }
     const end = Date.now() - start;
     success(`Route ${f.method.toUpperCase()}:${f.url} created in ${end}ms`, "HMR");
   } else if (op === "modify-file") {
@@ -133,17 +173,31 @@ const applyRouteHMR = /* @__PURE__ */ __name(async (oweb, op, workingDir, fallba
     const files = await walk(workingDir, [], fallbackDir);
     const routes = await generateRoutes(files, path2);
     routesCache = routes;
-    const f = routes.find((x) => x.fileInfo.filePath == path2);
-    if (f?.fn?.prototype instanceof WebSocketRoute) {
+    const f = routes.find((x) => normalizeFsPath(x.fileInfo.filePath) === normalizedChangedPath);
+    if (!f) {
+      warn(`HMR could not resolve route metadata for file ${path2}`, "HMR");
+      return;
+    }
+    if (!path2.endsWith(".ts") && content.length) {
+      const fresh = await importFreshModule(path2, content);
+      if (fresh?.default) {
+        f.fn = fresh.default;
+      }
+    }
+    if (f.fn?.prototype instanceof WebSocketRoute) {
       websocketRoutes[f.url] = new f.fn();
       const end2 = Date.now() - start;
       success(`WebSocket Route ${f.url} reloaded in ${end2}ms`, "HMR");
       return;
     }
-    if (f.url in temporaryRequests[f.method.toLowerCase()]) {
-      temporaryRequests[f.method.toLowerCase()][f.url] = inner(oweb, f);
+    const method = f.method.toLowerCase();
+    const nextHandler = inner(oweb, f);
+    if (routeFunctions[method][f.url]) {
+      routeFunctions[method][f.url] = nextHandler;
+    } else if (f.url in temporaryRequests[method]) {
+      temporaryRequests[method][f.url] = nextHandler;
     } else {
-      routeFunctions[f.method.toLowerCase()][f.url] = inner(oweb, f);
+      routeFunctions[method][f.url] = nextHandler;
     }
     const end = Date.now() - start;
     success(`Route ${f.method.toUpperCase()}:${f.url} reloaded in ${end}ms`, "HMR");
@@ -176,8 +230,7 @@ const generateRoutes = /* @__PURE__ */ __name(async (files, onlyGenerateFn) => {
   const routes = [];
   for (const file of files) {
     const parsedFile = path.parse(file.rel);
-    const filePath = file.filePath.replaceAll("\\", "/");
-    const packageURL = new URL(path.resolve(filePath), `file://${__dirname}`).pathname.replaceAll("\\", "/");
+    const packageURL = pathToFileURL(path.resolve(file.filePath)).href;
     const routePath = buildRoutePath(parsedFile);
     const route = buildRouteURL(routePath);
     if (compiledRoutes[file.filePath]) {
@@ -191,7 +244,7 @@ const generateRoutes = /* @__PURE__ */ __name(async (files, onlyGenerateFn) => {
       continue;
     }
     let routeFuncs;
-    if (!(onlyGenerateFn && file.filePath !== onlyGenerateFn)) {
+    if (!(onlyGenerateFn && normalizeFsPath(file.filePath) !== normalizeFsPath(onlyGenerateFn))) {
       const cacheBuster = `?t=${Date.now()}`;
       const def = await import(packageURL + cacheBuster);
       routeFuncs = def.default;
@@ -212,141 +265,186 @@ function inner(oweb, route) {
   }
   const routeFunc = new route.fn();
   const matchers = route.matchers;
+  const hooks = route.fileInfo.hooks;
+  const hasHooks = hooks.length > 0;
+  const hasMatchers = matchers.length > 0;
   const isParametric = route.url.includes(":") || route.url.includes("*");
-  return function(req, res) {
-    if (oweb._internalKV.get("hmr") && isParametric) {
-      const currentPath = req.raw.url.split("?")[0];
-      const method = req.method.toLowerCase();
-      const specificHandler = temporaryRequests[method]?.[currentPath];
-      if (specificHandler && specificHandler !== temporaryRequests[route.method][route.url]) {
-        return specificHandler(req, res);
+  const handleIsAsync = routeFunc.handle.constructor.name === "AsyncFunction";
+  const hasRouteErrorHandler = typeof routeFunc?.handleError === "function";
+  const hmrEnabled = !!oweb._internalKV.get("hmr");
+  const checkMatchers = /* @__PURE__ */ __name((req) => {
+    if (!hasMatchers) return true;
+    for (const matcher of matchers) {
+      const param = req.params[matcher.paramName];
+      const fun = matcherOverrides[matcher.matcherName];
+      if (fun) {
+        return fun(param);
       }
     }
-    const checkMatchers = /* @__PURE__ */ __name(() => {
-      for (const matcher of matchers) {
-        const param = req.params[matcher.paramName];
-        const fun = matcherOverrides[matcher.matcherName];
-        if (fun) {
-          return fun(param);
-        }
+    return true;
+  }, "checkMatchers");
+  const handleError = /* @__PURE__ */ __name((req, res, err) => {
+    const normalizedError = err instanceof Error ? err : new Error(String(err));
+    if (hasRouteErrorHandler) {
+      routeFunc.handleError(req, res, normalizedError);
+    } else {
+      oweb._options.OWEB_INTERNAL_ERROR_HANDLER(req, res, normalizedError);
+    }
+  }, "handleError");
+  const streamResult = /* @__PURE__ */ __name(async (req, res, result, isAsyncIterable) => {
+    const iterator = isAsyncIterable ? result[Symbol.asyncIterator]() : result[Symbol.iterator]();
+    let firstChunk;
+    try {
+      firstChunk = await iterator.next();
+    } catch (err) {
+      handleError(req, res, err);
+      return;
+    }
+    if (res.sent) return;
+    if (firstChunk.done) {
+      if (firstChunk.value !== void 0) res.send(firstChunk.value);
+      return;
+    }
+    const rawObj = res.raw;
+    const uwsRes = rawObj.res && typeof rawObj.res.cork === "function" ? rawObj.res : null;
+    const corkedOp = /* @__PURE__ */ __name((op) => {
+      if (uwsRes) uwsRes.cork(op);
+      else op();
+    }, "corkedOp");
+    corkedOp(() => {
+      const headers = {
+        ...res.getHeaders(),
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      };
+      res.raw.writeHead(200, headers);
+      if (res.raw.flushHeaders) res.raw.flushHeaders();
+    });
+    let aborted = false;
+    const onAborted = /* @__PURE__ */ __name(() => {
+      aborted = true;
+    }, "onAborted");
+    if (res.raw.on) {
+      res.raw.on("close", onAborted);
+      res.raw.on("aborted", onAborted);
+    } else if (rawObj["onAborted"]) {
+      rawObj["onAborted"](onAborted);
+    }
+    try {
+      corkedOp(() => {
+        res.raw.write(formatSSE(firstChunk.value));
+      });
+      while (true) {
+        if (aborted || res.raw.destroyed) break;
+        const chunk = await iterator.next();
+        if (chunk.done) break;
+        corkedOp(() => {
+          res.raw.write(formatSSE(chunk.value));
+        });
       }
-      return true;
-    }, "checkMatchers");
-    const handle = /* @__PURE__ */ __name(async () => {
-      let result;
-      try {
-        if (routeFunc.handle.constructor.name === "AsyncFunction") {
-          result = await routeFunc.handle(req, res);
-        } else {
-          result = routeFunc.handle(req, res);
-          if (result instanceof Promise) {
-            result = await result;
-          }
-        }
-      } catch (error2) {
-        if (routeFunc?.handleError) {
-          routeFunc.handleError(req, res, error2);
-        } else {
-          oweb._options.OWEB_INTERNAL_ERROR_HANDLER(req, res, error2);
-        }
-        return;
+    } catch (err) {
+      error("Error while streaming response for " + route.method.toUpperCase() + ":" + route.url + " - " + err.message, "SSE");
+    } finally {
+      if (res.raw.off) {
+        res.raw.off("close", onAborted);
+        res.raw.off("aborted", onAborted);
       }
-      if (res.sent) return;
-      const isIterable = result && typeof result[Symbol.iterator] === "function";
-      const isAsyncIterable = result && typeof result[Symbol.asyncIterator] === "function";
-      if (isIterable || isAsyncIterable) {
-        const iterator = isAsyncIterable ? result[Symbol.asyncIterator]() : result[Symbol.iterator]();
-        let firstChunk;
-        try {
-          firstChunk = await iterator.next();
-        } catch (err) {
-          if (routeFunc?.handleError) routeFunc.handleError(req, res, err);
-          else oweb._options.OWEB_INTERNAL_ERROR_HANDLER(req, res, err);
-          return;
-        }
-        if (res.sent) return;
-        if (firstChunk.done) {
-          if (firstChunk.value !== void 0) res.send(firstChunk.value);
-          return;
-        }
-        const rawObj = res.raw;
-        const uwsRes = rawObj.res && typeof rawObj.res.cork === "function" ? rawObj.res : null;
-        const corkedOp = /* @__PURE__ */ __name((op) => {
-          if (uwsRes) uwsRes.cork(op);
-          else op();
-        }, "corkedOp");
+      if (!aborted && !res.raw.destroyed) {
         corkedOp(() => {
-          const headers = {
-            ...res.getHeaders(),
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            Connection: "keep-alive"
-          };
-          res.raw.writeHead(200, headers);
-          if (res.raw.flushHeaders) res.raw.flushHeaders();
+          res.raw.end();
         });
-        let aborted = false;
-        const onAborted = /* @__PURE__ */ __name(() => {
-          aborted = true;
-        }, "onAborted");
-        if (res.raw.on) {
-          res.raw.on("close", onAborted);
-          res.raw.on("aborted", onAborted);
-        } else if (rawObj["onAborted"]) {
-          rawObj["onAborted"](onAborted);
-        }
-        try {
-          corkedOp(() => {
-            res.raw.write(formatSSE(firstChunk.value));
-          });
-          while (true) {
-            if (aborted || res.raw.destroyed) break;
-            const chunk = await iterator.next();
-            if (chunk.done) break;
-            corkedOp(() => {
-              res.raw.write(formatSSE(chunk.value));
-            });
-          }
-        } catch (err) {
-          error(`Error while streaming response for ${route.method.toUpperCase()}:${route.url} - ${err.message}`, "SSE");
-        } finally {
-          if (res.raw.off) {
-            res.raw.off("close", onAborted);
-            res.raw.off("aborted", onAborted);
-          }
-          if (!aborted && !res.raw.destroyed) {
-            corkedOp(() => {
-              res.raw.end();
-            });
-          }
-        }
+      }
+    }
+  }, "streamResult");
+  const finalizeResult = /* @__PURE__ */ __name((req, res, result) => {
+    if (res.sent) return;
+    const isIterable = result && typeof result[Symbol.iterator] === "function";
+    const isAsyncIterable = result && typeof result[Symbol.asyncIterator] === "function";
+    if (isIterable || isAsyncIterable) {
+      streamResult(req, res, result, isAsyncIterable);
+      return;
+    }
+    if (!res.sent && result !== void 0) {
+      res.send(result);
+    }
+  }, "finalizeResult");
+  const executeRoute = handleIsAsync ? async (req, res) => {
+    try {
+      const result = await routeFunc.handle(req, res);
+      finalizeResult(req, res, result);
+    } catch (error2) {
+      handleError(req, res, error2);
+    }
+  } : (req, res) => {
+    let result;
+    try {
+      result = routeFunc.handle(req, res);
+    } catch (error2) {
+      handleError(req, res, error2);
+      return;
+    }
+    if (result instanceof Promise) {
+      result.then((resolved) => {
+        finalizeResult(req, res, resolved);
+      }).catch((error2) => {
+        handleError(req, res, error2);
+      });
+      return;
+    }
+    finalizeResult(req, res, result);
+  };
+  const isSimpleRoute = !hmrEnabled && !hasHooks && !hasMatchers && !isParametric;
+  if (isSimpleRoute) {
+    return function(req, res) {
+      executeRoute(req, res);
+    };
+  }
+  const runHooks = /* @__PURE__ */ __name((req, res) => {
+    let hookIndex = 0;
+    const runNextHook = /* @__PURE__ */ __name((hookErr) => {
+      if (hookErr) {
+        handleError(req, res, hookErr);
         return;
       }
-      if (!res.sent && result !== void 0) {
-        res.send(result);
+      if (res.sent) return;
+      if (hookIndex >= hooks.length) {
+        executeRoute(req, res);
+        return;
       }
-    }, "handle");
-    if (route.fileInfo.hooks.length) {
-      for (let index = 0; index < route.fileInfo.hooks.length; index++) {
-        const hookFun = route.fileInfo.hooks[index];
-        const hookInstance = typeof hookFun === "function" ? new hookFun() : hookFun;
-        hookInstance.handle(req, res, () => {
-          if (index + 1 == route.fileInfo.hooks.length) {
-            if (!checkMatchers()) {
-              send404(req, res);
-            } else {
-              handle();
-            }
-          }
-        });
+      const hookFun = hooks[hookIndex++];
+      const hookInstance = typeof hookFun === "function" ? new hookFun() : hookFun;
+      let doneCalled = false;
+      const done = /* @__PURE__ */ __name((doneErr) => {
+        if (doneCalled) return;
+        doneCalled = true;
+        runNextHook(doneErr);
+      }, "done");
+      try {
+        hookInstance.handle(req, res, done);
+      } catch (err) {
+        done(err);
       }
-    } else {
-      if (!checkMatchers()) {
-        send404(req, res);
-      } else {
-        handle();
+    }, "runNextHook");
+    runNextHook();
+  }, "runHooks");
+  return function(req, res) {
+    if (hmrEnabled && isParametric) {
+      const currentPath = req.raw.url.split("?")[0];
+      const method = req.method.toLowerCase();
+      const specificHandler = temporaryRequests[method]?.[currentPath];
+      if (specificHandler) {
+        return specificHandler(req, res);
       }
     }
+    if (!checkMatchers(req)) {
+      return send404(req, res);
+    }
+    if (!hasHooks) {
+      executeRoute(req, res);
+      return;
+    }
+    runHooks(req, res);
   };
 }
 __name(inner, "inner");
@@ -358,11 +456,21 @@ function send404(req, res) {
   });
 }
 __name(send404, "send404");
+function getRegisteredWebSocketsForApp(oweb) {
+  let wsRegistry = oweb._internalKV.get(WS_REGISTRY_KEY);
+  if (!wsRegistry) {
+    wsRegistry = /* @__PURE__ */ new Set();
+    oweb._internalKV.set(WS_REGISTRY_KEY, wsRegistry);
+  }
+  return wsRegistry;
+}
+__name(getRegisteredWebSocketsForApp, "getRegisteredWebSocketsForApp");
 function assignSpecificRoute(oweb, route) {
   if (!route?.fn) return;
   if (route?.fn?.prototype instanceof WebSocketRoute) {
     const wsInstance = new route.fn();
     websocketRoutes[route.url] = wsInstance;
+    const registeredWebSockets = getRegisteredWebSocketsForApp(oweb);
     if (!registeredWebSockets.has(route.url)) {
       registeredWebSockets.add(route.url);
       if (oweb._options.uWebSocketsEnabled && oweb.uServer) {
@@ -461,27 +569,34 @@ function assignSpecificRoute(oweb, route) {
     return;
   }
   const routeFunc = new route.fn();
-  routeFunctions[route.method][route.url] = inner(oweb, route);
-  oweb[route.method](route.url, routeFunc._options || {}, function(req, res) {
-    if (routeFunctions[route.method][route.url]) {
-      return routeFunctions[route.method][route.url](req, res);
-    } else {
-      const vals = temporaryRequests[route.method];
-      const keys = Object.keys(vals);
-      if (!vals || !keys.length) {
-        return send404(req, res);
-      }
-      const f = keys.find((tempName) => {
-        const matcher = match(tempName);
-        return matcher(req.url);
-      });
-      if (f && vals[f]) {
-        return vals[f](req, res);
+  const routeHandler = inner(oweb, route);
+  if (!routeHandler) return;
+  const hmrEnabled = !!oweb._internalKV.get("hmr");
+  if (hmrEnabled) {
+    routeFunctions[route.method][route.url] = routeHandler;
+    oweb[route.method](route.url, routeFunc._options || {}, function(req, res) {
+      if (routeFunctions[route.method][route.url]) {
+        return routeFunctions[route.method][route.url](req, res);
       } else {
-        return send404(req, res);
+        const vals = temporaryRequests[route.method];
+        const keys = Object.keys(vals);
+        if (!vals || !keys.length) {
+          return send404(req, res);
+        }
+        const f = keys.find((tempName) => {
+          const matcher = match(tempName);
+          return matcher(req.url);
+        });
+        if (f && vals[f]) {
+          return vals[f](req, res);
+        } else {
+          return send404(req, res);
+        }
       }
-    }
-  });
+    });
+    return;
+  }
+  oweb[route.method](route.url, routeFunc._options || {}, routeHandler);
 }
 __name(assignSpecificRoute, "assignSpecificRoute");
 async function loadMatchers(directoryPath) {
@@ -490,17 +605,18 @@ async function loadMatchers(directoryPath) {
     ".ts"
   ].includes(path.extname(f)));
   for (const file of files) {
-    const filePath = path.join(directoryPath, file).replaceAll("\\", "/");
+    const filePath = path.join(directoryPath, file);
     const fileName = path.basename(filePath);
-    const packageURL = new URL(path.resolve(filePath), `file://${__dirname}`).pathname.replaceAll("\\", "/");
+    const packageURL = pathToFileURL(path.resolve(filePath)).href;
     const def = await import(packageURL);
     matcherOverrides[removeExtension(fileName)] = def.default;
   }
 }
 __name(loadMatchers, "loadMatchers");
 const assignRoutes = /* @__PURE__ */ __name(async (oweb, directory, matchersDirectory) => {
+  resetRuntimeCaches(oweb);
   if (matchersDirectory) {
-    loadMatchers(matchersDirectory);
+    await loadMatchers(matchersDirectory);
   }
   const files = await walk(directory);
   const routes = await generateRoutes(files);
@@ -522,14 +638,16 @@ const assignRoutes = /* @__PURE__ */ __name(async (oweb, directory, matchersDire
     }
   }
   __name(fallbackHandle, "fallbackHandle");
-  for (const element of [
-    "get",
-    "post",
-    "put",
-    "patch",
-    "delete"
-  ]) {
-    oweb[element]("*", fallbackHandle);
+  if (oweb._internalKV.get("hmr")) {
+    for (const element of [
+      "get",
+      "post",
+      "put",
+      "patch",
+      "delete"
+    ]) {
+      oweb[element]("*", fallbackHandle);
+    }
   }
   for (const route of routes) {
     assignSpecificRoute(oweb, route);

package/dist/utils/walk.js

@@ -2,11 +2,10 @@ import {
   __name
 } from "../chunk-SHUYVCID.js";
 import { readdirSync, statSync } from "node:fs";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { pathToFileURL } from "node:url";
 import path from "node:path";
 import { mergePaths } from './utils.js';
 import { warn } from './logger.js';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const isParentOrGrandparent = /* @__PURE__ */ __name((parentFolderPath, childFolderPath) => {
   if (childFolderPath.startsWith(parentFolderPath)) {
     const relativePath = path.relative(parentFolderPath, childFolderPath);
@@ -15,8 +14,7 @@ const isParentOrGrandparent = /* @__PURE__ */ __name((parentFolderPath, childFol
   }
   return false;
 }, "isParentOrGrandparent");
-const hookPaths = /* @__PURE__ */ new Set();
-const walk = /* @__PURE__ */ __name(async (directory, tree = [], fallbackDir) => {
+const walk = /* @__PURE__ */ __name(async (directory, tree = [], fallbackDir, hookPaths = /* @__PURE__ */ new Set()) => {
   const results = [];
   const readDirPriority = readdirSync(directory);
   readDirPriority.sort((a, b) => {
@@ -40,7 +38,7 @@ const walk = /* @__PURE__ */ __name(async (directory, tree = [], fallbackDir) =>
       results.push(...await walk(filePath, [
         ...tree,
         fileName
-      ], fallbackDir));
+      ], fallbackDir, hookPaths));
     } else {
       if (![
         ".js",
@@ -76,7 +74,8 @@ const walk = /* @__PURE__ */ __name(async (directory, tree = [], fallbackDir) =>
             rootWalkDir = path.dirname(rootWalkDir);
           }
           const relHook = path.relative(rootWalkDir, hookPath);
-          const targetDir = path.join(process.cwd(), fallbackDir, relHook);
+          const fallbackRoot = path.isAbsolute(fallbackDir) ? fallbackDir : path.join(process.cwd(), fallbackDir);
+          const targetDir = path.join(fallbackRoot, relHook);
           targetFile = path.join(targetDir, "_hooks.js");
         } else {
           targetFile = path.join(hookPath, "_hooks.js");