primate 0.25.0 → 0.26.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.25.0",
+  "version": "0.26.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.32.3"
+    "rcompat": "^0.3.3"
   },
   "engines": {
     "node": ">=18"

package/src/Logger.js

@@ -1,8 +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 console from "runtime-compat/console";
-import { stdout } from "runtime-compat/stdio";
+import { assert, is } from "rcompat/invariant";
+import { blue, bold, green, red, yellow, dim } from "rcompat/colors";
+import { map } from "rcompat/object";
+import console from "rcompat/console";
+import { stdout } from "rcompat/stdio";
 
 const levels = {
   Error: 0,

package/src/app.js

@@ -1,15 +1,12 @@
-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 } from "runtime-compat/object";
-import { globify } from "runtime-compat/string";
-import * as runtime from "runtime-compat/meta";
+import crypto from "rcompat/crypto";
+import { tryreturn } from "rcompat/async";
+import { Path } from "rcompat/fs";
+import { is } from "rcompat/invariant";
+import { transform, valmap } from "rcompat/object";
+import { globify } from "rcompat/string";
+import * as runtime from "rcompat/meta";
 
 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 loaders from "./loaders/exports.js";
@@ -18,8 +15,8 @@ const { DoubleFileExtension } = errors;
 
 // use user-provided file or fall back to default
 const index = (base, page, fallback) =>
-  tryreturn(_ => File.read(`${base.join(page)}`))
-    .orelse(_ => File.read(`${base.join(fallback)}`));
+  tryreturn(_ => Path.read(`${base.join(page)}`))
+    .orelse(_ => Path.read(`${base.join(fallback)}`));
 
 const encoder = new TextEncoder();
 
@@ -54,18 +51,13 @@ export default async (log, root, config) => {
   const secure = http?.ssl !== undefined;
   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);
-
   // if ssl activated, resolve key and cert early
   if (secure) {
     http.ssl.key = root.join(http.ssl.key);
     http.ssl.cert = root.join(http.ssl.cert);
   }
 
-  const types = await loaders.types(log, path.types);
   const error = await path.routes.join("+error.js");
-  const routes = await loaders.routes(log, path.routes);
 
   return {
     config,
@@ -79,15 +71,10 @@ export default async (log, root, config) => {
     root,
     log,
     error: {
-      default: await error.exists ? (await import(error)).default : undefined,
+      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),
+    extensions: {},
     modules: await loaders.modules(log, root, config),
     ...runtime,
     // copy files to build folder, potentially transforming them
@@ -97,21 +84,39 @@ export default async (log, root, config) => {
       is(mapper).function();
 
       const regexs = paths.map(file => globify(file));
-      const target = this.runpath(directory);
+      const target_base = this.runpath(directory);
 
       await Promise.all((await source.collect(filter)).map(async path => {
         const debased = path.debase(this.root).path.slice(1);
         const filename = new Path(directory).join(path.debase(source));
-        const to = await target.join(filename.debase(directory));
-        await to.directory.file.create();
-        if (regexs.some(regex => regex.test(debased))) {
-          const contents = mapper(await path.text());
-          await to.file.write(contents);
-        } else {
-          await path.file.copy(to);
-        }
+        const target = await target_base.join(filename.debase(directory));
+        await target.directory.create();
+        await (regexs.some(regex => regex.test(debased))
+          ? target.write(mapper(await path.text()))
+          : path.copy(target));
       }));
     },
+    async compile(component) {
+      const { location: { server, client, components } } = this.config;
+
+      const source = this.path.components;
+      const compile = this.extensions[component.extension]?.compile;
+      if (compile === undefined) {
+        const debased = `${component.path}`.replace(source, "");
+
+        const server_target = this.runpath(server, components);
+        await component.copy(server_target.join(debased));
+
+        const client_target = this.runpath(client, components);
+        await component.copy(client_target.join(debased));
+      } else {
+        // compile server components
+        await compile.server(component);
+
+        // compile client components
+        await compile.client(component);
+      }
+    },
     headers({ script = "", style = "" } = {}) {
       const csp = Object.keys(http.csp).reduce((policy, key) =>
         `${policy}${key} ${http.csp[key]};`, "")
@@ -154,8 +159,8 @@ export default async (log, root, config) => {
     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);
+        await base.directory.create();
+        await base.write(code);
       }
       if (inline || type === "style") {
         this.assets.push({
@@ -170,9 +175,10 @@ export default async (log, root, config) => {
     export({ type, code }) {
       this.exports.push({ type, code });
     },
-    register(extension, handler) {
+    register(extension, operations) {
       is(this.handlers[extension]).undefined(DoubleFileExtension.new(extension));
-      this.handlers[extension] = handler;
+      this.handlers[extension] = operations.handle;
+      this.extensions[extension] = operations;
     },
     async hash(data, algorithm = "sha-384") {
       const bytes = await crypto.subtle.digest(algorithm, encoder.encode(data));
@@ -202,8 +208,8 @@ export default async (log, root, config) => {
               ?? value.import?.replace(".", `./${module}`),
           ]));
       const dependency = Path.resolve().join(...path);
-      const to = new Path(this.runpath(client), this.library, ...parts);
-      await dependency.file.copy(to);
+      const target = new Path(this.runpath(client), this.library, ...parts);
+      await dependency.copy(target);
       this.importmaps = {
         ...valmap(exports, value => new Path(root, this.library, value).path),
         ...this.importmaps };

package/src/bin.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import args from "runtime-compat/args";
+import args from "rcompat/args";
 import run from "./run.js";
 await run(args[0]);

package/src/commands/dev.js

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

package/src/commands/serve.js

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

package/src/cwd.js

@@ -1,3 +1,3 @@
-import { Path } from "runtime-compat/fs";
+import { Path } from "rcompat/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 "rcompat/function";
 import Logger from "../Logger.js";
 
 export default {

package/src/dispatch.js

@@ -1,21 +1,24 @@
-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 } from "rcompat/invariant";
+import { tryreturn } from "rcompat/sync";
+import { map } from "rcompat/object";
+import { camelcased } from "rcompat/string";
 import errors from "./errors.js";
 import validate from "./validate.js";
 
-export default (patches = {}) => (value, raw, cased = true) => {
+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, value[property], property))
+      return tryreturn(_ => validate(patch, object[property], property))
         .orelse(({ message }) => errors.MismatchedType.throw(message));
     }]),
     get(property) {
-      maybe(property).string();
-      return property === undefined ? value :
-        value[cased ? property : property.toLowerCase()];
+      is(property).string();
+
+      return object[cased ? property : property.toLowerCase()];
+    },
+    getAll() {
+      return object;
     },
     raw,
   });

package/src/errors.js

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

package/src/errors.json

@@ -56,6 +56,11 @@
       "fix": "do not use dots in route names",
       "level": "Error"
     },
+    "InvalidTypeExport": {
+      "message": "invalid type export at {0}",
+      "fix": "export object with a `base` string and a `validate` function",
+      "level": "Error"
+    },
     "InvalidTypeName": {
       "message": "invalid type name {0}",
       "fix": "use lowercase-first latin letters and decimals in type names",

package/src/exports.js

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

package/src/handlers/error.js

@@ -1,4 +1,4 @@
-import { Response, Status, MediaType } from "runtime-compat/http";
+import { Response, Status, MediaType } from "rcompat/http";
 
 export default (body = "Not Found", { status = Status.NOT_FOUND, page } = {}) =>
   async app => new Response(await app.render({

package/src/handlers/html.js

@@ -1,4 +1,4 @@
-import { Response, Status, MediaType } from "runtime-compat/http";
+import { Response, Status, MediaType } from "rcompat/http";
 
 const script_re = /(?<=<script)>(?<code>.*?)(?=<\/script>)/gus;
 const style_re = /(?<=<style)>(?<code>.*?)(?=<\/style>)/gus;

package/src/handlers/json.js

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

package/src/handlers/redirect.js

@@ -1,4 +1,4 @@
-import { Response, Status } from "runtime-compat/http";
+import { Response, Status } from "rcompat/http";
 
 export default (Location, { status = Status.FOUND } = {}) => app =>
   /* no body */

package/src/handlers/stream.js

@@ -1,4 +1,4 @@
-import { Response, Status, MediaType } from "runtime-compat/http";
+import { Response, Status, MediaType } from "rcompat/http";
 
 export default (body, { status = Status.OK } = {}) => app =>
   new Response(body, {

package/src/handlers/text.js

@@ -1,4 +1,4 @@
-import { Response, Status, MediaType } from "runtime-compat/http";
+import { Response, Status, MediaType } from "rcompat/http";
 
 export default (body, { status = Status.OK } = {}) => app =>
   new Response(body, {

package/src/hooks/bundle.js

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

package/src/hooks/copy_includes.js

@@ -1,4 +1,4 @@
-import { Path } from "runtime-compat/fs";
+import { Path } from "rcompat/fs";
 
 export default async (app, type, post = () => undefined) => {
   const { config } = app;
@@ -13,10 +13,10 @@ export default async (app, type, post = () => undefined) => {
       .filter(include => /^[^/]*$/u.test(include))
       .map(async include => {
         const path = app.root.join(include);
-        if (await path.exists) {
-          const to = Path.join(type, include);
-          await app.stage(path, to);
-          await post(to);
+        if (await path.exists()) {
+          const target = Path.join(type, include);
+          await app.stage(path, target);
+          await post(target);
         }
       }));
   }

package/src/hooks/exports.js

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

package/src/hooks/handle.js

@@ -1,5 +1,5 @@
-import { Response, Status, MediaType } from "runtime-compat/http";
-import { cascade, tryreturn } from "runtime-compat/async";
+import { Response, Status, MediaType } from "rcompat/http";
+import { cascade, tryreturn } from "rcompat/async";
 import { respond } from "./respond/exports.js";
 import { invalid } from "./route.js";
 import { error as clientError } from "../handlers/exports.js";
@@ -63,11 +63,11 @@ export default app => {
     });
   };
 
-  const as_asset = async file => new Response(file.readable, {
+  const as_asset = async path => new Response(path.stream(), {
     status: Status.OK,
     headers: {
-      "Content-Type": MediaType.resolve(file.name),
-      Etag: await file.modified,
+      "Content-Type": MediaType.resolve(path.name),
+      Etag: await path.modified(),
     },
   });
 
@@ -79,11 +79,11 @@ export default app => {
       // try static first
       const asset = client.join(location.static, debased);
       if (await asset.isFile) {
-        return as_asset(asset.file);
+        return as_asset(asset);
       }
       const path = client.join(debased);
       if (await path.isFile) {
-        return as_asset(path.file);
+        return as_asset(path);
       }
     }
     return as_route(request);

package/src/hooks/init.js

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

package/src/hooks/parse.js

@@ -1,7 +1,7 @@
-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 "rcompat/http";
+import { tryreturn } from "rcompat/sync";
+import { stringify } from "rcompat/streams";
+import { from, valmap } from "rcompat/object";
 import errors from "../errors.js";
 
 const { APPLICATION_FORM_URLENCODED, APPLICATION_JSON } = MediaType;

package/src/hooks/publish.js

@@ -1,10 +1,9 @@
-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";
+import { Path } from "rcompat/fs";
+import { cascade } from "rcompat/async";
+import { stringify } from "rcompat/object";
 
 const post = async app => {
-  const { config: { location, http: { static: { root } } }, path } = app;
+  const { config: { http: { static: { root } } } } = app;
 
   {
     // after hook, publish a zero assumptions app.js (no css imports)
@@ -17,44 +16,11 @@ const post = async app => {
       type: "module",
     });
 
-    if (await path.components.exists) {
-      // copy .js files from components to build/client/components, 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 };
     const type = "importmap";
     await app.publish({ inline: true, code: stringify({ imports }), type });
   }
 
-  if (await path.static.exists) {
-    // copy static files to build/client/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.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}";` });
-    }));
-  }
-
-  // copy additional subdirectories to build/client
-  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(client, _ => ""));
-      await app.publish({ src, code: await script.text(), type: "module" });
-    })),
-  );
-
   return app;
 };
 

package/src/hooks/register.js

@@ -1,3 +1,74 @@
-import { cascade } from "runtime-compat/async";
+import { Path } from "rcompat/fs";
+import { cascade } from "rcompat/async";
+import cwd from "../cwd.js";
+import copy_includes from "./copy_includes.js";
 
-export default async app => (await cascade(app.modules.register))(app);
+const html = /^.*.html$/u;
+const defaults = cwd(import.meta, 2).join("defaults");
+
+const pre = async app => {
+  const { config: { location: { pages, client, components } }, path } = app;
+
+  await Promise.all(["server", "client", "pages"]
+    .map(directory => app.runpath(directory).create()));
+
+  // 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);
+
+  if (await path.components.exists()) {
+    // copy .js files from components to build/client/components, since
+    // frontend frameworks handle non-js files
+    const target = Path.join(client, components);
+    await app.stage(path.components, target, /^.*.js$/u);
+  }
+
+  return app;
+};
+
+const post = async app => {
+  const { config: { location, http: { static: { root } } }, path } = app;
+
+  if (await path.static.exists()) {
+    // copy static files to build/server/static
+    await app.stage(path.static, new Path(location.server, location.static));
+
+    // copy static files to build/client/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.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}";` });
+    }));
+  }
+
+  // copy additional subdirectories to build/server
+  await copy_includes(app, location.server);
+
+  // copy additional subdirectories to build/client
+  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(client, _ => ""));
+      await app.publish({ src, code: await script.text(), type: "module" });
+    })),
+  );
+
+  const components = await app.path.components.collect();
+
+  // from the build directory, compile to server and client
+  await Promise.all(components.map(component => app.compile(component)));
+
+  return app;
+};
+
+export default async app =>
+  post(await (await cascade(app.modules.register))(await pre(app)));

package/src/hooks/respond/duck.js

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

package/src/hooks/respond/respond.js

@@ -1,5 +1,5 @@
-import { Blob } from "runtime-compat/fs";
-import { URL } from "runtime-compat/http";
+import { Blob } from "rcompat/fs";
+import { URL } from "rcompat/http";
 import { text, json, stream, redirect } from "primate";
 import { isResponse as isResponseDuck } from "./duck.js";
 

package/src/hooks/route.js

@@ -1,5 +1,5 @@
-import { from } from "runtime-compat/object";
-import { tryreturn } from "runtime-compat/sync";
+import { from } from "rcompat/object";
+import { tryreturn } from "rcompat/sync";
 import errors from "../errors.js";
 import validate from "../validate.js";
 

package/src/hooks/serve.js

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

package/src/hooks/stage.js

@@ -0,0 +1,48 @@
+import { cascade } from "rcompat/async";
+import dispatch from "../dispatch.js";
+import * as loaders from "../loaders/exports.js";
+import { doubled } from "../loaders/common.js";
+import errors from "../errors.js";
+
+const pre = async app => {
+  // remove build directory in case exists
+  await app.path.build.remove();
+
+  return { ...app };
+};
+
+const post = async app => {
+  const { config: { location } } = app;
+
+  // 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 - 1)));
+  double && errors.DoubleRoute.throw(double);
+
+  await app.stage(app.path.routes, location.routes);
+  if (await app.path.types.exists()) {
+    await app.stage(app.path.types, location.types);
+  }
+  const types = await loaders.types(app.log, app.runpath(location.types));
+  const staged = app.runpath(location.routes);
+  for (const path of await staged.collect()) {
+    await app.extensions[path.extension]
+      ?.route(staged, path.debase(`${staged}/`), types);
+  }
+  const routes = await loaders.routes(app);
+
+  return {
+    ...app,
+    types,
+    routes,
+    dispatch: dispatch(app.types),
+    layout: {
+      depth: Math.max(...routes.map(({ layouts }) => layouts.length)) + 1,
+    },
+  };
+};
+
+export default async app =>
+  post(await (await cascade(app.modules.stage))(await pre(app)));

package/src/loaders/common.js

@@ -1,5 +1,5 @@
-import { Path } from "runtime-compat/fs";
-import { identity } from "runtime-compat/function";
+import { Path } from "rcompat/fs";
+import { identity } from "rcompat/function";
 import errors from "../errors.js";
 
 const ending = ".js";

package/src/loaders/modules.js

@@ -12,7 +12,7 @@ export default async (log, root, config) => {
 
   Array.isArray(modules) || errors.ModulesMustBeArray.throw("modules");
 
-  modules.some((module, n) => module.name === undefined &&
+  modules.some(({ name }, n) => name === undefined &&
     errors.ModuleHasNoName.throw(n));
 
   const names = modules.map(({ name }) => name);

package/src/loaders/routes/exports.js

@@ -1,4 +1,6 @@
+import load from "./load.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";
+export const guards = await load("guard");
+export const errors = await load("error");
+export const layouts = await load("layout");

package/src/loaders/routes/load.js

@@ -1,4 +1,4 @@
-import { Path } from "runtime-compat/fs";
+import { Path } from "rcompat/fs";
 import errors from "../../errors.js";
 import to_sorted from "../../to_sorted.js";
 

package/src/loaders/routes.js

@@ -1,9 +1,9 @@
-import { tryreturn } from "runtime-compat/sync";
-import { from } from "runtime-compat/object";
-import errors from "../errors.js";
-import { invalid } from "../hooks/route.js";
+import { tryreturn } from "rcompat/sync";
+import { from } from "rcompat/object";
 import { default as fs, doubled } from "./common.js";
 import * as get from "./routes/exports.js";
+import errors from "../errors.js";
+import { invalid } from "../hooks/route.js";
 
 const make = path => {
   const double = doubled(path.split("/")
@@ -23,26 +23,27 @@ const make = path => {
   return new RegExp(`^/${route}$`, "u");
 };
 
-const specials = ["guards", "errors", "layouts"];
-export default async (log, directory, load = fs) => {
-  const routes = await get.routes(log, directory, load);
-  const routes$ = from(await Promise.all(specials.map(async extra =>
-    [extra, await get[extra](log, directory, load)])));
+export default async (app, load = fs) => {
+  const { log } = app;
+  const directory = app.runpath(app.config.location.routes);
   const filter = path => ([name]) => path.includes(name);
+  const routes = from(await Promise.all(["guards", "errors", "layouts"]
+    .map(async extra => [extra, await get[extra](log, directory, load)])));
 
-  return routes.map(([path, imported]) => {
+  return (await get.routes(log, directory, load)).map(([path, imported]) => {
     if (imported === undefined || Object.keys(imported).length === 0) {
       errors.EmptyRouteFile.warn(log, directory.join(`${path}.js`).path);
       return [];
     }
+    const filtered = filter(path);
 
     return Object.entries(imported).map(([method, handler]) => ({
       method,
       handler,
       pathname: make(path.endsWith("/") ? path.slice(0, -1) : path),
-      guards: routes$.guards.filter(filter(path)).map(([, guard]) => guard),
-      errors: routes$.errors.filter(filter(path)).map(([, error]) => error),
-      layouts: routes$.layouts.filter(filter(path)).map(([, layout]) => layout),
+      guards: routes.guards.filter(filtered).map(([, guard]) => guard),
+      errors: routes.errors.filter(filtered).map(([, error]) => error),
+      layouts: routes.layouts.filter(filtered).map(([, layout]) => layout),
     }));
   }).flat();
 };

package/src/loaders/types.js

@@ -1,15 +1,22 @@
-import { Path } from "runtime-compat/fs";
+import { Path } from "rcompat/fs";
+import { is } from "rcompat/invariant";
+import { tryreturn } from "rcompat/sync";
 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 fs({ log, directory, name: "types", filter });
 
   const resolve = name => new Path(directory, name);
-  types.some(([name, type]) => typeof type !== "function"
-    && errors.InvalidDefaultExport.throw(resolve(`${name}.js`)));
+  types.every(([name, type]) => tryreturn(_ => {
+    is(type).object();
+    is(type.base).string();
+    is(type.validate).function();
+    return true;
+  }).orelse(_ => errors.InvalidTypeExport.throw(resolve(`${name}.js`))),
+  );
 
   types.every(([name]) =>
     /^(?:[a-z][^\W_]*)$/u.test(name) || errors.InvalidTypeName.throw(name));

package/src/run.js

@@ -1,6 +1,6 @@
-import { tryreturn } from "runtime-compat/async";
-import { Path } from "runtime-compat/fs";
-import { extend } from "runtime-compat/object";
+import { tryreturn } from "rcompat/async";
+import { Path } from "rcompat/fs";
+import { extend } from "rcompat/object";
 import app from "./app.js";
 import { default as Logger, bye } from "./Logger.js";
 import errors from "./errors.js";
@@ -13,7 +13,7 @@ const { runtime = "node" } = import.meta;
 const get_config = async root => {
   const name = "primate.config.js";
   const config = root.join(name);
-  return await config.exists
+  return await config.exists()
     ? tryreturn(async _ => {
       const imported = (await import(config)).default;
 

package/src/start.js

@@ -1,15 +1,24 @@
-import { serve, Response, Status } from "runtime-compat/http";
-import { cascade, tryreturn } from "runtime-compat/async";
+import { serve, Response, Status } from "rcompat/http";
+import { cascade, tryreturn } from "rcompat/async";
+import { bold, blue } from "rcompat/colors";
 import * as hooks from "./hooks/exports.js";
+import { print } from "./Logger.js";
 
-export default async (app$, deactivated = []) => {
+const base_hooks = ["init", "stage", "register", "publish", "bundle"];
+
+export default async (app$, mode = "development") => {
+  app$.mode = mode;
   // run one-time hooks
   let app = app$;
-  for (const hook of ["init", "register", "compile", "publish", "bundle"]) {
-    if (deactivated.includes(hook)) {
-      continue;
-    }
-    app.log.info(`running ${hook} hooks`, { module: "primate" });
+
+  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" });
+
+  for (const hook of base_hooks) {
+    app.log.info(`running ${bold(hook)} hooks`, { module: "primate" });
     app = await hooks[hook](app);
   }
 

package/src/validate.js

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

package/src/hooks/compile.js

@@ -1,45 +0,0 @@
-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 { config: { location }, path } = app;
-
-  // remove build directory in case exists
-  if (await path.build.exists) {
-    await path.build.file.remove();
-  }
-  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 path.components.exists) {
-    // copy all files to build/components
-    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);
-  }
-
-  if (await path.static.exists) {
-    // copy static files to build/server/static
-    await app.stage(path.static, new Path(location.server, location.static));
-  }
-
-  // copy additional subdirectories to build/server
-  await copy_includes(app, location.server);
-
-  return app;
-};
-
-export default async app =>
-  (await cascade(app.modules.compile))(await pre(app));

package/src/loaders/routes/errors.js

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

package/src/loaders/routes/guards.js

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

package/src/loaders/routes/layouts.js

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