@marko/run 0.1.1 → 0.1.3

package/dist/vite/index.js

@@ -3,7 +3,7 @@ import path2 from "path";
 import crypto from "crypto";
 import fs2 from "fs";
 import glob from "glob";
-import { mergeConfig, normalizePath } from "vite";
+import { mergeConfig, resolvePackageData } from "vite";
 import markoVitePlugin, { FileStore } from "@marko/vite";
 
 // src/vite/constants.ts
@@ -626,7 +626,7 @@ function renderRouter(routes, options = {
   writer.writeLines(`// @marko/run/router`);
   const imports = writer.branch("imports");
   imports.writeLines(
-    `import { NotHandled, NotMatched, createInput } from 'virtual:marko-run/internal';`
+    `import { NotHandled, NotMatched, createContext } from 'virtual:marko-run/internal';`
   );
   for (const route of routes.list) {
     const verbs = getVerbs(route);
@@ -643,7 +643,17 @@ function renderRouter(routes, options = {
       `import page${key} from '${virtualFilePrefix}/${markoRunFilePrefix}special__${key}.marko${serverEntryQuery}';`
     );
   }
-  writer.writeLines(``).writeBlockStart(`export function match(method, pathname) {`).writeLines(
+  writer.writeLines(
+    `
+const page404ResponseInit = {
+  status: 404,
+  headers: { "content-type": "text/html;charset=UTF-8" },
+};
+const page500ResponseInit = {
+  status: 404,
+  headers: { "content-type": "text/html;charset=UTF-8" },
+};`
+  ).writeBlockStart(`export function match(method, pathname) {`).writeLines(
     `if (!pathname) {
     pathname = '/';
   } else if (pathname.charAt(0) !== '/') {
@@ -661,17 +671,10 @@ function renderRouter(routes, options = {
   }
   writer.writeBlockEnd("}").writeLines("return null;").writeBlockEnd("}");
   writer.write(`
-export async function invoke(route, request, platform, url = new URL(request.url)) {
-  const context = {
-    url,
-    request,
-    platform
-  };
-  const buildInput = createInput(context);
+export async function invoke(route, request, platform, url) {
+  const [context, buildInput] = createContext(route, request, platform, url);
 	try {
 		if (route) {
-			context.params = route.params;
-			context.meta = route.meta;
       try {
 				const response = await route.handler(context, buildInput);
 				if (response) return response;
@@ -686,14 +689,9 @@ export async function invoke(route, request, platform, url = new URL(request.url
   if (routes.special[RoutableFileTypes.NotFound]) {
     writer.write(
       `    } else {
-      context.params = {};
-      context.meta = {};
     }
     if (context.request.headers.get('Accept')?.includes('text/html')) {
-      return new Response(page404.stream(buildInput()), {
-        status: 404,
-        headers: { "content-type": "text/html;charset=UTF-8" },
-      });
+      return new Response(page404.stream(buildInput()), page404ResponseInit);
     }
 `
     );
@@ -705,13 +703,8 @@ export async function invoke(route, request, platform, url = new URL(request.url
   if (routes.special[RoutableFileTypes.Error]) {
     writer.writeBlockStart(
       `if (context.request.headers.get('Accept')?.includes('text/html')) {`
-    ).writeBlock(
-      `return new Response(page500.stream(buildInput({ error })), {`,
-      [
-        `status: 500,`,
-        `headers: { "content-type": "text/html;charset=UTF-8" },`
-      ],
-      `});`
+    ).writeLines(
+      `return new Response(page500.stream(buildInput({ error })), page500ResponseInit);`
     ).writeBlockEnd("}");
   }
   writer.writeLines(`throw error;`).writeBlockEnd("}").writeBlockEnd("}").write(`
@@ -947,8 +940,8 @@ function stripTsExtension(path3) {
   }
   return path3;
 }
-function renderRouteTypeInfo(routes, pathPrefix = ".", adapterTypes = "") {
-  var _a, _b;
+async function renderRouteTypeInfo(routes, pathPrefix = ".", adapter) {
+  var _a, _b, _c, _d;
   const writer = createStringWriter();
   writer.writeLines(
     `/*
@@ -956,28 +949,25 @@ function renderRouteTypeInfo(routes, pathPrefix = ".", adapterTypes = "") {
   Do NOT manually edit this file or your changes will be lost.
 */
 `,
-    `import type { HandlerLike, Route as AnyRoute, Context as AnyContext, ValidatePath, ValidateHref } from "@marko/run";`,
-    adapterTypes,
-    `
-
-declare global {
-  namespace MarkoRun {`
+    `import type { HandlerLike, Route as AnyRoute, Context as AnyContext, ParamsObject, ValidatePath, ValidateHref } from "@marko/run";`
   );
-  const pathsWriter = writer.branch("paths");
-  writer.write(`
-    type GetablePath<T extends string> = ValidatePath<GetPaths, T>;
-    type GetableHref<T extends string> = ValidateHref<GetPaths, T>; 
-    type PostablePath<T extends string> = ValidatePath<PostPaths, T>;
-    type PostableHref<T extends string> = ValidateHref<PostPaths, T>; 
+  let platformType = "unknown";
+  if (adapter && adapter.typeInfo) {
+    platformType = await adapter.typeInfo((data) => writer.write(data));
+    writer.writeLines("");
   }
-}
+  writer.writeLines(`
+interface NoParams extends ParamsObject {}
+interface NoMeta {}
 `);
+  const pathsWriter = writer.branch("paths");
   const routesWriter = writer.branch("types");
   const serverWriter = writer.branch("server");
   const middlewareRouteTypes = /* @__PURE__ */ new Map();
   const layoutRouteTypes = /* @__PURE__ */ new Map();
   const getPaths = /* @__PURE__ */ new Set();
   const postPaths = /* @__PURE__ */ new Set();
+  writeModuleDeclaration(serverWriter, void 0, void 0, platformType);
   for (const route of routes.list) {
     const { meta, handler, params, middleware, page, layouts } = route;
     const routeType = `Route${route.index}`;
@@ -985,8 +975,8 @@ declare global {
       /\/\$(\$?)([^\/]*)/,
       (_, catchAll, name) => catchAll ? `/:${name || "rest"}*` : `/:${name}`
     )}\``;
-    const paramsType = params ? renderParamsInfoType(params) : "{}";
-    let metaType = "undefined";
+    const paramsType = (params == null ? void 0 : params.length) ? renderParamsInfoType(params) : "NoParams";
+    let metaType = "NoMeta";
     if (page || handler) {
       const isGet = page || ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.includes("get"));
       const isPost = (_b = handler == null ? void 0 : handler.verbs) == null ? void 0 : _b.includes("post");
@@ -1006,31 +996,31 @@ declare global {
       }
     }
     if (meta) {
-      metaType = `typeof import('${pathPrefix}/${stripTsExtension(
-        meta.relativePath
-      )}')`;
+      const path3 = stripTsExtension(`${pathPrefix}/${meta.relativePath}`);
+      metaType = `typeof import('${path3}')`;
       if (/\.(ts|js|mjs)$/.test(meta.relativePath)) {
         metaType += `['default']`;
       }
     }
     if (handler) {
-      writeRouteTypeModule(
+      writeModuleDeclaration(
         serverWriter,
-        pathPrefix,
-        handler.relativePath,
-        routeType
+        `${pathPrefix}/${handler.relativePath}`,
+        routeType,
+        platformType
       );
     }
     if (page) {
-      writer.writeLines(`
-declare module '${pathPrefix}/${page.relativePath}' {
-  export interface Input {}
-
-  namespace MarkoRun {
-    type Route = ${routeType};
-    type Context = AnyContext<AnyContext['platform'], Route>;
-  }
-}`);
+      writeModuleDeclaration(
+        writer,
+        `${pathPrefix}/${page.relativePath}`,
+        routeType,
+        platformType,
+        `
+  export interface Input {
+    renderBody: Marko.Body;
+  }`
+      );
     }
     if (middleware) {
       let i = 0;
@@ -1060,74 +1050,106 @@ declare module '${pathPrefix}/${page.relativePath}' {
       }
     }
     routesWriter.writeLines(
-      `interface ${routeType} extends AnyRoute<${paramsType}, ${metaType}, ${pathType}> {}`
+      `type ${routeType} = AnyRoute<${paramsType}, ${metaType}, ${pathType}>;`
     );
   }
-  pathsWriter.write("    type GetPaths =");
-  for (const path3 of getPaths) {
-    pathsWriter.write(`
-      | '${path3}'`);
+  pathsWriter.write(`type Get =`);
+  if (getPaths.size) {
+    for (const path3 of getPaths) {
+      pathsWriter.write(`
+  | '${path3}'`);
+    }
+  } else {
+    pathsWriter.write(" never");
   }
   pathsWriter.writeLines(";", "");
-  pathsWriter.write("    type PostPaths =");
-  for (const path3 of postPaths) {
-    pathsWriter.write(`
-      | '${path3}'`);
+  pathsWriter.write("type Post =");
+  if (postPaths.size) {
+    for (const path3 of postPaths) {
+      pathsWriter.write(`
+  | '${path3}'`);
+    }
+  } else {
+    pathsWriter.write(" never");
   }
-  pathsWriter.writeLines(";");
+  pathsWriter.writeLines(";", "");
   pathsWriter.join();
   for (const [file, { routeTypes }] of middlewareRouteTypes) {
-    writeRouteTypeModule(
+    writeModuleDeclaration(
       serverWriter,
-      pathPrefix,
-      file.relativePath,
-      routeTypes.join(" | ")
+      `${pathPrefix}/${file.relativePath}`,
+      routeTypes.join(" | "),
+      platformType
     );
   }
   for (const [file, { routeTypes }] of layoutRouteTypes) {
-    writer.writeLines(`
-declare module '${pathPrefix}/${file.relativePath}' {
+    writeModuleDeclaration(
+      writer,
+      `${pathPrefix}/${file.relativePath}`,
+      routeTypes.join(" | "),
+      platformType,
+      `
   export interface Input {
     renderBody: Marko.Body;
+  }`
+    );
   }
-
-  namespace MarkoRun {
-    type Route = ${routeTypes.join(" | ")};
-    type Context = AnyContext<AnyContext['platform'], Route>;
-  }
-}`);
+  if ((_c = routes.special["404"]) == null ? void 0 : _c.page) {
+    writeModuleDeclaration(
+      writer,
+      `${pathPrefix}/${routes.special["404"].page.relativePath}`,
+      void 0,
+      platformType,
+      `
+  export interface Input {}`
+    );
   }
-  for (const route of [routes.special["404"], routes.special["500"]]) {
-    if (route && route.page) {
-      writer.write(`
-declare module '${pathPrefix}/${route.page.relativePath}' {
-  export interface Input {`);
-      if (route.page.type === RoutableFileTypes.Error) {
-        writer.write(`
+  if ((_d = routes.special["500"]) == null ? void 0 : _d.page) {
+    writeModuleDeclaration(
+      writer,
+      `${pathPrefix}/${routes.special["500"].page.relativePath}`,
+      void 0,
+      platformType,
+      `
+  export interface Input {
     error: unknown;
-  `);
-      }
-      writer.writeLines(`}
-
-  namespace MarkoRun {
-    type Route = AnyRoute;
-    type Context = AnyContext<AnyContext['platform'], Route>;
-  }
-}`);
-    }
+  }`
+    );
   }
   serverWriter.join();
   return writer.end();
 }
-function writeRouteTypeModule(writer, pathPrefix, path3, routeType) {
-  writer.writeLines(`
-declare module '${pathPrefix}/${stripTsExtension(path3)}' {
+function writeModuleDeclaration(writer, path3 = "global", routeType = "AnyRoute", platformType = "unknown", moduleTypes) {
+  writer.writeLines("");
+  if (path3 === "global") {
+    writer.write("declare global {");
+  } else {
+    writer.write(`declare module '${stripTsExtension(path3)}' {`);
+  }
+  if (moduleTypes) {
+    writer.writeLines(moduleTypes);
+  }
+  const isMarko = path3.endsWith(".marko");
+  writer.write(`
   namespace MarkoRun {
+    type GetPaths = Get;
+    type PostPaths = Post;
+    type GetablePath<T extends string> = ValidatePath<Get, T>;
+    type GetableHref<T extends string> = ValidateHref<Get, T>; 
+    type PostablePath<T extends string> = ValidatePath<Post, T>;
+    type PostableHref<T extends string> = ValidateHref<Post, T>;
+    type Platform = ${platformType};`);
+  if (path3 !== "global") {
+    writer.write(`
     type Route = ${routeType};
-    type Context = AnyContext<AnyContext['platform'], Route>;
+    type Context = AnyContext<Platform, Route>${isMarko ? " & Marko.Global" : ""};
     type Handler<_Params = Route['params'], _Meta = Route['meta']> = HandlerLike<Route>;
     function route(handler: Handler): typeof handler;
     function route<_Params = Route['params'], _Meta = Route['meta']>(handler: Handler): typeof handler;
+    const NotHandled: unique symbol;
+    const NotMatched: unique symbol;`);
+  }
+  writer.writeLines(`
   }
 }`);
 }
@@ -1319,11 +1341,15 @@ var getExternalAdapterOptions = (viteConfig) => getConfig(viteConfig, AdapterCon
 import { fileURLToPath } from "url";
 var __dirname = fileURLToPath(new URL(".", import.meta.url));
 var markoExt = ".marko";
+var POSIX_SEP = "/";
+var WINDOWS_SEP = "\\";
+var normalizePath = path2.sep === WINDOWS_SEP ? (id) => id.replace(/\\/g, POSIX_SEP) : (id) => id;
 function isMarkoFile(id) {
   return id.endsWith(markoExt);
 }
-function markoServe(opts = {}) {
-  const { routesDir = "src/routes", adapter, ...markoOptions } = opts;
+function markoRun(opts = {}) {
+  let { routesDir = "src/routes", adapter, ...markoOptions } = opts;
+  let compiler;
   let store;
   let root;
   let resolvedRoutesDir;
@@ -1333,6 +1359,7 @@ function markoServe(opts = {}) {
   let tsConfigExists;
   let ssrEntryFiles;
   let devEntryFile;
+  let devEntryFilePosix;
   let devServer;
   let routes;
   let routeData;
@@ -1353,8 +1380,11 @@ function markoServe(opts = {}) {
       "{.tsconfig*,tsconfig*.json}"
     ))) {
       const filepath = path2.join(typesDir, "routes.d.ts");
-      const adapterTypeInfo = (adapter == null ? void 0 : adapter.writeTypeInfo) && await (adapter == null ? void 0 : adapter.writeTypeInfo());
-      const data = renderRouteTypeInfo(routes, path2.relative(typesDir, routesDir), adapterTypeInfo);
+      const data = await renderRouteTypeInfo(
+        routes,
+        path2.relative(typesDir, routesDir),
+        adapter
+      );
       if (data !== typesFile || !fs2.existsSync(filepath)) {
         await ensureDir(typesDir);
         await fs2.promises.writeFile(filepath, typesFile = data);
@@ -1367,24 +1397,30 @@ function markoServe(opts = {}) {
         route.handler.verbs = await extractVerbs(route.handler.filePath);
         if (!route.handler.verbs.length) {
           console.warn(
-            `Did not find any valid exports in middleware entry file:'${route.handler.filePath}' - expected to find any of 'get', 'post', 'put' or 'del'`
+            `Did not find any valid exports in middleware entry file:'${route.handler.filePath}' - expected to find any of 'GET', 'POST', 'PUT' or 'DELETE'`
           );
         }
       }
       if (route.page) {
         virtualFiles.set(
-          path2.join(root, `${markoRunFilePrefix}route__${route.key}.marko`),
+          path2.posix.join(
+            root,
+            `${markoRunFilePrefix}route__${route.key}.marko`
+          ),
           render ? renderRouteTemplate(route) : ""
         );
       }
       virtualFiles.set(
-        path2.join(root, `${markoRunFilePrefix}route__${route.key}.js`),
+        path2.posix.join(root, `${markoRunFilePrefix}route__${route.key}.js`),
         render ? renderRouteEntry(route) : ""
       );
     }
     for (const route of Object.values(routes.special)) {
       virtualFiles.set(
-        path2.join(root, `${markoRunFilePrefix}special__${route.key}.marko`),
+        path2.posix.join(
+          root,
+          `${markoRunFilePrefix}special__${route.key}.marko`
+        ),
         render ? renderRouteTemplate(route) : ""
       );
     }
@@ -1395,7 +1431,7 @@ function markoServe(opts = {}) {
       }) : ""
     );
     virtualFiles.set(
-      path2.join(root, `${markoRunFilePrefix}middleware.js`),
+      path2.posix.join(root, `${markoRunFilePrefix}middleware.js`),
       render ? renderMiddleware(routes.middleware) : ""
     );
   }
@@ -1424,25 +1460,36 @@ function markoServe(opts = {}) {
         if (externalPluginOptions) {
           opts = mergeConfig(opts, externalPluginOptions);
         }
+        root = normalizePath(config2.root || process.cwd());
+        isBuild = env.command === "build";
+        isSSRBuild = isBuild && Boolean((_a = config2.build) == null ? void 0 : _a.ssr);
+        adapter = await resolveAdapter(root, opts, config2.logLevel !== "silent" && !isBuild || isSSRBuild);
         if (adapter) {
           const externalAdapterConfig = getExternalAdapterOptions(config2);
           if (externalAdapterConfig && adapter.configure) {
             adapter.configure(externalAdapterConfig);
           }
-          const adapterOptions = await ((_a = adapter.pluginOptions) == null ? void 0 : _a.call(adapter, opts));
+          const adapterOptions = await ((_b = adapter.pluginOptions) == null ? void 0 : _b.call(adapter, opts));
           if (adapterOptions) {
             opts = mergeConfig(opts, adapterOptions);
           }
         }
-        root = normalizePath(config2.root || process.cwd());
+        compiler ?? (compiler = await import(opts.compiler || "@marko/compiler"));
+        compiler.taglib.register("@marko/run", {
+          "<*>": {
+            template: path2.resolve(
+              __dirname,
+              "../components/src-attributes-transformer.cjs"
+            )
+          }
+        });
         store = opts.store || new FileStore(
           `marko-serve-vite-${crypto.createHash("SHA1").update(root).digest("hex")}`
         );
-        isBuild = env.command === "build";
-        isSSRBuild = isBuild && Boolean((_b = config2.build) == null ? void 0 : _b.ssr);
         resolvedRoutesDir = path2.resolve(root, routesDir);
         typesDir = path2.join(root, ".marko-run");
         devEntryFile = path2.join(root, "index.html");
+        devEntryFilePosix = normalizePath(devEntryFile);
         let pluginConfig = {
           logLevel: isBuild ? "warn" : void 0,
           define: isBuild ? {
@@ -1535,9 +1582,10 @@ function markoServe(opts = {}) {
             root,
             importee.slice(virtualFilePrefix.length + 1)
           );
-        } else if (!isBuild && importer === devEntryFile && importee.startsWith(`/${markoRunFilePrefix}`)) {
+        } else if (!isBuild && importer && (importer === devEntryFile || normalizePath(importer) === devEntryFilePosix) && importee.startsWith(`/${markoRunFilePrefix}`)) {
           importee = path2.resolve(root, "." + importee);
         }
+        importee = normalizePath(importee);
         if (isStale) {
           await buildVirtualFiles();
         }
@@ -1679,6 +1727,31 @@ async function ensureDir(dir) {
     await fs2.promises.mkdir(dir, { recursive: true });
   }
 }
+async function resolveAdapter(root, options, log) {
+  const { adapter } = options;
+  if (adapter !== void 0) {
+    return adapter;
+  }
+  const pkg = resolvePackageData(".", root);
+  if (pkg) {
+    const dependecies = { ...pkg.data.dependecies, ...pkg.data.devDependencies };
+    for (const name of Object.keys(dependecies)) {
+      if (name.startsWith("@marko/run-adapter") || name.indexOf("marko-run-adapter") !== -1) {
+        try {
+          const module2 = await import(name);
+          log && console.log(`Using adapter ${name} listed in your package.json dependecies`);
+          return module2.default();
+        } catch (err) {
+          log && console.warn(`Attempt to use package '${name}' failed`, err);
+        }
+      }
+    }
+  }
+  const defaultAdapter = "@marko/run/adapter";
+  const module = await import(defaultAdapter);
+  log && console.log("Using default adapter");
+  return module.default();
+}
 
 // src/vite/utils/server.ts
 import net from "net";
@@ -1750,7 +1823,7 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 export {
-  markoServe as default,
+  markoRun as default,
   getAvailablePort,
   isPortInUse,
   loadEnv,

package/dist/vite/plugin.d.ts

@@ -1,3 +1,4 @@
 import type { Plugin } from "vite";
-import type { Options } from "./types";
-export default function markoServe(opts?: Options): Plugin[];
+import type { Options, Adapter } from "./types";
+export default function markoRun(opts?: Options): Plugin[];
+export declare function resolveAdapter(root: string, options: Options, log?: boolean): Promise<Adapter | null>;

package/dist/vite/routes/walk.d.ts

@@ -8,7 +8,7 @@ export interface WalkOptions {
     onEnter?: (dir: WalkEntry) => (() => void) | false | void;
     maxDepth?: number;
 }
-export declare type Walker = (options: WalkOptions) => Promise<void>;
+export type Walker = (options: WalkOptions) => Promise<void>;
 export declare function createFSWalker(dir: string): Walker;
-export declare type TestFileTree = [string, (string | TestFileTree)[]];
+export type TestFileTree = [string, (string | TestFileTree)[]];
 export declare function createTestWalker(dir: TestFileTree): Walker;

package/dist/vite/types.d.ts

@@ -2,7 +2,7 @@ import type { RoutableFileType, HttpVerb, RoutableFileTypes } from "./constants"
 import type { Options as MarkoViteOptions } from "@marko/vite";
 import type { ResolvedConfig, UserConfig } from "vite";
 export type { RoutableFileType, HttpVerb };
-export declare type StartServer = (port?: number) => Promise<void>;
+export type StartServer = (port?: number) => Promise<void>;
 export interface AdapterConfig {
     [name: PropertyKey]: any;
 }
@@ -15,7 +15,7 @@ export interface Adapter {
     startDev?(configFile: string, port: number, envFile?: string): Promise<void> | void;
     startPreview?(dir: string, entry?: string, port?: number, envFile?: string): Promise<void> | void;
     buildEnd?(config: ResolvedConfig, routes: Route[], builtEntries: string[], sourceEntries: string[]): Promise<void> | void;
-    writeTypeInfo?(): Promise<string> | string;
+    typeInfo?(writer: (data: string) => void): Promise<string> | string;
 }
 export interface RouterOptions {
     trailingSlashes: 'Ignore' | 'RedirectWithout' | 'RedirectWith' | 'RewriteWithout' | 'RewriteWith';
@@ -23,9 +23,9 @@ export interface RouterOptions {
 export interface MarkoServeOptions extends Partial<RouterOptions> {
     routesDir?: string;
     emitRoutes?(routes: Route[]): void | Promise<void>;
-    adapter?: Adapter;
+    adapter?: Adapter | null;
 }
-export declare type Options = MarkoServeOptions & MarkoViteOptions;
+export type Options = MarkoServeOptions & MarkoViteOptions;
 export interface Route {
     key: string;
     index: number;

package/dist/vite/utils/route.d.ts

@@ -1,3 +1,3 @@
 import type { HttpVerb, Route } from "../types";
-export declare function getVerbs(route: Route): ("get" | "delete" | "post" | "put")[];
+export declare function getVerbs(route: Route): ("get" | "post" | "put" | "delete")[];
 export declare function hasVerb(route: Route, verb: HttpVerb): boolean | import("../types").RoutableFile | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marko/run",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "The Marko application framework.",
   "license": "MIT",
   "homepage": "https://github.com/marko-js/run/tree/main/packages/run",
@@ -79,12 +79,10 @@
     "dist"
   ],
   "peerDependencies": {
-    "@marko/vite": "^2.3.12",
     "marko": "^5"
   },
   "devDependencies": {
     "@babel/types": "^7.19.0",
-    "@marko/vite": "^2.3.12",
     "@types/glob": "^8.0.1",
     "@types/human-format": "^1.0.0",
     "@types/mocha": "^9.1.1",
@@ -100,6 +98,7 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
+    "@marko/vite": "^2.3.13",
     "cli-table3": "^0.6.3",
     "compression": "^1.7.4",
     "dotenv": "^16.0.3",
@@ -109,7 +108,9 @@
     "kleur": "^4.1.5",
     "sade": "^1.8.1",
     "serve-static": "^1.15.0",
+    "strip-ansi": "^7.0.1",
     "undici": "^5.20.0",
-    "vite": "^4.1.4"
+    "vite": "^4.1.4",
+    "warp10": "^2.1.0"
   }
 }