webspresso 0.0.101 → 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/njk-frontmatter.js

@@ -4,7 +4,14 @@
  */
 
 const fs = require('fs');
-const { parse } = require('yaml');
+
+let _yamlParse = null;
+function getYamlParse() {
+  if (!_yamlParse) {
+    _yamlParse = require('yaml').parse;
+  }
+  return _yamlParse;
+}
 
 const FRONTMATTER_BLOCK = /^---\r?\n([\s\S]*?)\r?\n---\r?\n/;
 
@@ -43,6 +50,7 @@ function parseNjkFrontmatter(content) {
     return { body, fm: {}, hasDelimiter: true };
   }
   try {
+    const parse = getYamlParse();
     const fm = parse(yamlText);
     return {
       body,
@@ -171,6 +179,13 @@ function clearNjkFrontmatterCaches() {
   }
 }
 
+function seedProdRouteCache(entries) {
+  if (!entries || typeof entries !== 'object') return;
+  for (const [absPath, val] of Object.entries(entries)) {
+    prodRouteCache.set(absPath, val);
+  }
+}
+
 module.exports = {
   parseNjkFrontmatter,
   frontmatterToPatches,
@@ -178,4 +193,5 @@ module.exports = {
   clearNjkFrontmatterCaches,
   registerClearHook,
   extractFrontmatterBlock,
+  seedProdRouteCache,
 };

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(', ')}`
       );
@@ -669,6 +690,18 @@ class PluginManager {
    * Get a plugin's API by name
    */
   getPluginAPI(name) {
+    const plugin = this.plugins.get(name);
+    if (plugin && plugin.isLazy && typeof plugin.hydrate === 'function' && !plugin.isHydrated) {
+      const real = plugin.hydrate();
+      if (real && real.api) {
+        const boundAPI = {};
+        for (const [key, value] of Object.entries(real.api)) {
+          boundAPI[key] = typeof value === 'function' ? value.bind(real) : value;
+        }
+        this.pluginAPIs.set(name, boundAPI);
+      }
+      return this.pluginAPIs.get(name) || (real && real.api) || plugin.api;
+    }
     return this.pluginAPIs.get(name);
   }
 

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,14 +66,14 @@ 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;
   if (ma.depth !== mb.depth) return mb.depth - ma.depth;
   if (ma.paramSegCount !== mb.paramSegCount) return ma.paramSegCount - mb.paramSegCount;
-  return ma.routePath.localeCompare(mb.routePath);
+  return ma.routePath < mb.routePath ? -1 : (ma.routePath > mb.routePath ? 1 : 0);
 }
 
 /**