hermium 0.1.3 → 0.1.4

package/bin/hermium.mjs

@@ -10,6 +10,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url))
 const pkgDir = resolve(__dirname, '..')
 const apiEntry = resolve(pkgDir, 'dist', 'server', 'index.mjs')
 const webEntry = resolve(pkgDir, 'dist', 'web-server', 'index.mjs')
+const webServerDir = resolve(pkgDir, 'dist', 'web-server')
 const WEB_UI_HOME = resolve(homedir(), '.hermium')
 const API_PID_FILE = join(WEB_UI_HOME, 'api.pid')
 const WEB_PID_FILE = join(WEB_UI_HOME, 'web.pid')
@@ -117,7 +118,7 @@ function rotateLog(file) {
   } catch {}
 }
 
-function spawnServer({ name, entry, logFile, pidFile, port, env, runtime }) {
+function spawnServer({ name, entry, logFile, pidFile, port, env, runtime, cwd }) {
   if (!existsSync(entry)) {
     console.log(pc.red(`  ✗ ${name} not found: ${entry}`))
     console.log(`    Run "hermium build" first (or check your installation)`)
@@ -131,6 +132,7 @@ function spawnServer({ name, entry, logFile, pidFile, port, env, runtime }) {
     detached: true,
     stdio: ['ignore', logFd, logFd],
     env: { ...process.env, ...env, NODE_ENV: 'production' },
+    cwd: cwd || dirname(entry),
   })
 
   child.on('error', (err) => {
@@ -219,6 +221,7 @@ async function cmdStart() {
     pidFile: WEB_PID_FILE,
     port: webPort,
     runtime,
+    cwd: webServerDir,
     env: { PORT: String(webPort) },
   })
 

package/dist/web-server/__23tanstack-start-plugin-adapters-Cwee5PKy.mjs

@@ -0,0 +1,6 @@
+const pluginSerializationAdapters = [];
+const hasPluginAdapters = false;
+export {
+  hasPluginAdapters,
+  pluginSerializationAdapters
+};

package/dist/web-server/_chunks/ssr-renderer.mjs

@@ -0,0 +1,22 @@
+import { H as HTTPError, c as toRequest } from "../_libs/h3.mjs";
+import "../_libs/rou3.mjs";
+import "../_libs/srvx.mjs";
+import "node:http";
+import "node:stream";
+import "node:stream/promises";
+import "node:https";
+import "node:http2";
+function fetchViteEnv(viteEnvName, input, init) {
+  const envs = globalThis.__nitro_vite_envs__ || {};
+  const viteEnv = envs[viteEnvName];
+  if (!viteEnv) {
+    throw HTTPError.status(404);
+  }
+  return Promise.resolve(viteEnv.fetch(toRequest(input, init)));
+}
+function ssrRenderer({ req }) {
+  return fetchViteEnv("ssr", req);
+}
+export {
+  ssrRenderer as default
+};

package/dist/web-server/_libs/babel__runtime.mjs

@@ -0,0 +1,237 @@
+import { g as getDefaultExportFromCjs } from "./react.mjs";
+var objectWithoutProperties = { exports: {} };
+var objectWithoutPropertiesLoose = { exports: {} };
+var hasRequiredObjectWithoutPropertiesLoose;
+function requireObjectWithoutPropertiesLoose() {
+  if (hasRequiredObjectWithoutPropertiesLoose) return objectWithoutPropertiesLoose.exports;
+  hasRequiredObjectWithoutPropertiesLoose = 1;
+  (function(module) {
+    function _objectWithoutPropertiesLoose(r, e) {
+      if (null == r) return {};
+      var t = {};
+      for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+        if (-1 !== e.indexOf(n)) continue;
+        t[n] = r[n];
+      }
+      return t;
+    }
+    module.exports = _objectWithoutPropertiesLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  })(objectWithoutPropertiesLoose);
+  return objectWithoutPropertiesLoose.exports;
+}
+var hasRequiredObjectWithoutProperties;
+function requireObjectWithoutProperties() {
+  if (hasRequiredObjectWithoutProperties) return objectWithoutProperties.exports;
+  hasRequiredObjectWithoutProperties = 1;
+  (function(module) {
+    var objectWithoutPropertiesLoose2 = requireObjectWithoutPropertiesLoose();
+    function _objectWithoutProperties2(e, t) {
+      if (null == e) return {};
+      var o, r, i = objectWithoutPropertiesLoose2(e, t);
+      if (Object.getOwnPropertySymbols) {
+        var n = Object.getOwnPropertySymbols(e);
+        for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+      }
+      return i;
+    }
+    module.exports = _objectWithoutProperties2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  })(objectWithoutProperties);
+  return objectWithoutProperties.exports;
+}
+var objectWithoutPropertiesExports = requireObjectWithoutProperties();
+const _objectWithoutProperties = /* @__PURE__ */ getDefaultExportFromCjs(objectWithoutPropertiesExports);
+var toConsumableArray = { exports: {} };
+var arrayWithoutHoles = { exports: {} };
+var arrayLikeToArray = { exports: {} };
+var hasRequiredArrayLikeToArray;
+function requireArrayLikeToArray() {
+  if (hasRequiredArrayLikeToArray) return arrayLikeToArray.exports;
+  hasRequiredArrayLikeToArray = 1;
+  (function(module) {
+    function _arrayLikeToArray(r, a) {
+      (null == a || a > r.length) && (a = r.length);
+      for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+      return n;
+    }
+    module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  })(arrayLikeToArray);
+  return arrayLikeToArray.exports;
+}
+var hasRequiredArrayWithoutHoles;
+function requireArrayWithoutHoles() {
+  if (hasRequiredArrayWithoutHoles) return arrayWithoutHoles.exports;
+  hasRequiredArrayWithoutHoles = 1;
+  (function(module) {
+    var arrayLikeToArray2 = requireArrayLikeToArray();
+    function _arrayWithoutHoles(r) {
+      if (Array.isArray(r)) return arrayLikeToArray2(r);
+    }
+    module.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  })(arrayWithoutHoles);
+  return arrayWithoutHoles.exports;
+}
+var iterableToArray = { exports: {} };
+var hasRequiredIterableToArray;
+function requireIterableToArray() {
+  if (hasRequiredIterableToArray) return iterableToArray.exports;
+  hasRequiredIterableToArray = 1;
+  (function(module) {
+    function _iterableToArray(r) {
+      if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+    }
+    module.exports = _iterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  })(iterableToArray);
+  return iterableToArray.exports;
+}
+var unsupportedIterableToArray = { exports: {} };
+var hasRequiredUnsupportedIterableToArray;
+function requireUnsupportedIterableToArray() {
+  if (hasRequiredUnsupportedIterableToArray) return unsupportedIterableToArray.exports;
+  hasRequiredUnsupportedIterableToArray = 1;
+  (function(module) {
+    var arrayLikeToArray2 = requireArrayLikeToArray();
+    function _unsupportedIterableToArray(r, a) {
+      if (r) {
+        if ("string" == typeof r) return arrayLikeToArray2(r, a);
+        var t = {}.toString.call(r).slice(8, -1);
+        return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray2(r, a) : void 0;
+      }
+    }
+    module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  })(unsupportedIterableToArray);
+  return unsupportedIterableToArray.exports;
+}
+var nonIterableSpread = { exports: {} };
+var hasRequiredNonIterableSpread;
+function requireNonIterableSpread() {
+  if (hasRequiredNonIterableSpread) return nonIterableSpread.exports;
+  hasRequiredNonIterableSpread = 1;
+  (function(module) {
+    function _nonIterableSpread() {
+      throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+    module.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  })(nonIterableSpread);
+  return nonIterableSpread.exports;
+}
+var hasRequiredToConsumableArray;
+function requireToConsumableArray() {
+  if (hasRequiredToConsumableArray) return toConsumableArray.exports;
+  hasRequiredToConsumableArray = 1;
+  (function(module) {
+    var arrayWithoutHoles2 = requireArrayWithoutHoles();
+    var iterableToArray2 = requireIterableToArray();
+    var unsupportedIterableToArray2 = requireUnsupportedIterableToArray();
+    var nonIterableSpread2 = requireNonIterableSpread();
+    function _toConsumableArray2(r) {
+      return arrayWithoutHoles2(r) || iterableToArray2(r) || unsupportedIterableToArray2(r) || nonIterableSpread2();
+    }
+    module.exports = _toConsumableArray2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  })(toConsumableArray);
+  return toConsumableArray.exports;
+}
+var toConsumableArrayExports = requireToConsumableArray();
+const _toConsumableArray = /* @__PURE__ */ getDefaultExportFromCjs(toConsumableArrayExports);
+var defineProperty = { exports: {} };
+var toPropertyKey = { exports: {} };
+var _typeof = { exports: {} };
+var hasRequired_typeof;
+function require_typeof() {
+  if (hasRequired_typeof) return _typeof.exports;
+  hasRequired_typeof = 1;
+  (function(module) {
+    function _typeof2(o) {
+      "@babel/helpers - typeof";
+      return module.exports = _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+        return typeof o2;
+      } : function(o2) {
+        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+      }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof2(o);
+    }
+    module.exports = _typeof2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  })(_typeof);
+  return _typeof.exports;
+}
+var toPrimitive = { exports: {} };
+var hasRequiredToPrimitive;
+function requireToPrimitive() {
+  if (hasRequiredToPrimitive) return toPrimitive.exports;
+  hasRequiredToPrimitive = 1;
+  (function(module) {
+    var _typeof2 = require_typeof()["default"];
+    function toPrimitive2(t, r) {
+      if ("object" != _typeof2(t) || !t) return t;
+      var e = t[Symbol.toPrimitive];
+      if (void 0 !== e) {
+        var i = e.call(t, r || "default");
+        if ("object" != _typeof2(i)) return i;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return ("string" === r ? String : Number)(t);
+    }
+    module.exports = toPrimitive2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  })(toPrimitive);
+  return toPrimitive.exports;
+}
+var hasRequiredToPropertyKey;
+function requireToPropertyKey() {
+  if (hasRequiredToPropertyKey) return toPropertyKey.exports;
+  hasRequiredToPropertyKey = 1;
+  (function(module) {
+    var _typeof2 = require_typeof()["default"];
+    var toPrimitive2 = requireToPrimitive();
+    function toPropertyKey2(t) {
+      var i = toPrimitive2(t, "string");
+      return "symbol" == _typeof2(i) ? i : i + "";
+    }
+    module.exports = toPropertyKey2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  })(toPropertyKey);
+  return toPropertyKey.exports;
+}
+var hasRequiredDefineProperty;
+function requireDefineProperty() {
+  if (hasRequiredDefineProperty) return defineProperty.exports;
+  hasRequiredDefineProperty = 1;
+  (function(module) {
+    var toPropertyKey2 = requireToPropertyKey();
+    function _defineProperty2(e, r, t) {
+      return (r = toPropertyKey2(r)) in e ? Object.defineProperty(e, r, {
+        value: t,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      }) : e[r] = t, e;
+    }
+    module.exports = _defineProperty2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  })(defineProperty);
+  return defineProperty.exports;
+}
+var definePropertyExports = requireDefineProperty();
+const _defineProperty = /* @__PURE__ */ getDefaultExportFromCjs(definePropertyExports);
+var _extends$1 = { exports: {} };
+var hasRequired_extends;
+function require_extends() {
+  if (hasRequired_extends) return _extends$1.exports;
+  hasRequired_extends = 1;
+  (function(module) {
+    function _extends2() {
+      return module.exports = _extends2 = Object.assign ? Object.assign.bind() : function(n) {
+        for (var e = 1; e < arguments.length; e++) {
+          var t = arguments[e];
+          for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+        }
+        return n;
+      }, module.exports.__esModule = true, module.exports["default"] = module.exports, _extends2.apply(null, arguments);
+    }
+    module.exports = _extends2, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  })(_extends$1);
+  return _extends$1.exports;
+}
+var _extendsExports = require_extends();
+const _extends = /* @__PURE__ */ getDefaultExportFromCjs(_extendsExports);
+export {
+  _extends as _,
+  _defineProperty as a,
+  _objectWithoutProperties as b,
+  _toConsumableArray as c
+};

package/dist/web-server/_libs/bail.mjs

@@ -0,0 +1,8 @@
+function bail(error) {
+  if (error) {
+    throw error;
+  }
+}
+export {
+  bail as b
+};