miqro 6.3.0 → 7.0.1

package/build/esm/src/inflate/inflate-sea.js

@@ -24,7 +24,7 @@ export async function inflateSeaAssets(logger, inflateDir) {
         writeFile(logger, resolve(inflateDir, "sea", "esbuild"), esbuildBinaryBuffer);
         chmodSync(resolve(inflateDir, "sea", "esbuild"), constants.S_IXUSR | constants.S_IRUSR | constants.S_IWUSR);
     }
-    writeFile(logger, resolve(inflateDir, "sea", "postject.cjs"), Buffer.from(Buffer.from(getAsset("postject.base64.cjs")).toString(), "base64"));
+    // writeFile(logger, resolve(inflateDir, "sea", "postject.cjs"), Buffer.from(Buffer.from(getAsset("postject.base64.cjs")).toString(), "base64"));
     writeFile(logger, resolve(inflateDir, "sea", "config.json"), Buffer.from(getAsset("sea.basic.config.json")));
     writeFile(logger, resolve(inflateDir, "sea", "run.sh"), Buffer.from(getAsset("app.sh")));
     writeFile(logger, resolve(inflateDir, "sea", "node.sh"), Buffer.from(getAsset("node.sh")));
@@ -38,16 +38,16 @@ export async function inflateAppForSea(logger, inflateDir, services, port) {
     inflateSeaAssets(logger, inflateDir);
     writeFile(logger, resolve(inflateDir, "sea", "lib.cjs"), Buffer.from(getAsset("lib.cjs")));
     const WSLIST = services.filter(service => getWSConfigPath(resolve(cwd(), service))).map(service => {
-        return `(await import("../${service}/ws.cjs")).default`;
+        return `(await require("../${service}/ws.cjs")).default`;
     }).join(",");
     const SERVERCONFIGLIST = services.filter(service => getServerConfigPath(resolve(cwd(), service))).map(service => {
-        return `(await import("../${service}/server.cjs")).default`;
+        return `(await require("../${service}/server.cjs")).default`;
     }).join(",\n");
     const DBCONFIGLIST = services.filter(service => getDBConfigPath(resolve(cwd(), service))).map(service => {
         return `new Promise(async (resolve, reject) => {
     try {
-      const db = await dbManager.setupDB((await import("../${service}/db.cjs")).default);
-      await (await import("./${service}/migration-up.js")).runMigrations(db);
+      const db = await dbManager.setupDB((await require("../${service}/db.cjs")).default);
+      await (await require("./${service}/migration-up.cjs")).runMigrations(db);
       resolve();
     } catch(e) {
       reject(e);
@@ -56,7 +56,7 @@ export async function inflateAppForSea(logger, inflateDir, services, port) {
   })`;
     }).join(",");
     writeFile(logger, join(inflateDir, "sea", "package.json"), `{ "type": "module", "private": true }`);
-    writeFile(logger, join(inflateDir, "sea", "app.cjs"), `const { createServerInterface, ServerRequestHandler, WebSocketManager, initGlobals, DBManager, App, LoggerHandler, LogProvider, LocalCache, ClusterCache } = require("./lib.cjs");
+    writeFile(logger, join(inflateDir, "sea", "app.cjs"), `const { createServerInterface, ServerRequestHandler, WebSocketManager, DBManager, App, LoggerHandler, LogProvider, LocalCache, ClusterCache } = require("./lib.cjs");
 
 async function main() {
   const PORT = "${PORT}"; 
@@ -65,7 +65,6 @@ async function main() {
   const cache = new ClusterCache();
   const webSocketManager = new WebSocketManager();
   const dbManager = new DBManager();
-  await initGlobals();
   const serverInterface = createServerInterface({
     cache,
     localCache,
@@ -85,7 +84,7 @@ async function main() {
   ${SERVERCONFIGLIST ? `\n  await Promise.all([${SERVERCONFIGLIST}].filter(config=>config.preload).map(config=>config.preload(serverInterface)));\n` : ""}
   app.use(ServerRequestHandler(serverInterface));
   app.use(LoggerHandler());
-  ${services.map(service => `app.use(await (await import("./${join(service, "router.js")}")).setupRouter());`).join("\n")}
+  ${services.map(service => `app.use(await (await require("./${join(service, "router.cjs")}")).setupRouter());`).join("\n")}
   ${SERVERCONFIGLIST ? `\n  await Promise.all([${SERVERCONFIGLIST}].filter(config=>config.load).map(config=>config.load(serverInterface)));\n` : ""}
   
   await app.listen(PORT);
@@ -112,20 +111,20 @@ main().catch(e=>console.error(e));
 export async function inflateServiceForSea(logger, inflateDir, service, servicePath /*, serviceMigrations: string[]*/, serviceRouteFileMap, serviceStaticFileMap) {
     const migrationsFolderPath = getMigrationsPath(servicePath);
     const serviceMigrations = migrationsFolderPath ? migration.getSortedMigrations(migrationsFolderPath) : [];
-    writeFile(logger, join(inflateDir, "sea", service, "router.js"), `import { appendAPIModule, Router } from "./../lib.cjs";\n
-export async function setupRouter() {
+    writeFile(logger, join(inflateDir, "sea", service, "router.cjs"), `const { appendAPIModule, Router, middleware } = require("./../lib.cjs");\n
+async function setupRouter() {
   const router = new Router();
 ${getErrorConfigPath(servicePath) ? `
-  const errorConfig = (await import("../../${service}/catch.cjs")).default.default;
+  const errorConfig = (await require("../../${service}/catch.cjs")).default;
   if(errorConfig && errorConfig.catch) {
     for(const m of errorConfig.catch) {
       router.catch(m);
     }
   }` : ""}
-${getCORSConfigPath(servicePath) ? `  router.use(server.middleware.cors((await import("../../${service}/cors.cjs")).default.default));` : ""}
-${getAuthConfigPath(servicePath) ? `  router.use(server.middleware.session((await import("../../${service}/auth.cjs")).default.default));` : ""}
+${getCORSConfigPath(servicePath) ? `  router.use(middleware.cors((await require("../../${service}/cors.cjs")).default));` : ""}
+${getAuthConfigPath(servicePath) ? `  router.use(middleware.session((await require("../../${service}/auth.cjs")).default));` : ""}
 ${getMiddlewareConfigPath(servicePath) ? `
-  const middlewareConfig = (await import("../../${service}/middleware.cjs")).default.default;
+  const middlewareConfig = (await require("../../${service}/middleware.cjs")).default;
   if(middlewareConfig && middlewareConfig.middleware) {
     for(const m of middlewareConfig.middleware) {
       router.use(m);
@@ -139,14 +138,14 @@ ${Object.keys(serviceRouteFileMap)
         if (rPath) {
             const rPathExt = extname(rPath);
             const apiInflatedPath = join("..", "..", rPath.substring(0, rPath.length - rPathExt.length) + ".cjs");
-            return `  await appendAPIModule(router, "../../${service}/http", "./${apiInflatedPath}", (await import("./${apiInflatedPath}")).default.default);`;
+            return `  await appendAPIModule(router, "../../${service}/http", "./${apiInflatedPath}", (await require("./${apiInflatedPath}")).default);`;
         }
         else {
             return "";
         }
     }).filter(l => l)[0])
         .join("\n")}
-  router.use(await (await import("./static-router.js")).setupRouter())
+  router.use(await (await require("./static-router.cjs")).setupRouter())
 
 ${getMiddlewareConfigPath(servicePath) ? `
   if(middlewareConfig && middlewareConfig.post) {
@@ -156,29 +155,38 @@ ${getMiddlewareConfigPath(servicePath) ? `
   }` : ""}
       
   return router;
+}
+module.exports = {
+  setupRouter
 }`);
-    writeFile(logger, join(inflateDir, "sea", service, "migration-up.js"), `import { migration } from "./../lib.cjs";\n
-export async function runMigrations(db) {
+    writeFile(logger, join(inflateDir, "sea", service, "migration-up.cjs"), `const { migration } = require("./../lib.cjs");\n
+async function runMigrations(db) {
   await migration.init(db);
 ${serviceMigrations.map(file => {
         const name = `${file.substring(0, file.length - extname(file).length)}`;
-        return `  await migration.up.module(db, "${file}", (await import("../../${service}/migration/${name}.cjs")).default.default)`;
+        return `  await migration.up.module(db, "${file}", (await require("../../${service}/migration/${name}.cjs")).default)`;
     }).join("\n")}
+}
+module.exports = {
+  runMigrations
 }`);
-    writeFile(logger, join(inflateDir, "sea", service, "migration-down.js"), `import { migration } from "./../lib.cjs";\n
-export async function runMigrations(db) {
+    writeFile(logger, join(inflateDir, "sea", service, "migration-down.cjs"), `const { migration } = require("./../lib.cjs");\n
+async function runMigrations(db) {
   await migration.init(db);
 ${serviceMigrations.reverse().map(file => {
         const name = `${file.substring(0, file.length - extname(file).length)}`;
-        return `  await migration.down.module(db, "${file}", (await import("../../${service}/migration/${name}.cjs")).default.default)`;
+        return `  await migration.down.module(db, "${file}", (await require("../../${service}/migration/${name}.cjs")).default)`;
     }).join("\n")}
+}
+module.exports = {
+  runMigrations
 }`);
     const staticFiles = Object.keys(serviceStaticFileMap);
     /*if (staticFiles.length !== 0) {
       writeFile(logger, join(inflateDir, "sea", service, "static.base64.json"), JSON.stringify(serviceStaticFileMap));
     }*/
-    writeFile(logger, join(inflateDir, "sea", service, "static-router.js"), `import { appendAPIModule, Router } from "./../lib.cjs";\n
-export async function setupRouter() {
+    writeFile(logger, join(inflateDir, "sea", service, "static-router.cjs"), `const { appendAPIModule, Router } = require("./../lib.cjs");\n
+async function setupRouter() {
   const router = new Router();
   ${staticFiles.length === 0 ? "" : `
 ${staticFiles.map((filePath) => {
@@ -194,6 +202,9 @@ ${staticFiles.map((filePath) => {
     }).join("\n")}
 `}
   return router;
+}
+module.exports = {
+  setupRouter
 }`);
 }
 function writeFile(logger, path, buffer) {

package/build/esm/src/inflate/inflate.js

@@ -2,7 +2,7 @@ import { Router } from "@miqro/core";
 import { setupHTTPRouter } from "./setup-http.js";
 //import { WSMapConfig } from "./utils/websocketmanager.js";
 //import { ServerConfigMap, setupServerConfig } from "./setup-server-config.js";
-import { assertGlobalTampered } from "../services/globals.js";
+// import { assertGlobalTampered } from "../services/globals.js";
 import { getServicePath } from "../common/paths.js";
 import { inflateWSConfig } from "./setup-ws.js";
 import { inflateAppForSea, inflateServiceForSea } from "./inflate-sea.js";
@@ -17,7 +17,7 @@ export async function inflateApp({ inflateParallel, serverInterface, logger, hot
     const router = new Router();
     const logConfigMap = {};
     //const serverConfigMap: ServerConfigMap = {};
-    router.use(assertGlobalTampered);
+    // router.use(assertGlobalTampered);
     /*if (editor) {
       logger.info("setting up editor on %s", BASEEDITOR_PATH);
       const editorRouter = await createEditorRouter();
@@ -48,7 +48,7 @@ export async function inflateApp({ inflateParallel, serverInterface, logger, hot
             ...routeFileMap,
             ...serviceRouteFileMap
         };
-        await setupDoc(logger, servicePath, service, router, routeFileMap, inflateDir, errors);
+        await setupDoc(logger, servicePath, service, router, routeFileMap, serviceStaticFileMap, inflateDir, errors);
         await inflateWSConfig(logger, servicePath, service, wsConfigList, inflateSea ? inflateDir : undefined, errors);
         //await setupServerConfig(logger, servicePath, service, serverConfigMap, inflateSea ? inflateDir : undefined, errors);
         if (inflateDir && inflateSea) {
@@ -61,6 +61,6 @@ export async function inflateApp({ inflateParallel, serverInterface, logger, hot
     if (inflateDir && inflateSea) {
         await inflateAppForSea(logger, inflateDir, services, port);
     }
-    router.use(assertGlobalTampered);
+    // router.use(assertGlobalTampered);
     return errors.length === 0 ? [router, null, routeFileMap /*, migrations*/, wsConfigList /*, serverConfigMap*/, logConfigMap] : [router, errors, routeFileMap /*, migrations*/, wsConfigList /*, serverConfigMap*/, logConfigMap];
 }

package/build/esm/src/inflate/setup-auth.js

@@ -18,7 +18,7 @@ export async function setupAUTH(logger, servicePath, service, mainRouter, inflat
                 });
                 logger.log("writing [%s]", relative(cwd(), inflatePath));
                 writeFileSync(inflatePath, await inflateJSX(authPath, {
-                    embemedJSX: false,
+                    // embemedJSX: false,
                     minify: false,
                     useExport: true,
                     platform: "node",

package/build/esm/src/inflate/setup-cors.js

@@ -18,7 +18,7 @@ export async function setupCORS(logger, servicePath, service, mainRouter, inflat
                 });
                 logger.log("writing [%s]", relative(cwd(), inflatePath));
                 writeFileSync(inflatePath, await inflateJSX(corsPath, {
-                    embemedJSX: false,
+                    // embemedJSX: false,
                     minify: false,
                     useExport: true,
                     platform: "node",

package/build/esm/src/inflate/setup-db.js

@@ -28,7 +28,7 @@ export async function inflateDBConfig(logger, service, dbConfigList, inflateDir,
                     });
                     logger.log("writing [%s]", relative(cwd(), inflatePath));
                     writeFileSync(inflatePath, await inflateJSX(dbConfigPath, {
-                        embemedJSX: false,
+                        // embemedJSX: false,
                         minify: false,
                         useExport: true,
                         platform: "node",
@@ -76,7 +76,7 @@ export async function inflateDBMigrations(logger, service, dbName, inflateDir, e
                     });
                     logger?.log("writing [%s]", relative(cwd(), inflatePath));
                     writeFileSync(inflatePath, await inflateJSX(resolve(migrationsFolderPath, migrationName), {
-                        embemedJSX: false,
+                        // embemedJSX: false,
                         minify: false,
                         useExport: true,
                         platform: "node",

package/build/esm/src/inflate/setup-error.js

@@ -21,7 +21,7 @@ export async function setupError(logger, servicePath, service, mainRouter, infla
                 });
                 logger.log("writing [%s]", relative(cwd(), inflatePath));
                 writeFileSync(inflatePath, await inflateJSX(errorPath, {
-                    embemedJSX: false,
+                    // embemedJSX: false,
                     minify: false,
                     useExport: true,
                     platform: "node",

package/build/esm/src/inflate/setup-http.js

@@ -6,7 +6,7 @@ import { importHTMLModule, importAPIRoute, inflateJSX, importJSONModule, jsx2HTM
 import { createNodeRuntime } from "@miqro/jsx-node";
 import { getHotReloadScript } from "../services/hot-reload.js";
 import { cwd } from "node:process";
-import { assertGlobalTampered } from "../services/globals.js";
+// import { assertGlobalTampered } from "../services/globals.js";
 import { getHTTPRouterPath, getStaticFilesPath } from "../common/paths.js";
 import { setupCORS } from "./setup-cors.js";
 import { setupAUTH } from "./setup-auth.js";
@@ -84,7 +84,7 @@ async function createStaticRoute(service, logger, router, dir, file, inflateDir,
                     };
                 }
             }
-            router.use(assertGlobalTampered);
+            // router.use(assertGlobalTampered);
             router.get(path, async function (_req, res) {
                 await new Promise((resolve, reject) => {
                     try {
@@ -145,7 +145,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
     const maxParallel = inflateParallel ? inflateParallel : 1;
     server.logger.debug("loading http directory with parallel [%s]", maxParallel);
     let tR = [];
-    router.use(assertGlobalTampered);
+    // router.use(assertGlobalTampered);
     const files = scanFiles(dir);
     for (const file of files) {
         tR.push(new Promise(async (resolve) => {
@@ -172,7 +172,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                     previewMethod: "api"
                                 };
                                 const inflatedCode = inflateDir ? await inflateJSX(file.filePath, {
-                                    embemedJSX: false,
+                                    // embemedJSX: false,
                                     minify: false,
                                     useExport: true,
                                     platform: "node",
@@ -197,7 +197,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                         logger.log("writing [%s]", relative(cwd(), inflatePath));
                                         await writeFileASync(inflatePath, inflatedCode);
                                     }
-                                    router.use(assertGlobalTampered);
+                                    // router.use(assertGlobalTampered);
                                     router.use(module.handler, r.path, r.method, r.options);
                                 }
                                 return resolve();
@@ -243,7 +243,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                             }
                                         }
                                     }
-                                    router.use(assertGlobalTampered);
+                                    // router.use(assertGlobalTampered);
                                     router.use(async function (req, res) {
                                         const JSON = await getJSON(req, res, newURL(req.path), module.apiOptions?.basePath, module.default);
                                         return res.asyncEnd({
@@ -298,7 +298,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                             }
                                         }
                                     }
-                                    router.use(assertGlobalTampered);
+                                    // router.use(assertGlobalTampered);
                                     router.use(async function (req, res) {
                                         const toRender = typeof module.default === "function" ? module.default(req, res) : module.default;
                                         const HTML = await getHTML(hotreload, req, res, newURL(req.path), module.apiOptions?.basePath, await toRender);
@@ -319,9 +319,9 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                 // allow fall-through when extension is .js and .ts because is a static route without embemedJSX
                                 if (file.ext !== ".js" && file.ext !== ".ts") {
                                     const code = await inflateJSX(file.filePath, {
-                                        embemedJSX: true,
+                                        // embemedJSX: true,
                                         minify: file.subExt === ".min" ? true : false,
-                                        useExport: false,
+                                        useExport: true,
                                         logger
                                     });
                                     const contentType = CONTENT_TYPE_MAP[".js"];
@@ -354,7 +354,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                             };
                                         }
                                     }
-                                    router.use(assertGlobalTampered);
+                                    // router.use(assertGlobalTampered);
                                     router.get(path, async function (req, res) {
                                         return res.asyncEnd({
                                             status: 200,
@@ -403,7 +403,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                         };
                                     }
                                 }
-                                router.use(assertGlobalTampered);
+                                // router.use(assertGlobalTampered);
                                 router.get(path, async function (_req, res) {
                                     res.asyncEnd({
                                         status: 200,
@@ -427,9 +427,9 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                 case ".bundle":
                                 case ".min": {
                                     const code = await inflateJSX(file.filePath, {
-                                        embemedJSX: false,
+                                        // embemedJSX: false,
                                         minify: file.subExt === ".min" ? true : false,
-                                        useExport: false,
+                                        useExport: true,
                                         logger
                                     });
                                     const contentType = CONTENT_TYPE_MAP[".js"];
@@ -462,7 +462,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                             };
                                         }
                                     }
-                                    router.use(assertGlobalTampered);
+                                    // router.use(assertGlobalTampered);
                                     router.get(path, async function (_req, res) {
                                         res.asyncEnd({
                                             status: 200,
@@ -519,7 +519,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
                                             };
                                         }
                                     }
-                                    router.use(assertGlobalTampered);
+                                    // router.use(assertGlobalTampered);
                                     router.get(path, async function (_req, res) {
                                         res.asyncEnd({
                                             status: 200,
@@ -558,7 +558,7 @@ async function createRouterFromDirectory(server, hotreload, service, logger, dir
         await Promise.all(tR);
         tR = [];
     }
-    router.use(assertGlobalTampered);
+    // router.use(assertGlobalTampered);
     return {
         routeFileMap,
         router,

package/build/esm/src/inflate/setup-log.js

@@ -17,7 +17,7 @@ export async function setupLogConfig(logger, servicePath, service, logConfigMap,
                 });
                 logger.log("writing [%s]", relative(cwd(), inflatePath));
                 writeFileSync(inflatePath, await inflateJSX(logPath, {
-                    embemedJSX: false,
+                    // embemedJSX: false,
                     minify: false,
                     useExport: true,
                     platform: "node",

package/build/esm/src/inflate/setup-middleware.js

@@ -21,7 +21,7 @@ export async function setupMiddleware(logger, servicePath, service, mainRouter,
                 });
                 logger.log("writing [%s]", relative(cwd(), inflatePath));
                 writeFileSync(inflatePath, await inflateJSX(middlewarePath, {
-                    embemedJSX: false,
+                    // embemedJSX: false,
                     minify: false,
                     platform: "node",
                     useExport: true,

package/build/esm/src/inflate/setup-server-config.js

@@ -17,7 +17,7 @@ export async function setupServerConfig(logger, servicePath, service, serverConf
                 });
                 logger.log("writing [%s]", relative(cwd(), inflatePath));
                 writeFileSync(inflatePath, await inflateJSX(serverPath, {
-                    embemedJSX: false,
+                    // embemedJSX: false,
                     minify: false,
                     platform: "node",
                     useExport: true,

package/build/esm/src/inflate/setup-ws.js

@@ -24,7 +24,7 @@ export async function inflateWSConfig(logger, servicePath, service, wsConfigList
                 });
                 logger.log("writing [%s]", relative(cwd(), inflatePath));
                 writeFileSync(inflatePath, await inflateJSX(wsPath, {
-                    embemedJSX: false,
+                    // embemedJSX: false,
                     minify: false,
                     platform: "node",
                     useExport: true,

package/build/esm/src/inflate/setup.doc.d.ts

@@ -1,4 +1,4 @@
 import { Logger, Router } from "@miqro/core";
 import { InflateError } from "../common/jsx.js";
-import { RouteFileMap } from "./setup-http.js";
-export declare function setupDoc(logger: Logger, servicePath: string, service: string, mainRouter: Router, fileMap: RouteFileMap, inflateDir: string | undefined | false, errors: InflateError[]): Promise<any>;
+import { RouteFileMap, StaticFileMap } from "./setup-http.js";
+export declare function setupDoc(logger: Logger, servicePath: string, service: string, mainRouter: Router, fileMap: RouteFileMap, staticFileMap: StaticFileMap, inflateDir: string | undefined | false, errors: InflateError[]): Promise<any>;

package/build/esm/src/inflate/setup.doc.js

@@ -5,7 +5,7 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { cwd } from "node:process";
 import { getDocOutput } from "../bin/generate-doc.js";
 import { CONTENT_TYPE_MAP } from "../common/content-type.js";
-export async function setupDoc(logger, servicePath, service, mainRouter, fileMap, inflateDir, errors) {
+export async function setupDoc(logger, servicePath, service, mainRouter, fileMap, staticFileMap, inflateDir, errors) {
     const docPath = getDocConfigPath(servicePath); //resolve(process.cwd(), service, "auth.ts");
     if (docPath) {
         try {
@@ -15,11 +15,12 @@ export async function setupDoc(logger, servicePath, service, mainRouter, fileMap
                 const paths = Object.keys(docModule.publish);
                 for (const path of paths) {
                     const config = docModule.publish[path];
+                    const contentType = config.type === "MD" ? CONTENT_TYPE_MAP[".md"] :
+                        config.type === "JSON" ? CONTENT_TYPE_MAP[".json"] : CONTENT_TYPE_MAP[".html"];
                     const body = await getDocOutput(mainRouter, fileMap, config.all, config.type);
                     mainRouter.get(path, async (_, res) => {
                         switch (config.type) {
                             case "MD": {
-                                const contentType = CONTENT_TYPE_MAP[".md"];
                                 return await res.asyncEnd({
                                     headers: {
                                         "content-type": contentType
@@ -45,6 +46,26 @@ export async function setupDoc(logger, servicePath, service, mainRouter, fileMap
                         });
                         logger.log("writing [%s]", relative(cwd(), inflatePath));
                         writeFileSync(inflatePath, body);
+                        fileMap[docPath + path] = {
+                            routes: [{
+                                    method: "GET",
+                                    path
+                                }],
+                            service,
+                            filePath: docPath,
+                            previewMethod: "html"
+                        };
+                        if (staticFileMap) {
+                            staticFileMap[docPath + path] = {
+                                contentType,
+                                filePath: docPath,
+                                previewMethod: "html",
+                                method: "GET",
+                                path,
+                                body: Buffer.from(body),
+                                inflatePath: inflateDir ? join(inflateDir, service, "static", path) : undefined
+                            };
+                        }
                     }
                 }
             }

package/build/esm/src/inflate/utils/sea-utils.js

@@ -1,12 +1,12 @@
 import { describeFilePath } from "../../common/fs.js";
 import { getRoutes } from "../../services/utils/get-route.js";
-import { assertGlobalTampered } from "../../services/globals.js";
+// import { assertGlobalTampered } from "../../services/globals.js";
 import { dirname, join, relative } from "node:path";
 export async function appendAPIModule(router, dir, filePath, module) {
     const file = describeFilePath(filePath);
     const routes = getRoutes(join("/", dirname(relative(dir, file.filePath))), file.subName, module);
     for (const r of routes) {
-        router.use(assertGlobalTampered);
+        // router.use(assertGlobalTampered);
         router.use(module.handler, r.path, r.method, r.options);
     }
 }

package/build/esm/src/lib.d.ts

@@ -1,3 +1,4 @@
+import { Component, enableDebugLog, Fragment, Props } from "@miqro/jsx";
 export * from "./types.js";
 export { ClusterWebSocketServer2 } from "./services/utils/cluster-ws.js";
 export { ClusterCache } from "./services/utils/cluster-cache.js";
@@ -6,8 +7,16 @@ export { WebSocketManager, WebSocketManagerOptions } from "./services/utils/webs
 export { DBManager } from "./services/utils/db-manager.js";
 export { LogProvider, LogProviderOptions } from "./services/utils/log.js";
 export { Miqro, MiqroOptions, ServerRequestHandler } from "./services/app.js";
-export { initGlobals, assertGlobalTampered } from "./services/globals.js";
+export { jsx2HTML } from "./common/jsx.js";
 export { appendAPIModule } from "./inflate/utils/sea-utils.js";
 export { createServerInterface, ServerInterfaceImplOptions } from "./services/utils/server-interface.js";
 export { App, LoggerHandler, Router } from "@miqro/core";
 export { migration } from "@miqro/query";
+export { middleware } from "./services/utils/middleware.js";
+export { jwt } from "./services/utils/jwt.js";
+export declare const JSX: {
+    createElement: (tag: string | Component<any> | typeof Fragment, attributes: Props<any>, ...children: any[]) => JSX.Element;
+    Fragment: symbol;
+    enableDebugLog: typeof enableDebugLog;
+};
+export * as jsx from "@miqro/jsx";

package/build/esm/src/lib.js

@@ -1,3 +1,5 @@
+import { enableDebugLog, Fragment, createElement as realCreateElement } from "@miqro/jsx";
+import { jsx2HTML } from "./common/jsx.js";
 /*export * from "@miqro/core";
 export * from "@miqro/query";*/
 export * from "./types.js";
@@ -8,9 +10,22 @@ export { WebSocketManager } from "./services/utils/websocketmanager.js";
 export { DBManager } from "./services/utils/db-manager.js";
 export { LogProvider } from "./services/utils/log.js";
 export { Miqro, ServerRequestHandler } from "./services/app.js";
-export { initGlobals, assertGlobalTampered } from "./services/globals.js";
+// export { initGlobals, assertGlobalTampered } from "./services/globals.js";
+export { jsx2HTML } from "./common/jsx.js";
 //exported for --inflate-sea
 export { appendAPIModule } from "./inflate/utils/sea-utils.js";
 export { createServerInterface } from "./services/utils/server-interface.js";
 export { App, LoggerHandler, Router } from "@miqro/core";
 export { migration } from "@miqro/query";
+export { middleware } from "./services/utils/middleware.js";
+export { jwt } from "./services/utils/jwt.js";
+export const JSX = {
+    createElement: (...args) => {
+        const ret = realCreateElement(...args);
+        ret.toString = () => jsx2HTML(ret);
+        return ret;
+    },
+    Fragment,
+    enableDebugLog
+};
+export * as jsx from "@miqro/jsx";

package/build/esm/src/main.js

@@ -9,7 +9,7 @@ import { Miqro } from "./services/app.js";
 import { TEST_SOCKET } from "./common/paths.js";
 import { Logger } from "@miqro/core";
 async function main(args) {
-    if (args.installTypes || args.installTSConfig || args.installMiqroJSON) {
+    if (args.install || args.installTSConfig || args.installMiqroJSON) {
         await installTypings(args, new Logger(""));
         process.exit(EXIT_CODES.NORMAL_EXIT);
     }

package/build/esm/src/services/app.js

@@ -13,7 +13,6 @@ import { createEditorRouter } from "./editor.js";
 import { EDITOR_CONFIG_KEY, HOT_RELOAD_PATH } from "../common/constants.js";
 import { watchAndServer } from "../common/watch.js";
 import { LocalCache } from "./utils/cache.js";
-import { initGlobals } from "./globals.js";
 import { LogProvider } from "./utils/log.js";
 import { initAssets } from "../common/assets.js";
 import { setupExitHandlers } from "../common/exit.js";
@@ -156,7 +155,7 @@ export class Miqro {
         if (this.inflated !== null) {
             throw new Error("already inflated! call deflate()");
         }
-        initGlobals();
+        // initGlobals();
         // block others from inflating while inflateApp is running
         this.inflated = undefined;
         this.inflated = {
@@ -204,7 +203,7 @@ export class Miqro {
         // init assets only once for all ApplicationServer's
         if (Miqro.initAssetsPromise === null) {
             // init globals only once for all inflations
-            initGlobals();
+            // initGlobals();
             Miqro.initAssetsPromise = initAssets(this.logger);
         }
         await Miqro.initAssetsPromise;
@@ -253,7 +252,7 @@ export class Miqro {
             // init assets only once for all ApplicationServer's
             if (Miqro.initAssetsPromise === null) {
                 // init globals only once for all inflations
-                initGlobals();
+                // initGlobals();
                 Miqro.initAssetsPromise = initAssets(this.logger);
             }
             await Miqro.initAssetsPromise;

package/build/esm/src/services/migrations.js

@@ -21,7 +21,7 @@ export async function runMigrations(logger, db, servicePath, service, inflateDir
                 });
                 logger?.log("writing [%s]", relative(cwd(), inflatePath));
                 writeFileSync(inflatePath, await inflateJSX(resolve(migrationsFolderPath, migration), {
-                    embemedJSX: false,
+                    // embemedJSX: false,
                     minify: false,
                     useExport: true,
                     platform: "node",
@@ -49,7 +49,7 @@ export async function runMigrationsDown(logger, db, servicePath, service, inflat
                 });
                 logger?.log("writing [%s]", relative(cwd(), inflatePath));
                 writeFileSync(inflatePath, await inflateJSX(resolve(migrationsFolderPath, migration), {
-                    embemedJSX: false,
+                    // embemedJSX: false,
                     platform: "node",
                     minify: false,
                     useExport: true,

package/build/esm/src/services/utils/jwt.d.ts

@@ -0,0 +1,2 @@
+import { JWTInterface } from "../../types.js";
+export declare const jwt: JWTInterface;

package/build/esm/src/services/utils/jwt.js

@@ -0,0 +1,23 @@
+import { decodeJWT, decodeProtectedHeaderJWT, decryptJWT, encryptJWT, signJWT, verifyJWT } from "../../common/jwt.js";
+import { createSecretKey } from "node:crypto";
+export const jwt = {
+    createSecretKey,
+    decode(jwt) {
+        return decodeJWT(jwt);
+    },
+    decodeProtectedHeader(token) {
+        return decodeProtectedHeaderJWT(token);
+    },
+    decrypt(jwt, secret, options) {
+        return decryptJWT(jwt, secret, options);
+    },
+    encrypt(payload, secret, options) {
+        return encryptJWT(payload, secret, options);
+    },
+    sign(payload, secret, options) {
+        return signJWT(payload, secret, options);
+    },
+    verify(jwt, secret, options) {
+        return verifyJWT(jwt, secret, options);
+    }
+};