miqro 5.0.5 → 6.0.4

package/src/common/esbuild.ts

@@ -0,0 +1,94 @@
+import { exec } from "node:child_process";
+import { getAsset, initAsset, validateAsset } from "./assets.js";
+import { Logger } from "@miqro/core";
+import { getESBuildBinaryPath } from "./paths.js";
+import { dirname } from "node:path";
+import { calculateChecksumFromBuffer } from "./checksum.js";
+
+let esbuildBinaryBuffer = null; // Buffer.from(getAsset("esbuild-binary"));
+let esbuildBinaryChecksumPromise = null; // calculateChecksumFromBuffer(esbuildBinaryBuffer);
+
+export async function validateESBuild(logger?: Logger) {
+  return validateAsset(logger, getESBuildBinaryPath(), await esbuildBinaryChecksumPromise);
+}
+
+export async function initESBuild(logger: Logger) {
+  esbuildBinaryBuffer = esbuildBinaryBuffer ? esbuildBinaryBuffer : Buffer.from(getAsset("esbuild-binary"));
+  esbuildBinaryChecksumPromise = esbuildBinaryChecksumPromise ? esbuildBinaryChecksumPromise : calculateChecksumFromBuffer(esbuildBinaryBuffer);
+  return initAsset(logger, getESBuildBinaryPath(), esbuildBinaryBuffer, true, esbuildBinaryChecksumPromise, false);
+}
+
+const NODEJS_EXTERNAL = [
+  "node:cluster",
+  "node:assert",
+  "node:util",
+  "node:path",
+  "node:fs",
+  "node:crypto",
+  "node:http",
+  "node:https",
+  "node:os",
+  "node:dns",
+  "node:string_decoder",
+  "node:stream",
+  "node:http2",
+  "node:net",
+  "node:worker_threads",
+  "node:process",
+  "child_process",
+  "node:child_process",
+  "core",
+  "globals",
+  "jsx.globals",
+  "server.globals",
+  "browser.globals",
+  "sqlite3",
+  "pg"
+];
+
+export async function esBuild(options: {
+  platform?: string;
+  entryPoints: [string];
+  bundle?: boolean;
+  jsxFactory?: string;
+  jsxFragment?: string;
+  minify?: boolean;
+  outfile?: string;
+}, logger?: Logger): Promise<{
+  outputFiles: {
+    path: string;
+    contents: any;
+  }[]
+}> {
+  return new Promise(async (resolve, reject) => {
+    try {
+      //const logger = getLogger(`${SERVER_IDENTIFIER}_ESBUILD`);
+      const valid = await validateESBuild(logger);
+      const esBuildCMD = `${getESBuildBinaryPath()} "${options.entryPoints[0]}" ${NODEJS_EXTERNAL.map(e => `--external:${e}`).join(" ")} --loader:.js=jsx --jsx-factory=${options.jsxFactory} --jsx-fragment=${options.jsxFragment} ${options.bundle ? " --bundle" : ""}${options.minify ? " --minify" : ""}${options.outfile ? ` --outfile="${options.outfile}"` : ""}${options.platform ? ` --platform=${options.platform}` : ""}`;
+      logger?.trace(esBuildCMD);
+      if (!valid) {
+        const err = new Error(`esbuild installation at [${getESBuildBinaryPath()}] tampered`);
+        reject(err);
+      } else {
+        exec(esBuildCMD, {
+          maxBuffer: 1024 * 1000 * 2000,
+          cwd: dirname(options.entryPoints[0])
+        }, (err, stdout, _stderr) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve({
+              outputFiles: [{
+                path: "",
+                contents: stdout
+              }]
+            });
+          }
+        });
+      }
+    } catch (e) {
+      logger?.error(e);
+      reject(e);
+    }
+  });
+}

package/src/common/exit.ts

@@ -0,0 +1,91 @@
+import { existsSync, rmdirSync, unlinkSync } from "node:fs";
+//import { notifiyServerStop, notifiyServerUnLoad } from "../services/server.js";
+import { getESBuildBinaryPath, getJSXJSPath, JSX_TMP_DIR } from "./paths.js";
+import { CLEAR_JSX_CACHE } from "./constants.js";
+import { resolve } from "node:path";
+import { EXIT_CODES } from "./constants.js";
+import { Miqro } from "../services/app.js";
+
+function cleanJSX(app: Miqro) {
+  app.logger?.trace("trying to clean up esbuild installation at [%s]", getESBuildBinaryPath());
+  if (existsSync(getESBuildBinaryPath())) {
+    unlinkSync(getESBuildBinaryPath());
+  }
+  if (CLEAR_JSX_CACHE) {
+    app.logger?.trace("trying to clean up jsx.js installation at [%s]", getJSXJSPath());
+    if (existsSync(getJSXJSPath())) {
+      unlinkSync(getJSXJSPath());
+    }
+    const buildParendDir = resolve(JSX_TMP_DIR, String(process.pid));
+    app.logger?.trace("trying to clean up jsx build/import folders at [%s]", buildParendDir);
+    const buildDir = resolve(buildParendDir, "build");
+    const importDir = resolve(buildParendDir, "import");
+    if (existsSync(buildDir)) {
+      rmdirSync(buildDir);
+    }
+    if (existsSync(importDir)) {
+      rmdirSync(importDir);
+    }
+    if (existsSync(buildParendDir)) {
+      rmdirSync(buildParendDir);
+    }
+  }
+}
+
+export function setupExitHandlers(app: Miqro) {
+  let exceptionOccured = false;
+
+  process.on('uncaughtException', async function (err) {
+    app.logger?.error('Caught exception: ' + err);
+    app.logger?.error(err);
+    exceptionOccured = true;
+    /*if (app.server) {
+      notifiyServerConfigSync(app, "unload");
+      notifiyServerConfigSync(app, "stop");
+      app.webSocketManager.disconnectAll();
+      app.dbManager.closeAll();
+    }*/
+    cleanJSX(app);
+    if (app.server) {
+      app.stop();
+    }
+    process.exit(EXIT_CODES.ABNORMAL_UNCONTROLLED);
+  });
+
+  process.on('exit', async function (code) {
+    if (exceptionOccured) {
+      app.logger?.error('Exception occured');
+    } else {
+      /*if (app.server) {
+        notifiyServerConfigSync(app, "unload");
+        notifiyServerConfigSync(app, "stop");
+        app.webSocketManager.disconnectAll();
+        app.dbManager.closeAll();
+      }*/
+      cleanJSX(app);
+      if (app.server) {
+        app.stop();
+      }
+    }
+  });
+
+  process.on("SIGTERM", function () {
+    app.logger?.info('SIGTERM received');
+    process.exit(EXIT_CODES.ABNORMAL_UNCONTROLLED);
+  });
+
+  process.on('SIGHUP', function () {
+    app.logger?.info('SIGHUP received');
+    process.exit(EXIT_CODES.ABNORMAL_UNCONTROLLED);
+  });
+
+  /*process.on('SIGKILL', function () {
+    server.logger.info('SIGKILL received');
+    process.exit(EXIT_CODES.ABNORMAL_UNCONTROLLED);
+  });*/
+
+  process.on('SIGINT', function () {
+    app.logger?.info('SIGINT received');
+    process.exit(EXIT_CODES.ABNORMAL_UNCONTROLLED);
+  });
+}

package/src/common/fs.ts

@@ -0,0 +1,17 @@
+import { basename, extname } from "node:path";
+
+export function describeFilePath(filePath: string) {
+  const ext = extname(filePath);
+  const fileName = basename(filePath);
+  const name = fileName.substring(0, fileName.length - ext.length);
+  const subExt = extname(name);
+  const subName = name.substring(0, name.length - subExt.length);
+  return {
+    ext,
+    fileName,
+    name,
+    subExt,
+    subName,
+    filePath
+  };
+}

package/src/common/help.ts

@@ -0,0 +1,46 @@
+//import { basename } from "node:path";
+
+export const BIN_NAME = "miqro"; //,basename(process.argv[0]);
+
+export const usage = `usage: ${BIN_NAME} [...FLAGS] --service app/
+
+==examples==
+
+${BIN_NAME} --watch --service front/
+PORT=8181 ${BIN_NAME} --service api/ --service front/
+${BIN_NAME} --test --service front/
+${BIN_NAME} --inflate --service front/
+${BIN_NAME} --generate-doc --generate-doc-out API.md --service front/
+CLUSTER_COUNT=10 ${BIN_NAME}-cluster --service api/`;
+
+export const help = `
+==flags==
+
+-v, --version\t\toutputs the version number
+-h, --help\t\toutputs this page.
+--watch\t\tuse to enable the hot-reload functionality.
+--test\t\t\trun the tests for a service.
+--migrate-up\t\tmigrations up.
+--migrate-down\t\tmigrations down.
+--inflate\t\tinflates the application.
+--inflate-dir\t\tto set the output directory of the --inflate command. default value is inflated/.
+--editor\t\truns the application with a built-in editor.
+--generate-doc\t\tgenerates a documentation for the api endpoints of the service.
+--generate-doc-out\tthe output file for the generated documentation. default value is API.md.
+--generate-doc-type\tthe format of the generated documentation. it can be JSON or MD. default value is MD.
+--compile\t\tinflates the application and tries to create a NODE SEA binary.
+--inflate-sea\t\tinflates the application with sea compilation scripts.
+--install-tsconfig\tcreates a tsconfig.json configured to use with --install-types.
+--install-types\t\tcreates and updates the .types/ folder use together with --install-tsconfig.
+
+==environment variables==
+
+PORT\t\t\toverride the default 8080 port.
+LOG_FILE\t\toverride the default ./server.log file
+DB\t\t\tenable the server.db features
+DB_STORAGE\t\toverride the default local db location ./db.sqlite3
+DB_DIALECT\t\toverride the default node:sqlite
+DB_CONNECTION\t\toverride the default connection url
+CLEAR_JSX_CACHE\t\tset to 1 or 0 to enable or disable the clearing of the esbuild cache defaults to 1.
+JSX_TMP\t\t\tset custom location of esbuild builds defaults to /tmp/jsx_tmp.
+`;

package/src/common/jsx.ts

@@ -0,0 +1,414 @@
+import { Runtime } from "@miqro/jsx";
+import { createNodeRuntime } from "@miqro/jsx-node";
+import { basename, dirname, relative, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, rmdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { Request, Response, CORSOptions, Logger, APIRoute } from "@miqro/core";
+import { Parser, Schema } 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 { APIOptions, ServerConfig, WSConfig, AuthConfig, DBConfig, LogConfig } from "../types.js";
+import { getJSXJSPath, 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 { RouteOptionsSchema } from "@miqro/core/build/types.js";
+import { Migration } from "@miqro/query";
+
+let jsxJSBuffer: null | Buffer = null; // Buffer.from(getAsset("jsx.dom.js"));
+let jsxJSBufferChecksumPromise: null | Promise<string> = null; // calculateChecksumFromBuffer(jsxJSBuffer);
+
+export async function initJSXJS(logger: 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: Logger) {
+  const checksum = await jsxJSBufferChecksumPromise;
+  if (!checksum) {
+    throw new Error("error calculating checksum");
+  }
+  return validateAsset(logger, getJSXJSPath(), checksum);
+}
+
+export interface Dict<T> {
+  [key: string]: T | Dict<T>;
+}
+
+const parser = new Parser();
+
+export interface InflateError {
+  filePath: string;
+  error: Error;
+}
+
+export interface InflateOptions {
+  embemedJSX: boolean;
+  minify: boolean;
+  useExport: boolean;
+  logger?: Logger | Console;
+}
+
+const DEFAULT_ESOPTION = {
+  platform: "neutral",
+  bundle: true,
+  jsxFactory: "JSX.createElement",
+  jsxFragment: "JSX.Fragment"
+};
+
+export async function inflateJSX(inFile: string, options: InflateOptions): Promise<string> {
+  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 logger = options.logger; //getLogger(`${SERVER_IDENTIFIER}_JSX`);
+
+  try {
+
+    if (!options.embemedJSX) {
+      mkdirSync(tmpBuildDir, {
+        recursive: true
+      });
+      writeFileSync(inFileTmp, browserJSXGlobals(inFile, false, options.useExport));
+      //writeFileSync(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
+      });
+      if (CLEAR_JSX_CACHE) {
+        logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+        unlinkSync(inFileTmp);
+        rmdirSync(tmpBuildDir);
+      }
+      return contents;
+    } else {
+      mkdirSync(tmpBuildDir, {
+        recursive: true
+      });
+      //writeFileSync(jsxJSPath, Buffer.from(getAsset("jsx-dom-bundle")));
+      writeFileSync(inFileTmp, browserJSXGlobals(inFile, jsxJSPath));
+      //writeFileSync(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
+      });
+      if (CLEAR_JSX_CACHE) {
+        logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+        unlinkSync(inFileTmp);
+        //unlinkSync(jsxJSPath);
+        rmdirSync(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);
+        unlinkSync(inFileTmp);
+        //unlinkSync(jsxJSPath);
+        rmdirSync(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;
+  }
+}
+
+export async function importAPIRoute(inFile: string, logger?: Logger) {
+  const mod = (await importJSXFile(inFile, logger)).default;
+  const module = typeof mod === "function" ? { handler: mod } : parser.parse(mod, APIRouteSchema, basename(inFile));
+  if (module !== undefined) {
+    return module as APIRoute;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export const APIOptionsSchema: Schema<APIOptions> = {
+  type: "object?",
+  properties: {
+    basePath: "string?",
+    path: "string?|string[]?",
+    method: "string?|string[]?",
+    parser: {
+      type: "object?",
+      properties: {
+        parse: "function"
+      },
+      mode: "add_extra"
+    },
+    middleware: "function[]!?",
+    session: {
+      type: "object?|function?",
+      properties: SessionHandlerOptionsSchema.properties
+    },
+    ...RouteOptionsSchema.properties
+  }
+};
+
+export interface HTMLModule {
+  default: JSX.Element | ((req: Request | null, res: Response | null) => (Promise<JSX.Element> | JSX.Element));
+  apiOptions?: APIOptions;
+}
+
+export const HTMLModuleSchema: Schema<HTMLModule> = {
+  type: "object",
+  properties: {
+    default: {
+      type: "function|object"
+    },
+    apiOptions: APIOptionsSchema
+  }
+}
+
+export type JSONModuleValue = string | object;
+
+export interface JSONModule {
+  default: JSONModuleValue | ((req: Request | null, res: Response | null) => (Promise<JSONModuleValue> | JSONModuleValue));
+  apiOptions?: APIOptions;
+}
+
+export const JSONModuleSchema: Schema<JSONModule> = {
+  type: "object",
+  properties: {
+    default: {
+      type: "function|object|string"
+    },
+    apiOptions: APIOptionsSchema
+  }
+}
+
+export const MigrationSchema: Schema<Migration> = {
+  type: "object",
+  properties: {
+    up: "function",
+    down: "function"
+  }
+}
+
+export const CORSOptionsSchema: Schema<CORSOptions> = {
+  type: "object",
+  properties: {
+    origins: "string[]?|string?",
+    validate: "function?",
+    methods: "string?",
+    preflightContinue: "boolean?"
+  }
+}
+
+export const WSConfigSchema: Schema<WSConfig> = {
+  type: "object",
+  properties: {
+    path: "string",
+    disabled: "boolean?",
+    maxConnections: "number?",
+    validate: "function?",
+    onConnection: "function?",
+    onMessage: "function?",
+    onDisconnect: "function?"
+  }
+};
+
+export const DBConfigSchema: Schema<DBConfig> = {
+  type: "object",
+  properties: {
+    url: "string?",
+    disabled: "boolean?",
+    storage: "string?",
+    dialect: "string?",
+    name: "string"
+  }
+}
+
+export const ServerConfigSchema: Schema<ServerConfig> = {
+  type: "object",
+  properties: {
+    preload: "function?",
+    unload: "function?",
+    stop: "function?",
+    start: "function?",
+    load: "function?"
+  }
+};
+
+export const LogConfigSchema: Schema<LogConfig> = {
+  type: "object",
+  properties: {
+    level: {
+      type: "enum?",
+      enumValues: ["error", "warn", "info", "debug", "trace", "none"]
+    },
+    replaceConsoleTransport: "boolean?",
+    replaceFileTransport: "boolean?",
+    write: "function"
+  }
+};
+
+export const AuthConfigSchema: Schema<AuthConfig> = {
+  type: "object",
+  properties: {
+    ...SessionHandlerOptionsSchema.properties
+  }
+}
+
+
+
+export async function importMigrationModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, MigrationSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importHTMLModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)), HTMLModuleSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importJSONModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)), JSONModuleSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importAuthModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, AuthConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importCORSModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, CORSOptionsSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importWSConfigModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, WSConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importDBConfigModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, DBConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importLogConfigModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, LogConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importServerConfigModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, ServerConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importJSXFile(inFile: string, logger?: Logger | Console): Promise<any> {
+  const inflatedCode = await inflateJSX(inFile, {
+    embemedJSX: false,
+    minify: false,
+    useExport: true,
+    logger
+  });
+  const tmpBuildDir = resolve(JSX_TMP_DIR, String(process.pid), "import", Date.now() + "-" + randomUUID());
+  const inFileTmp = resolve(tmpBuildDir, basename(inFile) + ".mjs");
+  //const logger = getLogger(`${SERVER_IDENTIFIER}_JSX`);
+  mkdirSync(tmpBuildDir, {
+    recursive: true
+  });
+  try {
+    writeFileSync(inFileTmp, inflatedCode);
+    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(inFileTmp);
+    assertGlobalTampered();
+    if (CLEAR_JSX_CACHE) {
+      logger?.trace("clearing cache at [%s]. to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+      unlinkSync(inFileTmp);
+      rmdirSync(tmpBuildDir);
+    }
+    return module;
+  } catch (e) {
+    logger?.error(e);
+    logger?.error("error with: " + inFile);
+    if (CLEAR_JSX_CACHE) {
+      logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+      unlinkSync(inFileTmp);
+      rmdirSync(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;
+  }
+}
+
+export function jsx2HTML(out: JSX.Element, runtime?: Runtime): string {
+  runtime = runtime ? runtime : createNodeRuntime();
+  const element = runtime.createElement("root");
+  const container = runtime.createContainer(element, {
+    shadowInit: false, runtimeOptions: {
+      disableEffects: true,
+      disableEvents: true,
+      disableRefListener: true,
+      disableRefresh: true
+    }
+  });
+  container.render(out);
+  //console.log("jsx2HTML [%s]", element);
+  let HTML = "";
+  for (let i = 0; i < element.childNodes.length; i++) {
+    const child = element.childNodes[i];
+    //console.log("jsx2HTML child [%s]", child);
+    //console.log("jsx2HTML child [%s]", (child as any).toString("  ", -1));
+    HTML += (child as any).toString("  ", -1);
+  }
+  container.disconnect();
+  //console.log("jsx2HTML [%s]", HTML);
+  return HTML;
+}