@nuraly/lumenjs 0.1.2 → 0.1.4

package/dist/dev-server/plugins/vite-plugin-storage.js

@@ -0,0 +1,126 @@
+import path from 'path';
+import fs from 'fs';
+import { LocalStorageAdapter } from '../../storage/adapters/local.js';
+import { setStorage } from '../../storage/index.js';
+/**
+ * LumenJS storage plugin (dev mode).
+ *
+ * - Creates a LocalStorageAdapter pointing to `{projectDir}/uploads`
+ * - Registers it as the global storage singleton (`useStorage()`)
+ * - Serves uploaded files at `/uploads/*`
+ * - Handles presigned PUT requests at `/__nk_storage/upload/:token`
+ */
+export function lumenStoragePlugin(projectDir) {
+    const uploadDir = path.join(projectDir, 'uploads');
+    const adapter = new LocalStorageAdapter({ uploadDir, publicPath: '/uploads' });
+    // Register global singleton so API routes and communication handlers can use it
+    setStorage(adapter);
+    return {
+        name: 'lumenjs-storage',
+        configureServer(server) {
+            // ── Presigned upload endpoint ──────────────────────────────
+            // Client sends a PUT to /__nk_storage/upload/:token with the (possibly
+            // encrypted) file body. The token was issued via adapter.presignPut().
+            server.middlewares.use('/__nk_storage/upload', async (req, res, next) => {
+                if (req.method !== 'PUT')
+                    return next();
+                const token = req.url?.replace(/^\//, '').split('?')[0];
+                if (!token) {
+                    res.statusCode = 400;
+                    res.end(JSON.stringify({ error: 'missing token' }));
+                    return;
+                }
+                const pending = adapter.consumeUpload(token);
+                if (!pending) {
+                    res.statusCode = 410; // Gone — expired or unknown token
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({ error: 'upload token expired or invalid' }));
+                    return;
+                }
+                // Read raw body with streaming size enforcement
+                const MAX_UPLOAD = pending.maxSize || 50 * 1024 * 1024; // 50MB default cap
+                const chunks = [];
+                let uploadSize = 0;
+                let aborted = false;
+                req.on('data', (c) => {
+                    uploadSize += c.length;
+                    if (uploadSize > MAX_UPLOAD) {
+                        aborted = true;
+                        req.destroy();
+                        res.statusCode = 413;
+                        res.setHeader('Content-Type', 'application/json');
+                        res.end(JSON.stringify({ error: 'file_too_large', maxSize: MAX_UPLOAD, received: uploadSize }));
+                        return;
+                    }
+                    chunks.push(c);
+                });
+                await new Promise((resolve, reject) => {
+                    req.on('end', resolve);
+                    req.on('error', reject);
+                });
+                if (aborted)
+                    return;
+                const body = Buffer.concat(chunks);
+                // Enforce maxSize if specified (redundant safety check)
+                if (pending.maxSize && body.length > pending.maxSize) {
+                    res.statusCode = 413;
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({
+                        error: `file_too_large`,
+                        maxSize: pending.maxSize,
+                        received: body.length,
+                    }));
+                    return;
+                }
+                // Write to disk (validate path stays within uploadDir)
+                const filePath = path.resolve(uploadDir, pending.key);
+                if (!filePath.startsWith(uploadDir + path.sep) && filePath !== uploadDir) {
+                    res.statusCode = 400;
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({ error: 'invalid storage key' }));
+                    return;
+                }
+                fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                fs.writeFileSync(filePath, body);
+                res.statusCode = 200;
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({
+                    key: pending.key,
+                    url: adapter.publicUrl(pending.key),
+                    size: body.length,
+                }));
+            });
+            // ── Static file serving ────────────────────────────────────
+            // Serve files from uploadDir at /uploads/*
+            server.middlewares.use('/uploads', (req, res, next) => {
+                if (req.method !== 'GET' && req.method !== 'HEAD')
+                    return next();
+                const filePath = path.resolve(uploadDir, (req.url?.split('?')[0] ?? '/').replace(/^\/+/, ''));
+                if (!filePath.startsWith(uploadDir + path.sep) && filePath !== uploadDir) {
+                    return next();
+                }
+                if (!fs.existsSync(filePath) || fs.statSync(filePath).isDirectory()) {
+                    return next();
+                }
+                const ext = path.extname(filePath).toLowerCase();
+                const mimeTypes = {
+                    '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png',
+                    '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml',
+                    '.mp4': 'video/mp4', '.webm': 'video/webm', '.mp3': 'audio/mpeg',
+                    '.pdf': 'application/pdf', '.json': 'application/json',
+                    '.txt': 'text/plain', '.bin': 'application/octet-stream',
+                };
+                const contentType = mimeTypes[ext] ?? 'application/octet-stream';
+                const stat = fs.statSync(filePath);
+                res.setHeader('Content-Type', contentType);
+                res.setHeader('Content-Length', stat.size);
+                res.setHeader('Cache-Control', 'no-cache');
+                if (req.method === 'HEAD') {
+                    res.end();
+                    return;
+                }
+                fs.createReadStream(filePath).pipe(res);
+            });
+        },
+    };
+}

package/dist/dev-server/plugins/vite-plugin-virtual-modules.js

@@ -15,16 +15,38 @@ export function virtualModulesPlugin(runtimeDir, editorDir) {
         'router-data': 'router-data.js',
         'router-hydration': 'router-hydration.js',
         'i18n': 'i18n.js',
+        'auth': 'auth.js',
+        'communication': 'communication.js',
+        'webrtc': 'webrtc.js',
+        'error-boundary': 'error-boundary.js',
+        'hydrate-support': '__virtual__',
     };
     // Modules resolved via resolve.alias instead of virtual module.
     // They still appear in the map so relative import rewrites work.
-    const aliasedModules = new Set(['i18n']);
+    const aliasedModules = new Set(['i18n', 'auth', 'communication', 'webrtc']);
     const editorModules = {
         'editor-bridge': 'editor-bridge.js',
         'element-annotator': 'element-annotator.js',
         'click-select': 'click-select.js',
         'hover-detect': 'hover-detect.js',
         'inline-text-edit': 'inline-text-edit.js',
+        'editor-api-client': 'editor-api-client.js',
+        'standalone-overlay': 'standalone-overlay.js',
+        'standalone-overlay-dom': 'standalone-overlay-dom.js',
+        'standalone-overlay-styles': 'standalone-overlay-styles.js',
+        'standalone-file-panel': 'standalone-file-panel.js',
+        'overlay-utils': 'overlay-utils.js',
+        'text-toolbar': 'text-toolbar.js',
+        'editor-toolbar': 'editor-toolbar.js',
+        'css-rules': 'css-rules.js',
+        'ast-modification': 'ast-modification.js',
+        'ast-service': 'ast-service.js',
+        'file-service': 'file-service.js',
+        'property-registry': 'property-registry.js',
+        'properties-panel': 'properties-panel.js',
+        'i18n-key-gen': 'i18n-key-gen.js',
+        'ai-chat-panel': 'ai-chat-panel.js',
+        'ai-project-panel': 'ai-project-panel.js',
     };
     function rewriteRelativeImports(code, modules) {
         for (const name of Object.keys(modules)) {
@@ -55,8 +77,95 @@ export function virtualModulesPlugin(runtimeDir, editorDir) {
             if (!id.startsWith('\0lumenjs:'))
                 return;
             const name = id.slice('\0lumenjs:'.length);
+            if (name === 'hydrate-support') {
+                // Custom hydrate support that catches digest mismatch errors and falls
+                // back to CSR instead of leaving double-rendered content.
+                // The stock @lit-labs/ssr-client/lit-element-hydrate-support.js throws
+                // on digest mismatch, sets _$AG=false before throwing, so the next
+                // update() appends fresh render alongside stale SSR content.
+                return `
+import { render } from 'lit-html';
+import { hydrate } from '@lit-labs/ssr-client';
+
+globalThis.litElementHydrateSupport = ({LitElement}) => {
+  const observedGet = Object.getOwnPropertyDescriptor(
+    Object.getPrototypeOf(LitElement), 'observedAttributes'
+  ).get;
+  Object.defineProperty(LitElement, 'observedAttributes', {
+    get() { return [...observedGet.call(this), 'defer-hydration']; }
+  });
+
+  const origAttrChanged = LitElement.prototype.attributeChangedCallback;
+  LitElement.prototype.attributeChangedCallback = function(name, old, value) {
+    if (name === 'defer-hydration' && value === null) {
+      origConnected.call(this);
+    }
+    origAttrChanged.call(this, name, old, value);
+  };
+
+  const origConnected = LitElement.prototype.connectedCallback;
+  LitElement.prototype.connectedCallback = function() {
+    if (!this.hasAttribute('defer-hydration')) origConnected.call(this);
+  };
+
+  function adoptElementStyles(el) {
+    const styles = el.constructor.elementStyles;
+    if (styles?.length && el.renderRoot instanceof ShadowRoot) {
+      el.renderRoot.adoptedStyleSheets = styles.map(
+        s => s instanceof CSSStyleSheet ? s : s.styleSheet
+      );
+    }
+  }
+
+  const origCreateRoot = LitElement.prototype.createRenderRoot;
+  LitElement.prototype.createRenderRoot = function() {
+    if (this.shadowRoot) {
+      this._$AG = true;
+      // Adopt styles that SSR declarative shadow roots don't include
+      adoptElementStyles(this);
+      return this.shadowRoot;
+    }
+    return origCreateRoot.call(this);
+  };
+
+  const superUpdate = Object.getPrototypeOf(LitElement.prototype).update;
+  LitElement.prototype.update = function(changedProps) {
+    const value = this.render();
+    superUpdate.call(this, changedProps);
+    if (this._$AG) {
+      this._$AG = false;
+      for (const attr of this.getAttributeNames()) {
+        if (attr.startsWith('hydrate-internals-')) {
+          this.removeAttribute(attr.slice(18));
+          this.removeAttribute(attr);
+        }
+      }
+      try {
+        hydrate(value, this.renderRoot, this.renderOptions);
+      } catch (err) {
+        // Digest mismatch — clear SSR content and render fresh (CSR fallback)
+        console.warn('[LumenJS] Hydration failed for <' + this.localName + '>, falling back to CSR:', err.message);
+        const root = this.renderRoot;
+        while (root.firstChild) root.removeChild(root.firstChild);
+        delete root._$litPart$;
+        // Re-adopt styles since clearing removed SSR <style> tags
+        adoptElementStyles(this);
+        render(value, root, this.renderOptions);
+      }
+    } else {
+      render(value, this.renderRoot, this.renderOptions);
+    }
+  };
+};
+`;
+            }
             if (runtimeModules[name]) {
-                const code = fs.readFileSync(path.join(runtimeDir, runtimeModules[name]), 'utf-8');
+                let code = fs.readFileSync(path.join(runtimeDir, runtimeModules[name]), 'utf-8');
+                // Prepend hydrate support to app-shell so all Lit imports share one module graph.
+                // Uses our custom hydrate-support virtual module (with CSR fallback) instead of stock.
+                if (name === 'app-shell') {
+                    code = `import '/@lumenjs/hydrate-support';\n` + code;
+                }
                 return rewriteRelativeImports(code, runtimeModules);
             }
             if (editorModules[name]) {

package/dist/dev-server/server.js

@@ -11,12 +11,21 @@ import { ssrRenderPage } from './ssr-render.js';
 import { readProjectConfig, getLumenJSNodeModules, getLumenJSDirs } from './config.js';
 import { getNuralyUIAliases, resolveNuralyUIPaths } from './nuralyui-aliases.js';
 import { litDedupPlugin } from './plugins/vite-plugin-lit-dedup.js';
+import { autoDefinePlugin } from './plugins/vite-plugin-auto-define.js';
 import { autoImportPlugin } from './plugins/vite-plugin-auto-import.js';
 import { litHmrPlugin } from './plugins/vite-plugin-lit-hmr.js';
 import { sourceAnnotatorPlugin } from './plugins/vite-plugin-source-annotator.js';
+import { editorApiPlugin } from './plugins/vite-plugin-editor-api.js';
 import { virtualModulesPlugin } from './plugins/vite-plugin-virtual-modules.js';
 import { i18nPlugin, loadTranslationsFromDisk } from './plugins/vite-plugin-i18n.js';
+import { authPlugin } from './plugins/vite-plugin-auth.js';
+import { communicationPlugin } from './plugins/vite-plugin-communication.js';
+import { lumenStoragePlugin } from './plugins/vite-plugin-storage.js';
+import { lumenSocketIOPlugin } from './plugins/vite-plugin-socketio.js';
 import { resolveLocale } from './middleware/locale.js';
+import { setProjectDir } from '../db/context.js';
+import { scanMiddleware, getMiddlewareDirsForPathname } from '../build/scan.js';
+import { runMiddlewareChain, extractMiddleware } from '../shared/middleware-runner.js';
 // Re-export for backwards compatibility
 export { readProjectConfig, readProjectTitle, getLumenJSNodeModules, getLumenJSDirs } from './config.js';
 export { getNuralyUIAliases, resolveNuralyUIPaths } from './nuralyui-aliases.js';
@@ -29,24 +38,37 @@ export function getSharedViteConfig(projectDir, options) {
     const isDev = mode === 'development';
     const pagesDir = path.join(projectDir, 'pages');
     const lumenNodeModules = getLumenJSNodeModules();
-    const { runtimeDir, editorDir } = getLumenJSDirs();
+    const { distDir, runtimeDir, editorDir } = getLumenJSDirs();
     // Resolve NuralyUI paths for aliases (only when nuralyui integration is enabled)
     const aliases = {};
     if (options?.integrations?.includes('nuralyui')) {
         const nuralyUIPaths = resolveNuralyUIPaths(projectDir);
         if (nuralyUIPaths) {
             Object.assign(aliases, getNuralyUIAliases(nuralyUIPaths.componentsPath, nuralyUIPaths.commonPath));
+            // Add root aliases for theme CSS imports
+            const nuralyUIRoot = path.resolve(nuralyUIPaths.componentsPath, '..');
+            aliases['@nuralyui-theme'] = path.join(nuralyUIRoot, 'shared/themes');
+            aliases['@nuralyui-common'] = nuralyUIPaths.commonPath;
         }
     }
     const resolve = {
         alias: {
             ...aliases,
-            // Map @lumenjs/i18n to the physical dist file so Vite resolves it
-            // without going through node_modules (it's not an npm package).
             '@lumenjs/i18n': path.join(runtimeDir, 'i18n.js'),
+            '@lumenjs/auth': path.join(runtimeDir, 'auth.js'),
+            '@nuraly/lumenjs-auth': path.join(runtimeDir, 'auth.js'),
+            '@lumenjs/communication': path.join(runtimeDir, 'communication.js'),
+            '@lumenjs/webrtc': path.join(runtimeDir, 'webrtc.js'),
+            '@lumenjs/db': path.join(distDir, 'db', 'client.js'),
+            '@lumenjs/permissions': path.join(distDir, 'permissions', 'index.js'),
+            '@lumenjs/storage': path.join(distDir, 'storage', 'index.js'),
+            '@nuraly/lumenjs': path.resolve(distDir, '..'),
         },
         conditions: isDev ? ['development', 'browser'] : ['browser'],
-        dedupe: ['lit', 'lit-html', 'lit-element', '@lit/reactive-element'],
+        // Note: resolve.dedupe is NOT used — it resolves via Node's algorithm
+        // which ignores Vite's resolve.conditions, picking the `default` export
+        // (prod proxy) instead of `development`. The litDedupPlugin handles
+        // single-copy resolution with correct conditions instead.
     };
     const esbuild = {
         tsconfigRaw: {
@@ -59,6 +81,7 @@ export function getSharedViteConfig(projectDir, options) {
     const plugins = [
         lumenRoutesPlugin(pagesDir),
         lumenLoadersPlugin(pagesDir),
+        autoDefinePlugin(pagesDir),
         litDedupPlugin(lumenNodeModules, isDev),
         virtualModulesPlugin(runtimeDir, editorDir),
     ];
@@ -86,7 +109,13 @@ export async function createDevServer(options) {
     const apiDir = path.join(projectDir, 'api');
     const publicDir = path.join(projectDir, 'public');
     const config = readProjectConfig(projectDir);
-    const { title, integrations, i18n: i18nConfig } = config;
+    const { title, integrations, i18n: i18nConfig, prefetch: prefetchStrategy } = config;
+    // Read optional head.html for blocking scripts (e.g. theme initialization)
+    const headHtmlPath = path.join(projectDir, 'head.html');
+    const headContent = fs.existsSync(headHtmlPath) ? fs.readFileSync(headHtmlPath, 'utf-8') : undefined;
+    // Set project dir for DB context (used by loaders, API routes, plugins)
+    setProjectDir(projectDir);
+    process.env.LUMENJS_PROJECT_DIR = projectDir;
     const shared = getSharedViteConfig(projectDir, { integrations });
     const server = await createViteServer({
         root: projectDir,
@@ -97,15 +126,90 @@ export async function createDevServer(options) {
             strictPort: false,
             allowedHosts: true,
             cors: true,
-            hmr: true,
+            hmr: process.env.HMR_CLIENT_PORT ? { clientPort: parseInt(process.env.HMR_CLIENT_PORT), protocol: process.env.HMR_PROTOCOL || 'wss', host: process.env.HMR_HOST || undefined } : true,
+            fs: {
+                allow: [projectDir, getLumenJSNodeModules(), path.resolve(getLumenJSNodeModules(), '..')],
+            },
         },
         resolve: shared.resolve,
         plugins: [
+            ...(integrations.includes('auth') ? [authPlugin(projectDir)] : []),
             ...shared.plugins,
+            ...(integrations.includes('communication') ? [communicationPlugin(projectDir)] : []),
+            lumenStoragePlugin(projectDir),
             lumenApiRoutesPlugin(apiDir, projectDir),
             litHmrPlugin(projectDir),
             ...(i18nConfig ? [i18nPlugin(projectDir, i18nConfig)] : []),
-            ...(editorMode ? [sourceAnnotatorPlugin(projectDir)] : []),
+            ...(editorMode ? [sourceAnnotatorPlugin(projectDir), editorApiPlugin(projectDir)] : []),
+            lumenSocketIOPlugin(pagesDir),
+            {
+                // Clear SSR module cache on file changes so the next SSR request uses fresh code.
+                // Without this, HMR updates the client but SSR keeps serving stale modules.
+                name: 'lumenjs-ssr-invalidate-on-change',
+                handleHotUpdate({ file, server }) {
+                    const mods = server.moduleGraph.getModulesByFile(file);
+                    if (mods) {
+                        for (const m of mods) {
+                            m.ssrModule = null;
+                            m.ssrTransformResult = null;
+                        }
+                    }
+                },
+            },
+            {
+                name: 'lumenjs-user-middleware',
+                config(config) {
+                    const entries = scanMiddleware(pagesDir);
+                    if (entries.length === 0)
+                        return;
+                    const npmDeps = new Set();
+                    for (const entry of entries) {
+                        try {
+                            const content = fs.readFileSync(entry.filePath, 'utf-8');
+                            const importMatches = content.matchAll(/(?:import|require)\s*(?:\(?\s*['"]([^./][^'"]*)['"]\s*\)?|.*from\s*['"]([^./][^'"]*)['"]\s*)/g);
+                            for (const m of importMatches) {
+                                const pkg = m[1] || m[2];
+                                if (pkg) {
+                                    const pkgName = pkg.startsWith('@') ? pkg.split('/').slice(0, 2).join('/') : pkg.split('/')[0];
+                                    npmDeps.add(pkgName);
+                                }
+                            }
+                        }
+                        catch { }
+                    }
+                    if (npmDeps.size > 0) {
+                        const existing = config.ssr?.external || [];
+                        return { ssr: { external: [...existing, ...npmDeps] } };
+                    }
+                },
+                configureServer(server) {
+                    server.middlewares.use(async (req, res, next) => {
+                        const pathname = (req.url || '/').split('?')[0];
+                        if (pathname.startsWith('/@') || pathname.startsWith('/node_modules') || pathname.includes('.')) {
+                            return next();
+                        }
+                        const middlewareEntries = scanMiddleware(pagesDir);
+                        if (middlewareEntries.length === 0)
+                            return next();
+                        const matchingDirs = getMiddlewareDirsForPathname(pathname, middlewareEntries);
+                        if (matchingDirs.length === 0)
+                            return next();
+                        const allMw = [];
+                        for (const entry of matchingDirs) {
+                            try {
+                                const mod = await server.ssrLoadModule(entry.filePath);
+                                allMw.push(...extractMiddleware(mod));
+                            }
+                            catch (err) {
+                                console.error(`[LumenJS] Failed to load _middleware.ts (${entry.dir || 'root'}):`, err);
+                            }
+                        }
+                        if (allMw.length === 0)
+                            return next();
+                        runMiddlewareChain(allMw, req, res, next);
+                    });
+                }
+            },
             {
                 name: 'lumenjs-index-html',
                 configureServer(server) {
@@ -136,7 +240,7 @@ export async function createDevServer(options) {
                                 translations = loadTranslationsFromDisk(projectDir, locale);
                             }
                             const SSR_PLACEHOLDER = '<!--__NK_SSR_CONTENT__-->';
-                            ssrRenderPage(server, pagesDir, pathname, req.headers, locale).then(async (ssrResult) => {
+                            ssrRenderPage(server, pagesDir, pathname, req.headers, locale, req.nkAuth?.user ?? undefined).then(async (ssrResult) => {
                                 if (ssrResult?.redirect) {
                                     res.writeHead(ssrResult.redirect.status, { Location: ssrResult.redirect.location });
                                     res.end();
@@ -152,6 +256,9 @@ export async function createDevServer(options) {
                                     locale,
                                     i18nConfig: i18nConfig || undefined,
                                     translations,
+                                    prefetch: prefetchStrategy,
+                                    authUser: ssrResult?.authUser ?? req.nkAuth?.user ?? undefined,
+                                    headContent,
                                 });
                                 const transformed = await server.transformIndexHtml(req.url, shellHtml);
                                 const finalHtml = ssrResult
@@ -162,7 +269,7 @@ export async function createDevServer(options) {
                                 res.end(finalHtml);
                             }).catch(err => {
                                 console.error('[LumenJS] SSR/HTML generation error:', err);
-                                const html = generateIndexHtml({ title, editorMode, integrations, locale, i18nConfig: i18nConfig || undefined, translations });
+                                const html = generateIndexHtml({ title, editorMode, integrations, locale, i18nConfig: i18nConfig || undefined, translations, prefetch: prefetchStrategy, headContent });
                                 server.transformIndexHtml(req.url, html).then(transformed => {
                                     res.setHeader('Content-Type', 'text/html');
                                     res.setHeader('Cache-Control', 'no-store');
@@ -178,12 +285,21 @@ export async function createDevServer(options) {
         ],
         esbuild: shared.esbuild,
         optimizeDeps: {
-            include: ['lit', 'lit/decorators.js', 'lit/directive.js', 'lit/directive-helpers.js', 'lit/async-directive.js', 'lit-html', 'lit-element', '@lit/reactive-element'],
-            exclude: ['@lumenjs/i18n'],
+            exclude: [
+                '@lumenjs/i18n',
+                '@nuraly/lumenjs-auth',
+                // Lit packages must NOT be pre-bundled — pre-bundling creates separate
+                // module entries (/.vite/deps/) alongside raw /@fs/ files, causing
+                // multiple lit-html instances. Instead, resolve.dedupe forces all lit
+                // imports to a single copy. The project's lit version MUST match
+                // lumenjs's lit version for dedupe to work.
+                'lit', 'lit-html', 'lit-element', '@lit/reactive-element',
+                '@lit-labs/ssr-client',
+            ],
         },
         ssr: {
             noExternal: true,
-            external: ['node-domexception'],
+            external: ['node-domexception', 'socket.io-client', 'xmlhttprequest-ssl', 'engine.io-client', 'better-sqlite3', '@lumenjs/db', '@lumenjs/permissions'],
             resolve: {
                 conditions: ['node', 'import'],
             },

package/dist/dev-server/ssr-render.d.ts

@@ -9,7 +9,7 @@ export interface LayoutSSRData {
  *
  * Returns pre-rendered HTML and loader data, or null on failure (falls back to CSR).
  */
-export declare function ssrRenderPage(server: ViteDevServer, pagesDir: string, pathname: string, headers?: Record<string, string | string[] | undefined>, locale?: string): Promise<{
+export declare function ssrRenderPage(server: ViteDevServer, pagesDir: string, pathname: string, headers?: Record<string, string | string[] | undefined>, locale?: string, user?: any): Promise<{
     html: string;
     loaderData: any;
     layoutsData?: LayoutSSRData[];
@@ -17,4 +17,5 @@ export declare function ssrRenderPage(server: ViteDevServer, pagesDir: string, p
         location: string;
         status: number;
     };
+    authUser?: any;
 } | null>;