@lolyjs/core 0.2.0-alpha.32 → 0.2.0-alpha.33

package/dist/index.cjs

@@ -9906,8 +9906,8 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/server.ts
-var import_fs21 = __toESM(require("fs"));
-var import_path27 = __toESM(require("path"));
+var import_fs22 = __toESM(require("fs"));
+var import_path28 = __toESM(require("path"));
 
 // modules/server/utils/server-dir.ts
 var import_fs = __toESM(require("fs"));
@@ -12550,7 +12550,7 @@ var ReaddirpStream = class extends import_node_stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
     if (wantBigintFsStats) {
-      this._stat = (path30) => statMethod(path30, { bigint: true });
+      this._stat = (path31) => statMethod(path31, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -12575,8 +12575,8 @@ var ReaddirpStream = class extends import_node_stream.Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path30, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path30));
+          const { path: path31, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path31));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -12616,20 +12616,20 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path30, depth) {
+  async _exploreDir(path31, depth) {
     let files;
     try {
-      files = await (0, import_promises.readdir)(path30, this._rdOptions);
+      files = await (0, import_promises.readdir)(path31, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path30 };
+    return { files, depth, path: path31 };
   }
-  async _formatEntry(dirent, path30) {
+  async _formatEntry(dirent, path31) {
     let entry;
     const basename3 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path30, basename3));
+      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path31, basename3));
       entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename3 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -13029,16 +13029,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path30, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path31, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path30);
-    emitRaw(rawEvent, evPath, { watchedPath: path30 });
-    if (evPath && path30 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path30, evPath), KEY_LISTENERS, sysPath.join(path30, evPath));
+    listener(path31);
+    emitRaw(rawEvent, evPath, { watchedPath: path31 });
+    if (evPath && path31 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path31, evPath), KEY_LISTENERS, sysPath.join(path31, evPath));
     }
   };
   try {
-    return (0, import_fs16.watch)(path30, {
+    return (0, import_fs16.watch)(path31, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -13054,12 +13054,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path30, fullPath, options, handlers) => {
+var setFsWatchListener = (path31, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path30, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path31, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -13070,7 +13070,7 @@ var setFsWatchListener = (path30, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path30,
+      path31,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -13085,7 +13085,7 @@ var setFsWatchListener = (path30, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await (0, import_promises2.open)(path30, "r");
+          const fd = await (0, import_promises2.open)(path31, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -13116,7 +13116,7 @@ var setFsWatchListener = (path30, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path30, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path31, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -13138,7 +13138,7 @@ var setFsWatchFileListener = (path30, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path30, curr));
+          foreach(cont.listeners, (listener2) => listener2(path31, curr));
         }
       })
     };
@@ -13166,13 +13166,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path30, listener) {
+  _watchWithNodeFs(path31, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path30);
-    const basename3 = sysPath.basename(path30);
+    const directory = sysPath.dirname(path31);
+    const basename3 = sysPath.basename(path31);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename3);
-    const absolutePath = sysPath.resolve(path30);
+    const absolutePath = sysPath.resolve(path31);
     const options = {
       persistent: opts.persistent
     };
@@ -13182,12 +13182,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path30, absolutePath, options, {
+      closer = setFsWatchFileListener(path31, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path30, absolutePath, options, {
+      closer = setFsWatchListener(path31, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -13209,7 +13209,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename3))
       return;
-    const listener = async (path30, newStats) => {
+    const listener = async (path31, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -13223,11 +13223,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path30);
+            this.fsw._closeFile(path31);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path30, closer2);
+              this.fsw._addPathCloser(path31, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -13259,7 +13259,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path30, item) {
+  async _handleSymlink(entry, directory, path31, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -13269,7 +13269,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises2.realpath)(path30);
+        linkPath = await (0, import_promises2.realpath)(path31);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -13279,12 +13279,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path30, entry.stats);
+          this.fsw._emit(EV.CHANGE, path31, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path30, entry.stats);
+        this.fsw._emit(EV.ADD, path31, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -13313,9 +13313,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path30 = sysPath.join(directory, item);
+      let path31 = sysPath.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path30, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path31, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -13324,8 +13324,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path30 = sysPath.join(dir, sysPath.relative(dir, path30));
-        this._addToNodeFs(path30, initialAdd, wh, depth + 1);
+        path31 = sysPath.join(dir, sysPath.relative(dir, path31));
+        this._addToNodeFs(path31, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve3, reject) => {
@@ -13394,13 +13394,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path30, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path31, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path30) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path31) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path30);
+    const wh = this.fsw._getWatchHelpers(path31);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -13416,8 +13416,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path30);
-        const targetPath = follow ? await (0, import_promises2.realpath)(path30) : path30;
+        const absPath = sysPath.resolve(path31);
+        const targetPath = follow ? await (0, import_promises2.realpath)(path31) : path31;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -13427,29 +13427,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises2.realpath)(path30) : path30;
+        const targetPath = follow ? await (0, import_promises2.realpath)(path31) : path31;
         if (this.fsw.closed)
           return;
         const parent = sysPath.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path30, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path31, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path30), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path31), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path30, closer);
+        this.fsw._addPathCloser(path31, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path30;
+        return path31;
       }
     }
   }
@@ -13492,26 +13492,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path30) {
-  if (typeof path30 !== "string")
+function normalizePath(path31) {
+  if (typeof path31 !== "string")
     throw new Error("string expected");
-  path30 = sysPath2.normalize(path30);
-  path30 = path30.replace(/\\/g, "/");
+  path31 = sysPath2.normalize(path31);
+  path31 = path31.replace(/\\/g, "/");
   let prepend = false;
-  if (path30.startsWith("//"))
+  if (path31.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path30.match(DOUBLE_SLASH_RE2))
-    path30 = path30.replace(DOUBLE_SLASH_RE2, "/");
+  while (path31.match(DOUBLE_SLASH_RE2))
+    path31 = path31.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path30 = "/" + path30;
-  return path30;
+    path31 = "/" + path31;
+  return path31;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path30 = normalizePath(testString);
+  const path31 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path30, stats)) {
+    if (pattern(path31, stats)) {
       return true;
     }
   }
@@ -13551,19 +13551,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path30) => toUnix(sysPath2.normalize(toUnix(path30)));
-var normalizeIgnored = (cwd = "") => (path30) => {
-  if (typeof path30 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path30) ? path30 : sysPath2.join(cwd, path30));
+var normalizePathToUnix = (path31) => toUnix(sysPath2.normalize(toUnix(path31)));
+var normalizeIgnored = (cwd = "") => (path31) => {
+  if (typeof path31 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path31) ? path31 : sysPath2.join(cwd, path31));
   } else {
-    return path30;
+    return path31;
   }
 };
-var getAbsolutePath = (path30, cwd) => {
-  if (sysPath2.isAbsolute(path30)) {
-    return path30;
+var getAbsolutePath = (path31, cwd) => {
+  if (sysPath2.isAbsolute(path31)) {
+    return path31;
   }
-  return sysPath2.join(cwd, path30);
+  return sysPath2.join(cwd, path31);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -13618,10 +13618,10 @@ var DirEntry = class {
 var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-  constructor(path30, follow, fsw) {
+  constructor(path31, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path30;
-    this.path = path30 = path30.replace(REPLACER_RE, "");
+    const watchPath = path31;
+    this.path = path31 = path31.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -13743,20 +13743,20 @@ var FSWatcher = class extends import_events.EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path30) => {
-        const absPath = getAbsolutePath(path30, cwd);
+      paths = paths.map((path31) => {
+        const absPath = getAbsolutePath(path31, cwd);
         return absPath;
       });
     }
-    paths.forEach((path30) => {
-      this._removeIgnoredPath(path30);
+    paths.forEach((path31) => {
+      this._removeIgnoredPath(path31);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path30) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path30, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path31) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path31, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -13778,17 +13778,17 @@ var FSWatcher = class extends import_events.EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path30) => {
-      if (!sysPath2.isAbsolute(path30) && !this._closers.has(path30)) {
+    paths.forEach((path31) => {
+      if (!sysPath2.isAbsolute(path31) && !this._closers.has(path31)) {
         if (cwd)
-          path30 = sysPath2.join(cwd, path30);
-        path30 = sysPath2.resolve(path30);
+          path31 = sysPath2.join(cwd, path31);
+        path31 = sysPath2.resolve(path31);
       }
-      this._closePath(path30);
-      this._addIgnoredPath(path30);
-      if (this._watched.has(path30)) {
+      this._closePath(path31);
+      this._addIgnoredPath(path31);
+      if (this._watched.has(path31)) {
         this._addIgnoredPath({
-          path: path30,
+          path: path31,
           recursive: true
         });
       }
@@ -13852,38 +13852,38 @@ var FSWatcher = class extends import_events.EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path30, stats) {
+  async _emit(event, path31, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path30 = sysPath2.normalize(path30);
+      path31 = sysPath2.normalize(path31);
     if (opts.cwd)
-      path30 = sysPath2.relative(opts.cwd, path30);
-    const args = [path30];
+      path31 = sysPath2.relative(opts.cwd, path31);
+    const args = [path31];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path30))) {
+    if (awf && (pw = this._pendingWrites.get(path31))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path30, [event, ...args]);
+        this._pendingUnlinks.set(path31, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path31) => {
+          this._pendingUnlinks.forEach((entry, path32) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path31);
+            this._pendingUnlinks.delete(path32);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path30)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path31)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path30);
+        this._pendingUnlinks.delete(path31);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -13901,16 +13901,16 @@ var FSWatcher = class extends import_events.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path30, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path31, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path30, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path31, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path30) : path30;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path31) : path31;
       let stats2;
       try {
         stats2 = await (0, import_promises3.stat)(fullPath);
@@ -13941,23 +13941,23 @@ var FSWatcher = class extends import_events.EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path30, timeout) {
+  _throttle(actionType, path31, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path30);
+    const actionPath = action.get(path31);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path30);
+      const item = action.get(path31);
       const count = item ? item.count : 0;
-      action.delete(path30);
+      action.delete(path31);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -13965,7 +13965,7 @@ var FSWatcher = class extends import_events.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path30, thr);
+    action.set(path31, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -13979,44 +13979,44 @@ var FSWatcher = class extends import_events.EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path30, threshold, event, awfEmit) {
+  _awaitWriteFinish(path31, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path30;
-    if (this.options.cwd && !sysPath2.isAbsolute(path30)) {
-      fullPath = sysPath2.join(this.options.cwd, path30);
+    let fullPath = path31;
+    if (this.options.cwd && !sysPath2.isAbsolute(path31)) {
+      fullPath = sysPath2.join(this.options.cwd, path31);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       (0, import_fs17.stat)(fullPath, (err, curStat) => {
-        if (err || !writes.has(path30)) {
+        if (err || !writes.has(path31)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path30).lastChange = now2;
+          writes.get(path31).lastChange = now2;
         }
-        const pw = writes.get(path30);
+        const pw = writes.get(path31);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path30);
+          writes.delete(path31);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path30)) {
-      writes.set(path30, {
+    if (!writes.has(path31)) {
+      writes.set(path31, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path30);
+          writes.delete(path31);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -14027,8 +14027,8 @@ var FSWatcher = class extends import_events.EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path30, stats) {
-    if (this.options.atomic && DOT_RE.test(path30))
+  _isIgnored(path31, stats) {
+    if (this.options.atomic && DOT_RE.test(path31))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -14038,17 +14038,17 @@ var FSWatcher = class extends import_events.EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path30, stats);
+    return this._userIgnored(path31, stats);
   }
-  _isntIgnored(path30, stat4) {
-    return !this._isIgnored(path30, stat4);
+  _isntIgnored(path31, stat4) {
+    return !this._isIgnored(path31, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path30) {
-    return new WatchHelper(path30, this.options.followSymlinks, this);
+  _getWatchHelpers(path31) {
+    return new WatchHelper(path31, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -14080,63 +14080,63 @@ var FSWatcher = class extends import_events.EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path30 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path30);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path30) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path30, 100))
+    const path31 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path31);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path31) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path31, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path30);
+    const wp = this._getWatchedDir(path31);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path30, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path31, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path30;
+    let relPath = path31;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path30);
+      relPath = sysPath2.relative(this.options.cwd, path31);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path30);
+    this._watched.delete(path31);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path30))
-      this._emit(eventName, path30);
-    this._closePath(path30);
+    if (wasTracked && !this._isIgnored(path31))
+      this._emit(eventName, path31);
+    this._closePath(path31);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path30) {
-    this._closeFile(path30);
-    const dir = sysPath2.dirname(path30);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path30));
+  _closePath(path31) {
+    this._closeFile(path31);
+    const dir = sysPath2.dirname(path31);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path31));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path30) {
-    const closers = this._closers.get(path30);
+  _closeFile(path31) {
+    const closers = this._closers.get(path31);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path30);
+    this._closers.delete(path31);
   }
-  _addPathCloser(path30, closer) {
+  _addPathCloser(path31, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path30);
+    let list = this._closers.get(path31);
     if (!list) {
       list = [];
-      this._closers.set(path30, list);
+      this._closers.set(path31, list);
     }
     list.push(closer);
   }
@@ -14822,12 +14822,12 @@ var DEFAULT_IGNORED_PATHS = [
   /^\/sockjs-node/
   // Hot reload websocket
 ];
-function shouldIgnorePath(path30, ignoredPaths) {
+function shouldIgnorePath(path31, ignoredPaths) {
   return ignoredPaths.some((pattern) => {
     if (typeof pattern === "string") {
-      return path30 === pattern || path30.startsWith(pattern);
+      return path31 === pattern || path31.startsWith(pattern);
     }
-    return pattern.test(path30);
+    return pattern.test(path31);
   });
 }
 function requestLoggerMiddleware(options = {}) {
@@ -14986,11 +14986,11 @@ function createStrictRateLimiterFromConfig(config) {
 }
 
 // modules/server/middleware/auto-rate-limit.ts
-function matchesStrictPattern(path30, patterns) {
+function matchesStrictPattern(path31, patterns) {
   for (const pattern of patterns) {
     const regexPattern = pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\//g, "\\/");
     const regex = new RegExp(`^${regexPattern}$`);
-    if (regex.test(path30)) {
+    if (regex.test(path31)) {
       return true;
     }
   }
@@ -15689,25 +15689,89 @@ function handleNotFound(res, urlPath) {
   }
 }
 
-// modules/server/handlers/ssg.ts
-var import_fs20 = __toESM(require("fs"));
+// modules/server/global-middleware.ts
 var import_path24 = __toESM(require("path"));
+var import_fs20 = __toESM(require("fs"));
+var cachedGlobalMiddlewares = null;
+async function loadGlobalMiddlewares(projectRoot) {
+  if (cachedGlobalMiddlewares !== null) {
+    return cachedGlobalMiddlewares;
+  }
+  const globalMiddlewareFile = import_path24.default.join(projectRoot, "global.middleware.ts");
+  const globalMiddlewareFileJs = import_path24.default.join(projectRoot, "global.middleware.js");
+  const file = import_fs20.default.existsSync(globalMiddlewareFile) ? globalMiddlewareFile : import_fs20.default.existsSync(globalMiddlewareFileJs) ? globalMiddlewareFileJs : null;
+  if (!file) {
+    cachedGlobalMiddlewares = [];
+    return cachedGlobalMiddlewares;
+  }
+  if (file.endsWith(".ts") || file.endsWith(".tsx")) {
+    try {
+      require("tsx/cjs");
+    } catch (e) {
+    }
+  }
+  try {
+    const mod = require(file);
+    const middlewares = mod?.globalMiddlewares;
+    if (Array.isArray(middlewares)) {
+      const validMiddlewares = [];
+      for (let i = 0; i < middlewares.length; i++) {
+        const mw = middlewares[i];
+        if (typeof mw === "function") {
+          validMiddlewares.push(mw);
+        } else {
+          console.warn(
+            `[framework][global-middleware] Middleware at index ${i} in global.middleware.ts is not a function, skipping`
+          );
+        }
+      }
+      cachedGlobalMiddlewares = validMiddlewares;
+      return cachedGlobalMiddlewares;
+    } else if (middlewares !== void 0) {
+      console.warn(
+        "[framework][global-middleware] globalMiddlewares must be an array in global.middleware.ts, ignoring invalid value"
+      );
+    }
+  } catch (error) {
+    console.error("[framework][global-middleware] Error loading global.middleware.ts:", error);
+  }
+  cachedGlobalMiddlewares = [];
+  return cachedGlobalMiddlewares;
+}
+async function runGlobalMiddlewares(ctx, globalMiddlewares) {
+  for (const mw of globalMiddlewares) {
+    try {
+      await Promise.resolve(mw(ctx, async () => {
+      }));
+    } catch (error) {
+      console.error("[framework][global-middleware] Error in global middleware:", error);
+      continue;
+    }
+    if (ctx.res.headersSent) {
+      return;
+    }
+  }
+}
+
+// modules/server/handlers/ssg.ts
+var import_fs21 = __toESM(require("fs"));
+var import_path25 = __toESM(require("path"));
 var logger3 = createModuleLogger("ssg");
 function getSsgDirForPath(baseDir, urlPath) {
   const clean = urlPath === "/" ? "" : urlPath.replace(/^\/+/, "");
-  return import_path24.default.join(baseDir, clean);
+  return import_path25.default.join(baseDir, clean);
 }
 function getSsgHtmlPath(baseDir, urlPath) {
   const dir = getSsgDirForPath(baseDir, urlPath);
-  return import_path24.default.join(dir, "index.html");
+  return import_path25.default.join(dir, "index.html");
 }
 function getSsgDataPath(baseDir, urlPath) {
   const dir = getSsgDirForPath(baseDir, urlPath);
-  return import_path24.default.join(dir, "data.json");
+  return import_path25.default.join(dir, "data.json");
 }
 function tryServeSsgHtml(res, ssgOutDir, urlPath) {
   const ssgHtmlPath = getSsgHtmlPath(ssgOutDir, urlPath);
-  if (!import_fs20.default.existsSync(ssgHtmlPath)) {
+  if (!import_fs21.default.existsSync(ssgHtmlPath)) {
     return false;
   }
   logger3.info("Serving SSG HTML", { urlPath, ssgHtmlPath });
@@ -15717,17 +15781,17 @@ function tryServeSsgHtml(res, ssgOutDir, urlPath) {
   );
   res.statusCode = 200;
   res.setHeader("Content-Type", "text/html; charset=utf-8");
-  const stream = import_fs20.default.createReadStream(ssgHtmlPath, { encoding: "utf-8" });
+  const stream = import_fs21.default.createReadStream(ssgHtmlPath, { encoding: "utf-8" });
   stream.pipe(res);
   return true;
 }
 function tryServeSsgData(res, ssgOutDir, urlPath) {
   const ssgDataPath = getSsgDataPath(ssgOutDir, urlPath);
-  if (!import_fs20.default.existsSync(ssgDataPath)) {
+  if (!import_fs21.default.existsSync(ssgDataPath)) {
     return false;
   }
   try {
-    const raw = import_fs20.default.readFileSync(ssgDataPath, "utf-8");
+    const raw = import_fs21.default.readFileSync(ssgDataPath, "utf-8");
     res.setHeader("Content-Type", "application/json; charset=utf-8");
     res.status(200).end(raw);
     return true;
@@ -15739,7 +15803,7 @@ function tryServeSsgData(res, ssgOutDir, urlPath) {
 
 // modules/server/handlers/pages.ts
 init_globals();
-var import_path25 = __toESM(require("path"));
+var import_path26 = __toESM(require("path"));
 function mergeMetadata(base, override) {
   if (!base && !override) return null;
   if (!base) return override;
@@ -15797,7 +15861,7 @@ async function renderNotFoundPage(notFoundPage, req, res, urlPath, finalUrlPath,
           } catch (error) {
             const reqLogger = getRequestLogger(req);
             const layoutFile = notFoundPage.layoutFiles[i];
-            const relativeLayoutPath = layoutFile ? import_path25.default.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
+            const relativeLayoutPath = layoutFile ? import_path26.default.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
             reqLogger.error("Layout middleware failed for not-found page", error instanceof Error ? error : new Error(String(error)), {
               layoutIndex: i,
               layoutFile: relativeLayoutPath
@@ -15826,7 +15890,7 @@ async function renderNotFoundPage(notFoundPage, req, res, urlPath, finalUrlPath,
         } catch (error) {
           const reqLogger = getRequestLogger(req);
           const layoutFile = notFoundPage.layoutFiles[i];
-          const relativeLayoutPath = layoutFile ? import_path25.default.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
+          const relativeLayoutPath = layoutFile ? import_path26.default.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
           reqLogger.warn("Layout server hook failed for not-found page", {
             error: error instanceof Error ? error.message : String(error),
             stack: error instanceof Error ? error.stack : void 0,
@@ -16063,6 +16127,11 @@ async function handlePageRequestInternal(options) {
     Redirect: (destination, permanent = false) => new RedirectResponse(destination, permanent),
     NotFound: () => new NotFoundResponse()
   };
+  const globalMiddlewares = await loadGlobalMiddlewares(projectRoot || process.cwd());
+  await runGlobalMiddlewares(ctx, globalMiddlewares);
+  if (res.headersSent) {
+    return;
+  }
   await runRouteMiddlewares(route, ctx);
   if (res.headersSent) {
     return;
@@ -16083,7 +16152,7 @@ async function handlePageRequestInternal(options) {
             );
           } catch (error) {
             const layoutFile = route.layoutFiles[i];
-            const relativeLayoutPath = layoutFile ? import_path25.default.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
+            const relativeLayoutPath = layoutFile ? import_path26.default.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
             reqLogger.error("Layout middleware failed", error instanceof Error ? error : new Error(String(error)), {
               route: route.pattern,
               layoutIndex: i,
@@ -16149,7 +16218,7 @@ async function handlePageRequestInternal(options) {
           }
         } catch (error) {
           const layoutFile = route.layoutFiles[i];
-          const relativeLayoutPath = layoutFile ? import_path25.default.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
+          const relativeLayoutPath = layoutFile ? import_path26.default.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
           reqLogger.warn("Layout server hook failed", {
             error: error instanceof Error ? error.message : String(error),
             stack: error instanceof Error ? error.stack : void 0,
@@ -16212,7 +16281,7 @@ async function handlePageRequestInternal(options) {
       pageLoaderResult2.theme = theme;
     }
   } catch (error) {
-    const relativePagePath = route.pageFile ? import_path25.default.relative(projectRoot || process.cwd(), route.pageFile) : "unknown";
+    const relativePagePath = route.pageFile ? import_path26.default.relative(projectRoot || process.cwd(), route.pageFile) : "unknown";
     reqLogger.error("Page server hook failed", {
       error: error instanceof Error ? error.message : String(error),
       stack: error instanceof Error ? error.stack : void 0,
@@ -16382,7 +16451,7 @@ async function renderErrorPageWithStream(errorPage, req, res, error, routeChunks
               );
             } catch (error2) {
               const layoutFile = errorPage.layoutFiles[i];
-              const relativeLayoutPath = layoutFile ? import_path25.default.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
+              const relativeLayoutPath = layoutFile ? import_path26.default.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
               reqLogger.error("Layout middleware failed for error page", error2 instanceof Error ? error2 : new Error(String(error2)), {
                 layoutIndex: i,
                 layoutFile: relativeLayoutPath
@@ -16422,7 +16491,7 @@ async function renderErrorPageWithStream(errorPage, req, res, error, routeChunks
             }
           } catch (err) {
             const layoutFile = errorPage.layoutFiles[i];
-            const relativeLayoutPath = layoutFile ? import_path25.default.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
+            const relativeLayoutPath = layoutFile ? import_path26.default.relative(projectRoot || process.cwd(), layoutFile) : "unknown";
             reqLogger.warn("Layout server hook failed for error page", {
               error: err instanceof Error ? err.message : String(err),
               stack: err instanceof Error ? err.stack : void 0,
@@ -16745,7 +16814,7 @@ function validateRealtimeConfig(config) {
 }
 
 // modules/server/routes.ts
-var import_path26 = __toESM(require("path"));
+var import_path27 = __toESM(require("path"));
 var cachedRewriteLoader = null;
 var cachedProjectRoot = null;
 var cachedIsDev = null;
@@ -16773,8 +16842,8 @@ function setupRoutes(options) {
   } = options;
   const routeChunks = routeLoader.loadRouteChunks();
   const rewriteLoader = getRewriteLoader(projectRoot, isDev);
-  const ssgOutDir = import_path26.default.join(
-    config ? getBuildDir(projectRoot, config) : import_path26.default.join(projectRoot, BUILD_FOLDER_NAME),
+  const ssgOutDir = import_path27.default.join(
+    config ? getBuildDir(projectRoot, config) : import_path27.default.join(projectRoot, BUILD_FOLDER_NAME),
     "ssg"
   );
   app.all("/api/*", async (req, res) => {
@@ -18003,8 +18072,8 @@ var setupApplication = async ({
 
 // src/server.ts
 var import_dotenv2 = __toESM(require("dotenv"));
-var envPath = import_path27.default.join(process.cwd(), ".env");
-if (import_fs21.default.existsSync(envPath)) {
+var envPath = import_path28.default.join(process.cwd(), ".env");
+if (import_fs22.default.existsSync(envPath)) {
   import_dotenv2.default.config({ path: envPath });
 } else {
   import_dotenv2.default.config();
@@ -18025,8 +18094,8 @@ async function startServer(options = {}) {
   }
   const port = options.port ?? (process.env.PORT ? parseInt(process.env.PORT, 10) : void 0) ?? config.server.port;
   const host = process.env.HOST ?? (!isDev ? "0.0.0.0" : void 0) ?? config.server.host;
-  const appDir = options.appDir ?? (isDev ? getAppDir(projectRoot, config) : import_path27.default.join(getBuildDir(projectRoot, config), "server"));
-  if (!isDev && !import_fs21.default.existsSync(appDir)) {
+  const appDir = options.appDir ?? (isDev ? getAppDir(projectRoot, config) : import_path28.default.join(getBuildDir(projectRoot, config), "server"));
+  if (!isDev && !import_fs22.default.existsSync(appDir)) {
     logger4.error("Compiled directory not found", void 0, {
       buildDir: config.directories.build,
       appDir,
@@ -18097,10 +18166,10 @@ async function startProdServer(options = {}) {
 }
 
 // modules/build/ssg/builder.ts
-var import_path31 = __toESM(require("path"));
+var import_path32 = __toESM(require("path"));
 
 // modules/build/ssg/path.ts
-var import_path28 = __toESM(require("path"));
+var import_path29 = __toESM(require("path"));
 function buildPathFromPattern(pattern, params) {
   const segments = pattern.split("/").filter(Boolean);
   const parts = [];
@@ -18129,12 +18198,12 @@ function buildPathFromPattern(pattern, params) {
 }
 function pathToOutDir(baseDir, urlPath) {
   const clean = urlPath === "/" ? "" : urlPath.replace(/^\/+/, "");
-  return import_path28.default.join(baseDir, clean);
+  return import_path29.default.join(baseDir, clean);
 }
 
 // modules/build/ssg/renderer.ts
-var import_fs22 = __toESM(require("fs"));
-var import_path29 = __toESM(require("path"));
+var import_fs23 = __toESM(require("fs"));
+var import_path30 = __toESM(require("path"));
 var import_server3 = require("react-dom/server");
 init_globals();
 async function renderStaticRoute(projectRoot, ssgOutDir, route, urlPath, params, config) {
@@ -18270,16 +18339,16 @@ async function renderStaticRoute(projectRoot, ssgOutDir, route, urlPath, params,
   const html = "<!DOCTYPE html>" + (0, import_server3.renderToString)(documentTree);
   const dir = pathToOutDir(ssgOutDir, urlPath);
   ensureDir(dir);
-  const htmlFile = import_path29.default.join(dir, "index.html");
-  const dataFile = import_path29.default.join(dir, "data.json");
-  import_fs22.default.writeFileSync(htmlFile, html, "utf-8");
-  import_fs22.default.writeFileSync(dataFile, JSON.stringify(initialData, null, 2), "utf-8");
+  const htmlFile = import_path30.default.join(dir, "index.html");
+  const dataFile = import_path30.default.join(dir, "data.json");
+  import_fs23.default.writeFileSync(htmlFile, html, "utf-8");
+  import_fs23.default.writeFileSync(dataFile, JSON.stringify(initialData, null, 2), "utf-8");
 }
 
 // modules/build/ssg/builder.ts
 init_globals();
 async function buildStaticPages(projectRoot, routes, config) {
-  const ssgOutDir = import_path31.default.join(projectRoot, BUILD_FOLDER_NAME, "ssg");
+  const ssgOutDir = import_path32.default.join(projectRoot, BUILD_FOLDER_NAME, "ssg");
   ensureDir(ssgOutDir);
   for (const route of routes) {
     if (route.dynamic !== "force-static") continue;
@@ -18334,36 +18403,36 @@ async function buildStaticPages(projectRoot, routes, config) {
 }
 
 // modules/build/bundler/server.ts
-var import_path33 = __toESM(require("path"));
-var import_fs23 = __toESM(require("fs"));
+var import_path34 = __toESM(require("path"));
+var import_fs24 = __toESM(require("fs"));
 var import_esbuild = __toESM(require("esbuild"));
 init_globals();
 var SERVER_FILES = [INIT_FILE_NAME, CONFIG_FILE_NAME];
 function createPathAliasPlugin(projectRoot, outDir) {
   const aliases = loadAliasesFromTsconfig(projectRoot);
-  const tsconfigPath = import_path33.default.join(projectRoot, "tsconfig.json");
+  const tsconfigPath = import_path34.default.join(projectRoot, "tsconfig.json");
   let baseUrl = ".";
-  if (import_fs23.default.existsSync(tsconfigPath)) {
+  if (import_fs24.default.existsSync(tsconfigPath)) {
     try {
-      const tsconfig = JSON.parse(import_fs23.default.readFileSync(tsconfigPath, "utf-8"));
+      const tsconfig = JSON.parse(import_fs24.default.readFileSync(tsconfigPath, "utf-8"));
       baseUrl = tsconfig.compilerOptions?.baseUrl ?? ".";
     } catch {
     }
   }
   function resolveAliasToRelative(importPath, sourceFile) {
-    if (importPath.startsWith(".") || importPath.startsWith("/") || import_path33.default.isAbsolute(importPath) || importPath.includes("node_modules")) {
+    if (importPath.startsWith(".") || importPath.startsWith("/") || import_path34.default.isAbsolute(importPath) || importPath.includes("node_modules")) {
       return null;
     }
     for (const [aliasKey, aliasPath] of Object.entries(aliases)) {
       if (importPath.startsWith(aliasKey + "/") || importPath === aliasKey) {
         const restPath = importPath.startsWith(aliasKey + "/") ? importPath.slice(aliasKey.length + 1) : "";
-        const resolvedPath = restPath ? import_path33.default.join(aliasPath, restPath) : aliasPath;
+        const resolvedPath = restPath ? import_path34.default.join(aliasPath, restPath) : aliasPath;
         let actualPath = null;
         const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
-        if (import_fs23.default.existsSync(resolvedPath) && import_fs23.default.statSync(resolvedPath).isDirectory()) {
+        if (import_fs24.default.existsSync(resolvedPath) && import_fs24.default.statSync(resolvedPath).isDirectory()) {
           for (const ext of extensions) {
-            const indexPath = import_path33.default.join(resolvedPath, `index${ext}`);
-            if (import_fs23.default.existsSync(indexPath)) {
+            const indexPath = import_path34.default.join(resolvedPath, `index${ext}`);
+            if (import_fs24.default.existsSync(indexPath)) {
               actualPath = indexPath;
               break;
             }
@@ -18371,20 +18440,20 @@ function createPathAliasPlugin(projectRoot, outDir) {
         } else {
           for (const ext of extensions) {
             const filePath = resolvedPath + ext;
-            if (import_fs23.default.existsSync(filePath)) {
+            if (import_fs24.default.existsSync(filePath)) {
               actualPath = filePath;
               break;
             }
           }
-          if (!actualPath && import_fs23.default.existsSync(resolvedPath)) {
+          if (!actualPath && import_fs24.default.existsSync(resolvedPath)) {
             actualPath = resolvedPath;
           }
         }
         if (actualPath) {
-          const relativePath = import_path33.default.relative(outDir, actualPath);
+          const relativePath = import_path34.default.relative(outDir, actualPath);
           const normalizedPath = relativePath.replace(/\\/g, "/");
           const finalPath = normalizedPath.startsWith(".") ? normalizedPath : `./${normalizedPath}`;
-          const ext = import_path33.default.extname(finalPath);
+          const ext = import_path34.default.extname(finalPath);
           const pathWithoutExt = ext === ".json" ? finalPath : finalPath.slice(0, -ext.length);
           return pathWithoutExt;
         }
@@ -18396,13 +18465,13 @@ function createPathAliasPlugin(projectRoot, outDir) {
     name: "path-alias-resolver",
     setup(build) {
       build.onLoad({ filter: /\.(ts|tsx|js|jsx)$/ }, (args) => {
-        const fileName = import_path33.default.basename(args.path);
+        const fileName = import_path34.default.basename(args.path);
         const isServerFile = SERVER_FILES.some((f) => fileName === `${f}.ts` || fileName === `${f}.tsx` || fileName === `${f}.js` || fileName === `${f}.jsx`);
-        const isInProjectRoot = import_path33.default.dirname(args.path) === projectRoot;
+        const isInProjectRoot = import_path34.default.dirname(args.path) === projectRoot;
         if (!isServerFile || !isInProjectRoot) {
           return null;
         }
-        const contents = import_fs23.default.readFileSync(args.path, "utf-8");
+        const contents = import_fs24.default.readFileSync(args.path, "utf-8");
         let transformed = contents;
         const aliasPatterns = Object.keys(aliases).sort((a, b) => b.length - a.length);
         for (const aliasKey of aliasPatterns) {
@@ -18422,7 +18491,7 @@ function createPathAliasPlugin(projectRoot, outDir) {
         }
         return {
           contents: transformed,
-          loader: import_path33.default.extname(args.path).slice(1)
+          loader: import_path34.default.extname(args.path).slice(1)
         };
       });
       build.onResolve({ filter: /.*/ }, (args) => {
@@ -18441,9 +18510,9 @@ function createPathAliasPlugin(projectRoot, outDir) {
 function collectAppSources(appDir) {
   const entries = [];
   function walk(dir) {
-    const items = import_fs23.default.readdirSync(dir, { withFileTypes: true });
+    const items = import_fs24.default.readdirSync(dir, { withFileTypes: true });
     for (const item of items) {
-      const full = import_path33.default.join(dir, item.name);
+      const full = import_path34.default.join(dir, item.name);
       if (item.isDirectory()) {
         walk(full);
         continue;
@@ -18460,7 +18529,7 @@ function collectAppSources(appDir) {
   return entries;
 }
 async function buildServerApp(projectRoot, appDir) {
-  const outDir = import_path33.default.join(projectRoot, BUILD_FOLDER_NAME, "server");
+  const outDir = import_path34.default.join(projectRoot, BUILD_FOLDER_NAME, "server");
   const entryPoints = collectAppSources(appDir);
   ensureDir(outDir);
   if (entryPoints.length === 0) {
@@ -18478,14 +18547,14 @@ async function buildServerApp(projectRoot, appDir) {
     bundle: true,
     splitting: false,
     logLevel: "info",
-    tsconfig: import_path33.default.join(projectRoot, "tsconfig.json"),
+    tsconfig: import_path34.default.join(projectRoot, "tsconfig.json"),
     packages: "external"
   });
   const pathAliasPlugin = createPathAliasPlugin(projectRoot, outDir);
   for (const fileName of SERVER_FILES) {
-    const initTS = import_path33.default.join(projectRoot, `${fileName}.ts`);
-    const initJS = import_path33.default.join(outDir, `${fileName}.js`);
-    if (import_fs23.default.existsSync(initTS)) {
+    const initTS = import_path34.default.join(projectRoot, `${fileName}.ts`);
+    const initJS = import_path34.default.join(outDir, `${fileName}.js`);
+    if (import_fs24.default.existsSync(initTS)) {
       await import_esbuild.default.build({
         entryPoints: [initTS],
         outfile: initJS,
@@ -18496,7 +18565,7 @@ async function buildServerApp(projectRoot, appDir) {
         sourcemap: true,
         bundle: false,
         logLevel: "info",
-        tsconfig: import_path33.default.join(projectRoot, "tsconfig.json"),
+        tsconfig: import_path34.default.join(projectRoot, "tsconfig.json"),
         plugins: [pathAliasPlugin]
       });
     }
@@ -19783,11 +19852,11 @@ var ValidationError = class extends Error {
   format() {
     const formatted = {};
     for (const error of this.errors) {
-      const path30 = error.path.join(".");
-      if (!formatted[path30]) {
-        formatted[path30] = [];
+      const path31 = error.path.join(".");
+      if (!formatted[path31]) {
+        formatted[path31] = [];
       }
-      formatted[path30].push(error.message);
+      formatted[path31].push(error.message);
     }
     return formatted;
   }