express-file-cluster 0.1.3 → 0.1.5

package/src/cli/commands/start.ts

@@ -1,90 +0,0 @@
-import { Command } from 'commander';
-import { spawn } from 'node:child_process';
-import path from 'node:path';
-import fs from 'node:fs';
-import chalk from 'chalk';
-
-export function startCommand(): Command {
-  const cmd = new Command('start');
-
-  cmd
-    .argument('<mode>', 'dev | prod')
-    .description('Start the EFC server')
-    .action((mode: string) => {
-      if (mode === 'dev') {
-        startDev();
-      } else if (mode === 'prod') {
-        startProd();
-      } else {
-        console.error(chalk.red(`Unknown mode: ${mode}. Use 'dev' or 'prod'.`));
-        process.exit(1);
-      }
-    });
-
-  return cmd;
-}
-
-function parseDotenv(cwd: string): Record<string, string> {
-  const envFile = path.join(cwd, '.env');
-  if (!fs.existsSync(envFile)) return {};
-  const vars: Record<string, string> = {};
-  for (const line of fs.readFileSync(envFile, 'utf8').split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-    const eq = trimmed.indexOf('=');
-    if (eq === -1) continue;
-    const key = trimmed.slice(0, eq).trim();
-    const raw = trimmed.slice(eq + 1).trim();
-    vars[key] = raw.replace(/^(['"])(.*)\1$/, '$2');
-  }
-  return vars;
-}
-
-function startDev(): void {
-  const entry = resolveEntry();
-  if (!entry) {
-    console.error(chalk.red('[EFC] Could not find entry point. Expected src/index.ts or index.ts'));
-    process.exit(1);
-  }
-
-  console.log(chalk.cyan('[EFC] Starting development server…'));
-  console.log(chalk.dim(`  Entry: ${entry}`));
-
-  const cwd = process.cwd();
-  const localTsx = path.join(cwd, 'node_modules', '.bin', 'tsx');
-  const tsx = fs.existsSync(localTsx) ? localTsx : 'tsx';
-
-  // .env values are base; existing process.env takes precedence (same as dotenv default)
-  const env: NodeJS.ProcessEnv = { ...parseDotenv(cwd), ...process.env, NODE_ENV: 'development' };
-
-  const child = spawn(tsx, ['watch', entry], { stdio: 'inherit', env });
-  child.on('exit', (code) => process.exit(code ?? 0));
-}
-
-function startProd(): void {
-  const cwd = process.cwd();
-  const distEntry = path.join(cwd, 'dist', 'index.js');
-
-  if (!fs.existsSync(distEntry)) {
-    console.error(chalk.red('[EFC] dist/index.js not found. Run `efc build prod` first.'));
-    process.exit(1);
-  }
-
-  console.log(chalk.cyan('[EFC] Starting production server…'));
-
-  const env: NodeJS.ProcessEnv = { ...parseDotenv(cwd), ...process.env, NODE_ENV: 'production' };
-
-  const child = spawn('node', [distEntry], { stdio: 'inherit', env });
-  child.on('exit', (code) => process.exit(code ?? 0));
-}
-
-function resolveEntry(): string | null {
-  const cwd = process.cwd();
-  const candidates = [
-    path.join(cwd, 'src', 'index.ts'),
-    path.join(cwd, 'index.ts'),
-    path.join(cwd, 'src', 'index.js'),
-    path.join(cwd, 'index.js'),
-  ];
-  return candidates.find((f) => fs.existsSync(f)) ?? null;
-}

package/src/cli/index.ts

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-import { Command } from 'commander';
-import { startCommand } from './commands/start.js';
-import { buildCommand } from './commands/build.js';
-import { runCommand } from './commands/run.js';
-import { generateCommand } from './commands/generate.js';
-import { diagnosticsCommands } from './commands/diagnostics.js';
-
-const program = new Command('efc')
-  .description('Express File Cluster CLI')
-  .version('0.1.0');
-
-program.addCommand(startCommand());
-program.addCommand(buildCommand());
-program.addCommand(runCommand());
-program.addCommand(generateCommand());
-
-for (const cmd of diagnosticsCommands()) {
-  program.addCommand(cmd);
-}
-
-program.parse(process.argv);

package/src/cluster/index.ts

@@ -1,31 +0,0 @@
-import cluster from 'node:cluster';
-import os from 'node:os';
-
-interface ClusterOptions {
-  workers?: number;
-  onWorkerReady?: ((id: number) => void) | undefined;
-  onWorkerCrash?: ((id: number, code: number) => void) | undefined;
-}
-
-export function runMaster(options: ClusterOptions = {}): void {
-  const count = options.workers ?? os.cpus().length;
-
-  console.log(`[EFC] Primary ${process.pid} starting ${count} workers`);
-
-  for (let i = 0; i < count; i++) {
-    cluster.fork();
-  }
-
-  cluster.on('online', (worker) => {
-    options.onWorkerReady?.(worker.id);
-  });
-
-  cluster.on('exit', (worker, code, signal) => {
-    const exitCode = code ?? (signal ? -1 : 0);
-    console.warn(`[EFC] Worker ${worker.id} exited (code=${exitCode}), respawning…`);
-    options.onWorkerCrash?.(worker.id, exitCode);
-    cluster.fork();
-  });
-}
-
-export { cluster };

package/src/compose.ts

@@ -1,26 +0,0 @@
-import type { RequestHandler } from 'express';
-
-export function compose(...handlers: RequestHandler[]): RequestHandler {
-  return (req, res, next) => {
-    let index = 0;
-
-    function dispatch(i: number): void {
-      if (i >= handlers.length) {
-        next();
-        return;
-      }
-      const handler = handlers[i];
-      if (!handler) {
-        next();
-        return;
-      }
-      try {
-        Promise.resolve(handler(req, res, () => dispatch(i + 1))).catch(next);
-      } catch (err) {
-        next(err);
-      }
-    }
-
-    dispatch(index);
-  };
-}

package/src/db/index.ts

@@ -1,31 +0,0 @@
-// Thread-local DB client populated during Pre-Flight.
-// The Proxy ensures callers import `db` once and never null-check it —
-// it throws with a helpful message if accessed before Pre-Flight completes.
-
-type AnyClient = Record<string, unknown>;
-
-let _client: AnyClient | null = null;
-
-export function setDbClient(client: AnyClient): void {
-  _client = client;
-}
-
-export function getDbClient(): AnyClient {
-  if (!_client) {
-    throw new Error('[EFC] db not ready — accessed before Pre-Flight completed');
-  }
-  return _client;
-}
-
-export const db: AnyClient = new Proxy({} as AnyClient, {
-  get(_target, prop: string) {
-    return getDbClient()[prop];
-  },
-  set(_target, prop: string, value: unknown) {
-    getDbClient()[prop] = value;
-    return true;
-  },
-});
-
-export { connectMongo } from './mongo.js';
-export { defineModel } from './model.js';

package/src/db/model.ts

@@ -1,95 +0,0 @@
-import type { ModelSchema, ModelCRUD } from '../types.js';
-
-type AnyRecord = Record<string, unknown> & { id: string };
-
-function normalise(doc: Record<string, unknown>): AnyRecord {
-  const id = doc['_id'] ? String(doc['_id']) : '';
-  return { ...doc, id } as AnyRecord;
-}
-
-async function getModel(name: string, schemaObj: Record<string, unknown>): Promise<import('mongoose').Model<Record<string, unknown>>> {
-  let mg: typeof import('mongoose');
-  try {
-    mg = await import('mongoose');
-  } catch {
-    throw new Error('[EFC] mongoose is not installed. Run: npm install mongoose');
-  }
-
-  if (mg.models[name]) return mg.models[name] as import('mongoose').Model<Record<string, unknown>>;
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const schema = new mg.Schema(schemaObj as any, { timestamps: true });
-  return mg.model<Record<string, unknown>>(name, schema);
-}
-
-function buildMongooseSchema(schema: ModelSchema): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
-  for (const [key, def] of Object.entries(schema)) {
-    const entry: Record<string, unknown> = {};
-    switch (def.type) {
-      case 'string':   entry['type'] = String; break;
-      case 'number':   entry['type'] = Number; break;
-      case 'boolean':  entry['type'] = Boolean; break;
-      case 'date':     entry['type'] = Date; break;
-      case 'object':   entry['type'] = Object; break;
-      case 'array':    entry['type'] = Array; break;
-    }
-    if (def.required !== undefined) entry['required'] = def.required;
-    if (def.unique !== undefined)   entry['unique'] = def.unique;
-    if (def.default !== undefined)  entry['default'] = def.default;
-    out[key] = entry;
-  }
-  return out;
-}
-
-export function defineModel<T extends Record<string, unknown>>(
-  name: string,
-  schema: ModelSchema,
-): ModelCRUD<T> {
-  const mongooseSchema = buildMongooseSchema(schema);
-
-  return {
-    async find(filter = {}) {
-      const M = await getModel(name, mongooseSchema);
-      const docs = await M.find(filter as Record<string, unknown>).lean();
-      return (docs as Record<string, unknown>[]).map(normalise) as (T & { id: string })[];
-    },
-
-    async findById(id) {
-      const M = await getModel(name, mongooseSchema);
-      const doc = await M.findById(id).lean();
-      if (!doc) return null;
-      return normalise(doc as Record<string, unknown>) as T & { id: string };
-    },
-
-    async findOne(filter) {
-      const M = await getModel(name, mongooseSchema);
-      const doc = await M.findOne(filter as Record<string, unknown>).lean();
-      if (!doc) return null;
-      return normalise(doc as Record<string, unknown>) as T & { id: string };
-    },
-
-    async create(data) {
-      const M = await getModel(name, mongooseSchema);
-      const doc = await M.create(data);
-      return normalise(doc.toObject() as Record<string, unknown>) as T & { id: string };
-    },
-
-    async update(id, data) {
-      const M = await getModel(name, mongooseSchema);
-      const doc = await M.findByIdAndUpdate(id, data, { new: true }).lean();
-      if (!doc) return null;
-      return normalise(doc as Record<string, unknown>) as T & { id: string };
-    },
-
-    async delete(id) {
-      const M = await getModel(name, mongooseSchema);
-      await M.findByIdAndDelete(id);
-    },
-
-    async count(filter = {}) {
-      const M = await getModel(name, mongooseSchema);
-      return M.countDocuments(filter as Record<string, unknown>);
-    },
-  };
-}

package/src/db/mongo.ts

@@ -1,22 +0,0 @@
-// Wraps mongoose connection for Pre-Flight. Throws clearly if mongoose isn't installed.
-
-let mongoose: typeof import('mongoose');
-
-async function loadMongoose(): Promise<typeof import('mongoose')> {
-  if (mongoose) return mongoose;
-  try {
-    mongoose = await import('mongoose');
-    return mongoose;
-  } catch {
-    throw new Error(
-      '[EFC] mongoose is not installed. Run: npm install mongoose',
-    );
-  }
-}
-
-export async function connectMongo(url: string): Promise<import('mongoose').Connection> {
-  const mg = await loadMongoose();
-  await mg.connect(url);
-  console.log('[EFC] MongoDB connected');
-  return mg.connection;
-}

package/src/errors.ts

@@ -1,10 +0,0 @@
-export class HttpError extends Error {
-  readonly statusCode: number;
-
-  constructor(statusCode: number, message: string) {
-    super(message);
-    this.name = 'HttpError';
-    this.statusCode = statusCode;
-    Error.captureStackTrace(this, HttpError);
-  }
-}

package/src/ignite.test.ts

@@ -1,193 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import request from 'supertest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import type { Server } from 'node:http';
-import { ignite } from './index.js';
-
-// helpers ----------------------------------------------------------------
-
-function tmpDir() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'efc-ignite-'));
-}
-
-function writeRoute(dir: string, name: string, code: string) {
-  const file = path.join(dir, name);
-  fs.writeFileSync(file, code);
-  return file;
-}
-
-function closeServer(server: Server): Promise<void> {
-  return new Promise((resolve, reject) => server.close((e) => (e ? reject(e) : resolve())));
-}
-
-// -----------------------------------------------------------------------
-
-describe('ignite() — server integration', () => {
-  let apiDir: string;
-  let server: Server | undefined;
-
-  beforeEach(() => {
-    apiDir = tmpDir();
-    // ensure no DATABASE_URL so connectMongo is never called
-    delete process.env['DATABASE_URL'];
-    delete process.env['CORS_ORIGINS'];
-  });
-
-  afterEach(async () => {
-    if (server) { await closeServer(server); server = undefined; }
-    fs.rmSync(apiDir, { recursive: true, force: true });
-  });
-
-  // --- route serving ----------------------------------------------------
-
-  it('serves a GET route', async () => {
-    writeRoute(apiDir, 'health.js', `export const GET = async (_req, res) => res.json({ ok: true });`);
-    server = await ignite({ apiDir, cluster: false });
-    const res = await request(server).get('/health');
-    expect(res.status).toBe(200);
-    expect(res.body).toEqual({ ok: true });
-  });
-
-  it('serves a POST route', async () => {
-    writeRoute(apiDir, 'echo.js', `export const POST = async (req, res) => res.status(201).json(req.body);`);
-    server = await ignite({ apiDir, cluster: false });
-    const res = await request(server).post('/echo').send({ msg: 'hello' });
-    expect(res.status).toBe(201);
-    expect(res.body).toEqual({ msg: 'hello' });
-  });
-
-  it('resolves dynamic route params', async () => {
-    fs.mkdirSync(path.join(apiDir, 'users'));
-    writeRoute(
-      path.join(apiDir, 'users'), '[id].js',
-      `export const GET = async (req, res) => res.json({ id: req.params.id });`,
-    );
-    server = await ignite({ apiDir, cluster: false });
-    const res = await request(server).get('/users/42');
-    expect(res.status).toBe(200);
-    expect(res.body).toEqual({ id: '42' });
-  });
-
-  it('returns 405 for an unregistered method', async () => {
-    writeRoute(apiDir, 'items.js', `export const GET = async (_req, res) => res.json([]);`);
-    server = await ignite({ apiDir, cluster: false });
-    const res = await request(server).post('/items');
-    expect(res.status).toBe(405);
-  });
-
-  // --- body parsing -----------------------------------------------------
-
-  it('parses JSON bodies automatically', async () => {
-    writeRoute(apiDir, 'body.js', `export const POST = async (req, res) => res.json(req.body);`);
-    server = await ignite({ apiDir, cluster: false });
-    const res = await request(server)
-      .post('/body')
-      .set('Content-Type', 'application/json')
-      .send(JSON.stringify({ x: 1 }));
-    expect(res.body).toEqual({ x: 1 });
-  });
-
-  it('parses URL-encoded bodies automatically', async () => {
-    writeRoute(apiDir, 'form.js', `export const POST = async (req, res) => res.json(req.body);`);
-    server = await ignite({ apiDir, cluster: false });
-    const res = await request(server)
-      .post('/form')
-      .set('Content-Type', 'application/x-www-form-urlencoded')
-      .send('name=efc&version=1');
-    expect(res.body).toEqual({ name: 'efc', version: '1' });
-  });
-
-  // --- CORS -------------------------------------------------------------
-
-  it('allows all origins by default', async () => {
-    writeRoute(apiDir, 'ping.js', `export const GET = async (_req, res) => res.json({});`);
-    server = await ignite({ apiDir, cluster: false });
-    const res = await request(server).get('/ping').set('Origin', 'http://unknown.example');
-    expect(res.headers['access-control-allow-origin']).toBe('http://unknown.example');
-  });
-
-  it('restricts origins when CORS_ORIGINS is set', async () => {
-    process.env['CORS_ORIGINS'] = 'http://allowed.example';
-    writeRoute(apiDir, 'ping.js', `export const GET = async (_req, res) => res.json({});`);
-    server = await ignite({ apiDir, cluster: false });
-
-    const allowed = await request(server).get('/ping').set('Origin', 'http://allowed.example');
-    expect(allowed.headers['access-control-allow-origin']).toBe('http://allowed.example');
-
-    const blocked = await request(server).get('/ping').set('Origin', 'http://evil.example');
-    expect(blocked.headers['access-control-allow-origin']).toBeUndefined();
-  });
-
-  it('supports multiple origins in CORS_ORIGINS', async () => {
-    process.env['CORS_ORIGINS'] = 'http://a.example, http://b.example';
-    writeRoute(apiDir, 'ping.js', `export const GET = async (_req, res) => res.json({});`);
-    server = await ignite({ apiDir, cluster: false });
-
-    const a = await request(server).get('/ping').set('Origin', 'http://a.example');
-    expect(a.headers['access-control-allow-origin']).toBe('http://a.example');
-
-    const b = await request(server).get('/ping').set('Origin', 'http://b.example');
-    expect(b.headers['access-control-allow-origin']).toBe('http://b.example');
-  });
-
-  it('disables CORS when cors: false', async () => {
-    writeRoute(apiDir, 'ping.js', `export const GET = async (_req, res) => res.json({});`);
-    server = await ignite({ apiDir, cluster: false, cors: false });
-    const res = await request(server).get('/ping').set('Origin', 'http://anywhere.example');
-    expect(res.headers['access-control-allow-origin']).toBeUndefined();
-  });
-
-  // --- port & env auto-reading ------------------------------------------
-
-  it('reads PORT from env when port is not passed', async () => {
-    process.env['PORT'] = '0'; // 0 = OS assigns a free port
-    writeRoute(apiDir, 'hi.js', `export const GET = async (_req, res) => res.json({ hi: true });`);
-    server = await ignite({ apiDir, cluster: false });
-    const addr = server.address() as { port: number };
-    expect(addr.port).toBeGreaterThan(0);
-    delete process.env['PORT'];
-  });
-
-  it('falls back to port 3000 when PORT env is absent', async () => {
-    delete process.env['PORT'];
-    writeRoute(apiDir, 'hi.js', `export const GET = async (_req, res) => res.json({});`);
-    server = await ignite({ apiDir, cluster: false, port: 0 }); // 0 avoids binding 3000 in tests
-    const addr = server.address() as { port: number };
-    expect(addr.port).toBeGreaterThan(0);
-  });
-
-  it('ignores NaN port and falls back to env PORT', async () => {
-    process.env['PORT'] = '0';
-    writeRoute(apiDir, 'hi.js', `export const GET = async (_req, res) => res.json({});`);
-    server = await ignite({ apiDir, cluster: false, port: Number(undefined) }); // NaN
-    const addr = server.address() as { port: number };
-    expect(addr.port).toBeGreaterThan(0);
-    delete process.env['PORT'];
-  });
-
-  // --- error handling ---------------------------------------------------
-
-  it('returns 404 for unknown routes', async () => {
-    writeRoute(apiDir, 'exists.js', `export const GET = async (_req, res) => res.json({});`);
-    server = await ignite({ apiDir, cluster: false });
-    const res = await request(server).get('/does-not-exist');
-    expect(res.status).toBe(404);
-  });
-
-  it('returns structured JSON for HttpError', async () => {
-    // Attach statusCode directly to avoid cross-module instanceof issues in tests
-    writeRoute(
-      apiDir, 'fail.js',
-      `export const GET = async (_req, _res, next) => {
-         const err = Object.assign(new Error('Invalid input'), { statusCode: 422 });
-         next(err);
-       };`,
-    );
-    server = await ignite({ apiDir, cluster: false });
-    const res = await request(server).get('/fail');
-    expect(res.status).toBe(422);
-    expect(res.body).toMatchObject({ error: 'Invalid input', statusCode: 422 });
-  });
-});

package/src/index.ts

@@ -1,162 +0,0 @@
-import 'dotenv/config';
-import http from 'node:http';
-import express from 'express';
-import cors from 'cors';
-import cookieParser from 'cookie-parser';
-import cluster from 'node:cluster';
-import os from 'node:os';
-import type { EFCConfig } from './types.js';
-import { scanDir } from './router/scan.js';
-import { mountRoutes } from './router/mount.js';
-import { runMaster } from './cluster/index.js';
-import { configureAuth } from './auth/index.js';
-import { HttpError } from './errors.js';
-import { connectMongo } from './db/mongo.js';
-import { setDbClient } from './db/index.js';
-import { scanTasks } from './tasks/scanner.js';
-import { initBullMQ } from './tasks/bullmq-backend.js';
-
-function detectDatabase(url?: string): 'mongodb' | 'postgresql' | undefined {
-  if (!url) return undefined;
-  if (url.startsWith('mongodb')) return 'mongodb';
-  if (url.startsWith('postgres')) return 'postgresql';
-  return undefined;
-}
-
-export async function ignite(config: EFCConfig): Promise<http.Server | undefined> {
-  const {
-    port: _port,
-    workers,
-    apiDir,
-    globalMiddlewares = [],
-    onWorkerReady,
-    onWorkerCrash,
-    onError,
-  } = config;
-
-  // All runtime values fall back to environment variables
-  const port =
-    _port != null && !Number.isNaN(_port) ? _port : Number(process.env['PORT']) || 3000;
-  const databaseUrl = config.databaseUrl ?? process.env['DATABASE_URL'];
-  const database = config.database ?? detectDatabase(databaseUrl);
-  const jwtSecret = config.jwtSecret ?? process.env['JWT_SECRET'];
-  const authStrategy = config.authStrategy ?? 'http-only';
-  const clusterEnabled = config.cluster ?? process.env['NODE_ENV'] === 'production';
-
-  if (clusterEnabled && cluster.isPrimary) {
-    runMaster({
-      workers: workers ?? os.cpus().length,
-      ...(onWorkerReady !== undefined && { onWorkerReady }),
-      ...(onWorkerCrash !== undefined && { onWorkerCrash }),
-    });
-    return;
-  }
-
-  const app = express();
-
-  const corsOption = config.cors ?? true;
-  if (corsOption !== false) {
-    const envOrigins = process.env['CORS_ORIGINS'];
-    let origin: string | string[] | boolean;
-    if (envOrigins) {
-      const list = envOrigins.split(',').map((o) => o.trim()).filter(Boolean);
-      origin = list; // always array so cors validates against the request Origin
-    } else if (typeof corsOption === 'object' && corsOption.origin !== undefined) {
-      origin = corsOption.origin;
-    } else {
-      origin = true;
-    }
-    const corsOpts = typeof corsOption === 'object' ? { ...corsOption, origin } : { origin };
-    app.use(cors(corsOpts));
-  }
-
-  app.use(express.json());
-  app.use(express.urlencoded({ extended: true }));
-  app.use(cookieParser());
-
-  for (const mw of globalMiddlewares) {
-    app.use(mw);
-  }
-
-  // Pre-Flight step 1: Connect database
-  if (database === 'mongodb' && databaseUrl) {
-    const conn = await connectMongo(databaseUrl);
-    setDbClient(conn as unknown as Record<string, unknown>);
-  }
-
-  // Pre-Flight step 2: Configure auth
-  if (jwtSecret) {
-    const cookieDomain = process.env['COOKIE_DOMAIN'];
-    configureAuth({
-      secret: jwtSecret,
-      strategy: authStrategy,
-      expiresIn: process.env['JWT_EXPIRES_IN'] ?? '7d',
-      ...(cookieDomain !== undefined && { cookieDomain }),
-    });
-  }
-
-  // Pre-Flight step 3: Scan and register tasks
-  if (config.tasksDir) {
-    await scanTasks(config.tasksDir);
-  }
-
-  // Pre-Flight step 4: Start task queue backend
-  if (config.tasks) {
-    if (config.tasks.backend === 'bullmq') {
-      await initBullMQ({
-        redisUrl: config.tasks.redisUrl ?? 'redis://localhost:6379',
-        concurrency: config.tasks.concurrency ?? 5,
-      });
-    }
-  }
-
-  // Pre-Flight step 5: Scan routes and mount
-  const routes = scanDir(apiDir);
-  await mountRoutes(app, routes);
-
-  if (onError) {
-    app.use(onError);
-  } else {
-    app.use(
-      (
-        err: unknown,
-        _req: express.Request,
-        res: express.Response,
-        _next: express.NextFunction,
-      ) => {
-        const asHttp = err instanceof Error && 'statusCode' in err
-          ? (err as HttpError) : null;
-        if (asHttp) {
-          res.status(asHttp.statusCode).json({ error: asHttp.message, statusCode: asHttp.statusCode });
-        } else {
-          console.error('[EFC] Unhandled error:', err);
-          res.status(500).json({ error: 'Internal Server Error', statusCode: 500 });
-        }
-      },
-    );
-  }
-
-  return new Promise<http.Server>((resolve) => {
-    const server = app.listen(port, () => {
-      const wid = (cluster.worker as { id: number } | undefined)?.id ?? 'primary';
-      console.log(`[EFC] Worker ${wid} listening on :${port}`);
-      resolve(server);
-    });
-  });
-}
-
-export { HttpError } from './errors.js';
-export { compose } from './compose.js';
-export { db, setDbClient, getDbClient, defineModel } from './db/index.js';
-export { scanDir } from './router/scan.js';
-export type {
-  EFCConfig,
-  CorsConfig,
-  RouteEntry,
-  TaskOptions,
-  TaskDefinition,
-  DatabaseEngine,
-  AuthStrategy,
-  ModelSchema,
-  ModelCRUD,
-} from './types.js';