@hyperspan/framework 0.1.2 → 0.1.4

package/dist/server.js

@@ -1,194 +1,12 @@
+import {
+  buildClientCSS,
+  buildClientJS
+} from "./assets.js";
+
 // src/server.ts
-import { readdir as readdir2 } from "node:fs/promises";
+import { readdir } from "node:fs/promises";
 import { basename, extname, join } from "node:path";
-
-// ../html/dist/html.js
-/*!
- * escape-html
- * Copyright(c) 2012-2013 TJ Holowaychuk
- * Copyright(c) 2015 Andreas Lubbe
- * Copyright(c) 2015 Tiancheng "Timothy" Gu
- * MIT Licensed
- */
-var matchHtmlRegExp = /["'&<>]/;
-function escapeHtml(string) {
-  const str = "" + string;
-  const match = matchHtmlRegExp.exec(str);
-  if (!match) {
-    return str;
-  }
-  let escape;
-  let html = "";
-  let index = 0;
-  let lastIndex = 0;
-  for (index = match.index;index < str.length; index++) {
-    switch (str.charCodeAt(index)) {
-      case 34:
-        escape = "&quot;";
-        break;
-      case 38:
-        escape = "&amp;";
-        break;
-      case 39:
-        escape = "&#39;";
-        break;
-      case 60:
-        escape = "&lt;";
-        break;
-      case 62:
-        escape = "&gt;";
-        break;
-      default:
-        continue;
-    }
-    if (lastIndex !== index) {
-      html += str.substring(lastIndex, index);
-    }
-    lastIndex = index + 1;
-    html += escape;
-  }
-  return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
-}
-
-class TmplHtml {
-  _kind = "hstmpl";
-  content = "";
-  asyncContent;
-  constructor(props) {
-    this.content = props.content;
-    this.asyncContent = props.asyncContent;
-  }
-}
-var htmlId = 0;
-function html(strings, ...values) {
-  const asyncContent = [];
-  let content = "";
-  for (let i = 0;i < strings.length; i++) {
-    const value = values[i];
-    const kind = _typeOf(value);
-    const renderValue = _renderValue(value, { kind, asyncContent }) || "";
-    content += strings[i] + (renderValue ? renderValue : "");
-  }
-  return new TmplHtml({ content, asyncContent });
-}
-html.raw = (content) => ({ _kind: "html_safe", content });
-function _renderValue(value, opts = {
-  kind: undefined,
-  id: undefined,
-  asyncContent: []
-}) {
-  if (value === null || value === undefined || Number.isNaN(value)) {
-    return "";
-  }
-  const kind = opts.kind || _typeOf(value);
-  let id = opts.id;
-  switch (kind) {
-    case "array":
-      return value.map((v) => _renderValue(v, { id, asyncContent: opts.asyncContent })).join("");
-    case "object":
-      id = `async_loading_${htmlId++}`;
-      if (value instanceof TmplHtml || value.constructor.name === "TmplHtml" || value?._kind === "hstmpl") {
-        opts.asyncContent.push(...value.asyncContent);
-        return value.content;
-      }
-      if (value?._kind === "html_safe") {
-        return value?.content || "";
-      }
-      if (typeof value.renderAsync === "function") {
-        opts.asyncContent.push({
-          id,
-          promise: value.renderAsync().then((result) => ({
-            id,
-            value: result,
-            asyncContent: opts.asyncContent
-          }))
-        });
-      }
-      if (typeof value.render === "function") {
-        return render(_htmlPlaceholder(id, value.render()));
-      }
-      return JSON.stringify(value);
-    case "promise":
-      id = `async_loading_${htmlId++}`;
-      opts.asyncContent.push({
-        id,
-        promise: value.then((result) => ({
-          id,
-          value: result,
-          asyncContent: opts.asyncContent
-        }))
-      });
-      return render(_htmlPlaceholder(id));
-    case "generator":
-      throw new Error("Generators are not supported as a template value at this time. Sorry :(");
-    default:
-      console.log("_renderValue kind =", kind, value);
-  }
-  return escapeHtml(String(value));
-}
-function _htmlPlaceholder(id, content = "Loading...") {
-  return html`<!--hs:loading:${id}--><slot id="${id}">${content}</slot><!--/hs:loading:${id}-->`;
-}
-function render(tmpl) {
-  return tmpl.content;
-}
-async function renderAsync(tmpl) {
-  let { content, asyncContent } = tmpl;
-  while (asyncContent.length !== 0) {
-    const resolvedHtml = await Promise.all(asyncContent.map((p) => p.promise));
-    asyncContent = [];
-    resolvedHtml.map((obj) => {
-      const r = new RegExp(`<!--hs:loading:${obj.id}-->(.*?)<!--/hs:loading:${obj.id}-->`);
-      const found = content.match(r);
-      if (found) {
-        content = content.replace(found[0], _renderValue(obj.value, { asyncContent }));
-      }
-    });
-  }
-  return content;
-}
-async function* renderStream(tmpl) {
-  yield render(tmpl);
-  let asyncContent = tmpl.asyncContent;
-  while (asyncContent.length > 0) {
-    const nextContent = await Promise.race(asyncContent.map((p) => p.promise));
-    asyncContent = asyncContent.filter((p) => p.id !== nextContent.id);
-    const id = nextContent.id;
-    const content = _renderValue(nextContent.value, {
-      asyncContent
-    });
-    const script = html`<template id="${id}_content">${html.raw(content)}<!--end--></template>`;
-    yield render(script);
-  }
-}
-function _typeOf(obj) {
-  if (obj instanceof Promise)
-    return "promise";
-  if (obj instanceof Date)
-    return "date";
-  if (obj instanceof String)
-    return "string";
-  if (obj instanceof Number)
-    return "number";
-  if (obj instanceof Boolean)
-    return "boolean";
-  if (obj instanceof Function)
-    return "function";
-  if (Array.isArray(obj))
-    return "array";
-  if (Number.isNaN(obj))
-    return "NaN";
-  if (obj === undefined)
-    return "undefined";
-  if (obj === null)
-    return "null";
-  if (isGenerator(obj))
-    return "generator";
-  return typeof obj;
-}
-function isGenerator(obj) {
-  return obj && typeof obj.next == "function" && typeof obj.throw == "function";
-}
+import { TmplHtml, html, renderStream, renderAsync, render } from "@hyperspan/html";
 
 // node_modules/isbot/index.mjs
 var fullPattern = " daum[ /]| deusu/| yadirectfetcher|(?:^|[^g])news(?!sapphire)|(?<! (?:channel/|google/))google(?!(app|/google| pixel))|(?<! cu)bots?(?:\\b|_)|(?<!(?:lib))http|(?<![hg]m)score|@[a-z][\\w-]+\\.|\\(\\)|\\.com\\b|\\btime/|\\||^<|^[\\w \\.\\-\\(?:\\):%]+(?:/v?\\d+(?:\\.\\d+)?(?:\\.\\d{1,10})*?)?(?:,|$)|^[^ ]{50,}$|^\\d+\\b|^\\w*search\\b|^\\w+/[\\w\\(\\)]*$|^active|^ad muncher|^amaya|^avsdevicesdk/|^biglotron|^bot|^bw/|^clamav[ /]|^client/|^cobweb/|^custom|^ddg[_-]android|^discourse|^dispatch/\\d|^downcast/|^duckduckgo|^email|^facebook|^getright/|^gozilla/|^hobbit|^hotzonu|^hwcdn/|^igetter/|^jeode/|^jetty/|^jigsaw|^microsoft bits|^movabletype|^mozilla/\\d\\.\\d\\s[\\w\\.-]+$|^mozilla/\\d\\.\\d\\s\\(compatible;?(?:\\s\\w+\\/\\d+\\.\\d+)?\\)$|^navermailapp|^netsurf|^offline|^openai/|^owler|^php|^postman|^python|^rank|^read|^reed|^rest|^rss|^snapchat|^space bison|^svn|^swcd |^taringa|^thumbor/|^track|^w3c|^webbandit/|^webcopier|^wget|^whatsapp|^wordpress|^xenu link sleuth|^yahoo|^yandex|^zdm/\\d|^zoom marketplace/|^{{.*}}$|adscanner/|analyzer|archive|ask jeeves/teoma|audit|bit\\.ly/|bluecoat drtr|browsex|burpcollaborator|capture|catch|check\\b|checker|chrome-lighthouse|chromeframe|classifier|cloudflare|convertify|cookiehubscan|crawl|cypress/|dareboost|datanyze|dejaclick|detect|dmbrowser|download|evc-batch/|exaleadcloudview|feed|firephp|functionize|gomezagent|headless|httrack|hubspot marketing grader|hydra|ibisbrowser|infrawatch|insight|inspect|iplabel|ips-agent|java(?!;)|jsjcw_scanner|library|linkcheck|mail\\.ru/|manager|measure|neustar wpm|node|nutch|offbyone|onetrust|optimize|pageburst|pagespeed|parser|perl|phantomjs|pingdom|powermarks|preview|proxy|ptst[ /]\\d|retriever|rexx;|rigor|rss\\b|scanner\\.|scrape|server|sogou|sparkler/|speedcurve|spider|splash|statuscake|supercleaner|synapse|synthetic|tools|torrent|transcoder|url|validator|virtuoso|wappalyzer|webglance|webkit2png|whatcms/|zgrab";
@@ -209,48 +27,6 @@ function isbot(userAgent) {
   return Boolean(userAgent) && getPattern().test(userAgent);
 }
 
-// src/clientjs/md5.js
-var hex_chr = "0123456789abcdef".split("");
-
-// src/assets.ts
-import { readdir } from "node:fs/promises";
-import { resolve } from "node:path";
-var IS_PROD = false;
-var PWD = import.meta.dir;
-var clientJSFiles = new Map;
-async function buildClientJS() {
-  const sourceFile = resolve(PWD, "../", "./src/clientjs/hyperspan-client.ts");
-  const output = await Bun.build({
-    entrypoints: [sourceFile],
-    outdir: `./public/_hs/js`,
-    naming: IS_PROD ? "[dir]/[name]-[hash].[ext]" : undefined,
-    minify: IS_PROD
-  });
-  const jsFile = output.outputs[0].path.split("/").reverse()[0];
-  clientJSFiles.set("_hs", { src: "/_hs/js/" + jsFile });
-  return jsFile;
-}
-var clientCSSFiles = new Map;
-async function buildClientCSS() {
-  if (clientCSSFiles.has("_hs")) {
-    return clientCSSFiles.get("_hs");
-  }
-  const cssDir = "./public/_hs/css/";
-  const cssFiles = await readdir(cssDir);
-  let foundCSSFile = "";
-  for (const file of cssFiles) {
-    if (!file.endsWith(".css")) {
-      continue;
-    }
-    foundCSSFile = file.replace(cssDir, "");
-    clientCSSFiles.set("_hs", foundCSSFile);
-    break;
-  }
-  if (!foundCSSFile) {
-    console.log(`Unable to build CSS files from ${cssDir}`);
-  }
-}
-
 // node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
   return (context, next) => {
@@ -920,15 +696,15 @@ var Context = class {
     this.#preparedHeaders["content-type"] = "application/json";
     return typeof arg === "number" ? this.#newResponse(body, arg, headers) : this.#newResponse(body, arg);
   };
-  html = (html2, arg, headers) => {
+  html = (html, arg, headers) => {
     this.#preparedHeaders ??= {};
     this.#preparedHeaders["content-type"] = "text/html; charset=UTF-8";
-    if (typeof html2 === "object") {
-      return resolveCallback(html2, HtmlEscapedCallbackPhase.Stringify, false, {}).then((html22) => {
-        return typeof arg === "number" ? this.#newResponse(html22, arg, headers) : this.#newResponse(html22, arg);
+    if (typeof html === "object") {
+      return resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then((html2) => {
+        return typeof arg === "number" ? this.#newResponse(html2, arg, headers) : this.#newResponse(html2, arg);
       });
     }
-    return typeof arg === "number" ? this.#newResponse(html2, arg, headers) : this.#newResponse(html2, arg);
+    return typeof arg === "number" ? this.#newResponse(html, arg, headers) : this.#newResponse(html, arg);
   };
   redirect = (location, status) => {
     this.#headers ??= new Headers;
@@ -2020,328 +1796,162 @@ var WSContext = class {
   }
 };
 
-// node_modules/@zod/core/dist/esm/core.js
-var $brand = Symbol("zod_brand");
-
-class $ZodAsyncError extends Error {
-  constructor() {
-    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+// node_modules/hono/dist/http-exception.js
+var HTTPException = class extends Error {
+  res;
+  status;
+  constructor(status = 500, options) {
+    super(options?.message, { cause: options?.cause });
+    this.res = options?.res;
+    this.status = status;
+  }
+  getResponse() {
+    if (this.res) {
+      const newResponse = new Response(this.res.body, {
+        status: this.status,
+        headers: this.res.headers
+      });
+      return newResponse;
+    }
+    return new Response(this.message, {
+      status: this.status
+    });
   }
-}
-var globalConfig = {};
-function config(config2) {
-  if (config2)
-    Object.assign(globalConfig, config2);
-  return globalConfig;
-}
+};
 
-// node_modules/@zod/core/dist/esm/util.js
-function jsonStringifyReplacer(_, value) {
-  if (typeof value === "bigint")
-    return value.toString();
-  return value;
-}
-function cached(getter) {
-  const set = false;
-  return {
-    get value() {
-      if (!set) {
-        const value = getter();
-        Object.defineProperty(this, "value", { value });
-        return value;
+// src/server.ts
+var IS_PROD = false;
+var CWD = process.cwd();
+function createRoute(handler) {
+  let _handlers = {};
+  if (handler) {
+    _handlers["GET"] = handler;
+  }
+  const api = {
+    _kind: "hsRoute",
+    get(handler2) {
+      _handlers["GET"] = handler2;
+      return api;
+    },
+    post(handler2) {
+      _handlers["POST"] = handler2;
+      return api;
+    },
+    put(handler2) {
+      _handlers["PUT"] = handler2;
+      return api;
+    },
+    delete(handler2) {
+      _handlers["DELETE"] = handler2;
+      return api;
+    },
+    patch(handler2) {
+      _handlers["PATCH"] = handler2;
+      return api;
+    },
+    async run(method, context) {
+      const handler2 = _handlers[method];
+      if (!handler2) {
+        throw new HTTPException(405, { message: "Method not allowed" });
+      }
+      const routeContent = await handler2(context);
+      if (routeContent instanceof Response) {
+        return routeContent;
+      }
+      const userIsBot = isbot(context.req.header("User-Agent"));
+      const streamOpt = context.req.query("__nostream");
+      const streamingEnabled = !userIsBot && (streamOpt !== undefined ? streamOpt : true);
+      const routeKind = typeof routeContent;
+      if (routeContent && routeKind === "object" && (routeContent instanceof TmplHtml || routeContent.constructor.name === "TmplHtml" || routeContent?._kind === "TmplHtml")) {
+        if (streamingEnabled) {
+          return new StreamResponse(renderStream(routeContent));
+        } else {
+          const output = await renderAsync(routeContent);
+          return context.html(output);
+        }
       }
-      throw new Error("cached value already set");
+      return context.text(String(routeContent));
     }
   };
+  return api;
 }
-var allowsEval = cached(() => {
-  try {
-    new Function("");
-    return true;
-  } catch (_) {
-    return false;
-  }
-});
-var propertyKeyTypes = new Set(["string", "number", "symbol"]);
-var primitiveTypes = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
-var NUMBER_FORMAT_RANGES = {
-  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
-  int32: [-2147483648, 2147483647],
-  uint32: [0, 4294967295],
-  float32: [-340282346638528860000000000000000000000, 340282346638528860000000000000000000000],
-  float64: [-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000]
-};
-function unwrapMessage(message) {
-  return typeof message === "string" ? message : message?.message;
-}
-function finalizeIssue(iss, ctx, config2) {
-  const full = { ...iss, path: iss.path ?? [] };
-  if (!iss.message) {
-    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
-    full.message = message;
-  }
-  delete full.inst;
-  delete full.continue;
-  if (!ctx?.reportInput) {
-    delete full.input;
-  }
-  return full;
-}
-
-// node_modules/@zod/core/dist/esm/errors.js
-var ZOD_ERROR = Symbol.for("{{zod.error}}");
-
-class $ZodError {
-  get message() {
-    return JSON.stringify(this.issues, jsonStringifyReplacer, 2);
-  }
-  constructor(issues) {
-    Object.defineProperty(this, "_tag", { value: ZOD_ERROR, enumerable: false });
-    Object.defineProperty(this, "name", { value: "$ZodError", enumerable: false });
-    this.issues = issues;
-  }
-  static [Symbol.hasInstance](inst) {
-    return inst?._tag === ZOD_ERROR;
-  }
-}
-function flattenError(error, mapper = (issue) => issue.message) {
-  const fieldErrors = {};
-  const formErrors = [];
-  for (const sub of error.issues) {
-    if (sub.path.length > 0) {
-      fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
-      fieldErrors[sub.path[0]].push(mapper(sub));
-    } else {
-      formErrors.push(mapper(sub));
-    }
-  }
-  return { formErrors, fieldErrors };
-}
-function formatError(error, _mapper) {
-  const mapper = _mapper || function(issue) {
-    return issue.message;
-  };
-  const fieldErrors = { _errors: [] };
-  const processError = (error2) => {
-    for (const issue of error2.issues) {
-      if (issue.code === "invalid_union") {
-        issue.errors.map((issues) => processError({ issues }));
-      } else if (issue.code === "invalid_key") {
-        processError({ issues: issue.issues });
-      } else if (issue.code === "invalid_element") {
-        processError({ issues: issue.issues });
-      } else if (issue.path.length === 0) {
-        fieldErrors._errors.push(mapper(issue));
-      } else {
-        let curr = fieldErrors;
-        let i = 0;
-        while (i < issue.path.length) {
-          const el = issue.path[i];
-          const terminal = i === issue.path.length - 1;
-          if (!terminal) {
-            curr[el] = curr[el] || { _errors: [] };
-          } else {
-            curr[el] = curr[el] || { _errors: [] };
-            curr[el]._errors.push(mapper(issue));
-          }
-          curr = curr[el];
-          i++;
+function createAPIRoute(handler) {
+  let _handlers = {};
+  if (handler) {
+    _handlers["GET"] = handler;
+  }
+  const api = {
+    _kind: "hsRoute",
+    get(handler2) {
+      _handlers["GET"] = handler2;
+      return api;
+    },
+    post(handler2) {
+      _handlers["POST"] = handler2;
+      return api;
+    },
+    put(handler2) {
+      _handlers["PUT"] = handler2;
+      return api;
+    },
+    delete(handler2) {
+      _handlers["DELETE"] = handler2;
+      return api;
+    },
+    patch(handler2) {
+      _handlers["PATCH"] = handler2;
+      return api;
+    },
+    async run(method, context) {
+      const handler2 = _handlers[method];
+      if (!handler2) {
+        throw new Error("Method not allowed");
+      }
+      try {
+        const response = await handler2(context);
+        if (response instanceof Response) {
+          return response;
         }
+        return context.json({ meta: { success: true, dtResponse: new Date }, data: response }, { status: 200 });
+      } catch (err) {
+        const e = err;
+        console.error(e);
+        return context.json({
+          meta: { success: false, dtResponse: new Date },
+          data: {},
+          error: {
+            message: e.message,
+            stack: IS_PROD ? undefined : e.stack?.split(`
+`)
+          }
+        }, { status: 500 });
       }
     }
   };
-  processError(error);
-  return fieldErrors;
+  return api;
 }
-
-// node_modules/@zod/core/dist/esm/parse.js
-function _parse(schema, value, _ctx) {
-  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
-  if (result instanceof Promise) {
-    throw new $ZodAsyncError;
+function getRunnableRoute(route) {
+  if (isRouteRunnable(route)) {
+    return route;
   }
-  if (result.issues.length) {
-    throw new (this?.Error ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+  const kind = typeof route;
+  if (kind === "function") {
+    return createRoute(route);
   }
-  return result.value;
-}
-
-// node_modules/zod/dist/esm/errors.js
-class ZodError extends $ZodError {
-  format(mapper) {
-    return formatError(this, mapper);
-  }
-  flatten(mapper) {
-    return flattenError(this, mapper);
-  }
-  addIssue(issue) {
-    this.issues.push(issue);
-  }
-  addIssues(issues) {
-    this.issues.push(...issues);
-  }
-  get isEmpty() {
-    return this.issues.length === 0;
+  if (kind === "object" && "default" in route) {
+    return getRunnableRoute(route.default);
   }
+  throw new Error('Route not runnable. Use "export default createRoute()" to create a Hyperspan route.');
 }
-
-// node_modules/zod/dist/esm/parse.js
-var parse = /* @__PURE__ */ _parse.bind({ Error: ZodError });
-
-// src/server.ts
-var IS_PROD2 = false;
-var CWD = process.cwd();
-function createRoute(handler) {
-  return new HSRoute(handler);
-}
-function createComponent(render2) {
-  return new HSComponent(render2);
-}
-function createForm(renderForm, schema) {
-  return new HSFormRoute(renderForm, schema);
-}
-var HS_DEFAULT_LOADING = () => html`<div>Loading...</div>`;
-
-class HSComponent {
-  _kind = "hsComponent";
-  _handlers = {};
-  _loading;
-  render;
-  constructor(render2) {
-    this.render = render2;
-  }
-  loading(fn) {
-    this._loading = fn;
-    return this;
-  }
-}
-
-class HSRoute {
-  _kind = "hsRoute";
-  _handlers = {};
-  _methods = null;
-  constructor(handler) {
-    this._handlers.GET = handler;
-  }
-}
-
-class HSFormRoute {
-  _kind = "hsFormRoute";
-  _handlers = {};
-  _form;
-  _methods = null;
-  _schema = null;
-  constructor(renderForm, schema = null) {
-    if (schema) {
-      this._form = renderForm;
-      this._schema = schema;
-    } else {
-      this._form = renderForm;
-    }
-    this._handlers.GET = () => renderForm(this.getDefaultData());
-  }
-  getDefaultData() {
-    if (!this._schema) {
-      return {};
-    }
-    const data = parse(this._schema, {});
-    return data;
-  }
-  renderForm(data) {
-    return this._form(data || this.getDefaultData());
-  }
-  get(handler) {
-    this._handlers.GET = handler;
-    return this;
-  }
-  patch(handler) {
-    this._handlers.PATCH = handler;
-    return this;
-  }
-  post(handler) {
-    this._handlers.POST = handler;
-    return this;
-  }
-  put(handler) {
-    this._handlers.PUT = handler;
-    return this;
-  }
-  delete(handler) {
-    this._handlers.DELETE = handler;
-    return this;
-  }
-}
-async function runFileRoute(RouteModule, context) {
-  const req = context.req;
-  const url = new URL(req.url);
-  const qs = url.searchParams;
-  const userIsBot = isbot(context.req.header("User-Agent"));
-  const streamOpt = qs.get("__nostream") ? !Boolean(qs.get("__nostream")) : undefined;
-  const streamingEnabled = !userIsBot && (streamOpt !== undefined ? streamOpt : true);
-  const RouteComponent = RouteModule.default;
-  const reqMethod = req.method.toUpperCase();
-  try {
-    if (RouteModule[reqMethod] !== undefined) {
-      return await runAPIRoute(RouteModule[reqMethod], context);
-    }
-    let routeContent;
-    if (!RouteComponent) {
-      throw new Error("No route was exported by default in matched route file.");
-    }
-    if (typeof RouteComponent._handlers !== "undefined") {
-      const routeMethodHandler = RouteComponent._handlers[reqMethod];
-      if (!routeMethodHandler) {
-        return new Response("Method Not Allowed", {
-          status: 405,
-          headers: { "content-type": "text/plain" }
-        });
-      }
-      routeContent = await routeMethodHandler(context);
-    } else {
-      routeContent = await RouteComponent(context);
-    }
-    if (routeContent instanceof Response) {
-      return routeContent;
-    }
-    let routeKind = typeof routeContent;
-    if (routeKind === "object" && (routeContent instanceof TmplHtml || routeContent.constructor.name === "TmplHtml" || routeContent?._kind === "TmplHtml")) {
-      if (streamingEnabled) {
-        return new StreamResponse(renderStream(routeContent));
-      } else {
-        const output = await renderAsync(routeContent);
-        return context.html(output);
-      }
-    }
-    console.log("Returning unknown type... ", routeContent);
-    return routeContent;
-  } catch (e) {
-    console.error(e);
-    return await showErrorReponse(context, e);
-  }
-}
-async function runAPIRoute(routeFn, context, middlewareResult) {
-  try {
-    return await routeFn(context, middlewareResult);
-  } catch (err) {
-    const e = err;
-    console.error(e);
-    return context.json({
-      meta: { success: false },
-      data: {
-        message: e.message,
-        stack: IS_PROD2 ? undefined : e.stack?.split(`
-`)
-      }
-    }, { status: 500 });
-  }
+function isRouteRunnable(route) {
+  return typeof route === "object" && "run" in route;
 }
 async function showErrorReponse(context, err) {
   const output = render(html`
     <main>
       <h1>Error</h1>
       <pre>${err.message}</pre>
-      <pre>${!IS_PROD2 && err.stack ? err.stack.split(`
+      <pre>${!IS_PROD && err.stack ? err.stack.split(`
 `).slice(1).join(`
 `) : ""}</pre>
     </main>
@@ -2351,10 +1961,10 @@ async function showErrorReponse(context, err) {
   });
 }
 var ROUTE_SEGMENT = /(\[[a-zA-Z_\.]+\])/g;
-async function buildRoutes(config2) {
-  const routesDir = join(config2.appDir, "routes");
+async function buildRoutes(config) {
+  const routesDir = join(config.appDir, "routes");
   console.log(routesDir);
-  const files = await readdir2(routesDir, { recursive: true });
+  const files = await readdir(routesDir, { recursive: true });
   const routes = [];
   for (const file of files) {
     if (!file.includes(".") || basename(file).startsWith(".")) {
@@ -2387,11 +1997,27 @@ async function buildRoutes(config2) {
   }
   return routes;
 }
-async function createServer(config2) {
+function createRouteFromModule(RouteModule) {
+  return async (context) => {
+    const reqMethod = context.req.method.toUpperCase();
+    try {
+      const runnableRoute = getRunnableRoute(RouteModule);
+      const content = await runnableRoute.run(reqMethod, context);
+      if (content instanceof Response) {
+        return content;
+      }
+      return context.text(String(content));
+    } catch (e) {
+      console.error(e);
+      return await showErrorReponse(context, e);
+    }
+  };
+}
+async function createServer(config) {
   await Promise.all([buildClientJS(), buildClientCSS()]);
   const app = new Hono2;
-  config2.beforeRoutesAdded && config2.beforeRoutesAdded(app);
-  const fileRoutes = await buildRoutes(config2);
+  config.beforeRoutesAdded && config.beforeRoutesAdded(app);
+  const fileRoutes = await buildRoutes(config);
   const routeMap = [];
   for (let i = 0;i < fileRoutes.length; i++) {
     let route = fileRoutes[i];
@@ -2399,26 +2025,23 @@ async function createServer(config2) {
     const routePattern = normalizePath(route.route);
     routeMap.push({ route: routePattern, file: route.file });
     const routeModule = await import(fullRouteFile);
-    app.all(routePattern, async (context) => {
-      const matchedRoute = await runFileRoute(routeModule, context);
-      if (matchedRoute) {
-        return matchedRoute;
-      }
-      return context.notFound();
-    });
+    app.all(routePattern, createRouteFromModule(routeModule));
   }
   if (routeMap.length === 0) {
     app.get("/", (context) => {
       return context.text("No routes found. Add routes to app/routes. Example: `app/routes/index.ts`", { status: 404 });
     });
   }
-  if (!IS_PROD2) {
+  if (!IS_PROD) {
     console.log("[Hyperspan] File system routes (in app/routes):");
     console.table(routeMap);
   }
-  config2.afterRoutesAdded && config2.afterRoutesAdded(app);
+  config.afterRoutesAdded && config.afterRoutesAdded(app);
   app.use("*", serveStatic2({
-    root: config2.staticFileRoot
+    root: config.staticFileRoot,
+    onFound: IS_PROD ? (_, c) => {
+      c.header("Cache-Control", "public, max-age=2592000");
+    } : undefined
   }));
   app.notFound((context) => {
     return context.text("Not... found?", { status: 404 });
@@ -2433,8 +2056,9 @@ class StreamResponse extends Response {
     return new Response(stream, {
       status: 200,
       headers: {
-        "Content-Type": "text/html",
         "Transfer-Encoding": "chunked",
+        "Content-Type": "text/html; charset=UTF-8",
+        "Content-Encoding": "Identity",
         ...options?.headers ?? {}
       },
       ...options
@@ -2460,18 +2084,15 @@ function normalizePath(urlPath) {
   return (urlPath.endsWith("/") ? urlPath.substring(0, urlPath.length - 1) : urlPath).toLowerCase() || "/";
 }
 export {
-  runFileRoute,
   normalizePath,
+  isRouteRunnable,
+  getRunnableRoute,
   createServer,
+  createRouteFromModule,
   createRoute,
   createReadableStreamFromAsyncGenerator,
-  createForm,
-  createComponent,
+  createAPIRoute,
   buildRoutes,
   StreamResponse,
-  IS_PROD2 as IS_PROD,
-  HS_DEFAULT_LOADING,
-  HSRoute,
-  HSFormRoute,
-  HSComponent
+  IS_PROD
 };