@vesk/vesk-cli 0.2.69 → 0.2.71

package/dist/cli.js

@@ -49909,11 +49909,26 @@ function resolveCssUrls(opts) {
 
 // ../adapter/src/ssr-function.ts
 init_default_pages();
-function resolveErrorFile(sourceDir, appDir) {
+function resolveBoundaryFile(sourceDir, appDir, file) {
   const rel = relative(appDir, sourceDir).split("/").filter(Boolean);
   for (let depth = rel.length; depth >= 0; depth--) {
     const dir = depth === 0 ? appDir : join5(appDir, ...rel.slice(0, depth));
-    const p = join5(dir, "error.vsk");
+    const p = join5(dir, file);
+    if (existsSync8(p)) return p;
+  }
+  return null;
+}
+function resolveErrorFile(sourceDir, appDir) {
+  return resolveBoundaryFile(sourceDir, appDir, "error.vsk");
+}
+function resolveNotFoundFile(sourceDir, appDir) {
+  return resolveBoundaryFile(sourceDir, appDir, "not-found.vsk");
+}
+function resolveBoundaryFileForUrl(pathname, appDir, file) {
+  const segments = pathname.split("/").filter(Boolean);
+  for (let depth = segments.length; depth >= 0; depth--) {
+    const dir = join5(appDir, ...segments.slice(0, depth));
+    const p = join5(dir, file);
     if (existsSync8(p)) return p;
   }
   return null;
@@ -50053,6 +50068,12 @@ function generateSsrFunction(routeNode, appDir, outDir, componentMap, options) {
   const errorVars = errorPath ? `const _errorComp = ${JSON.stringify(errorComp)};
 const _errorCompiled = ${hydrateInvoke(precompilePlan(errorPath))};
 ` : "const _errorComp = null;\nconst _errorCompiled = null;\n";
+  const notFoundPath = resolveNotFoundFile(routeNode.sourceDir, appDir);
+  const notFoundSrc = notFoundPath ? readFileSync7(notFoundPath, "utf-8") : null;
+  const notFoundComp = notFoundPath ? extractCompName(notFoundSrc) || "NotFound" : null;
+  const notFoundVars = notFoundPath ? `const _notFoundComp = ${JSON.stringify(notFoundComp)};
+const _notFoundCompiled = ${hydrateInvoke(precompilePlan(notFoundPath))};
+` : "const _notFoundComp = null;\nconst _notFoundCompiled = null;\n";
   let src2 = "";
   if (layoutDecls.length > 0) {
     src2 = `const _pageComp = ${JSON.stringify(pageComp)};
@@ -50065,13 +50086,13 @@ const _errorCompiled = ${hydrateInvoke(precompilePlan(errorPath))};
 ${layoutDecls.map((d) => "  " + d.compiled + ",").join("\n")}
 ];
 `;
-    src2 += errorVars;
+    src2 += errorVars + notFoundVars;
   } else {
     src2 = `const _comp = ${JSON.stringify(pageComp)};
 `;
     src2 += `const _compiled = (() => { try { return hydratePrecompile(${pagePlan}); } catch { return null; } })();
 `;
-    src2 += errorVars;
+    src2 += errorVars + notFoundVars;
   }
   const urlParts = routeNode.fullPath.split("/").filter(Boolean);
   const paramExprs = buildParamExtraction(routeNode, urlParts);
@@ -50113,30 +50134,66 @@ ${layoutDecls.map((d) => "  " + d.compiled + ",").join("\n")}
       "  }",
       "}",
       "",
+      // Returns null rather than throwing when there is no boundary, so the
+      // caller can re-throw the original NotFoundError and let the server answer
+      // — a page with no not-found.vsk anywhere must still get a 404.
+      "async function __renderNotFoundBody(props) {",
+      "  if (!_notFoundComp) return null;",
+      "  try {",
+      "    const result = await renderPage('', _notFoundComp, props, __componentRegistry, { hydrate: true, cached: _notFoundCompiled });",
+      "    return result.body;",
+      "  } catch {",
+      "    return null;",
+      "  }",
+      "}",
+      "",
+      // The layout wrap, shared by the page / error / not-found paths. Extracted
+      // because three call sites that each re-implemented it is three chances to
+      // forget the head merge.
+      "async function __wrapLayouts(params, body, head) {",
+      "  let _b = body;",
+      '  let _h = head || "";',
+      "  for (let _i = _layoutCompList.length - 1; _i > 0; _i--) {",
+      "    const _inner = await renderPage('', _layoutCompList[_i], { params, children: _b }, __componentRegistry, { hydrate: true, cached: _layoutCompiledList[_i] });",
+      "    _b = _inner.body;",
+      "    if (_inner.head) _h = _inner.head + _h;",
+      "  }",
+      "  return renderFullPage('', _layoutCompList[0], { params, children: _b }, __componentRegistry, { hydrate: true, cached: _layoutCompiledList[0]" + bakedOptions + clientScriptOption + dataScriptOption + ", pageHead: _h });",
+      "}",
+      "",
       "async function __renderHtml(params, requestUrl) {",
       "  return withSsrStore(async () => {",
       "  resetPersistedStoreKeys();",
       "  let page;",
       "  let caughtError = null;",
+      "  let notFound = false;",
       "  const __expose = process.env.NODE_ENV !== 'production';",
       "  try {",
       "    page = await renderPage('', _pageComp, { params }, __componentRegistry, { hydrate: true, cached: _pageCompiled });",
       "  } catch (err) {",
-      "    if (err && (err.name === 'NotFoundError' || err.name === 'Redirect')) throw err;",
-      "    caughtError = err;",
-      "    const message = err && typeof err === 'object' && 'message' in err ? String(err.message) : String(err);",
-      "    const stack = err && typeof err === 'object' && 'stack' in err ? String(err.stack) : '';",
-      "    page = { body: await __renderErrorBody({ params, statusCode: 500, error: __expose ? message : 'Internal Server Error', stack: __expose ? stack : '', url: requestUrl || '' }), head: '' };",
+      "    if (err && err.name === 'Redirect') throw err;",
+      "    if (err && err.name === 'NotFoundError') {",
+      // The boundary is chosen per-route at build time (resolveNotFoundFile walks
+      // this route's own directory up to the app root), so a nested
+      // app/admin/not-found.vsk answers /admin/* and the root one answers the
+      // rest — matching the client router's deepest-first chain walk.
+      "      const nfBody = await __renderNotFoundBody({ params, url: requestUrl || '' });",
+      "      if (nfBody !== null) {",
+      "        notFound = true;",
+      "        page = { body: nfBody, head: '' };",
+      "      } else {",
+      "        throw err;",
+      "      }",
+      "    } else {",
+      "      caughtError = err;",
+      "      const message = err && typeof err === 'object' && 'message' in err ? String(err.message) : String(err);",
+      "      const stack = err && typeof err === 'object' && 'stack' in err ? String(err.stack) : '';",
+      "      page = { body: await __renderErrorBody({ params, statusCode: 500, error: __expose ? message : 'Internal Server Error', stack: __expose ? stack : '', url: requestUrl || '' }), head: '' };",
+      "    }",
       "  }",
       "  let _body = (caughtError ? '<!--vesk-ssr-error:' + (caughtError && typeof caughtError === 'object' && 'message' in caughtError ? encodeURIComponent(__expose ? String(caughtError.message) : 'Internal Server Error') : '') + '-->' : '') + page.body;",
-      "  let _head = page.head || '';",
-      "  for (let _i = _layoutCompList.length - 1; _i > 0; _i--) {",
-      "    const _inner = await renderPage('', _layoutCompList[_i], { params, children: _body }, __componentRegistry, { hydrate: true, cached: _layoutCompiledList[_i] });",
-      "    _body = _inner.body;",
-      "    if (_inner.head) _head = _inner.head + _head;",
-      "  }",
-      "  const html = await renderFullPage('', _layoutCompList[0], { params, children: _body }, __componentRegistry, { hydrate: true, cached: _layoutCompiledList[0]" + bakedOptions + clientScriptOption + dataScriptOption + ", pageHead: _head });",
-      "  return new Response(__injectStoreInit(html), { headers: { 'Content-Type': 'text/html' }, status: caughtError ? 500 : 200 });",
+      "  const html = await __wrapLayouts(params, _body, page.head || '');",
+      "  return new Response(__injectStoreInit(html), { headers: { 'Content-Type': 'text/html' }, status: notFound ? 404 : (caughtError ? 500 : 200) });",
       "  });",
       "}",
       ""
@@ -52505,6 +52562,7 @@ function generateManifest(routes, ssrRoutes, apiRoutes, staticRoutes, middleware
     if (r._isrTags) entry.tags = r._isrTags;
     routeEntries.push(entry);
   }
+  routeEntries.sort((a, b) => compareSpecificity(a.path, b.path));
   const apiEntries = [];
   for (const r of apiRoutes) {
     const urlParts = r.fullPath.split("/").filter(Boolean);
@@ -52952,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));
@@ -53009,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";
@@ -53138,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;
     }
   }
@@ -53409,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;
             }
           }
         }
@@ -53430,17 +53582,29 @@ async function startProdServer(outDir, options) {
     const pageCssUrls = resolveCssUrls({
       enabled: hasBuiltGlobalCss(outDir)
     });
-    const nfPath = resolve14(appDir, "not-found.vsk");
-    let notFoundHtml = null;
-    if (existsSync16(nfPath)) {
-      try {
-        const runtimePath = resolve14(outDir, "server", "runtime.js");
-        const { renderFullPage: renderFullPage2, storeDataScriptGlobal } = await import(runtimePath);
-        const src2 = readFileSync18(nfPath, "utf-8");
-        const compName = resolveComponentName(src2) || "NotFound";
-        notFoundHtml = await renderFullPage2(src2, compName, { params: {}, url: url.pathname }, /* @__PURE__ */ new Map(), { hydrate: true, cssUrls: pageCssUrls, security: securityConfig?.security || {}, externalDataScript: storeDataScriptGlobal, sourcePath: nfPath, headExtra: bakedHeadExtra });
-      } catch {
+    const boundaryCache = /* @__PURE__ */ new Map();
+    async function renderBoundaryFile(file, pathname, props) {
+      const boundaryPath = resolveBoundaryFileForUrl(pathname, appDir, file);
+      if (!boundaryPath) return null;
+      const key = `${file}:${boundaryPath}`;
+      let html = boundaryCache.has(key) ? boundaryCache.get(key) : null;
+      if (html === null) {
+        try {
+          const runtimePath = resolve14(outDir, "server", "runtime.js");
+          const { renderFullPage: renderFullPage2, storeDataScriptGlobal } = await import(runtimePath);
+          const src2 = readFileSync18(boundaryPath, "utf-8");
+          const compName = resolveComponentName(src2) || (file === "error.vsk" ? "Error" : "NotFound");
+          html = await renderFullPage2(src2, compName, props, /* @__PURE__ */ new Map(), { hydrate: true, cssUrls: pageCssUrls, clientScriptUrl: buildConfig?.assets?.client?.url || "/_vesk/static/client.js", clientScriptIntegrity: buildConfig?.assets?.client?.integrity, security: securityConfig?.security || {}, externalDataScript: storeDataScriptGlobal, sourcePath: boundaryPath, headExtra: bakedHeadExtra });
+        } catch {
+          return null;
+        }
       }
+      return html;
+    }
+    let notFoundHtml = null;
+    {
+      const rendered = await renderBoundaryFile("not-found.vsk", url.pathname, { params: {}, url: url.pathname });
+      notFoundHtml = rendered;
     }
     for (const route of buildConfig.routes) {
       if (route.type === "ssr") {
@@ -53510,19 +53674,13 @@ async function startProdServer(outDir, options) {
               if (eventsMod) {
                 await executeError(err, { url: url.href, routePath: route.path, target: "node", status: 500 }, eventsMod);
               }
-              const errPath = resolve14(appDir, "error.vsk");
-              let errorHtml = null;
-              if (existsSync16(errPath)) {
-                try {
-                  const runtimePath = resolve14(outDir, "server", "runtime.js");
-                  const { renderFullPage: renderFullPage2, storeDataScriptGlobal } = await import(runtimePath);
-                  const src2 = readFileSync18(errPath, "utf-8");
-                  const compName = resolveComponentName(src2) || "Error";
-                  const expose = process.env.NODE_ENV !== "production";
-                  errorHtml = await renderFullPage2(src2, compName, { error: expose ? err.message : "Internal Server Error", stack: expose ? err.stack : "", statusCode: 500, url: url.pathname }, /* @__PURE__ */ new Map(), { hydrate: true, cssUrls: pageCssUrls, clientScriptUrl: buildConfig?.assets?.client?.url || "/_vesk/static/client.js", clientScriptIntegrity: buildConfig?.assets?.client?.integrity, security: securityConfig?.security || {}, externalDataScript: storeDataScriptGlobal, sourcePath: errPath, headExtra: bakedHeadExtra });
-                } catch {
-                }
-              }
+              const expose = process.env.NODE_ENV !== "production";
+              const errorHtml = await renderBoundaryFile("error.vsk", url.pathname, {
+                error: expose ? err.message : "Internal Server Error",
+                stack: expose ? err.stack : "",
+                statusCode: 500,
+                url: url.pathname
+              });
               res.writeHead(500, { "Content-Type": "text/html" });
               res.end(errorHtml || renderDefaultErrorPage({ message: process.env.NODE_ENV !== "production" ? err.message : void 0, url: url.pathname, headExtra: bakedHeadExtra }));
               return;
@@ -65074,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.69",
+  "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.69",
-    "@vesk/compiler": "^0.2.69",
-    "@vesk/plugin-tailwind": "^0.2.69",
-    "@vesk/runtime": "^0.2.69",
+    "@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",