veko-framework 1.0.0

package/src/cli/dev.ts

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+/**
+ * Veko v1 – Dev server with hot restart
+ * Watches .vk files, recompiles on change, restarts the generated server.
+ */
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { spawn, ChildProcess } from 'child_process';
+import chokidar from 'chokidar';
+import chalk from 'chalk';
+import { DEFAULTS } from '../config/defaults.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+/** Project root: where the user ran veko (process.cwd()), so dev/build work in the consumer app. */
+const ROOT = process.cwd();
+
+const SIGKILL_TIMEOUT_MS = 5000;
+const REBUILD_DEBOUNCE_MS = 300;
+
+interface CompileResult {
+  config: { output: { server: string }; server?: { port?: number } };
+  output: { server: string; types: string };
+}
+
+let serverProcess: ChildProcess | null = null;
+let serverPath: string | null = null;
+
+function log(msg: string, style: 'info' | 'success' | 'error' | 'warn' = 'info') {
+  const prefix = chalk.gray('[veko]');
+  switch (style) {
+    case 'success':
+      console.log(prefix, chalk.green(msg));
+      break;
+    case 'error':
+      console.error(prefix, chalk.red(msg));
+      break;
+    case 'warn':
+      console.warn(prefix, chalk.yellow(msg));
+      break;
+    default:
+      console.log(prefix, msg);
+  }
+}
+
+async function runCompile(): Promise<CompileResult | null> {
+  const { compile } = await import('../compiler/compile.js');
+  try {
+    const result = (await compile(ROOT)) as CompileResult;
+    return result;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log(`Compilation failed: ${message}`, 'error');
+    if (err instanceof Error && err.stack) {
+      console.error(chalk.gray(err.stack));
+    }
+    return null;
+  }
+}
+
+function startServer(serverPath: string, port: number): ChildProcess {
+  const child = spawn('node', [serverPath], {
+    cwd: ROOT,
+    stdio: 'inherit',
+    env: { ...process.env, PORT: String(port), NODE_ENV: 'development' },
+  });
+  child.on('error', (err) => {
+    log(`Server process error: ${err.message}`, 'error');
+  });
+  child.on('exit', (code, signal) => {
+    if (code !== null && code !== 0 && signal !== 'SIGTERM' && signal !== 'SIGKILL') {
+      log(`Server exited with code ${code}`, 'warn');
+    }
+  });
+  return child;
+}
+
+function killServer(): Promise<void> {
+  return new Promise((resolve) => {
+    if (!serverProcess) {
+      resolve();
+      return;
+    }
+    const proc = serverProcess;
+    serverProcess = null;
+
+    const done = () => {
+      clearTimeout(killTimeout);
+      proc.removeAllListeners('exit');
+      resolve();
+    };
+
+    proc.once('exit', () => done());
+
+    proc.kill('SIGTERM');
+
+    const killTimeout = setTimeout(() => {
+      try {
+        proc.kill('SIGKILL');
+      } catch {
+        /* already gone */
+      }
+      done();
+    }, SIGKILL_TIMEOUT_MS);
+  });
+}
+
+let rebuildDebounceTimer: ReturnType<typeof setTimeout> | null = null;
+let pendingChangedFile: string | undefined;
+
+async function rebuildAndRestart(changedFile?: string): Promise<void> {
+  pendingChangedFile = changedFile ?? pendingChangedFile;
+
+  if (rebuildDebounceTimer) {
+    clearTimeout(rebuildDebounceTimer);
+  }
+  rebuildDebounceTimer = setTimeout(async () => {
+    rebuildDebounceTimer = null;
+    const fileToLog = pendingChangedFile;
+    pendingChangedFile = undefined;
+
+    const result = await runCompile();
+    if (!result) {
+      if (fileToLog) {
+        log(`Keeping previous server running. Fix errors and save again.`, 'warn');
+      }
+      return;
+    }
+
+    const { output, config } = result;
+    const port = config.server?.port ?? DEFAULTS.PORT;
+
+    await killServer();
+
+    serverPath = output.server;
+    serverProcess = startServer(output.server, port);
+
+    if (fileToLog) {
+      const relative = path.relative(ROOT, fileToLog);
+      log(chalk.bold(`🚀 Server reloaded due to changes in ${relative}`), 'success');
+    }
+  }, REBUILD_DEBOUNCE_MS);
+}
+
+function main(): void {
+  log(chalk.cyan('Starting Veko v1 dev server...'));
+
+  // Watch only .vk in project root (and entry dir if different) to avoid EMFILE
+  const glob = path.join(ROOT, '**/*.vk');
+  const watcher = chokidar.watch(glob, {
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 150 },
+    ignored: [/(^|[/\\])node_modules([/\\]|$)/, /([/\\])\.git([/\\]|$)/],
+  });
+
+  watcher.on('change', (filePath) => {
+    log(`Change detected: ${path.relative(ROOT, filePath)}`);
+    rebuildAndRestart(filePath);
+  });
+
+  watcher.on('add', (filePath) => {
+    log(`New .vk file: ${path.relative(ROOT, filePath)}`);
+    rebuildAndRestart(filePath);
+  });
+
+  watcher.on('ready', () => {
+    log('Watching .vk files...');
+    rebuildAndRestart();
+  });
+
+  watcher.on('error', (err: unknown) => {
+    log(`Watcher error: ${err instanceof Error ? err.message : String(err)}`, 'error');
+  });
+
+  process.on('SIGINT', async () => {
+    log('Shutting down...');
+    await killServer();
+    watcher.close();
+    process.exit(0);
+  });
+
+  process.on('SIGTERM', async () => {
+    await killServer();
+    watcher.close();
+    process.exit(0);
+  });
+}
+
+main();

package/src/cli/migrate.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+/**
+ * Veko v1 – Migrate (apply versioned migrations from .vk or migrations dir)
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { DEFAULTS } from '../config/defaults.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const root = process.cwd();
+
+async function loadConfig() {
+  const configPath = path.join(root, 'veko.config.js');
+  let adapter = 'sqlite';
+  let dbPath = path.join(root, process.env.DB_FILE || (process.env.NODE_ENV === 'test' ? DEFAULTS.DB_FILE_TEST : DEFAULTS.DB_FILE));
+  let migrationsTable = '_veko_migrations';
+  if (fs.existsSync(configPath)) {
+    const mod = await import(pathToFileURL(configPath).href);
+    const c = mod.default || mod;
+    adapter = c.adapter || 'sqlite';
+    dbPath = c.database?.sqlite?.path || dbPath;
+    migrationsTable = c.migrations?.table || migrationsTable;
+  }
+  return { adapter, dbPath, migrationsTable };
+}
+
+function ensureMigrationsTable(db, table) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS "${table}" (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      version TEXT UNIQUE NOT NULL,
+      applied_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+}
+
+function getAppliedVersions(db, table) {
+  const rows = db.prepare(`SELECT version FROM "${table}" ORDER BY id`).all();
+  return new Set(rows.map((r) => r.version));
+}
+
+async function main() {
+  const { adapter, dbPath, migrationsTable } = await loadConfig();
+  if (adapter !== 'sqlite') {
+    console.log('Only SQLite migrations are implemented in this CLI. Use Postgres manually or extend this script.');
+    process.exit(0);
+  }
+  const Database = (await import('better-sqlite3')).default;
+  const db = new Database(dbPath);
+  ensureMigrationsTable(db, migrationsTable);
+  const applied = getAppliedVersions(db, migrationsTable);
+
+  // Load migrations from api.vk (parser) or from migrations/*.sql / migrations/*.vk
+  const migrationsDir = path.join(root, 'migrations');
+  const migrations = [];
+  if (fs.existsSync(migrationsDir)) {
+    const files = fs.readdirSync(migrationsDir).filter((f) => f.endsWith('.sql'));
+    for (const f of files.sort()) {
+      const version = f.replace(/\.sql$/, '');
+      if (applied.has(version)) continue;
+      const sql = fs.readFileSync(path.join(migrationsDir, f), 'utf-8');
+      migrations.push({ version, sql });
+    }
+  }
+
+  for (const { version, sql } of migrations) {
+    console.log('Applying', version);
+    db.exec(sql);
+    db.prepare(`INSERT INTO "${migrationsTable}" (version) VALUES (?)`).run(version);
+  }
+  if (migrations.length === 0) console.log('No new migrations.');
+  db.close();
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/compiler/aot-validation.js

@@ -0,0 +1,67 @@
+/**
+ * Veko v1 – AOT validation code generation
+ * Produces inline validate_SchemaName(data) functions and TypeScript field types.
+ */
+
+/**
+ * Generate the validate_SchemaName(data) function source for a data block.
+ * @param {{ name: string, fields: Array<{ name: string, type: string, optional?: boolean, args?: { min?: number, max?: number, enum?: string[] } }> }} schema
+ * @returns {string}
+ */
+export function schemaToValidationCode(schema) {
+  let code = `function validate_${schema.name}(data) {\n`;
+  code += `  if (data === null || typeof data !== 'object' || Array.isArray(data)) {\n`;
+  code += `    throw Object.assign(new Error('${schema.name}: body must be a plain object'), { status: 400 });\n`;
+  code += `  }\n`;
+  code += `  const result = {};\n`;
+  for (const f of schema.fields) {
+    const key = f.name;
+    const req = !f.optional;
+    code += `  if (data['${key}'] === undefined || data['${key}'] === null) {\n`;
+    if (req) {
+      code += `    throw Object.assign(new Error('${schema.name}: missing required field "${key}"'), { status: 400 });\n`;
+    } else {
+      code += `    result['${key}'] = null;\n`;
+    }
+    code += `  } else {\n`;
+
+    if (['string', 'password', 'date', 'enum'].includes(f.type.toLowerCase()) || f.args?.enum) {
+      code += `    if (typeof data['${key}'] !== 'string') throw Object.assign(new Error('${schema.name}: "${key}" must be a string'), { status: 400 });\n`;
+      if (f.args?.min !== undefined) code += `    if (data['${key}'].length < ${f.args.min}) throw Object.assign(new Error('${schema.name}: "${key}" too short'), { status: 400 });\n`;
+      if (f.args?.max !== undefined) code += `    if (data['${key}'].length > ${f.args.max}) throw Object.assign(new Error('${schema.name}: "${key}" too long'), { status: 400 });\n`;
+      if (f.args?.enum) {
+        const enumStr = JSON.stringify(f.args.enum);
+        code += `    if (!${enumStr}.includes(data['${key}'])) throw Object.assign(new Error('${schema.name}: "${key}" invalid enum'), { status: 400 });\n`;
+      }
+      code += `    result['${key}'] = data['${key}'];\n`;
+    } else if (f.type.toLowerCase() === 'number') {
+      code += `    const n = Number(data['${key}']);\n`;
+      code += `    if (!Number.isFinite(n)) throw Object.assign(new Error('${schema.name}: "${key}" must be a number'), { status: 400 });\n`;
+      if (f.args?.min !== undefined) code += `    if (n < ${f.args.min}) throw Object.assign(new Error('${schema.name}: "${key}" must be >= ${f.args.min}'), { status: 400 });\n`;
+      if (f.args?.max !== undefined) code += `    if (n > ${f.args.max}) throw Object.assign(new Error('${schema.name}: "${key}" must be <= ${f.args.max}'), { status: 400 });\n`;
+      code += `    result['${key}'] = n;\n`;
+    } else if (f.type.toLowerCase() === 'boolean') {
+      code += `    result['${key}'] = Boolean(data['${key}']);\n`;
+    } else {
+      code += `    result['${key}'] = data['${key}'];\n`;
+    }
+    code += `  }\n`;
+  }
+  code += `  return result;\n`;
+  code += `}\n\n`;
+  return code;
+}
+
+/**
+ * @param {{ type: string }} f
+ * @returns {string}
+ */
+export function fieldToTsType(f) {
+  if (f.type === 'Number') return 'number';
+  if (f.type === 'Boolean') return 'boolean';
+  if (f.type === 'String' || f.type === 'Enum' || f.type === 'Password') return 'string';
+  if (f.type === 'Date') return 'string';
+  return 'unknown';
+}
+
+export default { schemaToValidationCode, fieldToTsType };

package/src/compiler/codegen.js

@@ -0,0 +1,203 @@
+/**
+ * Veko v1 – AOT-Optimized Code Generation
+ * Lean and modular: uses aot-validation, QueryBuilder, wrapAction, shared defaults.
+ */
+
+import { schemaToValidationCode, fieldToTsType } from './aot-validation.js';
+import { DEFAULTS } from '../config/defaults.js';
+
+export function generate(ast, options = {}) {
+  const { adapter = 'sqlite', serverPath = './generated/server.js', runtimeDir = './runtime' } = options;
+  const relRuntime = runtimeDir.startsWith('.') ? runtimeDir : `./${runtimeDir}`;
+
+  const knownTables = new Set(ast.dataBlocks.map((b) => b.name));
+
+  const adapterImport = adapter === 'postgres' ? 'PostgresAdapter' : 'SqliteAdapter';
+  const adapterPath = `${relRuntime}/adapters/${adapter}.js`;
+
+  let server = `/**
+ * Generated by Veko v1 – AOT Optimized Server (Lean & Modular)
+ */
+
+import express from 'express';
+import jwt from 'jsonwebtoken';
+import { signToken } from '${relRuntime}/auth.js';
+import { wrapAction } from '${relRuntime}/wrapAction.js';
+import { toVekoError } from '${relRuntime}/errors.js';
+import QueryBuilder from '${relRuntime}/queryBuilder.js';
+import { ${adapterImport} } from '${adapterPath}';
+
+const app = express();
+app.use(express.json());
+
+// Database adapter connection
+`;
+  if (adapter === 'sqlite') {
+    server += `const db = new SqliteAdapter(process.env.DB_FILE || '${DEFAULTS.DB_FILE}');\n`;
+  } else {
+    server += `const db = new PostgresAdapter(process.env.DATABASE_URL);\n`;
+  }
+  server += `await db.connect();\n\n`;
+
+  const tableCols = {};
+  for (const b of ast.dataBlocks) tableCols[b.name] = b.fields.map((f) => f.name);
+  server += `const TABLE_COLS = ${JSON.stringify(tableCols)};\n`;
+  server += `const PREP = QueryBuilder.prepareAll('${adapter}', db, TABLE_COLS);\n\n`;
+  server += `\n// AOT Database Helpers\nconst aot_db = {\n`;
+  for (const b of ast.dataBlocks) {
+    const t = b.name;
+    const args = b.fields.map(f => `data.${f.name}`);
+    const allowedCols = JSON.stringify(['id', ...b.fields.map(f => f.name)]);
+    server += `  ${t}: {\n`;
+    if (adapter === 'sqlite') {
+      server += `    save: (data) => { const r = PREP['${t}'].insert.run(${args.join(', ')}); return { id: r.lastInsertRowid }; },\n`;
+      server += `    update: (id, data) => PREP['${t}'].update.run(${args.join(', ')}, id),\n`;
+      server += `    remove: (id) => PREP['${t}'].delete.run(id),\n`;
+      server += `    find: (id) => PREP['${t}'].findById.get(id),\n`;
+      server += `    findAll: async (where = {}, orderBy = null) => {
+      const allowed = ${allowedCols};
+      for (const k of Object.keys(where)) {
+        if (!allowed.includes(k)) throw Object.assign(new Error('Invalid where column: ' + k), { status: 400 });
+      }
+      if (orderBy && !allowed.includes(orderBy.field)) throw Object.assign(new Error('Invalid orderBy column: ' + orderBy.field), { status: 400 });
+      return db.findAll('${t}', where, orderBy);
+    }\n`;
+    } else {
+      server += `    save: async (data) => { const r = await db.pool.query(PREP['${t}'].insert, [${args.join(', ')}]); return { id: r.rows[0].id }; },\n`;
+      server += `    update: async (id, data) => await db.pool.query(PREP['${t}'].update, [${args.join(', ')}, id]),\n`;
+      server += `    remove: async (id) => await db.pool.query(PREP['${t}'].delete, [id]),\n`;
+      server += `    find: async (id) => { const r = await db.pool.query(PREP['${t}'].findById, [id]); return r.rows[0]; },\n`;
+      server += `    findAll: async (where = {}, orderBy = null) => {
+      const allowed = ${allowedCols};
+      for (const k of Object.keys(where)) {
+        if (!allowed.includes(k)) throw Object.assign(new Error('Invalid where column: ' + k), { status: 400 });
+      }
+      if (orderBy && !allowed.includes(orderBy.field)) throw Object.assign(new Error('Invalid orderBy column: ' + orderBy.field), { status: 400 });
+      return db.findAll('${t}', where, orderBy);
+    }\n`;
+    }
+    server += `  },\n`;
+  }
+  server += `  query: async (sql, ...params) => {
+    const trimmed = (typeof sql === 'string' ? sql : '').trim();
+    if (!trimmed.toUpperCase().startsWith('SELECT')) {
+      throw Object.assign(new Error('sugar.query() is restricted to SELECT statements only.'), { status: 403 });
+    }
+    return db.query(sql, params);
+  }\n};\n\n`;
+
+  server += `// Static Validation Blocks\n`;
+  for (const b of ast.dataBlocks) {
+    server += schemaToValidationCode(b);
+  }
+
+  server += `\n// Fast-path JSON Stringifiers\n`;
+  for (const b of ast.dataBlocks) {
+    server += `function fastJson_${b.name}(data, _d) {\n`;
+    server += `  const depth = _d ?? 0;\n`;
+    server += `  if (depth > 10) return 'null';\n`;
+    server += `  if (Array.isArray(data)) return '[' + data.map((x) => fastJson_${b.name}(x, depth + 1)).join(',') + ']';\n`;
+    server += `  if (!data) return 'null';\n`;
+    let parts = [`'"id":' + data.id`];
+    for (const f of b.fields) {
+      if (['string', 'password', 'date', 'enum'].includes(f.type.toLowerCase()) || f.args?.enum) {
+        parts.push(`'"${f.name}":"' + (data.${f.name} || '').toString().replace(/(["\\\\\\n\\r\\t])/g, '\\\\$1') + '"'`);
+      } else {
+        parts.push(`'"${f.name}":' + (data.${f.name} !== undefined ? data.${f.name} : 'null')`);
+      }
+    }
+    server += `  return '{' + ${parts.join(" + ',' + ")} + '}';\n`;
+    server += `}\n\n`;
+  }
+
+  for (const block of ast.doBlocks) {
+    let body = block.body;
+    body = body.replace(/sugar\.save\(\s*['"]([^'"]+)['"]\s*,\s*(.*?)\)/g, "aot_db.$1.save($2)");
+    body = body.replace(/sugar\.find\(\s*['"]([^'"]+)['"]\s*,\s*(.*?)\)/g, "aot_db.$1.find($2)");
+    body = body.replace(/sugar\.remove\(\s*['"]([^'"]+)['"]\s*,\s*(.*?)\)/g, "aot_db.$1.remove($2)");
+    body = body.replace(/sugar\.update\(\s*['"]([^'"]+)['"]\s*,\s*(.*?)\s*,\s*(.*?)\)/g, "aot_db.$1.update($2, $3)");
+    body = body.replace(/sugar\.all\(\s*['"]([^'"]+)['"]\s*(?:,\s*([^)]*))?\)/g, (_, table, args) =>
+      args ? `aot_db.${table}.findAll(${args})` : `aot_db.${table}.findAll()`);
+    body = body.replace(/sugar\.query/g, "aot_db.query");
+
+    server += `async function ${block.name}(data) {\n`;
+    server += `  ${body.split('\n').join('\n  ')}\n`;
+    server += `}\n\n`;
+  }
+
+  server += `app.get('/__health', (req, res) => res.json({ status: 'ok', engine: 'Veko v1 AOT' }));\n\n`;
+
+  for (const route of ast.routeLines) {
+    const method = route.method.toLowerCase();
+    let needsAuth = false;
+    let schemaToValidate = null;
+    let actionName = null;
+    for (const step of route.pipeline) {
+      if (step.kind === 'auth') needsAuth = true;
+      else if (step.kind === 'validate') schemaToValidate = step.schema;
+      else if (step.kind === 'action') actionName = step.name;
+    }
+    if (!actionName) continue;
+
+    server += `app.${method}("${route.path}", wrapAction(async (req, res) => {\n`;
+
+    if (needsAuth) {
+      server += `  const rawAuth = req.headers.authorization;\n`;
+      server += `  const header = Array.isArray(rawAuth) ? rawAuth[0] : rawAuth;\n`;
+      server += `  if (typeof header !== 'string' || !header.startsWith('Bearer ')) throw Object.assign(new Error('Unauthorized'), { status: 401 });\n`;
+      server += `  req.user = jwt.verify(header.slice(7), process.env.JWT_SECRET || '${DEFAULTS.JWT_SECRET}', { algorithms: ['HS256'] });\n`;
+    }
+
+    if (schemaToValidate) {
+      server += `  const validatedBody = validate_${schemaToValidate}(req.body || {});\n`;
+      server += `  const ctx = { ...req.params, ...validatedBody };\n`;
+    } else {
+      server += `  const ctx = { ...req.params, ...req.query, ...(req.body || {}) };\n`;
+    }
+
+    server += `  const result = await ${actionName}(ctx);\n`;
+
+    if (schemaToValidate) {
+      server += `  if (result && typeof result === 'object' && !result.token) {\n`;
+      server += `    res.type('json').send(fastJson_${schemaToValidate}(result));\n`;
+      server += `  } else {\n`;
+      server += `    res.json(result ?? { success: true });\n`;
+      server += `  }\n`;
+    } else {
+      server += `  res.json(result ?? { success: true });\n`;
+    }
+
+    server += `}));\n\n`;
+  }
+
+  server += `app.use((err, req, res, next) => {\n`;
+  server += `  if (res.headersSent) return next(err);\n`;
+  server += `  const e = toVekoError(err);\n`;
+  server += `  res.status(e.status).json({ error: e.message, message: e.message });\n`;
+  server += `});\n\n`;
+
+  server += `const port = parseInt(process.env.PORT || '${DEFAULTS.PORT}', 10);\n`;
+  server += `const host = process.env.HOST || '${DEFAULTS.HOST}';\n`;
+  server += `const server = app.listen(port, host, () => {\n`;
+  server += `  console.log('Veko v1 server on http://' + host + ':' + port);\n`;
+  server += `});\n`;
+  server += `server.on('error', (err) => {\n`;
+  server += `  if (err.code === 'EADDRINUSE') {\n`;
+  server += `    console.error('Port ' + port + ' is already in use. Stop the other process or set PORT to a different number.');\n`;
+  server += `    process.exit(1);\n`;
+  server += `  }\n`;
+  server += `  throw err;\n`;
+  server += `});\n`;
+
+  let types = `/**\n * Generated by Veko v1 AOT\n */\n\n`;
+  for (const block of ast.dataBlocks) {
+    types += `export interface ${block.name} {\n  id: number;\n`;
+    for (const f of block.fields) {
+      const t = fieldToTsType(f);
+      types += `  ${f.name}${f.optional ? '?' : ''}: ${t};\n`;
+    }
+    types += `}\n\n`;
+  }
+
+  return { server, types };
+}

package/src/compiler/compile.d.ts

@@ -0,0 +1,16 @@
+export interface VekoConfig {
+  root: string;
+  entry: string;
+  output: { server: string; types: string };
+  adapter: string;
+  database: Record<string, unknown>;
+  server: { port?: number };
+  migrations: { table: string; dir: string };
+  plugins: unknown[];
+}
+
+export function loadConfig(rootDir?: string): Promise<VekoConfig>;
+
+export function compile(
+  rootDir?: string
+): Promise<{ config: VekoConfig; output: { server: string; types: string } }>;

package/src/compiler/compile.js

@@ -0,0 +1,39 @@
+/**
+ * Veko v1 – Compiler entry: load config, parse, generate, write.
+ * Used by cli/build.js and cli/dev.ts.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { resolveModules } from './resolver.js';
+import { generate } from './codegen.js';
+import { loadConfig } from '../config/load-config.js';
+
+// Re-export for CLI and programmatic use
+export { loadConfig };
+
+/**
+ * Compile api.vk → generated/server.js + types.d.ts.
+ * @param {string} [rootDir] - Project root
+ * @returns {{ config: object, output: { server: string, types: string } }}
+ * @throws {Error} on parse/generate/write failure
+ */
+export async function compile(rootDir) {
+  const config = await loadConfig(rootDir);
+  const { entry, output, adapter } = config;
+  if (!fs.existsSync(entry)) {
+    throw new Error(`Entry file not found: ${entry}`);
+  }
+  const ast = resolveModules(entry, config.root);
+  const relRuntime = path.relative(path.dirname(output.server), config.root).replace(/\\/g, '/') || '.';
+  const { server, types } = generate(ast, {
+    adapter,
+    serverPath: output.server,
+    runtimeDir: path.join(relRuntime, 'src', 'runtime'),
+  });
+  const outDir = path.dirname(output.server);
+  if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+  fs.writeFileSync(output.server, server, 'utf-8');
+  fs.writeFileSync(output.types, types, 'utf-8');
+  return { config, output: config.output };
+}

package/src/compiler/index.js

@@ -0,0 +1,5 @@
+/**
+ * Veko v1 – Compiler module (public API for programmatic use)
+ */
+
+export { compile, loadConfig } from './compile.js';