miqro 6.2.13 → 7.0.1

package/build/esm/src/common/jsx.js

@@ -5,99 +5,93 @@ import { Parser } from "@miqro/parser";
 import { APIRouteSchema, SessionHandlerOptionsSchema } from "@miqro/core";
 import { cwd } from "node:process";
 import { esBuild } from "./esbuild.js";
-import { assertGlobalTampered, browserJSXGlobals } from "../services/globals.js";
-import { getJSXJSPath, JSX_TMP_DIR } from "./paths.js";
+import { JSX_TMP_DIR } from "./paths.js";
 import { CLEAR_JSX_CACHE } from "./constants.js";
-import { getAsset, initAsset, validateAsset } from "./assets.js";
-import { calculateChecksumFromBuffer } from "./checksum.js";
 import { HandlerWithOptionsSchema, RouteOptionsSchema } from "@miqro/core/build/types.js";
 import { mkdirASync, rmdirASync, unlinkASync, writeFileASync } from "./fs.js";
 let jsxJSBuffer = null; // Buffer.from(getAsset("jsx.dom.js"));
 let jsxJSBufferChecksumPromise = null; // calculateChecksumFromBuffer(jsxJSBuffer);
-export async function initJSXJS(logger) {
-    jsxJSBuffer = jsxJSBuffer ? jsxJSBuffer : Buffer.from(getAsset("jsx.dom.js"));
-    jsxJSBufferChecksumPromise = jsxJSBufferChecksumPromise ? jsxJSBufferChecksumPromise : calculateChecksumFromBuffer(jsxJSBuffer);
-    return initAsset(logger, getJSXJSPath(), jsxJSBuffer, true, jsxJSBufferChecksumPromise, false);
-}
-export async function validateJSXJS(logger) {
-    const checksum = await jsxJSBufferChecksumPromise;
-    if (!checksum) {
-        throw new Error("error calculating checksum");
-    }
-    return validateAsset(logger, getJSXJSPath(), checksum);
-}
 const parser = new Parser();
 const DEFAULT_ESOPTION = {
     platform: "neutral",
+    mainFields: "module,main",
+    // platform: "node",
     bundle: true,
     jsxFactory: "JSX.createElement",
     jsxFragment: "JSX.Fragment"
 };
+function JSXTemplate(inFile /*, jsxPath: string | false = false*/, useExport = true) {
+    // const PRE = ``;
+    // return `${jsxPath ? PRE : ""}\n${useExport ? `export * from "${inFile}";import * as lib from "${inFile}";export default lib.default;` : `import * as lib from "${inFile}"`}`;
+    return `${useExport ? `export * from "${inFile}";import * as lib from "${inFile}";export default lib.default;` : `import * as lib from "${inFile}"`}`;
+}
 export async function inflateJSX(inFile, options) {
     const tmpBuildDir = resolve(JSX_TMP_DIR, String(process.pid), "build", Date.now() + "-" + randomUUID());
     const inFileTmp = resolve(tmpBuildDir, basename(inFile) + ".mjs");
-    const jsxJSPath = getJSXJSPath(); //resolve(tmpBuildDir, "jsx.js");
+    //const jsxJSPath = getJSXJSPath();//resolve(tmpBuildDir, "jsx.js");
     const logger = options.logger; //getLogger(`${SERVER_IDENTIFIER}_JSX`);
     try {
-        if (!options.embemedJSX) {
-            await mkdirASync(tmpBuildDir, {
-                recursive: true
-            });
-            await writeFileASync(inFileTmp, browserJSXGlobals(inFile, false, options.useExport));
-            //await writeFileASync(inFileTmp, browserJSXGlobals(relative(tmpBuildDir, inFile), false));
-            logger?.trace("inflating [%s] from [%s]. to change the import folder set JSX_TMP", relative(cwd(), inFile), dirname(relative(JSX_TMP_DIR, inFileTmp)));
-            const { outputFiles: [{ contents }] } = await esBuild({
-                ...DEFAULT_ESOPTION,
-                entryPoints: [inFileTmp],
-                minify: options.minify,
-                platform: options.platform ? options.platform : DEFAULT_ESOPTION.platform
-            });
-            if (CLEAR_JSX_CACHE) {
-                logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
-                await unlinkASync(inFileTmp);
-                await rmdirASync(tmpBuildDir);
-            }
-            return contents;
-        }
-        else {
-            await mkdirASync(tmpBuildDir, {
-                recursive: true
-            });
-            //await writeFileASync(jsxJSPath, Buffer.from(getAsset("jsx-dom-bundle")));
-            await writeFileASync(inFileTmp, browserJSXGlobals(inFile, jsxJSPath));
-            //await writeFileASync(inFileTmp, browserJSXGlobals(relative(tmpBuildDir, inFile), relative(tmpBuildDir, jsxJSPath)));
-            logger?.trace("inflating [%s] from [%s] with jsx.js embedded. to change the import folder set JSX_TMP", relative(cwd(), inFile), dirname(relative(JSX_TMP_DIR, inFileTmp)));
-            const { outputFiles: [{ contents }] } = await esBuild({
-                ...DEFAULT_ESOPTION,
-                entryPoints: [inFileTmp],
-                minify: options.minify,
-                platform: options.platform ? options.platform : DEFAULT_ESOPTION.platform
-            });
-            if (CLEAR_JSX_CACHE) {
-                logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
-                await unlinkASync(inFileTmp);
-                //await unlinkASync(jsxJSPath);
-                await rmdirASync(tmpBuildDir);
-            }
-            return contents;
+        // if (!options.embemedJSX) {
+        await mkdirASync(tmpBuildDir, {
+            recursive: true
+        });
+        await writeFileASync(inFileTmp, JSXTemplate(inFile /*, false*/, options.useExport));
+        //await writeFileASync(inFileTmp, browserJSXGlobals(relative(tmpBuildDir, inFile), false));
+        logger?.trace("inflating [%s] from [%s]. to change the import folder set JSX_TMP", relative(cwd(), inFile), dirname(relative(JSX_TMP_DIR, inFileTmp)));
+        const { outputFiles: [{ contents }] } = await esBuild({
+            ...DEFAULT_ESOPTION,
+            entryPoints: [inFileTmp],
+            minify: options.minify,
+            platform: options.platform !== undefined ? options.platform : DEFAULT_ESOPTION.platform,
+            mainFields: options.mainFields !== undefined ? options.mainFields : DEFAULT_ESOPTION.mainFields,
+            external: options.external ? options.external : undefined,
+        });
+        if (CLEAR_JSX_CACHE) {
+            logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+            await unlinkASync(inFileTmp);
+            await rmdirASync(tmpBuildDir);
         }
+        return contents;
+        /*} else {
+          await mkdirASync(tmpBuildDir, {
+            recursive: true
+          });
+          //await writeFileASync(jsxJSPath, Buffer.from(getAsset("jsx-dom-bundle")));
+          await writeFileASync(inFileTmp, browserJSXGlobals(inFile, false));
+          //await writeFileASync(inFileTmp, browserJSXGlobals(relative(tmpBuildDir, inFile), relative(tmpBuildDir, jsxJSPath)));
+          logger?.trace("inflating [%s] from [%s] with jsx.js embedded. to change the import folder set JSX_TMP", relative(cwd(), inFile), dirname(relative(JSX_TMP_DIR, inFileTmp)));
+          const { outputFiles: [{ contents }] } = await esBuild({
+            ...DEFAULT_ESOPTION,
+            entryPoints: [inFileTmp],
+            minify: options.minify,
+            platform: options.platform !== undefined ? options.platform : DEFAULT_ESOPTION.platform,
+            mainFields: options.mainFields !== undefined ? options.mainFields : DEFAULT_ESOPTION.mainFields,
+            external: options.external ? options.external : undefined
+          });
+          if (CLEAR_JSX_CACHE) {
+            logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+            await unlinkASync(inFileTmp);
+            //await unlinkASync(jsxJSPath);
+            await rmdirASync(tmpBuildDir);
+          }
+          return contents;
+        }*/
     }
     catch (e) {
         logger?.error("error with: " + inFile);
         logger?.error(e);
-        if (options.embemedJSX) {
-            if (CLEAR_JSX_CACHE) {
-                logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
-                await unlinkASync(inFileTmp);
-                //await unlinkASync(jsxJSPath);
-                await rmdirASync(tmpBuildDir);
-            }
-            else {
-                //console.error("errors on: " + tmpBuildDir);
-                logger?.error("error with: %s", inFileTmp);
-                logger?.trace("NOT clearing cache. to change this behaivor set CLEAR_JSX_CACHE to 1", tmpBuildDir);
-            }
-        }
+        /*if (options.embemedJSX) {
+          if (CLEAR_JSX_CACHE) {
+            logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+            await unlinkASync(inFileTmp);
+            //await unlinkASync(jsxJSPath);
+            await rmdirASync(tmpBuildDir);
+          } else {
+            //console.error("errors on: " + tmpBuildDir);
+            logger?.error("error with: %s", inFileTmp);
+            logger?.trace("NOT clearing cache. to change this behaivor set CLEAR_JSX_CACHE to 1", tmpBuildDir);
+          }
+        }*/
         throw e;
     }
 }
@@ -417,14 +411,14 @@ export async function importServerConfigModule(inFile, logger) {
 }
 export async function importJSXFile(inFile, logger) {
     const inflatedCode = await inflateJSX(inFile, {
-        embemedJSX: false,
+        // embemedJSX: false,
         minify: false,
         useExport: true,
         platform: "node",
         logger
     });
     const tmpBuildDir = resolve(JSX_TMP_DIR, String(process.pid), "import", Date.now() + "-" + randomUUID());
-    //const inFileTmp = resolve(tmpBuildDir, basename(inFile) + ".mjs");
+    // const inFileTmp = resolve(tmpBuildDir, basename(inFile) + ".mjs");
     const inFileTmp = resolve(tmpBuildDir, basename(inFile) + ".cjs");
     //const logger = getLogger(`${SERVER_IDENTIFIER}_JSX`);
     await mkdirASync(tmpBuildDir, {
@@ -432,11 +426,12 @@ export async function importJSXFile(inFile, logger) {
     });
     try {
         await writeFileASync(inFileTmp, inflatedCode);
-        assertGlobalTampered();
+        // assertGlobalTampered();
         logger?.trace("importing [%s] from [%s]. to change the import folder set JSX_TMP", relative(cwd(), inFile), dirname(relative(JSX_TMP_DIR, inFileTmp)));
         logger?.debug("importing [%s]", relative(cwd(), inFile));
         const module = await import(resolve(inFileTmp));
-        assertGlobalTampered();
+        // console.dir(module);
+        // assertGlobalTampered();
         if (CLEAR_JSX_CACHE) {
             logger?.trace("clearing cache at [%s]. to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
             await unlinkASync(inFileTmp);

package/build/esm/src/common/paths.d.ts

@@ -15,4 +15,3 @@ export declare function getAuthConfigPath(servicePath: string): string | false;
 export declare function getHTTPRouterPath(servicePath: string): string | false;
 export declare function getMigrationsPath(servicePath: string): string | false;
 export declare function getESBuildBinaryPath(): string;
-export declare function getJSXJSPath(): string;

package/build/esm/src/common/paths.js

@@ -82,6 +82,6 @@ export function getESBuildBinaryPath() {
         return resolve(JSX_TMP_DIR, String(process.pid), "esbuild");
     }
 }
-export function getJSXJSPath() {
-    return resolve(JSX_TMP_DIR, String(process.pid), "jsx.js");
-}
+/*export function getJSXJSPath() {
+  return resolve(JSX_TMP_DIR, String(process.pid), "jsx.js");
+}*/

package/build/esm/src/common/watch.d.ts

@@ -1,4 +1,3 @@
-import "../services/globals.js";
 import { Miqro } from "../services/app.js";
 export declare function watchAndServer(app: Miqro): Promise<{
     stopWatch: () => void;

package/build/esm/src/common/watch.js

@@ -1,4 +1,4 @@
-import "../services/globals.js";
+//import "../services/globals.js";
 import { existsSync, readdirSync, statSync, watch } from "node:fs";
 import { resolve } from "node:path";
 export async function watchAndServer(app) {
@@ -43,6 +43,7 @@ export async function watchAndServer(app) {
         }, 2000);
     }
     function watchDir(toWatch) {
+        clearTimeout(timeout);
         const files = existsSync(toWatch) ? readdirSync(toWatch) : [];
         for (const file of files) {
             const filePath = resolve(toWatch, file);
@@ -56,6 +57,7 @@ export async function watchAndServer(app) {
         }
     }
     function stopWatch() {
+        clearTimeout(timeout);
         const toClose = watchers.splice(0, watchers.length);
         for (const watcher of toClose) {
             watcher.close();
@@ -63,6 +65,7 @@ export async function watchAndServer(app) {
     }
     function reWatch() {
         stopWatch();
+        clearTimeout(timeout);
         for (const service of app.options.services) {
             const toWatch = resolve(process.cwd(), service);
             watchDir(toWatch);

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,