@zenithbuild/cli 0.7.0 → 0.7.2

package/README.md

@@ -8,7 +8,9 @@ The command-line interface for developing and building Zenith applications.
 ## Canonical Docs
 
 - CLI contract: `../zenith-docs/documentation/cli-contract.md`
+- Deployment targets guide: `/Users/judahsullivan/Personal/zenithbuild-monorepo/docs/documentation/guides/deployment-targets.md`
 - Script server/data contract: `../zenith-docs/documentation/contracts/server-data.md`
+- Server output contract: `./SERVER_OUTPUT_CONTRACT.md`
 
 ## Overview
 
@@ -21,6 +23,62 @@ The command-line interface for developing and building Zenith applications.
 - **Plugin Management**: Easily add and remove Zenith plugins.
 - **Preview**: Test your production builds locally.
 
+## Config Baseline
+
+Current top-level `zenith.config.js` keys:
+
+- `router`
+- `embeddedMarkupExpressions`
+- `typescriptDefault`
+- `outDir`
+- `pagesDir`
+- `basePath`
+- `target`
+- `adapter`
+- `strictDomLints`
+- `images`
+
+There is no separate `assetPrefix` config. Public framework asset URLs follow `basePath`.
+
+`pagesDir` resolution:
+
+- If `pagesDir` is set, the CLI uses that path relative to the project root.
+- If `pagesDir` is not set, the CLI checks `pages/` first, then `src/pages/`, then falls back to the default `pages` path.
+
+`basePath` behavior:
+
+- `basePath` defaults to `/`.
+- Canonical route paths stay base-path free in manifests and route classification.
+- Public app URLs, bundled asset URLs, router URLs, `/_zenith/image`, and `/__zenith/route-check` are prefixed with `basePath`.
+- Static emitted files stay adapter-neutral; adapters map the public base path to those canonical outputs.
+
+`router` behavior:
+
+- `router: true` enables client router bootstrap/runtime injection.
+- `router: false` disables client router bootstrap/runtime injection.
+- `assets/router-manifest.json` may still be emitted as an internal preview artifact. Its presence does not mean client router mode is enabled.
+
+`target` / `adapter` behavior:
+
+- `target` is the shorthand deployment target. Phase 1 defaults loaded config to `target: 'static'`.
+- `adapter` is the explicit adapter object form and is mutually exclusive with `target`.
+- `vercel-static` emits a Vercel Build Output API layout rooted at `outDir`.
+- `netlify-static` emits a Netlify publish directory rooted at `outDir`, including generated `_redirects` rewrites for dynamic prerendered routes.
+- `vercel` emits a Vercel Build Output API layout with packaged route functions for server-classified routes and static rewrites for prerendered dynamic routes.
+- `netlify` emits a deploy root with `publish/`, `functions/`, `netlify.toml`, and generated `_redirects` that force server-classified routes through packaged functions.
+- `node` emits a standalone Node artifact rooted at `outDir` with `index.js`, `package.json`, `manifest.json`, `static/`, and `server/`.
+
+Server-capable target contract:
+
+- Route classification stays upstream in the manifest and server package layers.
+- `.zenith-output/server` is the canonical packaged server contract consumed by adapters.
+- Adapters package classified output into host layouts; they do not reinterpret route meaning.
+
+Current limitations:
+
+- There is no separate `assetPrefix` knob. Assets intentionally follow `basePath`.
+- `vercel` and `netlify` do not yet emit a deployed `/_zenith/image` endpoint. The `node` target does.
+
 ## Commands
 
 ### `zenith dev`
@@ -30,7 +88,7 @@ Starts the development server on `localhost:3000`.
 Compiles and bundles your application for production.
 
 ### `zenith preview`
-Serves the locally built application for verification.
+Previews the locally built target contract for verification. Static targets serve built files; `target: 'node'` boots the built Node artifact.
 
 ### `zenith add <plugin>`
 Installs and configures a Zenith plugin.

package/dist/adapters/adapter-netlify-static.d.ts

@@ -0,0 +1,5 @@
+export namespace netlifyStaticAdapter {
+    let name: string;
+    function validateRoutes(manifest: any): void;
+    function adapt(options: any): Promise<void>;
+}

package/dist/adapters/adapter-netlify-static.js

@@ -0,0 +1,39 @@
+import { cp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createNetlifyBasePathAssetRules, createNetlifyRewriteRules } from './route-rules.js';
+function createRedirectsFile(manifest) {
+    const lines = [
+        '# Generated by Zenith netlify-static adapter',
+        ...createNetlifyBasePathAssetRules(manifest.base_path)
+    ];
+    const seen = new Set();
+    for (const route of manifest.routes) {
+        for (const line of createNetlifyRewriteRules(route, manifest.base_path)) {
+            if (seen.has(line)) {
+                continue;
+            }
+            seen.add(line);
+            lines.push(line);
+        }
+    }
+    return `${lines.join('\n')}\n`;
+}
+export const netlifyStaticAdapter = {
+    name: 'netlify-static',
+    validateRoutes(manifest) {
+        const serverRoutes = manifest.filter((entry) => entry.render_mode === 'server');
+        if (serverRoutes.length === 0) {
+            return;
+        }
+        const first = serverRoutes[0];
+        throw new Error(`[Zenith:Build] target "netlify-static" cannot emit server-rendered routes. ` +
+            `Route "${first.path}" (${first.file}) requires render_mode="server".`);
+    },
+    async adapt(options) {
+        const staticDir = join(options.coreOutput, 'static');
+        await rm(options.outDir, { recursive: true, force: true });
+        await mkdir(options.outDir, { recursive: true });
+        await cp(staticDir, options.outDir, { recursive: true, force: true });
+        await writeFile(join(options.outDir, '_redirects'), createRedirectsFile(options.manifest), 'utf8');
+    }
+};

package/dist/adapters/adapter-netlify.d.ts

@@ -0,0 +1,5 @@
+export namespace netlifyAdapter {
+    let name: string;
+    function validateRoutes(): void;
+    function adapt(options: any): Promise<void>;
+}

package/dist/adapters/adapter-netlify.js

@@ -0,0 +1,129 @@
+import { cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { prependBasePath } from '../base-path.js';
+import { compareRouteSpecificity } from '../server/resolve-request-route.js';
+import { createNetlifyBasePathAssetRules, createNetlifyRewriteRules } from './route-rules.js';
+function buildNetlifyServerRules(route, basePath = '/') {
+    const destination = `/.netlify/functions/__zenith_${route.name}`;
+    if (!Array.isArray(route.params) || route.params.length === 0) {
+        return [`${prependBasePath(basePath, route.path === '/' ? '/' : route.path)} ${destination} 200!`];
+    }
+    const segments = route.path.split('/').filter(Boolean);
+    const terminal = segments[segments.length - 1];
+    const prefix = segments.slice(0, -1).join('/');
+    const prefixPath = prefix ? `/${prefix}` : '';
+    if (terminal.startsWith('*') && terminal.endsWith('?')) {
+        const key = terminal.slice(1, -1);
+        const exactPath = prefixPath || '/';
+        const splatPath = prefixPath ? `${prefixPath}/*` : '/*';
+        return [
+            `${prependBasePath(basePath, exactPath)} ${destination}?__zenith_param_${key}= 200!`,
+            `${prependBasePath(basePath, splatPath)} ${destination}?__zenith_param_${key}=:splat 200!`
+        ];
+    }
+    if (terminal.startsWith('*')) {
+        const key = terminal.slice(1);
+        const splatPath = prefixPath ? `${prefixPath}/*` : '/*';
+        return [`${prependBasePath(basePath, splatPath)} ${destination}?__zenith_param_${key}=:splat 200!`];
+    }
+    const sourcePath = `/${segments.map((segment) => segment.startsWith(':') ? segment : segment).join('/')}`;
+    const query = route.params.map((param) => `__zenith_param_${param}=:${param}`).join('&');
+    return [`${prependBasePath(basePath, sourcePath)} ${destination}?${query} 200!`];
+}
+function createFunctionSource(route) {
+    return [
+        "import { fileURLToPath } from 'node:url';",
+        "import { dirname, join } from 'node:path';",
+        "import { renderRouteRequest, extractInternalParams } from './_zenith/runtime/route-render.js';",
+        '',
+        'const __dirname = dirname(fileURLToPath(import.meta.url));',
+        `const route = ${JSON.stringify(route, null, 2)};`,
+        '',
+        'export default async function(request) {',
+        '  const params = extractInternalParams(request.url, route);',
+        '  return renderRouteRequest({',
+        '    request,',
+        '    route,',
+        '    params,',
+        `    routeModulePath: join(__dirname, '_zenith', 'routes', ${JSON.stringify(route.name)}, 'route', 'entry.js'),`,
+        `    shellHtmlPath: join(__dirname, '_zenith', 'routes', ${JSON.stringify(route.name)}, 'route', 'page.html'),`,
+        `    pageAssetPath: ${route.page_asset_file ? "join(__dirname, '_zenith', 'routes', " + JSON.stringify(route.name) + ", 'route', " + JSON.stringify(route.page_asset_file) + ')' : 'null'},`,
+        `    imageManifestPath: ${route.image_manifest_file ? "join(__dirname, '_zenith', 'routes', " + JSON.stringify(route.name) + ", 'route', " + JSON.stringify(route.image_manifest_file) + ')' : 'null'},`,
+        `    imageConfig: ${JSON.stringify(route.image_config || {}, null, 2)}`,
+        '  });',
+        '}',
+        ''
+    ].join('\n');
+}
+async function loadServerManifest(coreOutput) {
+    try {
+        const parsed = JSON.parse(await readFile(join(coreOutput, 'server', 'manifest.json'), 'utf8'));
+        return Array.isArray(parsed.routes) ? parsed.routes : [];
+    }
+    catch {
+        return [];
+    }
+}
+function buildRedirectsFile(buildManifest, serverRoutes) {
+    const lines = [
+        '# Generated by Zenith netlify adapter',
+        ...createNetlifyBasePathAssetRules(buildManifest.base_path)
+    ];
+    const seen = new Set();
+    for (const route of [...serverRoutes].sort((left, right) => compareRouteSpecificity(left.path, right.path))) {
+        for (const line of buildNetlifyServerRules(route, buildManifest.base_path)) {
+            if (seen.has(line)) {
+                continue;
+            }
+            seen.add(line);
+            lines.push(line);
+        }
+    }
+    for (const route of buildManifest.routes.filter((entry) => entry.render_mode === 'prerender' && entry.path_kind === 'dynamic')) {
+        for (const line of createNetlifyRewriteRules(route, buildManifest.base_path)) {
+            if (seen.has(line)) {
+                continue;
+            }
+            seen.add(line);
+            lines.push(line);
+        }
+    }
+    return `${lines.join('\n')}\n`;
+}
+export const netlifyAdapter = {
+    name: 'netlify',
+    validateRoutes() { },
+    async adapt(options) {
+        const publishDir = join(options.outDir, 'publish');
+        const functionsDir = join(options.outDir, 'functions');
+        const staticDir = join(options.coreOutput, 'static');
+        // Route meaning is fixed upstream in the manifest/server package.
+        // The adapter only maps already-classified output into Netlify's layout.
+        const serverRoutes = await loadServerManifest(options.coreOutput);
+        await rm(options.outDir, { recursive: true, force: true });
+        await mkdir(publishDir, { recursive: true });
+        await mkdir(functionsDir, { recursive: true });
+        await cp(staticDir, publishDir, { recursive: true, force: true });
+        await writeFile(join(functionsDir, 'package.json'), '{\n  "type": "module"\n}\n', 'utf8');
+        if (serverRoutes.length > 0) {
+            await cp(join(options.coreOutput, 'server', 'runtime'), join(functionsDir, '_zenith', 'runtime'), { recursive: true, force: true });
+            await cp(join(options.coreOutput, 'server', 'images'), join(functionsDir, '_zenith', 'images'), { recursive: true, force: true });
+            await cp(join(options.coreOutput, 'server', 'base-path.js'), join(functionsDir, '_zenith', 'base-path.js'), { force: true });
+            await cp(join(options.coreOutput, 'server', 'server-contract.js'), join(functionsDir, '_zenith', 'server-contract.js'), { force: true });
+            for (const route of serverRoutes) {
+                await cp(join(options.coreOutput, 'server', 'routes', route.name), join(functionsDir, '_zenith', 'routes', route.name), { recursive: true, force: true });
+                await writeFile(join(functionsDir, `__zenith_${route.name}.mjs`), createFunctionSource(route), 'utf8');
+            }
+        }
+        await writeFile(join(publishDir, '_redirects'), buildRedirectsFile(options.manifest, serverRoutes), 'utf8');
+        await writeFile(join(options.outDir, 'netlify.toml'), [
+            '[build]',
+            'publish = "publish"',
+            '',
+            '[functions]',
+            'directory = "functions"',
+            'node_bundler = "esbuild"',
+            ''
+        ].join('\n'), 'utf8');
+    }
+};

package/dist/adapters/adapter-node.d.ts

@@ -0,0 +1,5 @@
+export namespace nodeAdapter {
+    let name: string;
+    function validateRoutes(): void;
+    function adapt(options: any): Promise<void>;
+}

package/dist/adapters/adapter-node.js

@@ -0,0 +1,121 @@
+import { cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+const PACKAGE_REQUIRE = createRequire(import.meta.url);
+const NODE_RUNTIME_FILES = [
+    {
+        from: new URL('../server-runtime/node-server.js', import.meta.url),
+        to: 'runtime/node-server.js'
+    },
+    {
+        from: new URL('../server/resolve-request-route.js', import.meta.url),
+        to: 'runtime/resolve-request-route.js'
+    },
+    {
+        from: new URL('../images/service.js', import.meta.url),
+        to: 'images/service.js'
+    }
+];
+function createNodeEntrySource() {
+    return [
+        "import { fileURLToPath } from 'node:url';",
+        "import { dirname, resolve } from 'node:path';",
+        "import { createNodeServer as createZenithNodeServer, createRequestHandler as createZenithRequestHandler } from './server/runtime/node-server.js';",
+        '',
+        'const __filename = fileURLToPath(import.meta.url);',
+        'const __dirname = dirname(__filename);',
+        '',
+        'export function createRequestHandler(options = {}) {',
+        '  return createZenithRequestHandler({',
+        '    distDir: __dirname,',
+        '    ...options',
+        '  });',
+        '}',
+        '',
+        'export function createNodeServer(options = {}) {',
+        '  return createZenithNodeServer({',
+        '    distDir: __dirname,',
+        '    ...options',
+        '  });',
+        '}',
+        '',
+        'const isDirectRun = process.argv[1] && resolve(process.argv[1]) === __filename;',
+        '',
+        'if (isDirectRun) {',
+        '  const port = process.env.PORT ? Number.parseInt(process.env.PORT, 10) : 3000;',
+        "  const host = process.env.HOST || '0.0.0.0';",
+        '  createNodeServer({ port, host }).then(({ port: actualPort }) => {',
+        "    const displayHost = host === '0.0.0.0' || host === '::' ? '127.0.0.1' : host;",
+        '    console.log(`http://${displayHost}:${actualPort}`);',
+        '  }).catch((error) => {',
+        '    console.error(error);',
+        '    process.exit(1);',
+        '  });',
+        '}',
+        ''
+    ].join('\n');
+}
+function createNodePackageJson() {
+    return {
+        private: true,
+        type: 'module',
+        main: './index.js'
+    };
+}
+function createSharpRuntimeSource() {
+    const sharpPath = PACKAGE_REQUIRE.resolve('sharp');
+    const fallbackUrl = pathToFileURL(sharpPath).href;
+    return [
+        'async function loadSharp() {',
+        '  try {',
+        "    const mod = await import('sharp');",
+        '    return mod.default || mod;',
+        '  } catch {',
+        `    const mod = await import(${JSON.stringify(fallbackUrl)});`,
+        '    return mod.default || mod;',
+        '  }',
+        '}',
+        '',
+        'const sharp = await loadSharp();',
+        'export default sharp;',
+        ''
+    ].join('\n');
+}
+async function copyNodeRuntimeFiles(serverDir) {
+    for (const file of NODE_RUNTIME_FILES) {
+        const targetPath = join(serverDir, file.to);
+        await mkdir(join(targetPath, '..'), { recursive: true });
+        await cp(file.from, targetPath, { force: true });
+    }
+    const imageServicePath = join(serverDir, 'images', 'service.js');
+    const imageServiceSource = await readFile(imageServicePath, 'utf8');
+    await writeFile(imageServicePath, imageServiceSource.replace("import sharp from 'sharp';", "import sharp from './sharp-runtime.js';"), 'utf8');
+    await writeFile(join(serverDir, 'images', 'sharp-runtime.js'), createSharpRuntimeSource(), 'utf8');
+}
+export const nodeAdapter = {
+    name: 'node',
+    validateRoutes() { },
+    async adapt(options) {
+        const staticDir = join(options.coreOutput, 'static');
+        const packagedServerDir = join(options.coreOutput, 'server');
+        const targetServerDir = join(options.outDir, 'server');
+        // Route meaning is fixed upstream in the manifest/server package.
+        // The adapter only maps already-classified output into a Node runtime layout.
+        await rm(options.outDir, { recursive: true, force: true });
+        await mkdir(options.outDir, { recursive: true });
+        await cp(staticDir, join(options.outDir, 'static'), { recursive: true, force: true });
+        await cp(packagedServerDir, targetServerDir, { recursive: true, force: true });
+        await copyNodeRuntimeFiles(targetServerDir);
+        await writeFile(join(options.outDir, 'manifest.json'), `${JSON.stringify(options.manifest, null, 2)}\n`, 'utf8');
+        await writeFile(join(targetServerDir, 'config.json'), `${JSON.stringify({
+            target: 'node',
+            base_path: options.manifest.base_path || '/',
+            static_dir: '../static',
+            build_manifest: '../manifest.json',
+            images: options.config?.images || {}
+        }, null, 2)}\n`, 'utf8');
+        await writeFile(join(options.outDir, 'index.js'), createNodeEntrySource(), 'utf8');
+        await writeFile(join(options.outDir, 'package.json'), `${JSON.stringify(createNodePackageJson(), null, 2)}\n`, 'utf8');
+    }
+};

package/dist/adapters/adapter-static.d.ts

@@ -0,0 +1,5 @@
+export namespace staticAdapter {
+    let name: string;
+    function validateRoutes(manifest: any): void;
+    function adapt(options: any): Promise<void>;
+}

package/dist/adapters/adapter-static.js

@@ -0,0 +1,20 @@
+import { cp, mkdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+export const staticAdapter = {
+    name: 'static',
+    validateRoutes(manifest) {
+        const serverRoutes = manifest.filter((entry) => entry.render_mode === 'server');
+        if (serverRoutes.length === 0) {
+            return;
+        }
+        const first = serverRoutes[0];
+        throw new Error(`[Zenith:Build] target "static" cannot emit server-rendered routes. ` +
+            `Route "${first.path}" (${first.file}) requires render_mode="server".`);
+    },
+    async adapt(options) {
+        const staticDir = join(options.coreOutput, 'static');
+        await rm(options.outDir, { recursive: true, force: true });
+        await mkdir(options.outDir, { recursive: true });
+        await cp(staticDir, options.outDir, { recursive: true, force: true });
+    }
+};

package/dist/adapters/adapter-types.d.ts

@@ -0,0 +1,44 @@
+export const KNOWN_TARGETS: string[];
+export type ZenithTarget = "static" | "vercel-static" | "netlify-static" | "vercel" | "netlify" | "node";
+export type ZenithRenderMode = "prerender" | "server";
+export type ZenithPathKind = "static" | "dynamic";
+export type RouteManifestEntry = {
+    path: string;
+    file: string;
+    path_kind: ZenithPathKind;
+    render_mode: ZenithRenderMode;
+    params: string[];
+};
+export type BuildManifest = {
+    schema_version: number;
+    zenith_version: string;
+    target: string;
+    base_path: string;
+    content_hash: string;
+    routes: Array<{
+        path: string;
+        file: string;
+        path_kind: ZenithPathKind;
+        render_mode: ZenithRenderMode;
+        requires_hydration: boolean;
+        params: string[];
+        html: string;
+        assets: string[];
+    }>;
+    assets: {
+        js: string[];
+        css: string[];
+        vendor: string | null;
+    };
+};
+export type AdaptOptions = {
+    coreOutput: string;
+    outDir: string;
+    manifest: BuildManifest;
+    config: object;
+};
+export type ZenithAdapter = {
+    name: string;
+    validateRoutes: (manifest: RouteManifestEntry[]) => void;
+    adapt: (options: AdaptOptions) => Promise<void>;
+};

package/dist/adapters/adapter-types.js

@@ -0,0 +1,65 @@
+export const KNOWN_TARGETS = [
+    'static',
+    'vercel-static',
+    'netlify-static',
+    'vercel',
+    'netlify',
+    'node'
+];
+/**
+ * @typedef {'static' | 'vercel-static' | 'netlify-static' | 'vercel' | 'netlify' | 'node'} ZenithTarget
+ */
+/**
+ * @typedef {'prerender' | 'server'} ZenithRenderMode
+ */
+/**
+ * @typedef {'static' | 'dynamic'} ZenithPathKind
+ */
+/**
+ * @typedef {{
+ *   path: string,
+ *   file: string,
+ *   path_kind: ZenithPathKind,
+ *   render_mode: ZenithRenderMode,
+ *   params: string[]
+ * }} RouteManifestEntry
+ */
+/**
+ * @typedef {{
+ *   schema_version: number,
+ *   zenith_version: string,
+ *   target: string,
+ *   base_path: string,
+ *   content_hash: string,
+ *   routes: Array<{
+ *     path: string,
+ *     file: string,
+ *     path_kind: ZenithPathKind,
+ *     render_mode: ZenithRenderMode,
+ *     requires_hydration: boolean,
+ *     params: string[],
+ *     html: string,
+ *     assets: string[]
+ *   }>,
+ *   assets: {
+ *     js: string[],
+ *     css: string[],
+ *     vendor: string | null
+ *   }
+ * }} BuildManifest
+ */
+/**
+ * @typedef {{
+ *   coreOutput: string,
+ *   outDir: string,
+ *   manifest: BuildManifest,
+ *   config: object
+ * }} AdaptOptions
+ */
+/**
+ * @typedef {{
+ *   name: string,
+ *   validateRoutes: (manifest: RouteManifestEntry[]) => void,
+ *   adapt: (options: AdaptOptions) => Promise<void>
+ * }} ZenithAdapter
+ */

package/dist/adapters/adapter-vercel-static.d.ts

@@ -0,0 +1,5 @@
+export namespace vercelStaticAdapter {
+    let name: string;
+    function validateRoutes(manifest: any): void;
+    function adapt(options: any): Promise<void>;
+}

package/dist/adapters/adapter-vercel-static.js

@@ -0,0 +1,36 @@
+import { cp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createVercelBasePathAssetRoutes, createVercelRouteSource } from './route-rules.js';
+function createConfig(manifest) {
+    return {
+        version: 3,
+        routes: [
+            ...createVercelBasePathAssetRoutes(manifest.base_path),
+            { handle: 'filesystem' },
+            ...manifest.routes.map((route) => ({
+                src: createVercelRouteSource(route.path, manifest.base_path),
+                dest: route.html
+            }))
+        ]
+    };
+}
+export const vercelStaticAdapter = {
+    name: 'vercel-static',
+    validateRoutes(manifest) {
+        const serverRoutes = manifest.filter((entry) => entry.render_mode === 'server');
+        if (serverRoutes.length === 0) {
+            return;
+        }
+        const first = serverRoutes[0];
+        throw new Error(`[Zenith:Build] target "vercel-static" cannot emit server-rendered routes. ` +
+            `Route "${first.path}" (${first.file}) requires render_mode="server".`);
+    },
+    async adapt(options) {
+        const staticDir = join(options.coreOutput, 'static');
+        const vercelStaticDir = join(options.outDir, 'static');
+        await rm(options.outDir, { recursive: true, force: true });
+        await mkdir(vercelStaticDir, { recursive: true });
+        await cp(staticDir, vercelStaticDir, { recursive: true, force: true });
+        await writeFile(join(options.outDir, 'config.json'), `${JSON.stringify(createConfig(options.manifest), null, 2)}\n`, 'utf8');
+    }
+};

package/dist/adapters/adapter-vercel.d.ts

@@ -0,0 +1,5 @@
+export namespace vercelAdapter {
+    let name: string;
+    function validateRoutes(): void;
+    function adapt(options: any): Promise<void>;
+}