@nuraly/lumenjs 0.1.0

package/README.md

@@ -0,0 +1,297 @@
+# LumenJS
+
+A full-stack web framework for [Lit](https://lit.dev/) web components. File-based routing, server loaders, SSR with hydration, nested layouts, API routes, and a Vite-powered dev server.
+
+## Quick Start
+
+```bash
+npx lumenjs dev --project ./my-app
+```
+
+## Project Structure
+
+```
+my-app/
+├── lumenjs.config.ts       # Project config
+├── package.json
+├── pages/                  # File-based routes
+│   ├── _layout.ts          # Root layout
+│   ├── index.ts            # → /
+│   ├── about.ts            # → /about
+│   └── blog/
+│       ├── _layout.ts      # Nested layout (wraps blog/*)
+│       ├── index.ts         # → /blog
+│       └── [slug].ts       # → /blog/:slug
+├── api/                    # API routes
+│   └── hello.ts            # → /api/hello
+└── public/                 # Static assets
+```
+
+## Configuration
+
+```typescript
+// lumenjs.config.ts
+export default {
+  title: 'My App',
+  integrations: ['tailwind'],
+};
+```
+
+| Option | Type | Description |
+|---|---|---|
+| `title` | `string` | HTML page title |
+| `integrations` | `string[]` | Optional integrations: `'tailwind'`, `'nuralyui'` |
+
+## Pages
+
+Pages are Lit components in the `pages/` directory. The file path determines the URL.
+
+```typescript
+// pages/index.ts
+import { LitElement, html, css } from 'lit';
+import { customElement } from 'lit/decorators.js';
+
+@customElement('page-index')
+export class PageIndex extends LitElement {
+  static styles = css`:host { display: block; }`;
+
+  render() {
+    return html`<h1>Hello, LumenJS!</h1>`;
+  }
+}
+```
+
+### Routing
+
+| File | URL | Tag |
+|---|---|---|
+| `pages/index.ts` | `/` | `<page-index>` |
+| `pages/about.ts` | `/about` | `<page-about>` |
+| `pages/blog/index.ts` | `/blog` | `<page-blog-index>` |
+| `pages/blog/[slug].ts` | `/blog/:slug` | `<page-blog-slug>` |
+| `pages/[...slug].ts` | `/*` (catch-all) | `<page-slug>` |
+
+Static routes take priority over dynamic ones. Dynamic `[param]` routes take priority over catch-all `[...param]` routes.
+
+## Loaders
+
+Export a `loader()` function from any page or layout to fetch data on the server.
+
+```typescript
+// pages/blog/[slug].ts
+export async function loader({ params, headers, query, url }) {
+  const post = await db.posts.findOne({ slug: params.slug });
+  if (!post) return { __nk_redirect: true, location: '/404', status: 302 };
+  return { post };
+}
+
+@customElement('page-blog-slug')
+export class BlogPost extends LitElement {
+  @property({ type: Object }) loaderData: any = {};
+
+  render() {
+    return html`<h1>${this.loaderData.post?.title}</h1>`;
+  }
+}
+```
+
+Loaders run server-side on initial load (SSR) and are fetched via `/__nk_loader/<path>` during client-side navigation. The `loader()` export is automatically stripped from client bundles.
+
+### Loader Context
+
+| Property | Type | Description |
+|---|---|---|
+| `params` | `Record<string, string>` | Dynamic route parameters |
+| `query` | `Record<string, string>` | Query string parameters |
+| `url` | `string` | Request pathname |
+| `headers` | `Record<string, any>` | Request headers |
+
+### Redirects
+
+```typescript
+export async function loader({ headers }) {
+  const user = await getUser(headers.authorization);
+  if (!user) return { __nk_redirect: true, location: '/login', status: 302 };
+  return { user };
+}
+```
+
+## Nested Layouts
+
+Create `_layout.ts` in any directory to wrap all pages in that directory and its subdirectories.
+
+```typescript
+// pages/_layout.ts
+@customElement('layout-root')
+export class RootLayout extends LitElement {
+  render() {
+    return html`
+      <header>My App</header>
+      <main><slot></slot></main>
+      <footer>Footer</footer>
+    `;
+  }
+}
+```
+
+Layouts persist across navigation — when navigating between pages that share the same layout, only the page component is swapped.
+
+Layouts can have their own `loader()` function for shared data like auth or navigation:
+
+```typescript
+// pages/dashboard/_layout.ts
+export async function loader({ headers }) {
+  const user = await getUser(headers.authorization);
+  if (!user) return { __nk_redirect: true, location: '/login', status: 302 };
+  return { user };
+}
+
+@customElement('layout-dashboard')
+export class DashboardLayout extends LitElement {
+  @property({ type: Object }) loaderData: any = {};
+
+  render() {
+    return html`
+      <nav>Welcome, ${this.loaderData.user?.name}</nav>
+      <slot></slot>
+    `;
+  }
+}
+```
+
+## API Routes
+
+Create files in `api/` and export named functions for each HTTP method.
+
+```typescript
+// api/users/[id].ts
+export async function GET(req) {
+  return { user: { id: req.params.id, name: 'Alice' } };
+}
+
+export async function POST(req) {
+  const { name } = req.body;
+  return { created: true, name };
+}
+```
+
+### Request Object
+
+| Property | Type | Description |
+|---|---|---|
+| `method` | `string` | HTTP method |
+| `url` | `string` | Request pathname |
+| `query` | `Record<string, string>` | Query string parameters |
+| `params` | `Record<string, string>` | Dynamic route parameters |
+| `body` | `any` | Parsed JSON body (non-GET) |
+| `files` | `NkUploadedFile[]` | Uploaded files (multipart) |
+| `headers` | `Record<string, any>` | Request headers |
+
+### Error Responses
+
+```typescript
+export async function GET(req) {
+  const item = await db.find(req.params.id);
+  if (!item) throw { status: 404, message: 'Not found' };
+  return item;
+}
+```
+
+### File Uploads
+
+Multipart form data is parsed automatically:
+
+```typescript
+export async function POST(req) {
+  for (const file of req.files) {
+    console.log(file.fileName, file.size, file.contentType);
+    // file.data is a Buffer
+  }
+  return { uploaded: req.files.length };
+}
+```
+
+## SSR & Hydration
+
+Pages with loaders are automatically server-rendered using `@lit-labs/ssr`:
+
+1. Loader runs on the server
+2. Lit component renders to HTML
+3. Loader data is embedded as JSON in the response
+4. Browser receives pre-rendered HTML (fast first paint)
+5. Client hydrates the existing DOM without re-rendering
+
+Pages without loaders render client-side only (SPA mode). If SSR fails, LumenJS falls back gracefully to client-side rendering.
+
+## Integrations
+
+### Tailwind CSS
+
+```bash
+npx lumenjs add tailwind
+```
+
+This installs `tailwindcss` and `@tailwindcss/vite`, creates `styles/tailwind.css`, and updates your config. For pages using Tailwind classes in light DOM:
+
+```typescript
+createRenderRoot() { return this; }
+```
+
+### NuralyUI
+
+Add `'nuralyui'` to integrations to enable auto-import of `<nr-*>` components:
+
+```typescript
+// lumenjs.config.ts
+export default {
+  title: 'My App',
+  integrations: ['nuralyui'],
+};
+```
+
+NuralyUI components are detected in `html\`\`` templates and imported automatically, including implicit dependencies (e.g., `nr-button` auto-imports `nr-icon`).
+
+## CLI
+
+```
+lumenjs dev    [--project <dir>] [--port <port>] [--base <path>] [--editor-mode]
+lumenjs build  [--project <dir>] [--out <dir>]
+lumenjs serve  [--project <dir>] [--port <port>]
+lumenjs add    <integration>
+```
+
+| Command | Description |
+|---|---|
+| `dev` | Start Vite dev server with HMR, SSR, and API routes |
+| `build` | Bundle client assets and server modules for production |
+| `serve` | Serve the production build with SSR and gzip compression |
+| `add` | Add an integration (e.g., `tailwind`) |
+
+### Default Ports
+
+| Mode | Default |
+|---|---|
+| `dev` | 3000 |
+| `serve` | 3000 |
+
+## Production Build
+
+```bash
+npx lumenjs build --project ./my-app
+npx lumenjs serve --project ./my-app --port 8080
+```
+
+The build outputs to `.lumenjs/`:
+
+```
+.lumenjs/
+├── client/           # Static assets (HTML, JS, CSS)
+├── server/           # Server modules (loaders, API routes, SSR runtime)
+└── manifest.json     # Route manifest
+```
+
+The production server includes gzip compression and serves pre-built assets while executing loaders and API routes on demand.
+
+## License
+
+MIT

package/dist/build/build.d.ts

@@ -0,0 +1,5 @@
+export interface BuildOptions {
+    projectDir: string;
+    outDir?: string;
+}
+export declare function buildProject(options: BuildOptions): Promise<void>;

package/dist/build/build.js

@@ -0,0 +1,172 @@
+import { build as viteBuild } from 'vite';
+import path from 'path';
+import fs from 'fs';
+import { getSharedViteConfig } from '../dev-server/server.js';
+import { readProjectConfig } from '../dev-server/config.js';
+import { generateIndexHtml } from '../dev-server/index-html.js';
+import { scanPages, scanLayouts, scanApiRoutes, getLayoutDirsForPage } from './scan.js';
+export async function buildProject(options) {
+    const { projectDir } = options;
+    const outDir = options.outDir || path.join(projectDir, '.lumenjs');
+    const clientDir = path.join(outDir, 'client');
+    const serverDir = path.join(outDir, 'server');
+    const pagesDir = path.join(projectDir, 'pages');
+    const apiDir = path.join(projectDir, 'api');
+    const publicDir = path.join(projectDir, 'public');
+    // Clean output directory
+    if (fs.existsSync(outDir)) {
+        fs.rmSync(outDir, { recursive: true });
+    }
+    fs.mkdirSync(outDir, { recursive: true });
+    const { title, integrations } = readProjectConfig(projectDir);
+    const shared = getSharedViteConfig(projectDir, { mode: 'production', integrations });
+    // Scan pages, layouts, and API routes for the manifest
+    const pageEntries = scanPages(pagesDir);
+    const layoutEntries = scanLayouts(pagesDir);
+    const apiEntries = scanApiRoutes(apiDir);
+    // --- Client build ---
+    console.log('[LumenJS] Building client bundle...');
+    // Generate index.html as build entry
+    const indexHtml = generateIndexHtml({ title, editorMode: false, integrations });
+    const tempIndexPath = path.join(projectDir, '__nk_build_index.html');
+    fs.writeFileSync(tempIndexPath, indexHtml);
+    try {
+        await viteBuild({
+            root: projectDir,
+            publicDir: fs.existsSync(publicDir) ? publicDir : undefined,
+            resolve: shared.resolve,
+            plugins: shared.plugins,
+            esbuild: shared.esbuild,
+            build: {
+                outDir: clientDir,
+                emptyOutDir: true,
+                rollupOptions: {
+                    input: tempIndexPath,
+                },
+            },
+            logLevel: 'warn',
+        });
+    }
+    finally {
+        // Clean up temp file
+        if (fs.existsSync(tempIndexPath)) {
+            fs.unlinkSync(tempIndexPath);
+        }
+    }
+    // Rename the built HTML file from __nk_build_index.html to index.html
+    const builtHtmlPath = path.join(clientDir, '__nk_build_index.html');
+    const finalHtmlPath = path.join(clientDir, 'index.html');
+    if (fs.existsSync(builtHtmlPath)) {
+        fs.renameSync(builtHtmlPath, finalHtmlPath);
+    }
+    // --- Server build ---
+    console.log('[LumenJS] Building server bundle...');
+    // Collect server entry points (pages with loaders + layouts with loaders + API routes)
+    const serverEntries = {};
+    for (const entry of pageEntries) {
+        if (entry.hasLoader) {
+            serverEntries[`pages/${entry.name}`] = entry.filePath;
+        }
+    }
+    for (const entry of layoutEntries) {
+        if (entry.hasLoader) {
+            const entryName = entry.dir ? `layouts/${entry.dir}/_layout` : 'layouts/_layout';
+            serverEntries[entryName] = entry.filePath;
+        }
+    }
+    for (const entry of apiEntries) {
+        serverEntries[`api/${entry.name}`] = entry.filePath;
+    }
+    // Create SSR runtime entry — bundles @lit-labs/ssr alongside Lit so all
+    // server modules share one Lit instance (avoids _$EM mismatches).
+    const ssrEntryPath = path.join(projectDir, '__nk_ssr_entry.js');
+    const hasPageLoaders = pageEntries.some(e => e.hasLoader);
+    const hasLayoutLoaders = layoutEntries.some(e => e.hasLoader);
+    if (hasPageLoaders || hasLayoutLoaders) {
+        fs.writeFileSync(ssrEntryPath, [
+            "import '@lit-labs/ssr/lib/install-global-dom-shim.js';",
+            "export { render } from '@lit-labs/ssr';",
+            "export { html, unsafeStatic } from 'lit/static-html.js';",
+        ].join('\n'));
+        serverEntries['ssr-runtime'] = ssrEntryPath;
+    }
+    try {
+        if (Object.keys(serverEntries).length > 0) {
+            await viteBuild({
+                root: projectDir,
+                resolve: shared.resolve,
+                plugins: shared.plugins,
+                esbuild: shared.esbuild,
+                build: {
+                    outDir: serverDir,
+                    emptyOutDir: true,
+                    ssr: true,
+                    rollupOptions: {
+                        input: serverEntries,
+                        output: {
+                            format: 'esm',
+                            entryFileNames: '[name].js',
+                            chunkFileNames: 'assets/[name]-[hash].js',
+                            manualChunks(id) {
+                                // Force all Lit packages into a single shared chunk so SSR runtime
+                                // and page modules use the exact same Lit class instances.
+                                if (id.includes('/node_modules/lit/') ||
+                                    id.includes('/node_modules/lit-html/') ||
+                                    id.includes('/node_modules/lit-element/') ||
+                                    id.includes('/node_modules/@lit/reactive-element/')) {
+                                    return 'lit-shared';
+                                }
+                            },
+                        },
+                        external: [
+                            /^node:/,
+                            'os', 'fs', 'path', 'url', 'util', 'crypto', 'http', 'https', 'net',
+                            'stream', 'zlib', 'events', 'buffer', 'querystring', 'child_process',
+                            'worker_threads', 'cluster', 'dns', 'tls', 'assert', 'constants',
+                        ],
+                    },
+                },
+                logLevel: 'warn',
+                ssr: {
+                    noExternal: true,
+                },
+            });
+        }
+        else {
+            fs.mkdirSync(serverDir, { recursive: true });
+        }
+    }
+    finally {
+        if (fs.existsSync(ssrEntryPath)) {
+            fs.unlinkSync(ssrEntryPath);
+        }
+    }
+    // --- Write manifest ---
+    const manifest = {
+        routes: pageEntries.map(e => {
+            const routeLayouts = getLayoutDirsForPage(e.filePath, pagesDir, layoutEntries);
+            return {
+                path: e.routePath,
+                module: e.hasLoader ? `pages/${e.name}.js` : '',
+                hasLoader: e.hasLoader,
+                ...(routeLayouts.length > 0 ? { layouts: routeLayouts } : {}),
+            };
+        }),
+        apiRoutes: apiEntries.map(e => ({
+            path: `/api/${e.routePath}`,
+            module: `api/${e.name}.js`,
+            hasLoader: false,
+        })),
+        layouts: layoutEntries.map(e => ({
+            dir: e.dir,
+            module: e.hasLoader ? (e.dir ? `layouts/${e.dir}/_layout.js` : 'layouts/_layout.js') : '',
+            hasLoader: e.hasLoader,
+        })),
+    };
+    fs.writeFileSync(path.join(outDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+    console.log('[LumenJS] Build complete.');
+    console.log(`  Output: ${outDir}`);
+    console.log(`  Client assets: ${clientDir}`);
+    console.log(`  Server modules: ${serverDir}`);
+    console.log(`  Routes: ${pageEntries.length} pages, ${apiEntries.length} API routes, ${layoutEntries.length} layouts`);
+}

package/dist/build/error-page.d.ts

@@ -0,0 +1 @@
+export declare function renderErrorPage(status: number, title: string, message: string, detail?: string): string;

package/dist/build/error-page.js

@@ -0,0 +1,74 @@
+import { escapeHtml } from '../shared/utils.js';
+export function renderErrorPage(status, title, message, detail) {
+    const gradients = {
+        404: 'linear-gradient(135deg, #6366f1, #8b5cf6, #a855f7)',
+        500: 'linear-gradient(135deg, #ef4444, #f97316, #f59e0b)',
+        502: 'linear-gradient(135deg, #f97316, #ef4444)',
+        503: 'linear-gradient(135deg, #64748b, #475569)',
+    };
+    const gradient = gradients[status] || gradients[500];
+    const detailBlock = detail
+        ? `<div style="margin-top:1.5rem;padding:.75rem 1rem;background:#f8fafc;border:1px solid #e2e8f0;border-radius:8px;text-align:left">
+        <div style="font-size:.6875rem;font-weight:600;color:#94a3b8;text-transform:uppercase;letter-spacing:.05em;margin-bottom:.375rem">Details</div>
+        <pre style="margin:0;font-size:.75rem;color:#64748b;white-space:pre-wrap;word-break:break-word;font-family:ui-monospace,SFMono-Regular,Menlo,monospace">${escapeHtml(detail)}</pre>
+      </div>`
+        : '';
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${status} — ${escapeHtml(title)}</title>
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      background: #fafbfc;
+      padding: 2rem;
+    }
+    .container { text-align: center; max-width: 440px; }
+    .status {
+      font-size: 5rem;
+      font-weight: 200;
+      letter-spacing: -2px;
+      line-height: 1;
+      color: #cbd5e1;
+      user-select: none;
+    }
+    h1 { font-size: 1rem; font-weight: 500; color: #334155; margin: 1.25rem 0 .5rem; }
+    .message { color: #94a3b8; font-size: .8125rem; line-height: 1.5; margin-bottom: 2rem; }
+    .btn {
+      display: inline-flex; align-items: center; gap: .375rem;
+      padding: .4375rem 1rem;
+      background: #f8fafc; color: #475569;
+      border: 1px solid #e2e8f0;
+      border-radius: 6px; font-size: .8125rem; font-weight: 400;
+      text-decoration: none; transition: all .15s;
+      cursor: pointer;
+    }
+    .btn:hover { background: #f1f5f9; border-color: #cbd5e1; }
+    .btn svg { flex-shrink: 0; }
+    .divider { width: 32px; height: 2px; background: #e2e8f0; border-radius: 1px; margin: 1.25rem auto; }
+    .footer { margin-top: 3rem; font-size: .6875rem; color: #e2e8f0; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="status">${status}</div>
+    <div class="divider"></div>
+    <h1>${escapeHtml(title)}</h1>
+    <p class="message">${escapeHtml(message)}</p>
+    <a href="/" class="btn">
+      <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><path d="m15 18-6-6 6-6"/></svg>
+      Back to home
+    </a>
+    ${detailBlock}
+    <div class="footer">LumenJS</div>
+  </div>
+</body>
+</html>`;
+}

package/dist/build/scan.d.ts

@@ -0,0 +1,21 @@
+export interface PageEntry {
+    name: string;
+    filePath: string;
+    routePath: string;
+    hasLoader: boolean;
+}
+export interface LayoutEntry {
+    dir: string;
+    filePath: string;
+    hasLoader: boolean;
+}
+export interface ApiEntry {
+    name: string;
+    filePath: string;
+    routePath: string;
+}
+export declare function scanPages(pagesDir: string): PageEntry[];
+export declare function scanLayouts(pagesDir: string): LayoutEntry[];
+export declare function scanApiRoutes(apiDir: string): ApiEntry[];
+/** Get the layout directory chain for a given page file */
+export declare function getLayoutDirsForPage(pageFilePath: string, pagesDir: string, layouts: LayoutEntry[]): string[];

package/dist/build/scan.js

@@ -0,0 +1,93 @@
+import fs from 'fs';
+import path from 'path';
+import { fileHasLoader, filePathToRoute } from '../shared/utils.js';
+export function scanPages(pagesDir) {
+    if (!fs.existsSync(pagesDir))
+        return [];
+    const entries = [];
+    walkDir(pagesDir, '', entries, pagesDir);
+    return entries;
+}
+export function scanLayouts(pagesDir) {
+    if (!fs.existsSync(pagesDir))
+        return [];
+    const entries = [];
+    walkForLayouts(pagesDir, '', entries);
+    return entries;
+}
+export function scanApiRoutes(apiDir) {
+    if (!fs.existsSync(apiDir))
+        return [];
+    const entries = [];
+    walkApiDir(apiDir, '', entries, apiDir);
+    return entries;
+}
+/** Get the layout directory chain for a given page file */
+export function getLayoutDirsForPage(pageFilePath, pagesDir, layouts) {
+    const relativeToPages = path.relative(pagesDir, pageFilePath).replace(/\\/g, '/');
+    const dirParts = path.dirname(relativeToPages).split('/').filter(p => p && p !== '.');
+    const chain = [];
+    // Check root layout
+    if (layouts.some(l => l.dir === '')) {
+        chain.push('');
+    }
+    // Check each directory level
+    let currentDir = '';
+    for (const part of dirParts) {
+        currentDir = currentDir ? `${currentDir}/${part}` : part;
+        if (layouts.some(l => l.dir === currentDir)) {
+            chain.push(currentDir);
+        }
+    }
+    return chain;
+}
+function walkDir(baseDir, relativePath, entries, pagesDir) {
+    const fullDir = path.join(baseDir, relativePath);
+    const dirEntries = fs.readdirSync(fullDir, { withFileTypes: true });
+    for (const entry of dirEntries) {
+        const entryRelative = path.join(relativePath, entry.name);
+        if (entry.isDirectory()) {
+            walkDir(baseDir, entryRelative, entries, pagesDir);
+        }
+        else if (entry.isFile() && /\.(ts|js)$/.test(entry.name) && !entry.name.startsWith('_')) {
+            const filePath = path.join(pagesDir, entryRelative);
+            const name = entryRelative.replace(/\.(ts|js)$/, '').replace(/\\/g, '/');
+            const routePath = filePathToRoute(entryRelative);
+            const hasLoader = fileHasLoader(filePath);
+            entries.push({ name, filePath, routePath, hasLoader });
+        }
+    }
+}
+function walkForLayouts(baseDir, relativePath, entries) {
+    const fullDir = path.join(baseDir, relativePath);
+    const dirEntries = fs.readdirSync(fullDir, { withFileTypes: true });
+    for (const entry of dirEntries) {
+        if (entry.isFile() && /^_layout\.(ts|js)$/.test(entry.name)) {
+            const filePath = path.join(fullDir, entry.name);
+            const dir = relativePath.replace(/\\/g, '/');
+            entries.push({ dir, filePath, hasLoader: fileHasLoader(filePath) });
+        }
+        if (entry.isDirectory()) {
+            walkForLayouts(baseDir, path.join(relativePath, entry.name), entries);
+        }
+    }
+}
+function walkApiDir(baseDir, relativePath, entries, apiDir) {
+    const fullDir = path.join(baseDir, relativePath);
+    const dirEntries = fs.readdirSync(fullDir, { withFileTypes: true });
+    for (const entry of dirEntries) {
+        const entryRelative = path.join(relativePath, entry.name);
+        if (entry.isDirectory()) {
+            walkApiDir(baseDir, entryRelative, entries, apiDir);
+        }
+        else if (entry.isFile() && /\.(ts|js)$/.test(entry.name) && !entry.name.startsWith('_')) {
+            const filePath = path.join(apiDir, entryRelative);
+            const name = entryRelative.replace(/\.(ts|js)$/, '').replace(/\\/g, '/');
+            const routePath = entryRelative
+                .replace(/\.(ts|js)$/, '')
+                .replace(/\\/g, '/')
+                .replace(/\[([^\]]+)\]/g, ':$1');
+            entries.push({ name, filePath, routePath });
+        }
+    }
+}

package/dist/build/serve-api.d.ts

@@ -0,0 +1,3 @@
+import http from 'http';
+import type { BuildManifest } from '../shared/types.js';
+export declare function handleApiRoute(manifest: BuildManifest, serverDir: string, pathname: string, queryString: string | undefined, method: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;