defuss-ssg 0.1.2 → 0.2.0

package/README.md

@@ -23,7 +23,7 @@ Usage
 Simply generate a static site from a content directory to an output directory with full defuss-MDX (GFM + Frontmatter) support:
 
 ```bash
-npx defuss-ssg build ./folder
+bunx defuss-ssg build ./folder
 ```
 
 Or install globally or locally in a project:

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { v as validateProjectDir, b as build, s as serve } from './serve-CMNixAKF.mjs';
+import { v as validateProjectDir, b as build, s as serve } from './serve-BZhZ9J90.mjs';
 import { join, dirname, resolve } from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
 import { spawn } from 'node:child_process';

package/dist/index.cjs

@@ -83,14 +83,21 @@ const autoHydratePlugin = {
                   ;(async function(){
 
                     const props = ${JSON.stringify(props || {})};
-                    const { hydrate } = await import("/components/runtime.js");
-                    const expports = (await import("${clientSrcFile}"));
+                    const cacheBust = "?v=" + Date.now();
+                    console.log("[hydrate:${id}] Starting hydration, cacheBust=" + cacheBust);
+                    console.log("[hydrate:${id}] Importing runtime from /components/runtime.js" + cacheBust);
+                    const { hydrate } = await import("/components/runtime.js" + cacheBust);
+                    console.log("[hydrate:${id}] Importing component from ${clientSrcFile}" + cacheBust);
+                    const expports = (await import("${clientSrcFile}" + cacheBust));
+
+                    console.log("[hydrate:${id}] Module keys:", Object.keys(expports));
 
                     if (!expports || typeof expports.default !== "function") {
                       console.error("Hydration error: No default export function found in", "${clientSrcFile}");
                       return;
                     }
                     const Component = expports.default;
+                    console.log("[hydrate:${id}] Component:", Component.name || "(anonymous)");
 
                     let roots = null;
                     try {
@@ -105,7 +112,11 @@ const autoHydratePlugin = {
                     } else {
                       console.error("Hydration error: Component MUST return a single root element, not an array of elements! (no fragments allowed)");
                     }
+
+                    console.log("[hydrate:${id}] Rendered VDOM roots:", roots.length, JSON.stringify(roots).slice(0, 200));
+
                     const wrapper = document.querySelector('div[data-hydrate-id="${id}"]');
+                    console.log("[hydrate:${id}] Wrapper found:", !!wrapper, wrapper?.childNodes?.length, "children");
                     
                     // remove <script> itself
                     document.getElementById("${id}")?.remove();
@@ -119,6 +130,7 @@ const autoHydratePlugin = {
                       }
                       // unwrap children
                       wrapper.replaceWith(...wrapper.childNodes);
+                      console.log("[hydrate:${id}] Hydration complete, wrapper unwrapped");
                     } else {
                       console.warn("No wrapper found for hydration id ${id}");
                     }
@@ -203,6 +215,289 @@ const validateProjectDir = (projectDir) => {
   return { code: "OK", message: "Project directory is valid." };
 };
 
+const HTTP_METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "HEAD",
+  "OPTIONS",
+  "ALL"
+];
+const createRedirect = (url, status = 302) => new Response(null, {
+  status,
+  headers: { Location: url }
+});
+const endpointFileToRoute = (filePath, pagesDir) => {
+  let route = node_path.relative(pagesDir, filePath).replace(/\\/g, "/").replace(/\.(ts|js)$/, "");
+  if (!route.startsWith("/")) {
+    route = `/${route}`;
+  }
+  return route;
+};
+const routeToExpressPattern = (route) => route.replace(/\[([^\]]+)\]/g, ":$1");
+const extractParamNames = (route) => Array.from(route.matchAll(/\[([^\]]+)\]/g), (m) => m[1]);
+const discoverEndpointSourceFiles = async (pagesDir) => {
+  if (!node_fs.existsSync(pagesDir)) return [];
+  return glob.async(node_path.join(pagesDir, "**/*.{ts,js}"), {
+    ignore: ["**/*.d.ts"]
+  });
+};
+const compileEndpoints = async (sourceFiles, pagesDir, outDir, debug = false) => {
+  if (sourceFiles.length === 0) return /* @__PURE__ */ new Map();
+  if (debug) {
+    console.log(`Compiling ${sourceFiles.length} endpoint source file(s)\u2026`);
+  }
+  console.time("[endpoints] esbuild-compile");
+  await esbuild.build({
+    entryPoints: sourceFiles,
+    format: "esm",
+    bundle: true,
+    platform: "node",
+    target: ["esnext"],
+    outdir: outDir,
+    outbase: pagesDir,
+    outExtension: { ".js": ".mjs" }
+  });
+  console.timeEnd("[endpoints] esbuild-compile");
+  const mapping = /* @__PURE__ */ new Map();
+  for (const src of sourceFiles) {
+    const rel = node_path.relative(pagesDir, src).replace(/\.(ts|js)$/, ".mjs");
+    mapping.set(src, node_path.join(outDir, rel));
+  }
+  return mapping;
+};
+const loadEndpointModule = async (filePath) => {
+  const code = await promises.readFile(filePath, "utf-8");
+  const encoded = Buffer.from(code).toString("base64");
+  const dataUrl = `data:text/javascript;base64,${encoded}`;
+  return import(dataUrl);
+};
+const resolveEndpoints = async (pagesDir, endpointsDir, debug = false) => {
+  const sourceFiles = await discoverEndpointSourceFiles(pagesDir);
+  if (sourceFiles.length === 0) return [];
+  console.time("[endpoints] compile-all");
+  const mapping = await compileEndpoints(sourceFiles, pagesDir, endpointsDir, debug);
+  console.timeEnd("[endpoints] compile-all");
+  const endpoints = [];
+  console.time("[endpoints] load-modules");
+  for (const [sourceFile, compiledFile] of mapping) {
+    const routePattern = endpointFileToRoute(sourceFile, pagesDir);
+    const paramNames = extractParamNames(routePattern);
+    const isDynamic = paramNames.length > 0;
+    if (debug) {
+      console.log(
+        `Endpoint: ${sourceFile} \u2192 ${compiledFile} \u2192 ${routePattern}` + (isDynamic ? ` (params: ${paramNames.join(", ")})` : "")
+      );
+    }
+    const module = await loadEndpointModule(compiledFile);
+    const prerender = module.prerender === true;
+    endpoints.push({
+      sourceFile,
+      compiledFile,
+      routePattern,
+      module,
+      isDynamic,
+      paramNames,
+      prerender
+    });
+  }
+  console.timeEnd("[endpoints] load-modules");
+  return endpoints;
+};
+const buildEndpoints = async (projectDir, config, debug = false) => {
+  const pagesDir = node_path.join(projectDir, config.pages);
+  const outputDir = node_path.join(projectDir, config.output);
+  const endpointsDir = node_path.join(projectDir, ".endpoints");
+  const endpoints = await resolveEndpoints(pagesDir, endpointsDir, debug);
+  if (endpoints.length === 0) return;
+  const prerenderEndpoints = endpoints.filter((e) => e.prerender);
+  const dynamicEndpoints = endpoints.filter((e) => !e.prerender);
+  console.log(
+    `Endpoints: ${endpoints.length} compiled` + (prerenderEndpoints.length ? `, ${prerenderEndpoints.length} pre-rendered` : "") + (dynamicEndpoints.length ? `, ${dynamicEndpoints.length} dynamic` : "")
+  );
+  for (const endpoint of prerenderEndpoints) {
+    const { module, routePattern, isDynamic } = endpoint;
+    const handler = module.GET;
+    if (!handler) {
+      if (debug) {
+        console.log(
+          `Endpoint ${routePattern}: prerender=true but no GET export \u2013 skipping`
+        );
+      }
+      continue;
+    }
+    let paramSets = [{}];
+    if (isDynamic) {
+      if (!module.getStaticPaths) {
+        console.warn(
+          `Dynamic endpoint ${routePattern} has no getStaticPaths() \u2013 skipping`
+        );
+        continue;
+      }
+      const paths = await module.getStaticPaths();
+      paramSets = paths.map((p) => p.params);
+    }
+    for (const params of paramSets) {
+      let resolvedRoute = routePattern;
+      for (const [key, value] of Object.entries(params)) {
+        resolvedRoute = resolvedRoute.replace(`[${key}]`, value);
+      }
+      const requestUrl = `http://localhost${resolvedRoute}`;
+      const context = {
+        params,
+        request: new Request(requestUrl),
+        redirect: createRedirect
+      };
+      if (debug) {
+        console.log(`Pre-rendering endpoint: ${resolvedRoute}`);
+      }
+      try {
+        const response = await handler(context);
+        const outputFile = node_path.join(outputDir, resolvedRoute);
+        const outputFileDir = node_path.dirname(outputFile);
+        if (!node_fs.existsSync(outputFileDir)) {
+          node_fs.mkdirSync(outputFileDir, { recursive: true });
+        }
+        if (response.status >= 300 && response.status < 400) {
+          const location = response.headers.get("Location") || "/";
+          await promises.writeFile(
+            outputFile,
+            `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0;url=${location}"><link rel="canonical" href="${location}"></head><body>Redirecting to <a href="${location}">${location}</a></body></html>`
+          );
+        } else {
+          const buffer = Buffer.from(await response.arrayBuffer());
+          await promises.writeFile(outputFile, buffer);
+        }
+        if (debug) {
+          console.log(`  \u2192 ${outputFile}`);
+        }
+      } catch (error) {
+        console.error(`Error pre-rendering endpoint ${resolvedRoute}:`, error);
+      }
+    }
+  }
+};
+const handleEndpointRoute = async (req, res, compiledFile, routePattern, method) => {
+  let currentModule;
+  try {
+    currentModule = await loadEndpointModule(compiledFile);
+  } catch (err) {
+    console.error(`Failed to load endpoint: ${compiledFile}`, err);
+    res.status(500).send("Internal Server Error");
+    return;
+  }
+  const handlerFn = currentModule[method] ?? currentModule.ALL;
+  if (!handlerFn) {
+    res.status(405).send("Method Not Allowed");
+    return;
+  }
+  const protocol = req.protocol || "http";
+  const host = req.get?.("host") || req.headers?.host || "localhost";
+  const url = `${protocol}://${host}${req.originalUrl}`;
+  const reqInit = {
+    method: req.method,
+    headers: req.headers
+  };
+  if (["POST", "PUT", "PATCH", "DELETE"].includes(req.method)) {
+    try {
+      const chunks = [];
+      await new Promise((resolve, reject) => {
+        req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+        req.on("end", resolve);
+        req.on("error", reject);
+      });
+      if (chunks.length > 0) {
+        reqInit.body = Buffer.concat(chunks);
+      }
+    } catch {
+    }
+  }
+  const request = new Request(url, reqInit);
+  const context = {
+    params: req.params || {},
+    request,
+    redirect: createRedirect
+  };
+  try {
+    const response = await handlerFn(context);
+    res.status(response.status);
+    response.headers.forEach((value, key) => {
+      res.set(key, value);
+    });
+    if (req.method === "HEAD") {
+      res.end();
+      return;
+    }
+    if (response.body) {
+      const buf = Buffer.from(await response.arrayBuffer());
+      res.send(buf);
+    } else {
+      res.end();
+    }
+  } catch (error) {
+    console.error(`Endpoint error ${req.method} ${routePattern}:`, error);
+    res.status(500).send("Internal Server Error");
+  }
+};
+const registerEndpoints = async (app, projectDir, config, debug = false) => {
+  const endpointsDir = node_path.join(projectDir, ".endpoints");
+  const mjsFiles = await glob.async(node_path.join(endpointsDir, "**/*.mjs"));
+  if (mjsFiles.length === 0) return;
+  let registered = 0;
+  for (const compiledFile of mjsFiles) {
+    let route = node_path.relative(endpointsDir, compiledFile).replace(/\\/g, "/").replace(/\.mjs$/, "");
+    if (!route.startsWith("/")) route = `/${route}`;
+    let module;
+    try {
+      module = await loadEndpointModule(compiledFile);
+    } catch (err) {
+      console.error(`Failed to load endpoint: ${compiledFile}`, err);
+      continue;
+    }
+    if (module.prerender === true) {
+      if (debug) {
+        console.log(`Skipping prerender endpoint: ${route}`);
+      }
+      continue;
+    }
+    const expressRoute = routeToExpressPattern(route);
+    const hasExportedMethods = HTTP_METHODS.some(
+      (m) => m in module && typeof module[m] === "function"
+    );
+    if (!hasExportedMethods) continue;
+    if (debug) {
+      console.log(`Registering dynamic endpoint: ${expressRoute}`);
+    }
+    for (const method of HTTP_METHODS) {
+      if (method in module && typeof module[method] === "function") {
+        const expressMethod = method === "ALL" ? "all" : method.toLowerCase();
+        app[expressMethod](
+          expressRoute,
+          async (req, res) => handleEndpointRoute(req, res, compiledFile, route, method)
+        );
+        if (debug) {
+          console.log(`  ${method} ${expressRoute}`);
+        }
+      }
+    }
+    if (module.GET && !module.HEAD) {
+      app.head(
+        expressRoute,
+        async (req, res) => handleEndpointRoute(req, res, compiledFile, route, "GET")
+      );
+      if (debug) {
+        console.log(`  HEAD ${expressRoute} (auto from GET)`);
+      }
+    }
+    registered++;
+  }
+  if (registered > 0) {
+    console.log(`Registered ${registered} dynamic endpoint(s)`);
+  }
+};
+
 const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
 const __dirname$1 = node_path.dirname(__filename$1);
 const build = async ({
@@ -214,7 +509,9 @@ const build = async ({
   const projectDirStatus = validateProjectDir(projectDir);
   if (projectDirStatus.code !== "OK") return projectDirStatus;
   const startTime = performance.now();
+  console.time("[build] readConfig");
   const config = await readConfig(projectDir, debug);
+  console.timeEnd("[build] readConfig");
   if (debug) {
     console.log("Using config:", config);
   }
@@ -264,29 +561,44 @@ const build = async ({
   const isFullBuild = changeKind === "full" || changeKind === "config";
   const tempExists = node_fs.existsSync(config.tmp);
   if (isFullBuild) {
+    console.time("[build] pre-plugins");
     for (const plugin of config.plugins || []) {
       if (plugin.phase === "pre" && (plugin.mode === mode || plugin.mode === "both")) {
+        console.time(`[build] pre-plugin:${plugin.name}`);
         if (debug) {
           console.log(`Running pre-plugin: ${plugin.name}`);
         }
         await plugin.fn(projectDir, config);
+        console.timeEnd(`[build] pre-plugin:${plugin.name}`);
       }
     }
+    console.timeEnd("[build] pre-plugins");
   }
+  console.time("[build] prepare-temp");
   if (isFullBuild || !tempExists) {
     if (tempExists) {
+      console.time("[build] prepare-temp:rmSync");
       node_fs.rmSync(config.tmp, { recursive: true });
+      console.timeEnd("[build] prepare-temp:rmSync");
     }
+    console.time("[build] prepare-temp:cp");
     await promises.cp(projectDir, config.tmp, {
       recursive: true,
       filter: (src) => {
-        const relative = src.replace(node_path.join(projectDir, ""), "");
-        if (relative.startsWith(node_path.join("assets", "")) || relative.startsWith(node_path.join("node_modules", ""))) {
+        const relative = src.startsWith(projectDir) ? src.slice(projectDir.length).replace(/^\//, "") : src;
+        const firstSegment = relative.split("/")[0];
+        if (firstSegment === "node_modules" || firstSegment === config.output || firstSegment === ".endpoints" || firstSegment === ".ssg-temp" || firstSegment === ".git" || firstSegment === "assets") {
           return false;
         }
         return true;
       }
     });
+    console.timeEnd("[build] prepare-temp:cp");
+    const srcNodeModules = node_path.join(projectDir, "node_modules");
+    const tmpNodeModules = node_path.join(config.tmp, "node_modules");
+    if (node_fs.existsSync(srcNodeModules) && !node_fs.existsSync(tmpNodeModules)) {
+      node_fs.symlinkSync(srcNodeModules, tmpNodeModules, "dir");
+    }
   } else {
     const srcFile = node_path.join(projectDir, changedRelative);
     const destFile = node_path.join(config.tmp, changedRelative);
@@ -298,6 +610,8 @@ const build = async ({
       await promises.cp(srcFile, destFile);
     }
   }
+  console.timeEnd("[build] prepare-temp");
+  console.time("[build] copy-hydration");
   await promises.cp(
     node_path.resolve(node_path.join(__dirname$1, "components", "index.mjs")),
     node_path.join(tmpComponentsDir, "hydrate.tsx")
@@ -306,7 +620,9 @@ const build = async ({
     node_path.resolve(node_path.join(__dirname$1, "runtime.mjs")),
     node_path.join(tmpComponentsDir, "runtime.ts")
   );
+  console.timeEnd("[build] copy-hydration");
   if (changeKind !== "asset") {
+    console.time("[build] esbuild-pages");
     const pageEntryPoints = changeKind === "page" ? [node_path.join(config.tmp, changedRelative)] : [node_path.join(tmpPagesDir, "**/*.mdx")];
     await esbuild.build({
       entryPoints: pageEntryPoints,
@@ -325,8 +641,10 @@ const build = async ({
         })
       ]
     });
+    console.timeEnd("[build] esbuild-pages");
   }
   if (isFullBuild || changeKind === "component") {
+    console.time("[build] esbuild-components");
     await esbuild.build({
       entryPoints: [
         node_path.join(tmpComponentsDir, "**/*.tsx"),
@@ -338,8 +656,10 @@ const build = async ({
       target: ["esnext"],
       outdir: tmpComponentsDir
     });
+    console.timeEnd("[build] esbuild-components");
   }
   if (changeKind !== "asset") {
+    console.time("[build] render-pages");
     let outputFiles;
     if (changeKind === "page") {
       const jsFile = node_path.join(config.tmp, changedRelative.replace(/\.mdx$/, ".js"));
@@ -356,20 +676,26 @@ const build = async ({
         `${tmpPagesDir}${node_path.sep}`,
         ""
       );
+      const pageLabel = relativeOutputHtmlFilePath;
       if (debug) {
         console.log("Processing output file (JS):", outputFile);
         console.log("Relative output HTML path:", relativeOutputHtmlFilePath);
       }
+      console.time(`[build] page:${pageLabel} import`);
       const code = await promises.readFile(outputFile, "utf-8");
       const encoded = Buffer.from(code).toString("base64");
       const dataUrl = `data:text/javascript;base64,${encoded}`;
       const exports$1 = await import(dataUrl);
+      console.timeEnd(`[build] page:${pageLabel} import`);
       if (debug) {
         console.log("exports", exports$1);
       }
+      console.time(`[build] page:${pageLabel} vdom`);
       let vdom = exports$1.default(exports$1);
+      console.timeEnd(`[build] page:${pageLabel} vdom`);
       for (const plugin of config.plugins || []) {
         if (plugin.phase === "page-vdom" && (plugin.mode === mode || plugin.mode === "both")) {
+          console.time(`[build] page:${pageLabel} plugin:${plugin.name}`);
           if (debug) {
             console.log(`Running page-vdom plugin: ${plugin.name}`);
           }
@@ -380,16 +706,20 @@ const build = async ({
             config,
             exports$1
           );
+          console.timeEnd(`[build] page:${pageLabel} plugin:${plugin.name}`);
         }
       }
+      console.time(`[build] page:${pageLabel} renderSync`);
       const browserGlobals = server.getBrowserGlobals();
       const document = server.getDocument(false, browserGlobals);
       browserGlobals.document = document;
       let el = server.renderSync(vdom, document.documentElement, {
         browserGlobals
       });
+      console.timeEnd(`[build] page:${pageLabel} renderSync`);
       for (const plugin of config.plugins || []) {
         if (plugin.phase === "page-dom" && (plugin.mode === mode || plugin.mode === "both")) {
+          console.time(`[build] page:${pageLabel} dom-plugin:${plugin.name}`);
           if (debug) {
             console.log(`Running page-dom plugin: ${plugin.name}`);
           }
@@ -399,11 +729,15 @@ const build = async ({
             projectDir,
             config
           );
+          console.timeEnd(`[build] page:${pageLabel} dom-plugin:${plugin.name}`);
         }
       }
+      console.time(`[build] page:${pageLabel} renderToString`);
       let html = server.renderToString(el);
+      console.timeEnd(`[build] page:${pageLabel} renderToString`);
       for (const plugin of config.plugins || []) {
         if (plugin.phase === "page-html" && (plugin.mode === mode || plugin.mode === "both")) {
+          console.time(`[build] page:${pageLabel} html-plugin:${plugin.name}`);
           if (debug) {
             console.log(`Running page-html plugin: ${plugin.name}`);
           }
@@ -413,6 +747,7 @@ const build = async ({
             projectDir,
             config
           );
+          console.timeEnd(`[build] page:${pageLabel} html-plugin:${plugin.name}`);
         }
       }
       const finalOutputFile = node_path.join(
@@ -424,16 +759,27 @@ const build = async ({
       if (!node_fs.existsSync(finalOutputDir)) {
         node_fs.mkdirSync(finalOutputDir, { recursive: true });
       }
+      console.time(`[build] page:${pageLabel} writeFile`);
       await promises.writeFile(finalOutputFile, html);
+      console.timeEnd(`[build] page:${pageLabel} writeFile`);
     }
+    console.timeEnd("[build] render-pages");
   }
+  if (isFullBuild || changeKind === "page") {
+    console.time("[build] build-endpoints");
+    await buildEndpoints(projectDir, config, debug);
+    console.timeEnd("[build] build-endpoints");
+  }
+  console.time("[build] copy-outputs");
   if (isFullBuild || changeKind === "component") {
     await promises.cp(tmpComponentsDir, outputComponentsDir, { recursive: true });
   }
   if (isFullBuild || changeKind === "asset") {
     await promises.cp(inputAssetsDir, outputAssetsDir, { recursive: true });
   }
+  console.timeEnd("[build] copy-outputs");
   if (isFullBuild || changeKind === "component") {
+    console.time("[build] post-plugins");
     for (const plugin of config.plugins || []) {
       if (plugin.phase === "post" && (plugin.mode === mode || plugin.mode === "both")) {
         if (debug) {
@@ -442,6 +788,7 @@ const build = async ({
         await plugin.fn(projectDir, config);
       }
     }
+    console.timeEnd("[build] post-plugins");
   }
   if (mode === "build" && !debug) {
     node_fs.rmSync(config.tmp, { recursive: true });
@@ -501,6 +848,15 @@ const serve = async ({
       message: `Port ${port} is already in use. Please stop the process using this port or choose a different port.`
     };
   }
+  console.time("[serve] register-endpoints");
+  await registerEndpoints(app, projectDir, config, debug);
+  console.timeEnd("[serve] register-endpoints");
+  app.use((_req, res, next) => {
+    res.set("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate");
+    res.set("Pragma", "no-cache");
+    res.set("Expires", "0");
+    next();
+  });
   app.use(express.static(outputDir));
   const server = app.listen(port, (listenedPort) => {
     console.log(
@@ -523,7 +879,9 @@ const serve = async ({
     }
     isBuilding = true;
     try {
+      console.time("[serve] rebuild");
       await build({ projectDir, debug, mode: "serve", changedFile: filePath });
+      console.timeEnd("[serve] rebuild");
       liveReloadServer.clients.forEach((client) => {
         if (client.readyState === 1) {
           client.send(
@@ -576,9 +934,16 @@ const serve = async ({
   return { code: "OK", message: "Server is running" };
 };
 
+exports.HTTP_METHODS = HTTP_METHODS;
 exports.build = build;
+exports.buildEndpoints = buildEndpoints;
+exports.compileEndpoints = compileEndpoints;
 exports.configDefaults = configDefaults;
+exports.discoverEndpointSourceFiles = discoverEndpointSourceFiles;
+exports.endpointFileToRoute = endpointFileToRoute;
 exports.readConfig = readConfig;
+exports.registerEndpoints = registerEndpoints;
 exports.rehypePlugins = rehypePlugins;
 exports.remarkPlugins = remarkPlugins;
+exports.resolveEndpoints = resolveEndpoints;
 exports.serve = serve;