primate 0.29.7 → 0.30.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.29.7",
+  "version": "0.30.0",
   "description": "Polymorphic development platform",
   "homepage": "https://primatejs.com",
   "bugs": "https://github.com/primatejs/primate/issues",
@@ -19,7 +19,7 @@
     "directory": "packages/primate"
   },
   "dependencies": {
-    "rcompat": "^0.8.3"
+    "rcompat": "^0.9.4"
   },
   "engines": {
     "node": ">=18"

package/src/Logger.js

@@ -1,6 +1,6 @@
 import { assert, is } from "rcompat/invariant";
 import { blue, bold, green, red, yellow, dim } from "rcompat/colors";
-import { map } from "rcompat/object";
+import o from "rcompat/object";
 import console from "rcompat/console";
 import { stdout } from "rcompat/stdio";
 
@@ -16,7 +16,7 @@ const mark = (format, ...params) => params.reduce((formatted, param, i) =>
   formatted.replace(`{${i}}`, bold(param)), format);
 
 const reference = (module, error) => {
-  const base = module ? `modules/${module}` : "guide/logging";
+  const base = module === "primate" ? "guide/logging" : `modules/${module}`;
   return `https://primatejs.com/${base}#${hyphenate(error)}`;
 };
 
@@ -49,7 +49,7 @@ const Logger = class Logger {
   #level; #trace;
 
   static err(errors, module) {
-    return map(errors, ([key, value]) => [key, throwable(value, key, module)]);
+    return o.map(errors, ([key, value]) => [key, throwable(value, key, module)]);
   }
 
   constructor({ level = levels.Error, trace = false } = {}) {
@@ -101,7 +101,7 @@ const Logger = class Logger {
 
   auto(error) {
     const { message } = error;
-    const matches = map(levels, ([name, level]) => [level, name.toLowerCase()]);
+    const matches = o.map(levels, ([key, level]) => [level, key.toLowerCase()]);
     return this[matches[error.level] ?? "error"](message, error);
   }
 };

package/src/app.js

@@ -2,9 +2,10 @@ import crypto from "rcompat/crypto";
 import { tryreturn } from "rcompat/async";
 import { File } from "rcompat/fs";
 import { is } from "rcompat/invariant";
-import { transform, valmap, to } from "rcompat/object";
+import o from "rcompat/object";
 import { globify } from "rcompat/string";
 import * as runtime from "rcompat/meta";
+import { identity } from "rcompat/function";
 import { Response, Status, MediaType } from "rcompat/http";
 
 import errors from "./errors.js";
@@ -14,8 +15,19 @@ import * as loaders from "./loaders/exports.js";
 
 const { DoubleFileExtension } = errors;
 
+const to_csp = (config_csp, assets, csp) => config_csp
+  // only csp entries in the config will be enriched
+  .map(([key, directives]) =>
+    // enrich with application assets
+    [key, assets[key] ? directives.concat(...assets[key]) : directives])
+  .map(([key, directives]) =>
+    // enrich with explicit csp
+    [key, csp[key] ? directives.concat(...csp[key]) : directives])
+  .map(([key, directives]) => `${key} ${directives.join(" ")}`)
+  .join(";");
+
 // use user-provided file or fall back to default
-const get_index = (base, page, fallback) =>
+const load = (base, page, fallback) =>
   tryreturn(_ => File.text(`${base.join(page)}`))
     .orelse(_ => File.text(`${base.join(fallback)}`));
 
@@ -52,13 +64,10 @@ const render_head = (assets, head) =>
         : tags.script({ inline, code, type, integrity, src }),
     ).join("\n").concat("\n", head ?? "");
 
-const { name, version } = await new File(import.meta.url).up(2)
-  .join(runtime.manifest).json();
-
 export default async (log, root, config) => {
   const { http } = config;
   const secure = http?.ssl !== undefined;
-  const path = valmap(config.location, value => root.join(value));
+  const path = o.valmap(config.location, value => root.join(value));
 
   // if ssl activated, resolve key and cert early
   if (secure) {
@@ -69,16 +78,15 @@ export default async (log, root, config) => {
   const error = await path.routes.join("+error.js");
 
   return {
-    config,
     secure,
-    name,
-    version,
     importmaps: {},
     assets: [],
     exports: [],
     path,
     root,
     log,
+    // pseudostatic thus arrowbound
+    get: (config_key, fallback) => o.get(config, config_key) ?? fallback,
     error: {
       default: await error.exists() ? await error.import("default") : undefined,
     },
@@ -88,11 +96,11 @@ export default async (log, root, config) => {
         handle: handlers.html,
       },
     },
-    modules: await loaders.modules(log, root, config),
+    modules: await loaders.modules(log, root, config.modules ?? []),
     ...runtime,
     // copy files to build folder, potentially transforming them
     async stage(source, directory, filter) {
-      const { paths, mapper } = this.config.build.transform;
+      const { paths = [], mapper = identity } = this.get("build.transform", {});
       is(paths).array();
       is(mapper).function();
 
@@ -110,7 +118,7 @@ export default async (log, root, config) => {
       }));
     },
     async compile(component) {
-      const { location: { server, client, components } } = this.config;
+      const { server, client, components } = this.get("location");
 
       const source = this.path.components;
       const compile = this.extensions[component.fullExtension]?.compile
@@ -133,41 +141,37 @@ export default async (log, root, config) => {
         await compile.client(component);
       }
     },
-    headers({ script = "", style = "" } = {}) {
-      const csp = Object.keys(http.csp).reduce((policy, key) =>
-        `${policy}${key} ${http.csp[key]};`, "")
-        .replace("script-src 'self'", `script-src 'self' ${script} ${this.assets
-          .filter(({ type }) => type !== "style")
-          .map(asset => `'${asset.integrity}'`).join(" ")
-        }`)
-        .replace("style-src 'self'", `style-src 'self' ${style} ${this.assets
-          .filter(({ type }) => type === "style")
-          .map(asset => `'${asset.integrity}'`).join(" ")
-        }`);
+    headers(csp = {}) {
+      const http_csp = Object.entries(this.get("http.csp", {}));
 
-      return { "Content-Security-Policy": csp, "Referrer-Policy": "same-origin" };
+      return {
+        ...this.get("http.headers", {}),
+        ...http_csp.length === 0 ? {} : {
+          "Content-Security-Policy": to_csp(http_csp, this.asset_csp, csp),
+        },
+      };
     },
     runpath(...directories) {
       return this.path.build.join(...directories);
     },
     async render(content) {
-      const { assets, config: { location, pages: { index } } } = this;
+      const index = this.get("pages.index");
       const { body, head, partial, placeholders = {}, page = index } = content;
       ["body", "head"].every(used => is(placeholders[used]).undefined());
 
-      return partial ? body : to(placeholders)
+      return partial ? body : Object.entries(placeholders)
         // replace given placeholders, defaulting to ""
         .reduce((html, [key, value]) => html.replace(`%${key}%`, value ?? ""),
-          await get_index(this.runpath(location.pages), page, index))
+          await load(this.runpath(this.get("location.pages")), page, index))
         // replace non-given placeholders, aside from %body% / %head%
         .replaceAll(/(?<keep>%(?:head|body)%)|%.*?%/gus, "$1")
         // replace body and head
         .replace("%body%", body)
-        .replace("%head%", render_head(assets, head));
+        .replace("%head%", render_head(this.assets, head));
     },
     respond(body, { status = Status.OK, headers = {} } = {}) {
       return new Response(body, { status, headers: {
-        ...this.headers(), "Content-Type": MediaType.TEXT_HTML, ...headers },
+        "Content-Type": MediaType.TEXT_HTML, ...this.headers(), ...headers },
       });
     },
     async view(options) {
@@ -182,11 +186,11 @@ export default async (log, root, config) => {
       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}'` };
+      return { head, integrity: `'${integrity}'` };
     },
     async publish({ src, code, type = "", inline = false, copy = true }) {
       if (!inline && copy) {
-        const base = this.runpath(this.config.location.client).join(src);
+        const base = this.runpath(this.get("location.client")).join(src);
         await base.directory.create();
         await base.write(code);
       }
@@ -199,6 +203,13 @@ export default async (log, root, config) => {
           integrity: await this.hash(code),
         });
       }
+      // rehash assets_csp
+      this.asset_csp = this.assets.map(({ type: directive, integrity }) => [
+        `${directive === "style" ? "style" : "script"}-src`, integrity])
+        .reduce((csp, [directive, hash]) =>
+          ({ ...csp, [directive]: csp[directive].concat(`'${hash}'`) } ),
+          { "style-src": [], "script-src": [] },
+        );
     },
     export({ type, code }) {
       this.exports.push({ type, code });
@@ -214,14 +225,12 @@ export default async (log, root, config) => {
       return `${prefix}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
     },
     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 File.resolve().join(...path, this.manifest).json();
       const exports = pkg.exports === undefined
         ? { [module]: `/${module}/${pkg.main}` }
-        : transform(pkg.exports, entry => entry
+        : o.transform(pkg.exports, entry => entry
           .filter(([, export$]) =>
             export$.browser?.[deep_import] !== undefined
             || export$.browser?.default !== undefined
@@ -236,10 +245,10 @@ export default async (log, root, config) => {
               ?? value.import?.replace(".", `./${module}`),
           ]));
       const dependency = File.resolve().join(...path);
-      const target = File.join(this.runpath(client), this.library, ...parts);
+      const target = this.runpath(this.get("location.client")).join(...path);
       await dependency.copy(target);
-      this.importmaps = { ...valmap(exports, value =>
-        File.join(root, this.library, value).normalize()),
+      this.importmaps = { ...o.valmap(exports, value =>
+        File.join(this.get("http.static.root"), this.library, value).webpath()),
         ...this.importmaps };
     },
   };

package/src/defaults/primate.config.js

@@ -15,19 +15,16 @@ export default {
   http: {
     host: "localhost",
     port: 6161,
-    csp: {
-      "default-src": "'self'",
-      "style-src": "'self'",
-      "script-src": "'self'",
-      "object-src": "'none'",
-      "frame-ancestors": "'none'",
-      "form-action": "'self'",
-      "base-uri": "'self'",
-    },
+    csp: {},
     static: {
       root: "/",
     },
   },
+  request: {
+    body: {
+      parse: true,
+    },
+  },
   location: {
     // renderable components
     components: "components",
@@ -54,7 +51,4 @@ export default {
       mapper: identity,
     },
   },
-  types: {
-    explicit: false,
-  },
 };

package/src/dispatch.js

@@ -1,21 +1,21 @@
 import { is } from "rcompat/invariant";
 import { tryreturn } from "rcompat/sync";
-import { map } from "rcompat/object";
+import o from "rcompat/object";
 import { camelcased } from "rcompat/string";
 import errors from "./errors.js";
 import validate from "./validate.js";
 
 export default (patches = {}) => (object, raw, cased = true) => {
   return Object.assign(Object.create(null), {
-    ...map(patches, ([name, patch]) => [`get${camelcased(name)}`, property => {
-      is(property).defined(`\`${name}\` called without property`);
-      return tryreturn(_ => validate(patch, object[property], property))
+    ...o.map(patches, ([name, patch]) => [`get${camelcased(name)}`, key => {
+      is(key).defined(`\`${name}\` called without key`);
+      return tryreturn(_ => validate(patch, object[key], key))
         .orelse(({ message }) => errors.MismatchedType.throw(message));
     }]),
-    get(property) {
-      is(property).string();
+    get(key) {
+      is(key).string();
 
-      return object[cased ? property : property.toLowerCase()];
+      return object[cased ? key : key.toLowerCase()];
     },
     json() {
       return JSON.parse(JSON.stringify(object));

package/src/errors.json

@@ -1,11 +1,6 @@
 {
   "module": "primate",
   "errors": {
-    "MismatchedBody": {
-      "message": "{0}: {1}",
-      "fix": "make sure the body payload corresponds to the used content type",
-      "level": "Error"
-    },
     "DoubleFileExtension": {
       "message": "double file extension {0}",
       "fix": "unload one of the two handlers registering the file extension",
@@ -26,9 +21,19 @@
       "fix": "disambiguate routes",
       "level": "Error"
     },
+    "EmptyConfigFile": {
+      "message": "empty config file at {0}",
+      "fix": "add configuration options to the file or remove it",
+      "level": "Warn"
+    },
+    "EmptyPathParameter": {
+      "message": "empty path parameter {0} in route {1}",
+      "fix": "name the parameter or remove it",
+      "level": "Error"
+    },
     "EmptyRouteFile": {
       "message": "empty route file at {0}",
-      "fix": "add routes or remove file",
+      "fix": "add routes to the file or remove it",
       "level": "Warn"
     },
     "EmptyDirectory": {
@@ -41,14 +46,19 @@
       "fix": "check errors in config file by running {1}",
       "level": "Error"
     },
+    "InvalidBodyReturned": {
+      "message": "invalid body returned from route, got {0}",
+      "fix": "return a proper body from route",
+      "level": "Error"
+    },
     "InvalidDefaultExport": {
       "message": "invalid default export at {0}",
       "fix": "use only functions for the default export",
       "level": "Error"
     },
-    "InvalidPathParameter": {
-      "message": "invalid path parameter {0} in route {1}",
-      "fix": "use only latin letters and decimal digits in path parameters",
+    "InvalidPath": {
+      "message": "invalid path {0}",
+      "fix": "use only letters, digits, '_', '[', ']' or '=' in path filenames",
       "level": "Error"
     },
     "InvalidTypeExport": {
@@ -61,6 +71,11 @@
       "fix": "use lowercase-first latin letters and decimals in type names",
       "level": "Error"
     },
+    "MismatchedBody": {
+      "message": "{0}: {1}",
+      "fix": "make sure the body payload corresponds to the used content type",
+      "level": "Error"
+    },
     "MismatchedPath": {
       "message": "mismatched path {0}: {1}",
       "fix": "fix the type or the caller",
@@ -86,11 +101,6 @@
       "fix": "change {0} to an array in the config or remove this property",
       "level": "Error"
     },
-    "EmptyConfigFile": {
-      "message": "empty config file at {0}",
-      "fix": "add configuration options or remove file",
-      "level": "Warn"
-    },
     "NoHandlerForComponent": {
       "message": "no handler for {0}",
       "fix": "add handler module for this component or remove {0}",

package/src/handlers.js

@@ -43,7 +43,7 @@ const redirect = (Location, { status = Status.FOUND } = {}) => app =>
 // }}}
 // {{{ error
 const error = (body = "Not Found", { status = Status.NOT_FOUND, page } = {}) =>
-  app => app.view({ body, status, page: page ?? app.config.pages.error });
+  app => app.view({ body, status, page: page ?? app.get("pages.error") });
 // }}}
 // {{{ html
 const script_re = /(?<=<script)>(?<code>.*?)(?=<\/script>)/gus;
@@ -55,15 +55,15 @@ const html = (name, options) => async app => {
     .map(({ groups: { code } }) => app.inline(code, "module")));
   const styles = await Promise.all([...component.matchAll(style_re)]
     .map(({ groups: { code } }) => app.inline(code, "style")));
-  const assets = [...scripts, ...styles];
+  const style_src = styles.map(asset => asset.integrity);
+  const script_src = scripts.map(asset => asset.integrity);
 
-  const body = component.replaceAll(remove, _ => "");
-  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 = app.headers({ script, style });
-
-  return app.view({ body, head, headers, ...options });
+  return app.view({
+    body: component.replaceAll(remove, _ => ""),
+    head: [...scripts, ...styles].map(asset => asset.head).join("\n"),
+    headers: app.headers({ "style-src": style_src, "script-src": script_src }),
+    ...options,
+  });
 };
 // }}}
 // {{{ view

package/src/hooks/copy_includes.js

@@ -1,11 +1,8 @@
 import { File } from "rcompat/fs";
 
 export default async (app, type, post = () => undefined) => {
-  const { config } = app;
-  const { build } = config;
-  const { includes } = build;
-
-  const reserved = Object.values(app.config.location);
+  const includes = app.get("build.includes");
+  const reserved = Object.values(app.get("location"));
 
   if (Array.isArray(includes)) {
     await Promise.all(includes

package/src/hooks/handle.js

@@ -33,9 +33,13 @@ const get_layouts = async (layouts, request) => {
     .slice(stop_at === -1 ? 0 : stop_at)
     .map(layout => layout.default(request)));
 };
+// last handler, preserve final request form
+const last = handler => async request => {
+  const response = await handler(request);
+  return { request, response };
+};
 
 export default app => {
-  const { config: { http: { static: { root } }, location } } = app;
   const route = request => app.route(request);
 
   const as_route = async request => {
@@ -47,15 +51,13 @@ export default app => {
 
       error_handler = errors?.at(-1);
 
-      const pathed = { ...request, path };
-
-      const hooks = [...app.modules.route, guard(app, guards)];
+      const hooks = [...app.modules.route, guard(app, guards), last(handler)];
 
       // handle request
-      const response = await (await cascade(hooks, handler))(pathed);
+      const routed = await (await cascade(hooks))({ ...request, path });
 
-      const $layouts = { layouts: await get_layouts(layouts, request) };
-      return (await respond(response))(app, $layouts, pathed);
+      const $layouts = { layouts: await get_layouts(layouts, routed.request) };
+      return (await respond(routed.response))(app, $layouts, routed.request);
     }).orelse(async error => {
       app.log.auto(error);
 
@@ -73,6 +75,8 @@ export default app => {
     },
   });
 
+  const location = app.get("location");
+  const root = app.get("http.static.root");
   const client = app.runpath(location.client);
   const handle = async request => {
     const { pathname } = request.url;

package/src/hooks/parse.js

@@ -1,23 +1,24 @@
 import { URL, Body } from "rcompat/http";
-import { from, valmap } from "rcompat/object";
+import o from "rcompat/object";
 import { tryreturn } from "rcompat/async";
 import errors from "../errors.js";
 
-const parse_body = (request, url) =>
+const get_body = (request, url) =>
   tryreturn(async _ => await Body.parse(request) ?? {})
     .orelse(error => errors.MismatchedBody.throw(url.pathname, error.message));
 
-export default dispatch => async original => {
+export default app => async original => {
   const { headers } = original;
 
   const url = new URL(globalThis.decodeURIComponent(original.url));
   const cookies = headers.get("cookie");
-  const body = await parse_body(original, url);
 
-  return { original, url, body, ...valmap({
-    query: [from(url.searchParams), url.search],
-    headers: [from(headers), headers, false],
-    cookies: [from(cookies?.split(";").map(cookie =>
+  return { original, url,
+    body: app.get("request.body.parse") ? await get_body(original, url) : {},
+  ...o.valmap({
+    query: [o.from(url.searchParams), url.search],
+    headers: [o.from(headers), headers, false],
+    cookies: [o.from(cookies?.split(";").map(cookie =>
       cookie.trim().split("=")) ?? []), cookies],
-  }, value => dispatch(...value)) };
+  }, value => app.dispatch(...value)) };
 };

package/src/hooks/publish.js

@@ -1,25 +1,21 @@
 import { File } from "rcompat/fs";
 import { cascade } from "rcompat/async";
-import { stringify } from "rcompat/object";
+import o from "rcompat/object";
 
 const post = async app => {
-  const { config: { http: { static: { root } } } } = app;
+  // after hook, publish a zero assumptions app.js (no css imports)
+  const src = File.join(app.get("http.static.root"), app.get("build.index"));
 
-  {
-    // after hook, publish a zero assumptions app.js (no css imports)
-    const src = File.join(root, app.config.build.index);
+  await app.publish({
+    code: app.exports.filter(({ type }) => type === "script")
+      .map(({ code }) => code).join(""),
+    src,
+    type: "module",
+  });
 
-    await app.publish({
-      code: app.exports.filter(({ type }) => type === "script")
-        .map(({ code }) => code).join(""),
-      src,
-      type: "module",
-    });
-
-    const imports = { ...app.importmaps, app: src.normalize() };
-    const type = "importmap";
-    await app.publish({ inline: true, code: stringify({ imports }), type });
-  }
+  const imports = { ...app.importmaps, app: src.webpath() };
+  const type = "importmap";
+  await app.publish({ inline: true, code: o.stringify({ imports }), type });
 
   return app;
 };

package/src/hooks/register.js

@@ -1,44 +1,45 @@
 import { File } from "rcompat/fs";
 import { cascade } from "rcompat/async";
-import cwd from "../cwd.js";
 import copy_includes from "./copy_includes.js";
 
 const html = /^.*.html$/u;
-const defaults = cwd(import.meta, 2).join("defaults");
+const defaults = new File(import.meta.url).up(2).join("defaults");
 
 const pre = async app => {
-  const { config: { location: { pages, client, components } }, path } = app;
+  const location = app.get("location");
+  const { pages, client, components } = location;
 
   // copy framework pages
   await app.stage(defaults, pages, html);
   // overwrite transformed pages to build
-  await path.pages.exists() && await app.stage(path.pages, pages, html);
+  await app.path.pages.exists() && await app.stage(app.path.pages, pages, html);
 
-  if (await path.components.exists()) {
+  if (await app.path.components.exists()) {
     // copy .js files from components to build/client/components, since
     // frontend frameworks handle non-js files
     const target = File.join(client, components);
-    await app.stage(path.components, target, /^.*.js$/u);
+    await app.stage(app.path.components, target, /^.*.js$/u);
   }
 
   return app;
 };
 
 const post = async app => {
-  const { config: { location, http: { static: { root } } }, path } = app;
+  const _static = app.path.static;
+  const location = app.get("location");
 
-  if (await path.static.exists()) {
+  if (await _static.exists()) {
     // copy static files to build/server/static
-    await app.stage(path.static, File.join(location.server, location.static));
+    await app.stage(_static, File.join(location.server, location.static));
 
     // copy static files to build/client/static
-    await app.stage(path.static, File.join(location.client, location.static));
+    await app.stage(_static, File.join(location.client, location.static));
 
     // publish JavaScript and CSS files
-    const imports = await File.collect(path.static, /\.(?:js|css)$/u);
+    const imports = await File.collect(_static, /\.(?:js|css)$/u);
     await Promise.all(imports.map(async file => {
       const code = await file.text();
-      const src = file.debase(path.static);
+      const src = file.debase(_static);
       const type = file.extension === ".css" ? "style" : "module";
       // already copied in `app.stage`
       await app.publish({ src, code, type, copy: false });
@@ -52,6 +53,7 @@ const post = async app => {
 
   // copy additional subdirectories to build/client
   const client = app.runpath(location.client);
+  const root = app.get("http.static.root");
   await copy_includes(app, location.client, async to =>
     Promise.all((await to.collect(/\.js$/u)).map(async script => {
       const src = File.join(root, script.path.replace(client, _ => ""));

package/src/hooks/respond.js

@@ -2,10 +2,9 @@ import { Blob, s_streamable } from "rcompat/fs";
 import { URL, Response } from "rcompat/http";
 import { identity } from "rcompat/function";
 import { text, json, stream, redirect } from "primate";
+import errors from "../errors.js";
 
-const not_found = value => {
-  throw new Error(`no handler found for ${value}`);
-};
+const not_found = value => errors.InvalidBodyReturned.throw(value);
 const is_text = value => typeof value === "string";
 const is_non_null_object = value => typeof value === "object" && value !== null;
 const is_instance = of => value => value instanceof of;

package/src/hooks/route.js

@@ -1,4 +1,4 @@
-import { from } from "rcompat/object";
+import o from "rcompat/object";
 import { tryreturn } from "rcompat/sync";
 import errors from "../errors.js";
 import validate from "../validate.js";
@@ -10,20 +10,17 @@ 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 } = app;
+  const location = app.get("location");
 
-  const to_path = (route, pathname) => app.dispatch(from(Object
+  const to_path = (route, pathname) => app.dispatch(o.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 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("$"), value])
     .map(([[name, type], value]) =>

package/src/hooks/stage.js

@@ -15,16 +15,17 @@ const pre = async app => {
 };
 
 const post = async app => {
-  const { config: { location } } = app;
+  const location = app.get("location");
 
   // stage routes
-  await app.runpath(location.routes).create();
   const double = doubled((await app.path.routes.collect())
     .map(path => path.debase(app.path.routes))
     .map(path => `${path}`.slice(1, -path.extension.length)));
   double && errors.DoubleRoute.throw(double);
 
-  await app.stage(app.path.routes, location.routes);
+  if (await app.path.routes.exists()) {
+    await app.stage(app.path.routes, location.routes);
+  }
   if (await app.path.types.exists()) {
     await app.stage(app.path.types, location.types);
   }

package/src/loaders/modules.js

@@ -7,9 +7,7 @@ const filter = (key, array) => array?.flatMap(m => m[key] ?? []) ?? [];
 const load = (modules = []) => modules.map(module =>
   [module, load(module.load?.() ?? [])]).flat();
 
-export default async (log, root, config) => {
-  const modules = config.modules ?? [];
-
+export default async (log, root, modules) => {
   Array.isArray(modules) || errors.ModulesMustBeArray.throw("modules");
 
   modules.some(({ name }, n) => name === undefined &&

package/src/loaders/routes.js

@@ -1,5 +1,5 @@
 import { tryreturn } from "rcompat/sync";
-import { from } from "rcompat/object";
+import o from "rcompat/object";
 import { File } from "rcompat/fs";
 import { default as fs, doubled } from "./common.js";
 import * as get from "./routes/exports.js";
@@ -7,18 +7,22 @@ import errors from "../errors.js";
 
 const { separator } = File;
 
+const valid_route = /^[\w\-[\]=/.]*$/u;
+
 const make = path => {
+  !valid_route.test(path) && errors.InvalidPath.throw(path);
+
   const double = doubled(path.split(separator)
-    .filter(part => part.startsWith("{") && part.endsWith("}"))
+    .filter(part => part.startsWith("[") && part.endsWith("]"))
     .map(part => part.slice(1, part.indexOf("="))));
   double && errors.DoublePathParameter.throw(double, path);
 
-  const route = path.replaceAll(/\{(?<named>.*?)\}/gu, (_, named) =>
+  const route = path.replaceAll(/\[(?<named>.*?)\]/gu, (_, named) =>
     tryreturn(_ => {
       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)));
+    }).orelse(_ => errors.EmptyPathParameter.throw(named, path)));
 
   // normalize to unix
   return new RegExp(`^/${route.replaceAll(separator, "/")}$`, "u");
@@ -26,9 +30,9 @@ const make = path => {
 
 export default async (app, load = fs) => {
   const { log } = app;
-  const directory = app.runpath(app.config.location.routes);
+  const directory = app.runpath(app.get("location.routes"));
   const filter = path => ([name]) => path.includes(name);
-  const routes = from(await Promise.all(["guards", "errors", "layouts"]
+  const routes = o.from(await Promise.all(["guards", "errors", "layouts"]
     .map(async extra => [extra, await get[extra](log, directory, load)])));
 
   return (await get.routes(log, directory, load)).map(([path, imported]) => {

package/src/run.js

@@ -1,6 +1,6 @@
 import { tryreturn } from "rcompat/async";
 import { File } from "rcompat/fs";
-import { extend } from "rcompat/object";
+import o from "rcompat/object";
 import { runtime } from "rcompat/meta";
 import app from "./app.js";
 import { default as Logger, bye } from "./Logger.js";
@@ -20,7 +20,7 @@ const get_config = async root => {
       (imported === undefined || Object.keys(imported).length === 0) &&
         errors.EmptyConfigFile.warn(logger, config);
 
-      return extend(defaults, imported);
+      return o.extend(defaults, imported);
     }).orelse(({ message }) =>
       errors.ErrorInConfigFile.throw(message, `${runtime} ${config}`))
     : defaults;

package/src/start.js

@@ -1,6 +1,7 @@
 import { serve, Response, Status } from "rcompat/http";
 import { tryreturn } from "rcompat/async";
-import { bold, blue } from "rcompat/colors";
+import { bold, blue, dim } from "rcompat/colors";
+import { resolve } from "rcompat/package";
 import * as hooks from "./hooks/exports.js";
 import { print } from "./Logger.js";
 
@@ -11,24 +12,24 @@ export default async (app$, mode = "development") => {
   // run one-time hooks
   let app = app$;
 
-  const { http } = app.config;
-  const address = `http${app.secure ? "s" : ""}://${http.host}:${http.port}`;
-  print(blue(bold(app.name)), blue(app.version), `at ${address}\n`);
-
-  app.log.info(`in ${bold(mode)} mode`, { module: "primate" });
+  const primate = await resolve(import.meta.url);
+  print(blue(bold(primate.name)), blue(primate.version), "in startup\n");
 
   for (const hook of base_hooks) {
-    app.log.info(`running ${bold(hook)} hooks`, { module: "primate" });
+    app.log.info(`running ${dim(hook)} hooks`, { module: "primate" });
     app = await hooks[hook](app);
   }
 
   app.route = hooks.route(app);
-  app.parse = hooks.parse(app.dispatch);
+  app.parse = hooks.parse(app);
   app.server = await serve(async request =>
     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 });
-      }),
-  app.config.http);
+      }), app.get("http"));
+
+  const { host, port } = app.get("http");
+  const address = `http${app.secure ? "s" : ""}://${host}:${port}`;
+  print(`${blue("++")} started ${dim("->")} ${dim(address)}\n`);
 };

package/src/cwd.js

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