@vesk/adapter 0.0.1

package/dist/hmr.js

@@ -0,0 +1,411 @@
+import { WebSocketServer } from 'ws';
+import { readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { compileClient } from '@vesk/compiler/src/client-codegen';
+import { resolveComponentName } from '@vesk/compiler/src/server-codegen';
+import { resolveErrorFile } from '@vesk/adapter/src/ssr-function';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function findRouteForSource(routeTree, sourceDir) {
+    for (const node of routeTree) {
+        if (node.sourceDir === sourceDir)
+            return node;
+        if (node.children) {
+            const found = findRouteForSource(node.children, sourceDir);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+function collectAncestorLayouts(routeTree, sourceDir, chain = []) {
+    for (const node of routeTree) {
+        if (node.sourceDir === sourceDir)
+            return chain;
+        if (node.children) {
+            const nextChain = node.layout
+                ? [...chain, { sourceDir: node.sourceDir, layoutCompName: node.layout }]
+                : chain;
+            const found = collectAncestorLayouts(node.children, sourceDir, nextChain);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+function extractComponentAssignments(code) {
+    const assignments = [];
+    const startRegex = /__components\["(\w+)"\]\s*=\s*/;
+    const lines = code.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const m = lines[i].match(startRegex);
+        if (m) {
+            const name = m[1];
+            const startIdx = i;
+            let braceDepth = 0;
+            for (let j = 0; j < lines[i].length; j++) {
+                if (lines[i][j] === '{')
+                    braceDepth++;
+                if (lines[i][j] === '}')
+                    braceDepth--;
+            }
+            i++;
+            while (i < lines.length && braceDepth > 0) {
+                for (let j = 0; j < lines[i].length; j++) {
+                    if (lines[i][j] === '{')
+                        braceDepth++;
+                    if (lines[i][j] === '}')
+                        braceDepth--;
+                }
+                i++;
+            }
+            const fullAssignment = lines.slice(startIdx, i).join('\n');
+            assignments.push({ name, raw: fullAssignment });
+        }
+        else {
+            i++;
+        }
+    }
+    return assignments;
+}
+function extractSourceDir(filename) {
+    if (filename === 'page.vsk')
+        return '';
+    if (filename.endsWith('/page.vsk'))
+        return filename.slice(0, -'/page.vsk'.length);
+    if (filename === 'layout.vsk')
+        return '';
+    if (filename.endsWith('/layout.vsk'))
+        return filename.slice(0, -'/layout.vsk'.length);
+    return null;
+}
+function escapeSource(src) {
+    return src.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$/g, '\\$');
+}
+function extractCompName(src) {
+    return resolveComponentName(src);
+}
+function routeName(segments) {
+    const parts = segments.filter(Boolean).map(s => {
+        if (s.startsWith(':'))
+            return s.slice(1) || 'param';
+        return s;
+    });
+    return parts.join('_') || 'index';
+}
+function buildParamExtraction(node, urlParts) {
+    const parts = [];
+    let partIdx = Math.max(0, urlParts.length - 1);
+    function walk(n) {
+        if (n.fullPath === '/') {
+            for (const child of (n.children || []))
+                walk(child);
+            return;
+        }
+        if (n.isGroup) {
+            for (const child of (n.children || []))
+                walk(child);
+            return;
+        }
+        if (partIdx >= urlParts.length)
+            return;
+        if (n.isCatchAll) {
+            const paramName = n.path.startsWith(':') ? n.path.slice(1) : 'slug';
+            parts.push(`${JSON.stringify(paramName)}: urlParts.slice(${partIdx}).join('/')`);
+            partIdx = urlParts.length;
+            return;
+        }
+        if (n.isDynamic) {
+            const paramName = n.path.startsWith(':') ? n.path.slice(1) : 'param';
+            parts.push(`${JSON.stringify(paramName)}: urlParts[${partIdx}]`);
+            partIdx++;
+            for (const child of (n.children || []))
+                walk(child);
+            return;
+        }
+        if (n.path === urlParts[partIdx]) {
+            partIdx++;
+            for (const child of (n.children || []))
+                walk(child);
+        }
+    }
+    walk(node);
+    return parts;
+}
+function regenerateSsrFunction(routeNode, appDir, outDir, componentMap, options) {
+    const ancestorLayouts = options?.ancestorLayouts || [];
+    const pagePath = resolve(appDir, routeNode.sourceDir, 'page.vsk');
+    const layoutPath = resolve(appDir, routeNode.sourceDir, 'layout.vsk');
+    const tailwindPath = resolve(outDir, 'static', '_tailwind.css');
+    const globalCssPath = resolve(appDir, '..', 'src', 'global.css');
+    const altCssPath = resolve(appDir, '..', 'src', 'app.css');
+    const hasGlobalCss = existsSync(globalCssPath) || existsSync(altCssPath);
+    const hasTailwind = existsSync(tailwindPath) && readFileSync(tailwindPath, 'utf-8').trim().length > 0;
+    const cssUrls = [];
+    if (hasTailwind)
+        cssUrls.push('/_vesk/static/_tailwind.css');
+    if (hasGlobalCss)
+        cssUrls.push('/_vesk/static/global.css');
+    const cssOption = cssUrls.length > 0 ? `, cssUrls: ${JSON.stringify(cssUrls)}` : '';
+    const parts = routeNode.fullPath.split('/').filter(Boolean);
+    const name = routeName(parts);
+    const funcDir = resolve(outDir, 'server', 'functions');
+    const funcPath = resolve(funcDir, `${name}.js`);
+    const hasLayout = !!routeNode.layout;
+    const hasAncestorLayout = ancestorLayouts.length > 0;
+    const pageSrc = readFileSync(pagePath, 'utf-8');
+    const pageComp = extractCompName(pageSrc) || 'Page';
+    const errorPath = resolveErrorFile(routeNode.sourceDir, appDir);
+    const errorSrc = errorPath ? readFileSync(errorPath, 'utf-8') : null;
+    const errorComp = errorPath ? (extractCompName(errorSrc) || 'Error') : null;
+    const errorVars = errorPath
+        ? `const _errorSrc = \`${escapeSource(errorSrc)}\`;\nconst _errorComp = ${JSON.stringify(errorComp)};\nconst _errorPath = ${JSON.stringify(errorPath)};\nconst _errorCompiled = (() => { try { setVskHydrate(true); return compileFile(_errorSrc, { sourcePath: _errorPath }); } catch { return null; } finally { setVskHydrate(false); } })();\n`
+        : 'const _errorSrc = null;\nconst _errorComp = null;\nconst _errorPath = null;\nconst _errorCompiled = null;\n';
+    const clientScriptOption = ', clientScriptUrl: "/_vesk/static/client.js"';
+    const dataScriptOption = ', externalDataScript: storeDataScriptGlobal';
+    let src = '';
+    if (hasLayout) {
+        const layoutSrc = readFileSync(layoutPath, 'utf-8');
+        const layoutComp = extractCompName(layoutSrc) || 'Layout';
+        src = `const _layoutSrc = \`${escapeSource(layoutSrc)}\`;\nconst _pageSrc = \`${escapeSource(pageSrc)}\`;\n`;
+        src += `const _layoutComp = ${JSON.stringify(layoutComp)};\nconst _pageComp = ${JSON.stringify(pageComp)};\n`;
+        src += `const _layoutPath = ${JSON.stringify(layoutPath)};\nconst _pagePath = ${JSON.stringify(pagePath)};\n`;
+        src += `const _layoutCompiled = (() => { try { setVskHydrate(true); return compileFile(_layoutSrc, { sourcePath: _layoutPath }); } catch { return null; } finally { setVskHydrate(false); } })();\n`;
+        src += `const _pageCompiled = (() => { try { setVskHydrate(true); return compileFile(_pageSrc, { sourcePath: _pagePath }); } catch { return null; } finally { setVskHydrate(false); } })();\n`;
+        src += errorVars;
+    }
+    else if (hasAncestorLayout) {
+        const outerLayout = ancestorLayouts[0];
+        const outerLayoutPath = resolve(appDir, outerLayout.sourceDir, 'layout.vsk');
+        const outerLayoutSrc = readFileSync(outerLayoutPath, 'utf-8');
+        const outerLayoutComp = extractCompName(outerLayoutSrc) || 'Layout';
+        src = `const _pageSrc = \`${escapeSource(pageSrc)}\`;\n`;
+        src += `const _pageComp = ${JSON.stringify(pageComp)};\n`;
+        src += `const _layoutSrc = \`${escapeSource(outerLayoutSrc)}\`;\n`;
+        src += `const _layoutComp = ${JSON.stringify(outerLayoutComp)};\n`;
+        src += `const _layoutPath = ${JSON.stringify(outerLayoutPath)};\nconst _pagePath = ${JSON.stringify(pagePath)};\n`;
+        src += `const _layoutCompiled = (() => { try { setVskHydrate(true); return compileFile(_layoutSrc, { sourcePath: _layoutPath }); } catch { return null; } finally { setVskHydrate(false); } })();\n`;
+        src += `const _pageCompiled = (() => { try { setVskHydrate(true); return compileFile(_pageSrc, { sourcePath: _pagePath }); } catch { return null; } finally { setVskHydrate(false); } })();\n`;
+        src += errorVars;
+    }
+    else {
+        src = `const _src = \`${escapeSource(pageSrc)}\`;\nconst _comp = ${JSON.stringify(pageComp)};\n`;
+        src += `const _srcPath = ${JSON.stringify(pagePath)};\n`;
+        src += `const _srcCompiled = (() => { try { setVskHydrate(true); return compileFile(_src, { sourcePath: _srcPath }); } catch { return null; } finally { setVskHydrate(false); } })();\n`;
+        src += errorVars;
+    }
+    const urlParts = routeNode.fullPath.split('/').filter(Boolean);
+    const paramExprs = buildParamExtraction(routeNode, urlParts);
+    const paramsCode = paramExprs.length > 0 ? `const params = { ${paramExprs.join(', ')} };\n` : 'const params = {};\n';
+    let registryCode = '';
+    const compRegEntries = [];
+    const compMap = componentMap || new Map();
+    for (const [compName, compPath] of compMap) {
+        const compSrc = readFileSync(compPath, 'utf-8');
+        const escapedSrc = escapeSource(compSrc);
+        compRegEntries.push(`  registry.set(${JSON.stringify(compName)}, async (props, __registry, __vesk) => {\n    const _src = \`${escapedSrc}\`;\n    const _comp = ${JSON.stringify(compName)};\n    const _compiled = (() => { try { setVskHydrate(true); return compileFile(_src, { sourcePath: ${JSON.stringify(compPath)} }); } catch { return null; } finally { setVskHydrate(false); } })();\n    const result = await renderPage(_src, _comp, props, __registry, { hydrate: true, cached: _compiled, sourcePath: ${JSON.stringify(compPath)} });\n    return result.body;\n  })`);
+    }
+    if (compRegEntries.length > 0) {
+        registryCode = `const __componentRegistry = new Map();\n{\n${compRegEntries.join('\n')}\n}\n`;
+    }
+    else {
+        registryCode = 'const __componentRegistry = new Map();\n';
+    }
+    let renderCode;
+    if (hasLayout) {
+        renderCode = [
+            '  let page;',
+            '  let caughtError = null;',
+            '  try {',
+            '    page = await renderPage(_pageSrc, _pageComp, { params }, __componentRegistry, { hydrate: true, cached: _pageCompiled, sourcePath: _pagePath });',
+            '  } catch (err) {',
+            "    if (err && (err.name === 'NotFoundError' || err.name === 'Redirect')) throw err;",
+            '    caughtError = err;',
+            "    const message = err && typeof err === 'object' && 'message' in err ? String(err.message) : String(err);",
+            "    const stack = err && typeof err === 'object' && 'stack' in err ? String(err.stack) : '';",
+            "    page = { body: await __renderErrorBody({ params, statusCode: 500, error: message, stack, url: url.href }), head: '' };",
+            '  }',
+            '  const html = await renderFullPage(_layoutSrc, _layoutComp, { params, children: (caughtError ? \'<!--vesk-ssr-error:\' + (caughtError && typeof caughtError === \'object\' && \'message\' in caughtError ? encodeURIComponent(String(caughtError.message)) : \'\') + \'-->\' : \'\') + page.body }, __componentRegistry, { hydrate: true, cached: _layoutCompiled' + cssOption + clientScriptOption + dataScriptOption + ', pageHead: page.head, sourcePath: _layoutPath });',
+            "  return new Response(html, { headers: { 'Content-Type': 'text/html' }, status: caughtError ? 500 : 200 });",
+        ].join('\n');
+    }
+    else if (hasAncestorLayout) {
+        renderCode = [
+            '  let page;',
+            '  let caughtError = null;',
+            '  try {',
+            '    page = await renderPage(_pageSrc, _pageComp, { params }, __componentRegistry, { hydrate: true, cached: _pageCompiled, sourcePath: _pagePath });',
+            '  } catch (err) {',
+            "    if (err && (err.name === 'NotFoundError' || err.name === 'Redirect')) throw err;",
+            '    caughtError = err;',
+            "    const message = err && typeof err === 'object' && 'message' in err ? String(err.message) : String(err);",
+            "    const stack = err && typeof err === 'object' && 'stack' in err ? String(err.stack) : '';",
+            "    page = { body: await __renderErrorBody({ params, statusCode: 500, error: message, stack, url: url.href }), head: '' };",
+            '  }',
+            '  const html = await renderFullPage(_layoutSrc, _layoutComp, { params, children: (caughtError ? \'<!--vesk-ssr-error:\' + (caughtError && typeof caughtError === \'object\' && \'message\' in caughtError ? encodeURIComponent(String(caughtError.message)) : \'\') + \'-->\' : \'\') + page.body }, __componentRegistry, { hydrate: true, cached: _layoutCompiled' + cssOption + clientScriptOption + dataScriptOption + ', pageHead: page.head, sourcePath: _layoutPath });',
+            "  return new Response(html, { headers: { 'Content-Type': 'text/html' }, status: caughtError ? 500 : 200 });",
+        ].join('\n');
+    }
+    else {
+        renderCode = [
+            '  let stream;',
+            '  try {',
+            '    stream = renderPageStream(_src, _comp, { params }, __componentRegistry, { hydrate: true, cached: _srcCompiled' + cssOption + clientScriptOption + dataScriptOption + ", sourcePath: _srcPath });",
+            '  } catch (err) {',
+            '    if (err && (err.name === \'NotFoundError\' || err.name === \'Redirect\')) throw err;',
+            '    if (!_errorSrc) throw err;',
+            "    const message = err && typeof err === 'object' && 'message' in err ? String(err.message) : String(err);",
+            "    const stack = err && typeof err === 'object' && 'stack' in err ? String(err.stack) : '';",
+            "    const html = await renderFullPage(_errorSrc, _errorComp, { params, statusCode: 500, error: message, stack, url: url.href }, __componentRegistry, { hydrate: true, cached: _errorCompiled" + cssOption + clientScriptOption + dataScriptOption + ', sourcePath: _errorPath });',
+            "    return new Response(html, { headers: { 'Content-Type': 'text/html' }, status: 500 });",
+            '  }',
+            '  return new Response(new ReadableStream({',
+            '    async start(controller) {',
+            '      const enc = new TextEncoder();',
+            '      for await (const chunk of stream) {',
+            '        controller.enqueue(enc.encode(chunk));',
+            '      }',
+            '      controller.close();',
+            '    },',
+            "  }), { headers: { 'Content-Type': 'text/html' } });",
+        ].join('\n');
+    }
+    const errorBodyFnCode = [
+        'async function __renderErrorBody(props) {',
+        '  if (!_errorSrc) throw props.error || new Error("Internal Server Error");',
+        '  try {',
+        '    const result = await renderPage(_errorSrc, _errorComp, props, __componentRegistry, { hydrate: true, cached: _errorCompiled, sourcePath: _errorPath });',
+        '    return result.body;',
+        '  } catch {',
+        "    return '<h1>500 \\u2014 Internal Server Error</h1>';",
+        '  }',
+        '}',
+    ].join('\n');
+    const funcCode = [
+        "import { renderFullPage, renderPageStream, renderPage, compileFile, setVskHydrate, storeDataScriptGlobal } from '../runtime.js';",
+        '', registryCode, src, '',
+        errorBodyFnCode,
+        '',
+        'export async function handle(request) {',
+        '  const url = new URL(request.url);',
+        "  const urlParts = url.pathname.split('/').filter(Boolean);",
+        `  ${paramsCode}`,
+        renderCode,
+        '}',
+    ].join('\n');
+    writeFileSync(funcPath, funcCode, 'utf-8');
+}
+export function createHmrServer(httpServer, appDir, devDir, componentMap) {
+    const wss = new WebSocketServer({ server: httpServer, path: '/_vesk/hmr' });
+    const clients = new Set();
+    wss.on('connection', (ws) => {
+        clients.add(ws);
+        ws.on('close', () => clients.delete(ws));
+        ws.on('error', () => clients.delete(ws));
+    });
+    function broadcast(type, data) {
+        const msg = JSON.stringify({ type, ...data });
+        for (const ws of clients) {
+            try {
+                ws.send(msg);
+            }
+            catch {
+                clients.delete(ws);
+            }
+        }
+    }
+    async function handleFileChange(filename, doFullBuild, routeTree) {
+        if (!filename)
+            return;
+        broadcast('compiling');
+        if (filename.endsWith('.vsk')) {
+            const sourceDir = extractSourceDir(filename);
+            const fullPath = resolve(appDir, filename);
+            if (!existsSync(fullPath))
+                return;
+            try {
+                const start = Date.now();
+                const src = readFileSync(fullPath, 'utf-8');
+                const code = compileClient(src, null, { forceClient: true });
+                const assignments = extractComponentAssignments(code);
+                if (assignments.length > 0) {
+                    const components = {};
+                    const fnSources = {};
+                    for (const { name, raw } of assignments) {
+                        components[name] = true;
+                        fnSources[name] = raw;
+                    }
+                    broadcast('update', {
+                        components,
+                        fnSources,
+                        time: Date.now() - start,
+                    });
+                }
+                if (sourceDir !== null) {
+                    const routeNode = findRouteForSource(routeTree, sourceDir);
+                    if (routeNode) {
+                        const ancestorLayouts = collectAncestorLayouts(routeTree, sourceDir);
+                        regenerateSsrFunction(routeNode, appDir, devDir, componentMap, { ancestorLayouts: ancestorLayouts || [] });
+                    }
+                }
+                console.error(`vesk hmr: ${assignments.map(a => a.name).join(', ')} (${Date.now() - start}ms)`);
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                broadcast('error', { message, file: filename });
+                console.error(`vesk hmr: error — ${message}`);
+            }
+            return;
+        }
+        if (filename.includes('/api/') && (filename.endsWith('.ts') || filename.endsWith('.js'))) {
+            const start = Date.now();
+            try {
+                await doFullBuild();
+                broadcast('reload', { reason: `API: ${filename}`, time: Date.now() - start });
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                broadcast('error', { message, file: filename });
+            }
+            return;
+        }
+        if (filename === 'middleware.ts' || filename.endsWith('/middleware.ts')) {
+            const start = Date.now();
+            try {
+                await doFullBuild();
+                broadcast('reload', { reason: `Middleware: ${filename}`, time: Date.now() - start });
+                console.error(`vesk hmr: middleware ${filename} rebuilt (${Date.now() - start}ms)`);
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                broadcast('error', { message, file: filename });
+            }
+            return;
+        }
+        if (filename === 'vesk.config.ts' || filename === 'vesk.config.js' ||
+            filename === 'tsconfig.json' || filename === 'package.json') {
+            const start = Date.now();
+            try {
+                await doFullBuild();
+                broadcast('reload', { reason: `Config: ${filename}`, time: Date.now() - start });
+                console.error(`vesk hmr: ${filename} rebuilt (${Date.now() - start}ms)`);
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                broadcast('error', { message, file: filename });
+            }
+            return;
+        }
+        const start = Date.now();
+        try {
+            await doFullBuild();
+            broadcast('reload', { reason: `${filename} changed`, time: Date.now() - start });
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            broadcast('error', { message, file: filename });
+        }
+    }
+    return { broadcast, handleFileChange };
+}

package/dist/image-pipeline.d.ts

@@ -0,0 +1,3 @@
+import type { ImageResult } from '@vesk/adapter/src/types';
+export declare function optimizeImages(appDir: string, outDir: string): Promise<ImageResult[]>;
+//# sourceMappingURL=image-pipeline.d.ts.map

package/dist/image-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-pipeline.d.ts","sourceRoot":"","sources":["../src/image-pipeline.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAY,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAsFrE,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAgD3F"}

package/dist/image-pipeline.js

@@ -0,0 +1,120 @@
+import { mkdirSync, writeFileSync, readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
+import { resolve, extname, dirname } from 'node:path';
+const SUPPORTED = new Set(['.jpg', '.jpeg', '.png', '.webp', '.avif', '.tiff']);
+const OUTPUT_WIDTHS = [640, 768, 1024, 1280, 1536];
+const FORMATS = ['webp', 'avif'];
+let sharpFn = null;
+try {
+    const mod = await import('sharp');
+    sharpFn = mod.default;
+}
+catch {
+    // sharp not available — fall through to copy-only
+}
+async function processImage(srcPath, outDir, baseName) {
+    const image = sharpFn ? sharpFn(srcPath) : null;
+    if (!image) {
+        const original = readFileSync(srcPath);
+        for (const w of OUTPUT_WIDTHS) {
+            const outputPath = resolve(outDir, `${baseName}-${w}w`);
+            mkdirSync(dirname(outputPath), { recursive: true });
+            writeFileSync(outputPath, original);
+        }
+        return [];
+    }
+    const meta = await image.metadata();
+    const originalWidth = meta.width || 1920;
+    const generated = [];
+    for (const w of OUTPUT_WIDTHS) {
+        if (w > originalWidth)
+            continue;
+        const resized = image.clone().resize({ width: w, withoutEnlargement: true });
+        const base = `${baseName}-${w}w`;
+        const jpgPath = resolve(outDir, `${base}${extname(srcPath)}`);
+        mkdirSync(dirname(jpgPath), { recursive: true });
+        await resized.toFile(jpgPath);
+        generated.push(jpgPath);
+        for (const fmt of FORMATS) {
+            const fmtPath = resolve(outDir, `${base}.${fmt}`);
+            await resized.toFormat(fmt, { quality: 80 }).toFile(fmtPath);
+            generated.push(fmtPath);
+        }
+    }
+    return generated;
+}
+function collectImageRefs(appDir) {
+    const refs = [];
+    function walk(dir) {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = resolve(dir, entry);
+            const st = statSync(full);
+            if (st.isDirectory()) {
+                if (entry.startsWith('.'))
+                    continue;
+                walk(full);
+            }
+            else if (entry === 'page.vsk') {
+                const src = readFileSync(full, 'utf-8');
+                const imgRegex = /<Image\s+src=["']([^"']+)["']/g;
+                let m;
+                while ((m = imgRegex.exec(src)) !== null) {
+                    refs.push({ source: full, src: m[1] });
+                }
+            }
+        }
+    }
+    walk(appDir);
+    return refs;
+}
+export async function optimizeImages(appDir, outDir) {
+    const imageOutDir = resolve(outDir, 'static', 'images');
+    mkdirSync(imageOutDir, { recursive: true });
+    const refs = collectImageRefs(appDir);
+    if (refs.length === 0) {
+        console.error('vesk images: no <Image> refs found');
+        return [];
+    }
+    const results = [];
+    for (const ref of refs) {
+        const possiblePaths = [
+            resolve(appDir, ref.src),
+            resolve(appDir, '..', 'public', ref.src.replace(/^\//, '')),
+            resolve(appDir, '..', 'src', ref.src.replace(/^\//, '')),
+            resolve(outDir, 'static', 'public', ref.src.replace(/^\//, '')),
+        ];
+        let srcPath = null;
+        for (const p of possiblePaths) {
+            if (existsSync(p)) {
+                srcPath = p;
+                break;
+            }
+        }
+        if (!srcPath) {
+            console.error(`vesk images: not found — ${ref.src} (referenced by ${ref.source})`);
+            continue;
+        }
+        const ext = extname(srcPath).toLowerCase();
+        if (!SUPPORTED.has(ext)) {
+            console.error(`vesk images: unsupported format — ${ref.src} (${ext})`);
+            continue;
+        }
+        const baseName = ref.src.replace(/^\//, '').replace(extname(ref.src), '');
+        const files = await processImage(srcPath, imageOutDir, baseName);
+        results.push({ src: ref.src, baseName, files, widths: OUTPUT_WIDTHS });
+        console.error(`vesk images: ${ref.src} → ${files.length} variants`);
+    }
+    if (sharpFn) {
+        console.error(`vesk images: sharp pipeline — ${results.length} images processed`);
+    }
+    else {
+        console.error('vesk images: sharp not available — originals copied (install sharp for resizing)');
+    }
+    return results;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { BuildOptions, BuildResult } from '@vesk/adapter/src/types';
+export declare function build(appDir: string, options?: BuildOptions): Promise<BuildResult | undefined>;
+export { startProdServer } from '@vesk/adapter/src/prod-server';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EACe,YAAY,EAAE,WAAW,EAEnD,MAAM,yBAAyB,CAAC;AAgBjC,wBAAsB,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAwSpG;AAED,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC"}