@vesk/adapter 0.0.1

package/dist/index.js

@@ -0,0 +1,291 @@
+import { mkdirSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
+import { resolve, dirname, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { cssBlockEnd } from '@vesk/compiler/src/scan';
+import { bundleRuntime } from '@vesk/adapter/src/runtime-bundle';
+import { generateSsrFunction } from '@vesk/adapter/src/ssr-function';
+import { collectActionIds } from '@vesk/compiler/src/actions';
+import { generateApiFunction } from '@vesk/adapter/src/api-function';
+import { compileMiddleware, compileMiddlewareCode } from '@vesk/adapter/src/middleware';
+import { generateClientBundle } from '@vesk/adapter/src/client-bundle';
+import { generateManifest } from '@vesk/adapter/src/manifest';
+import { copyStaticAssets } from '@vesk/adapter/src/static';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+async function resolveCompilerApi(name) {
+    const monorepoSrc = resolve(__dirname, '..', '..', 'compiler', 'src');
+    if (existsSync(monorepoSrc)) {
+        const tsFile = resolve(monorepoSrc, name.replace(/\.js$/, '.ts'));
+        if (existsSync(tsFile)) {
+            return import(tsFile);
+        }
+        return import(resolve(monorepoSrc, name));
+    }
+    return import(`@vesk/compiler/src/${name.replace(/\.js$/, '')}`);
+}
+export async function build(appDir, options) {
+    appDir = resolve(appDir);
+    const outDir = resolve(options?.outDir || resolve(appDir, '..', '.vesk'));
+    const publicDir = options?.publicDir || resolve(appDir, '..', 'public');
+    const plugins = options?.plugins || [];
+    for (const plugin of plugins) {
+        if (typeof plugin.onBuildStart === 'function') {
+            await plugin.onBuildStart();
+        }
+    }
+    console.error(`vesk build: output → ${outDir}`);
+    const dirs = [
+        resolve(outDir, 'server', 'functions'),
+        resolve(outDir, 'server', 'api'),
+        resolve(outDir, 'static', 'public'),
+        resolve(outDir, 'prerendered'),
+    ];
+    for (const d of dirs)
+        mkdirSync(d, { recursive: true });
+    const { scanRoutes, scanComponents } = await resolveCompilerApi('router.js');
+    const { scanApiRoutes } = await resolveCompilerApi('api-routes.js');
+    const { collectMiddlewareChain } = await resolveCompilerApi('middleware.js');
+    const routeTree = scanRoutes(appDir);
+    if (routeTree.length === 0) {
+        console.error('vesk build: no routes found in', appDir);
+        return;
+    }
+    const projectRoot = resolve(appDir, '..');
+    const componentsDir = resolve(projectRoot, 'components');
+    const componentMap = scanComponents(componentsDir);
+    if (componentMap.size > 0) {
+        console.error(`vesk build: ${componentMap.size} external components found in ${componentsDir}`);
+    }
+    const apiDir = resolve(appDir, 'api');
+    const apiTree = existsSync(apiDir) ? scanApiRoutes(apiDir) : [];
+    console.error(`vesk build: ${routeTree.length} root routes, ${apiTree.length} API routes`);
+    console.error('vesk build: bundling server runtime...');
+    await bundleRuntime(appDir, outDir);
+    const ssrRoutes = [];
+    const actionMap = {};
+    function walk(nodes, ancestorLayouts = []) {
+        for (const node of nodes) {
+            const childAncestorLayouts = node.layout
+                ? [...ancestorLayouts, { sourceDir: node.sourceDir, layoutCompName: node.layout }]
+                : ancestorLayouts;
+            if (node.page) {
+                const mwChain = collectMiddlewareChain(routeTree, node.fullPath, appDir);
+                let mwCode = null;
+                if (mwChain.length > 0) {
+                    const mwSources = mwChain.map((m) => readFileSync(m.sourcePath, 'utf-8'));
+                    mwCode = compileMiddlewareCode(mwSources);
+                }
+                const { funcPath, funcCode, name } = generateSsrFunction(node, appDir, outDir, componentMap, { ancestorLayouts, middlewareCode: mwCode });
+                writeFileSync(funcPath, funcCode, 'utf-8');
+                const pagePath = resolve(appDir, node.sourceDir, 'page.vsk');
+                if (existsSync(pagePath)) {
+                    const src = readFileSync(pagePath, 'utf-8');
+                    const actionIds = collectActionIds(src);
+                    if (node.layout) {
+                        const layoutSrc = readFileSync(resolve(appDir, node.sourceDir, 'layout.vsk'), 'utf-8');
+                        actionIds.push(...collectActionIds(layoutSrc));
+                    }
+                    for (const a of ancestorLayouts) {
+                        const ancestorSrc = readFileSync(resolve(appDir, a.sourceDir, 'layout.vsk'), 'utf-8');
+                        actionIds.push(...collectActionIds(ancestorSrc));
+                    }
+                    for (const id of actionIds) {
+                        if (!actionMap[id])
+                            actionMap[id] = `server/functions/${name}.js`;
+                    }
+                    const revalidateMatch = src.match(/export\s+const\s+revalidate\s*=\s*(\d+)/);
+                    if (revalidateMatch)
+                        node._revalidate = parseInt(revalidateMatch[1], 10);
+                    const tagsMatch = src.match(/export\s+const\s+isrTags\s*=\s*\[([^\]]*)\]/);
+                    if (tagsMatch) {
+                        node._isrTags = tagsMatch[1].split(',').map(t => t.trim().replace(/['"]/g, '')).filter(Boolean);
+                    }
+                }
+                ssrRoutes.push(node);
+                console.error(`vesk build: ssr  → server/functions/${name}.js  (${node.fullPath})${mwCode ? ' [mw]' : ''}`);
+            }
+            walk(node.children || [], childAncestorLayouts);
+        }
+    }
+    walk(routeTree);
+    const apiRoutes = [];
+    function walkApi(nodes) {
+        for (const node of nodes) {
+            if (node.filePath) {
+                const { funcPath, funcCode, name } = generateApiFunction(node, apiDir, outDir);
+                writeFileSync(funcPath, funcCode, 'utf-8');
+                apiRoutes.push(node);
+                console.error(`vesk build: api  → server/api/${name}.js  (${node.fullPath})`);
+            }
+            walkApi(node.children || []);
+        }
+    }
+    walkApi(apiTree);
+    let middlewareEnabled = false;
+    const mwChain = collectMiddlewareChain(routeTree, '/', appDir);
+    if (mwChain.length > 0) {
+        const mwCode = compileMiddleware(mwChain, appDir);
+        if (mwCode) {
+            writeFileSync(resolve(outDir, 'server', 'middleware.js'), mwCode, 'utf-8');
+            middlewareEnabled = true;
+            console.error(`vesk build: mw   → server/middleware.js  (${mwChain.length} middlewares)`);
+        }
+    }
+    console.error('vesk build: bundling client runtime...');
+    const bundleOpts = {};
+    if (options?.codeSplit)
+        bundleOpts.codeSplit = true;
+    if (options?.hmr)
+        bundleOpts.hmr = true;
+    if (options?.routeDataCache !== undefined)
+        bundleOpts.routeDataCache = options.routeDataCache;
+    const { main, chunks } = await generateClientBundle(routeTree, appDir, componentMap, bundleOpts);
+    writeFileSync(resolve(outDir, 'static', 'client.js'), main, 'utf-8');
+    const mode = chunks.length > 0 ? 'code-split' : 'monolithic';
+    console.error(`vesk build: client → static/client.js  (${main.length} bytes, ${mode})`);
+    if (chunks.length > 0) {
+        const staticDir = resolve(outDir, 'static');
+        for (const chunk of chunks) {
+            writeFileSync(resolve(staticDir, chunk.name), chunk.code, 'utf-8');
+            console.error(`vesk build: chunk → static/${chunk.name}  (${chunk.code.length} bytes)`);
+        }
+    }
+    copyStaticAssets(publicDir, outDir);
+    console.error('vesk build: static → static/public/');
+    const srcDir = resolve(appDir, '..', 'src');
+    const cssSrc = resolve(srcDir, 'global.css');
+    const altCssSrc = resolve(srcDir, 'app.css');
+    let cssContent = null;
+    let cssSourcePath = null;
+    if (existsSync(cssSrc)) {
+        cssContent = readFileSync(cssSrc, 'utf-8');
+        cssSourcePath = cssSrc;
+    }
+    else if (existsSync(altCssSrc)) {
+        cssContent = readFileSync(altCssSrc, 'utf-8');
+        cssSourcePath = altCssSrc;
+    }
+    function stripTailwindDirectives(css) {
+        const blockStart = /^\s*@(theme\s*\{|layer\s+(components|utilities)\s*\{|utility\s+\w+\s*\{)/;
+        let result = css.replace(/^\s*@import\s+['"]tailwindcss['"]\s*;?\s*$/gm, '');
+        result = result.replace(/^\s*@source\s+['"][^'"]+['"]\s*;?\s*$/gm, '');
+        const output = [];
+        let pos = 0;
+        while (pos < result.length) {
+            const lineEnd = result.indexOf('\n', pos) === -1 ? result.length : result.indexOf('\n', pos) + 1;
+            const line = result.slice(pos, lineEnd);
+            if (blockStart.test(line.trim())) {
+                const end = cssBlockEnd(result, pos);
+                pos = end;
+                continue;
+            }
+            output.push(line);
+            pos = lineEnd;
+        }
+        return output.join('').trim();
+    }
+    if (cssContent !== null) {
+        const userCss = stripTailwindDirectives(cssContent);
+        const userCssTarget = resolve(outDir, 'static', 'global.css');
+        writeFileSync(userCssTarget, userCss, 'utf-8');
+        console.error(`vesk build: css  → static/global.css  (${userCss.length} bytes)`);
+        let twCss = cssContent;
+        for (const plugin of plugins) {
+            if (typeof plugin.onCSS === 'function') {
+                const result = await plugin.onCSS(twCss, cssSourcePath);
+                if (result !== null && typeof result === 'string') {
+                    twCss = result;
+                }
+            }
+        }
+        const twCssTarget = resolve(outDir, 'static', '_tailwind.css');
+        const hasUnresolvedTailwindImport = /@import\s+['"]tailwindcss['"]/.test(twCss);
+        if (hasUnresolvedTailwindImport) {
+            const lines = twCss.split('\n').filter(l => !/^\s*@import\s+['"]tailwindcss['"]/.test(l));
+            twCss = lines.join('\n').trim();
+            if (twCss.length === 0) {
+                writeFileSync(twCssTarget, '', 'utf-8');
+                console.error('vesk build: css  → static/_tailwind.css  (empty, tailwind unresolved)');
+            }
+            else {
+                writeFileSync(twCssTarget, twCss, 'utf-8');
+                console.error(`vesk build: css  → static/_tailwind.css  (${twCss.length} bytes, tailwind partially unresolved)`);
+            }
+        }
+        else {
+            writeFileSync(twCssTarget, twCss, 'utf-8');
+            console.error(`vesk build: css  → static/_tailwind.css  (${twCss.length} bytes)`);
+        }
+    }
+    let prerenderedRoutes = [];
+    if (options?.ssg) {
+        const { generateSsgRoutes } = await import('./static.js');
+        prerenderedRoutes = await generateSsgRoutes(routeTree, appDir, outDir);
+        console.error(`vesk build: ssg   → prerendered/  (${prerenderedRoutes.length} pages)`);
+    }
+    {
+        const { optimizeImages } = await import('./image-pipeline.js');
+        await optimizeImages(appDir, outDir);
+    }
+    if (options?.seo) {
+        const { runSeoAudit } = await import('./seo-audit.js');
+        const audit = runSeoAudit(appDir);
+        if (options?.strictSeo && audit.errors > 0) {
+            throw new Error(`SEO audit failed with ${audit.errors} error(s) — fix them before deploying`);
+        }
+    }
+    {
+        const { optimizeImages } = await import('./image-pipeline.js');
+        await optimizeImages(appDir, outDir);
+    }
+    {
+        const { generateSitemap, generateRobotsTxt } = await import('./static.js');
+        const publicDirResolved = resolve(outDir, 'static', 'public');
+        const siteUrl = options?.siteUrl || 'http://localhost:3000';
+        const sitemapOverride = resolve(publicDirResolved, 'sitemap.xml');
+        if (!existsSync(sitemapOverride)) {
+            const sitemap = generateSitemap(routeTree, ssrRoutes, prerenderedRoutes, { siteUrl });
+            writeFileSync(sitemapOverride, sitemap, 'utf-8');
+            console.error(`vesk build: seo   → static/public/sitemap.xml (${sitemap.length} bytes)`);
+        }
+        const robotsOverride = resolve(publicDirResolved, 'robots.txt');
+        if (!existsSync(robotsOverride)) {
+            const robots = generateRobotsTxt(siteUrl);
+            writeFileSync(robotsOverride, robots, 'utf-8');
+            console.error(`vesk build: seo   → static/public/robots.txt (${robots.length} bytes)`);
+        }
+    }
+    const manifest = generateManifest(routeTree, ssrRoutes, apiRoutes, prerenderedRoutes, middlewareEnabled, actionMap);
+    writeFileSync(resolve(outDir, 'config.json'), JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
+    console.error('vesk build: config → config.json');
+    {
+        const { detectPlatform } = await import('@vesk/adapter/src/platform');
+        const { emitPlatformOutput } = await import('@vesk/adapter/src/platform-deploy');
+        let platform = detectPlatform(options?.platform ? ['--platform', options.platform] : [], process.env);
+        if (platform === 'node' && options?.target === 'edge')
+            platform = 'edge';
+        if (platform !== 'node') {
+            const outRoot = await emitPlatformOutput(platform, {
+                outDir,
+                ssrRoutes,
+                apiRoutes,
+                prerenderedPaths: prerenderedRoutes.map(r => r.path),
+                prerenderedRoutes,
+                hasMiddleware: middlewareEnabled,
+            });
+            if (outRoot) {
+                console.error(`vesk build: ${platform} → ${relative(projectRoot, outRoot)}`);
+                if (platform === 'vercel') {
+                    console.error('vesk build: vercel → .vercel/output (symlink)');
+                }
+            }
+        }
+    }
+    for (const plugin of plugins) {
+        if (typeof plugin.onBuildEnd === 'function') {
+            await plugin.onBuildEnd();
+        }
+    }
+    console.error(`\nvesk build: done (${outDir})`);
+    return { routeTree, apiTree, ssrRoutes, apiRoutes, manifest };
+}
+export { startProdServer } from '@vesk/adapter/src/prod-server';

package/dist/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { RouteNode, ApiRouteNode, Manifest, SsgRouteResult } from '@vesk/adapter/src/types';
+export declare function generateManifest(routes: RouteNode[], ssrRoutes: RouteNode[], apiRoutes: ApiRouteNode[], staticRoutes: SsgRouteResult[], middlewareEnabled: boolean, actionMap?: Record<string, string>): Manifest;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAqE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEpK,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,EAAE,EACnB,SAAS,EAAE,SAAS,EAAE,EACtB,SAAS,EAAE,YAAY,EAAE,EACzB,YAAY,EAAE,cAAc,EAAE,EAC9B,iBAAiB,EAAE,OAAO,EAC1B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,QAAQ,CAiDV"}

package/dist/manifest.js

@@ -0,0 +1,47 @@
+export function generateManifest(routes, ssrRoutes, apiRoutes, staticRoutes, middlewareEnabled, actionMap) {
+    const routeEntries = [];
+    for (const r of ssrRoutes) {
+        const urlParts = r.fullPath.split('/').filter(Boolean);
+        const name = urlParts.map(s => s.startsWith(':') ? s.slice(1) : s).join('_') || 'index';
+        const entry = {
+            path: r.fullPath,
+            type: 'ssr',
+            function: `server/functions/${name}.js`,
+        };
+        if (r._revalidate != null)
+            entry.revalidate = r._revalidate;
+        if (r._isrTags)
+            entry.tags = r._isrTags;
+        routeEntries.push(entry);
+    }
+    for (const r of apiRoutes) {
+        const urlParts = r.fullPath.split('/').filter(Boolean);
+        const name = urlParts.map(s => s.startsWith(':') ? s.slice(1) || 'param' : s).join('_') || 'index';
+        routeEntries.push({
+            path: `/api${r.fullPath}`,
+            type: 'api',
+            function: `server/api/${name}.js`,
+        });
+    }
+    const ssgEntries = [];
+    for (const r of staticRoutes) {
+        ssgEntries.push({
+            path: r.path,
+            file: `prerendered${r.path === '/' ? '/index' : r.path}.html`,
+        });
+    }
+    const actionEntries = actionMap
+        ? Object.entries(actionMap).map(([id, fn]) => ({ id, function: fn }))
+        : [];
+    return {
+        version: 1,
+        middleware: middlewareEnabled,
+        routes: routeEntries,
+        prerendered: ssgEntries,
+        static: {
+            prefix: '/_vesk/static',
+            dir: 'static',
+        },
+        ...(actionEntries.length > 0 ? { actions: actionEntries } : {}),
+    };
+}

package/dist/middleware.d.ts

@@ -0,0 +1,4 @@
+import type { MiddlewareChainItem } from '@vesk/adapter/src/types';
+export declare function compileMiddleware(mwChain: MiddlewareChainItem[], _appDir: string): string | null;
+export declare function compileMiddlewareCode(mwSourceTexts: string[]): string | null;
+//# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../src/middleware.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAA2B,MAAM,yBAAyB,CAAC;AAS5F,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,mBAAmB,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA6ChG;AAED,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CA2C5E"}

package/dist/middleware.js

@@ -0,0 +1,96 @@
+import { readFileSync } from 'node:fs';
+import { extractMiddlewareParts } from '@vesk/compiler/src/router';
+function extractMiddlewareBody(src) {
+    const parts = extractMiddlewareParts(src);
+    if (!parts)
+        return null;
+    return { params: parts.params, body: parts.body };
+}
+export function compileMiddleware(mwChain, _appDir) {
+    if (mwChain.length === 0)
+        return null;
+    const parts = [];
+    for (let i = 0; i < mwChain.length; i++) {
+        const { sourcePath } = mwChain[i];
+        const src = readFileSync(sourcePath, 'utf-8');
+        const extracted = extractMiddlewareBody(src);
+        if (!extracted)
+            continue;
+        parts.push(`async function mw_${i}(${extracted.params}) {\n${extracted.body}\n}`);
+    }
+    if (parts.length === 0)
+        return null;
+    const code = [
+        '// Auto-generated middleware chain — do not edit',
+        '',
+        parts.join('\n\n'),
+        '',
+        `const chain = [${parts.map((_, i) => `mw_${i}`).join(', ')}];`,
+        '',
+        'export async function execute(ctx) {',
+        '  let rewriteUrl = null;',
+        '  async function run(index) {',
+        '    if (index >= chain.length) return null;',
+        '    const fn = chain[index];',
+        '    let nextCalled = false;',
+        '    async function next(rewrite) {',
+        '      if (nextCalled) return null;',
+        '      nextCalled = true;',
+        '      if (rewrite) rewriteUrl = rewrite;',
+        '      return run(index + 1);',
+        '    }',
+        '    const result = await fn(ctx, next);',
+        '    if (result instanceof Response) return result;',
+        '    if (!nextCalled) return run(index + 1);',
+        '    return null;',
+        '  }',
+        '  const response = await run(0);',
+        '  return { response, rewriteUrl };',
+        '}',
+        '',
+    ].join('\n');
+    return code;
+}
+export function compileMiddlewareCode(mwSourceTexts) {
+    if (!mwSourceTexts || mwSourceTexts.length === 0)
+        return null;
+    const parts = [];
+    for (let i = 0; i < mwSourceTexts.length; i++) {
+        const extracted = extractMiddlewareBody(mwSourceTexts[i]);
+        if (!extracted)
+            continue;
+        parts.push(`async function mw_${i}(${extracted.params}) {\n${extracted.body}\n}`);
+    }
+    if (parts.length === 0)
+        return null;
+    const code = [
+        '// ── Middleware chain (inline) ──',
+        '',
+        parts.join('\n\n'),
+        '',
+        `const __mwChain = [${parts.map((_, i) => `mw_${i}`).join(', ')}];`,
+        '',
+        'async function __executeMw(ctx) {',
+        '  let rewriteUrl = null;',
+        '  async function run(index) {',
+        '    if (index >= __mwChain.length) return null;',
+        '    const fn = __mwChain[index];',
+        '    let nc = false;',
+        '    async function next(rewrite) {',
+        '      if (nc) return null;',
+        '      nc = true;',
+        '      if (rewrite) rewriteUrl = rewrite;',
+        '      return run(index + 1);',
+        '    }',
+        '    const result = await fn(ctx, next);',
+        '    if (result instanceof Response) return result;',
+        '    if (!nc) return run(index + 1);',
+        '    return null;',
+        '  }',
+        '  const response = await run(0);',
+        '  return { response, rewriteUrl };',
+        '}',
+        '',
+    ].join('\n');
+    return code;
+}

package/dist/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@vesk/adapter",
+  "version": "0.1.9",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./src/*": "./*.js",
+    "./package.json": "./package.json"
+  }
+}

package/dist/platform-deploy.d.ts

@@ -0,0 +1,18 @@
+import { type PlatformBuildContext } from '@vesk/adapter/src/platform-handler';
+import type { SsgRouteResult } from '@vesk/adapter/src/types';
+import type { Platform } from '@vesk/adapter/src/platform';
+export interface DeployContext extends PlatformBuildContext {
+    prerenderedRoutes: SsgRouteResult[];
+}
+/**
+ * Universal deployment emit. The handler, the bundle and the static layout are
+ * shared across every platform — only the ~10-line shell each runtime mandates
+ * differs (artifact directory, bootstrap, function config). Deno-based platforms
+ * (Coxmos, Deno Deploy) share the exact same shell.
+ *
+ * Every artifact is written under `.vesk/<platform>/`; Vercel additionally gets
+ * a gitignored `.vercel/output` symlink because the Build Output API is keyed on
+ * that literal directory.
+ */
+export declare function emitPlatformOutput(platform: Platform, ctx: DeployContext): Promise<string | null>;
+//# sourceMappingURL=platform-deploy.d.ts.map

package/dist/platform-deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-deploy.d.ts","sourceRoot":"","sources":["../src/platform-deploy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAwD,KAAK,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAErI,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAE3D,MAAM,WAAW,aAAc,SAAQ,oBAAoB;IACzD,iBAAiB,EAAE,cAAc,EAAE,CAAC;CACrC;AA0BD;;;;;;;;;GASG;AACH,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAyEvG"}