@vesk/vesk-cli 0.2.70 → 0.2.71

package/dist/cli.js

@@ -53010,6 +53010,142 @@ function installResponsePipeline(res, req, options = {}) {
   });
 }
 
+// ../adapter/src/web-request.ts
+import { Buffer as Buffer2 } from "node:buffer";
+function bodyTooLarge(maxBytes) {
+  const err = new Error(`Request body exceeds limit (${maxBytes} bytes)`);
+  err.status = 413;
+  return err;
+}
+function makeWebRequest(nodeReq, url, maxBodyBytes = DEFAULT_MAX_BODY_BYTES) {
+  const parsedUrl = new URL(url, `http://${nodeReq.headers.host || "localhost"}`);
+  const method = nodeReq.method || "GET";
+  let cachedBody = null;
+  let streamTaken = false;
+  let streamEnded = false;
+  const endWaiters = [];
+  const settleEnd = (body) => {
+    if (body !== null) cachedBody = body;
+    streamEnded = true;
+    for (const resolve41 of endWaiters.splice(0)) resolve41();
+  };
+  function createBodyStream() {
+    streamTaken = true;
+    const cache2 = [];
+    let total = 0;
+    return new ReadableStream({
+      start(controller) {
+        nodeReq.on("data", (chunk) => {
+          total += chunk.length;
+          if (total > maxBodyBytes) {
+            settleEnd(Buffer2.concat(cache2));
+            cache2.length = 0;
+            try {
+              controller.error(bodyTooLarge(maxBodyBytes));
+            } catch {
+            }
+            nodeReq.destroy();
+            return;
+          }
+          cache2.push(chunk);
+          try {
+            controller.enqueue(new Uint8Array(chunk));
+          } catch {
+          }
+        });
+        nodeReq.on("end", () => {
+          settleEnd(Buffer2.concat(cache2));
+          cache2.length = 0;
+          try {
+            controller.close();
+          } catch {
+          }
+        });
+        nodeReq.on("error", (e) => {
+          settleEnd(Buffer2.concat(cache2));
+          cache2.length = 0;
+          try {
+            controller.error(e);
+          } catch {
+          }
+        });
+      }
+    });
+  }
+  async function getBody() {
+    if (cachedBody) return cachedBody;
+    if (streamTaken) {
+      while (!streamEnded) await new Promise((r) => endWaiters.push(r));
+      return cachedBody || Buffer2.alloc(0);
+    }
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of nodeReq) {
+      total += chunk.byteLength;
+      if (total > maxBodyBytes) throw bodyTooLarge(maxBodyBytes);
+      chunks.push(Buffer2.from(chunk));
+    }
+    cachedBody = Buffer2.concat(chunks);
+    return cachedBody;
+  }
+  const webRequest = new Request(parsedUrl, {
+    method,
+    headers: nodeReq.headers,
+    body: null
+  });
+  let bodyStream = null;
+  Object.defineProperty(webRequest, "body", {
+    configurable: true,
+    enumerable: false,
+    get: () => {
+      if (bodyStream) return bodyStream;
+      if (method === "GET" || method === "HEAD") return null;
+      bodyStream = createBodyStream();
+      return bodyStream;
+    }
+  });
+  webRequest.json = async () => {
+    try {
+      return JSON.parse((await getBody()).toString());
+    } catch {
+      return null;
+    }
+  };
+  webRequest.text = async () => (await getBody()).toString("utf-8");
+  webRequest.formData = async () => {
+    const body = await getBody();
+    const ct = String(nodeReq.headers["content-type"] || "");
+    if (ct.includes("multipart/form-data")) {
+      const temp = new Request("http://localhost", { method: "POST", headers: nodeReq.headers, body });
+      return temp.formData();
+    }
+    const fd = new FormData();
+    if (ct.includes("x-www-form-urlencoded")) {
+      for (const [k, v] of new URLSearchParams(body.toString()).entries()) fd.append(k, v);
+    }
+    return fd;
+  };
+  webRequest.clone = () => webRequest;
+  const cookies2 = {};
+  for (const part of String(nodeReq.headers.cookie || "").split(";")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const name = part.slice(0, eq).trim();
+    if (!name) continue;
+    const raw2 = part.slice(eq + 1).trim();
+    try {
+      cookies2[name] = decodeURIComponent(raw2);
+    } catch {
+      cookies2[name] = raw2;
+    }
+  }
+  webRequest.cookies = cookies2;
+  const query = {};
+  for (const [k, v] of parsedUrl.searchParams.entries()) query[k] = v;
+  webRequest.query = query;
+  return webRequest;
+}
+
 // ../adapter/src/prod-server.ts
 init_platform_output();
 var __dirname4 = dirname11(fileURLToPath3(import.meta.url));
@@ -53067,65 +53203,10 @@ function pumpRemaining(res, reader) {
     res.end();
   })();
 }
-function bodyTooLarge(maxBytes) {
-  const err = new Error(`Request body exceeds limit (${maxBytes} bytes)`);
-  err.status = 413;
-  return err;
-}
 function errorStatus(e, fallback) {
   const s = e?.status ?? e?.statusCode;
   return typeof s === "number" && s >= 400 && s < 600 ? s : fallback;
 }
-function makeWebRequest(nodeReq, url, maxBodyBytes = DEFAULT_MAX_BODY_BYTES) {
-  const parsedUrl = new URL(url, `http://${nodeReq.headers.host || "localhost"}`);
-  const method = nodeReq.method || "GET";
-  let _bodyBuffer = null;
-  async function getBody() {
-    if (_bodyBuffer) return _bodyBuffer;
-    const chunks = [];
-    let total = 0;
-    for await (const chunk of nodeReq) {
-      total += chunk.byteLength;
-      if (total > maxBodyBytes) throw bodyTooLarge(maxBodyBytes);
-      chunks.push(Buffer.from(chunk));
-    }
-    _bodyBuffer = Buffer.concat(chunks);
-    return _bodyBuffer;
-  }
-  const webRequest = new Request(parsedUrl, { method, headers: nodeReq.headers, body: null });
-  webRequest.json = async () => {
-    try {
-      return JSON.parse((await getBody()).toString());
-    } catch {
-      return null;
-    }
-  };
-  webRequest.text = async () => (await getBody()).toString("utf-8");
-  webRequest.formData = async () => {
-    const body = await getBody();
-    const ct = String(nodeReq.headers["content-type"] || "");
-    if (ct.includes("multipart/form-data")) {
-      const temp = new Request("http://localhost", { method: "POST", headers: nodeReq.headers, body });
-      return temp.formData();
-    }
-    const fd = new FormData();
-    if (ct.includes("x-www-form-urlencoded")) {
-      for (const [k, v] of new URLSearchParams(body.toString()).entries()) fd.append(k, v);
-    }
-    return fd;
-  };
-  webRequest.clone = () => webRequest;
-  const cookies2 = {};
-  for (const [k, v] of String(nodeReq.headers.cookie || "").split(";").map((s) => s.trim()).filter(Boolean)) {
-    const eq = k.indexOf("=");
-    if (eq > -1) cookies2[k.slice(0, eq)] = decodeURIComponent(k.slice(eq + 1));
-  }
-  webRequest.cookies = cookies2;
-  const query = {};
-  for (const [k, v] of parsedUrl.searchParams.entries()) query[k] = v;
-  webRequest.query = query;
-  return webRequest;
-}
 async function startProdServer(outDir, options) {
   const port = options?.port || 3e3;
   const host = options?.host || "127.0.0.1";
@@ -53196,15 +53277,22 @@ async function startProdServer(outDir, options) {
     }
   }
   const functionCache = /* @__PURE__ */ new Map();
+  const functionFailures = /* @__PURE__ */ new Map();
+  function functionFailure(funcPath) {
+    return functionFailures.get(funcPath);
+  }
   async function loadFunction(funcPath) {
     if (functionCache.has(funcPath)) return functionCache.get(funcPath);
+    if (functionFailures.has(funcPath)) return null;
     const fullPath = resolve14(outDir, funcPath);
     if (!existsSync16(fullPath)) return null;
     try {
       const mod = await import(`${fullPath}?t=${Date.now()}`);
       functionCache.set(funcPath, mod);
       return mod;
-    } catch {
+    } catch (e) {
+      console.error(`vesk start: failed to load ${funcPath}:`, e instanceof Error ? e.message : e);
+      functionFailures.set(funcPath, e);
       return null;
     }
   }
@@ -53467,18 +53555,24 @@ async function startProdServer(outDir, options) {
           const params = matchPath(route.path, url.pathname);
           if (params) {
             const mod = await loadFunction(route.function);
-            if (mod) {
-              try {
-                const webRequest = makeWebRequest(req, url.href, maxBodyBytes);
-                const response = await withSecurityScope(() => mod.handle(webRequest));
-                await deliverResponse(res, response);
-                return;
-              } catch (e) {
-                const status = errorStatus(e, 500);
-                res.writeHead(status, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ error: status === 500 ? "Internal Server Error" : e instanceof Error ? e.message : String(e) }));
+            if (!mod) {
+              if (functionFailure(route.function)) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Internal Server Error" }));
                 return;
               }
+              continue;
+            }
+            try {
+              const webRequest = makeWebRequest(req, url.href, maxBodyBytes);
+              const response = await withSecurityScope(() => mod.handle(webRequest));
+              await deliverResponse(res, response);
+              return;
+            } catch (e) {
+              const status = errorStatus(e, 500);
+              res.writeHead(status, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: status === 500 ? "Internal Server Error" : e instanceof Error ? e.message : String(e) }));
+              return;
             }
           }
         }
@@ -65138,6 +65232,10 @@ var PACKAGES = {
   // servers on fresh checkouts (CI).
   "plugin-pwa": { name: "@vesk/plugin-pwa", entry: "index" },
   "plugin-tailwind": { name: "@vesk/plugin-tailwind", entry: "index" },
+  // The multipart plugin ships as a real published package: an app route imports
+  // it by name, so its dist must exist for the API-function bundler to resolve it
+  // on a fresh checkout (CI).
+  "plugin-multipart": { name: "@vesk/plugin-multipart", entry: "index" },
   // testing last — it depends on the compiler.
   testing: { name: "@vesk/testing", entry: "index" }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vesk/vesk-cli",
-  "version": "0.2.70",
+  "version": "0.2.71",
   "type": "module",
   "description": "Vesk — compiler-first framework for the post-VDOM web. vesk dev, vesk build.",
   "bin": {
@@ -8,10 +8,10 @@
   },
   "main": "./dist/cli.js",
   "dependencies": {
-    "@vesk/adapter": "^0.2.70",
-    "@vesk/compiler": "^0.2.70",
-    "@vesk/plugin-tailwind": "^0.2.70",
-    "@vesk/runtime": "^0.2.70",
+    "@vesk/adapter": "^0.2.71",
+    "@vesk/compiler": "^0.2.71",
+    "@vesk/plugin-tailwind": "^0.2.71",
+    "@vesk/runtime": "^0.2.71",
     "esrap": "^2.3.0",
     "typescript": "^5.8.0",
     "ws": "^8.18.0",