primate 0.20.4 → 0.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.20.4",
+  "version": "0.21.0",
   "description": "Expressive, minimal and extensible web framework",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",
@@ -18,7 +18,7 @@
     "directory": "packages/primate"
   },
   "dependencies": {
-    "runtime-compat": "^0.21.0"
+    "runtime-compat": "^0.24.1"
   },
   "engines": {
     "node": ">=18.16"

package/src/Logger.js

@@ -1,6 +1,7 @@
 import {assert, is} from "runtime-compat/dyndef";
 import {blue, bold, green, red, yellow, dim} from "runtime-compat/colors";
 import {map} from "runtime-compat/object";
+import console from "runtime-compat/console";
 
 const levels = {
   Error: 0,

package/src/app.js

@@ -15,10 +15,14 @@ const base = new Path(import.meta.url).up(1);
 const packager = import.meta.runtime?.packager ?? "package.json";
 const library = import.meta.runtime?.library ?? "node_modules";
 
+const fallback = (app, page) =>
+  tryreturn(_ => base.join("defaults", page).text())
+    .orelse(_ => base.join("defaults", app.config.pages.index).text());
+
 // use user-provided file or fall back to default
-const index = (app, name) =>
+const index = (app, page) =>
   tryreturn(_ => File.read(`${app.paths.pages.join(name)}`))
-    .orelse(_ => base.join("defaults", app.config.index).text());
+    .orelse(_ => fallback(app, page));
 
 const encoder = new TextEncoder();
 const hash = async (string, algorithm = "sha-384") => {
@@ -39,8 +43,6 @@ export default async (config, root, log) => {
   const secure = http?.ssl !== undefined;
   const {name, version} = await base.up(1).join(packager).json();
   const paths = valmap(config.paths, value => root.join(value));
-  paths.client = paths.build.join("client");
-  paths.server = paths.build.join("server");
 
   const at = `at http${secure ? "s" : ""}://${http.host}:${http.port}\n`;
   print(blue(bold(name)), blue(version), at);
@@ -54,6 +56,13 @@ export default async (config, root, log) => {
   const types = await loaders.types(log, paths.types);
 
   const app = {
+    build: {
+      paths: {
+        client: paths.build.join("client"),
+        server: paths.build.join("server"),
+        components: paths.build.join("components"),
+      },
+    },
     config,
     secure,
     name,
@@ -73,7 +82,7 @@ export default async (config, root, log) => {
         await to.file.write(file);
       }));
     },
-    headers: _ => {
+    headers() {
       const csp = Object.keys(http.csp).reduce((policy_string, key) =>
         `${policy_string}${key} ${http.csp[key]};`, "")
         .replace("script-src 'self'", `script-src 'self' ${
@@ -93,8 +102,8 @@ export default async (config, root, log) => {
       };
     },
     handlers: {...handlers},
-    render: async ({body = "", page} = {}) => {
-      const html = await index(app, page ?? config.index);
+    async render({body = "", page} = {}) {
+      const html = await index(app, page ?? config.pages.index);
       // inline: <script type integrity>...</script>
       // outline: <script type integrity src></script>
       const script = ({inline, code, type, integrity, src}) => inline
@@ -105,7 +114,7 @@ export default async (config, root, log) => {
       const style = ({inline, code, href, rel = "stylesheet"}) => inline
         ? tag({name: "style", code})
         : tag({name: "link", attributes: {rel, href}, close: false});
-      const head = toSorted(app.assets,
+      const head = toSorted(this.assets,
         ({type}) => -1 * (type === "importmap"))
         .map(({src, code, type, inline, integrity}) =>
           type === "style"
@@ -113,39 +122,43 @@ export default async (config, root, log) => {
             : script({inline, code, type, integrity, src})
         ).join("\n");
       // remove inline assets
-      app.assets = app.assets.filter(({inline, type}) => !inline
+      this.assets = this.assets.filter(({inline, type}) => !inline
         || type === "importmap");
       return html.replace("%body%", _ => body).replace("%head%", _ => head);
     },
-    publish: async ({src, code, type = "", inline = false}) => {
+    async publish({src, code, type = "", inline = false}) {
       if (!inline) {
-        const base = paths.client.join(src);
+        const base = this.build.paths.client.join(src);
         await base.directory.file.create();
         await base.file.write(code);
       }
       if (inline || type === "style") {
-        app.assets.push({src: new Path(http.static.root).join(src ?? "").path,
+        this.assets.push({src: new Path(http.static.root).join(src ?? "").path,
           code: inline ? code : "", type, inline, integrity: await hash(code)});
       }
     },
-    bootstrap: ({type, code}) => {
-      app.entrypoints.push({type, code});
+    bootstrap({type, code}) {
+      this.entrypoints.push({type, code});
     },
     async import(module) {
       const {build} = config;
       const {root} = http.static;
-      const path = [library, module];
+      const path = [library, ...module.split("/")];
       const pkg = await Path.resolve().join(...path, packager).json();
       const exports = pkg.exports === undefined
         ? {[module]: `/${module}/${pkg.main}`}
         : transform(pkg.exports, entry => entry
-          .filter(([, _export]) => _export.import !== undefined || _export.default !== undefined)
+          .filter(([, _export]) => _export.browser?.default !== undefined
+            || _export.import !== undefined
+            || _export.default !== undefined)
           .map(([key, value]) => [
             key.replace(".", module),
-            value.import?.replace(".", `./${module}`) ?? value.default.replace(".", `./${module}`),
+            value.browser?.default.replace(".", `./${module}`)
+              ?? value.default?.replace(".", `./${module}`)
+              ?? value.import?.replace(".", `./${module}`),
           ]));
       const dependency = Path.resolve().join(...path);
-      const to = new Path(paths.client, build.modules, dependency.name);
+      const to = new Path(this.build.paths.client, build.modules, ...module.split("/"));
       await dependency.file.copy(to);
       this.importmaps = {
         ...valmap(exports, value => new Path(root, build.modules, value).path),

package/src/commands/exports.js

@@ -1,8 +1,4 @@
 import {default as dev} from "./dev.js";
 import {default as serve} from "./serve.js";
 
-const commands = {dev, serve};
-
-const run = name => commands[name] ?? dev;
-
-export default name => name === undefined ? dev : run(name);
+export default name => ({dev, serve})[name] ?? dev;

package/src/defaults/primate.config.js

@@ -2,6 +2,11 @@ import Logger from "../Logger.js";
 
 export default {
   base: "/",
+  modules: [],
+  pages: {
+    index: "app.html",
+    error: "error.html",
+  },
   logger: {
     level: Logger.Warn,
     trace: false,
@@ -22,7 +27,6 @@ export default {
       root: "/",
     },
   },
-  index: "app.html",
   paths: {
     build: "build",
     components: "components",
@@ -38,7 +42,6 @@ export default {
     modules: "modules",
     index: "index.js",
   },
-  modules: [],
   types: {
     explicit: false,
   },

package/src/dispatch.js

@@ -1,19 +1,22 @@
 import {is, maybe} from "runtime-compat/dyndef";
 import {tryreturn} from "runtime-compat/sync";
 import {map} from "runtime-compat/object";
+import {camelcased} from "runtime-compat/string";
 import errors from "./errors.js";
+import validate from "./validate.js";
 
-export default (patches = {}) => value => {
-  is(patches.get).undefined();
+export default (patches = {}) => (value, raw, cased = true) => {
   return Object.assign(Object.create(null), {
-    ...map(patches, ([name, patch]) => [name, property => {
+    ...map(patches, ([name, patch]) => [`get${camelcased(name)}`, property => {
       is(property).defined(`\`${name}\` called without property`);
-      return tryreturn(_ => patch(value[property], property))
+      return tryreturn(_ => validate(patch, value[property], property))
         .orelse(({message}) => errors.MismatchedType.throw(message));
     }]),
     get(property) {
       maybe(property).string();
-      return property === undefined ? value : value[property];
+      return property === undefined ? value :
+        value[cased ? property : property.toLowerCase()];
     },
+    raw,
   });
 };

package/src/errors.json

@@ -32,7 +32,7 @@
       "level": "Warn"
     },
     "ErrorInConfigFile": {
-      "message": "error in config file :: {0}",
+      "message": "error in config file: {0}",
       "fix": "check errors in config file by running {1}",
       "level": "Error"
     },
@@ -57,12 +57,12 @@
       "level": "Error"
     },
     "MismatchedPath": {
-      "message": "mismatched {0} path :: {1}",
+      "message": "mismatched path {0}: {1}",
       "fix": "if unintentional, fix the type or the caller",
       "level": "Info"
     },
     "MismatchedType": {
-      "message": "mismatched type :: {0}",
+      "message": "mismatched type: {0}",
       "fix": "if unintentional, fix the type or the caller",
       "level": "Info"
     },
@@ -98,7 +98,7 @@
     },
     "NoRouteToPath": {
       "message": "no {0} route to {1}",
-      "fix": "if unintentional create a route at {2}.js",
+      "fix": "if unintentional create a {3} route function at {2}.js",
       "level": "Info"
     },
     "ReservedTypeName": {

package/src/exports.js

@@ -4,6 +4,6 @@ export * from "./handlers/exports.js";
 
 export {default as Logger} from "./Logger.js";
 
-export {URL, Response, Status} from "runtime-compat/http";
+export {URL, Response, Status, MediaType} from "runtime-compat/http";
 
 export default command => run(command);

package/src/handlers/error.js

@@ -1,9 +1,9 @@
-import {Status} from "runtime-compat/http";
+import {Response, Status, MediaType} from "runtime-compat/http";
 
-export default (body = "Not Found", {status = Status.NotFound} = {}) =>
-  async app => [
-    await app.render({body}), {
+export default (body = "Not Found", {status = Status.NOT_FOUND, page} = {}) =>
+  async app => new Response(await app.render({
+    body,
+    page: page ?? app.config.pages.error}), {
       status,
-      headers: {...app.headers(), "Content-Type": "text/html"},
-    },
-  ];
+      headers: {...app.headers(), "Content-Type": MediaType.TEXT_HTML},
+    });

package/src/handlers/html.js

@@ -1,3 +1,5 @@
+import {Response, Status, MediaType} from "runtime-compat/http";
+
 const script = /(?<=<script)>(?<code>.*?)(?=<\/script>)/gus;
 const style = /(?<=<style)>(?<code>.*?)(?=<\/style>)/gus;
 
@@ -10,7 +12,7 @@ const integrate = async (html, publish) => {
 };
 
 export default (component, options = {}) => {
-  const {status = 200, partial = false, load = false} = options;
+  const {status = Status.OK, partial = false, load = false} = options;
 
   return async app => {
     const body = await integrate(await load ?
@@ -19,9 +21,9 @@ export default (component, options = {}) => {
     // needs to happen before app.render()
     const headers = app.headers();
 
-    return [partial ? body : await app.render({body}), {
+    return new Response(partial ? body : await app.render({body}), {
       status,
-      headers: {...headers, "Content-Type": "text/html"},
-    }];
+      headers: {...headers, "Content-Type": MediaType.TEXT_HTML},
+    });
   };
 };

package/src/handlers/json.js

@@ -1,6 +1,7 @@
-export default (body, {status = 200} = {}) => app => [
-  JSON.stringify(body), {
+import {Response, Status, MediaType} from "runtime-compat/http";
+
+export default (body, {status = Status.OK} = {}) => app =>
+  new Response(JSON.stringify(body), {
     status,
-    headers: {...app.headers(), "Content-Type": "application/json"},
-  },
-];
+    headers: {...app.headers(), "Content-Type": MediaType.APPLICATION_JSON},
+  });

package/src/handlers/redirect.js

@@ -1,9 +1,8 @@
-import {Status} from "runtime-compat/http";
+import {Response, Status} from "runtime-compat/http";
 
-export default (Location, {status = Status.Found} = {}) => app => [
+export default (Location, {status = Status.FOUND} = {}) => app =>
   /* no body */
-  null, {
+  new Response(null, {
     status,
     headers: {...app.headers(), Location},
-  },
-];
+  });

package/src/handlers/stream.js

@@ -1,6 +1,8 @@
-export default (body, {status = 200} = {}) => app => [
-  body, {
+import {Response, Status, MediaType} from "runtime-compat/http";
+
+export default (body, {status = Status.OK} = {}) => app =>
+  new Response(body, {
     status,
-    headers: {...app.headers(), "Content-Type": "application/octet-stream"},
-  },
-];
+    headers: {...app.headers(), "Content-Type":
+      MediaType.APPLICATION_OCTET_STREAM},
+  });

package/src/handlers/text.js

@@ -1,6 +1,7 @@
-export default (body, {status = 200} = {}) => app => [
-  body, {
+import {Response, Status, MediaType} from "runtime-compat/http";
+
+export default (body, {status = Status.OK} = {}) => app =>
+  new Response(body, {
     status,
-    headers: {...app.headers(), "Content-Type": "text/plain"},
-  },
-];
+    headers: {...app.headers(), "Content-Type": MediaType.TEXT_PLAIN},
+  });

package/src/handlers/view.js

@@ -1,4 +1,4 @@
-import errors from "../errors.js";
+ import errors from "../errors.js";
 
 export default (name, props, options) => async (app, ...rest) => {
   const ending = name.slice(name.lastIndexOf(".") + 1);

package/src/hooks/bundle.js

@@ -1,10 +1,10 @@
 import {File} from "runtime-compat/fs";
 
 const pre = async app => {
-  const {paths, config} = app;
+  const {paths, config, build} = app;
   if (await paths.static.exists) {
-    // copy static files to build/client/_static
-    await File.copy(paths.static, paths.client.join(config.build.static));
+    // copy static files to build/client/static
+    await File.copy(paths.static, build.paths.client.join(config.build.static));
   }
 };
 

package/src/hooks/compile.js

@@ -1,16 +1,20 @@
 import copy_includes from "./copy_includes.js";
 
 const pre = async app => {
-  const {paths, config: {build}} = app;
+  const {build, paths, config} = app;
 
   // remove build directory in case exists
   if (await paths.build.exists) {
     await paths.build.file.remove();
   }
-  await paths.server.file.create();
+  await build.paths.server.file.create();
+  await build.paths.components.file.create();
 
   if (await paths.components.exists) {
-    await app.copy(paths.components, paths.server.join(build.app));
+    // copy all files to build/components
+    await app.copy(paths.components, build.paths.components, /^.*$/u);
+    // copy .js files from components to build/server
+    await app.copy(paths.components, build.paths.server.join(config.build.app));
   }
 
   // copy additional subdirectories to build/server

package/src/hooks/copy_includes.js

@@ -1,7 +1,7 @@
 const system = ["routes", "components", "build"];
 
 export default async (app, type, post = () => undefined) => {
-  const {paths, config} = app;
+  const {config} = app;
   const {build} = config;
   const {includes} = build;
 
@@ -14,7 +14,7 @@ export default async (app, type, post = () => undefined) => {
       .map(async include => {
         const path = app.root.join(include);
         if (await path.exists) {
-          const to = paths[type].join(include);
+          const to = app.build.paths[type].join(include);
           await to.file.create();
           await app.copy(path, to);
           await post(to);

package/src/hooks/handle.js

@@ -1,63 +1,65 @@
-import {Response, Status} from "runtime-compat/http";
+import {Response, Status, MediaType} from "runtime-compat/http";
 import {tryreturn} from "runtime-compat/async";
-import {mime, isResponse, respond} from "./respond/exports.js";
+import {respond} from "./respond/exports.js";
 import {invalid} from "./route.js";
 import {error as clientError} from "../handlers/exports.js";
-import errors from "../errors.js";
+import _errors from "../errors.js";
+const {NoFileForPath} = _errors;
 
 const guardError = Symbol("guardError");
 
 export default app => {
   const {config: {http: {static: {root}}, build}, paths} = app;
 
-  const run = async request => {
+  const route = async request => {
     const {pathname} = request.url;
-    const {path, guards, layouts, handler} = invalid(pathname)
-      ? errors.NoFileForPath.throw(pathname, paths.static)
-      : await app.route(request);
+    // if NoFileForPath is thrown, this will remain undefined
+    let errorHandler = undefined;
 
-    // handle guards
-    try {
-      guards.every(guard => {
-        const result = guard(request);
-        if (result === true) {
-          return true;
+    return tryreturn(async _ => {
+      const {path, guards, errors, layouts, handler} = invalid(pathname)
+        ? NoFileForPath.throw(pathname, paths.static)
+        : await app.route(request);
+      errorHandler = errors?.at(-1);
+
+      // handle guards
+      try {
+        guards.every(guard => {
+          const result = guard(request);
+          if (result === true) {
+            return true;
+          }
+          const error = new Error();
+          error.result = result;
+          error.type = guardError;
+          throw error;
+        });
+      } catch (error) {
+        if (error.type === guardError) {
+          return (await respond(error.result))(app);
         }
-        const error = new Error();
-        error.result = result;
-        error.type = guardError;
+        // rethrow if not guard error
         throw error;
-      });
-    } catch (error) {
-      if (error.type === guardError) {
-        return (await respond(error.result))(app);
       }
-      // rethrow if not guard error
-      throw error;
-    }
 
-    // handle request
-    const handlers = [...app.modules.route, handler]
-      .reduceRight((next, last) => input => last(input, next));
-
-    return (await respond(await handlers({...request, path})))(app, {
-      layouts: await Promise.all(layouts.map(layout => layout(request))),
-    });
-  };
-
-  const route = async request =>
-    tryreturn(async _ => {
-      const response = await run(request);
-      return isResponse(response) ? response : new Response(...response);
+      // handle request
+      const handlers = [...app.modules.route, handler]
+        .reduceRight((next, last) => input => last(input, next));
+      return (await respond(await handlers({...request, path})))(app, {
+        layouts: await Promise.all(layouts.map(layout => layout(request))),
+      }, request);
     }).orelse(async error => {
       app.log.auto(error);
-      return new Response(...await clientError()(app, {}));
+      // the +error.js page itself could fail
+      return tryreturn(_ => respond(errorHandler())(app, {}, request))
+        .orelse(_ => clientError()(app, {}, request));
     });
+  };
 
   const asset = async file => new Response(file.readable, {
     status: Status.OK,
     headers: {
-      "Content-Type": mime(file.name),
+      "Content-Type": MediaType.resolve(file.name),
       Etag: await file.modified,
     },
   });
@@ -66,12 +68,13 @@ export default app => {
     const {pathname} = request.url;
     if (pathname.startsWith(root)) {
       const debased = pathname.replace(root, _ => "");
+      const {client} = app.build.paths;
       // try static first
-      const _static = paths.client.join(build.static, debased);
+      const _static = client.join(build.static, debased);
       if (await _static.isFile) {
         return asset(_static.file);
       }
-      const _app = app.paths.client.join(debased);
+      const _app = client.join(debased);
       return await _app.isFile ? asset(_app.file) : route(request);
     }
     return route(request);

package/src/hooks/parse.js

@@ -1,38 +1,35 @@
-import {URL} from "runtime-compat/http";
+import {URL, MediaType} from "runtime-compat/http";
 import {tryreturn} from "runtime-compat/sync";
 import {stringify} from "runtime-compat/streams";
+import {from, valmap} from "runtime-compat/object";
 import errors from "../errors.js";
 
-const {fromEntries: from} = Object;
+const {APPLICATION_FORM_URLENCODED, APPLICATION_JSON} = MediaType;
 
 const contents = {
-  "application/x-www-form-urlencoded": body => from(body.split("&")
+  [APPLICATION_FORM_URLENCODED]: body => from(body.split("&")
     .map(part => part.split("=")
       .map(subpart => decodeURIComponent(subpart).replaceAll("+", " ")))),
-  "application/json": body => JSON.parse(body),
+  [APPLICATION_JSON]: body => JSON.parse(body),
 };
 
-const parse = {
-  content(content_type, body) {
-    return tryreturn(_ => {
-      const type = contents[content_type];
-      return type === undefined ? body : type(body);
-    }).orelse(_ => errors.CannotParseBody.throw(body, content_type));
-  },
-  async body({body, headers}) {
-    return body === null
-      ? null
-      : this.content(headers.get("content-type"), await stringify(body));
-  },
-};
+const content = (type, body) =>
+  tryreturn(_ => contents[type?.split(";")[0]]?.(body) ?? body)
+    .orelse(_ => errors.CannotParseBody.throw(body, type));
 
-export default dispatch => async request => {
-  const body = dispatch(await parse.body(request));
-  const cookies = dispatch(from(request.headers.get("cookie")?.split(";")
-    .map(cookie => cookie.trim().split("=")) ?? []));
-  const headers = dispatch(from(request.headers));
-  const url = new URL(request.url);
-  const query = dispatch(from(url.searchParams));
+export default dispatch => async original => {
+  const {headers} = original;
+  const url = new URL(original.url);
+  const body = await stringify(original.body);
+  const cookies = headers.get("cookie");
 
-  return {original: request, url, body, cookies, headers, query};
+  return {original, url,
+    ...valmap({
+      body: [content(headers.get("content-type"), body), body],
+      query: [from(url.searchParams), url.search],
+      headers: [from(headers), headers, false],
+      cookies: [from(cookies?.split(";").map(cookie => cookie.trim().split("="))
+        ?? []), cookies],
+    }, value => dispatch(...value)),
+  };
 };

package/src/hooks/publish.js

@@ -1,9 +1,9 @@
 import {Path} from "runtime-compat/fs";
 import {identity} from "runtime-compat/function";
-import copy_includes from "./copy_includes.js"
+import copy_includes from "./copy_includes.js";
 
 const post = async app => {
-  const {config} = app;
+  const {config, paths} = app;
   const build = config.build.app;
   {
     // after hook, publish a zero assumptions app.js (no css imports)
@@ -12,7 +12,10 @@ const post = async app => {
     const src = new Path(config.http.static.root, build, config.build.index);
     await app.publish({src, code, type: "module"});
 
-    await app.copy(app.paths.components, app.paths.client.join(build));
+    if (await paths.components.exists) {
+      // copy .js files from components to build/server
+      await app.copy(app.paths.components, app.build.paths.client.join(build));
+    }
 
     const imports = {...app.importmaps, app: src.path};
     await app.publish({
@@ -36,7 +39,7 @@ const post = async app => {
     }
   }));
 
-  const source = `${app.paths.client}`;
+  const source = `${app.build.paths.client}`;
   const {root} = app.config.http.static;
   // copy additional subdirectories to build/client
   await copy_includes(app, "client", async to =>

package/src/hooks/respond/exports.js

@@ -1,3 +1,2 @@
-export {default as mime} from "./mime.js";
 export {isResponse} from "./duck.js";
 export {default as respond} from "./respond.js";

package/src/hooks/route.js

@@ -1,6 +1,7 @@
 import {keymap} from "runtime-compat/object";
 import {tryreturn} from "runtime-compat/sync";
 import errors from "../errors.js";
+import validate from "../validate.js";
 
 // insensitive-case equal
 const ieq = (left, right) => left.toLowerCase() === right.toLowerCase();
@@ -18,9 +19,8 @@ export default app => {
     .filter(([name]) => name.includes("$"))
     .map(([name, value]) => [name.split("$")[1], value])
     .every(([name, value]) =>
-      tryreturn(_ => types?.[name].type(value) === true)
-        .orelse(({message}) => errors.MismatchedPath.throw(pathname, message))
-    );
+      tryreturn(_ => validate(types[name], value, name))
+        .orelse(({message}) => errors.MismatchedPath.throw(pathname, message)));
   const isPath = ({route, pathname}) => {
     const result = route.pathname.exec(pathname);
     return result === null ? false : isType(result.groups, pathname);
@@ -34,11 +34,10 @@ export default app => {
   const deroot = pathname => pathname.endsWith("/") && pathname !== "/"
     ? pathname.slice(0, -1) : pathname;
 
-  return request => {
-    const {original: {method}, url} = request;
+  return ({original: {method}, url}) => {
     const pathname = deroot(url.pathname);
-    const route = find(method, pathname) ??
-      errors.NoRouteToPath.throw(method, pathname, index(pathname));
+    const route = find(method, pathname) ?? errors.NoRouteToPath
+      .throw(method, pathname, index(pathname), method.toLowerCase());
 
     const path = app.dispatch(keymap(route.pathname?.exec(pathname).groups,
       key => key.split("$")[0]));

package/src/loaders/routes/errors.js

@@ -0,0 +1,3 @@
+import load from "./load.js";
+
+export default load("error");

package/src/loaders/routes/exports.js

@@ -1,3 +1,4 @@
 export {default as routes} from "./routes.js";
 export {default as guards} from "./guards.js";
+export {default as errors} from "./errors.js";
 export {default as layouts} from "./layouts.js";

package/src/loaders/routes.js

@@ -1,4 +1,5 @@
 import {tryreturn} from "runtime-compat/sync";
+import {from, filter, valmap} from "runtime-compat/object";
 import errors from "../errors.js";
 import {invalid} from "../hooks/route.js";
 import {default as fs, doubled} from "./common.js";
@@ -22,10 +23,11 @@ const make = path => {
   return new RegExp(`^/${route}$`, "u");
 };
 
+const specials = ["guards", "errors", "layouts"];
 export default async (log, directory, load = fs) => {
   const routes = await get.routes(log, directory, load);
-  const guards = await get.guards(log, directory, load);
-  const layouts = await get.layouts(log, directory, load);
+  const $routes = from(await Promise.all(specials.map(async extra =>
+    [extra, await get[extra](log, directory, load)])));
   const filter = path => ([name]) => path.includes(name);
 
   return routes.map(([path, imported]) => {
@@ -38,8 +40,9 @@ export default async (log, directory, load = fs) => {
       method,
       handler,
       pathname: make(path.endsWith("/") ? path.slice(0, -1) : path),
-      guards: guards.filter(filter(path)).map(([, guard]) => guard),
-      layouts: layouts.filter(filter(path)).map(([, layout]) => layout),
+      guards: $routes.guards.filter(filter(path)).map(([, guard]) => guard),
+      errors: $routes.errors.filter(filter(path)).map(([, error]) => error),
+      layouts: $routes.layouts.filter(filter(path)).map(([, layout]) => layout),
     }));
   }).flat();
 };

package/src/start.js

@@ -21,7 +21,7 @@ export default async (app, operations = {}) => {
     tryreturn(async _ => hooks.handle(app)(await app.parse(request)))
       .orelse(error => {
         app.log.auto(error);
-        return new Response(null, {status: Status.InternalServerError});
+        return new Response(null, {status: Status.INTERNAL_SERVER_ERROR});
       }),
   app.config.http);
 

package/src/validate.js

@@ -0,0 +1,10 @@
+import {is, maybe} from "runtime-compat/dyndef";
+
+export default (type, value, name) => {
+  maybe(type.validate).function();
+  if (type.validate) {
+    return type.validate(value, name);
+  }
+  is(type).function();
+  return type(value, name);
+};

package/src/hooks/respond/mime.js

@@ -1,18 +0,0 @@
-const mimes = {
-  binary: "application/octet-stream",
-  css: "text/css",
-  html: "text/html",
-  jpg: "image/jpeg",
-  js: "text/javascript",
-  mjs: "text/javascript",
-  json: "application/json",
-  png: "image/png",
-  svg: "image/svg+xml",
-  woff2: "font/woff2",
-  webp: "image/webp",
-};
-
-const regex = /\.(?<extension>[a-z1-9]*)$/u;
-const match = filename => filename.match(regex)?.groups.extension;
-
-export default filename => mimes[match(filename)] ?? mimes.binary;