webspresso 0.0.102 → 0.0.103

package/src/helpers.js

@@ -21,6 +21,25 @@ dayjs.extend(customParseFormat);
 // Cache for isPath regex patterns
 const isPathRegexCache = new Map();
 
+// Caches for manifest files and filesystem existence checks
+const manifestFileCache = new Map();
+const diskExistenceCache = new Map();
+
+function cachedExistsSync(filePath) {
+  const cached = diskExistenceCache.get(filePath);
+  if (cached !== undefined) return cached;
+  let exists = false;
+  try {
+    exists = fs.existsSync(filePath);
+  } catch (_) {
+    exists = false;
+  }
+  if (diskExistenceCache.size < 2000) {
+    diskExistenceCache.set(filePath, exists);
+  }
+  return exists;
+}
+
 /**
  * Asset Manager - handles asset paths, versioning, and manifest
  */
@@ -34,6 +53,12 @@ class AssetManager {
     this.version = options.version || null;
     this.prefix = options.prefix || '';
     
+    // Per-instance fast-path caches
+    this._resolveCache = new Map();
+    this._hasJsCache = new Map();
+    this._hasCssCache = new Map();
+    this._lookupIndex = null;
+    
     // Auto-detect manifest if not explicitly provided
     if (!this.manifestPath) {
       const candidates = [
@@ -42,7 +67,7 @@ class AssetManager {
         path.join(this.publicDir, '.vite', 'manifest.json'),
       ];
       for (const candidate of candidates) {
-        if (fs.existsSync(candidate)) {
+        if (cachedExistsSync(candidate)) {
           this.manifestPath = candidate;
           break;
         }
@@ -54,6 +79,25 @@ class AssetManager {
       this.loadManifest();
     }
   }
+
+  /**
+   * Pre-build lookup index for fast O(1) fallback matching
+   */
+  _buildLookupIndex() {
+    if (!this.manifest || typeof this.manifest !== 'object') {
+      this._lookupIndex = null;
+      return;
+    }
+    const idx = new Map();
+    for (const [key, val] of Object.entries(this.manifest)) {
+      idx.set(key, val);
+      const base = path.basename(key);
+      if (!idx.has(base)) {
+        idx.set(base, val);
+      }
+    }
+    this._lookupIndex = idx;
+  }
   
   /**
    * Load asset manifest file (Vite, Webpack, etc.)
@@ -62,12 +106,35 @@ class AssetManager {
     try {
       const fullPath = path.resolve(this.manifestPath);
       if (fs.existsSync(fullPath)) {
-        const content = fs.readFileSync(fullPath, 'utf-8');
-        this.manifest = JSON.parse(content);
+        try {
+          const stats = fs.statSync(fullPath);
+          const cached = manifestFileCache.get(fullPath);
+          if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
+            this.manifest = cached.manifest;
+            this._lookupIndex = cached.lookupIndex;
+            return;
+          }
+          const content = fs.readFileSync(fullPath, 'utf-8');
+          this.manifest = JSON.parse(content);
+          this._buildLookupIndex();
+          manifestFileCache.set(fullPath, {
+            mtimeMs: stats.mtimeMs,
+            size: stats.size,
+            manifest: this.manifest,
+            lookupIndex: this._lookupIndex,
+          });
+          return;
+        } catch (_) {
+          const content = fs.readFileSync(fullPath, 'utf-8');
+          this.manifest = JSON.parse(content);
+          this._buildLookupIndex();
+          return;
+        }
       }
     } catch (err) {
       console.warn('Failed to load asset manifest:', err.message);
       this.manifest = null;
+      this._lookupIndex = null;
     }
   }
   
@@ -77,6 +144,9 @@ class AssetManager {
    * @returns {string}
    */
   resolve(assetPath) {
+    const cached = this._resolveCache.get(assetPath);
+    if (cached !== undefined) return cached;
+
     // Remove leading slash for manifest lookup
     const lookupPath = assetPath.replace(/^\//, '');
     
@@ -85,7 +155,12 @@ class AssetManager {
       // 1. Direct match with lookupPath or assetPath
       let entry = this.manifest[lookupPath] || this.manifest[assetPath];
 
-      // 2. Flexible fallback: match by basename or trailing path
+      // 2. Fast lookup index match
+      if (!entry && this._lookupIndex) {
+        entry = this._lookupIndex.get(lookupPath) || this._lookupIndex.get(path.basename(lookupPath));
+      }
+
+      // 3. Flexible fallback: match by basename or trailing path
       if (!entry) {
         const baseName = path.basename(lookupPath);
         for (const [key, val] of Object.entries(this.manifest)) {
@@ -102,14 +177,20 @@ class AssetManager {
       }
 
       if (entry) {
+        let result;
         // Webpack string format (e.g. "/dist/app.xyz789.js")
         if (typeof entry === 'string') {
-          return this.prefix + entry;
-        }
-        // Vite / esbuild metafile format (e.g. { file: "assets/app-xyz789.js" })
-        if (entry.file) {
+          result = this.prefix + entry;
+        } else if (entry.file) {
+          // Vite / esbuild metafile format (e.g. { file: "assets/app-xyz789.js" })
           const file = entry.file.startsWith('/') ? entry.file : '/' + entry.file;
-          return this.prefix ? (this.prefix + file).replace(/\/+/g, '/') : file;
+          result = this.prefix ? (this.prefix + file).replace(/\/+/g, '/') : file;
+        }
+        if (result !== undefined) {
+          if (this._resolveCache.size < 2000) {
+            this._resolveCache.set(assetPath, result);
+          }
+          return result;
         }
       }
     }
@@ -123,6 +204,9 @@ class AssetManager {
       finalPath += `${separator}v=${this.version}`;
     }
     
+    if (this._resolveCache.size < 2000) {
+      this._resolveCache.set(assetPath, finalPath);
+    }
     return finalPath;
   }
   
@@ -136,8 +220,11 @@ class AssetManager {
   /**
    * Generate CSS link tag
    */
-  css(href, attributes = {}) {
+  css(href, attributes) {
     const resolvedHref = this.resolve(href);
+    if (!attributes || Object.keys(attributes).length === 0) {
+      return `<link rel="stylesheet" href="${this.escapeHtml(resolvedHref)}">`;
+    }
     const attrs = this.buildAttributes({
       rel: 'stylesheet',
       href: resolvedHref,
@@ -149,8 +236,11 @@ class AssetManager {
   /**
    * Generate JS script tag
    */
-  js(src, attributes = {}) {
+  js(src, attributes) {
     const resolvedSrc = this.resolve(src);
+    if (!attributes || Object.keys(attributes).length === 0) {
+      return `<script src="${this.escapeHtml(resolvedSrc)}"></script>`;
+    }
     const attrs = this.buildAttributes({
       src: resolvedSrc,
       ...attributes
@@ -161,8 +251,11 @@ class AssetManager {
   /**
    * Generate image tag
    */
-  img(src, alt = '', attributes = {}) {
+  img(src, alt = '', attributes) {
     const resolvedSrc = this.resolve(src);
+    if (!attributes || Object.keys(attributes).length === 0) {
+      return `<img src="${this.escapeHtml(resolvedSrc)}" alt="${this.escapeHtml(alt)}">`;
+    }
     const attrs = this.buildAttributes({
       src: resolvedSrc,
       alt,
@@ -325,6 +418,9 @@ class AssetManager {
    */
   hasPageJs(name) {
     if (!name || typeof name !== 'string') return false;
+    const cached = this._hasJsCache.get(name);
+    if (cached !== undefined) return cached;
+
     let clean = String(name).trim().replace(/^\/+/, '');
     if (clean.startsWith('pages/')) clean = clean.slice(6);
     if (clean.startsWith('dist/pages/')) clean = clean.slice(11);
@@ -343,6 +439,7 @@ class AssetManager {
         this.manifest['src/client/' + pagePath] ||
         this.manifest['client/' + pagePath]
       ) {
+        if (this._hasJsCache.size < 500) this._hasJsCache.set(name, true);
         return true;
       }
     }
@@ -369,13 +466,13 @@ class AssetManager {
     ];
 
     for (const p of diskChecks) {
-      try {
-        if (fs.existsSync(p)) {
-          return true;
-        }
-      } catch (_) {}
+      if (cachedExistsSync(p)) {
+        if (this._hasJsCache.size < 500) this._hasJsCache.set(name, true);
+        return true;
+      }
     }
 
+    if (this._hasJsCache.size < 500) this._hasJsCache.set(name, false);
     return false;
   }
 
@@ -386,6 +483,9 @@ class AssetManager {
    */
   hasPageCss(name) {
     if (!name || typeof name !== 'string') return false;
+    const cached = this._hasCssCache.get(name);
+    if (cached !== undefined) return cached;
+
     let clean = String(name).trim().replace(/^\/+/, '');
     if (clean.startsWith('pages/')) clean = clean.slice(6);
     if (clean.startsWith('dist/pages/')) clean = clean.slice(11);
@@ -404,6 +504,7 @@ class AssetManager {
         this.manifest['src/client/' + pagePath] ||
         this.manifest['client/' + pagePath]
       ) {
+        if (this._hasCssCache.size < 500) this._hasCssCache.set(name, true);
         return true;
       }
     }
@@ -426,13 +527,13 @@ class AssetManager {
     ];
 
     for (const p of diskChecks) {
-      try {
-        if (fs.existsSync(p)) {
-          return true;
-        }
-      } catch (_) {}
+      if (cachedExistsSync(p)) {
+        if (this._hasCssCache.size < 500) this._hasCssCache.set(name, true);
+        return true;
+      }
     }
 
+    if (this._hasCssCache.size < 500) this._hasCssCache.set(name, false);
     return false;
   }
 
@@ -507,16 +608,28 @@ class AssetManager {
    * Build HTML attributes string
    */
   buildAttributes(attrs) {
-    return Object.entries(attrs)
-      .filter(([k, v]) => v !== undefined && v !== null && v !== false && /^[a-zA-Z0-9_\-:]+$/.test(k))
-      .map(([k, v]) => v === true ? k : `${k}="${this.escapeHtml(String(v))}"`)
-      .join(' ');
+    if (!attrs || typeof attrs !== 'object') return '';
+    let result = '';
+    const keys = Object.keys(attrs);
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i];
+      const v = attrs[k];
+      if (v === undefined || v === null || v === false || !/^[a-zA-Z0-9_\-:]+$/.test(k)) {
+        continue;
+      }
+      if (result) result += ' ';
+      result += v === true ? k : `${k}="${this.escapeHtml(String(v))}"`;
+    }
+    return result;
   }
   
   /**
    * Escape HTML special characters
    */
   escapeHtml(str) {
+    if (!str || typeof str !== 'string' || !/[&"'<>]/.test(str)) {
+      return str;
+    }
     return str
       .replace(/&/g, '&amp;')
       .replace(/"/g, '&quot;')

package/src/plugin-manager.js

@@ -7,20 +7,29 @@
  * Simple semver comparison utilities
  * (Lightweight alternative to full semver package)
  */
+const semverCache = new Map();
+
 const semver = {
   /**
    * Parse version string to components
    */
   parse(version) {
     if (!version) return null;
+    const cached = semverCache.get(version);
+    if (cached !== undefined) return cached;
     const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/);
-    if (!match) return null;
-    return {
+    if (!match) {
+      if (semverCache.size < 200) semverCache.set(version, null);
+      return null;
+    }
+    const parsed = {
       major: parseInt(match[1], 10),
       minor: parseInt(match[2], 10),
       patch: parseInt(match[3], 10),
       prerelease: match[4] || null
     };
+    if (semverCache.size < 200) semverCache.set(version, parsed);
+    return parsed;
   },
 
   /**
@@ -93,21 +102,29 @@ const semver = {
   }
 };
 
+const patternRegexCache = new Map();
+
 /**
  * Simple glob/minimatch pattern matching
  */
 function matchPattern(path, pattern) {
   if (pattern === '*' || pattern === '**') return true;
   
-  // Convert glob to regex
-  const regexPattern = pattern
-    .replace(/[.+^${}()|[\]\\]/g, '\\$&')  // Escape special regex chars
-    .replace(/\*\*/g, '{{GLOBSTAR}}')       // Temp placeholder for **
-    .replace(/\*/g, '[^/]*')                // * matches anything except /
-    .replace(/\{\{GLOBSTAR\}\}/g, '.*')     // ** matches everything
-    .replace(/\?/g, '.');                   // ? matches single char
-
-  const regex = new RegExp(`^${regexPattern}$`);
+  let regex = patternRegexCache.get(pattern);
+  if (!regex) {
+    // Convert glob to regex
+    const regexPattern = pattern
+      .replace(/[.+^${}()|[\]\\]/g, '\\$&')  // Escape special regex chars
+      .replace(/\*\*/g, '{{GLOBSTAR}}')       // Temp placeholder for **
+      .replace(/\*/g, '[^/]*')                // * matches anything except /
+      .replace(/\{\{GLOBSTAR\}\}/g, '.*')     // ** matches everything
+      .replace(/\?/g, '.');                   // ? matches single char
+
+    regex = new RegExp(`^${regexPattern}$`);
+    if (patternRegexCache.size < 500) {
+      patternRegexCache.set(pattern, regex);
+    }
+  }
   return regex.test(path);
 }
 
@@ -206,6 +223,8 @@ class PluginManager {
    * Resolve dependency order using topological sort
    */
   _resolveDependencyOrder(plugins) {
+    if (!plugins || plugins.length === 0) return [];
+
     const graph = new Map();
     const pluginMap = new Map();
 
@@ -228,6 +247,7 @@ class PluginManager {
 
     // Topological sort (Kahn's algorithm)
     const sorted = [];
+    const sortedNames = new Set();
     const noIncoming = [];
 
     // Find nodes with no dependencies
@@ -243,12 +263,13 @@ class PluginManager {
     while (noIncoming.length > 0) {
       const name = noIncoming.shift();
       sorted.push(pluginMap.get(name));
+      sortedNames.add(name);
 
       // Remove this node from all dependencies
       for (const [n, deps] of graph) {
         if (deps.has(name)) {
           deps.delete(name);
-          if (deps.size === 0 && !sorted.find(p => p.name === n)) {
+          if (deps.size === 0 && !sortedNames.has(n)) {
             noIncoming.push(n);
           }
         }
@@ -257,7 +278,7 @@ class PluginManager {
 
     // Check for cycles - warn and exclude circular plugins
     if (sorted.length !== pluginMap.size) {
-      const remaining = Array.from(pluginMap.keys()).filter(name => !sorted.find(p => p.name === name));
+      const remaining = Array.from(pluginMap.keys()).filter(name => !sortedNames.has(name));
       console.warn(
         `[plugin-manager] Circular dependency detected. Skipping plugins: ${remaining.join(', ')}`
       );

package/src/routing/route-table.js

@@ -6,19 +6,24 @@
  * @module src/routing/route-table
  */
 
+const routeSortMetaCache = new Map();
+
 /**
  * Computes route sorting priority metadata
  * @param {string} routePath
  * @returns {{ tier: number, literalSegCount: number, paramSegCount: number, depth: number, routePath: string }}
  */
 function getRouteSortMeta(routePath) {
+  const cached = routeSortMetaCache.get(routePath);
+  if (cached !== undefined) return cached;
+
   let hasStar = false;
   let hasColon = false;
   let depth = 0;
   let literalSegCount = 0;
   let paramSegCount = 0;
 
-  const clean = routePath.split('?')[0];
+  const clean = routePath.includes('?') ? routePath.split('?')[0] : routePath;
   const segments = clean.split('/').filter(Boolean);
 
   for (const seg of segments) {
@@ -40,13 +45,18 @@ function getRouteSortMeta(routePath) {
   if (hasStar) tier = 2;
   else if (hasColon) tier = 1;
 
-  return {
+  const meta = {
     tier,
     literalSegCount,
     paramSegCount,
     depth,
     routePath,
   };
+
+  if (routeSortMetaCache.size < 1000) {
+    routeSortMetaCache.set(routePath, meta);
+  }
+  return meta;
 }
 
 /**
@@ -56,8 +66,8 @@ function getRouteSortMeta(routePath) {
  * @returns {number}
  */
 function compareRouteOrder(a, b) {
-  const ma = a._sortMeta || getRouteSortMeta(a.path);
-  const mb = b._sortMeta || getRouteSortMeta(b.path);
+  const ma = a._sortMeta || (a._sortMeta = getRouteSortMeta(a.path));
+  const mb = b._sortMeta || (b._sortMeta = getRouteSortMeta(b.path));
 
   if (ma.tier !== mb.tier) return ma.tier - mb.tier;
   if (ma.literalSegCount !== mb.literalSegCount) return mb.literalSegCount - ma.literalSegCount;

package/src/server.js

@@ -54,6 +54,19 @@ const {
 // Async storage for tracking template render call stacks (circular extends guard)
 const renderStackStorage = new AsyncLocalStorage();
 
+let isWebspressoPackageCache = null;
+function checkIsWebspressoPackage() {
+  if (isWebspressoPackageCache === null) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf8'));
+      isWebspressoPackageCache = Boolean(pkg && pkg.name === 'webspresso');
+    } catch (_) {
+      isWebspressoPackageCache = false;
+    }
+  }
+  return isWebspressoPackageCache;
+}
+
 /**
  * Fast hardware-accelerated Weak ETag generator using native zlib.crc32
  * Up to 13x faster than Express default SHA-1, zero external dependencies.
@@ -91,6 +104,7 @@ function fastETag(body, encoding) {
  */
 function normalizeTemplateName(name) {
   if (typeof name !== 'string') return name;
+  if (!name.includes('\\') && !name.includes('views')) return name;
   let normalized = name.replace(/\\/g, '/');
   // Collapse any repeated views/views/... to a single views/ or clean path
   while (/(?:^|\/)views\/(?:\.\/)?views(?:\/|$)/.test(normalized)) {
@@ -102,6 +116,7 @@ function normalizeTemplateName(name) {
 function canonicalTemplateKey(name) {
   const norm = normalizeTemplateName(name);
   if (typeof norm !== 'string') return String(norm);
+  if (!norm.startsWith('.') && !norm.startsWith('views/')) return norm;
   // Canonical key strips leading ./ or views/ for cycle detection
   return norm.replace(/^\.\//, '').replace(/^views\//, '');
 }
@@ -591,10 +606,7 @@ function createApp(options = {}) {
 
   const rootDir = options.rootDir || (() => {
     if (process.env.NODE_ENV === 'test') {
-      try {
-        const pkg = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf8'));
-        if (pkg.name === 'webspresso') return process.cwd();
-      } catch (_) {}
+      if (checkIsWebspressoPackage()) return process.cwd();
       return path.resolve(__dirname, '..');
     }
     return process.cwd();
@@ -875,9 +887,13 @@ function createApp(options = {}) {
     for (let i = 0; i < paramNames.length; i++) {
       const val = match[i + 1];
       if (val !== undefined) {
-        try {
-          params[paramNames[i]] = decodeURIComponent(val);
-        } catch (_) {
+        if (typeof val === 'string' && val.includes('%')) {
+          try {
+            params[paramNames[i]] = decodeURIComponent(val);
+          } catch (_) {
+            params[paramNames[i]] = val;
+          }
+        } else {
           params[paramNames[i]] = val;
         }
       }

package/src/services/validator.js

@@ -8,12 +8,17 @@ const { ValidationError } = require('../../core/errors');
 const { z: zForServices, sanitizeInput, hasDangerousKeys } = require('../../core/validation');
 const z = zForServices;
 
+const descriptorCache = new Map();
+
 /**
  * Compile a concise type string descriptor into a Zod schema
  * @param {string} typeName - Type name descriptor (e.g. 'number', 'string', 'email', 'string?')
  * @returns {z.ZodTypeAny}
  */
 function descriptorToZod(typeName) {
+  const cached = descriptorCache.get(typeName);
+  if (cached) return cached;
+
   const isOptional = typeName.endsWith('?');
   const baseType = isOptional ? typeName.slice(0, -1).toLowerCase() : typeName.toLowerCase();
 
@@ -60,9 +65,15 @@ function descriptorToZod(typeName) {
       break;
   }
 
-  return isOptional ? schema.optional() : schema;
+  const finalSchema = isOptional ? schema.optional() : schema;
+  if (descriptorCache.size < 200) {
+    descriptorCache.set(typeName, finalSchema);
+  }
+  return finalSchema;
 }
 
+const compiledSchemaCache = new WeakMap();
+
 /**
  * Compile service schema definition into an executable validator
  * @param {Function|Object|null} rawSchema - Schema definition
@@ -71,50 +82,64 @@ function descriptorToZod(typeName) {
 function compileServiceSchema(rawSchema) {
   if (!rawSchema) return null;
 
-  // If already a Zod schema
-  if (rawSchema instanceof z.ZodType || typeof rawSchema.safeParse === 'function') {
-    return rawSchema;
+  if (typeof rawSchema === 'object' || typeof rawSchema === 'function') {
+    const cached = compiledSchemaCache.get(rawSchema);
+    if (cached !== undefined) {
+      return cached;
+    }
   }
 
-  // If function: check if ({ z }) schema compiler or custom validator function
-  if (typeof rawSchema === 'function') {
+  let compiled = null;
+
+  // If already a Zod schema
+  if (rawSchema instanceof z.ZodType || typeof rawSchema.safeParse === 'function') {
+    compiled = rawSchema;
+  } else if (typeof rawSchema === 'function') {
+    // If function: check if ({ z }) schema compiler or custom validator function
     try {
-      const compiled = rawSchema({ z: zForServices });
-      if (compiled && (compiled instanceof z.ZodType || typeof compiled.safeParse === 'function')) {
-        return compiled;
+      const res = rawSchema({ z: zForServices });
+      if (res && (res instanceof z.ZodType || typeof res.safeParse === 'function')) {
+        compiled = res;
       }
     } catch (e) {
       // If invoking with { z } throws, treat as a direct validator function
     }
-    return rawSchema;
-  }
-
-  // If object descriptor: { id: 'number', name: 'string', email: 'email' }
-  if (typeof rawSchema === 'object' && rawSchema !== null) {
+    if (!compiled) {
+      compiled = rawSchema;
+    }
+  } else if (typeof rawSchema === 'object' && rawSchema !== null) {
+    // If object descriptor: { id: 'number', name: 'string', email: 'email' }
     const keys = Object.keys(rawSchema);
     if (keys.length === 0) {
-      return null;
-    }
-    const shape = {};
-    for (const [key, val] of Object.entries(rawSchema)) {
-      if (typeof val === 'string') {
-        shape[key] = descriptorToZod(val);
-      } else if (val instanceof z.ZodType || (val && typeof val.safeParse === 'function')) {
-        shape[key] = val;
-      } else if (typeof val === 'object' && val !== null) {
-        const isOpt = val.optional === true || val.required === false;
-        let base = val.type ? descriptorToZod(String(val.type)) : z.any();
-        shape[key] = isOpt ? base.optional() : base;
-      } else if (typeof val === 'function') {
-        shape[key] = z.custom(val);
-      } else {
-        shape[key] = z.any();
+      compiled = null;
+    } else {
+      const shape = {};
+      for (const [key, val] of Object.entries(rawSchema)) {
+        if (typeof val === 'string') {
+          shape[key] = descriptorToZod(val);
+        } else if (val instanceof z.ZodType || (val && typeof val.safeParse === 'function')) {
+          shape[key] = val;
+        } else if (typeof val === 'object' && val !== null) {
+          const isOpt = val.optional === true || val.required === false;
+          let base = val.type ? descriptorToZod(String(val.type)) : z.any();
+          shape[key] = isOpt ? base.optional() : base;
+        } else if (typeof val === 'function') {
+          shape[key] = z.custom(val);
+        } else {
+          shape[key] = z.any();
+        }
       }
+      compiled = z.object(shape);
     }
-    return z.object(shape);
+  } else {
+    compiled = rawSchema;
+  }
+
+  if (typeof rawSchema === 'object' || typeof rawSchema === 'function') {
+    compiledSchemaCache.set(rawSchema, compiled);
   }
 
-  return rawSchema;
+  return compiled;
 }
 
 /**