@kosmojs/dev 0.0.11 → 0.0.21

package/pkg/index.js

@@ -1,33 +1,135 @@
-// src/index.ts
-import { default as default2 } from "@kosmojs/api-generator";
-import { default as default3 } from "@kosmojs/fetch-generator";
-
 // src/alias-plugin/index.ts
 import { glob } from "tinyglobby";
+
+// src/paths.ts
+import { join } from "node:path";
+
+// src/defaults.ts
+var defaults = {
+  appPrefix: "~",
+  srcPrefix: "@",
+  libPrefix: "_",
+  coreDir: "core",
+  srcDir: "src",
+  libDir: "lib",
+  configDir: "config",
+  apiDir: "api",
+  pagesDir: "pages",
+  entryDir: "entry",
+  fetchDir: "fetch"
+};
+
+// src/paths.ts
+var createTsconfigPaths = (prefix) => {
+  return {
+    [`${defaults.appPrefix}/*`]: [`${prefix}/*`],
+    [`${defaults.srcPrefix}/*`]: [`${prefix}/${defaults.srcDir}/*`],
+    [`${defaults.libPrefix}/*`]: [
+      `${prefix}/${defaults.libDir}/${defaults.srcDir}/*`
+    ]
+  };
+};
+var pathResolver = ({
+  appRoot,
+  sourceFolder
+}) => {
+  const createPath = (...a) => {
+    return appRoot ? join(appRoot, ...a) : join(...a);
+  };
+  const createImport = {
+    coreApi(...a) {
+      return join(defaults.appPrefix, defaults.coreDir, defaults.apiDir, ...a);
+    },
+    src(...a) {
+      return join(defaults.srcPrefix, sourceFolder, ...a);
+    },
+    config(...a) {
+      return this.src(defaults.configDir, ...a);
+    },
+    api(...a) {
+      return this.src(defaults.apiDir, ...a);
+    },
+    pages(...a) {
+      return this.src(defaults.pagesDir, ...a);
+    },
+    lib(...a) {
+      return join(defaults.libPrefix, sourceFolder, ...a);
+    },
+    libApi(...a) {
+      return this.lib(defaults.apiDir, ...a);
+    },
+    libEntry(...a) {
+      return this.lib(defaults.entryDir, ...a);
+    }
+  };
+  return {
+    createPath: {
+      coreApi(...a) {
+        return createPath(defaults.coreDir, defaults.apiDir, ...a);
+      },
+      src(...a) {
+        return createPath(defaults.srcDir, sourceFolder, ...a);
+      },
+      api(...a) {
+        return this.src(defaults.apiDir, ...a);
+      },
+      pages(...a) {
+        return this.src(defaults.pagesDir, ...a);
+      },
+      config(...a) {
+        return this.src(defaults.configDir, ...a);
+      },
+      entry(...a) {
+        return this.src(defaults.entryDir, ...a);
+      },
+      lib(...a) {
+        return createPath(defaults.libDir, defaults.srcDir, sourceFolder, ...a);
+      },
+      libApi(...a) {
+        return this.lib(defaults.apiDir, ...a);
+      },
+      libEntry(...a) {
+        return this.lib(defaults.entryDir, ...a);
+      },
+      libPages(...a) {
+        return this.lib(defaults.pagesDir, ...a);
+      }
+    },
+    createImport,
+    createImportHelper: (key, ...a) => {
+      return createImport[key](...a.slice(0, -1));
+    }
+  };
+};
+
+// src/alias-plugin/index.ts
 var alias_plugin_default = (appRoot, opt) => {
   return {
     name: "@kosmojs:aliasPlugin",
     async config() {
-      const compilerOptions = await import(`${appRoot}/tsconfig.json`, {
-        with: { type: "json" }
-      }).then((e) => e.default.compilerOptions);
+      const paths = await import(`${appRoot}/tsconfig.json`, { with: { type: "json" } }).then((e) => {
+        return {
+          ...e.default.compilerOptions?.paths,
+          ...createTsconfigPaths(".")
+        };
+      });
       const aliasmap = [];
-      const pathEntries = Object.entries({ ...compilerOptions?.paths });
+      const pathEntries = Object.entries(paths);
       for (const [aliasPattern, pathPatterns] of pathEntries) {
         const alias = aliasPattern.replace("/*", "");
-        const paths = pathPatterns.map((e) => e.replace("/*", "")).sort((a, b) => a.split(/\/+/).length - b.split(/\/+/).length);
-        if (paths.length === 1) {
+        const paths2 = pathPatterns.map((e) => e.replace("/*", "")).sort((a, b) => a.split(/\/+/).length - b.split(/\/+/).length);
+        if (paths2.length === 1) {
           aliasmap.push({
             find: new RegExp(`^${alias}/`),
-            replacement: `${appRoot}/${paths[0]}/`
+            replacement: `${appRoot}/${paths2[0]}/`
           });
-        } else if (paths.length > 1) {
+        } else if (paths2.length > 1) {
           aliasmap.push({
             find: new RegExp(`^${alias}/`),
             replacement: "",
             async customResolver(_src) {
               const src = _src.replace(/(\$|\^|\+|\(|\)|\[|\])/g, "\\$1");
-              const patterns = paths.flatMap((path) => [
+              const patterns = paths2.flatMap((path) => [
                 // Case 1: Extension is explicitly provided
                 // e.g. import styles from "@admin/{solid}/styles.module.css"
                 `${path}/${src}*`,
@@ -67,111 +169,33 @@ var alias_plugin_default = (appRoot, opt) => {
 };
 
 // src/base-plugin/index.ts
-import { basename, join as join3, resolve as resolve5 } from "node:path";
-import { styleText as styleText2 } from "node:util";
+import { writeFile as writeFile3 } from "node:fs/promises";
+import { basename as basename2, join as join5, resolve as resolve5 } from "node:path";
+import { styleText as styleText4 } from "node:util";
 import { Worker } from "node:worker_threads";
-import apiGenerator from "@kosmojs/api-generator";
 import stubGenerator from "@kosmojs/dev/stub-generator";
-import fetchGenerator from "@kosmojs/fetch-generator";
 
-// src/base-plugin/api-handler.ts
-import { join, resolve } from "node:path";
-import { styleText } from "node:util";
-import { context } from "esbuild";
-import { defaults } from "@kosmojs/devlib";
-var api_handler_default = async (options) => {
-  const { appRoot, sourceFolder, baseurl, apiurl } = options;
-  const apiDir = join(sourceFolder, defaults.apiDir);
-  const outDir = join(options.outDir, defaults.apiDir);
-  const esbuildOptions = await import(resolve(appRoot, "esbuild.json"), { with: { type: "json" } }).then((e) => e.default);
-  let app;
-  let devMiddlewareFactory;
-  let teardownHandler;
-  const watcher = async () => {
-    const rebuildPlugin = {
-      name: "rebuild",
-      setup(build) {
-        build.onEnd(async () => {
-          if (app) {
-            await teardownHandler?.(app);
-          }
-          try {
-            const exports = await import(`${outDir}/app.js?${Date.now()}`);
-            devMiddlewareFactory = exports.devMiddlewareFactory;
-            teardownHandler = exports.teardownHandler;
-            app = await exports.default();
-            console.debug(`${styleText("green", "\u279C")} Api handler ready`);
-          } catch (error) {
-            console.error(`${styleText("red", "\u2717")} Api handler error`);
-            console.error(error);
-          }
-        });
-      }
-    };
-    const ctx = await context({
-      ...esbuildOptions,
-      logLevel: "error",
-      bundle: true,
-      entryPoints: [join(apiDir, "app.ts")],
-      plugins: [rebuildPlugin],
-      outdir: outDir
-    });
-    return {
-      async start() {
-        await ctx.watch({
-          // waits this many milliseconds before rebuilding after a change is detected
-          delay: options.watcher.delay
-        });
-      },
-      async stop() {
-        await ctx.dispose();
-      }
-    };
-  };
-  const devMiddleware = async (req, res, viteHandler) => {
-    const next = () => {
-      return viteHandler();
-    };
-    if (devMiddlewareFactory) {
-      const handler = devMiddlewareFactory(app);
-      await handler(req, res, next);
-    } else {
-      !req?.url || !new RegExp(`^${join(baseurl, apiurl)}($|/)`).test(req.url) ? next() : await app?.callback()(req, res);
-    }
-  };
-  return {
-    watcher,
-    devMiddleware
-  };
-};
-
-// src/base-plugin/routes.ts
-import {
-  defaults as defaults3
-} from "@kosmojs/devlib";
-
-// src/base-plugin/routes/resolve.ts
-import { dirname as dirname2, join as join2, resolve as resolve4 } from "node:path";
-import crc3 from "crc/crc32";
+// src/routes-factory/resolve.ts
+import { dirname as dirname3, join as join3, resolve as resolve3 } from "node:path";
+import { styleText as styleText2 } from "node:util";
+import crc5 from "crc/crc32";
+import mimeTypes from "mime-types";
 import picomatch from "picomatch";
 import { glob as glob2 } from "tinyglobby";
-import {
-  defaults as defaults2,
-  pathResolver as pathResolver2,
-  pathTokensFactory,
-  render,
-  renderToFile
-} from "@kosmojs/devlib";
 
-// src/base-plugin/ast.ts
-import { resolve as resolve2 } from "node:path";
+// src/ast.ts
+import { resolve } from "node:path";
+import { styleText } from "node:util";
 import crc from "crc/crc32";
 import { flattener } from "tfusion";
 import {
   Project,
   SyntaxKind
 } from "ts-morph";
-import { HTTPMethods } from "@kosmojs/api";
+import {
+  HTTPMethods,
+  RequestValidationTargets
+} from "@kosmojs/api";
 var createProject = (opts) => new Project(opts);
 var resolveRouteSignature = async (route, opts) => {
   const {
@@ -183,19 +207,12 @@ var resolveRouteSignature = async (route, opts) => {
   );
   const defaultExport = extractDefaultExport(sourceFile);
   const paramsRefinements = defaultExport ? extractParamsRefinements(defaultExport) : void 0;
-  const methods = defaultExport ? extractRouteMethods(defaultExport, route) : [];
-  const payloadTypes = methods.flatMap((e) => {
-    return e.payloadType ? [e.payloadType] : [];
-  });
-  const responseTypes = methods.flatMap((e) => {
-    return e.responseType ? [e.responseType] : [];
-  });
+  const methods = defaultExport ? extractRouteMethods(route, defaultExport) : [];
   return {
     typeDeclarations,
     paramsRefinements,
     methods: methods.map((e) => e.method),
-    payloadTypes,
-    responseTypes,
+    validationDefinitions: methods.flatMap((e) => e.validationDefinitions),
     referencedFiles
   };
 };
@@ -210,22 +227,23 @@ var extractDefaultExport = (sourceFile) => {
   return defaultExport;
 };
 var extractParamsRefinements = (callExpression) => {
-  const [firstGeneric] = extractGenerics(callExpression);
-  if (!firstGeneric?.node.isKind(SyntaxKind.TupleType)) {
-    return;
-  }
-  const tupleElements = firstGeneric.node.getElements();
-  if (!tupleElements?.length) {
+  const [
+    _routeName,
+    // first generic - the route name
+    paramsGeneric
+    // second generic - params refinements
+  ] = extractGenerics(callExpression);
+  if (!paramsGeneric?.isKind(SyntaxKind.TupleType)) {
     return;
   }
-  return tupleElements.map((node, index) => {
+  return paramsGeneric.getElements().map((node, index) => {
     return {
       index,
       text: node.getText()
     };
   });
 };
-var extractRouteMethods = (callExpression, route) => {
+var extractRouteMethods = (route, callExpression) => {
   const funcDeclaration = callExpression.getFirstChildByKind(SyntaxKind.ArrowFunction) || callExpression.getFirstChildByKind(SyntaxKind.FunctionExpression);
   if (!funcDeclaration) {
     return [];
@@ -246,35 +264,173 @@ var extractRouteMethods = (callExpression, route) => {
     }
   }
   const methods = [];
-  const skipValidationFilter = (e) => /@skip-validation/.test(e);
   for (const [callExpression2, method] of callExpressions) {
-    const [payloadGeneric, responseGeneric] = extractGenerics(callExpression2);
-    const payloadText = payloadGeneric?.node ? payloadGeneric.node.getChildren().length === 0 ? "{}" : payloadGeneric.node.getFullText() : void 0;
-    const responseText = responseGeneric?.node.getText();
-    const responseType = responseText ? {
-      id: ["ResponseT", crc(route.importName + method)].join(""),
-      method,
-      skipValidation: responseGeneric?.comments ? responseGeneric.comments.some(skipValidationFilter) : false,
-      text: ["never", "object"].includes(responseText) ? "{}" : responseText,
-      resolvedType: void 0
-    } : void 0;
-    const payloadType = payloadText ? {
-      id: ["PayloadT", crc(route.importName + method)].join(""),
-      responseTypeId: responseType?.id,
-      method,
-      skipValidation: payloadGeneric?.comments ? payloadGeneric.comments.some(skipValidationFilter) : false,
-      isOptional: payloadText ? payloadText === "{}" || route.optionalParams : true,
-      text: payloadText,
-      resolvedType: void 0
-    } : void 0;
+    const [vDefs, vOpts] = extractGenerics(callExpression2);
     methods.push({
       method,
-      payloadType,
-      responseType
+      validationDefinitions: extractValidationDefinitions(
+        route,
+        method,
+        vDefs,
+        vOpts
+      )
     });
   }
   return methods;
 };
+var parseRuntimeValidation = (typeNode) => {
+  if (typeNode.isKind(SyntaxKind.LiteralType)) {
+    const literal = typeNode.getFirstChild();
+    if (literal?.isKind(SyntaxKind.TrueKeyword)) {
+      return true;
+    } else if (literal?.isKind(SyntaxKind.FalseKeyword)) {
+      return false;
+    }
+  }
+  return void 0;
+};
+var extractResponseVariant = (typeNode) => {
+  if (!typeNode.isKind(SyntaxKind.TupleType)) {
+    return;
+  }
+  let status = 200;
+  let contentType;
+  let body;
+  const [statusNode, contentTypeNode, bodyNode] = typeNode.getElements();
+  if (statusNode?.isKind(SyntaxKind.LiteralType)) {
+    const literal = statusNode.getFirstChildByKind(SyntaxKind.NumericLiteral);
+    if (literal) {
+      status = Number(literal.getText());
+    }
+  }
+  if (contentTypeNode) {
+    contentType = extractStringLiteral(contentTypeNode);
+  }
+  if (bodyNode) {
+    body = bodyNode.getText();
+    if (["object"].includes(body)) {
+      body = "{}";
+    }
+  }
+  return { status, contentType, body };
+};
+var parseValidationOptions = (typeNode) => {
+  const opts = {};
+  if (!typeNode?.isKind(SyntaxKind.TypeLiteral)) {
+    return opts;
+  }
+  for (const prop of typeNode.getMembers()) {
+    if (!prop.isKind(SyntaxKind.PropertySignature)) {
+      continue;
+    }
+    const target = prop.getName();
+    const typeNode2 = prop.getTypeNodeOrThrow();
+    if (!typeNode2.isKind(SyntaxKind.TypeLiteral)) {
+      continue;
+    }
+    let contentType;
+    let runtimeValidation;
+    const customErrors = {};
+    for (const member of typeNode2.getMembers()) {
+      if (!member.isKind(SyntaxKind.PropertySignature)) {
+        continue;
+      }
+      const nameNode = member.getNameNode();
+      const valueNode = member.getTypeNodeOrThrow();
+      const name = nameNode.isKind(SyntaxKind.StringLiteral) ? nameNode.getLiteralText() : nameNode.getText();
+      if (name === "contentType") {
+        contentType = extractStringLiteral(valueNode);
+      } else if (name === "runtimeValidation") {
+        runtimeValidation = parseRuntimeValidation(valueNode);
+      } else if (name.startsWith("error")) {
+        const literal = extractStringLiteral(valueNode);
+        if (literal) {
+          customErrors[name] = literal;
+        }
+      }
+    }
+    opts[target] = {
+      contentType,
+      runtimeValidation,
+      customErrors
+    };
+  }
+  return opts;
+};
+var extractStringLiteral = (typeNode) => {
+  const literal = typeNode.isKind(SyntaxKind.LiteralType) ? typeNode.getFirstChildByKind(SyntaxKind.StringLiteral) : void 0;
+  return literal ? literal.getLiteralText() : void 0;
+};
+var extractValidationDefinitions = (route, method, defsNode, optsNode) => {
+  const definitions = [];
+  if (!defsNode?.isKind(SyntaxKind.TypeLiteral)) {
+    return definitions;
+  }
+  const optsMap = parseValidationOptions(optsNode);
+  const createId = (target, hash) => {
+    return [
+      target.replace(/^./, (c) => c.toUpperCase()),
+      "T",
+      method,
+      crc(route.id + hash)
+    ].join("");
+  };
+  for (const prop of defsNode.getMembers()) {
+    if (!prop.isKind(SyntaxKind.PropertySignature)) {
+      continue;
+    }
+    const target = prop.getName();
+    const typeNode = prop.getTypeNodeOrThrow();
+    if (target === "response") {
+      const variants = typeNode.isKind(SyntaxKind.UnionType) ? typeNode.getChildrenOfKind(SyntaxKind.TupleType) : [typeNode];
+      definitions.push({
+        ...optsMap[target],
+        method,
+        target,
+        variants: variants.flatMap((e, i) => {
+          const { status, contentType, body } = extractResponseVariant(e) || {};
+          if (!status) {
+            return [];
+          }
+          if (contentType && typeof contentType !== "string") {
+            console.warn(
+              styleText(
+                ["bold", "red"],
+                `\u2717 The second element of a response variant should specify the Response Content Type`
+              )
+            );
+            console.warn(
+              styleText(["blue"], `  Example: [200, "json", Schema]`)
+            );
+            console.warn(
+              `  Route: ${route.name}; Method: ${method}; Response Variant: #${i}`
+            );
+            console.warn();
+          }
+          return [
+            {
+              id: createId(target, JSON.stringify([status, contentType, body])),
+              status,
+              contentType,
+              body
+            }
+          ];
+        })
+      });
+    } else if (Object.keys(RequestValidationTargets).includes(target)) {
+      definitions.push({
+        ...optsMap[target],
+        method,
+        target,
+        schema: {
+          id: createId(target),
+          text: typeNode.getText()
+        }
+      });
+    }
+  }
+  return definitions;
+};
 var extractTypeDeclarations = (sourceFile, opts) => {
   const declarations = [];
   const referencedFiles = opts?.withReferencedFiles ? [] : void 0;
@@ -379,16 +535,11 @@ var getReferencedFiles = (importIdentifier) => {
   });
 };
 var extractGenerics = (callExpression) => {
-  return callExpression.getTypeArguments().map((node) => {
-    return {
-      node,
-      comments: node.getLeadingCommentRanges().map((range) => range.getText().trim())
-    };
-  });
+  return callExpression.getTypeArguments();
 };
 var typeResolverFactory = ({ appRoot }) => {
   const project = createProject({
-    tsConfigFilePath: resolve2(appRoot, "tsconfig.json"),
+    tsConfigFilePath: resolve(appRoot, "tsconfig.json"),
     skipAddingFilesFromTsConfig: true
   });
   const literalTypesResolver = (literalTypes, options) => {
@@ -418,12 +569,24 @@ var typeResolverFactory = ({ appRoot }) => {
   };
 };
 
-// src/base-plugin/cache.ts
+// src/cache.ts
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, resolve as resolve3 } from "node:path";
+import { dirname, resolve as resolve2 } from "node:path";
 import crc2 from "crc/crc32";
 import self from "@kosmojs/dev/package.json" with { type: "json" };
-import { pathExists, pathResolver } from "@kosmojs/devlib";
+
+// src/fs.ts
+import { access, constants } from "node:fs/promises";
+var pathExists = async (path) => {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// src/cache.ts
 var cacheFactory = (route, {
   appRoot,
   sourceFolder,
@@ -432,7 +595,7 @@ var cacheFactory = (route, {
   const cacheFile = pathResolver({
     appRoot,
     sourceFolder
-  }).resolve("apiLibDir", dirname(route.file), "cache.json");
+  }).createPath.libApi(dirname(route.file), "cache.json");
   const getCache = async (opt) => {
     if (await pathExists(cacheFile)) {
       try {
@@ -477,7 +640,7 @@ var cacheFactory = (route, {
       return;
     }
     for (const [file, hash2] of Object.entries(cache.referencedFiles)) {
-      if (!identicalHashSum(hash2, await generateFileHash(resolve3(appRoot, file)))) {
+      if (!identicalHashSum(hash2, await generateFileHash(resolve2(appRoot, file)))) {
         return;
       }
     }
@@ -507,13 +670,232 @@ var identicalHashSum = (a, b) => {
   return a === b;
 };
 
-// src/base-plugin/templates/resolved-types.hbs
+// src/render.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, join as join2 } from "node:path";
+import crc3 from "crc/crc32";
+import handlebars from "handlebars";
+var render = (template, context2, options) => {
+  const { noEscape = true, renderer = handlebars } = { ...options };
+  return renderer.compile(template, { noEscape })(context2);
+};
+var renderToFile = async (file, template, context2, options) => {
+  const content = render(template, context2, options);
+  if (await pathExists(file)) {
+    const { overwrite = true } = { ...options };
+    if (overwrite === false) {
+      return;
+    }
+    const fileContent = await readFile2(file, "utf8");
+    if (typeof overwrite === "function" && !overwrite(fileContent)) {
+      return;
+    }
+    if (crc3(content) === crc3(fileContent)) {
+      return;
+    }
+  }
+  await mkdir2(dirname2(file), { recursive: true });
+  await writeFile2(file, content, "utf8");
+};
+var renderFactory = (options) => {
+  const renderer = handlebars.create();
+  renderer.registerPartial({ ...options?.partials });
+  renderer.registerHelper({ ...options?.helpers });
+  return {
+    render(template, context2, selfOoptions) {
+      return render(template, context2, {
+        renderer,
+        ...options,
+        ...selfOoptions
+      });
+    },
+    async renderToFile(file, template, context2, selfOoptions) {
+      return renderToFile(
+        options?.outdir ? join2(options.outdir, file) : file,
+        template,
+        context2,
+        { renderer, ...options, ...selfOoptions }
+      );
+    }
+  };
+};
+var renderHelpers = {
+  createParamsLiteral: (params) => {
+    return params.schema.map((p) => {
+      return p.kind === "splat" ? `${p.const}?: Array<string | number>` : p.kind === "optional" ? `${p.const}?: string | number` : `${p.const}: string | number`;
+    }).join(", ");
+  }
+};
+
+// src/routes-factory/base.ts
+import crc4 from "crc/crc32";
+import { parse } from "path-to-regexp";
+var pathTokensFactory = (path, {
+  transformStaticValue = normalizeStaticValue
+} = {}) => {
+  const extractParts = (tokens2, createConst, insideGroup = false) => {
+    const parts = [];
+    for (const token of tokens2) {
+      switch (token.type) {
+        case "text":
+          if (token.value !== "/") {
+            parts.push({
+              type: "static",
+              value: transformStaticValue(token.value)
+            });
+          }
+          break;
+        case "param":
+          parts.push({
+            type: "param",
+            kind: insideGroup ? "optional" : "required",
+            name: token.name,
+            const: createConst(token.name)
+          });
+          break;
+        case "wildcard":
+          parts.push({
+            type: "param",
+            kind: "splat",
+            name: token.name,
+            const: createConst(token.name)
+          });
+          break;
+        case "group":
+          parts.push(...extractParts(token.tokens, createConst, true));
+          break;
+      }
+    }
+    return parts;
+  };
+  const patternTransforms = [
+    // Transform required params: [id] => :id
+    // Only pure \w param names,
+    // [some-id] used as is, not treated as param,
+    // use [some_id] instead.
+    (s) => s.replace(/\[(\w+)\]/g, ":$1"),
+    // Transform optional params: {id} => {:id}
+    // Only pure \w param names,
+    // anything else treated as a path-to-regexp pattern and used as is.
+    // {some-id} treated as an optional static segment.
+    // use {some_id} for simple param syntax
+    // or {:some-id} pattern where :some is the param name and -id is a static segment.
+    (s) => s.replace(/\{(\w+)\}/g, "{:$1}"),
+    // Transform splat params: {...param} => {*param}
+    (s) => s.replace(/\{\.\.\./g, "{*"),
+    // Insert leading slash inside optional/splat groups.
+    // {:name} => {/:name}
+    // {*name} => {/*name}
+    (s) => {
+      return s.startsWith("{") ? s.replace(/^\{/, "{/") : s;
+    }
+  ];
+  const detectBareParams = (s) => {
+    let depth = 0;
+    for (const [i, ch] of [...s].entries()) {
+      if (ch === "{") {
+        depth += 1;
+      } else if (ch === "}") {
+        depth -= 1;
+      } else if (ch === ":" && depth === 0) {
+        const match = s.slice(i + 1).match(/^\w+/);
+        return match?.[0] || ":";
+      }
+    }
+    return;
+  };
+  const tokens = path.replace(/^index\/?/, "").split("/").flatMap((orig) => {
+    if (!orig.length) {
+      return [];
+    }
+    const bareParam = detectBareParams(orig);
+    if (bareParam === ":") {
+      throw new Error(
+        `${path} contains colons outside braces, use : only within {}`
+      );
+    } else if (bareParam) {
+      throw new Error(
+        `${path} contains bare params, use [${bareParam}] instead of :${bareParam}`
+      );
+    }
+    const pattern = patternTransforms.reduce((src, fn) => fn(src), orig);
+    const { tokens: tokens2 } = parse(pattern);
+    const parts = extractParts(tokens2, (val) => {
+      return /\W/.test(val) || /^\d/.test(val) ? [val.replace(/^\d+|\W/g, "_"), crc4(orig)].join("_") : val;
+    });
+    const isStatic = parts.length === 1 ? parts[0].type === "static" : false;
+    const isParam = parts.length === 1 ? parts[0].type === "param" : false;
+    const kind = isStatic ? "static" : isParam ? "param" : "mixed";
+    return [
+      {
+        kind,
+        orig,
+        pattern,
+        parts
+      }
+    ];
+  });
+  return [
+    tokens,
+    tokens.map(({ pattern }, i) => {
+      const next = tokens[i + 1];
+      if (!next || next.pattern.includes("/")) {
+        return pattern;
+      }
+      const slashRequired = tokens.slice(i + 1).some((e) => {
+        return e.parts.some((e2) => {
+          return e2.type === "static" || e2.kind === "required";
+        });
+      });
+      return slashRequired ? `${pattern}/` : pattern;
+    }).join("")
+  ];
+};
+var normalizeStaticValue = (value) => {
+  return value.replace(/\+/g, "\\\\+");
+};
+var sortRoutes = (a, b) => {
+  const aSpecificity = routeSpecificity(a.pathTokens);
+  const bSpecificity = routeSpecificity(b.pathTokens);
+  if (aSpecificity !== bSpecificity) {
+    return bSpecificity - aSpecificity;
+  }
+  if (a.pathTokens.length !== b.pathTokens.length) {
+    return a.pathTokens.length - b.pathTokens.length;
+  }
+  return a.name.localeCompare(b.name);
+};
+var paramWeight = (part) => {
+  return {
+    required: 2,
+    optional: 1,
+    splat: 0
+  }[part.kind];
+};
+var mixedSegmentWeight = (parts) => {
+  const hasSplat = parts.some((p) => {
+    return p.type === "param" ? p.kind === "splat" : false;
+  });
+  return hasSplat ? 0.5 : 3;
+};
+var segmentWeight = (token) => {
+  return {
+    static: 4,
+    mixed: mixedSegmentWeight(token.parts),
+    param: paramWeight(token.parts[0])
+  }[token.kind];
+};
+var routeSpecificity = (pathTokens) => {
+  return pathTokens.reduce((sum, token) => sum + segmentWeight(token), 0);
+};
+
+// src/routes-factory/templates/resolved-types.hbs
 var resolved_types_default = "{{#each resolvedTypes}}\nexport type {{name}} = {{text}};\n{{/each}}\n";
 
-// src/base-plugin/templates/types.hbs
-var types_default = '{{#each typeDeclarations}}{{text}}\n{{/each}}\n\nexport type {{params.id}} = {\n  {{#each paramsSchema}}\n  "{{name}}"{{#unless isRequired}}?{{/unless}}:{{#if isRest}} Array<{{/if}}\n    {{#if refinement}}{{refinement.text}}{{else}}string{{/if}}\n  {{#if isRest}}>{{/if}}\n  {{/each}}\n};\n\n{{#each payloadTypes}}\nexport type {{id}} = {{text}};\n{{/each}}\n\n{{#each responseTypes}}\nexport type {{id}} = {{text}};\n{{/each}}\n';
+// src/routes-factory/templates/types.hbs
+var types_default = '{{#each typeDeclarations}}{{text}}\n{{/each}}\n\nexport type {{params.id}} = {\n  {{#each paramsSchema}}\n  "{{name}}"{{#unless isRequired}}?{{/unless}}: {{#if refinement}}\n    {{refinement.text}},\n  {{else}}\n    {{#if isSplat}}Array<string>{{else}}string{{/if}},\n  {{/if}}\n  {{/each}}\n};\n\n{{#each validationTypes}}export type {{id}} = {{text}};\n{{/each}}\n';
 
-// src/base-plugin/routes/resolve.ts
+// src/routes-factory/resolve.ts
 var API_INDEX_BASENAME = "index";
 var API_INDEX_PATTERN = `${API_INDEX_BASENAME}.ts`;
 var API_USE_BASENAME = "use";
@@ -524,29 +906,30 @@ var PAGE_LAYOUT_BASENAME = "layout";
 var PAGE_LAYOUT_PATTERN = `${PAGE_LAYOUT_BASENAME}.{tsx,vue}`;
 var ROUTE_FILE_PATTERNS = [
   // match index files in api dir
-  `${defaults2.apiDir}/**/${API_INDEX_PATTERN}`,
+  `${defaults.apiDir}/**/${API_INDEX_PATTERN}`,
   // match use files in api dir
-  `${defaults2.apiDir}/**/${API_USE_PATTERN}`,
+  `${defaults.apiDir}/**/${API_USE_PATTERN}`,
   // match index files in pages dir
-  `${defaults2.pagesDir}/**/${PAGE_INDEX_PATTERN}`,
+  `${defaults.pagesDir}/**/${PAGE_INDEX_PATTERN}`,
   // match layout files in pages dir
-  `${defaults2.pagesDir}/**/${PAGE_LAYOUT_PATTERN}`
+  `${defaults.pagesDir}/**/${PAGE_LAYOUT_PATTERN}`
 ];
 var scanRoutes = async ({
   appRoot,
   sourceFolder
 }) => {
+  const { createPath } = pathResolver({ appRoot, sourceFolder });
   return glob2(ROUTE_FILE_PATTERNS, {
-    cwd: resolve4(appRoot, sourceFolder),
+    cwd: createPath.src(),
     absolute: true,
     onlyFiles: true,
     followSymbolicLinks: false,
     ignore: [
       // ignore top-level matches, routes resides in folders, even index route
-      `${defaults2.apiDir}/${API_INDEX_PATTERN}`,
-      `${defaults2.apiDir}/${API_USE_PATTERN}`,
-      `${defaults2.pagesDir}/${PAGE_INDEX_PATTERN}`,
-      `${defaults2.pagesDir}/${PAGE_LAYOUT_PATTERN}`
+      `${defaults.apiDir}/${API_INDEX_PATTERN}`,
+      `${defaults.apiDir}/${API_USE_PATTERN}`,
+      `${defaults.pagesDir}/${PAGE_INDEX_PATTERN}`,
+      `${defaults.pagesDir}/${PAGE_LAYOUT_PATTERN}`
     ]
   });
 };
@@ -554,11 +937,11 @@ var isRouteFile = (file, {
   appRoot,
   sourceFolder
 }) => {
-  const [_sourceFolder, folder, ...rest] = resolve4(appRoot, file).replace(`${appRoot}/`, "").split("/");
+  const [_sourceFolder, folder, ...rest] = resolve3(appRoot, file).replace(`${appRoot}/${defaults.srcDir}/`, "").split("/");
   if (!folder || _sourceFolder !== sourceFolder || rest.length < 2) {
-    return;
+    return false;
   }
-  return picomatch.isMatch(join2(folder, ...rest), ROUTE_FILE_PATTERNS) ? [folder, rest.join("/")] : void 0;
+  return picomatch.isMatch(join3(folder, ...rest), ROUTE_FILE_PATTERNS) ? [folder, rest.join("/")] : false;
 };
 var isApiRoute = (file) => {
   return picomatch.matchBase(file, `**/${API_INDEX_PATTERN}`);
@@ -572,29 +955,27 @@ var isPageRoute = (file) => {
 var isPageLayout = (file) => {
   return picomatch.matchBase(file, `**/${PAGE_LAYOUT_PATTERN}`);
 };
-var createRouteEntry = (_file, {
+var createRouteEntry = (fileFullpath, {
   appRoot,
   sourceFolder
 }) => {
-  const resolvedPaths = isRouteFile(_file, { appRoot, sourceFolder });
+  const resolvedPaths = isRouteFile(fileFullpath, { appRoot, sourceFolder });
   if (!resolvedPaths) {
     return;
   }
   const [folder, file] = resolvedPaths;
-  const fileFullpath = join2(appRoot, sourceFolder, folder, file);
-  const pathTokens = pathTokensFactory(dirname2(file));
-  const name = pathTokens.map((e) => e.orig).join("/");
-  const importFile = file;
-  const importName = `${importFile.replace(/\W+/g, "_")}_${crc3(importFile)}`;
-  return {
-    name,
-    folder,
-    file,
-    fileFullpath,
-    pathTokens,
-    importFile,
-    importName
-  };
+  const id = `${file.replace(/\W+/g, "_")}_${crc5(file)}`;
+  const name = dirname3(file);
+  try {
+    const [pathTokens, pathPattern] = pathTokensFactory(dirname3(file));
+    return { id, name, folder, file, fileFullpath, pathTokens, pathPattern };
+  } catch (error) {
+    console.error(
+      `\u2757${styleText2("red", "ERROR")}: Failed parsing path for "${styleText2("cyan", file)}"`
+    );
+    console.error(error);
+    return;
+  }
 };
 var pageLayoutResolverFactory = () => {
   return (entry) => {
@@ -610,27 +991,21 @@ var pageLayoutResolverFactory = () => {
 };
 var pageRouteResolverFactory = () => {
   return (entry) => {
-    const {
-      name,
-      folder,
-      file,
-      fileFullpath,
-      pathTokens,
-      importFile,
-      importName
-    } = entry;
+    const { id, name, folder, file, fileFullpath, pathTokens, pathPattern } = entry;
     const handler = async () => {
       const entry2 = {
+        id,
         name,
         pathTokens,
+        pathPattern,
         params: {
-          schema: pathTokens.flatMap((e) => e.param ? [e.param] : [])
+          schema: pathTokens.flatMap((e) => {
+            return e.parts.filter((p) => p.type === "param");
+          })
         },
         folder,
         file,
-        fileFullpath,
-        importFile,
-        importName
+        fileFullpath
       };
       return {
         kind: "pageRoute",
@@ -657,38 +1032,35 @@ var apiRouteResolverFactory = (pluginOptions) => {
     appRoot,
     sourceFolder,
     generators = [],
-    formatters = [],
     refineTypeName
   } = pluginOptions;
-  let resolveTypes = false;
-  for (const { options } of generators) {
-    if (options?.resolveTypes) {
-      resolveTypes = true;
-    }
-  }
+  const resolveTypes = generators.some((e) => e.options?.resolveTypes);
   const {
     //
     literalTypesResolver,
     getSourceFile,
     refreshSourceFile
   } = typeResolverFactory(pluginOptions);
-  return (entry) => {
-    const {
-      name,
-      file,
-      folder,
-      fileFullpath,
-      pathTokens,
-      importFile,
-      importName
-    } = entry;
+  return ({
+    id,
+    name,
+    file,
+    folder,
+    fileFullpath,
+    pathTokens,
+    pathPattern
+  }) => {
     const handler = async (updatedFile) => {
-      const paramsSchema = pathTokens.flatMap((e) => {
-        return e.param ? [e.param] : [];
-      });
-      const optionalParams = paramsSchema.length ? !paramsSchema.some((e) => e.isRequired) : true;
+      const paramsSchema = pathTokens.flatMap(
+        (e) => {
+          return e.parts.flatMap((p) => {
+            return p.type === "param" ? [p] : [];
+          });
+        }
+      );
+      const optionalParams = paramsSchema.length ? paramsSchema.filter((e) => e.kind === "required").length === 0 : true;
       const { getCache, persistCache } = cacheFactory(
-        { file, fileFullpath, importName },
+        { id, file, fileFullpath },
         {
           appRoot,
           sourceFolder,
@@ -704,19 +1076,23 @@ var apiRouteResolverFactory = (pluginOptions) => {
           typeDeclarations,
           paramsRefinements,
           methods,
-          payloadTypes,
-          responseTypes,
+          validationDefinitions: validationDefinitions2,
           referencedFiles = []
         } = await resolveRouteSignature(
-          { importName, fileFullpath, optionalParams },
+          { id, name, fileFullpath, optionalParams },
           {
             withReferencedFiles: true,
             sourceFile: getSourceFile(fileFullpath),
             relpathResolver(path) {
-              return join2(sourceFolder, defaults2.apiDir, dirname2(file), path);
+              return join3(sourceFolder, defaults.apiDir, dirname3(file), path);
             }
           }
         );
+        const validationTypes = validationDefinitions2.flatMap((def) => {
+          return def.target === "response" ? def.variants.flatMap(({ id: id2, body }) => {
+            return body ? [{ id: id2, text: body }] : [];
+          }) : [def.schema];
+        });
         const numericParams = paramsRefinements ? paramsRefinements.flatMap(({ text, index }) => {
           if (text === "number") {
             const param = paramsSchema.at(index);
@@ -724,13 +1100,12 @@ var apiRouteResolverFactory = (pluginOptions) => {
           }
           return [];
         }) : [];
-        const typesFile = pathResolver2({ appRoot, sourceFolder }).resolve(
-          "apiLibDir",
-          dirname2(file),
-          "types.ts"
-        );
+        const typesFile = pathResolver({
+          appRoot,
+          sourceFolder
+        }).createPath.libApi(dirname3(file), "types.ts");
         const params = {
-          id: ["ParamsT", crc3(name)].join(""),
+          id: ["ParamsT", crc5(name)].join(""),
           schema: paramsSchema,
           resolvedType: void 0
         };
@@ -739,25 +1114,21 @@ var apiRouteResolverFactory = (pluginOptions) => {
           paramsSchema: paramsSchema.map((param, index) => {
             return {
               ...param,
+              isRequired: param.kind === "required",
+              isSplat: param.kind === "splat",
               refinement: paramsRefinements?.at(index)
             };
           }),
           typeDeclarations,
-          payloadTypes,
-          responseTypes
+          validationTypes
         });
         const resolvedTypes = resolveTypes ? literalTypesResolver(typesFileContent, {
-          overrides: [...payloadTypes, ...responseTypes].reduce(
-            (map, { id, skipValidation }) => {
-              if (skipValidation) {
-                map[id] = "never";
-              }
-              return map;
-            },
-            { [refineTypeName]: refineTypeName }
-          ),
-          withProperties: [params.id, ...payloadTypes.map((e) => e.id)],
-          formatters
+          stripComments: true,
+          overrides: { [refineTypeName]: refineTypeName },
+          withProperties: [
+            params.id,
+            ...validationTypes.flatMap(({ id: id2 }) => id2)
+          ]
         }) : void 0;
         await renderToFile(
           typesFile,
@@ -770,59 +1141,205 @@ var apiRouteResolverFactory = (pluginOptions) => {
           methods,
           typeDeclarations,
           numericParams,
-          // text was needed at writing types.ts file, dropping from cache
-          payloadTypes: payloadTypes.map(({ text, ...rest }) => {
-            return {
-              ...rest,
-              resolvedType: resolvedTypes?.find((e) => e.name === rest.id)
-            };
-          }),
-          responseTypes: responseTypes.map(({ text, ...rest }) => {
+          referencedFiles,
+          validationDefinitions: validationDefinitions2.map((def) => {
             return {
-              ...rest,
-              resolvedType: resolvedTypes?.find((e) => e.name === rest.id)
+              ...def,
+              ...def.target === "response" ? {
+                variants: def.variants.map((variant) => {
+                  return {
+                    ...variant,
+                    resolvedType: resolvedTypes?.find(
+                      (e) => e.name === variant.id
+                    )
+                  };
+                })
+              } : {
+                schema: {
+                  ...def.schema,
+                  resolvedType: resolvedTypes?.find(
+                    (e) => e.name === def.schema.id
+                  )
+                }
+              }
             };
-          }),
-          referencedFiles
+          })
         });
       }
-      const entry2 = {
+      const validationDefinitions = cache.validationDefinitions.flatMap(
+        (def) => {
+          let augmentedDef = def;
+          if (def.target === "response") {
+            augmentedDef = {
+              ...def,
+              variants: def.variants.flatMap((variant, i) => {
+                if (typeof variant.contentType !== "string") {
+                  return [variant];
+                }
+                if (variant.contentType.includes("/")) {
+                  return [variant];
+                }
+                const contentType = mimeTypes.lookup(variant.contentType);
+                if (contentType === false) {
+                  console.warn(
+                    styleText2(
+                      ["bold", "red"],
+                      "\u2717 Failed resolving Response Content Type"
+                    )
+                  );
+                  console.warn(
+                    `  Invalid value provided for mime-types lookup - ${variant.contentType}`
+                  );
+                  console.warn(
+                    styleText2(
+                      ["cyan"],
+                      `  Response variant #${i} excluded from route schemas`
+                    )
+                  );
+                  console.warn(`  Route: ${name}; Method: ${def.method}`);
+                  console.warn();
+                  return [];
+                }
+                return [{ ...variant, contentType }];
+              })
+            };
+          } else if (def.contentType && !def.contentType.includes("/")) {
+            const contentType = mimeTypes.lookup(def.contentType);
+            if (contentType === false) {
+              console.warn(
+                styleText2(
+                  ["bold", "red"],
+                  "\u2717 Failed resolving Response Content Type"
+                )
+              );
+              console.warn(
+                `  Invalid value provided for mime-types lookup - ${def.contentType}`
+              );
+              console.warn(`  Route: ${name}; Method: ${def.method}`);
+              console.warn();
+            } else {
+              augmentedDef = { ...def, contentType };
+            }
+          }
+          return augmentedDef ? [augmentedDef] : [];
+        }
+      );
+      const entry = {
+        id,
         name,
         pathTokens,
+        pathPattern,
         params: cache.params,
         numericParams: cache.numericParams,
         optionalParams,
-        importName,
-        importFile,
         folder,
         file,
         fileFullpath,
         methods: cache.methods,
         typeDeclarations: cache.typeDeclarations,
-        payloadTypes: cache.payloadTypes,
-        responseTypes: cache.responseTypes,
+        validationDefinitions,
         referencedFiles: Object.keys(cache.referencedFiles).map(
           // expand referenced files path,
           // they are stored as relative in cache
-          (e) => resolve4(appRoot, e)
+          (e) => resolve3(appRoot, e)
         )
       };
       return {
         kind: "apiRoute",
-        entry: entry2
+        entry
       };
     };
     return { name, handler };
   };
 };
 
-// src/base-plugin/routes/nesting.ts
-import {
-  sortRoutes
-} from "@kosmojs/devlib";
+// src/routes-factory/nesting.ts
+import { basename } from "node:path";
+var nestedRoutesFactory = (routeEntries) => {
+  const entryStack = structuredClone(routeEntries).sort(sortRoutes);
+  const transformEntries = (entries, parent) => {
+    return [...new Set(entries.map((e) => e.name))].flatMap((name) => {
+      const nameEntries = entryStack.flatMap(({ fileFullpath, ...entry }) => {
+        return entry.name === name ? [entry] : [];
+      });
+      const index = nameEntries.find(
+        (e) => basename(e.file).startsWith(PAGE_INDEX_BASENAME)
+      );
+      const layout = nameEntries.find(
+        (e) => basename(e.file).startsWith(PAGE_LAYOUT_BASENAME)
+      );
+      if (index || layout) {
+        return [
+          {
+            index: index ? {
+              ...index,
+              pathTokens: index.pathTokens.slice(
+                parent?.pathTokens.length || 0
+              )
+            } : void 0,
+            layout: layout ? {
+              ...layout,
+              pathTokens: layout.pathTokens.slice(
+                parent?.pathTokens.length || 0
+              )
+            } : void 0,
+            parent: parent?.name,
+            children: transformEntries(
+              findDescendantEntries(index || layout),
+              index || layout
+            )
+          }
+        ];
+      }
+      return [];
+    });
+  };
+  const findDescendantEntries = ({
+    name,
+    pathTokens
+  }) => {
+    const potentialChildren = entryStack.filter((entry) => {
+      if (entry.pathTokens.length <= pathTokens.length) {
+        return false;
+      }
+      if (!entry.name.startsWith(`${name}/`)) {
+        return false;
+      }
+      return true;
+    });
+    return potentialChildren.filter((child) => {
+      const hasIntermediateRoute = potentialChildren.some((intermediate) => {
+        if (intermediate === child) {
+          return false;
+        }
+        if (intermediate.pathTokens.length <= pathTokens.length) {
+          return false;
+        }
+        if (intermediate.pathTokens.length >= child.pathTokens.length) {
+          return false;
+        }
+        return child.name.startsWith(`${intermediate.name}/`);
+      });
+      return !hasIntermediateRoute;
+    });
+  };
+  const rootEntries = entryStack.filter((entry) => {
+    const hasParent = entryStack.some((potential) => {
+      if (potential === entry) {
+        return false;
+      }
+      if (potential.pathTokens.length >= entry.pathTokens.length) {
+        return false;
+      }
+      return entry.name.startsWith(`${potential.name}/`);
+    });
+    return !hasParent;
+  });
+  return transformEntries(rootEntries);
+};
 
-// src/base-plugin/routes.ts
-var routes_default = async (pluginOptions) => {
+// src/routes-factory/index.ts
+var routesFactory = async (pluginOptions) => {
   const { appRoot, sourceFolder } = pluginOptions;
   const apiRouteResolver = apiRouteResolverFactory(pluginOptions);
   const apiUseResolver = apiUseResolverFactory(pluginOptions);
@@ -835,13 +1352,13 @@ var routes_default = async (pluginOptions) => {
       return entry ? [entry] : [];
     });
     for (const entry of entries) {
-      if (entry.folder === defaults3.apiDir) {
+      if (entry.folder === defaults.apiDir) {
         if (isApiRoute(entry.file)) {
           resolvers.set(entry.fileFullpath, apiRouteResolver(entry));
         } else if (isApiUse(entry.file)) {
           resolvers.set(entry.fileFullpath, apiUseResolver(entry));
         }
-      } else if (entry.folder === defaults3.pagesDir) {
+      } else if (entry.folder === defaults.pagesDir) {
         if (isPageRoute(entry.file)) {
           resolvers.set(entry.fileFullpath, pageRouteResolver(entry));
         } else if (isPageLayout(entry.file)) {
@@ -858,10 +1375,85 @@ var routes_default = async (pluginOptions) => {
   };
 };
 
+// src/base-plugin/api-handler.ts
+import { join as join4, resolve as resolve4 } from "node:path";
+import { styleText as styleText3 } from "node:util";
+import { context } from "esbuild";
+var api_handler_default = async (options) => {
+  const { appRoot, sourceFolder, baseurl, apiurl } = options;
+  const { createPath } = pathResolver({ appRoot, sourceFolder });
+  const outDir = join4(options.outDir, defaults.apiDir);
+  const esbuildOptions = await import(resolve4(appRoot, "esbuild.json"), { with: { type: "json" } }).then((e) => e.default);
+  let devSetup;
+  const watcher = async () => {
+    const rebuildPlugin = {
+      name: "rebuild",
+      setup(build) {
+        build.onEnd(async () => {
+          if (devSetup) {
+            await devSetup.teardownHandler?.();
+          }
+          try {
+            await import(`${outDir}/dev.js?${Date.now()}`).then((e) => {
+              devSetup = e.default;
+            });
+            console.debug(`${styleText3("green", "\u279C")} Api handler ready`);
+          } catch (error) {
+            console.error(`${styleText3("red", "\u2717")} Api handler error`);
+            console.error(error);
+          }
+        });
+      }
+    };
+    const ctx = await context({
+      ...esbuildOptions,
+      define: {
+        ...esbuildOptions.define,
+        PRODUCTION_BUILD: "false"
+      },
+      logLevel: "error",
+      bundle: true,
+      entryPoints: [createPath.api("dev.ts")],
+      plugins: [rebuildPlugin],
+      outdir: outDir
+    });
+    return {
+      async start() {
+        await ctx.watch({
+          // waits this many milliseconds before rebuilding after a change is detected
+          delay: options.watcher.delay
+        });
+      },
+      async stop() {
+        await ctx.dispose();
+      }
+    };
+  };
+  const devMiddleware = async (req, res, next) => {
+    const {
+      requestMatcher = () => {
+        return new RegExp(`^${join4(baseurl, apiurl)}($|/)`).test(
+          req.url
+        );
+      },
+      requestHandler
+    } = { ...devSetup };
+    if (!requestMatcher(req)) {
+      return next();
+    }
+    const handler = requestHandler?.();
+    return handler ? handler(req, res) : next();
+  };
+  return {
+    watcher,
+    devMiddleware
+  };
+};
+
 // src/base-plugin/spinner.ts
-import ora from "ora";
+import { Spinner } from "@topcli/spinner";
 var spinnerFactory = (startText) => {
-  const spinner = ora().start(startText);
+  const spinner = new Spinner().start(startText);
   let _text = startText;
   return {
     text(text) {
@@ -883,7 +1475,7 @@ var spinnerFactory = (startText) => {
       if (text) {
         this.text([_text, text].join("\n"));
       }
-      spinner.fail();
+      spinner.failed();
     }
   };
 };
@@ -894,19 +1486,13 @@ var base_plugin_default = (apiurl, pluginOptions) => {
   const outDirSuffix = "client";
   const store = {};
   const createWorker = () => {
-    const {
-      generators = [],
-      formatters = [],
-      ...restOptions
-    } = store.resolvedOptions;
+    const { generators = [], ...restOptions } = store.resolvedOptions;
     const generatorModules = generators.map(
       (e) => [e.moduleImport, e.moduleConfig]
     );
-    const formatterModules = pluginOptions?.formatters ? pluginOptions.formatters.map((e) => [e.moduleImport, e.moduleConfig]) : [];
     const workerData = {
       ...restOptions,
-      generatorModules,
-      formatterModules
+      generatorModules
     };
     return new Worker(resolve5(import.meta.dirname, "base-plugin/worker.js"), {
       workerData,
@@ -945,10 +1531,10 @@ var base_plugin_default = (apiurl, pluginOptions) => {
           const { error } = msg;
           if (error.stack) {
             const [message, ...stack] = error.stack.split("\n");
-            console.error(styleText2("red", message));
+            console.error(styleText4("red", message));
             console.error(stack.join("\n"));
           } else if (error?.message) {
-            console.error(`${styleText2("red", error?.name)}: ${error.message}`);
+            console.error(`${styleText4("red", error?.name)}: ${error.message}`);
           } else {
             console.error(error);
           }
@@ -974,15 +1560,15 @@ var base_plugin_default = (apiurl, pluginOptions) => {
       }
       return {
         build: {
-          outDir: join3(config.build.outDir, outDirSuffix),
+          outDir: join5(config.build.outDir, outDirSuffix),
           manifest: true
         }
       };
     },
     async configResolved(_config) {
       store.config = _config;
-      const appRoot = resolve5(store.config.root, "..");
-      const sourceFolder = basename(store.config.root);
+      const appRoot = resolve5(store.config.root, "../..");
+      const sourceFolder = basename2(store.config.root);
       const outDir = resolve5(appRoot, resolve5(store.config.build.outDir, ".."));
       const { stabilityThreshold = 1e3 } = typeof store.config.server.watch?.awaitWriteFinish === "object" ? store.config.server.watch.awaitWriteFinish : {};
       const watcher = {
@@ -990,14 +1576,12 @@ var base_plugin_default = (apiurl, pluginOptions) => {
         ...store.config.server.watch ? { options: store.config.server.watch } : {}
       };
       {
-        const {
-          generators = [],
-          formatters = [],
-          refineTypeName = "TRefine"
-        } = { ...pluginOptions };
-        const _apiGenerator = generators.find((e) => e.kind === "api");
-        const _fetchGenerator = generators.find((e) => e.kind === "fetch");
-        const _ssrGenerator = generators.find((e) => e.kind === "ssr");
+        const { generators = [], refineTypeName = "TRefine" } = {
+          ...pluginOptions
+        };
+        const apiGenerator = generators.find((e) => e.slot === "api");
+        const fetchGenerator = generators.find((e) => e.slot === "fetch");
+        const ssrGenerator = generators.find((e) => e.slot === "ssr");
         store.resolvedOptions = {
           ...pluginOptions,
           command: store.config.command,
@@ -1006,17 +1590,16 @@ var base_plugin_default = (apiurl, pluginOptions) => {
             // 1. stub generator should run first
             stubGenerator(),
             // 2. then api generator
-            _apiGenerator || apiGenerator(),
-            // 3. then fetch generator
-            _fetchGenerator || fetchGenerator(),
+            ...apiGenerator ? [apiGenerator] : [],
+            // 3. then fetch generator, only if api generator also enabled
+            ...fetchGenerator && apiGenerator ? [fetchGenerator] : [],
             // 4. user generators in the order they were added
             ...generators.filter((e) => {
-              return e.kind ? !["api", "fetch", "ssr"].includes(e.kind) : true;
+              return e.slot ? !["api", "fetch", "ssr"].includes(e.slot) : true;
             }),
             // 5. ssr generator should run last
-            ..._ssrGenerator ? [_ssrGenerator] : []
+            ...ssrGenerator ? [ssrGenerator] : []
           ],
-          formatters: formatters.map((e) => e.formatter),
           refineTypeName,
           baseurl: store.config.base,
           apiurl,
@@ -1025,8 +1608,54 @@ var base_plugin_default = (apiurl, pluginOptions) => {
           outDir
         };
       }
+      const packageJsonFile = resolve5(appRoot, "package.json");
+      const packageJson = await import(packageJsonFile, {
+        with: { type: "json" }
+      }).then((e) => e.default);
+      const newDependencies = [];
+      for (const generator of store.resolvedOptions.generators) {
+        for (const key of ["dependencies", "devDependencies"]) {
+          for (const [pkg, ver] of Object.entries(generator[key] || {})) {
+            if (!packageJson[key]?.[pkg]) {
+              newDependencies.push([key, pkg, ver]);
+            }
+          }
+        }
+      }
+      if (newDependencies.length) {
+        console.warn();
+        console.warn(
+          [
+            "\u{1F4A1} ",
+            styleText4(["bold", "italic", "red"], "New dependencies added: "),
+            styleText4("dim", newDependencies.map(([, pkg]) => pkg).join(", "))
+          ].join("")
+        );
+        console.warn(
+          "\u{1F4E6}",
+          [
+            styleText4(
+              ["bold", "blueBright"],
+              store.config.command === "build" ? "Install them and run a new build: " : "Install them and restart dev server: "
+            ),
+            styleText4(
+              "dim",
+              ["npm", "pnpm", "yarn"].map((e) => `\`${e} install\``).join(" / ")
+            )
+          ].join("")
+        );
+        console.warn();
+        for (const [key, pkg, ver] of newDependencies) {
+          packageJson[key] = { ...packageJson[key], [pkg]: ver };
+        }
+        await writeFile3(
+          packageJsonFile,
+          JSON.stringify(packageJson, null, 2),
+          "utf8"
+        );
+      }
       if (store.config.command === "build") {
-        const { resolvers } = await routes_default(store.resolvedOptions);
+        const { resolvers } = await routesFactory(store.resolvedOptions);
         const resolvedEntries = [];
         {
           const spinner = spinnerFactory("Resolving Routes");
@@ -1042,8 +1671,8 @@ var base_plugin_default = (apiurl, pluginOptions) => {
           const spinner = spinnerFactory("Running Generators");
           for (const { name, factory } of store.resolvedOptions.generators) {
             spinner.append(name);
-            const { watchHandler } = await factory(store.resolvedOptions);
-            await watchHandler(resolvedEntries);
+            const { build } = await factory(store.resolvedOptions);
+            await build(resolvedEntries);
           }
           spinner.succeed();
         }
@@ -1053,6 +1682,10 @@ var base_plugin_default = (apiurl, pluginOptions) => {
       if (store.config.command !== "serve") {
         return;
       }
+      if (!store.resolvedOptions.generators.find((e) => e.slot === "api")) {
+        const stopWorker2 = workerHandler(() => stopWorker2());
+        return;
+      }
       const apiHandler = await api_handler_default(store.resolvedOptions);
       const apiWatcher = await apiHandler.watcher();
       const stopWorker = workerHandler(
@@ -1070,9 +1703,8 @@ var base_plugin_default = (apiurl, pluginOptions) => {
 };
 
 // src/define-plugin/index.ts
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 import { parse as dotenv } from "dotenv";
-import { pathExists as pathExists2 } from "@kosmojs/devlib";
 var define_plugin_default = (entries) => {
   return {
     name: "@kosmojs:definePlugin",
@@ -1080,8 +1712,8 @@ var define_plugin_default = (entries) => {
       const define = {};
       for (const { keys, file, defineOn = "process.env", use } of entries) {
         define[defineOn] = {};
-        const fileExists = file ? await pathExists2(file) : false;
-        const env = fileExists ? dotenv(await readFile2(file, "utf8")) : process.env;
+        const fileExists = file ? await pathExists(file) : false;
+        const env = fileExists ? dotenv(await readFile3(file, "utf8")) : process.env;
         for (const [key, val] of Object.entries(env)) {
           if (keys.includes(key)) {
             define[`${defineOn}.${key}`] = JSON.stringify(val);
@@ -1093,11 +1725,57 @@ var define_plugin_default = (entries) => {
     }
   };
 };
+
+// src/typebox.ts
+var typeboxLiteralText = (text, options) => {
+  return [
+    // Escape backticks for safe use in template literals
+    [/(?<!\\)`/g, "\\`"],
+    // Escape $ for safe use in template literals
+    [/(?<!\\)\$\{/g, "\\${"],
+    /**
+     * TypeBox's built-in `Options` type is not configurable.
+     * To allow a custom type name, exposing `refineTypeName` option,
+     * defaulted to TRefine, then renaming it to `Options`.
+     * */
+    [new RegExp(`\\b${options.refineTypeName}\\s*<`, "g"), "Options<"]
+  ].reduce((text2, [a, b]) => text2.replace(a, b), text);
+};
 export {
+  API_INDEX_BASENAME,
+  API_INDEX_PATTERN,
+  API_USE_BASENAME,
+  API_USE_PATTERN,
+  PAGE_INDEX_BASENAME,
+  PAGE_INDEX_PATTERN,
+  PAGE_LAYOUT_BASENAME,
+  PAGE_LAYOUT_PATTERN,
   alias_plugin_default as aliasPlugin,
-  default2 as apiGenerator,
+  apiRouteResolverFactory,
+  apiUseResolverFactory,
+  createRouteEntry,
+  createTsconfigPaths,
   base_plugin_default as default,
+  defaults,
   define_plugin_default as definePlugin,
-  default3 as fetchGenerator
+  isApiRoute,
+  isApiUse,
+  isPageLayout,
+  isPageRoute,
+  isRouteFile,
+  nestedRoutesFactory,
+  normalizeStaticValue,
+  pageLayoutResolverFactory,
+  pageRouteResolverFactory,
+  pathResolver,
+  pathTokensFactory,
+  render,
+  renderFactory,
+  renderHelpers,
+  renderToFile,
+  routesFactory,
+  scanRoutes,
+  sortRoutes,
+  typeboxLiteralText
 };
 //# sourceMappingURL=index.js.map