@antelopejs/dms-frontend 0.10.0 → 0.10.2

package/templates/vue/server/module-routes.mjs

@@ -1,3 +1,4 @@
+import { resolveAuth } from "./auth-declarations.mjs";
 import { resolveBackendProxies } from "./backend-proxies.mjs";
 import { compilePathPattern } from "./path-patterns.mjs";
 import { matchPublicEndpoint } from "./public-endpoints.mjs";
@@ -12,8 +13,8 @@ import {
 /** @typedef {(message: string) => void} Warn */
 /**
  * @import {
- *   AuthProvider, DeclaredModule, ModuleDeclared, RouteRegistration,
- *   ServerDeclarations, ServerModuleDeclaration, ServerRoute
+ *   DeclaredModule, ModuleDeclared, RouteRegistration,
+ *   ServerDeclarations, ServerMethod, ServerModuleDeclaration, ServerRoute
  * } from "./module-route-types.mjs"
  * @import { PublicEndpoint } from "./public-endpoints.mjs"
  */
@@ -156,13 +157,19 @@ function collectDeclarations(setup) {
   return declared;
 }
 
+/**
+ * @param {unknown} name
+ * @returns {name is ServerMethod}
+ */
+function isMethod(name) {
+  return isString(name) && METHODS.has(name);
+}
+
 /** @param {unknown} method */
 function methodsOf(method) {
   /** @type {readonly unknown[]} */
   const methods = Array.isArray(method) ? method : [method];
-  return methods.length && methods.every((name) => METHODS.has(name))
-    ? methods
-    : undefined;
+  return methods.length && methods.every(isMethod) ? methods : undefined;
 }
 
 /** @param {RouteRegistration} registration */
@@ -176,7 +183,7 @@ function registrationRejection(registration) {
 }
 
 /**
- * @param {RouteRegistration["method"]} method
+ * @param {string | readonly string[]} method
  * @param {string} path
  */
 function describeRoute(method, path) {
@@ -241,15 +248,16 @@ function declarationsOfModule(declaration, warn) {
 function routesOfModule(module, warn) {
   const { id, priority = 0 } = module;
   return module.declared.routes.flatMap((registration, order) => {
+    const methods = methodsOf(registration.method);
     const reason = registrationRejection(registration);
-    if (reason) {
+    if (reason || !methods) {
       warn(
         `Frontend module ${id} declares route ${describeRoute(registration.method, registration.path)}, which is ignored: ${reason}.`,
       );
       return [];
     }
     const compiled = compilePath(registration.path);
-    return methodsOf(registration.method).map((method) => ({
+    return methods.map((method) => ({
       ...compiled,
       id,
       priority,
@@ -399,70 +407,6 @@ function resolveRoutes(modules, warn, publicEndpoints) {
   return routes;
 }
 
-const AUTH_HOOKS = ["refreshSession", "publicSession"];
-
-/** @param {unknown} auth */
-function authRejection(auth) {
-  if (!isNonNullObject(auth)) return "it is not an object";
-  for (const hook of AUTH_HOOKS)
-    if (auth[hook] !== undefined && !isFunction(auth[hook]))
-      return `${hook} is not a function`;
-  if (
-    auth.signInPath !== undefined &&
-    (!isString(auth.signInPath) ||
-      !compilePathPattern(auth.signInPath) ||
-      auth.signInPath.includes("*"))
-  )
-    return "signInPath is not a page path";
-  if (
-    auth.signInExempt !== undefined &&
-    !(
-      Array.isArray(auth.signInExempt) &&
-      auth.signInExempt.every((pattern) => compilePathPattern(pattern))
-    )
-  )
-    return "signInExempt is not a list of /x, /x/* or /x/** patterns";
-  return undefined;
-}
-
-/**
- * The auth hooks: those of the highest-priority module that registers them.
- * A module registering them twice, or after another one, is reported.
- *
- * @param {DeclaredModule[]} modules
- * @param {Warn} warn
- */
-function resolveAuth(modules, warn) {
-  /** @type {AuthProvider | undefined} */
-  let provider;
-  for (const module of modules) {
-    for (const auth of module.declared.auth) {
-      const reason = authRejection(auth);
-      if (reason) {
-        warn(
-          `Frontend module ${module.id} registers auth hooks, which are ignored: ${reason}.`,
-        );
-        continue;
-      }
-      if (provider) {
-        warn(
-          `Frontend module ${module.id} registers auth hooks, which are ignored: ${provider.id} (priority ${provider.priority ?? 0}) provides them.`,
-        );
-        continue;
-      }
-      provider = {
-        id: module.id,
-        priority: module.priority ?? 0,
-        signInPath: auth.signInPath,
-        signInExempt: auth.signInExempt?.map(compilePathPattern),
-        refreshSession: auth.refreshSession,
-        publicSession: auth.publicSession,
-      };
-    }
-  }
-  return provider;
-}
-
 /**
  * The route rules: of two declarations of the same pattern, the module of
  * higher priority keeps it, with a warning.
@@ -482,18 +426,22 @@ function resolveRules(modules, warn) {
         continue;
       }
       for (const [pattern, rule] of Object.entries(rules)) {
-        const reason = ruleRejection(pattern, rule);
+        const compiled = compilePathPattern(pattern);
         const current = kept.get(pattern);
-        if (reason || current) {
+        const reason =
+          ruleRejection(pattern, rule) ??
+          (current &&
+            `${current.id} (priority ${current.priority}) declares it`);
+        if (!compiled || reason) {
           warn(
-            `Frontend module ${module.id} declares the route rule "${pattern}", which is ignored: ${reason ?? `${current.id} (priority ${current.priority}) declares it`}.`,
+            `Frontend module ${module.id} declares the route rule "${pattern}", which is ignored: ${reason}.`,
           );
           continue;
         }
         kept.set(pattern, {
           id: module.id,
           priority: module.priority ?? 0,
-          pattern: compilePathPattern(pattern),
+          pattern: compiled,
           rule,
         });
       }

package/templates/vue/server/module-server.mjs

@@ -3,7 +3,7 @@ import { fileURLToPath } from "node:url";
 import { allowedEstablishEndpoints } from "./auth/establish-endpoints.mjs";
 import { serverAuth } from "./auth-hooks.mjs";
 import { answerModuleRoute } from "./module-event.mjs";
-import { isNonNullObject, isString } from "./type-guards.mjs";
+import { isNonNullObject, isRecord, isString } from "./type-guards.mjs";
 import {
   matchModuleRoute,
   mayHaveModuleRoute,
@@ -81,19 +81,24 @@ function readJsonFile(url, fallback) {
 const UNSAFE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
 
 /**
- * The object holding `path`'s last key, when every key up to it is own.
+ * The object holding `path`'s last key, and that key, when every key up to it
+ * is own.
  *
  * @param {Record<string, unknown>} target
  * @param {string[]} path
+ * @returns {{ holder: Record<string, unknown>, key: string } | undefined}
  */
-function holderOf(target, path) {
+function slotOf(target, path) {
+  const key = path.at(-1);
+  if (key === undefined || UNSAFE_KEYS.has(key)) return undefined;
   let node = target;
-  for (const key of path.slice(0, -1)) {
-    if (UNSAFE_KEYS.has(key) || !Object.hasOwn(node, key)) return undefined;
-    node = node[key];
-    if (!isNonNullObject(node)) return undefined;
+  for (const step of path.slice(0, -1)) {
+    if (UNSAFE_KEYS.has(step) || !Object.hasOwn(node, step)) return undefined;
+    const next = node[step];
+    if (!isRecord(next)) return undefined;
+    node = next;
   }
-  return UNSAFE_KEYS.has(path.at(-1)) ? undefined : node;
+  return { holder: node, key };
 }
 
 /**
@@ -104,10 +109,12 @@ function holderOf(target, path) {
  * @param {string} value
  */
 function fillPath(target, path, value) {
-  const holder = holderOf(target, path);
-  const key = path.at(-1);
-  if (holder && (holder[key] === undefined || holder[key] === ""))
-    holder[key] = value;
+  const slot = slotOf(target, path);
+  if (
+    slot &&
+    (slot.holder[slot.key] === undefined || slot.holder[slot.key] === "")
+  )
+    slot.holder[slot.key] = value;
 }
 
 /**
@@ -118,10 +125,13 @@ function fillPath(target, path, value) {
  * @param {string} value
  */
 function fillEmptied(target, path, value) {
-  const holder = holderOf(target, path);
-  const key = path.at(-1);
-  if (holder && Object.hasOwn(holder, key) && holder[key] === "")
-    holder[key] = value;
+  const slot = slotOf(target, path);
+  if (
+    slot &&
+    Object.hasOwn(slot.holder, slot.key) &&
+    slot.holder[slot.key] === ""
+  )
+    slot.holder[slot.key] = value;
 }
 
 /**
@@ -327,7 +337,7 @@ export async function loadServerModules(devServer) {
  * module route serves is the module's for every method: another method is
  * answered `405`.
  *
- * @param {import("node:http").IncomingMessage} request The Node request
+ * @param {import("./request-target.mjs").ServerRequest} request The Node request
  * @param {import("node:http").ServerResponse} response The Node response
  * @param {string} pathname The request's normalized path
  * @param {ServerModules} modules What `loadServerModules` or `createServerModules` returned

package/templates/vue/server/module-testing.mjs

@@ -2,7 +2,9 @@ import { createServer } from "node:http";
 import { RequestBodyError, UpstreamError } from "./auth/backend.mjs";
 import { UNEXPECTED_ERROR_BODY } from "./backend-response.mjs";
 import { createServerModules, handleModuleRoute } from "./module-server.mjs";
-import { failureStatus } from "./request-failure.mjs";
+import { failureStatus, writeBadRequest } from "./request-failure.mjs";
+import { isServerRequest } from "./request-target.mjs";
+import { isString } from "./type-guards.mjs";
 
 /**
  * What the frontend server answers an API request whose handler failed.
@@ -52,6 +54,10 @@ export async function serveModuleRoutes(declarations, deployment = {}) {
     warn: (message) => warnings.push(message),
   });
   const server = createServer((request, response) => {
+    if (!isServerRequest(request)) {
+      writeBadRequest(response);
+      return;
+    }
     const { pathname } = new URL(request.url, "http://frontend.local");
     handleModuleRoute(request, response, pathname, modules)
       .then((answered) => {
@@ -61,16 +67,25 @@ export async function serveModuleRoutes(declarations, deployment = {}) {
         /** @param {unknown} error */ (error) => writeFailure(error, response),
       );
   });
-  await new Promise((settle) => server.listen(0, "127.0.0.1", settle));
-  const { port } = server.address();
+  /** @type {Promise<void>} */
+  const listening = new Promise((settle) =>
+    server.listen(0, "127.0.0.1", settle),
+  );
+  await listening;
+  const address = server.address();
+  if (address === null || isString(address))
+    throw new TypeError("The module test server is not listening on a port");
+  const { port } = address;
+  /** @returns {Promise<void>} */
+  const close = () =>
+    new Promise((settle) => {
+      server.closeAllConnections();
+      server.close(() => settle());
+    });
   return {
     url: `http://127.0.0.1:${port}`,
     modules,
     warnings,
-    close: () =>
-      new Promise((settle) => {
-        server.closeAllConnections();
-        server.close(() => settle());
-      }),
+    close,
   };
 }

package/templates/vue/server/page-props.mjs

@@ -46,7 +46,7 @@ const NOT_FOUND = 404;
  *
  * @typedef {{
  *   signInPath: string,
- *   view: (session: unknown) => { user?: unknown, session?: unknown }
+ *   view: (session: import("./auth/session.mjs").Session | undefined) => { user?: unknown, session?: unknown }
  * }} PageAuth
  */
 
@@ -66,8 +66,9 @@ export function pageRoute(props) {
  * browser holding the layout of another account or workspace, after a sign-in,
  * a sign-out or a switch, holds another key, so it is sent the right one.
  *
- * @param {unknown} session The sealed session: any JSON value, since only its
- *   `accountId` and `activeTenantId` are read, as empty when it holds none
+ * @param {{ accountId?: string, activeTenantId?: string } | undefined} session
+ *   The sealed session, of which only the `accountId` and `activeTenantId` are
+ *   read, as empty when it holds none
  * @returns {string}
  */
 export function sharedOnceKey(session) {
@@ -118,7 +119,7 @@ function pagePath(url, withShared) {
   }
   for (const [name, value] of pageQuery) query.set(name, value);
   if (!withShared) query.set(SHARED_PROP, "false");
-  return `/dms/page?${query}`;
+  return `/dms/page?${query.toString()}`;
 }
 
 /**
@@ -206,7 +207,7 @@ export async function propsForQuery(props, url, backend, auth) {
  * session's layout, sent now or already held: declaring it otherwise would let
  * a layout of another session pass for this one.
  *
- * @param {import("node:http").IncomingMessage} request
+ * @param {import("./request-target.mjs").ServerRequest} request
  * @param {PageBackend} backend
  * @param {PageAuth} auth
  * @returns {Promise<{

package/templates/vue/server/page-redirects.mjs

@@ -17,7 +17,7 @@ export function redirectToHomepage(request, response, pathname) {
 }
 
 /**
- * @param {import("node:http").IncomingMessage} request
+ * @param {import("./request-target.mjs").ServerRequest} request
  * @param {import("node:http").ServerResponse} response
  * @param {import("./page-props.mjs").PageProps} props
  * @param {import("./module-server.mjs").ServerModules["serverAuth"]} auth

package/templates/vue/server/path-patterns.mjs

@@ -2,6 +2,19 @@ import { isString } from "./type-guards.mjs";
 
 const SEGMENT = /^[A-Za-z0-9._~-]+$/;
 
+/** The forms a path pattern takes, as the warnings name them. */
+export const PATH_PATTERN_FORMS = "/x, /x/* or /x/**";
+
+/**
+ * The wildcard a pattern may end with: what it matches below the literal
+ * segments, and how it ranks against a pattern with the same literals.
+ */
+const TAILS = new Map([
+  ["*", { matcher: "/[^/]+", rank: 3 }],
+  ["**", { matcher: "(?:/.*)?", rank: 0 }],
+]);
+const NO_TAIL = { matcher: "", rank: 1 };
+
 /**
  * @typedef {object} CompiledPathPattern
  * @property {string} pattern The pattern as declared
@@ -17,7 +30,8 @@ const SEGMENT = /^[A-Za-z0-9._~-]+$/;
  *
  * Page path patterns, as the modules' `dms.server.ts` name them: `/x` is the
  * page itself, `/x/*` one segment below it, `/x/**` the page and everything
- * below it. Nothing else: no prefix match inside a segment, no query string.
+ * below it. Nothing else: a wildcard only as the last segment, no prefix
+ * match inside a segment, no query string.
  *
  * @param {unknown} pattern
  * @returns {CompiledPathPattern | undefined}
@@ -25,26 +39,23 @@ const SEGMENT = /^[A-Za-z0-9._~-]+$/;
 export function compilePathPattern(pattern) {
   if (!isString(pattern) || !pattern.startsWith("/")) return undefined;
   const segments = pattern === "/" ? [] : pattern.slice(1).split("/");
-  const deep = segments.at(-1) === "**";
-  const literal = deep ? segments.slice(0, -1) : segments;
+  const last = TAILS.get(segments.at(-1) ?? "");
+  const literal = last ? segments.slice(0, -1) : segments;
   if (
     literal.some(
       (segment) =>
-        segment !== "*" &&
-        (!SEGMENT.test(segment) || segment === "." || segment === ".."),
+        !SEGMENT.test(segment) || segment === "." || segment === "..",
     )
   )
     return undefined;
+  const tail = last ?? NO_TAIL;
   const body = literal
-    .map((segment) =>
-      segment === "*" ? "/[^/]+" : `/${segment.replaceAll(".", "\\.")}`,
-    )
+    .map((segment) => `/${segment.replaceAll(".", "\\.")}`)
     .join("");
-  const matcher = new RegExp(`^${body}${deep ? "(?:/.*)?" : ""}/?$`);
-  const literals = literal.filter((segment) => segment !== "*").length;
+  const matcher = new RegExp(`^${body}${tail.matcher}/?$`);
   return {
     pattern,
-    specificity: literals * 4 + literal.length * 2 + (deep ? 0 : 1),
+    specificity: literal.length * 6 + tail.rank,
     test: (pathname) => matcher.test(pathname === "" ? "/" : pathname),
   };
 }

package/templates/vue/server/proxy-headers.mjs

@@ -57,7 +57,7 @@ export function writeProxyHeaders(
   for (const name of [...HOP_BY_HOP_HEADERS, ...named]) delete headers[name];
   delete headers["set-cookie"];
   const cookies = upstream.headers.getSetCookie?.() ?? [];
-  if (cookies.length) headers["set-cookie"] = cookies;
+  if (cookies.length) Object.assign(headers, { "set-cookie": cookies });
   if (headers.location && upstream.url)
     headers.location = relayedLocation(
       headers.location,

package/templates/vue/server/proxy-redirects.mjs

@@ -6,6 +6,7 @@ export const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
  * @returns {string | undefined}
  */
 function originOf(url) {
+  if (url === undefined) return undefined;
   try {
     return new URL(url).origin;
   } catch {

package/templates/vue/server/proxy-request.mjs

@@ -21,7 +21,7 @@ const SAFE_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
  * the storage's signed URL, on the public origin the server itself may not
  * reach, which turned every download into a 502.
  *
- * @param {import("node:http").IncomingMessage} request
+ * @param {import("./request-target.mjs").ServerRequest} request
  * @param {import("node:http").ServerResponse} response
  * @param {import("./backend-proxies.mjs").BackendProxy} backendProxy
  * @param {(path: string) => boolean} isProxiedPath
@@ -36,6 +36,7 @@ export async function proxy(request, response, backendProxy, isProxiedPath) {
   if (response.closed) return;
   const abandoned = new AbortController();
   response.once("close", () => abandoned.abort());
+  /** @type {RequestInit} */
   const init = {
     signal: abandoned.signal,
     method: request.method,

package/templates/vue/server/proxy-transfers.mjs

@@ -1,3 +1,5 @@
+import { isObjectLike } from "./type-guards.mjs";
+
 const PAYLOAD_TOO_LARGE = 413;
 const TOO_LARGE_BODY = JSON.stringify({ message: "Payload Too Large" });
 /**
@@ -41,7 +43,7 @@ async function* limitedChunks(request, maxBodyBytes) {
 }
 
 /**
- * @param {import("node:http").IncomingMessage} request
+ * @param {import("./request-target.mjs").ServerRequest} request
  * @param {number | undefined} maxBodyBytes
  */
 function requestBody(request, maxBodyBytes) {
@@ -70,7 +72,7 @@ function declaresTooLargeBody(request, maxBodyBytes) {
 function isBodyTooLarge(error) {
   return (
     error instanceof BodyTooLargeError ||
-    error?.cause instanceof BodyTooLargeError
+    (isObjectLike(error) && error.cause instanceof BodyTooLargeError)
   );
 }
 
@@ -93,7 +95,10 @@ function refuseTooLargeBody(request, response) {
     connection: "close",
   });
   response.write(TOO_LARGE_BODY);
-  if (request.complete) return response.end();
+  if (request.complete) {
+    response.end();
+    return;
+  }
   const close = () => {
     clearTimeout(timer);
     response.end();
@@ -117,7 +122,7 @@ function refuseTooLargeBody(request, response) {
  * before a byte is passed on, a chunked body is cut off as soon as it goes
  * over.
  *
- * @param {import("node:http").IncomingMessage} request
+ * @param {import("./request-target.mjs").ServerRequest} request
  * @param {import("node:http").ServerResponse} response
  * @param {number | undefined} maxBodyBytes
  * @param {(
@@ -125,18 +130,19 @@ function refuseTooLargeBody(request, response) {
  * ) => Promise<Response>} send The backend request with the body to stream:
  *   none for a GET or a HEAD, the request itself, or its bytes cut off past
  *   the limit
- * @returns {Promise<Response | import("node:http").ServerResponse | undefined>}
- *   The backend's answer, or once the body went over and `response` got the
- *   413: `undefined`, or `response` itself when the request had been read
- *   already (`response.end()`'s own return)
+ * @returns {Promise<Response | undefined>} The backend's answer, or
+ *   `undefined` once the body went over and `response` got the 413
  */
 export async function sendWithinLimit(request, response, maxBodyBytes, send) {
-  if (declaresTooLargeBody(request, maxBodyBytes))
-    return refuseTooLargeBody(request, response);
+  if (declaresTooLargeBody(request, maxBodyBytes)) {
+    refuseTooLargeBody(request, response);
+    return undefined;
+  }
   try {
     return await send(requestBody(request, maxBodyBytes));
   } catch (error) {
     if (!isBodyTooLarge(error)) throw error;
-    return refuseTooLargeBody(request, response);
+    refuseTooLargeBody(request, response);
+    return undefined;
   }
 }

package/templates/vue/server/public-endpoints.mjs

@@ -2,13 +2,7 @@ import { readFileSync } from "node:fs";
 import { json } from "./auth/backend.mjs";
 import { CROSS_ORIGIN_ERROR, isSameOrigin } from "./auth/client-ip.mjs";
 import { PROXY_AUTH_MODES } from "./backend-proxies.mjs";
-import {
-  isNonNullObject,
-  isNumber,
-  isObjectLike,
-  isRecord,
-  isString,
-} from "./type-guards.mjs";
+import { isNumber, isObjectLike, isRecord, isString } from "./type-guards.mjs";
 
 /**
  * A public endpoint, compiled from a declaration that passed every check.
@@ -96,7 +90,7 @@ export function readDeclaredPublicEndpoints(file = DECLARED_ENDPOINTS_FILE) {
  * when the proxies are resolved.
  *
  * @param {unknown} entry
- * @returns {entry is { path: string, auth?: "session" | "none", maxBodyBytes?: number }}
+ * @returns {entry is { path: string, auth?: "session" | "none", maxBodyBytes?: number, module?: unknown }}
  */
 function isProxyDeclaration(entry) {
   return (
@@ -252,11 +246,11 @@ function pathMatcher(path) {
  * A declaration made usable, or `undefined` when any part of it is malformed:
  * a bad entry is dropped whole, never widened to what it might have meant.
  *
- * @param {PublicEndpointDeclaration | null | undefined} entry
+ * @param {unknown} entry
  * @returns {PublicEndpoint | undefined}
  */
 export function compilePublicEndpoint(entry) {
-  if (!isNonNullObject(entry)) return undefined;
+  if (!isObjectLike(entry)) return undefined;
   if (!isString(entry.path) || !PUBLIC_PATH.test(entry.path)) return undefined;
   const methods = normalizedMethods(entry.methods);
   const headers = normalizedHeaders(entry.headers);
@@ -284,7 +278,9 @@ export function allowedPublicEndpoints(
 ) {
   return [...declared, ...environmentEndpoints(declaration)].flatMap(
     (entry) => {
-      const endpoint = compilePublicEndpoint(entry);
+      const endpoint = isRecord(entry)
+        ? compilePublicEndpoint(entry)
+        : undefined;
       if (!endpoint)
         console.warn(
           `Ignoring malformed public endpoint ${JSON.stringify(entry)}: expected ` +
@@ -337,23 +333,23 @@ export function matchPublicEndpoint(
  * Origin. Under `auth: "session"`, a state-changing request needs one unless
  * it reaches a public endpoint, which is why the proxy never sends a public
  * endpoint the session: a cross-site form posting to it acts as nobody.
+ * Under either mode, a request that reaches a public endpoint carries the
+ * endpoint's declared headers.
  *
- * @param {import("node:http").IncomingMessage} request The incoming request
+ * @param {import("./request-target.mjs").ServerRequest} request The incoming request
  * @param {ReadonlySet<string>} safeMethods Methods that change nothing and need no Origin
  * @param {import("./backend-proxies.mjs").BackendProxy} proxy The backend proxy the request reached
  * @returns `{ anonymous, headers, isRefused }`
  */
 export function proxyAccess(request, safeMethods, proxy) {
-  if (proxy.auth === "none")
-    return { anonymous: true, headers: [], isRefused: false };
   const publicEndpoint = matchPublicEndpoint(
     request.method,
     new URL(request.url, "http://frontend.local").pathname,
   );
-  if (publicEndpoint)
+  if (publicEndpoint || proxy.auth === "none")
     return {
       anonymous: true,
-      headers: publicEndpoint.headers,
+      headers: publicEndpoint?.headers ?? [],
       isRefused: false,
     };
   return {

package/templates/vue/server/request-failure.mjs

@@ -38,7 +38,7 @@ export function failureStatus(error) {
  */
 export function isResponseGone(error, response) {
   return (
-    error?.code === "ERR_STREAM_PREMATURE_CLOSE" ||
+    (isObjectLike(error) && error.code === "ERR_STREAM_PREMATURE_CLOSE") ||
     response.destroyed ||
     response.writableEnded ||
     response.headersSent

package/templates/vue/server/request-routing.mjs

@@ -1,4 +1,5 @@
 import { matchBackendProxy } from "./backend-proxies.mjs";
+import { isIconRequest } from "./icons.mjs";
 import { isRendererFilePath, moduleRouteMethods } from "./module-routes.mjs";
 
 /**
@@ -37,7 +38,11 @@ const PAGE_METHODS = new Set(["GET", "HEAD"]);
  *   `{ kind: "not-found" }`
  */
 export function requestOwner(method, pathname, modules, hasRendererFile) {
-  if (isRendererFilePath(pathname) || hasRendererFile(pathname))
+  if (
+    isIconRequest(pathname) ||
+    isRendererFilePath(pathname) ||
+    hasRendererFile(pathname)
+  )
     return { kind: "renderer" };
   const route = modules.routes.find((candidate) =>
     candidate.matcher.test(pathname),