veryfront 0.1.49 → 0.1.51

package/src/src/types/entities.ts

@@ -1,5 +1,3 @@
-import { z } from "zod";
-
 export interface Frontmatter {
   title?: string;
   description?: string;
@@ -55,49 +53,6 @@ export interface EntityTypeInfo {
   isPage: boolean;
 }
 
-const FILE_PATH_REGEX = /\.(mdx?|tsx?|jsx?)$/;
-
-const FrontmatterValueSchema = z.union([
-  z.string(),
-  z.number(),
-  z.boolean(),
-  z.array(z.string()),
-  z.undefined(),
-]);
-
-export const FrontmatterSchema: z.ZodType<Frontmatter> = z.record(
-  z.string(),
-  FrontmatterValueSchema,
-);
-
-export const EntitySchema: z.ZodType<Entity> = z.object({
-  id: z.string().uuid("Entity id must be a valid UUID"),
-  path: z
-    .string()
-    .min(1, "Entity path cannot be empty")
-    .regex(
-      FILE_PATH_REGEX,
-      "Entity path must end with a valid file extension (.md, .mdx, .ts, .tsx, .js, .jsx)",
-    ),
-  slug: z.string().min(1, "Entity slug cannot be empty"),
-  type: z.enum(["page", "layout", "component"]),
-  content: z.string(),
-  frontmatter: FrontmatterSchema,
-  kind: z.enum(["mdx", "tsx"]).optional(),
-  isLayout: z.boolean().optional(),
-  isComponent: z.boolean().optional(),
-  isPage: z.boolean().optional(),
-});
-
-export function validateEntity(entity: unknown): Entity {
-  return EntitySchema.parse(entity);
-}
-
-export function safeValidateEntity(entity: unknown): Entity | null {
-  const result = EntitySchema.safeParse(entity);
-  return result.success ? result.data : null;
-}
-
 function detectFileKind(ext?: string): "mdx" | "tsx" | undefined {
   if (ext === "mdx") return "mdx";
   if (ext === "tsx" || ext === "ts" || ext === "jsx" || ext === "js") return "tsx";

package/src/src/utils/box.ts

@@ -5,7 +5,7 @@
  * Inspired by Lip Gloss (charmbracelet).
  */
 
-// deno-lint-ignore no-control-regex
+// deno-lint-ignore no-control-regex -- intentional: matches ANSI escape sequences for terminal color stripping
 const ANSI_REGEX = /\x1b\[[0-9;]*m/g;
 const RESET = `\x1b[0m`;
 

package/src/src/utils/bundle-manifest-init.ts

@@ -117,28 +117,3 @@ export function getBundleManifestTTL(
   if (mode === "production") return BUNDLE_MANIFEST_PROD_TTL_MS;
   return BUNDLE_MANIFEST_DEV_TTL_MS;
 }
-
-export async function warmupBundleManifest(
-  store: BundleManifestStore,
-  keys: string[],
-): Promise<void> {
-  logger.debug("Warming up cache", { keys: keys.length });
-
-  let loaded = 0;
-  let failed = 0;
-
-  for (const key of keys) {
-    try {
-      const metadata = await store.getBundleMetadata(key);
-      if (!metadata) continue;
-
-      await store.getBundleCode(metadata.codeHash);
-      loaded++;
-    } catch (error) {
-      logger.debug("Failed to warm up key", { key, error });
-      failed++;
-    }
-  }
-
-  logger.debug("Cache warmup complete", { loaded, failed });
-}

package/src/src/utils/bundle-manifest-kv.ts

@@ -5,7 +5,7 @@ import type {
   BundleMetadata,
 } from "./bundle-manifest.js";
 
-export interface KVBundleManifestStoreOptions {
+interface KVBundleManifestStoreOptions {
   keyPrefix?: string;
 }
 

package/src/src/utils/bundle-manifest-redis.ts

@@ -5,7 +5,7 @@ import type {
   BundleMetadata,
 } from "./bundle-manifest.js";
 
-export interface RedisBundleManifestStoreOptions {
+interface RedisBundleManifestStoreOptions {
   url?: string;
   keyPrefix?: string;
 }

package/src/src/utils/cache-dir.ts

@@ -59,8 +59,8 @@ export async function ensureCacheNodeModules(): Promise<void> {
     try {
       lstatSync(targetLink);
       return;
-    } catch {
-      // Doesn't exist yet
+    } catch (_) {
+      /* expected: symlink doesn't exist yet */
     }
 
     const require = createRequire(import.meta.url);
@@ -74,8 +74,7 @@ export async function ensureCacheNodeModules(): Promise<void> {
 
     mkdirSync(cacheBase, { recursive: true });
     symlinkSync(nodeModulesDir, targetLink, "dir");
-  } catch {
-    // Best-effort: if symlink fails (permissions, platform), bare specifier
-    // resolution will fall through to Node.js defaults.
+  } catch (_) {
+    /* expected: best-effort symlink may fail due to permissions or platform */
   }
 }

package/src/src/utils/cache-file-ops.ts

@@ -85,7 +85,8 @@ export async function verifyCacheFileExists(
   try {
     const stat = await fs.stat(path);
     return !!stat?.isFile;
-  } catch {
+  } catch (_) {
+    /* expected: file may not exist */
     return false;
   }
 }

package/src/src/utils/circuit-breaker.ts

@@ -11,9 +11,21 @@ import { logger as baseLogger } from "./index.js";
 
 const logger = baseLogger.component("circuit-breaker");
 
-export type CircuitState = "CLOSED" | "OPEN" | "HALF_OPEN";
+/** Default number of consecutive failures before the circuit opens */
+const DEFAULT_FAILURE_THRESHOLD = 5;
 
-export interface CircuitBreakerOptions {
+/** Default time to wait in OPEN state before attempting recovery (30 seconds) */
+const DEFAULT_RESET_TIMEOUT_MS = 30_000;
+
+/** Default number of successes in HALF_OPEN required to close the circuit */
+const DEFAULT_SUCCESS_THRESHOLD = 3;
+
+/** Maximum concurrent attempts allowed while the circuit is HALF_OPEN */
+const MAX_HALF_OPEN_ATTEMPTS = 3;
+
+type CircuitState = "CLOSED" | "OPEN" | "HALF_OPEN";
+
+interface CircuitBreakerOptions {
   /** Failures before opening (default: 5) */
   failureThreshold?: number;
   /** Ms to wait before retry (default: 30000) */
@@ -52,9 +64,9 @@ export class CircuitBreaker {
   private readonly breakerName: string;
 
   constructor(options: CircuitBreakerOptions = {}) {
-    this.failureThreshold = options.failureThreshold ?? 5;
-    this.resetTimeoutMs = options.resetTimeoutMs ?? 30000;
-    this.successThreshold = options.successThreshold ?? 3;
+    this.failureThreshold = options.failureThreshold ?? DEFAULT_FAILURE_THRESHOLD;
+    this.resetTimeoutMs = options.resetTimeoutMs ?? DEFAULT_RESET_TIMEOUT_MS;
+    this.successThreshold = options.successThreshold ?? DEFAULT_SUCCESS_THRESHOLD;
     this.breakerName = options.name ?? "default";
   }
 
@@ -67,7 +79,7 @@ export class CircuitBreaker {
     }
 
     if (this.state === "HALF_OPEN") {
-      if (this.halfOpenAttempts >= 3) {
+      if (this.halfOpenAttempts >= MAX_HALF_OPEN_ATTEMPTS) {
         this.transitionTo("OPEN");
         this.lastFailureTime = Date.now();
         throw new CircuitBreakerOpen(this.breakerName, this.resetTimeoutMs);
@@ -145,7 +157,7 @@ export class CircuitBreaker {
 }
 
 /** Maximum number of circuit breakers to keep in registry */
-const MAX_BREAKERS = 1000;
+const MAX_BREAKERS = 1_000;
 
 /** Minimum age (ms) before a breaker can be evicted (1 hour) */
 const MIN_EVICTION_AGE_MS = 60 * 60 * 1000;
@@ -202,24 +214,3 @@ export function getCircuitBreaker(
   breakers.set(name, { breaker, lastUsed: Date.now() });
   return breaker;
 }
-
-/** Get circuit breaker registry stats for monitoring */
-export function getCircuitBreakerStats(): {
-  total: number;
-  open: number;
-  halfOpen: number;
-  closed: number;
-} {
-  let open = 0;
-  let halfOpen = 0;
-  let closed = 0;
-
-  for (const { breaker } of breakers.values()) {
-    const state = breaker.getState();
-    if (state === "OPEN") open++;
-    else if (state === "HALF_OPEN") halfOpen++;
-    else closed++;
-  }
-
-  return { total: breakers.size, open, halfOpen, closed };
-}

package/src/src/utils/constants/cache.ts

@@ -16,8 +16,8 @@ function getEnvString(key: string): string | undefined {
 
   try {
     return g.Deno?.env?.get?.(key) ?? g.process?.env?.[key];
-  } catch {
-    // Gracefully handle missing --allow-env permission in Deno
+  } catch (_) {
+    /* expected: Deno may deny --allow-env permission */
     return undefined;
   }
 }

package/src/src/utils/env-loader.ts

@@ -1,4 +1,4 @@
-import { serverLogger } from "./logger/index.js";
+import { refreshLoggerConfig, serverLogger } from "./logger/index.js";
 import { cwd as getCwd, getEnv, setEnv } from "../platform/compat/process.js";
 import { isNotFoundError, readTextFile } from "../platform/compat/fs.js";
 
@@ -56,6 +56,7 @@ export async function loadEnv(
   }
 
   envLoaded = true;
+  refreshLoggerConfig();
   if (loadedCount === 0) return;
 
   logger.debug(

package/src/src/utils/file-discovery.ts

@@ -25,7 +25,7 @@ async function getDefaultAdapter(): Promise<RuntimeAdapter> {
   return nodeAdapter;
 }
 
-export interface FileDiscoveryOptions {
+interface FileDiscoveryOptions {
   baseDir: string;
   extensions?: string[];
   patterns?: string[];
@@ -37,7 +37,7 @@ export interface FileDiscoveryOptions {
   adapter?: RuntimeAdapter;
 }
 
-export interface FileDiscoveryResult {
+interface FileDiscoveryResult {
   path: string;
   name: string;
   isFile: boolean;
@@ -196,12 +196,12 @@ async function* walkDirectory(options: WalkDirectoryOptions): AsyncGenerator<Fil
           isDirectory: false,
           depth: currentDepth,
         };
-      } catch {
-        // Ignore broken symlinks
+      } catch (_) {
+        /* expected: broken symlinks cannot be stat'd */
       }
     }
-  } catch {
-    // Silently skip missing/inaccessible directories
+  } catch (_) {
+    /* expected: directory may be missing or inaccessible */
   }
 }
 

package/src/src/utils/hash-utils.ts

@@ -1,6 +1,10 @@
 import * as dntShim from "../../_dnt.shims.js";
+import { FNV1A_PRIME_32 } from "./constants/crypto.js";
 import { HASH_SEED_FNV1A } from "./constants/hash.js";
 
+/** Number of hex characters kept by shortHash (8 hex chars = 32 bits) */
+const SHORT_HASH_LENGTH = 8;
+
 export async function computeHash(content: string): Promise<string> {
   const data = new TextEncoder().encode(content);
   const hashBuffer = await dntShim.crypto.subtle.digest("SHA-256", data);
@@ -36,7 +40,7 @@ export function hashCodeHex(str: string): string {
 
 export async function shortHash(content: string): Promise<string> {
   const fullHash = await computeHash(content);
-  return fullHash.slice(0, 8);
+  return fullHash.slice(0, SHORT_HASH_LENGTH);
 }
 
 /** FNV-1a hash for strings - returns hex string */
@@ -45,7 +49,7 @@ export function fnv1aHash(input: string): string {
 
   for (const char of input) {
     hash ^= char.charCodeAt(0);
-    hash = Math.imul(hash, 16777619);
+    hash = Math.imul(hash, FNV1A_PRIME_32);
   }
 
   return (hash >>> 0).toString(16);

package/src/src/utils/import-lockfile.ts

@@ -2,6 +2,7 @@ import * as dntShim from "../../_dnt.shims.js";
 import { computeHash } from "./hash-utils.js";
 import { serverLogger } from "./logger/index.js";
 import { createFileSystem } from "../platform/compat/fs.js";
+import { CACHE_ERROR, NETWORK_ERROR } from "../errors/index.js";
 
 const logger = serverLogger.component("lockfile");
 
@@ -182,9 +183,10 @@ export async function fetchWithLock(options: FetchWithLockOptions): Promise<Fetc
 
     if (!res.ok) {
       if (strict) {
-        throw new Error(
-          `Lockfile entry stale: ${url} resolved to ${entry.resolved} returned ${res.status}`,
-        );
+        throw CACHE_ERROR.create({
+          detail:
+            `Lockfile entry stale: ${url} resolved to ${entry.resolved} returned ${res.status}`,
+        });
       }
       logger.warn(`Cached URL ${entry.resolved} returned ${res.status}, refetching`);
     } else {
@@ -201,9 +203,10 @@ export async function fetchWithLock(options: FetchWithLockOptions): Promise<Fetc
       }
 
       if (strict) {
-        throw new Error(
-          `Integrity mismatch for ${url}: expected ${entry.integrity}, got ${currentIntegrity}`,
-        );
+        throw CACHE_ERROR.create({
+          detail:
+            `Integrity mismatch for ${url}: expected ${entry.integrity}, got ${currentIntegrity}`,
+        });
       }
       logger.warn(`Integrity mismatch for ${url}, updating lockfile`);
     }
@@ -212,7 +215,7 @@ export async function fetchWithLock(options: FetchWithLockOptions): Promise<Fetc
   logger.debug(`Fetching fresh: ${url}`);
   const res = await fetchFn(url, { headers: USER_AGENT_HEADERS, redirect: "follow" });
 
-  if (!res.ok) throw new Error(`Failed to fetch ${url}: ${res.status}`);
+  if (!res.ok) throw NETWORK_ERROR.create({ detail: `Failed to fetch ${url}: ${res.status}` });
 
   const content = await res.text();
   const resolvedUrl = res.url || url;
@@ -265,7 +268,8 @@ export function resolveImportUrl(specifier: string, baseUrl: string): string | n
 
   try {
     return new URL(specifier, baseUrl).toString();
-  } catch {
+  } catch (_) {
+    /* expected: specifier may not be a valid relative URL */
     return null;
   }
 }

package/src/src/utils/logger/core.ts

@@ -99,7 +99,8 @@ export function formatValue(value: unknown): string {
   let text: string | undefined;
   try {
     text = JSON.stringify(value);
-  } catch {
+  } catch (_) {
+    /* expected: JSON.stringify fails on circular references */
     text = String(value);
   }
 

package/src/src/utils/logger/logger.ts

@@ -41,13 +41,13 @@ export interface LogEntry {
   // Error details if applicable
   error?: SerializedError;
   // Request context (when available)
-  /** @deprecated Use `request_id` instead. Kept for Grafana dashboard transition. */
+  /** @deprecated Use `request_id` instead. Kept for Grafana dashboard transition. Planned removal after Grafana dashboard migration is complete. */
   requestId?: string;
-  /** @deprecated Use `trace_id` instead. Kept for Grafana dashboard transition. */
+  /** @deprecated Use `trace_id` instead. Kept for Grafana dashboard transition. Planned removal after Grafana dashboard migration is complete. */
   traceId?: string;
-  /** @deprecated Use `span_id` instead. Kept for Grafana dashboard transition. */
+  /** @deprecated Use `span_id` instead. Kept for Grafana dashboard transition. Planned removal after Grafana dashboard migration is complete. */
   spanId?: string;
-  /** @deprecated Use `project_slug` instead. Kept for Grafana dashboard transition. */
+  /** @deprecated Use `project_slug` instead. Kept for Grafana dashboard transition. Planned removal after Grafana dashboard migration is complete. */
   projectSlug?: string;
   // Standard fields for Loki filtering (snake_case)
   request_id?: string;
@@ -61,7 +61,7 @@ export interface LogEntry {
   branch_id?: string;
   branch_name?: string;
   // Duration for timed operations
-  /** @deprecated Use `duration_ms` instead. Kept for Grafana dashboard transition. */
+  /** @deprecated Use `duration_ms` instead. Kept for Grafana dashboard transition. Planned removal after Grafana dashboard migration is complete. */
   durationMs?: number;
   duration_ms?: number;
 }
@@ -177,7 +177,16 @@ function extractContext(
       continue;
     }
     if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
-      context = { ...context, ...arg };
+      const contextArg = arg as Record<string, unknown>;
+      if (contextArg.error instanceof Error) {
+        const { error: contextError, ...rest } = contextArg;
+        error = serializeError(contextError);
+        if (Object.keys(rest).length > 0) {
+          context = { ...context, ...rest };
+        }
+        continue;
+      }
+      context = { ...context, ...contextArg };
     }
   }
 
@@ -202,7 +211,8 @@ function isTty(): boolean {
     if (hasNodeProcess(dntShim.dntGlobalThis)) {
       return Boolean(globalThis.process?.stdout?.isTTY);
     }
-  } catch {
+  } catch (_) {
+    /* expected: TTY detection may fail in restricted environments */
     return false;
   }
   return false;

package/src/src/utils/lru-wrapper.ts

@@ -5,7 +5,10 @@ import { DEFAULT_LRU_MAX_ENTRIES } from "./index.js";
 import { unrefTimer } from "../platform/compat/process.js";
 import { getEnv } from "../platform/compat/process.js";
 
-export interface LRUOptions {
+/** Default interval between expired-entry cleanup sweeps (1 minute) */
+const DEFAULT_CLEANUP_INTERVAL_MS = 60_000;
+
+interface LRUOptions {
   maxEntries?: number;
   ttlMs?: number;
   cleanupIntervalMs?: number;
@@ -25,7 +28,7 @@ export class LRUCache<K, V> {
 
     this.adapter = new LRUCacheAdapter(adapterOptions);
     this.ttlMs = options.ttlMs;
-    this.cleanupIntervalMs = options.cleanupIntervalMs ?? 60000;
+    this.cleanupIntervalMs = options.cleanupIntervalMs ?? DEFAULT_CLEANUP_INTERVAL_MS;
 
     if (this.ttlMs && this.ttlMs > 0) {
       this.startPeriodicCleanup();

package/src/src/utils/memoize.ts

@@ -1,7 +1,6 @@
+import { FNV1A_PRIME_32 } from "./constants/crypto.js";
 import { HASH_SEED_FNV1A } from "./constants/hash.js";
 
-const FNV_PRIME = 16777619;
-
 export class MemoCache<V> {
   private cache = new Map<string, V>();
 
@@ -93,7 +92,7 @@ export function simpleHash(...values: unknown[]): string {
 
     for (let i = 0; i < str.length; i++) {
       hash ^= str.charCodeAt(i);
-      hash = Math.imul(hash, FNV_PRIME);
+      hash = Math.imul(hash, FNV1A_PRIME_32);
     }
   }
 

package/src/src/utils/memory/profiler.ts

@@ -12,6 +12,15 @@ import { getArgs, getEnv, memoryUsage } from "../../platform/compat/process.js";
 
 const logger = rendererLogger.component("memory-profiler");
 
+/** Fallback V8 heap limit when no --max-old-space-size flag is set (5 GB) */
+const DEFAULT_HEAP_LIMIT_MB = 5_120;
+
+/** Default interval for periodic memory snapshots (30 seconds) */
+const DEFAULT_MEMORY_MONITORING_INTERVAL_MS = 30_000;
+
+/** Heap growth (MB) per interval that triggers a rapid-growth warning */
+const HEAP_RAPID_GROWTH_THRESHOLD_MB = 100;
+
 const cacheRegistry = new Map<string, () => CacheStats>();
 
 export interface CacheStats {
@@ -91,7 +100,7 @@ function getConfiguredHeapLimit(): number {
   const v8MaxOldSpaceSize = parseInt(getEnv("V8_MAX_OLD_SPACE_SIZE") ?? "", 10);
   if (!Number.isNaN(v8MaxOldSpaceSize) && v8MaxOldSpaceSize > 0) return v8MaxOldSpaceSize;
 
-  return 5120;
+  return DEFAULT_HEAP_LIMIT_MB;
 }
 
 export function getCacheStats(): CacheStats[] {
@@ -126,14 +135,15 @@ export async function forceGC(): Promise<boolean> {
   try {
     const buffer = new Uint8Array(100 * 1024 * 1024);
     buffer.fill(0);
-    await new Promise<void>((resolve) => dntShim.setTimeout(resolve, 100));
+    await new Promise<void>((resolve) => dntShim.setTimeout(resolve, 100)); // no cleanup needed: one-shot
     return true;
-  } catch {
+  } catch (error) {
+    logger.debug("forceGC allocation failed", { error });
     return false;
   }
 }
 
-export function startMemoryMonitoring(intervalMs = 30000): void {
+export function startMemoryMonitoring(intervalMs = DEFAULT_MEMORY_MONITORING_INTERVAL_MS): void {
   if (memoryCheckInterval) clearInterval(memoryCheckInterval);
 
   logger.info(`Starting memory monitoring (interval: ${intervalMs}ms)`);
@@ -161,7 +171,7 @@ export function startMemoryMonitoring(intervalMs = 30000): void {
     }
 
     const heapGrowthMB = heap.usedHeapSizeMB - lastHeapUsed;
-    if (heapGrowthMB > 100) {
+    if (heapGrowthMB > HEAP_RAPID_GROWTH_THRESHOLD_MB) {
       logger.warn("Rapid heap growth detected", {
         growthMB: heapGrowthMB,
         intervalMs,
@@ -198,14 +208,15 @@ export function clearAllCaches(): void {
  */
 function getMemoryThreshold(envVar: string, fallback: number): number {
   try {
-    const value = typeof dntShim.Deno !== "undefined" ? dntShim.Deno.env.get(envVar) : undefined;
+    const value = getEnv(envVar);
     if (!value) return fallback;
 
     const parsed = parseInt(value, 10);
     if (Number.isNaN(parsed)) return fallback;
 
     return parsed;
-  } catch {
+  } catch (_) {
+    /* expected: Deno.env.get may fail without --allow-env */
     return fallback;
   }
 }

package/src/src/utils/parallel.ts

@@ -9,6 +9,7 @@
 
 import { Semaphore } from "../modules/react-loader/ssr-module-loader/concurrency/semaphore.js";
 import { withSpan } from "../observability/tracing/otlp-setup.js";
+import { TIMEOUT_ERROR } from "../errors/index.js";
 
 const DEFAULT_CONCURRENCY = 20;
 const ACQUIRE_TIMEOUT_MS = 30_000;
@@ -32,9 +33,10 @@ async function acquireOrThrow(
   const acquired = await semaphore.tryAcquire(timeoutMs);
   if (acquired) return;
 
-  throw new Error(
-    `${label}: timed out waiting for semaphore after ${timeoutMs}ms (available: ${semaphore.available}, waiting: ${semaphore.waiting})`,
-  );
+  throw TIMEOUT_ERROR.create({
+    detail:
+      `${label}: timed out waiting for semaphore after ${timeoutMs}ms (available: ${semaphore.available}, waiting: ${semaphore.waiting})`,
+  });
 }
 
 export function parallelMap<T, R>(

package/src/src/utils/path-utils.ts

@@ -1,13 +1,14 @@
+import { normalize } from "../platform/compat/path/index.js";
 import { logger } from "./logger/logger.js";
 
-export function normalizePath(pathname: string): string {
-  let normalized = pathname.replace(/\\+/g, "/").replace(/\/\.+\//g, "/");
-
-  if (normalized !== "/" && normalized.endsWith("/")) {
-    normalized = normalized.slice(0, -1);
-  }
+function stripTrailingSlash(pathname: string): string {
+  if (pathname === "/") return pathname;
+  return pathname.replace(/\/+$/, "");
+}
 
-  return normalized;
+export function normalizePath(pathname: string): string {
+  if (!pathname) return pathname;
+  return stripTrailingSlash(normalize(pathname.replace(/\\+/g, "/")));
 }
 
 export function joinPath(a: string, b: string): string {
@@ -17,9 +18,10 @@ export function joinPath(a: string, b: string): string {
 }
 
 export function isWithinDirectory(root: string, target: string): boolean {
-  const normalizedRoot = normalizePath(root);
-  const normalizedTarget = normalizePath(target);
+  const normalizedRoot = stripTrailingSlash(normalizePath(root));
+  const normalizedTarget = stripTrailingSlash(normalizePath(target));
 
+  if (normalizedRoot === "/") return normalizedTarget.startsWith("/");
   return normalizedTarget === normalizedRoot || normalizedTarget.startsWith(`${normalizedRoot}/`);
 }
 

package/src/src/utils/platform.ts

@@ -14,7 +14,8 @@ export function isCompiledBinary(): boolean {
 
   try {
     return execPath().includes("veryfront");
-  } catch {
+  } catch (_) {
+    /* expected: execPath may not be available on all platforms */
     return false;
   }
 }