webspresso 0.0.73 → 0.0.75

package/src/file-router.js

@@ -9,6 +9,12 @@ const { ZodError } = require('zod');
 const { compileSchema, invalidateSchema } = require('../core/compileSchema');
 const { applySchema } = require('../core/applySchema');
 const { createHelpers } = require('./helpers');
+const {
+  loadNjkRouteTemplate,
+  parseNjkFrontmatter,
+  frontmatterToPatches,
+  clearNjkFrontmatterCaches,
+} = require('./njk-frontmatter');
 
 // Cache for i18n files (key: filePath, value: { mtime, data })
 const i18nCache = new Map();
@@ -22,6 +28,89 @@ const routeConfigDevCache = new Map();
 // Cache for API filename -> { method, baseName } (basename keys; stable per process)
 const methodFromFilenameCache = new Map();
 
+const MAX_LOCALE_LEN = 16;
+
+/** @returns {Set<string>} */
+function parseSupportedLocaleSet() {
+  const raw = process.env.SUPPORTED_LOCALES || 'en';
+  return new Set(
+    raw.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean)
+  );
+}
+
+/**
+ * @param {string} raw
+ * @returns {string|null}
+ */
+function normalizeLocaleCandidate(raw) {
+  let s = String(raw).trim().toLowerCase().split(';')[0].split(',')[0].trim().replace(/_/g, '-');
+  if (s.length < 1 || s.length > MAX_LOCALE_LEN) {
+    return null;
+  }
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(s)) {
+    return null;
+  }
+  return s;
+}
+
+/**
+ * @param {string|null} normalized
+ * @param {Set<string>} supported
+ * @returns {string|null}
+ */
+function pickMatchingLocale(normalized, supported) {
+  if (!normalized) {
+    return null;
+  }
+  if (supported.has(normalized)) {
+    return normalized;
+  }
+  const base = normalized.split('-')[0];
+  if (supported.has(base)) {
+    return base;
+  }
+  return null;
+}
+
+/**
+ * Linear-time conversion of [...x] → * then [x] → :x (filesystem route segments only).
+ * @param {string} route
+ */
+function rewriteDynamicRouteMarkers(route) {
+  let i = 0;
+  let out = '';
+  const n = route.length;
+  while (i < n) {
+    const open = route.indexOf('[', i);
+    if (open === -1) {
+      out += route.slice(i);
+      break;
+    }
+    out += route.slice(i, open);
+    const close = route.indexOf(']', open + 1);
+    if (close === -1) {
+      out += route.slice(open);
+      break;
+    }
+    const inner = route.slice(open + 1, close);
+    let repl;
+    if (inner.startsWith('...') && inner.length > 3) {
+      repl = '*';
+    } else if (inner.length > 0 && inner.indexOf('[') === -1) {
+      repl = ':' + inner;
+    } else {
+      repl = route.slice(open, close + 1);
+    }
+    out += repl;
+    i = close + 1;
+  }
+  return out;
+}
+
+function escapeRegExp(s) {
+  return String(s).replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+
 /**
  * Convert a file path to an Express route pattern
  * @param {string} filePath - Relative path from pages/
@@ -43,12 +132,9 @@ function filePathToRoute(filePath, ext) {
     route = '/';
   }
   
-  // Convert [param] to :param
-  route = route.replace(/\[([^\]\.]+)\]/g, ':$1');
-  
-  // Convert [...param] to * (catch-all)
-  route = route.replace(/\[\.\.\.([^\]]+)\]/g, '*');
-  
+  // Convert [param] / [...param] without regex backtracking hazards
+  route = rewriteDynamicRouteMarkers(route);
+
   // Ensure leading slash
   if (!route.startsWith('/')) {
     route = '/' + route;
@@ -65,27 +151,50 @@ function filePathToRoute(filePath, ext) {
  * @returns {{ tier: number, literalSegCount: number, paramSegCount: number, depth: number, routePath: string }}
  */
 function routeRegistrationMeta(routePath) {
-  const hasCatchAll = routePath.includes('*');
-  const hasDynamic = routePath.includes(':');
-  let tier;
-  if (hasCatchAll) tier = 2;
-  else if (hasDynamic) tier = 1;
-  else tier = 0;
-
-  const segments = routePath.split('/').filter(Boolean);
+  let pathHasStar = false;
+  let pathHasColon = false;
+  let depth = 0;
   let literalSegCount = 0;
   let paramSegCount = 0;
-  for (const seg of segments) {
-    if (seg === '*' || (seg.length > 0 && seg.includes('*'))) continue;
-    if (seg.includes(':')) paramSegCount += 1;
+
+  const s = routePath;
+  const n = s.length;
+  let i = 0;
+  while (i < n) {
+    while (i < n && s.charCodeAt(i) === 47 /* / */) i++;
+    if (i >= n) break;
+    const start = i;
+    while (i < n && s.charCodeAt(i) !== 47) i++;
+
+    depth++;
+    let segHasStar = false;
+    let segHasColon = false;
+    for (let j = start; j < i; j++) {
+      const c = s.charCodeAt(j);
+      if (c === 42 /* * */) segHasStar = true;
+      else if (c === 58 /* : */) segHasColon = true;
+    }
+    if (segHasStar) pathHasStar = true;
+    if (segHasColon) pathHasColon = true;
+
+    if (segHasStar) {
+      // Same as: seg === '*' || (seg.length > 0 && seg.includes('*'))
+      continue;
+    }
+    if (segHasColon) paramSegCount += 1;
     else literalSegCount += 1;
   }
 
+  let tier;
+  if (pathHasStar) tier = 2;
+  else if (pathHasColon) tier = 1;
+  else tier = 0;
+
   return {
     tier,
     literalSegCount,
     paramSegCount,
-    depth: segments.length,
+    depth,
     routePath,
   };
 }
@@ -140,6 +249,69 @@ function extractMethodFromFilename(filename) {
   return result;
 }
 
+/**
+ * Whether `load()` return values for `stylesheets` and `scripts` are promoted to
+ * `pageHead` in Nunjucks (see `createApp({ pageAssets })`).
+ * @param {boolean|{enabled?: boolean, stylesheets?: boolean, scripts?: boolean}|null|undefined} raw
+ * @returns {{ enabled: boolean, stylesheets: boolean, scripts: boolean }}
+ */
+function resolvePageAssets(raw) {
+  if (raw === true) {
+    return { enabled: true, stylesheets: true, scripts: true };
+  }
+  if (raw == null || raw === false) {
+    return { enabled: false, stylesheets: false, scripts: false };
+  }
+  if (typeof raw === 'object') {
+    const on = raw.enabled !== false;
+    if (!on) {
+      return { enabled: false, stylesheets: false, scripts: false };
+    }
+    return {
+      enabled: true,
+      stylesheets: raw.stylesheets !== false,
+      scripts: raw.scripts !== false,
+    };
+  }
+  return { enabled: false, stylesheets: false, scripts: false };
+}
+
+/**
+ * @param {unknown} v
+ * @returns {unknown[]}
+ */
+function toList(v) {
+  if (v == null) return [];
+  return Array.isArray(v) ? v : [v];
+}
+
+/**
+ * @param {{ enabled: boolean, stylesheets: boolean, scripts: boolean }} cfg
+ * @param {Object} data
+ * @returns {{ data: Object, pageHead: { stylesheets: unknown[], scripts: unknown[] }|null, pageAssets: boolean }}
+ */
+function applyPageAssetsToTemplateData(cfg, data) {
+  if (!cfg || !cfg.enabled) {
+    return { data, pageHead: null, pageAssets: false };
+  }
+  const out = { ...data };
+  let styles = [];
+  let scriptItems = [];
+  if (cfg.stylesheets && Object.prototype.hasOwnProperty.call(out, 'stylesheets')) {
+    styles = toList(out.stylesheets);
+    delete out.stylesheets;
+  }
+  if (cfg.scripts && Object.prototype.hasOwnProperty.call(out, 'scripts')) {
+    scriptItems = toList(out.scripts);
+    delete out.scripts;
+  }
+  return {
+    data: out,
+    pageHead: { stylesheets: styles, scripts: scriptItems },
+    pageAssets: true,
+  };
+}
+
 /**
  * Recursively scan a directory for files
  * @param {string} dir - Directory to scan
@@ -197,7 +369,7 @@ function loadI18nFile(filePath) {
     i18nCache.set(filePath, { mtime: stats.mtimeMs, data });
     return data;
   } catch (err) {
-    console.error(`Error loading i18n file ${filePath}:`, err.message);
+    console.error('Error loading i18n file:', filePath, err.message);
     return {};
   }
 }
@@ -252,7 +424,8 @@ function createTranslator(translations) {
     // Replace params like {{name}} in the translation
     if (typeof value === 'string' && Object.keys(params).length > 0) {
       for (const [paramKey, paramValue] of Object.entries(params)) {
-        value = value.replace(new RegExp(`{{\\s*${paramKey}\\s*}}`, 'g'), paramValue);
+        const escaped = escapeRegExp(paramKey);
+        value = value.replace(new RegExp(`{{\\s*${escaped}\\s*}}`, 'g'), paramValue);
       }
     }
     
@@ -295,7 +468,7 @@ function loadRouteConfig(configPath, isDev) {
     configCache.set(configPath, config);
     return config;
   } catch (err) {
-    console.error(`Error loading route config ${configPath}:`, err.message);
+    console.error('Error loading route config:', configPath, err.message);
     return null;
   }
 }
@@ -317,9 +490,9 @@ function loadGlobalHooks(pagesDir, isDev) {
  * @param {string} hookName - Hook name
  * @param {Object} ctx - Context object
  */
-async function executeHook(hooks, hookName, ctx) {
+async function executeHook(hooks, hookName, ctx, ...extra) {
   if (hooks && typeof hooks[hookName] === 'function') {
-    await hooks[hookName](ctx);
+    await hooks[hookName](ctx, ...extra);
   }
 }
 
@@ -329,23 +502,32 @@ async function executeHook(hooks, hookName, ctx) {
  * @returns {string} Locale code
  */
 function detectLocale(req) {
-  // 1. Check query parameter
-  if (req.query.lang) {
-    return req.query.lang;
+  const supported = parseSupportedLocaleSet();
+  const defaultCand = normalizeLocaleCandidate(process.env.DEFAULT_LOCALE || 'en');
+  const def =
+    pickMatchingLocale(defaultCand, supported)
+    ?? (supported.has('en') ? 'en' : [...supported][0])
+    ?? 'en';
+
+  if (req.query && req.query.lang != null && req.query.lang !== '') {
+    const q = normalizeLocaleCandidate(String(req.query.lang));
+    const hit = pickMatchingLocale(q, supported);
+    if (hit) {
+      return hit;
+    }
   }
-  
-  // 2. Check Accept-Language header
+
   const acceptLanguage = req.get('Accept-Language');
   if (acceptLanguage) {
-    const supported = (process.env.SUPPORTED_LOCALES || 'en').split(',');
-    const preferred = acceptLanguage.split(',')[0].split('-')[0].toLowerCase();
-    if (supported.includes(preferred)) {
-      return preferred;
+    const langPart = acceptLanguage.split(',')[0];
+    const a = normalizeLocaleCandidate(langPart);
+    const hit = pickMatchingLocale(a, supported);
+    if (hit) {
+      return hit;
     }
   }
-  
-  // 3. Default locale
-  return process.env.DEFAULT_LOCALE || 'en';
+
+  return def;
 }
 
 /**
@@ -439,6 +621,7 @@ function resolveMiddlewares(middlewareConfig, middlewareRegistry = {}) {
  * @param {boolean} options.silent - Suppress console output
  * @param {Object} options.db - Database instance (exposed as ctx.db in load/meta)
  * @param {{ alpine?: boolean, swup?: boolean }} [options.clientRuntime] - Passed to Nunjucks as `clientRuntime` (default both false)
+ * @param {boolean|{enabled?: boolean, stylesheets?: boolean, scripts?: boolean}} [options.pageAssets] - If set, `load()` may return `stylesheets` / `scripts` promoted to `pageHead` in templates
  * @returns {Array} Route metadata for plugins
  */
 function mountPages(app, options) {
@@ -450,7 +633,9 @@ function mountPages(app, options) {
     silent = false,
     db = null,
     clientRuntime: clientRuntimeOpt = null,
+    pageAssets: pageAssetsOpt = null,
   } = options;
+  const pageAssetsResolved = resolvePageAssets(pageAssetsOpt);
   const clientRuntime = clientRuntimeOpt && typeof clientRuntimeOpt === 'object'
     ? { alpine: !!clientRuntimeOpt.alpine, swup: !!clientRuntimeOpt.swup }
     : { alpine: false, swup: false };
@@ -485,7 +670,7 @@ function mountPages(app, options) {
       apiRoutes.push({
         file,
         method,
-        routePath: filePathToRoute(routePath.replace(/^\/api/, '/api'), ''),
+        routePath: filePathToRoute(routePath, ''),
         fullPath: path.join(absolutePagesDir, file)
       });
     } else if (ext === '.njk') {
@@ -520,6 +705,10 @@ function mountPages(app, options) {
     const handler = require(route.fullPath);
     const handlerFn = typeof handler === 'function' ? handler : handler.default || handler.handler;
     const routeMiddleware = handler.middleware;
+
+    const preResolvedMw = routeMiddleware
+      ? resolveMiddlewares(routeMiddleware, middlewares)
+      : [];
     
     if (typeof handlerFn !== 'function') {
       console.warn(`API route ${route.file} does not export a function`);
@@ -568,11 +757,9 @@ function mountPages(app, options) {
           throw err;
         }
         
-        // Run middleware if defined
-        const mwConfig = isDev ? currentHandler.middleware : routeMiddleware;
-        if (mwConfig) {
-          const resolvedMw = resolveMiddlewares(mwConfig, middlewares);
-          for (const mw of resolvedMw) {
+        // Run middleware if defined (resolved at route registration — required for stateful middleware like express-rate-limit)
+        if (preResolvedMw.length) {
+          for (const mw of preResolvedMw) {
             await new Promise((resolve, reject) => {
               mw(req, res, (err) => {
                 if (err) reject(err);
@@ -585,7 +772,13 @@ function mountPages(app, options) {
         await fn(req, res, next);
       } catch (err) {
         console.error(`API error ${route.routePath}:`, err);
-        res.status(500).json({ error: 'Internal Server Error' });
+        const hookCtx = { req, res, error: err };
+        try {
+          await executeHook(globalHooks, 'onError', hookCtx, err);
+        } catch (hookErr) {
+          console.error('Error in onError hook:', hookErr);
+        }
+        return next(err);
       }
     });
     
@@ -596,6 +789,11 @@ function mountPages(app, options) {
   /** Register SSR GET routes (shared by static phase and dynamic phase). */
   const registerSsrRoutes = (routes) => {
     for (const route of routes) {
+    const mountConfig = loadRouteConfig(route.configPath, isDev);
+    const preResolvedPageMw = mountConfig?.middleware
+      ? resolveMiddlewares(mountConfig.middleware, middlewares)
+      : [];
+
     app.get(route.routePath, async (req, res, next) => {
       try {
         // Detect locale
@@ -613,6 +811,8 @@ function mountPages(app, options) {
         const baseHelpers = createHelpers({ req, res, locale });
         const pluginHelpers = pluginManager ? pluginManager.getHelpers() : {};
         
+        const njkTpl = loadNjkRouteTemplate(route.fullPath, isDev);
+
         const ctx = {
           req,
           res,
@@ -622,12 +822,13 @@ function mountPages(app, options) {
           routeDir: route.routeDir,
           locale,
           t,
-          data: {},
+          data: { ...njkTpl.dataPatch },
           meta: {
             title: t('meta.title') !== 'meta.title' ? t('meta.title') : null,
             description: t('meta.description') !== 'meta.description' ? t('meta.description') : null,
             indexable: true,
-            canonical: null
+            canonical: null,
+            ...njkTpl.metaPatch,
           },
           fsy: { ...baseHelpers, ...pluginHelpers },
           clientRuntime,
@@ -645,10 +846,9 @@ function mountPages(app, options) {
         await executeHook(globalHooks, 'beforeMiddleware', ctx);
         await executeHook(routeHooks, 'beforeMiddleware', ctx);
         
-        // Run route middleware
-        if (config?.middleware) {
-          const resolvedMiddlewares = resolveMiddlewares(config.middleware, middlewares);
-          for (const mw of resolvedMiddlewares) {
+        // Run route middleware (chain fixed at route registration; edit middleware in dev → restart)
+        if (preResolvedPageMw.length) {
+          for (const mw of preResolvedPageMw) {
             await new Promise((resolve, reject) => {
               mw(req, res, (err) => {
                 if (err) reject(err);
@@ -686,9 +886,9 @@ function mountPages(app, options) {
         await executeHook(globalHooks, 'beforeRender', ctx);
         await executeHook(routeHooks, 'beforeRender', ctx);
         
-        // Render the template
-        const templatePath = route.file.split(path.sep).join('/');
-        const html = nunjucks.render(templatePath, {
+        const pageAssetBundle = applyPageAssetsToTemplateData(pageAssetsResolved, ctx.data);
+        ctx.data = pageAssetBundle.data;
+        const renderContext = {
           ...ctx.data,
           meta: ctx.meta,
           locale: ctx.locale,
@@ -700,7 +900,18 @@ function mountPages(app, options) {
             query: req.query,
             params: req.params
           }
-        });
+        };
+        if (pageAssetBundle.pageAssets) {
+          renderContext.pageAssets = true;
+          renderContext.pageHead = pageAssetBundle.pageHead;
+        }
+        
+        // Render the template
+        const templatePath = route.file.split(path.sep).join('/');
+        const html =
+          njkTpl.useStringRender && njkTpl.templateBody != null
+            ? nunjucks.renderString(njkTpl.templateBody, renderContext, { path: route.fullPath })
+            : nunjucks.render(templatePath, renderContext);
         
         // Execute hooks: afterRender
         ctx.html = html;
@@ -719,7 +930,7 @@ function mountPages(app, options) {
           console.error('Error in onError hook:', hookErr);
         }
         
-        res.status(500).send('Internal Server Error');
+        return next(err);
       }
     });
     
@@ -769,5 +980,11 @@ module.exports = {
   resolveMiddlewares,
   routeRegistrationMeta,
   compareRouteRegistrationOrder,
+  resolvePageAssets,
+  applyPageAssetsToTemplateData,
+  parseNjkFrontmatter,
+  frontmatterToPatches,
+  loadNjkRouteTemplate,
+  clearNjkFrontmatterCaches,
 };
 

package/src/njk-frontmatter.js

@@ -0,0 +1,156 @@
+/**
+ * YAML frontmatter for pages/*.njk (optional).
+ * Opens with --- … --- at file top; merges into ctx.meta / ctx.data before route hooks/load.
+ */
+
+const fs = require('fs');
+const { parse } = require('yaml');
+
+const FRONTMATTER_BLOCK = /^---\r?\n([\s\S]*?)\r?\n---\r?\n/;
+
+/** @typedef {{ metaPatch: Record<string, unknown>, dataPatch: Record<string, unknown> }} Patch */
+
+const prodRouteCache = new Map();
+/** @type {Map<string, { mtimeMs: number, cached: LoadedNjk }>} */
+const devRouteCache = new Map();
+
+/** @typedef {{ useStringRender: boolean, templateBody: string|null, metaPatch: Record<string, unknown>, dataPatch: Record<string, unknown> }} LoadedNjk */
+
+/**
+ * @param {string} raw
+ * @returns {{ body: string, yamlText: string|null, extracted: boolean }}
+ */
+function extractFrontmatterBlock(raw) {
+  const strippedBom = raw.replace(/^\uFEFF/, '');
+  const match = strippedBom.match(FRONTMATTER_BLOCK);
+  if (!match) {
+    return { body: strippedBom, yamlText: null, extracted: false };
+  }
+  const body = strippedBom.slice(match[0].length);
+  const yamlText = match[1] != null ? String(match[1]).trimEnd() : '';
+  return { body, yamlText, extracted: true };
+}
+
+/**
+ * @param {string} content Full .njk file contents
+ */
+function parseNjkFrontmatter(content) {
+  const { body, yamlText, extracted } = extractFrontmatterBlock(content);
+  if (!extracted || yamlText == null) {
+    return { body, fm: null, hasDelimiter: extracted };
+  }
+  if (yamlText === '') {
+    return { body, fm: {}, hasDelimiter: true };
+  }
+  try {
+    const fm = parse(yamlText);
+    return {
+      body,
+      fm: fm && typeof fm === 'object' && !Array.isArray(fm) ? fm : null,
+      hasDelimiter: true,
+    };
+  } catch (err) {
+    console.warn('[webspresso] .njk frontmatter YAML parse failed — rendering without fm meta:', err.message);
+    return { body, fm: null, hasDelimiter: true };
+  }
+}
+
+/**
+ * @param {unknown} fm
+ * @returns {Patch}
+ */
+function frontmatterToPatches(fm) {
+  if (!fm || typeof fm !== 'object' || Array.isArray(fm)) {
+    return { metaPatch: {}, dataPatch: {} };
+  }
+
+  /** @type {Record<string, unknown>} */
+  const metaPatch = {};
+  const fmObj = fm;
+  const nestedMeta = fmObj.meta;
+  if (nestedMeta && typeof nestedMeta === 'object' && !Array.isArray(nestedMeta)) {
+    Object.assign(metaPatch, nestedMeta);
+  }
+  for (const k of ['title', 'description', 'canonical', 'indexable']) {
+    if (Object.prototype.hasOwnProperty.call(fmObj, k) && fmObj[k] !== undefined) {
+      metaPatch[k] = fmObj[k];
+    }
+  }
+
+  /** @type {Record<string, unknown>} */
+  let dataPatch = {};
+  const d = fmObj.data;
+  if (d && typeof d === 'object' && !Array.isArray(d)) {
+    dataPatch = { ...d };
+  }
+
+  return { metaPatch, dataPatch };
+}
+
+/**
+ * @param {boolean} [isDevLike]
+ */
+function readAndParse(absPath, isDevLike = false) {
+  const raw = fs.readFileSync(absPath, 'utf8');
+  const { body, fm, hasDelimiter } = parseNjkFrontmatter(raw);
+  const patches = frontmatterToPatches(fm);
+
+  /** @type {LoadedNjk} */
+  const loaded = {
+    useStringRender: !!hasDelimiter,
+    templateBody: hasDelimiter ? body : null,
+    metaPatch: patches.metaPatch,
+    dataPatch: patches.dataPatch,
+  };
+
+  if (isDevLike) {
+    return loaded;
+  }
+  prodRouteCache.set(absPath, loaded);
+  return loaded;
+}
+
+/**
+ * @param {string} absPath Absolute path to pages/…/*.njk
+ * @param {boolean} isDev NODE_ENV !== 'production' style
+ */
+function loadNjkRouteTemplate(absPath, isDev) {
+  if (!fs.existsSync(absPath)) {
+    return {
+      useStringRender: false,
+      templateBody: null,
+      metaPatch: {},
+      dataPatch: {},
+    };
+  }
+
+  const stat = fs.statSync(absPath);
+
+  if (isDev) {
+    const prev = devRouteCache.get(absPath);
+    if (prev && prev.mtimeMs >= stat.mtimeMs) {
+      return prev.cached;
+    }
+    const fresh = readAndParse(absPath, true);
+    devRouteCache.set(absPath, { mtimeMs: stat.mtimeMs, cached: fresh });
+    return fresh;
+  }
+
+  if (prodRouteCache.has(absPath)) {
+    return prodRouteCache.get(absPath);
+  }
+  return readAndParse(absPath, false);
+}
+
+function clearNjkFrontmatterCaches() {
+  prodRouteCache.clear();
+  devRouteCache.clear();
+}
+
+module.exports = {
+  parseNjkFrontmatter,
+  frontmatterToPatches,
+  loadNjkRouteTemplate,
+  clearNjkFrontmatterCaches,
+  extractFrontmatterBlock,
+};

package/src/plugin-manager.js

@@ -130,7 +130,7 @@ class PluginManager {
   /**
    * Register plugins with the manager (async version)
    * @param {Array} plugins - Array of plugin definitions or factory functions
-   * @param {Object} context - Context object { app, nunjucksEnv, options }
+   * @param {Object} context - Context object `{ app, nunjucksEnv, options, middlewares? }`
    */
   async register(plugins, context) {
     if (!plugins || !Array.isArray(plugins)) return;
@@ -159,7 +159,7 @@ class PluginManager {
   /**
    * Register plugins with the manager (sync version)
    * @param {Array} plugins - Array of plugin definitions or factory functions
-   * @param {Object} context - Context object { app, nunjucksEnv, options }
+   * @param {Object} context - Context object `{ app, nunjucksEnv, options, middlewares? }`
    */
   registerSync(plugins, context) {
     if (!plugins || !Array.isArray(plugins)) return;
@@ -372,6 +372,8 @@ class PluginManager {
       options: plugin._options || {},
       nunjucksEnv: context.nunjucksEnv,
       db: context.options?.db ?? null,
+      /** @type {Record<string, unknown>} Named middleware registry (same reference as createApp → mountPages) */
+      middlewares: context.middlewares ?? {},
 
       /**
        * Get another plugin's API