vxrn 0.1.63 → 0.1.64

package/dist/cjs/exports/createServer.js

@@ -1,8 +1,7 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: !0 });
@@ -12,44 +11,20 @@ var __export = (target, all) => {
       !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
-  mod
-)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 var createServer_exports = {};
 __export(createServer_exports, {
   createProdServer: () => createProdServer
 });
 module.exports = __toCommonJS(createServer_exports);
-var import_h3 = require("h3"), import_sirv = __toESM(require("sirv"), 1);
+var import_hono = require("hono"), import_compress = require("hono/compress"), import_serve_static = require("@hono/node-server/serve-static");
 const createProdServer = async (options) => {
-  const app = (0, import_h3.createApp)(), sirvStaticMiddleware = (0, import_sirv.default)("dist/static", {
-    gzip: !0
-  });
-  options.serve && options.serve(options, app), app.use(
-    (0, import_h3.defineEventHandler)(async ({ node: { req, res } }) => {
-      await new Promise((response) => {
-        sirvStaticMiddleware(req, res, () => {
-          response();
-        });
-      });
+  const app = new import_hono.Hono();
+  return app.use((0, import_compress.compress)()), app.use(
+    "*",
+    (0, import_serve_static.serveStatic)({
+      root: "./dist/client"
     })
-  );
-  const sirvMiddleware = (0, import_sirv.default)("dist/client", {
-    gzip: !0
-  });
-  return app.use(
-    (0, import_h3.defineEventHandler)(async ({ node: { req, res } }) => {
-      await new Promise((response) => {
-        sirvMiddleware(req, res, () => {
-          response();
-        });
-      });
-    })
-  ), app;
+  ), options.serve && options.serve(options, app), app;
 };
 //# sourceMappingURL=createServer.js.map

package/dist/cjs/exports/createServer.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/exports/createServer.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAA8C,eAC9C,cAAiB;AAGV,MAAM,mBAAmB,OAAO,YAAwB;AAC7D,QAAM,UAAM,qBAAU,GAEhB,2BAAuB,YAAAA,SAAK,eAAe;AAAA,IAC/C,MAAM;AAAA,EACR,CAAC;AAED,EAAI,QAAQ,SACV,QAAQ,MAAM,SAAS,GAAG,GAG5B,IAAI;AAAA,QACF,8BAAmB,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM;AACnD,YAAM,IAAI,QAAc,CAAC,aAAa;AACpC,6BAAqB,KAAK,KAAK,MAAM;AACnC,mBAAS;AAAA,QACX,CAAC;AAAA,MACH,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAEA,QAAM,qBAAiB,YAAAA,SAAK,eAAe;AAAA,IACzC,MAAM;AAAA,EACR,CAAC;AAED,aAAI;AAAA,QACF,8BAAmB,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM;AACnD,YAAM,IAAI,QAAc,CAAC,aAAa;AACpC,uBAAe,KAAK,KAAK,MAAM;AAC7B,mBAAS;AAAA,QACX,CAAC;AAAA,MACH,CAAC;AAAA,IACH,CAAC;AAAA,EACH,GAEO;AACT;",
-  "names": ["sirv"]
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAqB,iBACrB,kBAAyB,0BAEzB,sBAA4B;AAIrB,MAAM,mBAAmB,OAAO,YAAwB;AAC7D,QAAM,MAAM,IAAI,iBAAK;AAErB,aAAI,QAAI,0BAAS,CAAC,GAElB,IAAI;AAAA,IACF;AAAA,QACA,iCAAY;AAAA,MACV,MAAM;AAAA,IACR,CAAC;AAAA,EACH,GAUI,QAAQ,SACV,QAAQ,MAAM,SAAS,GAAG,GAGrB;AACT;",
+  "names": []
 }

package/dist/cjs/exports/createServer.native.js

@@ -1,9 +1,8 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: !0 });
@@ -13,20 +12,13 @@ var __export = (target, all) => {
       !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
-  mod
-)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 var createServer_exports = {};
 __export(createServer_exports, {
   createProdServer: () => createProdServer
 });
 module.exports = __toCommonJS(createServer_exports);
-var import_h3 = require("h3"), import_sirv = __toESM(require("sirv"), 1);
+var import_hono = require("hono"), import_compress = require("hono/compress"), import_serve_static = require("@hono/node-server/serve-static");
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
     var info = gen[key](arg), value = info.value;
@@ -143,67 +135,45 @@ function _ts_generator(thisArg, body) {
   }
 }
 var createProdServer = function() {
-  var _ref = _async_to_generator(function(options) {
-    var app, sirvStaticMiddleware, sirvMiddleware;
-    return _ts_generator(this, function(_state) {
-      return app = (0, import_h3.createApp)(), sirvStaticMiddleware = (0, import_sirv.default)("dist/static", {
-        gzip: !0
-      }), options.serve && options.serve(options, app), app.use((0, import_h3.defineEventHandler)(function() {
-        var _ref2 = _async_to_generator(function(param) {
-          var _param_node, req, res;
-          return _ts_generator(this, function(_state2) {
-            switch (_state2.label) {
-              case 0:
-                return _param_node = param.node, req = _param_node.req, res = _param_node.res, [
-                  4,
-                  new Promise(function(response) {
-                    sirvStaticMiddleware(req, res, function() {
-                      response();
-                    });
-                  })
-                ];
-              case 1:
-                return _state2.sent(), [
-                  2
-                ];
-            }
-          });
-        });
-        return function(_) {
-          return _ref2.apply(this, arguments);
-        };
-      }())), sirvMiddleware = (0, import_sirv.default)("dist/client", {
-        gzip: !0
-      }), app.use((0, import_h3.defineEventHandler)(function() {
-        var _ref2 = _async_to_generator(function(param) {
-          var _param_node, req, res;
-          return _ts_generator(this, function(_state2) {
-            switch (_state2.label) {
-              case 0:
-                return _param_node = param.node, req = _param_node.req, res = _param_node.res, [
-                  4,
-                  new Promise(function(response) {
-                    sirvMiddleware(req, res, function() {
-                      response();
-                    });
-                  })
-                ];
-              case 1:
-                return _state2.sent(), [
-                  2
-                ];
-            }
-          });
-        });
-        return function(_) {
-          return _ref2.apply(this, arguments);
-        };
-      }())), [
-        2,
-        app
-      ];
-    });
-  });
+  var _ref = _async_to_generator(
+    function(options) {
+      var app;
+      return _ts_generator(this, function(_state) {
+        return app = new import_hono.Hono(), app.use((0, import_compress.compress)()), app.use("*", (0, import_serve_static.serveStatic)({
+          root: "./dist/client"
+        })), options.serve && options.serve(options, app), [
+          2,
+          app
+        ];
+      });
+    }
+    // // testing cache
+    // const caches = {}
+    // function createCache(name: string) {
+    //   if (caches[name]) return caches[name] as any
+    //   const store = {}
+    //   const cache = {
+    //     async match(key: string) {
+    //       console.log('matching', key)
+    //       return store[key]
+    //     },
+    //     async put(key: string, val) {
+    //       store[key] = val
+    //     },
+    //     async delete(key: string) {
+    //       delete store[key]
+    //     },
+    //   }
+    //   caches[name] = cache
+    //   return cache
+    // }
+    // globalThis.caches = {
+    //   ...createCache(''),
+    //   async open(name: string) {
+    //     return createCache(name)
+    //   },
+    // }
+  );
   return function(options) {
     return _ref.apply(this, arguments);
   };

package/dist/cjs/exports/createServer.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/exports/Users/n8/vxrn/packages/vxrn/src/exports/createServer.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,gBAA8C,eAC9C,cAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGV,IAAMA,mBAAAA,WAAAA;aAAmB,oBAAA,SAAOC,SAAAA;QAC/BC,KAEAC,sBAkBAC;;AApBAF,uBAAMG,qBAAAA,GAENF,2BAAuBG,YAAAA,SAAK,eAAe;QAC/CC,MAAM;MACR,CAAA,GAEIN,QAAQO,SACVP,QAAQO,MAAMP,SAASC,GAAAA,GAGzBA,IAAIO,QACFC,8BAAAA,WAAAA;oBAAmB,oBAAA,SAAA,OAAA;2BAAiBC,KAAKC;;;;2CAAbC,MAAQF,MAAAA,YAAAA,KAAKC,MAAAA,YAAAA,KACvC;;kBAAM,IAAIE,QAAc,SAACC,UAAAA;AACvBZ,yCAAqBQ,KAAKC,KAAK,WAAA;AAC7BG,+BAAAA;oBACF,CAAA;kBACF,CAAA;;;AAJA,uBAAAC,QAAA,KAAA;;;;;QAKF,CAAA;;;;aAGIZ,qBAAiBE,YAAAA,SAAK,eAAe;QACzCC,MAAM;MACR,CAAA,GAEAL,IAAIO,QACFC,8BAAAA,WAAAA;oBAAmB,oBAAA,SAAA,OAAA;2BAAiBC,KAAKC;;;;2CAAbC,MAAQF,MAAAA,YAAAA,KAAKC,MAAAA,YAAAA,KACvC;;kBAAM,IAAIE,QAAc,SAACC,UAAAA;AACvBX,mCAAeO,KAAKC,KAAK,WAAA;AACvBG,+BAAAA;oBACF,CAAA;kBACF,CAAA;;;AAJA,uBAAAC,QAAA,KAAA;;;;;QAKF,CAAA;;;;aAGF;;QAAOd;;;EACT,CAAA;kBApCuCD,SAAAA;;;;",
-  "names": ["createProdServer", "options", "app", "sirvStaticMiddleware", "sirvMiddleware", "createApp", "sirv", "gzip", "serve", "use", "defineEventHandler", "req", "res", "node", "Promise", "response", "_state"]
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA,kBAAqB,iBACrB,kBAAyB,0BAEzB,sBAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIrB,IAAMA,mBAAAA,WAAAA;aAAmB;IAAA,SAAOC,SAAAA;UAC/BC;;AAAAA,qBAAM,IAAIC,iBAAAA,GAEhBD,IAAIE,QAAIC,0BAAAA,CAAAA,GAERH,IAAIE,IACF,SACAE,iCAAY;UACVC,MAAM;QACR,CAAA,CAAA,GAWEN,QAAQO,SACVP,QAAQO,MAAMP,SAASC,GAAAA,GAGzB;;UAAOA;;;IACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAzBuCD,SAAAA;;;;",
+  "names": ["createProdServer", "options", "app", "Hono", "use", "compress", "serveStatic", "root", "serve"]
 }

package/dist/cjs/exports/serve.js

@@ -17,10 +17,16 @@ __export(serve_exports, {
   serve: () => serve
 });
 module.exports = __toCommonJS(serve_exports);
-var import_h3 = require("h3"), import_node_http = require("node:http"), import_createServer = require("./createServer"), import_getOptionsFilled = require("../utils/getOptionsFilled");
+var import_node_server = require("@hono/node-server"), import_createServer = require("./createServer"), import_getOptionsFilled = require("../utils/getOptionsFilled");
 const serve = async (optionsIn) => {
-  const options = await (0, import_getOptionsFilled.getOptionsFilled)(optionsIn, { mode: "prod" }), app = await (0, import_createServer.createProdServer)(options), server = (0, import_node_http.createServer)((0, import_h3.toNodeListener)(app));
-  await new Promise((res) => setTimeout(res, 1)), server.listen(options.port, options.host), console.info(`Listening on http://${options.host}:${options.port}`), await new Promise((res) => {
+  const options = await (0, import_getOptionsFilled.getOptionsFilled)(optionsIn, { mode: "prod" }), app = await (0, import_createServer.createProdServer)(options);
+  await new Promise((res) => setTimeout(res, 1));
+  const server = (0, import_node_server.serve)({
+    fetch: app.fetch,
+    port: options.port,
+    hostname: options.host
+  });
+  console.info(`Listening on http://${options.host}:${options.port}`), await new Promise((res) => {
     server.on("close", () => {
       res();
     });

package/dist/cjs/exports/serve.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/exports/serve.ts"],
-  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAA+B,eAC/B,mBAA6B,sBAE7B,sBAAiC,2BACjC,0BAAiC;AAE1B,MAAM,QAAQ,OAAO,cAA0B;AACpD,QAAM,UAAU,UAAM,0CAAiB,WAAW,EAAE,MAAM,OAAO,CAAC,GAC5D,MAAM,UAAM,sCAAiB,OAAO,GACpC,aAAS,mCAAa,0BAAe,GAAG,CAAC;AAE/C,QAAM,IAAI,QAAQ,CAAC,QAAQ,WAAW,KAAK,CAAC,CAAC,GAC7C,OAAO,OAAO,QAAQ,MAAM,QAAQ,IAAI,GACxC,QAAQ,KAAK,uBAAuB,QAAQ,IAAI,IAAI,QAAQ,IAAI,EAAE,GAClE,MAAM,IAAI,QAAc,CAAC,QAAQ;AAC/B,WAAO,GAAG,SAAS,MAAM;AACvB,UAAI;AAAA,IACN,CAAC;AAAA,EACH,CAAC;AACH;",
-  "names": []
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAAmC,8BAGnC,sBAAiC,2BACjC,0BAAiC;AAE1B,MAAM,QAAQ,OAAO,cAA0B;AACpD,QAAM,UAAU,UAAM,0CAAiB,WAAW,EAAE,MAAM,OAAO,CAAC,GAC5D,MAAM,UAAM,sCAAiB,OAAO;AAE1C,QAAM,IAAI,QAAQ,CAAC,QAAQ,WAAW,KAAK,CAAC,CAAC;AAC7C,QAAM,aAAS,mBAAAA,OAAU;AAAA,IACvB,OAAO,IAAI;AAAA,IACX,MAAM,QAAQ;AAAA,IACd,UAAU,QAAQ;AAAA,EACpB,CAAC;AAED,UAAQ,KAAK,uBAAuB,QAAQ,IAAI,IAAI,QAAQ,IAAI,EAAE,GAClE,MAAM,IAAI,QAAc,CAAC,QAAQ;AAC/B,WAAO,GAAG,SAAS,MAAM;AACvB,UAAI;AAAA,IACN,CAAC;AAAA,EACH,CAAC;AACH;",
+  "names": ["honoServe"]
 }

package/dist/cjs/exports/serve.native.js

@@ -18,7 +18,7 @@ __export(serve_exports, {
   serve: () => serve
 });
 module.exports = __toCommonJS(serve_exports);
-var import_h3 = require("h3"), import_node_http = require("node:http"), import_createServer = require("./createServer"), import_getOptionsFilled = require("../utils/getOptionsFilled");
+var import_node_server = require("@hono/node-server"), import_createServer = require("./createServer"), import_getOptionsFilled = require("../utils/getOptionsFilled");
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
     var info = gen[key](arg), value = info.value;
@@ -152,14 +152,18 @@ var serve = function() {
             (0, import_createServer.createProdServer)(options)
           ];
         case 2:
-          return app = _state.sent(), server = (0, import_node_http.createServer)((0, import_h3.toNodeListener)(app)), [
+          return app = _state.sent(), [
             4,
             new Promise(function(res) {
               return setTimeout(res, 1);
             })
           ];
         case 3:
-          return _state.sent(), server.listen(options.port, options.host), console.info("Listening on http://".concat(options.host, ":").concat(options.port)), [
+          return _state.sent(), server = (0, import_node_server.serve)({
+            fetch: app.fetch,
+            port: options.port,
+            hostname: options.host
+          }), console.info("Listening on http://".concat(options.host, ":").concat(options.port)), [
             4,
             new Promise(function(res) {
               server.on("close", function() {

package/dist/cjs/exports/serve.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/exports/Users/n8/vxrn/packages/vxrn/src/exports/serve.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA,gBAA+B,eAC/B,mBAA6B,sBAE7B,sBAAiC,2BACjC,0BAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE1B,IAAMA,QAAAA,WAAAA;aAAQ,oBAAA,SAAOC,WAAAA;QACpBC,SACAC,KACAC;;;;AAFU,iBAAA;;gBAAMC,0CAAiBJ,WAAW;cAAEK,MAAM;YAAO,CAAA;;;AAA3DJ,2BAAU,OAAA,KAAA,GACJ;;gBAAMK,sCAAiBL,OAAAA;;;AAA7BC,uBAAM,OAAA,KAAA,GACNC,aAASI,mCAAaC,0BAAeN,GAAAA,CAAAA,GAE3C;;YAAM,IAAIO,QAAQ,SAACC,KAAAA;qBAAQC,WAAWD,KAAK,CAAA;;;;AAA3C,wBAAA,KAAA,GACAP,OAAOS,OAAOX,QAAQY,MAAMZ,QAAQa,IAAI,GACxCC,QAAQC,KAAM,uBAAsCf,OAAhBA,QAAQa,MAAK,GAAA,EAAgB,OAAbb,QAAQY,IAAI,CAAA,GAChE;;YAAM,IAAIJ,QAAc,SAACC,KAAAA;AACvBP,qBAAOc,GAAG,SAAS,WAAA;AACjBP,oBAAAA;cACF,CAAA;YACF,CAAA;;;AAJA,wBAAA,KAAA;;;;;EAKF,CAAA;kBAb4BV,WAAAA;;;;",
-  "names": ["serve", "optionsIn", "options", "app", "server", "getOptionsFilled", "mode", "createProdServer", "createServer", "toNodeListener", "Promise", "res", "setTimeout", "listen", "port", "host", "console", "info", "on"]
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA,yBAAmC,8BAGnC,sBAAiC,2BACjC,0BAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE1B,IAAMA,QAAAA,WAAAA;aAAQ,oBAAA,SAAOC,WAAAA;QACpBC,SACAC,KAGAC;;;;AAJU,iBAAA;;gBAAMC,0CAAiBJ,WAAW;cAAEK,MAAM;YAAO,CAAA;;;AAA3DJ,2BAAU,OAAA,KAAA,GACJ;;gBAAMK,sCAAiBL,OAAAA;;;AAA7BC,uBAAM,OAAA,KAAA,GAEZ;;YAAM,IAAIK,QAAQ,SAACC,KAAAA;qBAAQC,WAAWD,KAAK,CAAA;;;;AAA3C,wBAAA,KAAA,GACML,aAASO,mBAAAA,OAAU;YACvBC,OAAOT,IAAIS;YACXC,MAAMX,QAAQW;YACdC,UAAUZ,QAAQa;UACpB,CAAA,GAEAC,QAAQC,KAAM,uBAAsCf,OAAhBA,QAAQa,MAAK,GAAA,EAAgB,OAAbb,QAAQW,IAAI,CAAA,GAChE;;YAAM,IAAIL,QAAc,SAACC,KAAAA;AACvBL,qBAAOc,GAAG,SAAS,WAAA;AACjBT,oBAAAA;cACF,CAAA;YACF,CAAA;;;AAJA,wBAAA,KAAA;;;;;EAKF,CAAA;kBAjB4BR,WAAAA;;;;",
+  "names": ["serve", "optionsIn", "options", "app", "server", "getOptionsFilled", "mode", "createProdServer", "Promise", "res", "setTimeout", "honoServe", "fetch", "port", "hostname", "host", "console", "info", "on"]
 }

package/dist/esm/exports/createServer.js

@@ -1,30 +1,14 @@
-import { createApp, defineEventHandler } from "h3";
-import sirv from "sirv";
+import { Hono } from "hono";
+import { compress } from "hono/compress";
+import { serveStatic } from "@hono/node-server/serve-static";
 const createProdServer = async (options) => {
-  const app = createApp(), sirvStaticMiddleware = sirv("dist/static", {
-    gzip: !0
-  });
-  options.serve && options.serve(options, app), app.use(
-    defineEventHandler(async ({ node: { req, res } }) => {
-      await new Promise((response) => {
-        sirvStaticMiddleware(req, res, () => {
-          response();
-        });
-      });
+  const app = new Hono();
+  return app.use(compress()), app.use(
+    "*",
+    serveStatic({
+      root: "./dist/client"
     })
-  );
-  const sirvMiddleware = sirv("dist/client", {
-    gzip: !0
-  });
-  return app.use(
-    defineEventHandler(async ({ node: { req, res } }) => {
-      await new Promise((response) => {
-        sirvMiddleware(req, res, () => {
-          response();
-        });
-      });
-    })
-  ), app;
+  ), options.serve && options.serve(options, app), app;
 };
 export {
   createProdServer

package/dist/esm/exports/createServer.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/exports/createServer.ts"],
-  "mappings": "AAAA,SAAS,WAAW,0BAA0B;AAC9C,OAAO,UAAU;AAGV,MAAM,mBAAmB,OAAO,YAAwB;AAC7D,QAAM,MAAM,UAAU,GAEhB,uBAAuB,KAAK,eAAe;AAAA,IAC/C,MAAM;AAAA,EACR,CAAC;AAED,EAAI,QAAQ,SACV,QAAQ,MAAM,SAAS,GAAG,GAG5B,IAAI;AAAA,IACF,mBAAmB,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM;AACnD,YAAM,IAAI,QAAc,CAAC,aAAa;AACpC,6BAAqB,KAAK,KAAK,MAAM;AACnC,mBAAS;AAAA,QACX,CAAC;AAAA,MACH,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAEA,QAAM,iBAAiB,KAAK,eAAe;AAAA,IACzC,MAAM;AAAA,EACR,CAAC;AAED,aAAI;AAAA,IACF,mBAAmB,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM;AACnD,YAAM,IAAI,QAAc,CAAC,aAAa;AACpC,uBAAe,KAAK,KAAK,MAAM;AAC7B,mBAAS;AAAA,QACX,CAAC;AAAA,MACH,CAAC;AAAA,IACH,CAAC;AAAA,EACH,GAEO;AACT;",
+  "mappings": "AAAA,SAAS,YAAY;AACrB,SAAS,gBAAgB;AAEzB,SAAS,mBAAmB;AAIrB,MAAM,mBAAmB,OAAO,YAAwB;AAC7D,QAAM,MAAM,IAAI,KAAK;AAErB,aAAI,IAAI,SAAS,CAAC,GAElB,IAAI;AAAA,IACF;AAAA,IACA,YAAY;AAAA,MACV,MAAM;AAAA,IACR,CAAC;AAAA,EACH,GAUI,QAAQ,SACV,QAAQ,MAAM,SAAS,GAAG,GAGrB;AACT;",
   "names": []
 }

package/dist/esm/exports/createServer.mjs

@@ -1,36 +1,10 @@
-import { createApp, defineEventHandler } from "h3";
-import sirv from "sirv";
+import { Hono } from "hono";
+import { compress } from "hono/compress";
+import { serveStatic } from "@hono/node-server/serve-static";
 const createProdServer = async options => {
-  const app = createApp(),
-    sirvStaticMiddleware = sirv("dist/static", {
-      gzip: !0
-    });
-  options.serve && options.serve(options, app), app.use(defineEventHandler(async ({
-    node: {
-      req,
-      res
-    }
-  }) => {
-    await new Promise(response => {
-      sirvStaticMiddleware(req, res, () => {
-        response();
-      });
-    });
-  }));
-  const sirvMiddleware = sirv("dist/client", {
-    gzip: !0
-  });
-  return app.use(defineEventHandler(async ({
-    node: {
-      req,
-      res
-    }
-  }) => {
-    await new Promise(response => {
-      sirvMiddleware(req, res, () => {
-        response();
-      });
-    });
-  })), app;
+  const app = new Hono();
+  return app.use(compress()), app.use("*", serveStatic({
+    root: "./dist/client"
+  })), options.serve && options.serve(options, app), app;
 };
 export { createProdServer };

package/dist/esm/exports/createServer.native.js

@@ -1,5 +1,6 @@
-import { createApp, defineEventHandler } from "h3";
-import sirv from "sirv";
+import { Hono } from "hono";
+import { compress } from "hono/compress";
+import { serveStatic } from "@hono/node-server/serve-static";
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
     var info = gen[key](arg), value = info.value;
@@ -116,67 +117,45 @@ function _ts_generator(thisArg, body) {
   }
 }
 var createProdServer = function() {
-  var _ref = _async_to_generator(function(options) {
-    var app, sirvStaticMiddleware, sirvMiddleware;
-    return _ts_generator(this, function(_state) {
-      return app = createApp(), sirvStaticMiddleware = sirv("dist/static", {
-        gzip: !0
-      }), options.serve && options.serve(options, app), app.use(defineEventHandler(function() {
-        var _ref2 = _async_to_generator(function(param) {
-          var _param_node, req, res;
-          return _ts_generator(this, function(_state2) {
-            switch (_state2.label) {
-              case 0:
-                return _param_node = param.node, req = _param_node.req, res = _param_node.res, [
-                  4,
-                  new Promise(function(response) {
-                    sirvStaticMiddleware(req, res, function() {
-                      response();
-                    });
-                  })
-                ];
-              case 1:
-                return _state2.sent(), [
-                  2
-                ];
-            }
-          });
-        });
-        return function(_) {
-          return _ref2.apply(this, arguments);
-        };
-      }())), sirvMiddleware = sirv("dist/client", {
-        gzip: !0
-      }), app.use(defineEventHandler(function() {
-        var _ref2 = _async_to_generator(function(param) {
-          var _param_node, req, res;
-          return _ts_generator(this, function(_state2) {
-            switch (_state2.label) {
-              case 0:
-                return _param_node = param.node, req = _param_node.req, res = _param_node.res, [
-                  4,
-                  new Promise(function(response) {
-                    sirvMiddleware(req, res, function() {
-                      response();
-                    });
-                  })
-                ];
-              case 1:
-                return _state2.sent(), [
-                  2
-                ];
-            }
-          });
-        });
-        return function(_) {
-          return _ref2.apply(this, arguments);
-        };
-      }())), [
-        2,
-        app
-      ];
-    });
-  });
+  var _ref = _async_to_generator(
+    function(options) {
+      var app;
+      return _ts_generator(this, function(_state) {
+        return app = new Hono(), app.use(compress()), app.use("*", serveStatic({
+          root: "./dist/client"
+        })), options.serve && options.serve(options, app), [
+          2,
+          app
+        ];
+      });
+    }
+    // // testing cache
+    // const caches = {}
+    // function createCache(name: string) {
+    //   if (caches[name]) return caches[name] as any
+    //   const store = {}
+    //   const cache = {
+    //     async match(key: string) {
+    //       console.log('matching', key)
+    //       return store[key]
+    //     },
+    //     async put(key: string, val) {
+    //       store[key] = val
+    //     },
+    //     async delete(key: string) {
+    //       delete store[key]
+    //     },
+    //   }
+    //   caches[name] = cache
+    //   return cache
+    // }
+    // globalThis.caches = {
+    //   ...createCache(''),
+    //   async open(name: string) {
+    //     return createCache(name)
+    //   },
+    // }
+  );
   return function(options) {
     return _ref.apply(this, arguments);
   };

package/dist/esm/exports/createServer.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/exports/Users/n8/vxrn/packages/vxrn/src/exports/createServer.ts"],
-  "mappings": "AAAA,SAASA,WAAWC,0BAA0B;AAC9C,OAAOC,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGV,IAAMC,mBAAAA,WAAAA;aAAmB,oBAAA,SAAOC,SAAAA;QAC/BC,KAEAC,sBAkBAC;;AApBAF,mBAAML,UAAAA,GAENM,uBAAuBJ,KAAK,eAAe;QAC/CM,MAAM;MACR,CAAA,GAEIJ,QAAQK,SACVL,QAAQK,MAAML,SAASC,GAAAA,GAGzBA,IAAIK,IACFT,mBAAAA,WAAAA;oBAAmB,oBAAA,SAAA,OAAA;2BAAiBU,KAAKC;;;;2CAAbC,MAAQF,MAAAA,YAAAA,KAAKC,MAAAA,YAAAA,KACvC;;kBAAM,IAAIE,QAAc,SAACC,UAAAA;AACvBT,yCAAqBK,KAAKC,KAAK,WAAA;AAC7BG,+BAAAA;oBACF,CAAA;kBACF,CAAA;;;AAJA,uBAAAC,QAAA,KAAA;;;;;QAKF,CAAA;;;;aAGIT,iBAAiBL,KAAK,eAAe;QACzCM,MAAM;MACR,CAAA,GAEAH,IAAIK,IACFT,mBAAAA,WAAAA;oBAAmB,oBAAA,SAAA,OAAA;2BAAiBU,KAAKC;;;;2CAAbC,MAAQF,MAAAA,YAAAA,KAAKC,MAAAA,YAAAA,KACvC;;kBAAM,IAAIE,QAAc,SAACC,UAAAA;AACvBR,mCAAeI,KAAKC,KAAK,WAAA;AACvBG,+BAAAA;oBACF,CAAA;kBACF,CAAA;;;AAJA,uBAAAC,QAAA,KAAA;;;;;QAKF,CAAA;;;;aAGF;;QAAOX;;;EACT,CAAA;kBApCuCD,SAAAA;;;;",
-  "names": ["createApp", "defineEventHandler", "sirv", "createProdServer", "options", "app", "sirvStaticMiddleware", "sirvMiddleware", "gzip", "serve", "use", "req", "res", "node", "Promise", "response", "_state"]
+  "mappings": "AAAA,SAASA,YAAY;AACrB,SAASC,gBAAgB;AAEzB,SAASC,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIrB,IAAMC,mBAAAA,WAAAA;aAAmB;IAAA,SAAOC,SAAAA;UAC/BC;;AAAAA,qBAAM,IAAIL,KAAAA,GAEhBK,IAAIC,IAAIL,SAAAA,CAAAA,GAERI,IAAIC,IACF,KACAJ,YAAY;UACVK,MAAM;QACR,CAAA,CAAA,GAWEH,QAAQI,SACVJ,QAAQI,MAAMJ,SAASC,GAAAA,GAGzB;;UAAOA;;;IACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAzBuCD,SAAAA;;;;",
+  "names": ["Hono", "compress", "serveStatic", "createProdServer", "options", "app", "use", "root", "serve"]
 }

package/dist/esm/exports/serve.js

@@ -1,10 +1,15 @@
-import { toNodeListener } from "h3";
-import { createServer } from "node:http";
+import { serve as honoServe } from "@hono/node-server";
 import { createProdServer } from "./createServer";
 import { getOptionsFilled } from "../utils/getOptionsFilled";
 const serve = async (optionsIn) => {
-  const options = await getOptionsFilled(optionsIn, { mode: "prod" }), app = await createProdServer(options), server = createServer(toNodeListener(app));
-  await new Promise((res) => setTimeout(res, 1)), server.listen(options.port, options.host), console.info(`Listening on http://${options.host}:${options.port}`), await new Promise((res) => {
+  const options = await getOptionsFilled(optionsIn, { mode: "prod" }), app = await createProdServer(options);
+  await new Promise((res) => setTimeout(res, 1));
+  const server = honoServe({
+    fetch: app.fetch,
+    port: options.port,
+    hostname: options.host
+  });
+  console.info(`Listening on http://${options.host}:${options.port}`), await new Promise((res) => {
     server.on("close", () => {
       res();
     });

package/dist/esm/exports/serve.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/exports/serve.ts"],
-  "mappings": "AAAA,SAAS,sBAAsB;AAC/B,SAAS,oBAAoB;AAE7B,SAAS,wBAAwB;AACjC,SAAS,wBAAwB;AAE1B,MAAM,QAAQ,OAAO,cAA0B;AACpD,QAAM,UAAU,MAAM,iBAAiB,WAAW,EAAE,MAAM,OAAO,CAAC,GAC5D,MAAM,MAAM,iBAAiB,OAAO,GACpC,SAAS,aAAa,eAAe,GAAG,CAAC;AAE/C,QAAM,IAAI,QAAQ,CAAC,QAAQ,WAAW,KAAK,CAAC,CAAC,GAC7C,OAAO,OAAO,QAAQ,MAAM,QAAQ,IAAI,GACxC,QAAQ,KAAK,uBAAuB,QAAQ,IAAI,IAAI,QAAQ,IAAI,EAAE,GAClE,MAAM,IAAI,QAAc,CAAC,QAAQ;AAC/B,WAAO,GAAG,SAAS,MAAM;AACvB,UAAI;AAAA,IACN,CAAC;AAAA,EACH,CAAC;AACH;",
+  "mappings": "AAAA,SAAS,SAAS,iBAAiB;AAGnC,SAAS,wBAAwB;AACjC,SAAS,wBAAwB;AAE1B,MAAM,QAAQ,OAAO,cAA0B;AACpD,QAAM,UAAU,MAAM,iBAAiB,WAAW,EAAE,MAAM,OAAO,CAAC,GAC5D,MAAM,MAAM,iBAAiB,OAAO;AAE1C,QAAM,IAAI,QAAQ,CAAC,QAAQ,WAAW,KAAK,CAAC,CAAC;AAC7C,QAAM,SAAS,UAAU;AAAA,IACvB,OAAO,IAAI;AAAA,IACX,MAAM,QAAQ;AAAA,IACd,UAAU,QAAQ;AAAA,EACpB,CAAC;AAED,UAAQ,KAAK,uBAAuB,QAAQ,IAAI,IAAI,QAAQ,IAAI,EAAE,GAClE,MAAM,IAAI,QAAc,CAAC,QAAQ;AAC/B,WAAO,GAAG,SAAS,MAAM;AACvB,UAAI;AAAA,IACN,CAAC;AAAA,EACH,CAAC;AACH;",
   "names": []
 }

package/dist/esm/exports/serve.mjs

@@ -1,14 +1,18 @@
-import { toNodeListener } from "h3";
-import { createServer } from "node:http";
+import { serve as honoServe } from "@hono/node-server";
 import { createProdServer } from "./createServer.mjs";
 import { getOptionsFilled } from "../utils/getOptionsFilled.mjs";
 const serve = async optionsIn => {
   const options = await getOptionsFilled(optionsIn, {
       mode: "prod"
     }),
-    app = await createProdServer(options),
-    server = createServer(toNodeListener(app));
-  await new Promise(res => setTimeout(res, 1)), server.listen(options.port, options.host), console.info(`Listening on http://${options.host}:${options.port}`), await new Promise(res => {
+    app = await createProdServer(options);
+  await new Promise(res => setTimeout(res, 1));
+  const server = honoServe({
+    fetch: app.fetch,
+    port: options.port,
+    hostname: options.host
+  });
+  console.info(`Listening on http://${options.host}:${options.port}`), await new Promise(res => {
     server.on("close", () => {
       res();
     });

package/dist/esm/exports/serve.native.js

@@ -1,5 +1,4 @@
-import { toNodeListener } from "h3";
-import { createServer } from "node:http";
+import { serve as honoServe } from "@hono/node-server";
 import { createProdServer } from "./createServer";
 import { getOptionsFilled } from "../utils/getOptionsFilled";
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
@@ -135,14 +134,18 @@ var serve = function() {
             createProdServer(options)
           ];
         case 2:
-          return app = _state.sent(), server = createServer(toNodeListener(app)), [
+          return app = _state.sent(), [
             4,
             new Promise(function(res) {
               return setTimeout(res, 1);
             })
           ];
         case 3:
-          return _state.sent(), server.listen(options.port, options.host), console.info("Listening on http://".concat(options.host, ":").concat(options.port)), [
+          return _state.sent(), server = honoServe({
+            fetch: app.fetch,
+            port: options.port,
+            hostname: options.host
+          }), console.info("Listening on http://".concat(options.host, ":").concat(options.port)), [
             4,
             new Promise(function(res) {
               server.on("close", function() {

package/dist/esm/exports/serve.native.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../../src/exports/Users/n8/vxrn/packages/vxrn/src/exports/serve.ts"],
-  "mappings": "AAAA,SAASA,sBAAsB;AAC/B,SAASC,oBAAoB;AAE7B,SAASC,wBAAwB;AACjC,SAASC,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE1B,IAAMC,QAAAA,WAAAA;aAAQ,oBAAA,SAAOC,WAAAA;QACpBC,SACAC,KACAC;;;;AAFU,iBAAA;;YAAML,iBAAiBE,WAAW;cAAEI,MAAM;YAAO,CAAA;;;AAA3DH,2BAAU,OAAA,KAAA,GACJ;;YAAMJ,iBAAiBI,OAAAA;;;AAA7BC,uBAAM,OAAA,KAAA,GACNC,SAASP,aAAaD,eAAeO,GAAAA,CAAAA,GAE3C;;YAAM,IAAIG,QAAQ,SAACC,KAAAA;qBAAQC,WAAWD,KAAK,CAAA;;;;AAA3C,wBAAA,KAAA,GACAH,OAAOK,OAAOP,QAAQQ,MAAMR,QAAQS,IAAI,GACxCC,QAAQC,KAAM,uBAAsCX,OAAhBA,QAAQS,MAAK,GAAA,EAAgB,OAAbT,QAAQQ,IAAI,CAAA,GAChE;;YAAM,IAAIJ,QAAc,SAACC,KAAAA;AACvBH,qBAAOU,GAAG,SAAS,WAAA;AACjBP,oBAAAA;cACF,CAAA;YACF,CAAA;;;AAJA,wBAAA,KAAA;;;;;EAKF,CAAA;kBAb4BN,WAAAA;;;;",
-  "names": ["toNodeListener", "createServer", "createProdServer", "getOptionsFilled", "serve", "optionsIn", "options", "app", "server", "mode", "Promise", "res", "setTimeout", "listen", "port", "host", "console", "info", "on"]
+  "mappings": "AAAA,SAASA,SAASC,iBAAiB;AAGnC,SAASC,wBAAwB;AACjC,SAASC,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE1B,IAAMH,QAAAA,WAAAA;aAAQ,oBAAA,SAAOI,WAAAA;QACpBC,SACAC,KAGAC;;;;AAJU,iBAAA;;YAAMJ,iBAAiBC,WAAW;cAAEI,MAAM;YAAO,CAAA;;;AAA3DH,2BAAU,OAAA,KAAA,GACJ;;YAAMH,iBAAiBG,OAAAA;;;AAA7BC,uBAAM,OAAA,KAAA,GAEZ;;YAAM,IAAIG,QAAQ,SAACC,KAAAA;qBAAQC,WAAWD,KAAK,CAAA;;;;AAA3C,wBAAA,KAAA,GACMH,SAASN,UAAU;YACvBW,OAAON,IAAIM;YACXC,MAAMR,QAAQQ;YACdC,UAAUT,QAAQU;UACpB,CAAA,GAEAC,QAAQC,KAAM,uBAAsCZ,OAAhBA,QAAQU,MAAK,GAAA,EAAgB,OAAbV,QAAQQ,IAAI,CAAA,GAChE;;YAAM,IAAIJ,QAAc,SAACC,KAAAA;AACvBH,qBAAOW,GAAG,SAAS,WAAA;AACjBR,oBAAAA;cACF,CAAA;YACF,CAAA;;;AAJA,wBAAA,KAAA;;;;;EAKF,CAAA;kBAjB4BN,WAAAA;;;;",
+  "names": ["serve", "honoServe", "createProdServer", "getOptionsFilled", "optionsIn", "options", "app", "server", "mode", "Promise", "res", "setTimeout", "fetch", "port", "hostname", "host", "console", "info", "on"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vxrn",
-  "version": "0.1.63",
+  "version": "0.1.64",
   "source": "src/index.ts",
   "types": "./types/index.d.ts",
   "type": "module",
@@ -32,14 +32,15 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.21.4",
+    "@hono/node-server": "^1.11.1",
     "@vitejs/plugin-react": "^4.2.1",
     "@vitejs/plugin-react-swc": "^3.6.0",
-    "@vxrn/react-native-prebuilt": "0.1.63",
-    "@vxrn/safe-area": "0.1.63",
-    "@vxrn/vite-flow": "0.1.63",
-    "@vxrn/vite-native-client": "0.1.63",
-    "@vxrn/vite-native-hmr": "0.1.63",
-    "@vxrn/vite-native-swc": "0.1.63",
+    "@vxrn/react-native-prebuilt": "0.1.64",
+    "@vxrn/safe-area": "0.1.64",
+    "@vxrn/vite-flow": "0.1.64",
+    "@vxrn/vite-native-client": "0.1.64",
+    "@vxrn/vite-native-hmr": "0.1.64",
+    "@vxrn/vite-native-swc": "0.1.64",
     "citty": "^0.1.6",
     "crossws": "^0.2.4",
     "es-module-lexer": "^1.3.0",
@@ -51,7 +52,9 @@
     "get-port-please": "^3.1.2",
     "glob": "^10.3.12",
     "h3": "^1.11.1",
+    "h3-compression": "^0.3.2",
     "h3-proxy": "^1.13.0",
+    "hono": "^4.3.10",
     "import-meta-resolve": "^4.0.0",
     "jiti": "^1.21.0",
     "metro-inspector-proxy": "^0.71.0",
@@ -66,7 +69,7 @@
     "source-map": "^0.7.3",
     "url": "^0.11.0",
     "vite": "6.0.0-alpha.11",
-    "vxs": "0.1.63",
+    "vxs": "0.1.64",
     "ws": "^8.7.0"
   },
   "devDependencies": {

package/src/exports/createServer.ts

@@ -1,41 +1,60 @@
-import { createApp, defineEventHandler } from 'h3'
-import sirv from 'sirv'
+import { Hono } from 'hono'
+import { compress } from 'hono/compress'
+// import { cache } from 'hono/cache'
+import { serveStatic } from '@hono/node-server/serve-static'
+
 import type { VXRNConfig } from '../types'
 
 export const createProdServer = async (options: VXRNConfig) => {
-  const app = createApp()
-
-  const sirvStaticMiddleware = sirv('dist/static', {
-    gzip: true,
-  })
+  const app = new Hono()
 
-  if (options.serve) {
-    options.serve(options, app)
-  }
+  app.use(compress())
 
   app.use(
-    defineEventHandler(async ({ node: { req, res } }) => {
-      await new Promise<void>((response) => {
-        sirvStaticMiddleware(req, res, () => {
-          response()
-        })
-      })
+    '*',
+    serveStatic({
+      root: './dist/client',
     })
   )
 
-  const sirvMiddleware = sirv('dist/client', {
-    gzip: true,
-  })
+  // app.get(
+  //   '*',
+  //   cache({
+  //     cacheName: 'my-app',
+  //     cacheControl: 'max-age=3600',
+  //   })
+  // )
 
-  app.use(
-    defineEventHandler(async ({ node: { req, res } }) => {
-      await new Promise<void>((response) => {
-        sirvMiddleware(req, res, () => {
-          response()
-        })
-      })
-    })
-  )
+  if (options.serve) {
+    options.serve(options, app)
+  }
 
   return app
 }
+
+// // testing cache
+// const caches = {}
+// function createCache(name: string) {
+//   if (caches[name]) return caches[name] as any
+//   const store = {}
+//   const cache = {
+//     async match(key: string) {
+//       console.log('matching', key)
+//       return store[key]
+//     },
+//     async put(key: string, val) {
+//       store[key] = val
+//     },
+//     async delete(key: string) {
+//       delete store[key]
+//     },
+//   }
+//   caches[name] = cache
+//   return cache
+// }
+// globalThis.caches = {
+//   ...createCache(''),
+//   async open(name: string) {
+//     return createCache(name)
+//   },
+// }

package/src/exports/serve.ts

@@ -1,5 +1,5 @@
-import { toNodeListener } from 'h3'
-import { createServer } from 'node:http'
+import { serve as honoServe } from '@hono/node-server'
+
 import type { VXRNConfig } from '../types'
 import { createProdServer } from './createServer'
 import { getOptionsFilled } from '../utils/getOptionsFilled'
@@ -7,10 +7,14 @@ import { getOptionsFilled } from '../utils/getOptionsFilled'
 export const serve = async (optionsIn: VXRNConfig) => {
   const options = await getOptionsFilled(optionsIn, { mode: 'prod' })
   const app = await createProdServer(options)
-  const server = createServer(toNodeListener(app))
   // strange prevents a cant listen on port issue
   await new Promise((res) => setTimeout(res, 1))
-  server.listen(options.port, options.host)
+  const server = honoServe({
+    fetch: app.fetch,
+    port: options.port,
+    hostname: options.host,
+  })
+  // server.listen(options.port, options.host)
   console.info(`Listening on http://${options.host}:${options.port}`)
   await new Promise<void>((res) => {
     server.on('close', () => {

package/src/types.ts

@@ -1,5 +1,5 @@
 import type { Options as FlowOptions } from '@vxrn/vite-flow'
-import type { App } from 'h3'
+import type { Hono } from 'hono'
 import type { OutputAsset, OutputChunk } from 'rollup'
 import type { InlineConfig, UserConfig } from 'vite'
 
@@ -41,7 +41,7 @@ export type VXRNConfig = {
 
   afterBuild?: (props: AfterBuildProps) => void | Promise<void>
 
-  serve?: (options: VXRNConfig, app: App) => void
+  serve?: (options: VXRNConfig, app: Hono) => void
 }
 
 export type HMRListener = (update: { file: string; contents: string }) => void

package/types/exports/createServer.d.ts

@@ -1,3 +1,4 @@
+import { Hono } from 'hono';
 import type { VXRNConfig } from '../types';
-export declare const createProdServer: (options: VXRNConfig) => Promise<import("h3").App>;
+export declare const createProdServer: (options: VXRNConfig) => Promise<Hono<import("hono").Env, import("hono/types").BlankSchema, "/">>;
 //# sourceMappingURL=createServer.d.ts.map

package/types/types.d.ts

@@ -1,5 +1,5 @@
 import type { Options as FlowOptions } from '@vxrn/vite-flow';
-import type { App } from 'h3';
+import type { Hono } from 'hono';
 import type { OutputAsset, OutputChunk } from 'rollup';
 import type { InlineConfig, UserConfig } from 'vite';
 export type AfterBuildProps = {
@@ -36,7 +36,7 @@ export type VXRNConfig = {
     nativeConfig?: InlineConfig;
     flow?: FlowOptions;
     afterBuild?: (props: AfterBuildProps) => void | Promise<void>;
-    serve?: (options: VXRNConfig, app: App) => void;
+    serve?: (options: VXRNConfig, app: Hono) => void;
 };
 export type HMRListener = (update: {
     file: string;

package/types/utils/getOptionsFilled.d.ts

@@ -20,7 +20,7 @@ export declare function getOptionsFilled(options: VXRNConfig, internal?: {
     nativeConfig?: import("vite").InlineConfig | undefined;
     flow?: import("@vxrn/vite-flow").Options | undefined;
     afterBuild?: ((props: import("..").AfterBuildProps) => void | Promise<void>) | undefined;
-    serve?: ((options: VXRNConfig, app: import("h3").App) => void) | undefined;
+    serve?: ((options: VXRNConfig, app: import("hono").Hono<import("hono").Env, import("hono/types").BlankSchema, "/">) => void) | undefined;
 }>;
 type State = {
     applyPatches?: boolean;