primate 0.30.2 → 0.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primate",
-  "version": "0.30.2",
+  "version": "0.31.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.9.4"
+    "rcompat": "^0.11.0"
   },
   "engines": {
     "node": ">=18"

package/src/app.js

@@ -1,6 +1,6 @@
 import crypto from "rcompat/crypto";
 import { tryreturn } from "rcompat/async";
-import { File } from "rcompat/fs";
+import FS from "rcompat/fs";
 import { is } from "rcompat/invariant";
 import o from "rcompat/object";
 import { globify } from "rcompat/string";
@@ -28,8 +28,8 @@ const to_csp = (config_csp, assets, csp) => config_csp
 
 // use user-provided file or fall back to default
 const load = (base, page, fallback) =>
-  tryreturn(_ => File.text(`${base.join(page)}`))
-    .orelse(_ => File.text(`${base.join(fallback)}`));
+  tryreturn(_ => FS.File.text(`${base.join(page)}`))
+    .orelse(_ => FS.File.text(`${base.join(fallback)}`));
 
 const encoder = new TextEncoder();
 
@@ -81,7 +81,6 @@ export default async (log, root, config) => {
     secure,
     importmaps: {},
     assets: [],
-    exports: [],
     path,
     root,
     log,
@@ -109,7 +108,7 @@ export default async (log, root, config) => {
 
       await Promise.all((await source.collect(filter)).map(async path => {
         const debased = path.debase(this.root).path.slice(1);
-        const filename = File.join(directory, path.debase(source));
+        const filename = FS.File.join(directory, path.debase(source));
         const target = await target_base.join(filename.debase(directory));
         await target.directory.create();
         await (regexs.some(regex => regex.test(debased))
@@ -188,15 +187,10 @@ export default async (log, root, config) => {
       const head = tags[tag_name]({ code, type, inline: true, integrity });
       return { head, integrity: `'${integrity}'` };
     },
-    async publish({ src, code, type = "", inline = false, copy = true }) {
-      if (!inline && copy) {
-        const base = this.runpath(this.get("location.client")).join(src);
-        await base.directory.create();
-        await base.write(code);
-      }
+    async publish({ src, code, type = "", inline = false }) {
       if (inline || type === "style") {
         this.assets.push({
-          src: File.join(http.static.root, src ?? "").path,
+          src: FS.File.join(http.static.root, src ?? "").path,
           code: inline ? code : "",
           type,
           inline,
@@ -211,9 +205,6 @@ export default async (log, root, config) => {
           { "style-src": [], "script-src": [] },
         );
     },
-    export({ type, code }) {
-      this.exports.push({ type, code });
-    },
     register(extension, operations) {
       is(this.handlers[extension]).undefined(DoubleFileExtension.new(extension));
       this.handlers[extension] = operations.handle;
@@ -224,32 +215,5 @@ export default async (log, root, config) => {
       const prefix = algorithm.replace("-", _ => "");
       return `${prefix}-${btoa(String.fromCharCode(...new Uint8Array(bytes)))}`;
     },
-    async import(module, deep_import) {
-      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}` }
-        : o.transform(pkg.exports, entry => entry
-          .filter(([, export$]) =>
-            export$.browser?.[deep_import] !== undefined
-            || export$.browser?.default !== undefined
-            || export$.import !== undefined
-            || export$.default !== undefined)
-          .map(([key, value]) => [
-            key.replace(".", deep_import === undefined
-              ? module : `${module}/${deep_import}`),
-            value.browser?.[deep_import]?.replace(".", `./${module}`)
-              ?? value.browser?.default.replace(".", `./${module}`)
-              ?? value.default?.replace(".", `./${module}`)
-              ?? value.import?.replace(".", `./${module}`),
-          ]));
-      const dependency = File.resolve().join(...path);
-      const target = this.runpath(this.get("location.client")).join(...path);
-      await dependency.copy(target);
-      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

@@ -44,8 +44,9 @@ export default {
     server: "server",
   },
   build: {
+    name: "app",
     includes: [],
-    index: "index.js",
+    excludes: [],
     transform: {
       paths: [],
       mapper: identity,

package/src/errors.js

@@ -1,7 +1,7 @@
-import { File } from "rcompat/fs";
+import FS from "rcompat/fs";
 import Logger from "./Logger.js";
 
-const json = await new File(import.meta.url).up(1).join("errors.json").json();
+const json = await new FS.File(import.meta.url).up(1).join("errors.json").json();
 
 const errors = Logger.err(json.errors, json.module);
 

package/src/errors.json

@@ -111,10 +111,20 @@
       "fix": "create a {0} route function at {2}.js",
       "level": "Info"
     },
+    "OptionalRoute": {
+      "message": "optional route {0} must be a leaf",
+      "fix": "move route to leaf (last) position in filesystem hierarchy",
+      "level": "Error"
+    },
     "ReservedTypeName": {
       "message": "reserved type name {0}",
       "fix": "do not use any reserved type names",
       "level": "Error"
+    },
+    "RestRoute": {
+      "message": "rest route {0} must be a leaf",
+      "fix": "move route to leaf (last) position in filesystem hierarchy",
+      "level": "Error"
     }
   }
 }

package/src/handlers.js

@@ -1,6 +1,7 @@
-import { File } from "rcompat/fs";
+import FS from "rcompat/fs";
 import { MediaType, Status } from "rcompat/http";
 import { identity } from "rcompat/function";
+import { HTML } from "rcompat/string";
 import errors from "./errors.js";
 
 const handle = (mediatype, mapper = identity) => (body, options) => app =>
@@ -49,27 +50,41 @@ const error = (body = "Not Found", { status = Status.NOT_FOUND, page } = {}) =>
 const script_re = /(?<=<script)>(?<code>.*?)(?=<\/script>)/gus;
 const style_re = /(?<=<style)>(?<code>.*?)(?=<\/style>)/gus;
 const remove = /<(?<tag>script|style)>.*?<\/\k<tag>>/gus;
-const html = (name, options) => async app => {
-  const component = await app.path.components.join(name).text();
+const render = (component, props = {}) => {
+  const encoded = JSON.parse(HTML.escape(JSON.stringify(props)));
+  const keys = Object.keys(encoded);
+  const values = Object.values(encoded);
+  return new Function(...keys, `return \`${component}\`;`)(...values);
+};
+const html = (name, props, options = {}) => async app => {
+  const location = app.get("location");
+  const components = app.runpath(location.server, location.components);
+  const component = await components.join(name).text();
+  const { head: xhead = [], csp = {}, headers, ...rest } = options;
+  const { script_src: xscript_src = [], style_src: xstyle_src = [] } = csp;
   const scripts = await Promise.all([...component.matchAll(script_re)]
     .map(({ groups: { code } }) => app.inline(code, "module")));
   const styles = await Promise.all([...component.matchAll(style_re)]
     .map(({ groups: { code } }) => app.inline(code, "style")));
-  const style_src = styles.map(asset => asset.integrity);
-  const script_src = scripts.map(asset => asset.integrity);
+  const style_src = styles.map(asset => asset.integrity).concat(xstyle_src);
+  const script_src = scripts.map(asset => asset.integrity).concat(xscript_src);
+  const head = [...scripts, ...styles].map(asset => asset.head);
 
   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,
+    body: render(component.replaceAll(remove, _ => ""), props),
+    head: [...head, ...xhead].join("\n"),
+    headers: {
+      ...app.headers({ "style-src": style_src, "script-src": script_src }),
+      ...headers,
+    },
+    ...rest,
   });
 };
 // }}}
 // {{{ view
 const extensions = ["fullExtension", "extension"];
 const view = (name, props, options) => (app, ...rest) => extensions
-  .map(extension => app.extensions[new File(name)[extension]])
+  .map(extension => app.extensions[new FS.File(name)[extension]])
   .find(extension => extension?.handle)
   ?.handle(name, props, options)(app, ...rest)
     ?? errors.NoHandlerForComponent.throw(name);

package/src/hooks/copy_includes.js

@@ -1,4 +1,4 @@
-import { File } from "rcompat/fs";
+import FS from "rcompat/fs";
 
 export default async (app, type, post = () => undefined) => {
   const includes = app.get("build.includes");
@@ -11,7 +11,7 @@ export default async (app, type, post = () => undefined) => {
       .map(async include => {
         const path = app.root.join(include);
         if (await path.exists()) {
-          const target = File.join(type, include);
+          const target = FS.File.join(type, include);
           await app.stage(path, target);
           await post(target);
         }

package/src/hooks/exports.js

@@ -2,7 +2,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 publish } from "./publish.js";
-export { default as bundle } from "./bundle.js";
 export { default as route } from "./route.js";
 export { default as handle } from "./handle.js";
 export { default as parse } from "./parse.js";

package/src/hooks/handle.js

@@ -1,4 +1,4 @@
-import { Response, Status, MediaType } from "rcompat/http";
+import { Response, Status, MediaType, fetch } from "rcompat/http";
 import { cascade, tryreturn } from "rcompat/async";
 import respond from "./respond.js";
 import { error as clientError } from "../handlers.js";
@@ -47,14 +47,15 @@ export default app => {
     let error_handler = app.error.default;
 
     return tryreturn(async _ => {
-      const { path, guards, errors, layouts, handler } = await route(request);
+      const { body, path, guards, errors, layouts, handler } =
+        await route(request);
 
       error_handler = errors?.at(-1);
 
       const hooks = [...app.modules.route, guard(app, guards), last(handler)];
 
       // handle request
-      const routed = await (await cascade(hooks))({ ...request, path });
+      const routed = await (await cascade(hooks))({ ...request, body, path });
 
       const $layouts = { layouts: await get_layouts(layouts, routed.request) };
       return respond(routed.response)(app, $layouts, routed.request);
@@ -94,6 +95,19 @@ export default app => {
     }
     return as_route(request);
   };
+  // first hook
+  const pass = (request, next) => next({
+    ...request,
+    pass(to) {
+      const { method, headers, body } = request.original;
+      const input = `${to}${request.url.pathname}`;
 
-  return cascade(app.modules.handle, handle);
+      return fetch(input, { headers, method, body, duplex: "half" });
+    },
+  });
+  const hotreload = (request, next) => app.mode === "development"
+    ? app.build.proxy(request, next)
+    : next(request);
+
+  return cascade([pass, hotreload, ...app.modules.handle], handle);
 };

package/src/hooks/parse.js

@@ -1,11 +1,5 @@
-import { URL, Body } from "rcompat/http";
+import { URL } from "rcompat/http";
 import o from "rcompat/object";
-import { tryreturn } from "rcompat/async";
-import errors from "../errors.js";
-
-const get_body = (request, url) =>
-  tryreturn(async _ => await Body.parse(request) ?? {})
-    .orelse(error => errors.MismatchedBody.throw(url.pathname, error.message));
 
 export default app => async original => {
   const { headers } = original;
@@ -14,7 +8,6 @@ export default app => async original => {
   const cookies = headers.get("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],

package/src/hooks/publish.js

@@ -1,24 +1,3 @@
-import { File } from "rcompat/fs";
 import { cascade } from "rcompat/async";
-import o from "rcompat/object";
 
-const post = async 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"));
-
-  await app.publish({
-    code: app.exports.filter(({ type }) => type === "script")
-      .map(({ code }) => code).join(""),
-    src,
-    type: "module",
-  });
-
-  const imports = { ...app.importmaps, app: src.webpath() };
-  const type = "importmap";
-  await app.publish({ inline: true, code: o.stringify({ imports }), type });
-
-  return app;
-};
-
-export default async app =>
-  post(await (await cascade(app.modules.publish))(app));
+export default async app => (await cascade(app.modules.publish))(app);

package/src/hooks/register.js

@@ -1,26 +1,18 @@
-import { File } from "rcompat/fs";
+import FS from "rcompat/fs";
 import { cascade } from "rcompat/async";
 import copy_includes from "./copy_includes.js";
 
 const html = /^.*.html$/u;
-const defaults = new File(import.meta.url).up(2).join("defaults");
+const defaults = new FS.File(import.meta.url).up(2).join("defaults");
 
 const pre = async app => {
-  const location = app.get("location");
-  const { pages, client, components } = location;
+  const pages = app.get("location.pages");
 
   // copy framework pages
   await app.stage(defaults, pages, html);
   // overwrite transformed pages to build
   await app.path.pages.exists() && await app.stage(app.path.pages, pages, html);
 
-  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(app.path.components, target, /^.*.js$/u);
-  }
-
   return app;
 };
 
@@ -30,37 +22,19 @@ const post = async app => {
 
   if (await _static.exists()) {
     // copy static files to build/server/static
-    await app.stage(_static, File.join(location.server, location.static));
-
-    // copy static files to build/client/static
-    await app.stage(_static, File.join(location.client, location.static));
+    await app.stage(_static, FS.File.join(location.server, location.static));
 
     // publish JavaScript and CSS files
-    const imports = await File.collect(_static, /\.(?:js|css)$/u);
+    const imports = await FS.File.collect(_static, /\.(?:css)$/u);
     await Promise.all(imports.map(async file => {
-      const code = await file.text();
       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 });
-      type === "style" && app.export({ type,
-        code: `import "./${location.static}${src}";` });
+      app.build.export(`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);
-  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, _ => ""));
-      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

package/src/hooks/respond.js

@@ -1,17 +1,17 @@
-import { Blob, s_streamable } from "rcompat/fs";
+import FS from "rcompat/fs";
 import { URL, Response } from "rcompat/http";
 import { identity } from "rcompat/function";
+import o from "rcompat/object";
 import { text, json, stream, redirect } from "primate";
 import errors from "../errors.js";
 
 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;
 const is_response = is_instance(globalThis.Response);
 const is_fake_response = is_instance(Response);
 const is_streamable =
-  value => value instanceof Blob || value?.streamable === s_streamable;
+  value => value instanceof FS.Blob || value?.streamable === FS.s_streamable;
 
 // [if, then]
 const guesses = [
@@ -19,7 +19,7 @@ const guesses = [
   [is_streamable, value => stream(value.stream())],
   [is_instance(ReadableStream), stream],
   [value => is_response(value) || is_fake_response(value), value => _ => value],
-  [is_non_null_object, json],
+  [o.proper, json],
   [is_text, text],
   [not_found, identity],
 ];

package/src/hooks/route.js

@@ -1,48 +1,49 @@
 import o from "rcompat/object";
 import { tryreturn } from "rcompat/sync";
-import errors from "../errors.js";
+import { Body } from "rcompat/http";
+import $errors from "../errors.js";
 import validate from "../validate.js";
 
-// insensitive-case equal
-const ieq = (left, right) => left.toLowerCase() === right.toLowerCase();
+const { MismatchedBody, MismatchedPath, NoRouteToPath } = $errors;
 
 const deroot = pathname => pathname.endsWith("/") && pathname !== "/"
   ? pathname.slice(0, -1) : pathname;
 
-export default app => {
-  const { types, routes } = app;
-  const location = app.get("location");
-
-  const to_path = (route, pathname) => app.dispatch(o.from(Object
-    .entries(route.pathname.exec(pathname)?.groups ?? {})
-    .map(([name, value]) => [name.split("$"), value])
-    .map(([[name, type], value]) =>
-      [name, type === undefined ? value : validate(types[type], value, name)],
-    )));
+const parse_body = (request, url) =>
+  tryreturn(async _ => await Body.parse(request) ?? {})
+    .orelse(error => MismatchedBody.throw(url.pathname, error.message));
 
-  const is_type = (groups, pathname) => Object.entries(groups ?? {})
-    .filter(([name]) => name.includes("$"))
-    .map(([name, value]) => [name.split("$"), value])
-    .map(([[name, type], value]) =>
-      tryreturn(_ => [name, validate(types[type], value, name)])
-        .orelse(({ message }) => errors.MismatchedPath.throw(pathname, message)));
-  const is_path = ({ route, pathname }) => {
-    const result = route.pathname.exec(pathname);
-    return result === null ? false : is_type(result.groups, pathname);
-  };
-  const is_method = ({ route, method, pathname }) => ieq(route.method, method)
-    && is_path({ route, pathname });
-  const find = (method, pathname) => routes.find(route =>
-    is_method({ route, method, pathname }));
+export default app => {
+  const $request_body_parse = app.get("request.body.parse");
+  const $location = app.get("location");
 
-  const index = path => `${location.routes}${path === "/" ? "/index" : path}`;
+  const index = path => `${$location.routes}${path === "/" ? "/index" : path}`;
   // remove excess slashes
   const deslash = url => url.replaceAll(/\/{2,}/gu, _ => "/");
 
-  return ({ original: { method }, url }) => {
+  return async ({ original, url }) => {
     const pathname = deroot(deslash(url.pathname));
-    const route = find(method, pathname) ?? errors.NoRouteToPath
-      .throw(method.toLowerCase(), pathname, index(pathname));
-    return { ...route, path: to_path(route, pathname) };
+    const route = await app.router.match(original) ?? NoRouteToPath
+      .throw(original.method.toLowerCase(), pathname, index(pathname));
+    const { params } = route;
+    const untyped_path = Object.fromEntries(Object.entries(params)
+      .filter(([name]) => !name.includes("="))
+      .map(([key, value]) => [key, value]));
+    const typed_path = Object.fromEntries(Object.entries(params)
+      .filter(([name]) => name.includes("="))
+      .map(([name, value]) => [name.split("="), value])
+      .map(([[name, type], value]) =>
+        tryreturn(_ => {
+          validate(app.types[type], value, name);
+          return [name, value];
+        }).orelse(({ message }) => MismatchedPath.throw(pathname, message))));
+    const path = app.dispatch({ ...untyped_path, ...typed_path });
+    const local_parse_body = route.file.body?.parse ?? $request_body_parse;
+    const body = local_parse_body ? await parse_body(original, url) : null;
+    const { guards = [], errors = [], layouts = [] } = o.map(route.specials,
+      ([key, value]) => [`${key}s`, value.default]);
+    const handler = route.file.default[original.method.toLowerCase()];
+
+    return { body, path, guards, errors, layouts, handler };
   };
 };

package/src/hooks/stage.js

@@ -1,3 +1,4 @@
+import FS from "rcompat/fs";
 import { cascade } from "rcompat/async";
 import dispatch from "../dispatch.js";
 import * as loaders from "../loaders/exports.js";
@@ -15,34 +16,46 @@ const pre = async app => {
 };
 
 const post = async app => {
-  const location = app.get("location");
+  const $location = app.get("location");
 
   // stage routes
-  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);
-
   if (await app.path.routes.exists()) {
-    await app.stage(app.path.routes, location.routes);
+    await app.stage(app.path.routes, $location.routes);
   }
   if (await app.path.types.exists()) {
-    await app.stage(app.path.types, location.types);
+    await app.stage(app.path.types, $location.types);
   }
-  const user_types = await loaders.types(app.log, app.runpath(location.types));
+  const user_types = await loaders.types(app.log, app.runpath($location.types));
   const types = { ...app.types, ...user_types };
 
-  const staged = app.runpath(location.routes);
-  for (const path of await staged.collect()) {
+  const directory = app.runpath($location.routes);
+  for (const path of await directory.collect()) {
     await app.extensions[path.extension]
-      ?.route(staged, path.debase(`${staged}/`), types);
+      ?.route(directory, path.debase(`${directory}/`), types);
   }
-  const routes = await loaders.routes(app);
-  const layout = {
-    depth: Math.max(...routes.map(({ layouts }) => layouts.length)) + 1,
-  };
 
-  return { ...app, types, routes, dispatch: dispatch(types), layout };
+  let router;
+
+  try {
+    router = await FS.Router.load({
+        directory,
+        specials: {
+          guard: { recursive: true },
+          error: { recursive: false },
+          layout: { recursive: true },
+        },
+        predicate(route, request) {
+          return route.default[request.method.toLowerCase()] !== undefined;
+        },
+      });
+  } catch (error) {
+    const { DoubleRoute, OptionalRoute, RestRoute } = FS.Router.Error;
+    error instanceof DoubleRoute && errors.DoubleRoute.throw(error.route);
+    error instanceof OptionalRoute && errors.OptionalRoute.throw(error.route);
+    error instanceof RestRoute && errors.RestRoute.throw(error.route);
+  }
+  const layout = { depth: router.depth("layout") };
+  return { ...app, types, dispatch: dispatch(types), layout, router };
 };
 
 export default async app =>

package/src/loaders/common.js

@@ -1,4 +1,4 @@
-import { File } from "rcompat/fs";
+import FS from "rcompat/fs";
 import { identity } from "rcompat/function";
 import errors from "../errors.js";
 
@@ -11,13 +11,13 @@ const empty = log => (objects, name, path) =>
 export default async ({
   log,
   directory,
-  filter = identity,
   name = "routes",
+  filter = identity,
   recursive = true,
   warn = true,
 } = {}) => {
   const objects = directory === undefined ? [] : await Promise.all(
-    (await File.collect(directory, /^.*.js$/u, { recursive }))
+    (await FS.File.collect(directory, /^.*.js$/u, { recursive }))
       .filter(filter)
       .map(async file => [
         `${file}`.replace(directory, _ => "").slice(1, -ending.length),

package/src/loaders/exports.js

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

package/src/loaders/types.js

@@ -1,4 +1,4 @@
-import { File } from "rcompat/fs";
+import FS from "rcompat/fs";
 import { is } from "rcompat/invariant";
 import { tryreturn } from "rcompat/sync";
 import errors from "../errors.js";
@@ -10,7 +10,7 @@ export default async (log, directory, load = fs) => {
   const types = (await load({ log, directory, name: "types", filter }))
     .map(([name, type]) => [name, type.default]);
 
-  const resolve = name => File.join(directory, name);
+  const resolve = name => FS.File.join(directory, name);
   types.every(([name, type]) => tryreturn(_ => {
     is(type).object();
     is(type.base).string();

package/src/run.js

@@ -1,5 +1,5 @@
 import { tryreturn } from "rcompat/async";
-import { File } from "rcompat/fs";
+import FS from "rcompat/fs";
 import o from "rcompat/object";
 import { runtime } from "rcompat/meta";
 import app from "./app.js";
@@ -28,7 +28,8 @@ const get_config = async root => {
 
 export default async name => tryreturn(async _ => {
   // use module root if possible, fall back to current directory
-  const root = await tryreturn(_ => File.root()).orelse(_ => File.resolve());
+  const root = await tryreturn(_ => FS.File.root())
+    .orelse(_ => FS.File.resolve());
   const config = await get_config(root);
   logger = new Logger(config.logger);
   await command(name)(await app(logger, root, config));

package/src/start.js

@@ -2,15 +2,44 @@ import { serve, Response, Status } from "rcompat/http";
 import { tryreturn } from "rcompat/async";
 import { bold, blue, dim } from "rcompat/colors";
 import { resolve } from "rcompat/package";
+import o from "rcompat/object";
+import Build from "rcompat/build";
+import FS from "rcompat/fs";
 import * as hooks from "./hooks/exports.js";
 import { print } from "./Logger.js";
 
-const base_hooks = ["init", "stage", "register", "publish", "bundle"];
+const base_hooks = ["init", "stage", "register", "publish"];
 
-export default async (app$, mode = "development") => {
-  app$.mode = mode;
-  // run one-time hooks
-  let app = app$;
+const publish = async app => {
+  const location = app.get("location");
+  const http = app.get("http");
+  const client = app.runpath(app.get("location.client"));
+
+  const re = new RegExp(`${location.client}/app..*(?:js|css)$`, "u");
+  for (const path of await client.collect(re, { recursive: false })) {
+    const src = path.name;
+    const type = path.extension === ".css" ? "style" : "module";
+    await app.publish({ src, type });
+    if (path.extension === ".js") {
+      const imports = { app: FS.File.join(http.static.root, src).path };
+      await app.publish({
+        inline: true,
+        code: JSON.stringify({ imports }, null, 2),
+        type: "importmap",
+      });
+    }
+  }
+};
+
+export default async ($app, mode = "development") => {
+  let app = $app;
+
+  app.mode = mode;
+  app.build = new Build({
+    ...o.exclude(app.get("build"), ["includes", "index", "transform"]),
+    outdir: app.runpath(app.get("location.client")).path,
+    resolveDir: app.root.path,
+  }, mode);
 
   const primate = await resolve(import.meta.url);
   print(blue(bold(primate.name)), blue(primate.version), "in startup\n");
@@ -19,11 +48,14 @@ export default async (app$, mode = "development") => {
     app.log.info(`running ${dim(hook)} hooks`, { module: "primate" });
     app = await hooks[hook](app);
   }
-
+  // start the build
+  await app.build.start();
+  await publish(app);
   app.route = hooks.route(app);
   app.parse = hooks.parse(app);
+  const handle = await hooks.handle(app);
   app.server = await serve(async request =>
-    tryreturn(async _ => (await hooks.handle(app))(await app.parse(request)))
+    tryreturn(async _ => handle(await app.parse(request)))
       .orelse(error => {
         app.log.auto(error);
         return new Response(null, { status: Status.INTERNAL_SERVER_ERROR });

package/src/hooks/bundle.js

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

package/src/loaders/routes/exports.js

@@ -1,6 +0,0 @@
-import load from "./load.js";
-
-export { default as routes } from "./routes.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,18 +0,0 @@
-import { File } from "rcompat/fs";
-import errors from "../../errors.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 = to_sorted((await load({ log, directory, filter, warn: false }))
-    .map(([name, object]) => [name.replace(replace, () => ""), object]),
-  ([a], [b]) => a.length - b.length);
-
-  const resolve = name => File.join(directory, name, `+${type}.js`);
-  objects.some(([name, value]) => typeof value.default !== "function"
-    && errors.InvalidDefaultExport.throw(resolve(name)));
-
-  return objects;
-};

package/src/loaders/routes/routes.js

@@ -1,25 +0,0 @@
-import { doubled } from "../common.js";
-import errors from "../../errors.js";
-
-const normalize = route => {
-  let i = 0;
-  // user/ -> user
-  // user/{id=number}/{id2=number} -> user/{0}/{1}
-  return (route.endsWith("/") ? route.slice(0, -1) : route)
-    .replaceAll(/\{(?:\w*)(?:=\w+)?\}?/gu, _ => `{${i++}}`);
-};
-
-// index -> ""
-const deindex = path => path.endsWith("index") ?
-  path.replace("index", "") : path;
-
-export default async (log, directory, load) => {
-  const filter = path => /^[^+].*.js$/u.test(path.name);
-  const routes = (await load({ log, directory, filter }))
-    .map(([path, handler]) => [deindex(path), handler]);
-
-  const double = doubled(routes.map(([route]) => normalize(route)));
-  double && errors.DoubleRoute.throw(double);
-
-  return routes;
-};

package/src/loaders/routes.js

@@ -1,55 +0,0 @@
-import { tryreturn } from "rcompat/sync";
-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";
-import errors from "../errors.js";
-
-const { separator } = File;
-
-const valid_route = /^[\w\-[\]=/.]*$/u;
-
-const make = path => {
-  !valid_route.test(new File(path).webpath()) && errors.InvalidPath.throw(path);
-
-  const double = doubled(path.split(separator)
-    .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) =>
-    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.EmptyPathParameter.throw(named, path)));
-
-  // normalize to unix
-  return new RegExp(`^/${route.replaceAll(separator, "/")}$`, "u");
-};
-
-export default async (app, load = fs) => {
-  const { log } = app;
-  const directory = app.runpath(app.get("location.routes"));
-  const filter = path => ([name]) => path.includes(name);
-  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]) => {
-    const route = imported.default;
-    if (route === undefined || Object.keys(route).length === 0) {
-      errors.EmptyRouteFile.warn(log, directory.join(`${path}.js`).path);
-      return [];
-    }
-    const filtered = filter(path);
-
-    return Object.entries(route).map(([method, handler]) => ({
-      method,
-      handler,
-      pathname: make(path.endsWith(separator) ? path.slice(0, -1) : path),
-      guards: routes.guards.filter(filtered).map(([, guard]) => guard.default),
-      errors: routes.errors.filter(filtered).map(([, error]) => error.default),
-      layouts: routes.layouts.filter(filtered).map(([, layout]) => layout),
-    }));
-  }).flat();
-};