primate 0.23.2 → 0.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.23.2",
+  "version": "0.25.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.28.4"
+    "runtime-compat": "^0.32.3"
   },
   "engines": {
     "node": ">=18"

package/src/Logger.js

@@ -1,7 +1,8 @@
-import {assert, is} from "runtime-compat/invariant";
-import {blue, bold, green, red, yellow, dim} from "runtime-compat/colors";
-import {map} from "runtime-compat/object";
+import { assert, is } from "runtime-compat/invariant";
+import { blue, bold, green, red, yellow, dim } from "runtime-compat/colors";
+import { map } from "runtime-compat/object";
 import console from "runtime-compat/console";
+import { stdout } from "runtime-compat/stdio";
 
 const levels = {
   Error: 0,
@@ -9,20 +10,23 @@ const levels = {
   Info: 2,
 };
 
-const print = (...messages) => process.stdout.write(messages.join(" "));
+const print = (...messages) => stdout.write(messages.join(" "));
 const bye = _ => print(dim(yellow("~~ bye\n")));
 const mark = (format, ...params) => params.reduce((formatted, param, i) =>
   formatted.replace(`{${i}}`, bold(param)), format);
 
-const reference = "https://primatejs.com/reference/errors";
+const reference = (module, error) => {
+  const base = module ? `modules/${module}` : "guide/logging";
+  return `https://primatejs.com/${base}#${hyphenate(error)}`;
+};
 
-const hyphenate = classCased => classCased
+const hyphenate = class_cased => class_cased
   .split("")
   .map(letter => letter.replace(/[A-Z]/u, upper => `-${upper.toLowerCase()}`))
   .join("")
   .slice(1);
 
-const throwable = ({message, level, fix}, name, module) => ({
+const throwable = ({ message, level, fix }, name, module) => ({
   new(...args) {
     const error = new Error(mark(message, ...args));
     error.level = Logger[level];
@@ -35,9 +39,9 @@ const throwable = ({message, level, fix}, name, module) => ({
     throw this.new(...args);
   },
   warn(logger, ...args) {
-    const error = {level: Logger[level], message: mark(message, ...args),
-      fix: mark(fix, ...args)};
-    logger.auto({...error, name, module});
+    const error = { level: Logger[level], message: mark(message, ...args),
+      fix: mark(fix, ...args) };
+    logger.auto({ ...error, name, module });
   },
 });
 
@@ -48,7 +52,7 @@ const Logger = class Logger {
     return map(errors, ([key, value]) => [key, throwable(value, key, module)]);
   }
 
-  constructor({level = levels.Error, trace = false} = {}) {
+  constructor({ level = levels.Error, trace = false } = {}) {
     assert(level !== undefined && level <= levels.Info);
     is(trace).boolean();
     this.#level = level;
@@ -68,11 +72,11 @@ const Logger = class Logger {
   }
 
   #print(pre, color, message, error = {}) {
-    const {fix, module, name, level} = error;
+    const { fix, module, name, level } = error;
     print(color(pre), `${module !== undefined ? `${color(module)} ` : ""}${message}`, "\n");
     if (fix) {
       print(blue("++"), fix);
-      name && print(dim(`\n   -> ${reference}/${module ?? "primate"}#${hyphenate(name)}`), "\n");
+      name && print(dim(`\n   -> ${reference(module, name)}`), "\n");
     }
     if (level === levels.Error || level === undefined && error.message) {
       this.#trace && console.log(error);
@@ -96,7 +100,7 @@ const Logger = class Logger {
   }
 
   auto(error) {
-    const {message} = error;
+    const { message } = error;
     const matches = map(levels, ([name, level]) => [level, name.toLowerCase()]);
     return this[matches[error.level] ?? "error"](message, error);
   }
@@ -104,4 +108,4 @@ const Logger = class Logger {
 
 export default Logger;
 
-export {print, bye, mark};
+export { print, bye, mark };

package/src/app.js

@@ -1,20 +1,20 @@
 import crypto from "runtime-compat/crypto";
-import {tryreturn} from "runtime-compat/async";
-import {File, Path} from "runtime-compat/fs";
-import {bold, blue} from "runtime-compat/colors";
-import {is} from "runtime-compat/invariant";
-import {transform, valmap, to} from "runtime-compat/object";
-import {globify} from "runtime-compat/string";
+import { tryreturn } from "runtime-compat/async";
+import { File, Path } from "runtime-compat/fs";
+import { bold, blue } from "runtime-compat/colors";
+import { is } from "runtime-compat/invariant";
+import { transform, valmap } from "runtime-compat/object";
+import { globify } from "runtime-compat/string";
 import * as runtime from "runtime-compat/meta";
 
 import errors from "./errors.js";
-import {print} from "./Logger.js";
+import { print } from "./Logger.js";
 import dispatch from "./dispatch.js";
 import to_sorted from "./to_sorted.js";
 import * as handlers from "./handlers/exports.js";
 import * as loaders from "./loaders/exports.js";
 
-const {DoubleFileExtension} = errors;
+const { DoubleFileExtension } = errors;
 
 // use user-provided file or fall back to default
 const index = (base, page, fallback) =>
@@ -27,14 +27,30 @@ 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}) =>
+const tag = ({ name, attributes = {}, code = "", close = true }) =>
   `<${name}${attribute(attributes)}${close ? `>${code}</${name}>` : "/>"}`;
+const tags = {
+  // inline: <script type integrity>...</script>
+  // outline: <script type integrity src></script>
+  script({ inline, code, type, integrity, src }) {
+    return inline
+      ? tag({ name: "script", attributes: { type, integrity }, code })
+      : tag({ name: "script", attributes: { type, integrity, src } });
+  },
+  // inline: <style>...</style>
+  // outline: <link rel="stylesheet" href/>
+  style({ inline, code, href, rel = "stylesheet" }) {
+    return inline
+      ? tag({ name: "style", code })
+      : tag({ name: "link", attributes: { rel, href }, close: false });
+  },
+};
 
-const {name, version} = await new Path(import.meta.url).up(2)
+const { name, version } = await new Path(import.meta.url).up(2)
   .join(runtime.manifest).json();
 
 export default async (log, root, config) => {
-  const {http} = config;
+  const { http } = config;
   const secure = http?.ssl !== undefined;
   const path = valmap(config.location, value => root.join(value));
 
@@ -65,18 +81,18 @@ export default async (log, root, config) => {
     error: {
       default: await error.exists ? (await import(error)).default : undefined,
     },
-    handlers: {...handlers},
+    handlers: { ...handlers },
     types,
     routes,
     layout: {
-      depth: Math.max(...routes.map(({layouts}) => layouts.length)) + 1,
+      depth: Math.max(...routes.map(({ layouts }) => layouts.length)) + 1,
     },
     dispatch: dispatch(types),
     modules: await loaders.modules(log, root, config),
     ...runtime,
     // copy files to build folder, potentially transforming them
     async stage(source, directory, filter) {
-      const {paths, mapper} = this.config.build.transform;
+      const { paths, mapper } = this.config.build.transform;
       is(paths).array();
       is(mapper).function();
 
@@ -96,56 +112,46 @@ export default async (log, root, config) => {
         }
       }));
     },
-    headers() {
+    headers({ script = "", style = "" } = {}) {
       const csp = Object.keys(http.csp).reduce((policy, key) =>
         `${policy}${key} ${http.csp[key]};`, "")
-        .replace("script-src 'self'", `script-src 'self' ${
+        .replace("script-src 'self'", `script-src 'self' ${script} ${
           this.assets
-            .filter(({type}) => type !== "style")
+            .filter(({ type }) => type !== "style")
             .map(asset => `'${asset.integrity}'`).join(" ")
-        } `)
-        .replace("style-src 'self'", `style-src 'self' ${
+        }`)
+        .replace("style-src 'self'", `style-src 'self' ${style} ${
           this.assets
-            .filter(({type}) => type === "style")
+            .filter(({ type }) => type === "style")
             .map(asset => `'${asset.integrity}'`).join(" ")
-        } `);
+        }`);
 
-      return {
-        "Content-Security-Policy": csp,
-        "Referrer-Policy": "same-origin",
-      };
+      return { "Content-Security-Policy": csp, "Referrer-Policy": "same-origin" };
     },
     runpath(...directories) {
       return this.path.build.join(...directories);
     },
-    async render({body = "", head = "", page = config.pages.index} = {}) {
-      const {location: {pages}} = this.config;
+    async render({ body = "", head = "", page = config.pages.index } = {}) {
+      const { location: { pages } } = this.config;
 
       const html = await index(this.runpath(pages), page, config.pages.index);
-      // 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 = head.concat("\n", to_sorted(this.assets,
-        ({type}) => -1 * (type === "importmap"))
-        .map(({src, code, type, inline, integrity}) =>
+
+      const heads = to_sorted(this.assets,
+        ({ type }) => -1 * (type === "importmap"))
+        .map(({ src, code, type, inline, integrity }) =>
           type === "style"
-            ? style({inline, code, href: src})
-            : script({inline, code, type, integrity, src})
-        ).join("\n"));
-      // remove inline assets
-      this.assets = this.assets.filter(({inline, type}) => !inline
-        || type === "importmap");
+            ? tags.style({ inline, code, href: src })
+            : tags.script({ inline, code, type, integrity, src }),
+        ).join("\n").concat("\n", head);
       return html.replace("%body%", _ => body).replace("%head%", _ => heads);
     },
-    async publish({src, code, type = "", inline = false, copy = true}) {
+    async inline(code, type) {
+      const integrity = await this.hash(code);
+      const tag_name = type === "style" ? "style" : "script";
+      const head = tags[tag_name]({ code, type, inline: true, integrity });
+      return { head, csp: `'${integrity}'` };
+    },
+    async publish({ src, code, type = "", inline = false, copy = true }) {
       if (!inline && copy) {
         const base = this.runpath(this.config.location.client).join(src);
         await base.directory.file.create();
@@ -161,8 +167,8 @@ export default async (log, root, config) => {
         });
       }
     },
-    export({type, code}) {
-      this.exports.push({type, code});
+    export({ type, code }) {
+      this.exports.push({ type, code });
     },
     register(extension, handler) {
       is(this.handlers[extension]).undefined(DoubleFileExtension.new(extension));
@@ -173,21 +179,25 @@ export default async (log, root, config) => {
       const prefix = algorithm.replace("-", _ => "");
       return `${prefix}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
     },
-    async import(module) {
-      const {http: {static: {root}}, location: {client}} = this.config;
+    async import(module, deep_import) {
+      const { http: { static: { root } }, location: { client } } = this.config;
 
       const parts = module.split("/");
       const path = [this.library, ...parts];
       const pkg = await Path.resolve().join(...path, this.manifest).json();
       const exports = pkg.exports === undefined
-        ? {[module]: `/${module}/${pkg.main}`}
+        ? { [module]: `/${module}/${pkg.main}` }
         : transform(pkg.exports, entry => entry
-          .filter(([, export$]) => export$.browser?.default !== undefined
+          .filter(([, export$]) =>
+            export$.browser?.[deep_import] !== undefined
+            || export$.browser?.default !== undefined
             || export$.import !== undefined
             || export$.default !== undefined)
           .map(([key, value]) => [
-            key.replace(".", module),
-            value.browser?.default.replace(".", `./${module}`)
+            key.replace(".", deep_import === undefined
+              ? module : `${module}/${deep_import}`),
+            value.browser?.[deep_import]?.replace(".", `./${module}`)
+              ?? value.browser?.default.replace(".", `./${module}`)
               ?? value.default?.replace(".", `./${module}`)
               ?? value.import?.replace(".", `./${module}`),
           ]));
@@ -196,7 +206,7 @@ export default async (log, root, config) => {
       await dependency.file.copy(to);
       this.importmaps = {
         ...valmap(exports, value => new Path(root, this.library, value).path),
-        ...this.importmaps};
+        ...this.importmaps };
     },
   };
 };

package/src/commands/exports.js

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

package/src/cwd.js

@@ -1,3 +1,3 @@
-import {Path} from "runtime-compat/fs";
+import { Path } from "runtime-compat/fs";
 
 export default (meta, up = 1) => new Path(meta.url).up(up);

package/src/defaults/primate.config.js

@@ -1,4 +1,4 @@
-import {identity} from "runtime-compat/function";
+import { identity } from "runtime-compat/function";
 import Logger from "../Logger.js";
 
 export default {

package/src/dispatch.js

@@ -1,7 +1,7 @@
-import {is, maybe} from "runtime-compat/invariant";
-import {tryreturn} from "runtime-compat/sync";
-import {map} from "runtime-compat/object";
-import {camelcased} from "runtime-compat/string";
+import { is, maybe } from "runtime-compat/invariant";
+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";
 
@@ -10,7 +10,7 @@ export default (patches = {}) => (value, raw, cased = true) => {
     ...map(patches, ([name, patch]) => [`get${camelcased(name)}`, property => {
       is(property).defined(`\`${name}\` called without property`);
       return tryreturn(_ => validate(patch, value[property], property))
-        .orelse(({message}) => errors.MismatchedType.throw(message));
+        .orelse(({ message }) => errors.MismatchedType.throw(message));
     }]),
     get(property) {
       maybe(property).string();

package/src/errors.js

@@ -1,4 +1,4 @@
-import {Path} from "runtime-compat/fs";
+import { Path } from "runtime-compat/fs";
 import Logger from "./Logger.js";
 
 const json = await new Path(import.meta.url).up(1).join("errors.json").json();

package/src/exports.js

@@ -2,8 +2,8 @@ import run from "./run.js";
 
 export * from "./handlers/exports.js";
 
-export {default as Logger} from "./Logger.js";
+export { default as Logger } from "./Logger.js";
 
-export {URL, Response, Status, MediaType} 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 {Response, Status, MediaType} from "runtime-compat/http";
+import { Response, Status, MediaType } from "runtime-compat/http";
 
-export default (body = "Not Found", {status = Status.NOT_FOUND, page} = {}) =>
+export default (body = "Not Found", { status = Status.NOT_FOUND, page } = {}) =>
   async app => new Response(await app.render({
     body,
-    page: page ?? app.config.pages.error}), {
+    page: page ?? app.config.pages.error }), {
       status,
-      headers: {...app.headers(), "Content-Type": MediaType.TEXT_HTML},
+      headers: { ...app.headers(), "Content-Type": MediaType.TEXT_HTML },
     });

package/src/handlers/exports.js

@@ -1,7 +1,7 @@
-export {default as text} from "./text.js";
-export {default as json} from "./json.js";
-export {default as stream} from "./stream.js";
-export {default as redirect} from "./redirect.js";
-export {default as html} from "./html.js";
-export {default as view} from "./view.js";
-export {default as error} from "./error.js";
+export { default as text } from "./text.js";
+export { default as json } from "./json.js";
+export { default as stream } from "./stream.js";
+export { default as redirect } from "./redirect.js";
+export { default as html } from "./html.js";
+export { default as view } from "./view.js";
+export { default as error } from "./error.js";

package/src/handlers/html.js

@@ -1,26 +1,29 @@
-import {Response, Status, MediaType} from "runtime-compat/http";
+import { Response, Status, MediaType } from "runtime-compat/http";
 
-const script = /(?<=<script)>(?<code>.*?)(?=<\/script>)/gus;
-const style = /(?<=<style)>(?<code>.*?)(?=<\/style>)/gus;
+const script_re = /(?<=<script)>(?<code>.*?)(?=<\/script>)/gus;
+const style_re = /(?<=<style)>(?<code>.*?)(?=<\/style>)/gus;
 const remove = /<(?<tag>script|style)>.*?<\/\k<tag>>/gus;
-const inline = true;
 
 export default (name, options = {}) => {
-  const {status = Status.OK, partial = false} = options;
+  const { status = Status.OK, partial = false } = options;
 
   return async app => {
     const html = await app.path.components.join(name).text();
-    await Promise.all([...html.matchAll(script)]
-      .map(({groups: {code}}) => app.publish({code, inline})));
-    await Promise.all([...html.matchAll(style)]
-      .map(({groups: {code}}) => app.publish({code, type: "style", inline})));
+    const scripts = await Promise.all([...html.matchAll(script_re)]
+      .map(({ groups: { code } }) => app.inline(code, "module")));
+    const styles = await Promise.all([...html.matchAll(style_re)]
+      .map(({ groups: { code } }) => app.inline(code, "style")));
+    const assets = [...scripts, ...styles];
+
     const body = html.replaceAll(remove, _ => "");
-    // needs to happen before app.render()
-    const headers = app.headers();
+    const head = assets.map(asset => asset.head).join("\n");
+    const script = scripts.map(asset => asset.csp).join(" ");
+    const style = styles.map(asset => asset.csp).join(" ");
+    const headers = { script, style };
 
-    return new Response(partial ? body : await app.render({body}), {
+    return new Response(partial ? body : await app.render({ body, head }), {
       status,
-      headers: {...headers, "Content-Type": MediaType.TEXT_HTML},
+      headers: { ...app.headers(headers), "Content-Type": MediaType.TEXT_HTML },
     });
   };
 };

package/src/handlers/json.js

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

package/src/handlers/redirect.js

@@ -1,8 +1,8 @@
-import {Response, 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 */
   new Response(null, {
     status,
-    headers: {...app.headers(), Location},
+    headers: { ...app.headers(), Location },
   });

package/src/handlers/stream.js

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

package/src/handlers/text.js

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

package/src/hooks/bundle.js

@@ -1,3 +1,3 @@
-import {cascade} from "runtime-compat/async";
+import { cascade } from "runtime-compat/async";
 
 export default async app => (await cascade(app.modules.bundle))(app);

package/src/hooks/compile.js

@@ -1,5 +1,5 @@
-import {Path} from "runtime-compat/fs";
-import {cascade} from "runtime-compat/async";
+import { Path } from "runtime-compat/fs";
+import { cascade } from "runtime-compat/async";
 import copy_includes from "./copy_includes.js";
 import cwd from "../cwd.js";
 
@@ -7,7 +7,7 @@ const html = /^.*.html$/u;
 const defaults = cwd(import.meta, 2).join("defaults");
 
 const pre = async app => {
-  const {config: {location}, path} = app;
+  const { config: { location }, path } = app;
 
   // remove build directory in case exists
   if (await path.build.exists) {

package/src/hooks/copy_includes.js

@@ -1,9 +1,9 @@
-import {Path} from "runtime-compat/fs";
+import { Path } from "runtime-compat/fs";
 
 export default async (app, type, post = () => undefined) => {
-  const {config} = app;
-  const {build} = config;
-  const {includes} = build;
+  const { config } = app;
+  const { build } = config;
+  const { includes } = build;
 
   const reserved = Object.values(app.config.location);
 

package/src/hooks/exports.js

@@ -1,9 +1,9 @@
-export {default as init} from "./init.js";
-export {default as register} from "./register.js";
-export {default as compile} from "./compile.js";
-export {default as publish} from "./publish.js";
-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";
+export { default as init } from "./init.js";
+export { default as register } from "./register.js";
+export { default as compile } from "./compile.js";
+export { default as publish } from "./publish.js";
+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

@@ -1,52 +1,59 @@
-import {Response, Status, MediaType} from "runtime-compat/http";
-import {cascade, tryreturn} from "runtime-compat/async";
-import {respond} from "./respond/exports.js";
-import {invalid} from "./route.js";
-import {error as clientError} from "../handlers/exports.js";
+import { Response, Status, MediaType } from "runtime-compat/http";
+import { cascade, tryreturn } from "runtime-compat/async";
+import { respond } from "./respond/exports.js";
+import { invalid } from "./route.js";
+import { error as clientError } from "../handlers/exports.js";
 import _errors from "../errors.js";
-const {NoFileForPath} = _errors;
+const { NoFileForPath } = _errors;
 
-const guardError = Symbol("guardError");
+const guard_error = Symbol("guard_error");
+const guard = (app, guards) => async (request, next) => {
+  // handle guards
+  try {
+    guards.every(guard => {
+      const result = guard(request);
+      if (result === true) {
+        return true;
+      }
+      const error = new Error();
+      error.result = result;
+      error.type = guard_error;
+      throw error;
+    });
+
+    return next(request);
+  } catch (error) {
+    if (error.type === guard_error) {
+      return (await respond(error.result))(app);
+    }
+    // rethrow if not guard error
+    throw error;
+  }
+};
 
 export default app => {
-  const {config: {http: {static: {root}}, location}} = app;
+  const { config: { http: { static: { root } }, location } } = app;
 
   const as_route = async request => {
-    const {pathname} = request.url;
+    const { pathname } = request.url;
     // if NoFileForPath is thrown, this will remain undefined
     let error_handler = app.error.default;
 
     return tryreturn(async _ => {
-      const {path, guards, errors, layouts, handler} = invalid(pathname)
+      const { path, guards, errors, layouts, handler } = invalid(pathname)
         ? NoFileForPath.throw(pathname, location.static)
         : await app.route(request);
       error_handler = 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);
-        }
-        // rethrow if not guard error
-        throw error;
-      }
+      const pathed = { ...request, path };
+
+      const hooks = [...app.modules.route, guard(app, guards)];
 
       // handle request
-      const response = (await cascade(app.modules.route, handler))({...request, path});
+      const response = (await cascade(hooks, handler))(pathed);
       return (await respond(await response))(app, {
         layouts: await Promise.all(layouts.map(layout => layout(request))),
-      }, request);
+      }, pathed);
     }).orelse(async error => {
       app.log.auto(error);
 
@@ -66,7 +73,7 @@ export default app => {
 
   const client = app.runpath(location.client);
   const handle = async request => {
-    const {pathname} = request.url;
+    const { pathname } = request.url;
     if (pathname.startsWith(root)) {
       const debased = pathname.replace(root, _ => "");
       // try static first

package/src/hooks/init.js

@@ -1,3 +1,3 @@
-import {cascade} from "runtime-compat/async";
+import { cascade } from "runtime-compat/async";
 
 export default async app => (await cascade(app.modules.init))(app);

package/src/hooks/parse.js

@@ -1,12 +1,12 @@
-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 { 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 {APPLICATION_FORM_URLENCODED, APPLICATION_JSON} = MediaType;
+const { APPLICATION_FORM_URLENCODED, APPLICATION_JSON } = MediaType;
 
-const {decodeURIComponent: decode} = globalThis;
+const { decodeURIComponent: decode } = globalThis;
 const deslash = url => url.replaceAll(/(?<!http:)\/{2,}/gu, _ => "/");
 
 const contents = {
@@ -21,12 +21,12 @@ const content = (type, body) =>
     .orelse(_ => errors.CannotParseBody.throw(body, type));
 
 export default dispatch => async original => {
-  const {headers} = original;
+  const { headers } = original;
   const url = new URL(deslash(decode(original.url)));
   const body = await stringify(original.body);
   const cookies = headers.get("cookie");
 
-  return {original, url,
+  return { original, url,
     ...valmap({
       body: [content(headers.get("content-type"), body), body],
       query: [from(url.searchParams), url.search],

package/src/hooks/publish.js

@@ -1,18 +1,18 @@
-import {Path} from "runtime-compat/fs";
-import {cascade} from "runtime-compat/async";
-import {stringify} from "runtime-compat/object";
+import { Path } from "runtime-compat/fs";
+import { cascade } from "runtime-compat/async";
+import { stringify } from "runtime-compat/object";
 import copy_includes from "./copy_includes.js";
 
 const post = async app => {
-  const {config: {location, http: {static: {root}}}, path} = app;
+  const { config: { location, http: { static: { root } } }, path } = app;
 
   {
     // after hook, publish a zero assumptions app.js (no css imports)
     const src = new Path(root, app.config.build.index);
 
     await app.publish({
-      code: app.exports.filter(({type}) => type === "script")
-        .map(({code}) => code).join(""),
+      code: app.exports.filter(({ type }) => type === "script")
+        .map(({ code }) => code).join(""),
       src,
       type: "module",
     });
@@ -24,10 +24,9 @@ const post = async app => {
       await app.stage(path.components, to, /^.*.js$/u);
     }
 
-    const imports = {...app.importmaps, app: src.path};
-    const inline = true;
+    const imports = { ...app.importmaps, app: src.path };
     const type = "importmap";
-    await app.publish({inline, code: stringify({imports}), type});
+    await app.publish({ inline: true, code: stringify({ imports }), type });
   }
 
   if (await path.static.exists) {
@@ -41,9 +40,9 @@ const post = async app => {
       const src = file.debase(path.static);
       const type = file.extension === ".css" ? "style" : "module";
       // already copied in `app.stage`
-      await app.publish({src, code, type, copy: false});
-      type === "style" && app.export({type,
-        code: `import "./${location.static}${src}";`});
+      await app.publish({ src, code, type, copy: false });
+      type === "style" && app.export({ type,
+        code: `import "./${location.static}${src}";` });
     }));
   }
 
@@ -52,8 +51,8 @@ const post = async app => {
   await copy_includes(app, location.client, async to =>
     Promise.all((await to.collect(/\.js$/u)).map(async script => {
       const src = new Path(root, script.path.replace(client, _ => ""));
-      await app.publish({src, code: await script.text(), type: "module"});
-    }))
+      await app.publish({ src, code: await script.text(), type: "module" });
+    })),
   );
 
   return app;

package/src/hooks/register.js

@@ -1,3 +1,3 @@
-import {cascade} from "runtime-compat/async";
+import { cascade } from "runtime-compat/async";
 
 export default async app => (await cascade(app.modules.register))(app);

package/src/hooks/respond/duck.js

@@ -1,4 +1,4 @@
-import {Headers} from "runtime-compat/http";
+import { Headers } from "runtime-compat/http";
 
 export const isResponse = value =>
   value.body !== undefined && value.headers instanceof Headers;

package/src/hooks/respond/exports.js

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

package/src/hooks/respond/respond.js

@@ -1,7 +1,7 @@
-import {Blob} from "runtime-compat/fs";
-import {URL} from "runtime-compat/http";
-import {text, json, stream, redirect} from "primate";
-import {isResponse as isResponseDuck} from "./duck.js";
+import { Blob } from "runtime-compat/fs";
+import { URL } from "runtime-compat/http";
+import { text, json, stream, redirect } from "primate";
+import { isResponse as isResponseDuck } from "./duck.js";
 
 const isText = value => {
   if (typeof value === "string") {

package/src/hooks/route.js

@@ -1,5 +1,5 @@
-import {from} from "runtime-compat/object";
-import {tryreturn} from "runtime-compat/sync";
+import { from } from "runtime-compat/object";
+import { tryreturn } from "runtime-compat/sync";
 import errors from "../errors.js";
 import validate from "../validate.js";
 
@@ -13,7 +13,7 @@ const deroot = pathname => pathname.endsWith("/") && pathname !== "/"
   ? pathname.slice(0, -1) : pathname;
 
 export default app => {
-  const {types, routes, config: {types: {explicit}, location}} = app;
+  const { types, routes, config: { types: { explicit }, location } } = app;
 
   const to_path = (route, pathname) => app.dispatch(from(Object
     .entries(route.pathname.exec(pathname)?.groups ?? {})
@@ -21,7 +21,7 @@ export default app => {
       [types[name] === undefined || explicit ? name : `${name}$${name}`, value])
     .map(([name, value]) => [name.split("$"), value])
     .map(([[name, type], value]) =>
-      [name, type === undefined ? value : validate(types[type], value, name)]
+      [name, type === undefined ? value : validate(types[type], value, name)],
     )));
 
   const is_type = (groups, pathname) => Object
@@ -32,22 +32,22 @@ export default app => {
     .map(([name, value]) => [name.split("$"), value])
     .map(([[name, type], value]) =>
       tryreturn(_ => [name, validate(types[type], value, name)])
-        .orelse(({message}) => errors.MismatchedPath.throw(pathname, message)));
-  const is_path = ({route, pathname}) => {
+        .orelse(({ message }) => errors.MismatchedPath.throw(pathname, message)));
+  const is_path = ({ route, pathname }) => {
     const result = route.pathname.exec(pathname);
     return result === null ? false : is_type(result.groups, pathname);
   };
-  const is_method = ({route, method, pathname}) => ieq(route.method, method)
-    && is_path({route, pathname});
+  const is_method = ({ route, method, pathname }) => ieq(route.method, method)
+    && is_path({ route, pathname });
   const find = (method, pathname) => routes.find(route =>
-    is_method({route, method, pathname}));
+    is_method({ route, method, pathname }));
 
   const index = path => `${location.routes}${path === "/" ? "/index" : path}`;
 
-  return ({original: {method}, url}) => {
+  return ({ original: { method }, url }) => {
     const pathname = deroot(url.pathname);
     const route = find(method, pathname) ?? errors.NoRouteToPath
       .throw(method.toLowerCase(), pathname, index(pathname));
-    return {...route, path: to_path(route, pathname)};
+    return { ...route, path: to_path(route, pathname) };
   };
 };

package/src/hooks/serve.js

@@ -1,6 +1,6 @@
-import {cascade} from "runtime-compat/async";
+import { cascade } from "runtime-compat/async";
 
 export default async (app, server) => {
-  app.log.info("running serve hooks", {module: "primate"});
-  await (await cascade(app.modules.serve))({...app, server});
+  app.log.info("running serve hooks", { module: "primate" });
+  await (await cascade(app.modules.serve))({ ...app, server });
 };

package/src/loaders/common.js

@@ -1,5 +1,5 @@
-import {Path} from "runtime-compat/fs";
-import {identity} from "runtime-compat/function";
+import { Path } from "runtime-compat/fs";
+import { identity } from "runtime-compat/function";
 import errors from "../errors.js";
 
 const ending = ".js";
@@ -17,7 +17,7 @@ export default async ({
   warn = true,
 } = {}) => {
   const objects = directory === undefined ? [] : await Promise.all(
-    (await Path.collect(directory, /^.*.js$/u, {recursive}))
+    (await Path.collect(directory, /^.*.js$/u, { recursive }))
       .filter(filter)
       .map(async path => [
         `${path}`.replace(directory, _ => "").slice(1, -ending.length),

package/src/loaders/exports.js

@@ -1,3 +1,3 @@
-export {default as modules} from "./modules.js";
-export {default as routes} from "./routes.js";
-export {default as types} from "./types.js";
+export { default as modules } from "./modules.js";
+export { default as routes } from "./routes.js";
+export { default as types } from "./types.js";

package/src/loaders/modules.js

@@ -1,5 +1,5 @@
 import * as hooks from "../hooks/exports.js";
-import {doubled} from "./common.js";
+import { doubled } from "./common.js";
 import errors from "../errors.js";
 
 const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
@@ -15,18 +15,21 @@ export default async (log, root, config) => {
   modules.some((module, n) => module.name === undefined &&
     errors.ModuleHasNoName.throw(n));
 
-  const names = modules.map(({name}) => name);
+  const names = modules.map(({ name }) => name);
   new Set(names).size !== modules.length &&
     errors.DoubleModule.throw(doubled(names), root.join("primate.config.js"));
 
   const hookless = modules.filter(module => !Object.keys(module).some(key =>
-    [...Object.keys(hooks), "load"].includes(key)));
+    [...Object.keys(hooks), "load", "context"].includes(key)));
   hookless.length > 0 && errors.ModuleHasNoHooks.warn(log,
-    hookless.map(({name}) => name).join(", "));
+    hookless.map(({ name }) => name).join(", "));
 
   // collect modules
   const loaded = load(modules).flat(2);
 
-  return Object.fromEntries(Object.keys(hooks)
-    .map(hook => [hook, filter(hook, loaded)]));
+  return {
+    names: loaded.map(module => module.name),
+    ...Object.fromEntries([...Object.keys(hooks), "context"]
+      .map(hook => [hook, filter(hook, loaded)])),
+  };
 };

package/src/loaders/routes/exports.js

@@ -1,4 +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";
+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/load.js

@@ -1,4 +1,4 @@
-import {Path} from "runtime-compat/fs";
+import { Path } from "runtime-compat/fs";
 import errors from "../../errors.js";
 import to_sorted from "../../to_sorted.js";
 
@@ -6,7 +6,7 @@ export default type => async (log, directory, load) => {
   const filter = path => new RegExp(`^\\+${type}.js$`, "u").test(path.name);
 
   const replace = new RegExp(`\\+${type}`, "u");
-  const objects = to_sorted((await load({log, directory, filter, warn: false}))
+  const objects = to_sorted((await load({ log, directory, filter, warn: false }))
     .map(([name, object]) => [name.replace(replace, () => ""), object]),
   ([a], [b]) => a.length - b.length);
 

package/src/loaders/routes/routes.js

@@ -1,4 +1,4 @@
-import {doubled} from "../common.js";
+import { doubled } from "../common.js";
 import errors from "../../errors.js";
 
 const normalize = route => {
@@ -13,7 +13,7 @@ const deindex = path => path.endsWith("index") ?
 
 export default async (log, directory, load) => {
   const filter = path => /^[^+].*.js$/u.test(path.name);
-  const routes = (await load({log, directory, filter}))
+  const routes = (await load({ log, directory, filter }))
     .map(([path, handler]) => [deindex(path), handler]);
 
   const double = doubled(routes.map(([route]) => normalize(route)));

package/src/loaders/routes.js

@@ -1,8 +1,8 @@
-import {tryreturn} from "runtime-compat/sync";
-import {from} from "runtime-compat/object";
+import { tryreturn } from "runtime-compat/sync";
+import { from } from "runtime-compat/object";
 import errors from "../errors.js";
-import {invalid} from "../hooks/route.js";
-import {default as fs, doubled} from "./common.js";
+import { invalid } from "../hooks/route.js";
+import { default as fs, doubled } from "./common.js";
 import * as get from "./routes/exports.js";
 
 const make = path => {
@@ -13,7 +13,7 @@ const make = path => {
 
   const route = path.replaceAll(/\{(?<named>.*?)\}/gu, (_, named) =>
     tryreturn(_ => {
-      const {name, type} = /^(?<name>\w+)(?<type>=\w+)?$/u.exec(named).groups;
+      const { name, type } = /^(?<name>\w+)(?<type>=\w+)?$/u.exec(named).groups;
       const param = type === undefined ? name : `${name}$${type.slice(1)}`;
       return `(?<${param}>[^/]{1,}?)`;
     }).orelse(_ => errors.InvalidPathParameter.throw(named, path)));

package/src/loaders/types.js

@@ -1,11 +1,11 @@
-import {Path} from "runtime-compat/fs";
+import { Path } from "runtime-compat/fs";
 import errors from "../errors.js";
 import fs from "./common.js";
 
 const filter = path => /^[a-z]/u.test(path.name);
 
 export default async (log, directory, load = fs) => {
-  const types = await load({log, directory, name: "types", filter});
+  const types = await load({ log, directory, name: "types", filter });
 
   const resolve = name => new Path(directory, name);
   types.some(([name, type]) => typeof type !== "function"

package/src/run.js

@@ -1,14 +1,14 @@
-import {tryreturn} from "runtime-compat/async";
-import {Path} from "runtime-compat/fs";
-import {extend} from "runtime-compat/object";
+import { tryreturn } from "runtime-compat/async";
+import { Path } from "runtime-compat/fs";
+import { extend } from "runtime-compat/object";
 import app from "./app.js";
-import {default as Logger, bye} from "./Logger.js";
+import { default as Logger, bye } from "./Logger.js";
 import errors from "./errors.js";
 import command from "./commands/exports.js";
 import defaults from "./defaults/primate.config.js";
 
-let logger = new Logger({level: Logger.Warn});
-const {runtime = "node"} = import.meta;
+let logger = new Logger({ level: Logger.Warn });
+const { runtime = "node" } = import.meta;
 
 const get_config = async root => {
   const name = "primate.config.js";
@@ -21,7 +21,7 @@ const get_config = async root => {
         errors.EmptyConfigFile.warn(logger, config);
 
       return extend(defaults, imported);
-    }).orelse(({message}) =>
+    }).orelse(({ message }) =>
       errors.ErrorInConfigFile.throw(message, `${runtime} ${config}`))
     : defaults;
 };

package/src/start.js

@@ -1,5 +1,5 @@
-import {serve, Response, Status} from "runtime-compat/http";
-import {cascade, tryreturn} from "runtime-compat/async";
+import { serve, Response, Status } from "runtime-compat/http";
+import { cascade, tryreturn } from "runtime-compat/async";
 import * as hooks from "./hooks/exports.js";
 
 export default async (app$, deactivated = []) => {
@@ -9,7 +9,7 @@ export default async (app$, deactivated = []) => {
     if (deactivated.includes(hook)) {
       continue;
     }
-    app.log.info(`running ${hook} hooks`, {module: "primate"});
+    app.log.info(`running ${hook} hooks`, { module: "primate" });
     app = await hooks[hook](app);
   }
 
@@ -20,9 +20,9 @@ export default async (app$, deactivated = []) => {
     tryreturn(async _ => (await hooks.handle(app))(await app.parse(request)))
       .orelse(error => {
         app.log.auto(error);
-        return new Response(null, {status: Status.INTERNAL_SERVER_ERROR});
+        return new Response(null, { status: Status.INTERNAL_SERVER_ERROR });
       }),
   app.config.http);
 
-  await (await cascade(app.modules.serve))({...app, server});
+  await (await cascade(app.modules.serve))({ ...app, server });
 };

package/src/validate.js

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