@lolyjs/core 0.3.0-alpha.4 → 0.3.0-alpha.6

package/dist/index.cjs

@@ -9993,8 +9993,8 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/server.ts
-var import_fs23 = __toESM(require("fs"));
-var import_path29 = __toESM(require("path"));
+var import_fs25 = __toESM(require("fs"));
+var import_path32 = __toESM(require("path"));
 
 // modules/server/utils/server-dir.ts
 var import_fs2 = __toESM(require("fs"));
@@ -11830,6 +11830,7 @@ async function processRewrites(urlPath, compiledRewrites, req) {
   const normalizedPath = urlPath.replace(/\/$/, "") || "/";
   if (normalizedPath.startsWith("/static/") || // Static assets (client.js, client.css, etc.)
   normalizedPath.startsWith("/__fw/") || // Framework internal routes (hot reload, etc.)
+  normalizedPath.startsWith("/_loly/") || // Framework internal routes (image optimization, etc.)
   normalizedPath === "/favicon.ico" || // Favicon
   normalizedPath.startsWith("/wss/")) {
     if (process.env.NODE_ENV === "development") {
@@ -12739,7 +12740,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 = (path33) => statMethod(path33, { bigint: true });
+      this._stat = (path36) => statMethod(path36, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -12764,8 +12765,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: path33, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path33));
+          const { path: path36, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path36));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -12805,20 +12806,20 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path33, depth) {
+  async _exploreDir(path36, depth) {
     let files;
     try {
-      files = await (0, import_promises.readdir)(path33, this._rdOptions);
+      files = await (0, import_promises.readdir)(path36, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path33 };
+    return { files, depth, path: path36 };
   }
-  async _formatEntry(dirent, path33) {
+  async _formatEntry(dirent, path36) {
     let entry;
     const basename3 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path33, basename3));
+      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path36, 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) {
@@ -13218,16 +13219,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path33, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path36, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path33);
-    emitRaw(rawEvent, evPath, { watchedPath: path33 });
-    if (evPath && path33 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path33, evPath), KEY_LISTENERS, sysPath.join(path33, evPath));
+    listener(path36);
+    emitRaw(rawEvent, evPath, { watchedPath: path36 });
+    if (evPath && path36 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path36, evPath), KEY_LISTENERS, sysPath.join(path36, evPath));
     }
   };
   try {
-    return (0, import_fs17.watch)(path33, {
+    return (0, import_fs17.watch)(path36, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -13243,12 +13244,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path33, fullPath, options, handlers) => {
+var setFsWatchListener = (path36, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path33, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path36, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -13259,7 +13260,7 @@ var setFsWatchListener = (path33, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path33,
+      path36,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -13274,7 +13275,7 @@ var setFsWatchListener = (path33, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await (0, import_promises2.open)(path33, "r");
+          const fd = await (0, import_promises2.open)(path36, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -13305,7 +13306,7 @@ var setFsWatchListener = (path33, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path33, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path36, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -13327,7 +13328,7 @@ var setFsWatchFileListener = (path33, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path33, curr));
+          foreach(cont.listeners, (listener2) => listener2(path36, curr));
         }
       })
     };
@@ -13355,13 +13356,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path33, listener) {
+  _watchWithNodeFs(path36, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path33);
-    const basename3 = sysPath.basename(path33);
+    const directory = sysPath.dirname(path36);
+    const basename3 = sysPath.basename(path36);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename3);
-    const absolutePath = sysPath.resolve(path33);
+    const absolutePath = sysPath.resolve(path36);
     const options = {
       persistent: opts.persistent
     };
@@ -13371,12 +13372,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path33, absolutePath, options, {
+      closer = setFsWatchFileListener(path36, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path33, absolutePath, options, {
+      closer = setFsWatchListener(path36, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -13398,7 +13399,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename3))
       return;
-    const listener = async (path33, newStats) => {
+    const listener = async (path36, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -13412,11 +13413,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path33);
+            this.fsw._closeFile(path36);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path33, closer2);
+              this.fsw._addPathCloser(path36, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -13448,7 +13449,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, path33, item) {
+  async _handleSymlink(entry, directory, path36, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -13458,7 +13459,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises2.realpath)(path33);
+        linkPath = await (0, import_promises2.realpath)(path36);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -13468,12 +13469,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, path33, entry.stats);
+          this.fsw._emit(EV.CHANGE, path36, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path33, entry.stats);
+        this.fsw._emit(EV.ADD, path36, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -13502,9 +13503,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path33 = sysPath.join(directory, item);
+      let path36 = sysPath.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path33, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path36, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -13513,8 +13514,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path33 = sysPath.join(dir, sysPath.relative(dir, path33));
-        this._addToNodeFs(path33, initialAdd, wh, depth + 1);
+        path36 = sysPath.join(dir, sysPath.relative(dir, path36));
+        this._addToNodeFs(path36, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve3, reject) => {
@@ -13583,13 +13584,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path33, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path36, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path33) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path36) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path33);
+    const wh = this.fsw._getWatchHelpers(path36);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -13605,8 +13606,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path33);
-        const targetPath = follow ? await (0, import_promises2.realpath)(path33) : path33;
+        const absPath = sysPath.resolve(path36);
+        const targetPath = follow ? await (0, import_promises2.realpath)(path36) : path36;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -13616,29 +13617,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises2.realpath)(path33) : path33;
+        const targetPath = follow ? await (0, import_promises2.realpath)(path36) : path36;
         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, path33, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path36, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path33), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path36), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path33, closer);
+        this.fsw._addPathCloser(path36, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path33;
+        return path36;
       }
     }
   }
@@ -13681,26 +13682,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path33) {
-  if (typeof path33 !== "string")
+function normalizePath(path36) {
+  if (typeof path36 !== "string")
     throw new Error("string expected");
-  path33 = sysPath2.normalize(path33);
-  path33 = path33.replace(/\\/g, "/");
+  path36 = sysPath2.normalize(path36);
+  path36 = path36.replace(/\\/g, "/");
   let prepend = false;
-  if (path33.startsWith("//"))
+  if (path36.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path33.match(DOUBLE_SLASH_RE2))
-    path33 = path33.replace(DOUBLE_SLASH_RE2, "/");
+  while (path36.match(DOUBLE_SLASH_RE2))
+    path36 = path36.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path33 = "/" + path33;
-  return path33;
+    path36 = "/" + path36;
+  return path36;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path33 = normalizePath(testString);
+  const path36 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path33, stats)) {
+    if (pattern(path36, stats)) {
       return true;
     }
   }
@@ -13740,19 +13741,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path33) => toUnix(sysPath2.normalize(toUnix(path33)));
-var normalizeIgnored = (cwd = "") => (path33) => {
-  if (typeof path33 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path33) ? path33 : sysPath2.join(cwd, path33));
+var normalizePathToUnix = (path36) => toUnix(sysPath2.normalize(toUnix(path36)));
+var normalizeIgnored = (cwd = "") => (path36) => {
+  if (typeof path36 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path36) ? path36 : sysPath2.join(cwd, path36));
   } else {
-    return path33;
+    return path36;
   }
 };
-var getAbsolutePath = (path33, cwd) => {
-  if (sysPath2.isAbsolute(path33)) {
-    return path33;
+var getAbsolutePath = (path36, cwd) => {
+  if (sysPath2.isAbsolute(path36)) {
+    return path36;
   }
-  return sysPath2.join(cwd, path33);
+  return sysPath2.join(cwd, path36);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -13807,10 +13808,10 @@ var DirEntry = class {
 var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-  constructor(path33, follow, fsw) {
+  constructor(path36, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path33;
-    this.path = path33 = path33.replace(REPLACER_RE, "");
+    const watchPath = path36;
+    this.path = path36 = path36.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -13932,20 +13933,20 @@ var FSWatcher = class extends import_events.EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path33) => {
-        const absPath = getAbsolutePath(path33, cwd);
+      paths = paths.map((path36) => {
+        const absPath = getAbsolutePath(path36, cwd);
         return absPath;
       });
     }
-    paths.forEach((path33) => {
-      this._removeIgnoredPath(path33);
+    paths.forEach((path36) => {
+      this._removeIgnoredPath(path36);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path33) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path33, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path36) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path36, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -13967,17 +13968,17 @@ var FSWatcher = class extends import_events.EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path33) => {
-      if (!sysPath2.isAbsolute(path33) && !this._closers.has(path33)) {
+    paths.forEach((path36) => {
+      if (!sysPath2.isAbsolute(path36) && !this._closers.has(path36)) {
         if (cwd)
-          path33 = sysPath2.join(cwd, path33);
-        path33 = sysPath2.resolve(path33);
+          path36 = sysPath2.join(cwd, path36);
+        path36 = sysPath2.resolve(path36);
       }
-      this._closePath(path33);
-      this._addIgnoredPath(path33);
-      if (this._watched.has(path33)) {
+      this._closePath(path36);
+      this._addIgnoredPath(path36);
+      if (this._watched.has(path36)) {
         this._addIgnoredPath({
-          path: path33,
+          path: path36,
           recursive: true
         });
       }
@@ -14041,38 +14042,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, path33, stats) {
+  async _emit(event, path36, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path33 = sysPath2.normalize(path33);
+      path36 = sysPath2.normalize(path36);
     if (opts.cwd)
-      path33 = sysPath2.relative(opts.cwd, path33);
-    const args = [path33];
+      path36 = sysPath2.relative(opts.cwd, path36);
+    const args = [path36];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path33))) {
+    if (awf && (pw = this._pendingWrites.get(path36))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path33, [event, ...args]);
+        this._pendingUnlinks.set(path36, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path34) => {
+          this._pendingUnlinks.forEach((entry, path37) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path34);
+            this._pendingUnlinks.delete(path37);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path33)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path36)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path33);
+        this._pendingUnlinks.delete(path36);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -14090,16 +14091,16 @@ var FSWatcher = class extends import_events.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path33, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path36, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path33, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path36, 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, path33) : path33;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path36) : path36;
       let stats2;
       try {
         stats2 = await (0, import_promises3.stat)(fullPath);
@@ -14130,23 +14131,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, path33, timeout) {
+  _throttle(actionType, path36, 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(path33);
+    const actionPath = action.get(path36);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path33);
+      const item = action.get(path36);
       const count = item ? item.count : 0;
-      action.delete(path33);
+      action.delete(path36);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -14154,7 +14155,7 @@ var FSWatcher = class extends import_events.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path33, thr);
+    action.set(path36, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -14168,44 +14169,44 @@ var FSWatcher = class extends import_events.EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path33, threshold, event, awfEmit) {
+  _awaitWriteFinish(path36, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path33;
-    if (this.options.cwd && !sysPath2.isAbsolute(path33)) {
-      fullPath = sysPath2.join(this.options.cwd, path33);
+    let fullPath = path36;
+    if (this.options.cwd && !sysPath2.isAbsolute(path36)) {
+      fullPath = sysPath2.join(this.options.cwd, path36);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       (0, import_fs18.stat)(fullPath, (err, curStat) => {
-        if (err || !writes.has(path33)) {
+        if (err || !writes.has(path36)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path33).lastChange = now2;
+          writes.get(path36).lastChange = now2;
         }
-        const pw = writes.get(path33);
+        const pw = writes.get(path36);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path33);
+          writes.delete(path36);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path33)) {
-      writes.set(path33, {
+    if (!writes.has(path36)) {
+      writes.set(path36, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path33);
+          writes.delete(path36);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -14216,8 +14217,8 @@ var FSWatcher = class extends import_events.EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path33, stats) {
-    if (this.options.atomic && DOT_RE.test(path33))
+  _isIgnored(path36, stats) {
+    if (this.options.atomic && DOT_RE.test(path36))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -14227,17 +14228,17 @@ var FSWatcher = class extends import_events.EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path33, stats);
+    return this._userIgnored(path36, stats);
   }
-  _isntIgnored(path33, stat4) {
-    return !this._isIgnored(path33, stat4);
+  _isntIgnored(path36, stat4) {
+    return !this._isIgnored(path36, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path33) {
-    return new WatchHelper(path33, this.options.followSymlinks, this);
+  _getWatchHelpers(path36) {
+    return new WatchHelper(path36, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -14269,63 +14270,63 @@ var FSWatcher = class extends import_events.EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path33 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path33);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path33) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path33, 100))
+    const path36 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path36);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path36) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path36, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path33);
+    const wp = this._getWatchedDir(path36);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path33, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path36, 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 = path33;
+    let relPath = path36;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path33);
+      relPath = sysPath2.relative(this.options.cwd, path36);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path33);
+    this._watched.delete(path36);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path33))
-      this._emit(eventName, path33);
-    this._closePath(path33);
+    if (wasTracked && !this._isIgnored(path36))
+      this._emit(eventName, path36);
+    this._closePath(path36);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path33) {
-    this._closeFile(path33);
-    const dir = sysPath2.dirname(path33);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path33));
+  _closePath(path36) {
+    this._closeFile(path36);
+    const dir = sysPath2.dirname(path36);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path36));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path33) {
-    const closers = this._closers.get(path33);
+  _closeFile(path36) {
+    const closers = this._closers.get(path36);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path33);
+    this._closers.delete(path36);
   }
-  _addPathCloser(path33, closer) {
+  _addPathCloser(path36, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path33);
+    let list = this._closers.get(path36);
     if (!list) {
       list = [];
-      this._closers.set(path33, list);
+      this._closers.set(path36, list);
     }
     list.push(closer);
   }
@@ -14541,7 +14542,20 @@ var DEFAULT_CONFIG = {
     ssr: true,
     ssg: true
   },
-  plugins: []
+  plugins: [],
+  images: {
+    remotePatterns: [],
+    domains: [],
+    deviceSizes: [640, 750, 828, 1080, 1200, 1920, 2048, 3840],
+    imageSizes: [16, 32, 48, 64, 96, 128, 256, 384],
+    formats: ["image/webp", "image/avif"],
+    quality: 75,
+    minimumCacheTTL: 60,
+    dangerouslyAllowSVG: false,
+    contentSecurityPolicy: "default-src 'self'; script-src 'none'; sandbox;",
+    maxWidth: 3840,
+    maxHeight: 3840
+  }
 };
 function deepMerge(target, source) {
   const result = { ...target };
@@ -14658,6 +14672,53 @@ function validateConfig(config, projectRoot) {
   if (typeof config.rendering.ssg !== "boolean") {
     errors.push("config.rendering.ssg must be a boolean");
   }
+  if (config.images) {
+    if (config.images.quality !== void 0) {
+      if (typeof config.images.quality !== "number" || config.images.quality < 1 || config.images.quality > 100) {
+        errors.push("config.images.quality must be a number between 1 and 100");
+      }
+    }
+    if (config.images.minimumCacheTTL !== void 0) {
+      if (typeof config.images.minimumCacheTTL !== "number" || config.images.minimumCacheTTL < 0) {
+        errors.push("config.images.minimumCacheTTL must be a non-negative number");
+      }
+    }
+    if (config.images.deviceSizes) {
+      if (!Array.isArray(config.images.deviceSizes) || config.images.deviceSizes.some((s) => typeof s !== "number" || s <= 0)) {
+        errors.push("config.images.deviceSizes must be an array of positive numbers");
+      }
+    }
+    if (config.images.imageSizes) {
+      if (!Array.isArray(config.images.imageSizes) || config.images.imageSizes.some((s) => typeof s !== "number" || s <= 0)) {
+        errors.push("config.images.imageSizes must be an array of positive numbers");
+      }
+    }
+    if (config.images.formats) {
+      const validFormats = ["image/webp", "image/avif"];
+      if (!Array.isArray(config.images.formats) || config.images.formats.some((f) => !validFormats.includes(f))) {
+        errors.push(`config.images.formats must be an array containing only: ${validFormats.join(", ")}`);
+      }
+    }
+    if (config.images.remotePatterns) {
+      if (!Array.isArray(config.images.remotePatterns)) {
+        errors.push("config.images.remotePatterns must be an array");
+      } else {
+        config.images.remotePatterns.forEach((pattern, idx) => {
+          if (!pattern.hostname || typeof pattern.hostname !== "string") {
+            errors.push(`config.images.remotePatterns[${idx}].hostname must be a non-empty string`);
+          }
+          if (pattern.protocol && !["http", "https"].includes(pattern.protocol)) {
+            errors.push(`config.images.remotePatterns[${idx}].protocol must be 'http' or 'https'`);
+          }
+        });
+      }
+    }
+    if (config.images.domains) {
+      if (!Array.isArray(config.images.domains) || config.images.domains.some((d) => typeof d !== "string")) {
+        errors.push("config.images.domains must be an array of strings");
+      }
+    }
+  }
   if (errors.length > 0) {
     const errorMessage = [
       "\u274C Configuration validation failed:",
@@ -15003,12 +15064,12 @@ var DEFAULT_IGNORED_PATHS = [
   /^\/sockjs-node/
   // Hot reload websocket
 ];
-function shouldIgnorePath(path33, ignoredPaths) {
+function shouldIgnorePath(path36, ignoredPaths) {
   return ignoredPaths.some((pattern) => {
     if (typeof pattern === "string") {
-      return path33 === pattern || path33.startsWith(pattern);
+      return path36 === pattern || path36.startsWith(pattern);
     }
-    return pattern.test(path33);
+    return pattern.test(path36);
   });
 }
 function requestLoggerMiddleware(options = {}) {
@@ -15167,11 +15228,11 @@ function createStrictRateLimiterFromConfig(config) {
 }
 
 // modules/server/middleware/auto-rate-limit.ts
-function matchesStrictPattern(path33, patterns) {
+function matchesStrictPattern(path36, patterns) {
   for (const pattern of patterns) {
     const regexPattern = pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\//g, "\\/");
     const regex = new RegExp(`^${regexPattern}$`);
-    if (regex.test(path33)) {
+    if (regex.test(path36)) {
       return true;
     }
   }
@@ -15694,7 +15755,7 @@ function createDocumentTree(options) {
       }),
       ...extraMetaTags,
       ...linkTags,
-      ...entrypointFiles.length > 0 ? entrypointFiles.slice(0, -1).map(
+      ...entrypointFiles.length > 0 ? entrypointFiles.map(
         (file) => import_react.default.createElement("link", {
           key: `preload-${file}`,
           rel: "preload",
@@ -15715,6 +15776,13 @@ function createDocumentTree(options) {
         href: faviconPath,
         type: faviconType || (faviconPath.endsWith(".ico") ? "image/x-icon" : "image/png")
       }),
+      // Preload CSS para evitar bloqueo de renderizado
+      import_react.default.createElement("link", {
+        key: "preload-css",
+        rel: "preload",
+        href: clientCssPath,
+        as: "style"
+      }),
       import_react.default.createElement("link", {
         rel: "stylesheet",
         href: clientCssPath
@@ -16861,6 +16929,438 @@ async function renderErrorPageWithStream(errorPage, req, res, error, routeChunks
   }
 }
 
+// modules/server/image-optimizer/index.ts
+var import_sharp = __toESM(require("sharp"));
+var import_fs24 = __toESM(require("fs"));
+var import_path30 = __toESM(require("path"));
+
+// modules/server/image-optimizer/validation.ts
+var import_path28 = __toESM(require("path"));
+function isRemoteUrl(url) {
+  return url.startsWith("http://") || url.startsWith("https://");
+}
+function sanitizeImagePath(imagePath) {
+  const normalized = import_path28.default.normalize(imagePath).replace(/^(\.\.(\/|\\|$))+/, "");
+  return normalized.replace(/^[/\\]+/, "");
+}
+function patternToRegex(pattern) {
+  const parts = [];
+  if (pattern.protocol) {
+    parts.push(pattern.protocol === "https" ? "https" : "http");
+  } else {
+    parts.push("https?");
+  }
+  parts.push("://");
+  let hostnamePattern = pattern.hostname.replace(/\./g, "\\.").replace(/\*\*/g, ".*").replace(/\*/g, "[^.]*");
+  parts.push(hostnamePattern);
+  if (pattern.port) {
+    parts.push(`:${pattern.port}`);
+  }
+  if (pattern.pathname) {
+    let pathnamePattern = pattern.pathname.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+    parts.push(pathnamePattern);
+  } else {
+    parts.push(".*");
+  }
+  const regexSource = `^${parts.join("")}`;
+  return new RegExp(regexSource);
+}
+function validateRemoteUrl(url, config) {
+  if (!config.remotePatterns && !config.domains) {
+    return false;
+  }
+  try {
+    const urlObj = new URL(url);
+    const protocol = urlObj.protocol.replace(":", "");
+    const hostname = urlObj.hostname;
+    const port = urlObj.port || "";
+    const pathname = urlObj.pathname;
+    if (config.remotePatterns && config.remotePatterns.length > 0) {
+      for (const pattern of config.remotePatterns) {
+        const regex = patternToRegex(pattern);
+        const testUrl = `${protocol}://${hostname}${port ? `:${port}` : ""}${pathname}`;
+        if (regex.test(testUrl)) {
+          if (pattern.protocol && pattern.protocol !== protocol) {
+            continue;
+          }
+          if (pattern.port && pattern.port !== port) {
+            continue;
+          }
+          return true;
+        }
+      }
+    }
+    if (config.domains && config.domains.length > 0) {
+      for (const domain of config.domains) {
+        const domainPattern = domain.replace(/\./g, "\\.").replace(/\*\*/g, ".*").replace(/\*/g, "[^.]*");
+        const regex = new RegExp(`^${domainPattern}$`);
+        if (regex.test(hostname)) {
+          if (process.env.NODE_ENV === "production" && protocol !== "https") {
+            continue;
+          }
+          return true;
+        }
+      }
+    }
+    return false;
+  } catch (error) {
+    return false;
+  }
+}
+function validateImageDimensions(width, height, config) {
+  const maxWidth = config.maxWidth || 3840;
+  const maxHeight = config.maxHeight || 3840;
+  if (width !== void 0 && (width <= 0 || width > maxWidth)) {
+    return {
+      valid: false,
+      error: `Image width must be between 1 and ${maxWidth}, got ${width}`
+    };
+  }
+  if (height !== void 0 && (height <= 0 || height > maxHeight)) {
+    return {
+      valid: false,
+      error: `Image height must be between 1 and ${maxHeight}, got ${height}`
+    };
+  }
+  return { valid: true };
+}
+function validateQuality(quality) {
+  if (quality === void 0) {
+    return { valid: true };
+  }
+  if (typeof quality !== "number" || quality < 1 || quality > 100) {
+    return {
+      valid: false,
+      error: `Image quality must be between 1 and 100, got ${quality}`
+    };
+  }
+  return { valid: true };
+}
+
+// modules/server/image-optimizer/cache.ts
+var import_fs23 = __toESM(require("fs"));
+var import_path29 = __toESM(require("path"));
+var import_crypto = __toESM(require("crypto"));
+function generateCacheKey(src, width, height, quality, format) {
+  const data = `${src}-${width || ""}-${height || ""}-${quality || ""}-${format || ""}`;
+  return import_crypto.default.createHash("sha256").update(data).digest("hex");
+}
+function getCacheDir(projectRoot, config) {
+  const buildDir = getBuildDir(projectRoot, config);
+  return import_path29.default.join(buildDir, "cache", "images");
+}
+function ensureCacheDir(cacheDir) {
+  if (!import_fs23.default.existsSync(cacheDir)) {
+    import_fs23.default.mkdirSync(cacheDir, { recursive: true });
+  }
+}
+function getCachedImagePath(cacheKey, extension, cacheDir) {
+  return import_path29.default.join(cacheDir, `${cacheKey}.${extension}`);
+}
+function hasCachedImage(cacheKey, extension, cacheDir) {
+  const cachedPath = getCachedImagePath(cacheKey, extension, cacheDir);
+  return import_fs23.default.existsSync(cachedPath);
+}
+function readCachedImage(cacheKey, extension, cacheDir) {
+  const cachedPath = getCachedImagePath(cacheKey, extension, cacheDir);
+  try {
+    if (import_fs23.default.existsSync(cachedPath)) {
+      return import_fs23.default.readFileSync(cachedPath);
+    }
+  } catch (error) {
+    console.warn(`[image-optimizer] Failed to read cached image: ${cachedPath}`, error);
+  }
+  return null;
+}
+function writeCachedImage(cacheKey, extension, cacheDir, imageBuffer) {
+  ensureCacheDir(cacheDir);
+  const cachedPath = getCachedImagePath(cacheKey, extension, cacheDir);
+  try {
+    import_fs23.default.writeFileSync(cachedPath, imageBuffer);
+  } catch (error) {
+    console.warn(`[image-optimizer] Failed to write cached image: ${cachedPath}`, error);
+  }
+}
+function getImageMimeType(format) {
+  const formatMap = {
+    webp: "image/webp",
+    avif: "image/avif",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    svg: "image/svg+xml"
+  };
+  const normalized = format.toLowerCase();
+  return formatMap[normalized] || "image/jpeg";
+}
+function getImageExtension(format) {
+  const formatMap = {
+    "image/webp": "webp",
+    "image/avif": "avif",
+    "image/jpeg": "jpg",
+    "image/png": "png",
+    "image/gif": "gif",
+    "image/svg+xml": "svg",
+    webp: "webp",
+    avif: "avif",
+    jpeg: "jpg",
+    jpg: "jpg",
+    png: "png",
+    gif: "gif",
+    svg: "svg"
+  };
+  const normalized = format.toLowerCase();
+  return formatMap[normalized] || "jpg";
+}
+
+// modules/server/image-optimizer/index.ts
+async function downloadRemoteImage(url, timeout = 1e4) {
+  let fetchFn;
+  try {
+    if (typeof fetch !== "undefined") {
+      fetchFn = fetch;
+    } else {
+      const { fetch: undiciFetch } = await import("undici");
+      fetchFn = undiciFetch;
+    }
+  } catch (error) {
+    throw new Error("Failed to load fetch implementation. Node 18+ required or install undici.");
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetchFn(url, {
+      signal: controller.signal,
+      headers: {
+        "User-Agent": "Loly-Image-Optimizer/1.0"
+      }
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      throw new Error(`Failed to download image: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Image download timeout after ${timeout}ms`);
+    }
+    throw error;
+  }
+}
+function readLocalImage(src, projectRoot, config) {
+  const sanitized = sanitizeImagePath(src);
+  const staticDir = getStaticDir(projectRoot, config);
+  const staticPath = import_path30.default.join(staticDir, sanitized);
+  if (import_fs24.default.existsSync(staticPath)) {
+    return import_fs24.default.readFileSync(staticPath);
+  }
+  if (src.startsWith("/")) {
+    const absolutePath = import_path30.default.join(projectRoot, sanitized);
+    if (import_fs24.default.existsSync(absolutePath)) {
+      return import_fs24.default.readFileSync(absolutePath);
+    }
+  }
+  throw new Error(`Image not found: ${src}`);
+}
+function determineOutputFormat(sourceFormat, requestedFormat, config) {
+  if (sourceFormat === "svg") {
+    return "svg";
+  }
+  if (requestedFormat && requestedFormat !== "auto") {
+    return requestedFormat;
+  }
+  const supportedFormats = config.formats || ["image/webp"];
+  if (supportedFormats.includes("image/avif")) {
+    return "avif";
+  }
+  if (supportedFormats.includes("image/webp")) {
+    return "webp";
+  }
+  return sourceFormat === "svg" ? "jpeg" : sourceFormat;
+}
+async function optimizeImage(options, projectRoot, config) {
+  const imageConfig = config.images || {};
+  const dimValidation = validateImageDimensions(options.width, options.height, imageConfig);
+  if (!dimValidation.valid) {
+    throw new Error(dimValidation.error);
+  }
+  const qualityValidation = validateQuality(options.quality);
+  if (!qualityValidation.valid) {
+    throw new Error(qualityValidation.error);
+  }
+  if (isRemoteUrl(options.src)) {
+    if (!validateRemoteUrl(options.src, imageConfig)) {
+      throw new Error(`Remote image domain not allowed: ${options.src}`);
+    }
+  }
+  const sourceFormat = import_path30.default.extname(options.src).slice(1).toLowerCase() || "jpeg";
+  const outputFormat = determineOutputFormat(
+    sourceFormat,
+    options.format,
+    imageConfig
+  );
+  const cacheKey = generateCacheKey(
+    options.src,
+    options.width,
+    options.height,
+    options.quality || imageConfig.quality || 75,
+    outputFormat
+  );
+  const cacheDir = getCacheDir(projectRoot, config);
+  const extension = getImageExtension(outputFormat);
+  if (hasCachedImage(cacheKey, extension, cacheDir)) {
+    const cached = readCachedImage(cacheKey, extension, cacheDir);
+    if (cached) {
+      const metadata2 = await (0, import_sharp.default)(cached).metadata();
+      return {
+        buffer: cached,
+        format: outputFormat,
+        mimeType: getImageMimeType(outputFormat),
+        width: metadata2.width || options.width || 0,
+        height: metadata2.height || options.height || 0
+      };
+    }
+  }
+  let imageBuffer;
+  if (isRemoteUrl(options.src)) {
+    imageBuffer = await downloadRemoteImage(options.src);
+  } else {
+    imageBuffer = readLocalImage(options.src, projectRoot, config);
+  }
+  if (outputFormat === "svg" || sourceFormat === "svg") {
+    if (!imageConfig.dangerouslyAllowSVG) {
+      throw new Error("SVG images are not allowed. Set images.dangerouslyAllowSVG to true to enable.");
+    }
+    return {
+      buffer: imageBuffer,
+      format: "svg",
+      mimeType: "image/svg+xml",
+      width: options.width || 0,
+      height: options.height || 0
+    };
+  }
+  let sharpInstance = (0, import_sharp.default)(imageBuffer);
+  const metadata = await sharpInstance.metadata();
+  if (options.width || options.height) {
+    const fit = options.fit || "cover";
+    sharpInstance = sharpInstance.resize(options.width, options.height, {
+      fit,
+      withoutEnlargement: true
+    });
+  }
+  const quality = options.quality || imageConfig.quality || 75;
+  switch (outputFormat) {
+    case "webp":
+      sharpInstance = sharpInstance.webp({ quality });
+      break;
+    case "avif":
+      sharpInstance = sharpInstance.avif({ quality });
+      break;
+    case "jpeg":
+    case "jpg":
+      sharpInstance = sharpInstance.jpeg({ quality });
+      break;
+    case "png":
+      sharpInstance = sharpInstance.png({ quality: Math.round(quality / 100 * 9) });
+      break;
+    default:
+      sharpInstance = sharpInstance.jpeg({ quality });
+  }
+  const optimizedBuffer = await sharpInstance.toBuffer();
+  const finalMetadata = await (0, import_sharp.default)(optimizedBuffer).metadata();
+  writeCachedImage(cacheKey, extension, cacheDir, optimizedBuffer);
+  return {
+    buffer: optimizedBuffer,
+    format: outputFormat,
+    mimeType: getImageMimeType(outputFormat),
+    width: finalMetadata.width || options.width || metadata.width || 0,
+    height: finalMetadata.height || options.height || metadata.height || 0
+  };
+}
+
+// modules/server/handlers/image.ts
+async function handleImageRequest(options) {
+  const { req, res, projectRoot, config } = options;
+  try {
+    const src = req.query.src;
+    const width = req.query.w ? parseInt(req.query.w, 10) : void 0;
+    const height = req.query.h ? parseInt(req.query.h, 10) : void 0;
+    const quality = req.query.q ? parseInt(req.query.q, 10) : void 0;
+    const format = req.query.format;
+    const fit = req.query.fit;
+    if (!src) {
+      res.status(400).json({
+        error: "Missing required parameter: src"
+      });
+      return;
+    }
+    if (typeof src !== "string") {
+      res.status(400).json({
+        error: "Parameter 'src' must be a string"
+      });
+      return;
+    }
+    const result = await optimizeImage(
+      {
+        src,
+        width,
+        height,
+        quality,
+        format,
+        fit
+      },
+      projectRoot,
+      config
+    );
+    const imageConfig = config.images || {};
+    const cacheTTL = imageConfig.minimumCacheTTL || 60;
+    res.setHeader("Content-Type", result.mimeType);
+    res.setHeader("Content-Length", result.buffer.length);
+    res.setHeader("Cache-Control", `public, max-age=${cacheTTL}, immutable`);
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    res.send(result.buffer);
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("not allowed")) {
+        res.status(403).json({
+          error: "Forbidden",
+          message: error.message
+        });
+        return;
+      }
+      if (error.message.includes("not found") || error.message.includes("Image not found")) {
+        res.status(404).json({
+          error: "Not Found",
+          message: error.message
+        });
+        return;
+      }
+      if (error.message.includes("must be")) {
+        res.status(400).json({
+          error: "Bad Request",
+          message: error.message
+        });
+        return;
+      }
+      if (error.message.includes("timeout") || error.message.includes("download")) {
+        res.status(504).json({
+          error: "Gateway Timeout",
+          message: error.message
+        });
+        return;
+      }
+    }
+    console.error("[image-optimizer] Error processing image:", error);
+    res.status(500).json({
+      error: "Internal Server Error",
+      message: "Failed to process image"
+    });
+  }
+}
+
 // modules/server/routes.ts
 init_globals();
 
@@ -17022,7 +17522,7 @@ function validateRealtimeConfig(config) {
 }
 
 // modules/server/routes.ts
-var import_path28 = __toESM(require("path"));
+var import_path31 = __toESM(require("path"));
 var cachedRewriteLoader = null;
 var cachedProjectRoot = null;
 var cachedIsDev = null;
@@ -17050,10 +17550,20 @@ function setupRoutes(options) {
   } = options;
   const routeChunks = routeLoader.loadRouteChunks();
   const rewriteLoader = getRewriteLoader(projectRoot, isDev);
-  const ssgOutDir = import_path28.default.join(
-    config ? getBuildDir(projectRoot, config) : import_path28.default.join(projectRoot, BUILD_FOLDER_NAME),
+  const ssgOutDir = import_path31.default.join(
+    config ? getBuildDir(projectRoot, config) : import_path31.default.join(projectRoot, BUILD_FOLDER_NAME),
     "ssg"
   );
+  if (config) {
+    app.get("/_loly/image", async (req, res) => {
+      await handleImageRequest({
+        req,
+        res,
+        projectRoot,
+        config
+      });
+    });
+  }
   app.all("/api/*", async (req, res) => {
     const apiRoutes = isDev && getRoutes ? (await getRoutes()).apiRoutes : initialApiRoutes;
     const serverConfig = await getServerConfig(projectRoot);
@@ -18100,7 +18610,7 @@ var import_cors = __toESM(require("cors"));
 var import_helmet = __toESM(require("helmet"));
 var import_cookie_parser = __toESM(require("cookie-parser"));
 var import_compression = __toESM(require("compression"));
-var import_crypto = __toESM(require("crypto"));
+var import_crypto2 = __toESM(require("crypto"));
 var setupApplication = async ({
   projectRoot
 }) => {
@@ -18209,7 +18719,7 @@ var setupApplication = async ({
   if (process.env.NODE_ENV !== "development" && security?.contentSecurityPolicy !== false) {
     app.use(
       (req, res, next) => {
-        const nonce = import_crypto.default.randomBytes(16).toString("base64");
+        const nonce = import_crypto2.default.randomBytes(16).toString("base64");
         res.locals.nonce = nonce;
         next();
       }
@@ -18280,8 +18790,8 @@ var setupApplication = async ({
 
 // src/server.ts
 var import_dotenv2 = __toESM(require("dotenv"));
-var envPath = import_path29.default.join(process.cwd(), ".env");
-if (import_fs23.default.existsSync(envPath)) {
+var envPath = import_path32.default.join(process.cwd(), ".env");
+if (import_fs25.default.existsSync(envPath)) {
   import_dotenv2.default.config({ path: envPath });
 } else {
   import_dotenv2.default.config();
@@ -18302,8 +18812,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_path29.default.join(getBuildDir(projectRoot, config), "server"));
-  if (!isDev && !import_fs23.default.existsSync(appDir)) {
+  const appDir = options.appDir ?? (isDev ? getAppDir(projectRoot, config) : import_path32.default.join(getBuildDir(projectRoot, config), "server"));
+  if (!isDev && !import_fs25.default.existsSync(appDir)) {
     logger4.error("Compiled directory not found", void 0, {
       buildDir: config.directories.build,
       appDir,
@@ -18374,14 +18884,14 @@ async function startProdServer(options = {}) {
 }
 
 // modules/build/index.ts
-var import_path36 = __toESM(require("path"));
-var import_fs26 = __toESM(require("fs"));
+var import_path39 = __toESM(require("path"));
+var import_fs28 = __toESM(require("fs"));
 
 // modules/build/ssg/builder.ts
-var import_path33 = __toESM(require("path"));
+var import_path36 = __toESM(require("path"));
 
 // modules/build/ssg/path.ts
-var import_path30 = __toESM(require("path"));
+var import_path33 = __toESM(require("path"));
 function buildPathFromPattern(pattern, params) {
   const segments = pattern.split("/").filter(Boolean);
   const parts = [];
@@ -18410,12 +18920,12 @@ function buildPathFromPattern(pattern, params) {
 }
 function pathToOutDir(baseDir, urlPath) {
   const clean = urlPath === "/" ? "" : urlPath.replace(/^\/+/, "");
-  return import_path30.default.join(baseDir, clean);
+  return import_path33.default.join(baseDir, clean);
 }
 
 // modules/build/ssg/renderer.ts
-var import_fs24 = __toESM(require("fs"));
-var import_path31 = __toESM(require("path"));
+var import_fs26 = __toESM(require("fs"));
+var import_path34 = __toESM(require("path"));
 var import_server3 = require("react-dom/server");
 init_globals();
 async function renderStaticRoute(projectRoot, ssgOutDir, route, urlPath, params, config) {
@@ -18551,16 +19061,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_path31.default.join(dir, "index.html");
-  const dataFile = import_path31.default.join(dir, "data.json");
-  import_fs24.default.writeFileSync(htmlFile, html, "utf-8");
-  import_fs24.default.writeFileSync(dataFile, JSON.stringify(initialData, null, 2), "utf-8");
+  const htmlFile = import_path34.default.join(dir, "index.html");
+  const dataFile = import_path34.default.join(dir, "data.json");
+  import_fs26.default.writeFileSync(htmlFile, html, "utf-8");
+  import_fs26.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_path33.default.join(projectRoot, BUILD_FOLDER_NAME, "ssg");
+  const ssgOutDir = import_path36.default.join(projectRoot, BUILD_FOLDER_NAME, "ssg");
   ensureDir(ssgOutDir);
   for (const route of routes) {
     if (route.dynamic !== "force-static") continue;
@@ -18615,36 +19125,36 @@ async function buildStaticPages(projectRoot, routes, config) {
 }
 
 // modules/build/bundler/server.ts
-var import_path35 = __toESM(require("path"));
-var import_fs25 = __toESM(require("fs"));
+var import_path38 = __toESM(require("path"));
+var import_fs27 = __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_path35.default.join(projectRoot, "tsconfig.json");
+  const tsconfigPath = import_path38.default.join(projectRoot, "tsconfig.json");
   let baseUrl = ".";
-  if (import_fs25.default.existsSync(tsconfigPath)) {
+  if (import_fs27.default.existsSync(tsconfigPath)) {
     try {
-      const tsconfig = JSON.parse(import_fs25.default.readFileSync(tsconfigPath, "utf-8"));
+      const tsconfig = JSON.parse(import_fs27.default.readFileSync(tsconfigPath, "utf-8"));
       baseUrl = tsconfig.compilerOptions?.baseUrl ?? ".";
     } catch {
     }
   }
   function resolveAliasToRelative(importPath, sourceFile) {
-    if (importPath.startsWith(".") || importPath.startsWith("/") || import_path35.default.isAbsolute(importPath) || importPath.includes("node_modules")) {
+    if (importPath.startsWith(".") || importPath.startsWith("/") || import_path38.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_path35.default.join(aliasPath, restPath) : aliasPath;
+        const resolvedPath = restPath ? import_path38.default.join(aliasPath, restPath) : aliasPath;
         let actualPath = null;
         const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
-        if (import_fs25.default.existsSync(resolvedPath) && import_fs25.default.statSync(resolvedPath).isDirectory()) {
+        if (import_fs27.default.existsSync(resolvedPath) && import_fs27.default.statSync(resolvedPath).isDirectory()) {
           for (const ext of extensions) {
-            const indexPath = import_path35.default.join(resolvedPath, `index${ext}`);
-            if (import_fs25.default.existsSync(indexPath)) {
+            const indexPath = import_path38.default.join(resolvedPath, `index${ext}`);
+            if (import_fs27.default.existsSync(indexPath)) {
               actualPath = indexPath;
               break;
             }
@@ -18652,20 +19162,20 @@ function createPathAliasPlugin(projectRoot, outDir) {
         } else {
           for (const ext of extensions) {
             const filePath = resolvedPath + ext;
-            if (import_fs25.default.existsSync(filePath)) {
+            if (import_fs27.default.existsSync(filePath)) {
               actualPath = filePath;
               break;
             }
           }
-          if (!actualPath && import_fs25.default.existsSync(resolvedPath)) {
+          if (!actualPath && import_fs27.default.existsSync(resolvedPath)) {
             actualPath = resolvedPath;
           }
         }
         if (actualPath) {
-          const relativePath = import_path35.default.relative(outDir, actualPath);
+          const relativePath = import_path38.default.relative(outDir, actualPath);
           const normalizedPath = relativePath.replace(/\\/g, "/");
           const finalPath = normalizedPath.startsWith(".") ? normalizedPath : `./${normalizedPath}`;
-          const ext = import_path35.default.extname(finalPath);
+          const ext = import_path38.default.extname(finalPath);
           const pathWithoutExt = ext === ".json" ? finalPath : finalPath.slice(0, -ext.length);
           return pathWithoutExt;
         }
@@ -18677,19 +19187,19 @@ function createPathAliasPlugin(projectRoot, outDir) {
     name: "path-alias-resolver",
     setup(build) {
       function resolveAliasToAbsolute(importPath) {
-        if (importPath.startsWith(".") || importPath.startsWith("/") || import_path35.default.isAbsolute(importPath) || importPath.includes("node_modules")) {
+        if (importPath.startsWith(".") || importPath.startsWith("/") || import_path38.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_path35.default.join(aliasPath, restPath) : aliasPath;
+            const resolvedPath = restPath ? import_path38.default.join(aliasPath, restPath) : aliasPath;
             let actualPath = null;
             const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
-            if (import_fs25.default.existsSync(resolvedPath) && import_fs25.default.statSync(resolvedPath).isDirectory()) {
+            if (import_fs27.default.existsSync(resolvedPath) && import_fs27.default.statSync(resolvedPath).isDirectory()) {
               for (const ext of extensions) {
-                const indexPath = import_path35.default.join(resolvedPath, `index${ext}`);
-                if (import_fs25.default.existsSync(indexPath)) {
+                const indexPath = import_path38.default.join(resolvedPath, `index${ext}`);
+                if (import_fs27.default.existsSync(indexPath)) {
                   actualPath = indexPath;
                   break;
                 }
@@ -18697,12 +19207,12 @@ function createPathAliasPlugin(projectRoot, outDir) {
             } else {
               for (const ext of extensions) {
                 const filePath = resolvedPath + ext;
-                if (import_fs25.default.existsSync(filePath)) {
+                if (import_fs27.default.existsSync(filePath)) {
                   actualPath = filePath;
                   break;
                 }
               }
-              if (!actualPath && import_fs25.default.existsSync(resolvedPath)) {
+              if (!actualPath && import_fs27.default.existsSync(resolvedPath)) {
                 actualPath = resolvedPath;
               }
             }
@@ -18715,7 +19225,7 @@ function createPathAliasPlugin(projectRoot, outDir) {
       }
       build.onResolve({ filter: /^[^./]/ }, (args) => {
         const absolutePath = resolveAliasToAbsolute(args.path);
-        if (absolutePath && import_fs25.default.existsSync(absolutePath)) {
+        if (absolutePath && import_fs27.default.existsSync(absolutePath)) {
           return {
             path: absolutePath,
             namespace: "file"
@@ -18724,13 +19234,13 @@ function createPathAliasPlugin(projectRoot, outDir) {
         return null;
       });
       build.onLoad({ filter: /\.(ts|tsx|js|jsx)$/ }, (args) => {
-        const fileName = import_path35.default.basename(args.path);
+        const fileName = import_path38.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_path35.default.dirname(args.path) === projectRoot;
+        const isInProjectRoot = import_path38.default.dirname(args.path) === projectRoot;
         if (!isServerFile || !isInProjectRoot) {
           return null;
         }
-        const contents = import_fs25.default.readFileSync(args.path, "utf-8");
+        const contents = import_fs27.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) {
@@ -18750,7 +19260,7 @@ function createPathAliasPlugin(projectRoot, outDir) {
         }
         return {
           contents: transformed,
-          loader: import_path35.default.extname(args.path).slice(1)
+          loader: import_path38.default.extname(args.path).slice(1)
         };
       });
     }
@@ -18762,13 +19272,13 @@ function rewritePathAliasesInOutput(outDir, projectRoot, appDir) {
     for (const [aliasKey, aliasSourcePath] of Object.entries(aliases)) {
       if (aliasPath.startsWith(aliasKey + "/") || aliasPath === aliasKey) {
         const restPath = aliasPath.startsWith(aliasKey + "/") ? aliasPath.slice(aliasKey.length + 1) : "";
-        const resolvedSourcePath = restPath ? import_path35.default.join(aliasSourcePath, restPath) : aliasSourcePath;
+        const resolvedSourcePath = restPath ? import_path38.default.join(aliasSourcePath, restPath) : aliasSourcePath;
         let actualSourcePath = null;
         const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
-        if (import_fs25.default.existsSync(resolvedSourcePath) && import_fs25.default.statSync(resolvedSourcePath).isDirectory()) {
+        if (import_fs27.default.existsSync(resolvedSourcePath) && import_fs27.default.statSync(resolvedSourcePath).isDirectory()) {
           for (const ext of extensions) {
-            const indexPath = import_path35.default.join(resolvedSourcePath, `index${ext}`);
-            if (import_fs25.default.existsSync(indexPath)) {
+            const indexPath = import_path38.default.join(resolvedSourcePath, `index${ext}`);
+            if (import_fs27.default.existsSync(indexPath)) {
               actualSourcePath = indexPath;
               break;
             }
@@ -18776,21 +19286,21 @@ function rewritePathAliasesInOutput(outDir, projectRoot, appDir) {
         } else {
           for (const ext of extensions) {
             const filePath = resolvedSourcePath + ext;
-            if (import_fs25.default.existsSync(filePath)) {
+            if (import_fs27.default.existsSync(filePath)) {
               actualSourcePath = filePath;
               break;
             }
           }
-          if (!actualSourcePath && import_fs25.default.existsSync(resolvedSourcePath)) {
+          if (!actualSourcePath && import_fs27.default.existsSync(resolvedSourcePath)) {
             actualSourcePath = resolvedSourcePath;
           }
         }
         if (actualSourcePath) {
-          const relativeFromApp = import_path35.default.relative(appDir, actualSourcePath);
-          const outputPath = import_path35.default.join(outDir, relativeFromApp);
+          const relativeFromApp = import_path38.default.relative(appDir, actualSourcePath);
+          const outputPath = import_path38.default.join(outDir, relativeFromApp);
           const pathWithoutExt = outputPath.replace(/\.(ts|tsx|js|jsx|json)$/, "");
           const compiledPath = pathWithoutExt + ".mjs";
-          if (import_fs25.default.existsSync(compiledPath)) {
+          if (import_fs27.default.existsSync(compiledPath)) {
             return compiledPath;
           }
         }
@@ -18799,17 +19309,17 @@ function rewritePathAliasesInOutput(outDir, projectRoot, appDir) {
     return null;
   }
   function walkAndRewrite(dir) {
-    if (!import_fs25.default.existsSync(dir)) return;
-    const items = import_fs25.default.readdirSync(dir, { withFileTypes: true });
+    if (!import_fs27.default.existsSync(dir)) return;
+    const items = import_fs27.default.readdirSync(dir, { withFileTypes: true });
     for (const item of items) {
-      const full = import_path35.default.join(dir, item.name);
+      const full = import_path38.default.join(dir, item.name);
       if (item.isDirectory()) {
         walkAndRewrite(full);
         continue;
       }
       if (item.isFile() && full.endsWith(".mjs")) {
         try {
-          let content = import_fs25.default.readFileSync(full, "utf-8");
+          let content = import_fs27.default.readFileSync(full, "utf-8");
           let modified = false;
           const aliasPatterns = Object.keys(aliases).sort((a, b) => b.length - a.length);
           for (const aliasKey of aliasPatterns) {
@@ -18821,8 +19331,8 @@ function rewritePathAliasesInOutput(outDir, projectRoot, appDir) {
             content = content.replace(aliasInQuotesPattern, (match, quote1, rest, quote2) => {
               const fullAliasPath = aliasKey + (rest || "");
               const resolvedOutputPath = resolveAliasToOutputPath(fullAliasPath);
-              if (resolvedOutputPath && import_fs25.default.existsSync(resolvedOutputPath)) {
-                const relativePath = import_path35.default.relative(import_path35.default.dirname(full), resolvedOutputPath);
+              if (resolvedOutputPath && import_fs27.default.existsSync(resolvedOutputPath)) {
+                const relativePath = import_path38.default.relative(import_path38.default.dirname(full), resolvedOutputPath);
                 let normalizedPath = relativePath.replace(/\\/g, "/");
                 if (!normalizedPath.startsWith(".")) {
                   normalizedPath = `./${normalizedPath}`;
@@ -18835,7 +19345,7 @@ function rewritePathAliasesInOutput(outDir, projectRoot, appDir) {
             });
           }
           if (modified) {
-            import_fs25.default.writeFileSync(full, content, "utf-8");
+            import_fs27.default.writeFileSync(full, content, "utf-8");
           }
         } catch (error) {
           console.warn(`[framework] Warning: Could not rewrite path aliases in ${full}:`, error instanceof Error ? error.message : String(error));
@@ -18846,14 +19356,14 @@ function rewritePathAliasesInOutput(outDir, projectRoot, appDir) {
   walkAndRewrite(outDir);
 }
 function copyStaticFilesFromApp(appDir, outDir) {
-  if (!import_fs25.default.existsSync(appDir)) return;
+  if (!import_fs27.default.existsSync(appDir)) return;
   const sourceExtensions = [".ts", ".tsx", ".js", ".jsx", ".d.ts", ".map"];
   function walk(srcDir, destDir) {
-    if (!import_fs25.default.existsSync(srcDir)) return;
-    const items = import_fs25.default.readdirSync(srcDir, { withFileTypes: true });
+    if (!import_fs27.default.existsSync(srcDir)) return;
+    const items = import_fs27.default.readdirSync(srcDir, { withFileTypes: true });
     for (const item of items) {
-      const srcPath = import_path35.default.join(srcDir, item.name);
-      const destPath = import_path35.default.join(destDir, item.name);
+      const srcPath = import_path38.default.join(srcDir, item.name);
+      const destPath = import_path38.default.join(destDir, item.name);
       if (item.isDirectory()) {
         if (item.name === "node_modules" || item.name.startsWith(".")) {
           continue;
@@ -18863,10 +19373,10 @@ function copyStaticFilesFromApp(appDir, outDir) {
         continue;
       }
       if (item.isFile()) {
-        const ext = import_path35.default.extname(item.name).toLowerCase();
+        const ext = import_path38.default.extname(item.name).toLowerCase();
         if (!sourceExtensions.includes(ext)) {
           ensureDir(destDir);
-          import_fs25.default.copyFileSync(srcPath, destPath);
+          import_fs27.default.copyFileSync(srcPath, destPath);
         }
       }
     }
@@ -18876,9 +19386,9 @@ function copyStaticFilesFromApp(appDir, outDir) {
 function collectAppSources(appDir) {
   const entries = [];
   function walk(dir) {
-    const items = import_fs25.default.readdirSync(dir, { withFileTypes: true });
+    const items = import_fs27.default.readdirSync(dir, { withFileTypes: true });
     for (const item of items) {
-      const full = import_path35.default.join(dir, item.name);
+      const full = import_path38.default.join(dir, item.name);
       if (item.isDirectory()) {
         walk(full);
         continue;
@@ -18895,7 +19405,7 @@ function collectAppSources(appDir) {
   return entries;
 }
 async function buildServerApp(projectRoot, appDir, config) {
-  const outDir = import_path35.default.join(projectRoot, BUILD_FOLDER_NAME, "server");
+  const outDir = import_path38.default.join(projectRoot, BUILD_FOLDER_NAME, "server");
   const entryPoints = collectAppSources(appDir);
   ensureDir(outDir);
   if (entryPoints.length === 0) {
@@ -18914,7 +19424,7 @@ async function buildServerApp(projectRoot, appDir, config) {
     bundle: true,
     splitting: false,
     logLevel: "info",
-    tsconfig: import_path35.default.join(projectRoot, "tsconfig.json"),
+    tsconfig: import_path38.default.join(projectRoot, "tsconfig.json"),
     packages: "external",
     outExtension: { ".js": ".mjs" },
     plugins: [pathAliasPlugin]
@@ -18923,9 +19433,9 @@ async function buildServerApp(projectRoot, appDir, config) {
   copyStaticFilesFromApp(appDir, outDir);
   rewritePathAliasesInOutput(outDir, projectRoot, appDir);
   for (const fileName of SERVER_FILES) {
-    const initTS = import_path35.default.join(projectRoot, `${fileName}.ts`);
-    if (import_fs25.default.existsSync(initTS)) {
-      const initJSWithExt = import_path35.default.join(outDir, `${fileName}.mjs`);
+    const initTS = import_path38.default.join(projectRoot, `${fileName}.ts`);
+    if (import_fs27.default.existsSync(initTS)) {
+      const initJSWithExt = import_path38.default.join(outDir, `${fileName}.mjs`);
       await import_esbuild.default.build({
         entryPoints: [initTS],
         outfile: initJSWithExt,
@@ -18937,7 +19447,7 @@ async function buildServerApp(projectRoot, appDir, config) {
         bundle: true,
         packages: "external",
         logLevel: "info",
-        tsconfig: import_path35.default.join(projectRoot, "tsconfig.json"),
+        tsconfig: import_path38.default.join(projectRoot, "tsconfig.json"),
         plugins: [pathAliasPlugin],
         outExtension: { ".js": ".mjs" }
       });
@@ -18953,8 +19463,8 @@ async function buildApp(options = {}) {
   const config = options.config ?? loadConfig(projectRoot);
   const appDir = options.appDir ?? getAppDir(projectRoot, config);
   try {
-    const tsxPath = import_path36.default.join(projectRoot, "node_modules", "tsx", "dist", "esm", "index.mjs");
-    if (import_fs26.default.existsSync(tsxPath)) {
+    const tsxPath = import_path39.default.join(projectRoot, "node_modules", "tsx", "dist", "esm", "index.mjs");
+    if (import_fs28.default.existsSync(tsxPath)) {
       const { pathToFileURL: pathToFileURL2 } = await import("url");
       const tsxUrl = pathToFileURL2(tsxPath).href;
       await import(tsxUrl);
@@ -19223,132 +19733,134 @@ function getOrCreateLink(rel, href) {
 }
 function applyMetadata(md) {
   if (!md) return;
-  if (md.title) {
-    document.title = md.title;
-  }
-  if (md.description) {
-    const meta = getOrCreateMeta('meta[name="description"]', { name: "description" });
-    meta.content = md.description;
-  }
-  if (md.robots) {
-    const meta = getOrCreateMeta('meta[name="robots"]', { name: "robots" });
-    meta.content = md.robots;
-  }
-  if (md.themeColor) {
-    const meta = getOrCreateMeta('meta[name="theme-color"]', { name: "theme-color" });
-    meta.content = md.themeColor;
-  }
-  if (md.viewport) {
-    const meta = getOrCreateMeta('meta[name="viewport"]', { name: "viewport" });
-    meta.content = md.viewport;
-  }
-  if (md.canonical) {
-    getOrCreateLink("canonical", md.canonical);
-  }
-  if (md.openGraph) {
-    const og = md.openGraph;
-    if (og.title) {
-      const meta = getOrCreateMeta('meta[property="og:title"]', { property: "og:title" });
-      meta.content = og.title;
-    }
-    if (og.description) {
-      const meta = getOrCreateMeta('meta[property="og:description"]', { property: "og:description" });
-      meta.content = og.description;
-    }
-    if (og.type) {
-      const meta = getOrCreateMeta('meta[property="og:type"]', { property: "og:type" });
-      meta.content = og.type;
-    }
-    if (og.url) {
-      const meta = getOrCreateMeta('meta[property="og:url"]', { property: "og:url" });
-      meta.content = og.url;
-    }
-    if (og.image) {
-      if (typeof og.image === "string") {
-        const meta = getOrCreateMeta('meta[property="og:image"]', { property: "og:image" });
-        meta.content = og.image;
-      } else {
-        const meta = getOrCreateMeta('meta[property="og:image"]', { property: "og:image" });
-        meta.content = og.image.url;
-        if (og.image.width) {
-          const metaWidth = getOrCreateMeta('meta[property="og:image:width"]', { property: "og:image:width" });
-          metaWidth.content = String(og.image.width);
-        }
-        if (og.image.height) {
-          const metaHeight = getOrCreateMeta('meta[property="og:image:height"]', { property: "og:image:height" });
-          metaHeight.content = String(og.image.height);
-        }
-        if (og.image.alt) {
-          const metaAlt = getOrCreateMeta('meta[property="og:image:alt"]', { property: "og:image:alt" });
-          metaAlt.content = og.image.alt;
+  requestAnimationFrame(() => {
+    if (md.title) {
+      document.title = md.title;
+    }
+    if (md.description) {
+      const meta = getOrCreateMeta('meta[name="description"]', { name: "description" });
+      meta.content = md.description;
+    }
+    if (md.robots) {
+      const meta = getOrCreateMeta('meta[name="robots"]', { name: "robots" });
+      meta.content = md.robots;
+    }
+    if (md.themeColor) {
+      const meta = getOrCreateMeta('meta[name="theme-color"]', { name: "theme-color" });
+      meta.content = md.themeColor;
+    }
+    if (md.viewport) {
+      const meta = getOrCreateMeta('meta[name="viewport"]', { name: "viewport" });
+      meta.content = md.viewport;
+    }
+    if (md.canonical) {
+      getOrCreateLink("canonical", md.canonical);
+    }
+    if (md.openGraph) {
+      const og = md.openGraph;
+      if (og.title) {
+        const meta = getOrCreateMeta('meta[property="og:title"]', { property: "og:title" });
+        meta.content = og.title;
+      }
+      if (og.description) {
+        const meta = getOrCreateMeta('meta[property="og:description"]', { property: "og:description" });
+        meta.content = og.description;
+      }
+      if (og.type) {
+        const meta = getOrCreateMeta('meta[property="og:type"]', { property: "og:type" });
+        meta.content = og.type;
+      }
+      if (og.url) {
+        const meta = getOrCreateMeta('meta[property="og:url"]', { property: "og:url" });
+        meta.content = og.url;
+      }
+      if (og.image) {
+        if (typeof og.image === "string") {
+          const meta = getOrCreateMeta('meta[property="og:image"]', { property: "og:image" });
+          meta.content = og.image;
+        } else {
+          const meta = getOrCreateMeta('meta[property="og:image"]', { property: "og:image" });
+          meta.content = og.image.url;
+          if (og.image.width) {
+            const metaWidth = getOrCreateMeta('meta[property="og:image:width"]', { property: "og:image:width" });
+            metaWidth.content = String(og.image.width);
+          }
+          if (og.image.height) {
+            const metaHeight = getOrCreateMeta('meta[property="og:image:height"]', { property: "og:image:height" });
+            metaHeight.content = String(og.image.height);
+          }
+          if (og.image.alt) {
+            const metaAlt = getOrCreateMeta('meta[property="og:image:alt"]', { property: "og:image:alt" });
+            metaAlt.content = og.image.alt;
+          }
         }
       }
+      if (og.siteName) {
+        const meta = getOrCreateMeta('meta[property="og:site_name"]', { property: "og:site_name" });
+        meta.content = og.siteName;
+      }
+      if (og.locale) {
+        const meta = getOrCreateMeta('meta[property="og:locale"]', { property: "og:locale" });
+        meta.content = og.locale;
+      }
     }
-    if (og.siteName) {
-      const meta = getOrCreateMeta('meta[property="og:site_name"]', { property: "og:site_name" });
-      meta.content = og.siteName;
-    }
-    if (og.locale) {
-      const meta = getOrCreateMeta('meta[property="og:locale"]', { property: "og:locale" });
-      meta.content = og.locale;
-    }
-  }
-  if (md.twitter) {
-    const twitter = md.twitter;
-    if (twitter.card) {
-      const meta = getOrCreateMeta('meta[name="twitter:card"]', { name: "twitter:card" });
-      meta.content = twitter.card;
-    }
-    if (twitter.title) {
-      const meta = getOrCreateMeta('meta[name="twitter:title"]', { name: "twitter:title" });
-      meta.content = twitter.title;
-    }
-    if (twitter.description) {
-      const meta = getOrCreateMeta('meta[name="twitter:description"]', { name: "twitter:description" });
-      meta.content = twitter.description;
-    }
-    if (twitter.image) {
-      const meta = getOrCreateMeta('meta[name="twitter:image"]', { name: "twitter:image" });
-      meta.content = twitter.image;
+    if (md.twitter) {
+      const twitter = md.twitter;
+      if (twitter.card) {
+        const meta = getOrCreateMeta('meta[name="twitter:card"]', { name: "twitter:card" });
+        meta.content = twitter.card;
+      }
+      if (twitter.title) {
+        const meta = getOrCreateMeta('meta[name="twitter:title"]', { name: "twitter:title" });
+        meta.content = twitter.title;
+      }
+      if (twitter.description) {
+        const meta = getOrCreateMeta('meta[name="twitter:description"]', { name: "twitter:description" });
+        meta.content = twitter.description;
+      }
+      if (twitter.image) {
+        const meta = getOrCreateMeta('meta[name="twitter:image"]', { name: "twitter:image" });
+        meta.content = twitter.image;
+      }
+      if (twitter.imageAlt) {
+        const meta = getOrCreateMeta('meta[name="twitter:image:alt"]', { name: "twitter:image:alt" });
+        meta.content = twitter.imageAlt;
+      }
+      if (twitter.site) {
+        const meta = getOrCreateMeta('meta[name="twitter:site"]', { name: "twitter:site" });
+        meta.content = twitter.site;
+      }
+      if (twitter.creator) {
+        const meta = getOrCreateMeta('meta[name="twitter:creator"]', { name: "twitter:creator" });
+        meta.content = twitter.creator;
+      }
     }
-    if (twitter.imageAlt) {
-      const meta = getOrCreateMeta('meta[name="twitter:image:alt"]', { name: "twitter:image:alt" });
-      meta.content = twitter.imageAlt;
+    if (md.metaTags && Array.isArray(md.metaTags)) {
+      md.metaTags.forEach((tag) => {
+        let selector = "";
+        if (tag.name) {
+          selector = `meta[name="${tag.name}"]`;
+        } else if (tag.property) {
+          selector = `meta[property="${tag.property}"]`;
+        } else if (tag.httpEquiv) {
+          selector = `meta[http-equiv="${tag.httpEquiv}"]`;
+        }
+        if (selector) {
+          const meta = getOrCreateMeta(selector, {
+            name: tag.name,
+            property: tag.property,
+            httpEquiv: tag.httpEquiv
+          });
+          meta.content = tag.content;
+        }
+      });
     }
-    if (twitter.site) {
-      const meta = getOrCreateMeta('meta[name="twitter:site"]', { name: "twitter:site" });
-      meta.content = twitter.site;
+    if (md.links && Array.isArray(md.links)) {
+      md.links.forEach((link) => {
+        getOrCreateLink(link.rel, link.href);
+      });
     }
-    if (twitter.creator) {
-      const meta = getOrCreateMeta('meta[name="twitter:creator"]', { name: "twitter:creator" });
-      meta.content = twitter.creator;
-    }
-  }
-  if (md.metaTags && Array.isArray(md.metaTags)) {
-    md.metaTags.forEach((tag) => {
-      let selector = "";
-      if (tag.name) {
-        selector = `meta[name="${tag.name}"]`;
-      } else if (tag.property) {
-        selector = `meta[property="${tag.property}"]`;
-      } else if (tag.httpEquiv) {
-        selector = `meta[http-equiv="${tag.httpEquiv}"]`;
-      }
-      if (selector) {
-        const meta = getOrCreateMeta(selector, {
-          name: tag.name,
-          property: tag.property,
-          httpEquiv: tag.httpEquiv
-        });
-        meta.content = tag.content;
-      }
-    });
-  }
-  if (md.links && Array.isArray(md.links)) {
-    md.links.forEach((link) => {
-      getOrCreateLink(link.rel, link.href);
-    });
-  }
+  });
 }
 
 // modules/runtime/client/AppShell.tsx
@@ -20238,11 +20750,11 @@ var ValidationError = class extends Error {
   format() {
     const formatted = {};
     for (const error of this.errors) {
-      const path33 = error.path.join(".");
-      if (!formatted[path33]) {
-        formatted[path33] = [];
+      const path36 = error.path.join(".");
+      if (!formatted[path36]) {
+        formatted[path36] = [];
       }
-      formatted[path33].push(error.message);
+      formatted[path36].push(error.message);
     }
     return formatted;
   }