primate 0.21.4 → 0.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.21.4",
+  "version": "0.22.1",
   "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.24.1"
+    "runtime-compat": "^0.25.7"
   },
   "engines": {
     "node": ">=18.16"

package/src/app.js

@@ -2,34 +2,28 @@ 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/dyndef";
 import {transform, valmap} from "runtime-compat/object";
+import {globify} from "runtime-compat/string";
+import errors from "./errors.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 hooks from "./hooks/exports.js";
 import * as loaders from "./loaders/exports.js";
-import dispatch from "./dispatch.js";
-import {print} from "./Logger.js";
-import toSorted from "./toSorted.js";
 
-const base = new Path(import.meta.url).up(1);
+const {DoubleFileExtension} = errors;
+
 // do not hard-depend on node
 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, page) =>
-  tryreturn(_ => File.read(`${app.paths.pages.join(page)}`))
-    .orelse(_ => fallback(app, page));
+const index = (base, page, fallback) =>
+  tryreturn(_ => File.read(`${base.join(page)}`))
+    .orelse(_ => File.read(`${base.join(fallback)}`));
 
 const encoder = new TextEncoder();
-const hash = async (string, algorithm = "sha-384") => {
-  const bytes = await crypto.subtle.digest(algorithm, encoder.encode(string));
-  const algo = algorithm.replace("-", _ => "");
-  return `${algo}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
-};
 
 const attribute = attributes => Object.keys(attributes).length > 0
   ? " ".concat(Object.entries(attributes)
@@ -38,11 +32,13 @@ const attribute = attributes => Object.keys(attributes).length > 0
 const tag = ({name, attributes = {}, code = "", close = true}) =>
   `<${name}${attribute(attributes)}${close ? `>${code}</${name}>` : "/>"}`;
 
-export default async (config, root, log) => {
+const base = new Path(import.meta.url).up(1);
+
+export default async (log, root, config) => {
   const {http} = config;
   const secure = http?.ssl !== undefined;
   const {name, version} = await base.up(1).join(packager).json();
-  const paths = valmap(config.paths, value => root.join(value));
+  const path = valmap(config.location, value => root.join(value));
 
   const at = `at http${secure ? "s" : ""}://${http.host}:${http.port}\n`;
   print(blue(bold(name)), blue(version), at);
@@ -53,33 +49,54 @@ export default async (config, root, log) => {
     http.ssl.cert = root.join(http.ssl.cert);
   }
 
-  const types = await loaders.types(log, paths.types);
+  const types = await loaders.types(log, path.types);
+  const error = await path.routes.join("+error.js");
+  const routes = await loaders.routes(log, path.routes);
+  const modules = await loaders.modules(log, root, config);
 
-  const app = {
-    build: {
-      paths: {
-        client: paths.build.join("client"),
-        server: paths.build.join("server"),
-        components: paths.build.join("components"),
-      },
-    },
+  return {
     config,
     secure,
     name,
     version,
     importmaps: {},
     assets: [],
-    entrypoints: [],
-    paths,
+    exports: [],
+    path,
     root,
     log,
-    async copy(source, target, filter = /^.*.js$/u) {
-      const jss = await source.collect(filter);
-      await Promise.all(jss.map(async js => {
-        const file = await js.file.read();
-        const to = await target.join(js.path.replace(source, ""));
+    error: {
+      default: await error.exists ? (await import(error)).default : undefined,
+    },
+    handlers: {...handlers},
+    types,
+    routes,
+    layout: {
+      depth: Math.max(...routes.map(({layouts}) => layouts.length)) + 1,
+    },
+    dispatch: dispatch(types),
+    modules,
+    packager,
+    library,
+    // copy files to build folder, potentially transforming them
+    async stage(source, directory, filter) {
+      const {paths, mapper} = this.config.build.transform;
+      is(paths).array();
+      is(mapper).function();
+
+      const regexs = paths.map(file => globify(file));
+      const target = this.runpath(directory);
+
+      await Promise.all((await source.collect(filter)).map(async path => {
+        const filename = new Path(directory).join(path.debase(source));
+        const to = await target.join(filename.debase(directory));
         await to.directory.file.create();
-        await to.file.write(file);
+        if (regexs.some(regex => regex.test(filename))) {
+          const contents = mapper(await path.text());
+          await to.file.write(contents);
+        } else {
+          await path.file.copy(to);
+        }
       }));
     },
     headers() {
@@ -101,9 +118,13 @@ export default async (config, root, log) => {
         "Referrer-Policy": "same-origin",
       };
     },
-    handlers: {...handlers},
-    async render({body = "", page} = {}) {
-      const html = await index(this, page ?? config.pages.index);
+    runpath(...directories) {
+      return this.path.build.join(...directories);
+    },
+    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
@@ -114,37 +135,53 @@ 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(this.assets,
+
+      const heads = head.concat("\n", 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");
+        ).join("\n"));
       // remove inline assets
       this.assets = this.assets.filter(({inline, type}) => !inline
         || type === "importmap");
-      return html.replace("%body%", _ => body).replace("%head%", _ => head);
+      return html.replace("%body%", _ => body).replace("%head%", _ => heads);
     },
-    async publish({src, code, type = "", inline = false}) {
-      if (!inline) {
-        const base = this.build.paths.client.join(src);
+    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();
         await base.file.write(code);
       }
       if (inline || type === "style") {
-        this.assets.push({src: new Path(http.static.root).join(src ?? "").path,
-          code: inline ? code : "", type, inline, integrity: await hash(code)});
+        this.assets.push({
+          src: new Path(http.static.root).join(src ?? "").path,
+          code: inline ? code : "",
+          type,
+          inline,
+          integrity: await this.hash(code),
+        });
       }
     },
-    bootstrap({type, code}) {
-      this.entrypoints.push({type, code});
+    export({type, code}) {
+      this.exports.push({type, code});
+    },
+    register(extension, handler) {
+      is(this.handlers[extension]).undefined(DoubleFileExtension.new(extension));
+      this.handlers[extension] = handler;
+    },
+    async hash(data, algorithm = "sha-384") {
+      const bytes = await crypto.subtle.digest(algorithm, encoder.encode(data));
+      const prefix = algorithm.replace("-", _ => "");
+      return `${prefix}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
     },
     async import(module) {
-      const {build: {modules}, http: {static: {root}}} = this.config;
+      const {http: {static: {root}}, location: {client}} = this.config;
+
       const parts = module.split("/");
-      const path = [library, ...parts];
-      const pkg = await Path.resolve().join(...path, packager).json();
+      const path = [this.library, ...parts];
+      const pkg = await Path.resolve().join(...path, this.packager).json();
       const exports = pkg.exports === undefined
         ? {[module]: `/${module}/${pkg.main}`}
         : transform(pkg.exports, entry => entry
@@ -158,27 +195,11 @@ export default async (config, root, log) => {
               ?? value.import?.replace(".", `./${module}`),
           ]));
       const dependency = Path.resolve().join(...path);
-      const to = new Path(this.build.paths.client, modules, ...parts);
+      const to = new Path(this.runpath(client), this.library, ...parts);
       await dependency.file.copy(to);
       this.importmaps = {
-        ...valmap(exports, value => new Path(root, modules, value).path),
+        ...valmap(exports, value => new Path(root, this.library, value).path),
         ...this.importmaps};
     },
-    types,
-    routes: await loaders.routes(log, paths.routes),
-    dispatch: dispatch(types),
-  };
-
-  const error = await app.paths.routes.join("+error.js");
-  const modules = await loaders.modules(app, root, config);
-
-  return {...app,
-    modules,
-    error: {
-      default: await error.exists ? (await import(error)).default : undefined,
-    },
-    layoutDepth: Math.max(...app.routes.map(({layouts}) => layouts.length)) + 1,
-    route: hooks.route({...app, modules}),
-    parse: hooks.parse(dispatch(types)),
   };
 };

package/src/commands/dev.js

@@ -1,3 +1,3 @@
 import start from "../start.js";
 
-export default app => start(app);
+export default app => start(app, ["bundle"]);

package/src/commands/serve.js

@@ -1,3 +1,3 @@
 import start from "../start.js";
 
-export default app => start(app, {bundle: true});
+export default app => start(app);

package/src/cwd.js

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

package/src/defaults/primate.config.js

@@ -1,3 +1,4 @@
+import {identity} from "runtime-compat/function";
 import Logger from "../Logger.js";
 
 export default {
@@ -27,20 +28,31 @@ export default {
       root: "/",
     },
   },
-  paths: {
-    build: "build",
+  location: {
+    // renderable components
     components: "components",
+    // HTML pages
     pages: "pages",
+    // hierarchical routes
     routes: "routes",
+    // static assets
     static: "static",
+    // runtime types
     types: "types",
+    // build environment
+    build: "build",
+    // client build
+    client: "client",
+    // server build
+    server: "server",
   },
   build: {
     includes: [],
-    static: "static",
-    app: "app",
-    modules: "modules",
     index: "index.js",
+    transform: {
+      paths: [],
+      mapper: identity,
+    },
   },
   types: {
     explicit: false,

package/src/errors.json

@@ -1,3 +1,5 @@
+
+
 {
   "module": "primate",
   "errors": {
@@ -6,6 +8,11 @@
       "fix": "use a different content type or fix body",
       "level": "Warn"
     },
+    "DoubleFileExtension": {
+      "message": "double file extension {0}",
+      "fix": "unload one of the two handlers registering the file extension",
+      "level": "Error"
+    },
     "DoubleModule": {
       "message": "double module {0} in {1}",
       "fix": "load {0} only once",
@@ -58,12 +65,12 @@
     },
     "MismatchedPath": {
       "message": "mismatched path {0}: {1}",
-      "fix": "if unintentional, fix the type or the caller",
+      "fix": "fix the type or the caller",
       "level": "Info"
     },
     "MismatchedType": {
       "message": "mismatched type: {0}",
-      "fix": "if unintentional, fix the type or the caller",
+      "fix": "fix the type or the caller",
       "level": "Info"
     },
     "ModuleHasNoHooks": {
@@ -88,7 +95,7 @@
     },
     "NoFileForPath": {
       "message": "no file for {0}",
-      "fix": "if unintentional create a file at {1}{0}",
+      "fix": "create a file at {1}{0}",
       "level": "Info"
     },
     "NoHandlerForExtension": {
@@ -98,7 +105,7 @@
     },
     "NoRouteToPath": {
       "message": "no {0} route to {1}",
-      "fix": "if unintentional create a {3} route function at {2}.js",
+      "fix": "create a {0} route function at {2}.js",
       "level": "Info"
     },
     "ReservedTypeName": {

package/src/handlers/html.js

@@ -2,22 +2,19 @@ import {Response, Status, MediaType} from "runtime-compat/http";
 
 const script = /(?<=<script)>(?<code>.*?)(?=<\/script>)/gus;
 const style = /(?<=<style)>(?<code>.*?)(?=<\/style>)/gus;
+const remove = /<(?<tag>script|style)>.*?<\/\k<tag>>/gus;
+const inline = true;
 
-const integrate = async (html, publish) => {
-  await Promise.all([...html.matchAll(script)]
-    .map(({groups: {code}}) => publish({code, inline: true})));
-  await Promise.all([...html.matchAll(style)]
-    .map(({groups: {code}}) => publish({code, type: "style", inline: true})));
-  return html.replaceAll(/<(?<tag>script|style)>.*?<\/\k<tag>>/gus, _ => "");
-};
-
-export default (component, options = {}) => {
-  const {status = Status.OK, partial = false, load = false} = options;
+export default (name, options = {}) => {
+  const {status = Status.OK, partial = false} = options;
 
   return async app => {
-    const body = await integrate(await load ?
-      await app.paths.components.join(component).text() : component,
-    app.publish);
+    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 body = html.replaceAll(remove, _ => "");
     // needs to happen before app.render()
     const headers = app.headers();
 

package/src/handlers/view.js

@@ -1,8 +1,7 @@
- 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);
-  const handler = app.handlers[ending];
-  return handler?.(name, {load: true, ...props}, options)(app, ...rest)
-    ?? errors.NoHandlerForExtension.throw(ending, name);
+  const extension = name.slice(name.lastIndexOf(".") + 1);
+  return app.handlers[extension]?.(name, props, options)(app, ...rest)
+    ?? errors.NoHandlerForExtension.throw(extension, name);
 };

package/src/hooks/bundle.js

@@ -1,18 +1,3 @@
-import {File} from "runtime-compat/fs";
+import {cascade} from "runtime-compat/async";
 
-const pre = async app => {
-  const {paths, config, build} = app;
-  if (await paths.static.exists) {
-    // copy static files to build/client/static
-    await File.copy(paths.static, build.paths.client.join(config.build.static));
-  }
-};
-
-export default async (app, bundle) => {
-  await pre(app);
-  if (bundle) {
-    app.log.info("running bundle hooks", {module: "primate"});
-    await [...app.modules.bundle, _ => _]
-      .reduceRight((acc, handler) => input => handler(input, acc))(app);
-  }
-};
+export default app => cascade(app.modules.bundle)(app);

package/src/hooks/compile.js

@@ -1,29 +1,39 @@
+import {Path} from "runtime-compat/fs";
+import {cascade} from "runtime-compat/async";
 import copy_includes from "./copy_includes.js";
+import cwd from "../cwd.js";
+
+const html = /^.*.html$/u;
+const defaults = cwd(import.meta, 2).join("defaults");
 
 const pre = async app => {
-  const {build, paths, config} = app;
+  const {config: {location}, path} = app;
 
   // remove build directory in case exists
-  if (await paths.build.exists) {
-    await paths.build.file.remove();
+  if (await path.build.exists) {
+    await path.build.file.remove();
   }
-  await build.paths.server.file.create();
-  await build.paths.components.file.create();
+  await Promise.all(["server", "client", "components", "pages"]
+    .map(directory => app.runpath(directory).file.create()));
+
+  // copy framework pages
+  await app.stage(defaults, location.pages, html);
+  // overwrite transformed pages to build
+  await path.pages.exists && await app.stage(path.pages, location.pages, html);
 
-  if (await paths.components.exists) {
+  if (await path.components.exists) {
     // 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));
+    await app.stage(path.components, location.components);
+    // copy .js files from components to build/server, since frontend
+    // frameworks handle non-js files
+    const to = Path.join(location.server, location.components);
+    await app.stage(path.components, to, /^.*.js$/u);
   }
 
   // copy additional subdirectories to build/server
-  await copy_includes(app, "server");
-};
+  await copy_includes(app, location.server);
 
-export default async app => {
-  await pre(app);
-  app.log.info("running compile hooks", {module: "primate"});
-  await [...app.modules.compile, _ => _]
-    .reduceRight((acc, handler) => input => handler(input, acc))(app);
+  return app;
 };
+
+export default async app => cascade(app.modules.compile)(await pre(app));

package/src/hooks/copy_includes.js

@@ -1,11 +1,11 @@
-const system = ["routes", "components", "build"];
+import {Path} from "runtime-compat/fs";
 
 export default async (app, type, post = () => undefined) => {
   const {config} = app;
   const {build} = config;
   const {includes} = build;
 
-  const reserved = system.concat(build.static, build.app, build.modules);
+  const reserved = Object.values(app.config.location);
 
   if (Array.isArray(includes)) {
     await Promise.all(includes
@@ -14,9 +14,8 @@ export default async (app, type, post = () => undefined) => {
       .map(async include => {
         const path = app.root.join(include);
         if (await path.exists) {
-          const to = app.build.paths[type].join(include);
-          await to.file.create();
-          await app.copy(path, to);
+          const to = Path.join(type, include);
+          await app.stage(path, to);
           await post(to);
         }
       }));

package/src/hooks/exports.js

@@ -1,3 +1,4 @@
+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";

package/src/hooks/handle.js

@@ -1,5 +1,5 @@
 import {Response, Status, MediaType} from "runtime-compat/http";
-import {tryreturn} from "runtime-compat/async";
+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";
@@ -9,18 +9,18 @@ const {NoFileForPath} = _errors;
 const guardError = Symbol("guardError");
 
 export default app => {
-  const {config: {http: {static: {root}}, build}, paths} = app;
+  const {config: {http: {static: {root}}, location}} = app;
 
-  const route = async request => {
+  const as_route = async request => {
     const {pathname} = request.url;
     // if NoFileForPath is thrown, this will remain undefined
-    let errorHandler = app.error.default;
+    let error_handler = app.error.default;
 
     return tryreturn(async _ => {
       const {path, guards, errors, layouts, handler} = invalid(pathname)
-        ? NoFileForPath.throw(pathname, paths.static)
+        ? NoFileForPath.throw(pathname, location.static)
         : await app.route(request);
-      errorHandler = errors?.at(-1);
+      error_handler = errors?.at(-1);
 
       // handle guards
       try {
@@ -43,21 +43,20 @@ export default app => {
       }
 
       // handle request
-      const handlers = [...app.modules.route, handler]
-        .reduceRight((next, last) => input => last(input, next));
-      return (await respond(await handlers({...request, path})))(app, {
+      const response = cascade(app.modules.route, handler)({...request, path});
+      return (await respond(await response))(app, {
         layouts: await Promise.all(layouts.map(layout => layout(request))),
       }, request);
     }).orelse(async error => {
       app.log.auto(error);
 
       // the +error.js page itself could fail
-      return tryreturn(_ => respond(errorHandler(request))(app, {}, request))
+      return tryreturn(_ => respond(error_handler(request))(app, {}, request))
         .orelse(_ => clientError()(app, {}, request));
     });
   };
 
-  const asset = async file => new Response(file.readable, {
+  const as_asset = async file => new Response(file.readable, {
     status: Status.OK,
     headers: {
       "Content-Type": MediaType.resolve(file.name),
@@ -65,22 +64,23 @@ export default app => {
     },
   });
 
+  const client = app.runpath(location.client);
   const handle = async request => {
     const {pathname} = request.url;
     if (pathname.startsWith(root)) {
       const debased = pathname.replace(root, _ => "");
-      const {client} = app.build.paths;
       // try static first
-      const _static = client.join(build.static, debased);
-      if (await _static.isFile) {
-        return asset(_static.file);
+      const asset = client.join(location.static, debased);
+      if (await asset.isFile) {
+        return as_asset(asset.file);
+      }
+      const path = client.join(debased);
+      if (await path.isFile) {
+        return as_asset(path.file);
       }
-      const _app = client.join(debased);
-      return await _app.isFile ? asset(_app.file) : route(request);
     }
-    return route(request);
+    return as_route(request);
   };
 
-  return [...app.modules.handle, handle]
-    .reduceRight((next, last) => input => last(input, next));
+  return cascade(app.modules.handle, handle);
 };

package/src/hooks/init.js

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

package/src/hooks/parse.js

@@ -6,10 +6,13 @@ import errors from "../errors.js";
 
 const {APPLICATION_FORM_URLENCODED, APPLICATION_JSON} = MediaType;
 
+const {decodeURIComponent: decode} = globalThis;
+const deslash = url => url.replaceAll(/(?<!http:)\/{2,}/gu, _ => "/");
+
 const contents = {
   [APPLICATION_FORM_URLENCODED]: body => from(body.split("&")
     .map(part => part.split("=")
-      .map(subpart => decodeURIComponent(subpart).replaceAll("+", " ")))),
+      .map(subpart => decode(subpart).replaceAll("+", " ")))),
   [APPLICATION_JSON]: body => JSON.parse(body),
 };
 
@@ -19,7 +22,7 @@ const content = (type, body) =>
 
 export default dispatch => async original => {
   const {headers} = original;
-  const url = new URL(original.url);
+  const url = new URL(deslash(decode(original.url)));
   const body = await stringify(original.body);
   const cookies = headers.get("cookie");
 

package/src/hooks/publish.js

@@ -1,20 +1,26 @@
 import {Path} from "runtime-compat/fs";
-import {identity} from "runtime-compat/function";
+import {cascade} from "runtime-compat/async";
 import copy_includes from "./copy_includes.js";
 
 const post = async app => {
-  const {config, paths} = app;
-  const build = config.build.app;
+  const {config: {location, http: {static: {root}}}, path} = app;
+
   {
     // after hook, publish a zero assumptions app.js (no css imports)
-    const code = app.entrypoints.filter(({type}) => type === "script")
-      .map(entrypoint => entrypoint.code).join("");
-    const src = new Path(config.http.static.root, build, config.build.index);
-    await app.publish({src, code, type: "module"});
-
-    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 src = new Path(root, app.config.build.index);
+
+    await app.publish({
+      code: app.exports.filter(({type}) => type === "script")
+        .map(({code}) => code).join(""),
+      src,
+      type: "module",
+    });
+
+    if (await path.components.exists) {
+      // copy .js files from components to build/client, since frontend
+      // frameworks handle non-js files
+      const to = Path.join(location.client, location.components);
+      await app.stage(path.components, to, /^.*.js$/u);
     }
 
     const imports = {...app.importmaps, app: src.path};
@@ -25,34 +31,33 @@ const post = async app => {
     });
   }
 
-  // copy JavaScript and CSS files from `app.paths.static`
-  const imports = await Path.collect(app.paths.static, /\.(?:js|css)$/u);
-  await Promise.all(imports.map(async file => {
-    const code = await file.text();
-    const src = file.name;
-    const isCSS = file.extension === ".css";
-    await app.publish({src: `${config.build.static}/${src}`, code,
-      type: isCSS ? "style" : "module"});
-    if (isCSS) {
-      app.bootstrap({type: "style",
-        code: `import "../${config.build.static}/${file.name}";`});
-    }
-  }));
+  if (await path.static.exists) {
+    // copy static files to build/static
+    await app.stage(path.static, new Path(location.client, location.static));
+
+    // publish JavaScript and CSS files
+    const imports = await Path.collect(path.static, /\.(?:js|css)$/u);
+    await Promise.all(imports.map(async file => {
+      const code = await file.text();
+      const src = `/${file.name}`;
+      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.client}/${location.static}${src}";`});
+    }));
+  }
 
-  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 =>
+  const client = app.runpath(location.client);
+  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(source, () => ""));
+      const src = new Path(root, script.path.replace(client, _ => ""));
       await app.publish({src, code: await script.text(), type: "module"});
     }))
   );
-};
 
-export default async app => {
-  app.log.info("running publish hooks", {module: "primate"});
-  await [...app.modules.publish, identity]
-    .reduceRight((acc, handler) => input => handler(input, acc))(app);
-  await post(app);
+  return app;
 };
+
+export default async app => post(await cascade(app.modules.publish)(app));

package/src/hooks/register.js

@@ -1,5 +1,3 @@
-export default async app => {
-  app.log.info("running register hooks", {module: "primate"});
-  await [...app.modules.register, _ => _]
-    .reduceRight((acc, handler) => input => handler(input, acc))(app);
-};
+import {cascade} from "runtime-compat/async";
+
+export default app => cascade(app.modules.register)(app);

package/src/hooks/route.js

@@ -1,4 +1,4 @@
-import {keymap} from "runtime-compat/object";
+import {from} from "runtime-compat/object";
 import {tryreturn} from "runtime-compat/sync";
 import errors from "../errors.js";
 import validate from "../validate.js";
@@ -9,39 +9,45 @@ const ieq = (left, right) => left.toLowerCase() === right.toLowerCase();
 /* routes may not contain dots */
 export const invalid = route => /\./u.test(route);
 
+const deroot = pathname => pathname.endsWith("/") && pathname !== "/"
+    ? pathname.slice(0, -1) : pathname;
+
 export default app => {
-  const {types, routes, config: {explicit, paths}} = app;
+  const {types, routes, config: {types: {explicit}, location}} = app;
+
+  const to_path = (route, pathname) => app.dispatch(from(Object
+    .entries(route.pathname.exec(pathname)?.groups ?? {})
+    .map(([name, value]) =>
+      [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)]
+    )));
 
-  const isType = (groups, pathname) => Object
+  const is_type = (groups, pathname) => Object
     .entries(groups ?? {})
     .map(([name, value]) =>
       [types[name] === undefined || explicit ? name : `${name}$${name}`, value])
     .filter(([name]) => name.includes("$"))
-    .map(([name, value]) => [name.split("$")[1], value])
-    .every(([name, value]) =>
-      tryreturn(_ => validate(types[name], value, name))
+    .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 isPath = ({route, pathname}) => {
+  const is_path = ({route, pathname}) => {
     const result = route.pathname.exec(pathname);
-    return result === null ? false : isType(result.groups, pathname);
+    return result === null ? false : is_type(result.groups, pathname);
   };
-  const isMethod = ({route, method, pathname}) => ieq(route.method, method)
-    && isPath({route, pathname});
+  const is_method = ({route, method, pathname}) => ieq(route.method, method)
+    && is_path({route, pathname});
   const find = (method, pathname) => routes.find(route =>
-    isMethod({route, method, pathname}));
+    is_method({route, method, pathname}));
 
-  const index = path => `${paths.routes}${path === "/" ? "/index" : path}`;
-  const deroot = pathname => pathname.endsWith("/") && pathname !== "/"
-    ? pathname.slice(0, -1) : pathname;
+  const index = path => `${location.routes}${path === "/" ? "/index" : path}`;
 
   return ({original: {method}, url}) => {
     const pathname = deroot(url.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]));
-
-    return {...route, path};
+      .throw(method.toLowerCase(), pathname, index(pathname));
+    return {...route, path: to_path(route, pathname)};
   };
 };

package/src/hooks/serve.js

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

package/src/loaders/modules.js

@@ -4,13 +4,10 @@ import errors from "../errors.js";
 
 const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
 
-const load = (app, modules = []) => {
-  return modules.map(module =>
-    [module, load(app, module.load?.(app) ?? [])]
-  ).flat();
-};
+const load = (modules = []) => modules.map(module =>
+  [module, load(module.load?.() ?? [])]).flat();
 
-export default async (app, root, config) => {
+export default async (log, root, config) => {
   const modules = config.modules ?? [];
 
   Array.isArray(modules) || errors.ModulesMustBeArray.throw("modules");
@@ -23,17 +20,12 @@ export default async (app, root, config) => {
     errors.DoubleModule.throw(doubled(names), root.join("primate.config.js"));
 
   const hookless = modules.filter(module => !Object.keys(module).some(key =>
-    [...Object.keys(hooks), "load", "init"].includes(key)));
-  hookless.length > 0 && errors.ModuleHasNoHooks.warn(app.log,
+    [...Object.keys(hooks), "load"].includes(key)));
+  hookless.length > 0 && errors.ModuleHasNoHooks.warn(log,
     hookless.map(({name}) => name).join(", "));
 
   // collect modules
-  const loaded = load(app, modules).flat(2);
-
-  // initialize modules
-  await Promise.all(loaded
-    .filter(module => module.init !== undefined)
-    .map(module => module.init(app)));
+  const loaded = load(modules).flat(2);
 
   return Object.fromEntries(Object.keys(hooks)
     .map(hook => [hook, filter(hook, loaded)]));

package/src/loaders/routes/load.js

@@ -1,12 +1,12 @@
 import {Path} from "runtime-compat/fs";
 import errors from "../../errors.js";
-import toSorted from "../../toSorted.js";
+import to_sorted from "../../to_sorted.js";
 
 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 = toSorted((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.js

@@ -1,5 +1,5 @@
 import {tryreturn} from "runtime-compat/sync";
-import {from, filter, valmap} from "runtime-compat/object";
+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";

package/src/run.js

@@ -10,7 +10,7 @@ import defaults from "./defaults/primate.config.js";
 let logger = new Logger({level: Logger.Warn});
 const {runtime = "node"} = import.meta;
 
-const getConfig = async root => {
+const get_config = async root => {
   const name = "primate.config.js";
   const config = root.join(name);
   return await config.exists
@@ -26,19 +26,16 @@ const getConfig = async root => {
     : defaults;
 };
 
-export default async name => {
-  try {
-    // use module root if possible, fall back to current directory
-    const root = await tryreturn(_ => Path.root()).orelse(_ => Path.resolve());
-    const config = await getConfig(root);
-    logger = new Logger(config.logger);
-    await command(name)(await app(config, root, logger));
-  } catch (error) {
-    if (error.level === Logger.Error) {
-      logger.auto(error);
-      bye();
-    } else {
-      throw error;
-    }
+export default async name => tryreturn(async _ => {
+  // use module root if possible, fall back to current directory
+  const root = await tryreturn(_ => Path.root()).orelse(_ => Path.resolve());
+  const config = await get_config(root);
+  logger = new Logger(config.logger);
+  await command(name)(await app(logger, root, config));
+}).orelse(error => {
+  if (error.level === Logger.Error) {
+    logger.auto(error);
+    return bye();
   }
-};
+  throw error;
+});

package/src/start.js

@@ -1,21 +1,18 @@
 import {serve, Response, Status} from "runtime-compat/http";
-import {tryreturn} from "runtime-compat/async";
-import {identity} from "runtime-compat/function";
+import {cascade, tryreturn} from "runtime-compat/async";
 import * as hooks from "./hooks/exports.js";
 
-export default async (app, operations = {}) => {
-  // register handlers
-  await hooks.register({...app, register(name, handler) {
-    app.handlers[name] = handler;
-  }});
+export default async (app$, deactivated = []) => {
+  // run one-time hooks
+  const app = await cascade(["init", "register", "compile", "publish", "bundle"]
+    .filter(hook => !deactivated.includes(hook))
+    .map(hook => async (input, next) => {
+      app$.log.info(`running ${hook} hooks`, {module: "primate"});
+      return next(await hooks[hook](input));
+    }))(app$);
 
-  // compile server-side code
-  await hooks.compile(app);
-  // publish client-side code
-  await hooks.publish(app);
-
-  // bundle client-side code
-  await hooks.bundle(app, operations?.bundle);
+  app.route = hooks.route(app);
+  app.parse = hooks.parse(app.dispatch);
 
   const server = await serve(async request =>
     tryreturn(async _ => hooks.handle(app)(await app.parse(request)))
@@ -25,8 +22,5 @@ export default async (app, operations = {}) => {
       }),
   app.config.http);
 
-  await [...app.modules.serve, identity]
-    .reduceRight((acc, handler) => input => handler(input, acc))({
-      ...app, server,
-    });
+  await cascade(app.modules.serve)({...app, server});
 };