primate 0.18.0 → 0.19.0

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "primate",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "Expressive, minimal and extensible web framework",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",
   "license": "MIT",
   "files": [
-    "src/**",
+    "src/**/*.js",
+    "src/defaults/index.html",
     "!src/**/*.spec.js"
   ],
   "bin": "src/bin.js",

package/src/Logger.js

@@ -80,10 +80,7 @@ const Logger = class Logger {
       print(blue("++"), fix);
       name && print(dim(`\n   -> ${reference}/${module ?? "primate"}#${hyphenate(name)}`), "\n");
     }
-    if (this.#trace && error) {
-      print(pre, color(module), "trace follows\n");
-      console.log(error);
-    }
+    this.#trace && error && console.log(error);
   }
 
   get level() {

package/src/app.js

@@ -4,6 +4,7 @@ import {bold, blue} from "runtime-compat/colors";
 import errors from "./errors.js";
 import * as handlers from "./handlers/exports.js";
 import * as hooks from "./hooks/exports.js";
+import dispatch from "./dispatch.js";
 
 const qualify = (root, paths) =>
   Object.keys(paths).reduce((sofar, key) => {
@@ -14,16 +15,17 @@ const qualify = (root, paths) =>
     return sofar;
   }, {});
 
-const src = new Path(import.meta.url).up(1);
+const base = new Path(import.meta.url).up(1);
+const defaultLayout = "index.html";
 
-const index = async app => {
-  const name = "index.html";
+const index = async (app, layout = defaultLayout) => {
+  const name = layout;
   try {
     // user-provided file
-    return await File.read(`${app.paths.static.join(name)}`);
+    return await File.read(`${app.paths.layouts.join(name)}`);
   } catch (error) {
     // fallback
-    return src.join("defaults", name).text();
+    return base.join("defaults", defaultLayout).text();
   }
 };
 
@@ -34,6 +36,13 @@ const hash = async (string, algorithm = "sha-384") => {
   return `${algo}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
 };
 
+const attribute = attributes => Object.keys(attributes).length > 0 ?
+  " ".concat(Object.entries(attributes)
+    .map(([key, value]) => `${key}="${value}"`).join(" "))
+  : "";
+const tag = ({name, attributes = {}, code = "", close = true}) =>
+  `<${name}${attribute(attributes)}${close ? `>${code}</${name}>` : "/>"}`;
+
 export default async (config, root, log) => {
   const {http} = config;
 
@@ -52,6 +61,17 @@ export default async (config, root, log) => {
         `${route}`.replace(paths.routes, "").slice(1, -ending.length),
         (await import(route)).default,
       ]));
+  const types = Object.fromEntries(
+    paths.types === undefined ? [] : await Promise.all(
+      (await Path.collect(paths.types , /^.*.js$/u))
+        /* accept only lowercase-first files in type filename */
+        .filter(path => /^[a-z]/u.test(path.name))
+        .map(async type => [
+          `${type}`.replace(paths.types, "").slice(1, -ending.length),
+          (await import(type)).default,
+        ])));
+  Object.entries(types).some(([name, type]) =>
+    typeof type !== "function" && errors.InvalidType.throw({name}));
 
   const modules = config.modules === undefined ? [] : config.modules;
 
@@ -68,7 +88,7 @@ export default async (config, root, log) => {
     !Object.keys(module).some(key => Object.keys(hooks).includes(key)));
   hookless.length > 0 && errors.ModuleHasNoHooks.warn(log, {hookless});
 
-  const {name, version} = await src.up(1).join("package.json").json();
+  const {name, version} = await base.up(1).join("package.json").json();
 
   const app = {
     config,
@@ -97,6 +117,7 @@ export default async (config, root, log) => {
       const csp = Object.keys(http.csp).reduce((policy_string, key) =>
         `${policy_string}${key} ${http.csp[key]};`, "");
       const scripts = app.resources
+        .filter(({type}) => type !== "style")
         .map(resource => `'${resource.integrity}'`).join(" ");
       const _csp = scripts === "" ? csp : `${csp}script-src 'self' ${scripts};`;
       // remove inline resources
@@ -113,19 +134,23 @@ export default async (config, root, log) => {
       };
     },
     handlers: {...handlers},
-    render: async ({body = "", head = ""} = {}) => {
-      const html = await index(app);
-      const heads = app.resources.map(({src, code, type, inline, integrity}) => {
-        const tag = type === "style" ? "link" : "script";
-        const pre = type === "style"
-          ? `<${tag} rel="stylesheet"`
-          : `<${tag} type="${type}" integrity="${integrity}"`;
-        const middle = type === "style"
-          ? ` href="${src}">`
-          : ` src="${src}">`;
-        const post = type === "style" ? "" : `</${tag}>`;
-        return inline ? `${pre}>${code}${post}` : `${pre}${middle}${post}`;
-      }).join("\n");
+    render: async ({body = "", head = "", layout} = {}) => {
+      const html = await index(app, layout);
+      // inline: <script type integrity>...</script>
+      // outline: <script type integrity src></script>
+      const script = ({inline, code, type, integrity, src}) => inline
+        ? tag({name: "script", attributes: {type, integrity}, code})
+        : tag({name: "script", attributes: {type, integrity, src}});
+      // inline: <style>...</style>
+      // outline: <link rel="stylesheet" href/>
+      const style = ({inline, code, href, rel = "stylesheet"}) => inline
+        ? tag({name: "style", code})
+        : tag({name: "link", attributes: {rel, href}, close: false});
+      const heads = app.resources.map(({src, code, type, inline, integrity}) =>
+        type === "style"
+          ? style({inline, code, href: src})
+          : script({inline, code, type, integrity, src})
+      ).join("\n");
       return html
         .replace("%body%", () => body)
         .replace("%head%", () => `${head}${heads}`);
@@ -134,8 +159,6 @@ export default async (config, root, log) => {
       if (type === "module") {
         code = app.replace(code);
       }
-      // while integrity is only really needed for scripts, it is also later
-      // used for the etag header
       const integrity = await hash(code);
       const _src = new Path(http.static.root).join(src ?? "");
       app.resources.push({src: `${_src}`, code, type, inline, integrity});
@@ -154,6 +177,7 @@ export default async (config, root, log) => {
       app.identifiers = {...exports, ...app.identifiers};
     },
     modules,
+    types,
   };
   log.class.print(blue(bold(name)), blue(version),
     `at http${app.secure ? "s" : ""}://${http.host}:${http.port}\n`);
@@ -164,5 +188,8 @@ export default async (config, root, log) => {
       app.modules.push(dependent);
     }})));
 
+  app.route = hooks.route({...app, dispatch: dispatch(types)});
+  app.parse = hooks.parse(dispatch(types));
+
   return app;
 };

package/src/defaults/primate.config.js

@@ -10,6 +10,7 @@ export default {
     port: 6161,
     csp: {
       "default-src": "'self'",
+      "style-src": "'self'",
       "object-src": "'none'",
       "frame-ancestors": "'none'",
       "form-action": "'self'",
@@ -21,6 +22,7 @@ export default {
     },
   },
   paths: {
+    layouts: "layouts",
     static: "static",
     public: "public",
     routes: "routes",
@@ -29,4 +31,7 @@ export default {
   },
   modules: [],
   dist: "app",
+  types: {
+    explicit: false,
+  },
 };

package/src/dispatch.js

@@ -0,0 +1,24 @@
+import {is, maybe} from "runtime-compat/dyndef";
+import errors from "./errors.js";
+
+export default (patches = {}) => value => {
+  is(patches.get).undefined();
+  return Object.assign(Object.create(null), {
+    ...Object.fromEntries(Object.entries(patches).map(([name, patch]) =>
+      [name, property => {
+        is(property).defined(`\`${name}\` called without property`);
+        try {
+          return patch(value[property], property);
+        } catch (error) {
+          errors.MismatchedType.throw({message: error.message});
+        }
+      }])),
+    get(property) {
+      maybe(property).string();
+      if (property !== undefined) {
+        return value[property];
+      }
+      return value;
+    },
+  });
+};

package/src/errors.js

@@ -45,9 +45,52 @@ export default Object.fromEntries(Object.entries({
       level: Logger.Error,
     };
   },
+  InvalidPathParameter({named, path}) {
+    return {
+      message: ["invalid path parameter % in route %", named, path],
+      fix: ["use only latin letters and decimal digits in path parameters"],
+      level: Logger.Error,
+    };
+  },
+  InvalidRouteName({path}) {
+    return {
+      message: ["invalid route name %", path],
+      fix: ["do not use dots in route names"],
+      level: Logger.Error,
+    };
+  },
+  InvalidType({name}) {
+    return {
+      message: ["invalid type %", name],
+      fix: ["use only functions for the default export of types"],
+      level: Logger.Error,
+    };
+  },
+  InvalidTypeName({name}) {
+    return {
+      message: ["invalid type name %", name],
+      fix: ["use only latin letters and decimal digits in types"],
+      level: Logger.Error,
+    };
+  },
+  MismatchedPath({path, message}) {
+    return {
+      message: [`mismatched % path: ${message}`, path],
+      fix: ["if unintentional, fix the type or the caller"],
+      level: Logger.Info,
+    };
+  },
+  MismatchedType({message}) {
+    return {
+      message: [`mismatched type: ${message}`],
+      fix: ["if unintentional, fix the type or the caller"],
+      level: Logger.Info,
+    };
+  },
   ModuleHasNoHooks({hookless}) {
+    const modules = hookless.map(({name}) => name).join(", ");
     return {
-      message: ["module % has no hooks", hookless.join(", ")],
+      message: ["module % has no hooks", modules],
       fix: ["ensure every module uses at least one hook or deactivate it"],
       level: Logger.Warn,
     };
@@ -81,31 +124,17 @@ export default Object.fromEntries(Object.entries({
     };
   },
   NoRouteToPath({method, pathname, config: {paths}}) {
-    const route = `${paths.routes}/${pathname === "/" ? "index" : ""}.js`;
+    const route = `${paths.routes}${pathname === "" ? "index" : pathname}.js`;
     return {
       message: ["no % route to %", method, pathname],
       fix: ["if unintentional create a route at %", route],
       level: Logger.Info,
     };
   },
-  InvalidPathParameter({named, path}) {
+  ReservedTypeName({name}) {
     return {
-      message: ["invalid path parameter % in route %", named, path],
-      fix: ["use only latin letters and decimal digits in path parameters"],
-      level: Logger.Error,
-    };
-  },
-  InvalidRouteName({path}) {
-    return {
-      message: ["invalid route name %", path],
-      fix: ["do not use dots in route names"],
-      level: Logger.Error,
-    };
-  },
-  InvalidType({name}) {
-    return {
-      message: ["invalid type %", name],
-      fix: ["use only latin letters and decimal digits in types"],
+      message: ["type name % is reserved", name],
+      fix: ["do not use any reserved type names"],
       level: Logger.Error,
     };
   },

package/src/handlers/html.js

@@ -1,11 +1,33 @@
-export default (component, flags = {}) => {
-  const {status = 200, partial = false, load = false} = flags;
+const script = /(?<=<script)>(?<code>.*?)(?=<\/script>)/gus;
+const style = /(?<=<style)>(?<code>.*?)(?=<\/style>)/gus;
+
+const integrate = async (html, publish, headers) => {
+  const scripts = await Promise.all([...html.matchAll(script)]
+    .map(({groups: {code}}) => publish({code, inline: true})));
+  for (const integrity of scripts) {
+    headers["Content-Security-Policy"] = headers["Content-Security-Policy"]
+      .replace("script-src 'self' ", `script-src 'self' '${integrity}' `);
+  }
+  const styles = await Promise.all([...html.matchAll(style)]
+    .map(({groups: {code}}) => publish({code, type: "style", inline: true})));
+  for (const integrity of styles) {
+    headers["Content-Security-Policy"] = headers["Content-Security-Policy"]
+      .replace("style-src 'self'", `style-src 'self' '${integrity}' `);
+  }
+  return html
+    .replaceAll(/<script>.*?<\/script>/gus, () => "")
+    .replaceAll(/<style>.*?<\/style>/gus, () => "");
+};
+
+export default (component, options = {}) => {
+  const {status = 200, partial = false, load = false, layout} = options;
 
   return async (app, headers) => {
-    const body = load ?
-      await app.paths.components.join(component).text() : component;
+    const body = await integrate(await load ?
+      await app.paths.components.join(component).text() : component,
+    app.publish, headers);
 
-    return [partial ? body : await app.render({body}), {
+    return [partial ? body : await app.render({body, layout}), {
       status,
       headers: {...headers, "Content-Type": "text/html"},
     }];

package/src/hooks/exports.js

@@ -5,3 +5,4 @@ export {default as bundle} from "./bundle.js";
 export {default as route} from "./route.js";
 export {default as handle} from "./handle.js";
 export {default as parse} from "./parse.js";
+export {default as serve} from "./serve.js";

package/src/hooks/handle.js

@@ -11,11 +11,10 @@ export default app => {
   const {http} = app.config;
 
   const _respond = async (request, headers) => {
-    if (invalid(request.url.pathname)) {
-      errors.NoFileForPath.throw({pathname: request.url.pathname, config: app.config});
-      return;
-    }
-    return respond(await app.route(request))(app, headers);
+    const {pathname} = request.url;
+    return invalid(pathname)
+      ? errors.NoFileForPath.throw({pathname, config: app.config})
+      : (await respond(await app.route(request)))(app, headers);
   };
 
   const route = async request => {
@@ -66,10 +65,6 @@ export default app => {
     return route(request);
   };
 
-  const handle = async request => {
-    return await resource(request);
-  };
-
-  return [...filter("handle", app.modules), handle]
+  return [...filter("handle", app.modules), resource]
     .reduceRight((acc, handler) => input => handler(input, acc));
 };

package/src/hooks/parse.js

@@ -1,16 +1,15 @@
 import {URL} from "runtime-compat/http";
-import fromNull from "../fromNull.js";
 import errors from "../errors.js";
 
 const contents = {
   "application/x-www-form-urlencoded": body =>
-    fromNull(Object.fromEntries(body.split("&").map(part => part.split("=")
-      .map(subpart => decodeURIComponent(subpart).replaceAll("+", " "))))),
+    Object.fromEntries(body.split("&").map(part => part.split("=")
+      .map(subpart => decodeURIComponent(subpart).replaceAll("+", " ")))),
   "application/json": body => JSON.parse(body),
 };
 const decoder = new TextDecoder();
 
-export default async request => {
+export default dispatch => async request => {
   const parseContentType = (contentType, body) => {
     const type = contents[contentType];
     return type === undefined ? body : type(body);
@@ -46,14 +45,15 @@ export default async request => {
   const _url = request.url;
   const url = new URL(_url.endsWith("/") ? _url.slice(0, -1) : _url);
 
+  const body = await parseBody(request);
   return {
     original: request,
     url,
-    body: await parseBody(request),
-    cookies: fromNull(cookies === null
+    body: dispatch(body),
+    cookies: dispatch(cookies === null
       ? {}
       : Object.fromEntries(cookies.split(";").map(c => c.trim().split("=")))),
-    headers: fromNull(Object.fromEntries(request.headers)),
-    query: fromNull(Object.fromEntries(url.searchParams)),
+    headers: dispatch(Object.fromEntries(request.headers)),
+    query: dispatch(Object.fromEntries(url.searchParams)),
   };
 };

package/src/hooks/route.js

@@ -4,13 +4,6 @@ const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
 
 // insensitive-case equal
 const ieq = (left, right) => left.toLowerCase() === right.toLowerCase();
-// HTTP verbs
-const verbs = [
-  // CRUD
-  "post", "get", "put", "delete",
-  // extended
-  "connect", "options", "trace", "patch", "head",
-];
 
 /* routes may not contain dots */
 export const invalid = route => /\./u.test(route);
@@ -63,27 +56,34 @@ export default app => {
         return [];
       }
 
-      const path = toRoute(route);
       return Object.entries(imported)
-        .filter(([verb]) => verbs.includes(verb))
-        .map(([method, handler]) => ({method, handler, path}));
+        .map(([method, handler]) => ({method, handler, path: toRoute(route)}));
     }).flat();
 
   const {types = {}} = app;
-  Object.entries(types).every(([name]) => /^(?:\w*)$/u.test(name) ||
-    errors.InvalidType.throw({name}));
-
-  const isType = groups => Object
+  Object.entries(types).some(([name]) => /^(?:[^\W_]*)$/u.test(name) ||
+    errors.InvalidTypeName.throw({name}));
+  const reserved = ["get", "raw"];
+  Object.entries(types).some(([name]) => reserved.includes(name) &&
+    errors.ReservedTypeName.throw({name}));
+
+  const {explicit} = app.config.types;
+  const isType = (groups, path) => Object
     .entries(groups ?? {})
     .map(([name, value]) =>
-      [types[name] === undefined ? name : `${name}$${name}`, value])
+      [types[name] === undefined || explicit ? name : `${name}$${name}`, value])
     .filter(([name]) => name.includes("$"))
     .map(([name, value]) => [name.split("$")[1], value])
-    .every(([name, value]) => types?.[name](value) === true)
-  ;
+    .every(([name, value]) => {
+      try {
+        return types?.[name](value) === true;
+      } catch (error) {
+        return errors.MismatchedPath.throw({message: error.message, path});
+      }
+    });
   const isPath = ({route, path}) => {
     const result = route.path.exec(path);
-    return result === null ? false : isType(result.groups);
+    return result === null ? false : isType(result.groups, path);
   };
   const isMethod = ({route, method, path}) => ieq(route.method, method)
     && isPath({route, path});
@@ -95,8 +95,8 @@ export default app => {
     const {original: {method}, url: {pathname}} = request;
     const verb = find(method, pathname) ??
       errors.NoRouteToPath.throw({method, pathname, config: app.config});
-    const path = reentry(verb.path?.exec(pathname).groups,
-      object => object.map(([key, value]) => [key.split("$")[0], value]));
+    const path = app.dispatch(reentry(verb.path?.exec(pathname).groups,
+      object => object.map(([key, value]) => [key.split("$")[0], value])));
 
     // verb.handler is the last module to be executed
     const handlers = [...modules, verb.handler].reduceRight((acc, handler) =>

package/src/hooks/serve.js

@@ -0,0 +1,8 @@
+const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
+
+export default async (app, server) => {
+  app.log.info("running serve hooks", {module: "primate"});
+  await [...filter("serve", app.modules), _ => _]
+    .reduceRight((acc, handler) => input =>
+      handler(input, acc))({...app, server});
+};

package/src/start.js

@@ -1,31 +1,36 @@
 import {serve, Response} from "runtime-compat/http";
 import {InternalServerError} from "./http-statuses.js";
-import {register, compile, publish, bundle, route, handle, parse}
-  from "./hooks/exports.js";
+import * as hooks from "./hooks/exports.js";
+
+const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
 
 export default async (app, operations = {}) => {
   // register handlers
-  await register({...app, register(name, handler) {
+  await hooks.register({...app, register(name, handler) {
     app.handlers[name] = handler;
   }});
 
   // compile server-side code
-  await compile(app);
+  await hooks.compile(app);
   // publish client-side code
-  await publish(app);
+  await hooks.publish(app);
 
   // bundle client-side code
-  await bundle(app, operations?.bundle);
-
-  const _route = route(app);
+  await hooks.bundle(app, operations?.bundle);
 
-  serve(async request => {
+  const server = await serve(async request => {
     try {
       // parse, handle
-      return await handle({...app, route: _route})(await parse(request));
+      return await hooks.handle(app)(await app.parse(request));
     } catch(error) {
+      console.log("TEST2");
       app.log.auto(error);
       return new Response(null, {status: InternalServerError});
     }
   }, app.config.http);
+
+  await [...filter("serve", app.modules), _ => _]
+    .reduceRight((acc, handler) => input => handler(input, acc))({
+      ...app, server,
+    });
 };

package/src/fromNull.js

@@ -1 +0,0 @@
-export default object => Object.assign(Object.create(null), object);

package/src/hooks/handle/mime.spec.js

@@ -1,13 +0,0 @@
-import mime from "./mime.js";
-
-export default test => {
-  test.case("match", assert => {
-    assert(mime("/app.js")).equals("text/javascript");
-  });
-  test.case("no extension", assert => {
-    assert(mime("/app")).equals("application/octet-stream");
-  });
-  test.case("unknown extension", assert => {
-    assert(mime("/app.unknown")).equals("application/octet-stream");
-  });
-};

package/src/hooks/handle/respond.spec.js

@@ -1,12 +0,0 @@
-import respond from "./respond.js";
-
-export default test => {
-  test.case("guess URL", assert => {
-    const url = "https://primatejs.com/";
-    const status = 302;
-    const [body, options] = respond(new URL(url))();
-    assert(body).null();
-    assert(options.status).equals(status);
-    assert(options.headers.Location).equals(url);
-  });
-};

package/src/hooks/parse.spec.js

@@ -1,72 +0,0 @@
-import parse from "./parse.js";
-import Logger from "../Logger.js";
-
-const {mark} = Logger;
-
-const r = await (async () => {
-  const p = "https://p.com";
-  const request = (method, path = "/", options = {}) =>
-    new Request(`${p}${path}`, {method, ...options});
-  return Object.fromEntries(["get", "post", "put", "delete"].map(verb =>
-    [verb, (...args) => parse(request(verb.toUpperCase(), ...args))]));
-})();
-
-export default test => {
-  test.case("no body => null", async assert => {
-    assert((await r.get("/")).body).null();
-    assert((await r.post("/")).body).null();
-  });
-  test.case("body is application/json", async assert => {
-    const body = JSON.stringify({foo: "bar"});
-    const contentType = "application/json";
-    const headers = {"Content-Type": contentType};
-    assert((await r.post("/", {body, headers})).body).equals({foo: "bar"});
-
-    const faulty = `${body}%`;
-    assert(() => r.post("/", {body: faulty, headers}))
-      .throws(mark("cannot parse body % as %", faulty, contentType));
-  });
-  test.case("body is application/x-www-form-urlencoded", async assert => {
-    assert((await r.post("/", {
-      body: encodeURI("foo=bar &bar=baz"),
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-      },
-    })).body).equals({foo: "bar ", bar: "baz"});
-  });
-  test.case("no query => {}", async assert => {
-    assert((await r.get("/")).query).equals({});
-  });
-  test.case("query", async assert => {
-    assert((await r.get("/?key=value")).query).equals({key: "value"});
-  });
-  test.case("no cookies => {}", async assert => {
-    assert((await r.get("/")).cookies).equals({});
-  });
-  test.case("cookies", async assert => {
-    assert((await r.get("/?key=value", {
-      headers: {
-        Cookie: "key=value;key2=value2",
-      },
-    })).cookies).equals({key: "value", key2: "value2"});
-  });
-  test.case("no headers => {}", async assert => {
-    assert((await r.get("/")).headers).equals({});
-  });
-  test.case("headers", async assert => {
-    assert((await r.get("/?key=value", {
-      headers: {
-        "X-User": "Donald",
-      },
-    })).headers).equals({"x-user": "Donald"});
-  });
-  test.case("cookies double as headers", async assert => {
-    const response = await r.get("/?key=value", {
-      headers: {
-        Cookie: "key=value",
-      },
-    });
-    assert(response.headers).equals({cookie: "key=value"});
-    assert(response.cookies).equals({key: "value"});
-  });
-};

package/src/hooks/route.spec.js

@@ -1,181 +0,0 @@
-import Logger from "../Logger.js";
-import route from "./route.js";
-
-const {mark} = Logger;
-
-const app = {
-  config: {
-    paths: {
-      routes: "/routes",
-    },
-  },
-  routes: [
-    "index",
-    "user",
-    "users/{userId}a",
-    "comments/{commentId:comment}",
-    "users/{userId}/comments/{commentId}",
-    "users/{userId:user}/comments/{commentId}/a",
-    "users/{userId:user}/comments/{commentId:comment}/b",
-    "users/{_userId}/comments/{commentId}/d",
-    "users/{_userId}/comments/{_commentId}/e",
-    "comments2/{_commentId}",
-    "users2/{_userId}/{commentId}",
-    "users3/{_userId}/{_commentId:_commentId}",
-    "users4/{_userId}/{_commentId}",
-    "users5/{truthy}",
-    "{uuid}/{Uuid}/{UUID}",
-  ].map(pathname => [pathname, {get: request => request}]),
-  types: {
-    user: id => /^\d*$/u.test(id),
-    comment: id => /^\d*$/u.test(id),
-    _userId: id => /^\d*$/u.test(id),
-    _commentId: id => /^\d*$/u.test(id),
-    truthy: () => 1,
-    uuid: _ => _ === "uuid",
-    Uuid: _ => _ === "Uuid",
-    UUID: _ => _ === "UUID",
-  },
-};
-
-export default test => {
-  const router = route(app);
-  const p = "https://p.com";
-  const r = pathname => {
-    const original = new Request(`${p}${pathname}`, {method: "GET"});
-    const {url} = original;
-    const end = -1;
-    return router({
-      original,
-      url: new URL(url.endsWith("/") ? url.slice(0, end) : url),
-    });
-  };
-
-  test.reassert(assert => ({
-    match: (url, result) => {
-      assert(r(url).url.pathname).equals(result ?? url);
-    },
-    fail: (url, result) => {
-      const throws = mark("no % route to %", "GET", result ?? url);
-      assert(() => r(url)).throws(throws);
-    },
-    path: (url, result) => assert(r(url).path).equals(result),
-    assert,
-  }));
-
-  const get = () => null;
-  /* errors {{{ */
-  test.case("error DoubleRouted", ({assert}) => {
-    const post = ["post", {get}];
-    const throws = mark("double route %", "post");
-    assert(() => route({routes: [post, post]})).throws(throws);
-  });
-  test.case("error DoublePathParameter", ({assert}) => {
-    const path = "{user}/{user}";
-    const throws = mark("double path parameter % in route %", "user", path);
-    assert(() => route({routes: [[path, {get}]]})).throws(throws);
-  });
-  test.case("error EmptyRoutefile", ({assert}) => {
-    const path = "user";
-    const throws = mark("empty route file at %", `/routes/${path}.js`);
-    const base = {
-      log: {
-        auto(error) {
-          throw error;
-        },
-      },
-      config: {
-        paths: {
-          routes: "/routes",
-        },
-      },
-    };
-    assert(() => route({...base, routes: [[path, undefined]]})).throws(throws);
-    assert(() => route({...base, routes: [[path, {}]]})).throws(throws);
-  });
-  test.case("error InvalidRouteName", ({assert}) => {
-    const post = ["po.st", {get}];
-    const throws = mark("invalid route name %", "po.st");
-    assert(() => route({routes: [post], types: {}})).throws(throws);
-  });
-  test.case("error InvalidParameter", ({assert}) => {
-    const path = "{us$er}";
-    const throws = mark("invalid path parameter % in route %", "us$er", path);
-    assert(() => route({routes: [[path, {get}]]})).throws(throws);
-  });
-  test.case("error InvalidType", ({assert}) => {
-    const throws = mark("invalid type %", "us$er");
-    const types = {us$er: () => false};
-    assert(() => route({routes: [], types})).throws(throws);
-  });
-  /* }}} */
-
-  test.case("index route", ({match}) => {
-    match("/");
-  });
-  test.case("simple route", ({match}) => {
-    match("/user");
-  });
-  test.case("param match/fail", ({match, fail}) => {
-    match("/users/1a");
-    match("/users/aa");
-    match("/users/ba?key=value", "/users/ba");
-    fail("/user/1a");
-    fail("/users/a");
-    fail("/users/aA");
-    fail("/users//a");
-    fail("/users/?a", "/users/");
-  });
-  test.case("no params", ({path}) => {
-    path("/", {});
-  });
-  test.case("single param", ({path}) => {
-    path("/users/1a", {userId: "1"});
-  });
-  test.case("params", ({path, fail}) => {
-    path("/users/1/comments/2", {userId: "1", commentId: "2"});
-    path("/users/1/comments/2/b", {userId: "1", commentId: "2"});
-    fail("/users/d/comments/2/b");
-    fail("/users/1/comments/d/b");
-    fail("/users/d/comments/d/b");
-  });
-  test.case("single typed param", ({path, fail}) => {
-    path("/comments/1", {commentId: "1"});
-    fail("/comments/ ", "/comments");
-    fail("/comments/1d");
-  });
-  test.case("mixed untyped and typed params", ({path, fail}) => {
-    path("/users/1/comments/2/a", {userId: "1", commentId: "2"});
-    fail("/users/d/comments/2/a");
-  });
-  test.case("single implicit typed param", ({path, fail}) => {
-    path("/comments2/1", {_commentId: "1"});
-    fail("/comments2/d");
-  });
-  test.case("mixed implicit and untyped params", ({path, fail}) => {
-    path("/users2/1/2", {_userId: "1", commentId: "2"});
-    fail("/users2/d/2");
-    fail("/users2/d");
-  });
-  test.case("mixed implicit and explicit params", ({path, fail}) => {
-    path("/users3/1/2", {_userId: "1", _commentId: "2"});
-    fail("/users3/d/2");
-    fail("/users3/1/d");
-    fail("/users3");
-  });
-  test.case("implicit params", ({path, fail}) => {
-    path("/users4/1/2", {_userId: "1", _commentId: "2"});
-    fail("/users4/d/2");
-    fail("/users4/1/d");
-    fail("/users4");
-  });
-  test.case("fail not strictly true implicit params", ({fail}) => {
-    fail("/users5/any");
-  });
-  test.case("different case params", ({path, fail}) => {
-    path("/uuid/Uuid/UUID", {uuid: "uuid", Uuid: "Uuid", UUID: "UUID"});
-    fail("/uuid/uuid/uuid");
-    fail("/Uuid/UUID/uuid");
-    fail("/UUID/uuid/Uuid");
-  });
-};