@morojs/moro 1.5.16 → 1.6.0

package/dist/moro.js

@@ -1,59 +1,21 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Moro = void 0;
-exports.createApp = createApp;
-exports.createAppNode = createAppNode;
-exports.createAppEdge = createAppEdge;
-exports.createAppLambda = createAppLambda;
-exports.createAppWorker = createAppWorker;
 // Moro Framework - Modern TypeScript API Framework
 // Built for developers who demand performance, elegance, and zero compromises
 // Event-driven • Modular • Enterprise-ready • Developer-first
-const framework_1 = require("./core/framework");
-const http_1 = require("./core/http");
-const logger_1 = require("./core/logger");
-const middleware_1 = require("./core/middleware");
-const app_integration_1 = require("./core/routing/app-integration");
-const docs_1 = require("./core/docs");
-const events_1 = require("events");
+import { Moro as MoroCore } from './core/framework.js';
+import { middleware } from './core/http/index.js';
+import { createFrameworkLogger, applyLoggingConfiguration } from './core/logger/index.js';
+import { MiddlewareManager } from './core/middleware/index.js';
+import { IntelligentRoutingManager } from './core/routing/app-integration.js';
+import { AppDocumentationManager } from './core/docs/index.js';
+import { EventEmitter } from 'events';
+import cluster from 'cluster';
+import os from 'os';
+import { normalizeValidationError } from './core/validation/schema-interface.js';
 // Configuration System Integration
-const config_1 = require("./core/config");
+import { initializeConfig } from './core/config/index.js';
 // Runtime System Integration
-const runtime_1 = require("./core/runtime");
-class Moro extends events_1.EventEmitter {
+import { createRuntimeAdapter } from './core/runtime/index.js';
+export class Moro extends EventEmitter {
     coreFramework;
     routes = [];
     moduleCounter = 0;
@@ -61,14 +23,17 @@ class Moro extends events_1.EventEmitter {
     lazyModules = new Map();
     routeHandlers = {};
     moduleDiscovery; // Store for cleanup
+    autoDiscoveryOptions = null;
+    autoDiscoveryInitialized = false;
+    autoDiscoveryPromise = null;
     // Enterprise event system integration
     eventBus;
     // Application logger
     logger;
     // Intelligent routing system
-    intelligentRouting = new app_integration_1.IntelligentRoutingManager();
+    intelligentRouting = new IntelligentRoutingManager();
     // Documentation system
-    documentation = new docs_1.AppDocumentationManager();
+    documentation = new AppDocumentationManager();
     // Configuration system
     config;
     // Runtime system
@@ -76,43 +41,48 @@ class Moro extends events_1.EventEmitter {
     runtimeType;
     // Middleware system
     middlewareManager;
+    // Queued WebSocket registrations (for async adapter detection)
+    queuedWebSocketRegistrations = [];
     constructor(options = {}) {
         super(); // Call EventEmitter constructor
         // Apply logging configuration BEFORE config loading to avoid DEBUG spam
         // 1. Environment variables (base level)
         const envLogLevel = process.env.LOG_LEVEL || process.env.MORO_LOG_LEVEL;
         if (envLogLevel) {
-            (0, logger_1.applyLoggingConfiguration)({ level: envLogLevel }, undefined);
+            applyLoggingConfiguration({ level: envLogLevel }, undefined);
         }
         // 2. createApp logger options (highest precedence)
         if (options.logger !== undefined) {
-            (0, logger_1.applyLoggingConfiguration)(undefined, options.logger);
+            applyLoggingConfiguration(undefined, options.logger);
         }
         // Create logger AFTER initial configuration
-        this.logger = (0, logger_1.createFrameworkLogger)('App');
+        this.logger = createFrameworkLogger('App');
         // Use simplified global configuration system
-        this.config = (0, config_1.initializeConfig)(options);
+        this.config = initializeConfig(options);
         // Apply config file logging if it exists (may override createApp options if needed)
         if (this.config.logging && !options.logger) {
-            (0, logger_1.applyLoggingConfiguration)(this.config.logging, undefined);
+            applyLoggingConfiguration(this.config.logging, undefined);
             // Recreate logger with updated config
-            this.logger = (0, logger_1.createFrameworkLogger)('App');
+            this.logger = createFrameworkLogger('App');
         }
         this.logger.info(`Configuration system initialized: ${process.env.NODE_ENV || 'development'}:${this.config.server.port}`);
         // Initialize runtime system
         this.runtimeType = options.runtime?.type || 'node';
-        this.runtimeAdapter = options.runtime?.adapter || (0, runtime_1.createRuntimeAdapter)(this.runtimeType);
+        this.runtimeAdapter = options.runtime?.adapter || createRuntimeAdapter(this.runtimeType);
         this.logger.info(`Runtime system initialized: ${this.runtimeType}`, 'Runtime');
         // Pass configuration from config to framework
         const frameworkOptions = {
             ...options,
             logger: this.config.logging,
-            websocket: this.config.websocket.enabled ? options.websocket || {} : false,
+            // Enable websockets if either config has it enabled OR user passed websocket options
+            websocket: this.config.websocket.enabled || options.websocket
+                ? options.websocket || this.config.websocket || {}
+                : false,
             config: this.config,
         };
-        this.coreFramework = new framework_1.Moro(frameworkOptions);
+        this.coreFramework = new MoroCore(frameworkOptions);
         // Initialize middleware system
-        this.middlewareManager = new middleware_1.MiddlewareManager();
+        this.middlewareManager = new MiddlewareManager();
         // Integrate hooks system with HTTP server
         const httpServer = this.coreFramework.httpServer;
         if (httpServer && httpServer.setHookManager) {
@@ -133,15 +103,10 @@ class Moro extends events_1.EventEmitter {
             ...this.getDefaultOptionsFromConfig(),
             ...options,
         });
-        // Auto-discover modules if enabled
-        if (options.autoDiscover !== false) {
-            // Initialize auto-discovery asynchronously
-            this.initializeAutoDiscovery(options).catch(error => {
-                this.logger.error('Auto-discovery initialization failed', 'Framework', {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            });
-        }
+        // Store auto-discovery options for later initialization
+        // IMPORTANT: Auto-discovery is deferred to ensure user middleware (like auth)
+        // is registered before module middleware that might bypass it
+        this.autoDiscoveryOptions = options.autoDiscover !== false ? options : null;
         // Emit initialization event through enterprise event bus
         this.eventBus.emit('framework:initialized', {
             options,
@@ -307,6 +272,11 @@ class Moro extends events_1.EventEmitter {
                 version: moduleOrPath.version || '1.0.0',
             });
         }
+        // IMPORTANT: If modules are loaded manually after auto-discovery,
+        // ensure the final module handler is set up to maintain middleware order
+        if (this.autoDiscoveryInitialized) {
+            this.coreFramework.setupFinalModuleHandler();
+        }
         return this;
     }
     // Database helper with events
@@ -320,29 +290,36 @@ class Moro extends events_1.EventEmitter {
     }
     // WebSocket helper with events
     websocket(namespace, handlers) {
+        // Queue the registration to be processed after adapter initialization
+        const registration = { namespace, handlers, processed: false };
+        this.queuedWebSocketRegistrations.push(registration);
+        // Try to process immediately if adapter is already ready
         const adapter = this.coreFramework.getWebSocketAdapter();
-        if (!adapter) {
-            throw new Error('WebSocket features require a WebSocket adapter. Install socket.io or configure an adapter:\n' +
-                'npm install socket.io\n' +
-                'or\n' +
-                'new Moro({ websocket: { adapter: new SocketIOAdapter() } })');
+        if (adapter && !registration.processed) {
+            // Adapter is ready, process immediately
+            this.processWebSocketRegistration(namespace, handlers, adapter);
+            registration.processed = true;
         }
+        // Otherwise, it will be processed when the server starts
+        return this;
+    }
+    processWebSocketRegistration(namespace, handlers, adapter) {
         this.emit('websocket:registering', { namespace, handlers });
         const ns = adapter.createNamespace(namespace);
         Object.entries(handlers).forEach(([event, handler]) => {
-            ns.on('connection', socket => {
+            ns.on('connection', (socket) => {
                 this.emit('websocket:connection', { namespace, event, socket });
                 socket.on(event, (data, callback) => {
                     this.emit('websocket:event', { namespace, event, data });
                     Promise.resolve(handler(socket, data))
-                        .then(result => {
+                        .then((result) => {
                         this.emit('websocket:response', { namespace, event, result });
                         if (callback)
                             callback(result);
                         else if (result)
                             socket.emit(`${event}:response`, result);
                     })
-                        .catch(error => {
+                        .catch((error) => {
                         this.emit('websocket:error', { namespace, event, error });
                         const errorResponse = { success: false, error: error.message };
                         if (callback)
@@ -354,7 +331,33 @@ class Moro extends events_1.EventEmitter {
             });
         });
         this.emit('websocket:registered', { namespace, handlers });
-        return this;
+    }
+    async processQueuedWebSocketRegistrations() {
+        // Wait for WebSocket adapter to be ready
+        await this.coreFramework.ensureWebSocketReady();
+        const adapter = this.coreFramework.getWebSocketAdapter();
+        // Check if any unprocessed registrations exist
+        const unprocessedRegistrations = this.queuedWebSocketRegistrations.filter(r => !r.processed);
+        if (!adapter && unprocessedRegistrations.length > 0) {
+            throw new Error('WebSocket features require a WebSocket adapter.\n\n' +
+                'Option 1: Install socket.io (auto-detected):\n' +
+                '  npm install socket.io\n' +
+                '  const app = new Moro({ websocket: {} });\n\n' +
+                'Option 2: Configure a specific adapter:\n' +
+                "  import { SocketIOAdapter } from '@morojs/moro';\n" +
+                '  const app = new Moro({ websocket: { adapter: new SocketIOAdapter() } });\n\n' +
+                'Option 3: Enable in config file (moro.config.js):\n' +
+                '  export default { websocket: { enabled: true } };');
+        }
+        if (adapter) {
+            // Process all unprocessed registrations
+            for (const registration of this.queuedWebSocketRegistrations) {
+                if (!registration.processed) {
+                    this.processWebSocketRegistration(registration.namespace, registration.handlers, adapter);
+                    registration.processed = true;
+                }
+            }
+        }
     }
     listen(portOrCallback, hostOrCallback, callback) {
         // Only available for Node.js runtime
@@ -396,9 +399,18 @@ class Moro extends events_1.EventEmitter {
             throw new Error('Port not specified and not found in configuration. Please provide a port number or configure it in moro.config.js/ts');
         }
         // Check if clustering is enabled for massive performance gains
+        // NOTE: uWebSockets.js does NOT support Node.js clustering - it's single-threaded only
+        const usingUWebSockets = this.config.server?.useUWebSockets || false;
         if (this.config.performance?.clustering?.enabled) {
-            this.startWithClustering(port, host, callback);
-            return;
+            if (usingUWebSockets) {
+                this.logger.warn('Clustering is not supported with uWebSockets.js - running in single-threaded mode. ' +
+                    'uWebSockets is so fast that single-threaded performance often exceeds multi-threaded Node.js!', 'Cluster');
+                // Continue without clustering
+            }
+            else {
+                this.startWithClustering(port, host, callback);
+                return;
+            }
         }
         this.eventBus.emit('server:starting', { port, runtime: this.runtimeType });
         // Add documentation middleware first (if enabled)
@@ -423,33 +435,139 @@ class Moro extends events_1.EventEmitter {
         if (this.routes.length > 0) {
             this.registerDirectRoutes();
         }
-        const actualCallback = () => {
-            const displayHost = host || 'localhost';
-            this.logger.info('Moro Server Started', 'Server');
-            this.logger.info(`Runtime: ${this.runtimeType}`, 'Server');
-            this.logger.info(`HTTP API: http://${displayHost}:${port}`, 'Server');
-            if (this.config.websocket.enabled) {
-                this.logger.info(`WebSocket: ws://${displayHost}:${port}`, 'Server');
+        const startServer = () => {
+            const actualCallback = () => {
+                const displayHost = host || 'localhost';
+                this.logger.info('Moro Server Started', 'Server');
+                this.logger.info(`Runtime: ${this.runtimeType}`, 'Server');
+                this.logger.info(`HTTP API: http://${displayHost}:${port}`, 'Server');
+                if (this.config.websocket.enabled) {
+                    this.logger.info(`WebSocket: ws://${displayHost}:${port}`, 'Server');
+                }
+                this.logger.info('Learn more at https://morojs.com', 'Server');
+                // Log intelligent routes info
+                const intelligentRoutes = this.intelligentRouting.getIntelligentRoutes();
+                if (intelligentRoutes.length > 0) {
+                    this.logger.info(`Intelligent Routes: ${intelligentRoutes.length} registered`, 'Server');
+                }
+                this.eventBus.emit('server:started', { port, runtime: this.runtimeType });
+                if (callback)
+                    callback();
+            };
+            if (host && typeof host === 'string') {
+                this.coreFramework.listen(port, host, actualCallback);
             }
-            this.logger.info('Learn more at https://morojs.com', 'Server');
-            // Log intelligent routes info
-            const intelligentRoutes = this.intelligentRouting.getIntelligentRoutes();
-            if (intelligentRoutes.length > 0) {
-                this.logger.info(`Intelligent Routes: ${intelligentRoutes.length} registered`, 'Server');
+            else {
+                this.coreFramework.listen(port, actualCallback);
             }
-            this.eventBus.emit('server:started', { port, runtime: this.runtimeType });
-            if (callback)
-                callback();
         };
-        if (host && typeof host === 'string') {
-            this.coreFramework.listen(port, host, actualCallback);
+        // Ensure auto-discovery and WebSocket setup is complete before starting server
+        Promise.all([this.ensureAutoDiscoveryComplete(), this.processQueuedWebSocketRegistrations()])
+            .then(() => {
+            startServer();
+        })
+            .catch(error => {
+            this.logger.error('Initialization failed during server start', 'Framework', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // For auto-discovery failures, start server anyway
+            // For WebSocket failures with queued registrations, error will propagate
+            if (error instanceof Error &&
+                error.message.includes('WebSocket features require a WebSocket adapter')) {
+                throw error;
+            }
+            startServer();
+        });
+    }
+    // Public method to manually initialize auto-discovery
+    // Useful for ensuring auth middleware is registered before auto-discovery
+    async initializeAutoDiscoveryNow() {
+        return this.ensureAutoDiscoveryComplete();
+    }
+    // Public API: Initialize modules explicitly after middleware setup
+    // This provides users with explicit control over module loading timing
+    // IMPORTANT: This forces module loading even if autoDiscovery.enabled is false
+    // Usage: app.initModules() or app.initModules({ paths: ['./my-modules'] })
+    initModules(options) {
+        this.logger.info('User-requested module initialization', 'ModuleSystem');
+        // If already initialized, do nothing
+        if (this.autoDiscoveryInitialized) {
+            this.logger.debug('Auto-discovery already completed, skipping', 'ModuleSystem');
+            return;
         }
-        else {
-            this.coreFramework.listen(port, actualCallback);
+        // Store the options and mark that we want to force initialization
+        this.autoDiscoveryOptions = {
+            autoDiscover: {
+                enabled: true, // Force enabled regardless of original config
+                paths: options?.paths || ['./modules', './src/modules'],
+                patterns: options?.patterns || [
+                    '**/*.module.{ts,js}',
+                    '**/index.{ts,js}',
+                    '**/*.config.{ts,js}',
+                ],
+                recursive: options?.recursive ?? true,
+                loadingStrategy: options?.loadingStrategy || 'eager',
+                watchForChanges: options?.watchForChanges ?? false,
+                ignorePatterns: options?.ignorePatterns || [
+                    '**/*.test.{ts,js}',
+                    '**/*.spec.{ts,js}',
+                    '**/node_modules/**',
+                ],
+                loadOrder: options?.loadOrder || 'dependency',
+                failOnError: options?.failOnError ?? false,
+                maxDepth: options?.maxDepth ?? 5,
+            },
+        };
+        this.logger.debug('Module initialization options stored, will execute on next listen/getHandler call', 'ModuleSystem');
+    }
+    // Robust method to ensure auto-discovery is complete, handling race conditions
+    async ensureAutoDiscoveryComplete() {
+        // If already initialized, nothing to do
+        if (this.autoDiscoveryInitialized) {
+            return;
+        }
+        // If auto-discovery is disabled, mark as initialized
+        if (!this.autoDiscoveryOptions) {
+            this.autoDiscoveryInitialized = true;
+            return;
+        }
+        // If already in progress, wait for it to complete
+        if (this.autoDiscoveryPromise) {
+            return this.autoDiscoveryPromise;
+        }
+        // Start auto-discovery
+        this.autoDiscoveryPromise = this.performAutoDiscovery();
+        try {
+            await this.autoDiscoveryPromise;
+            this.autoDiscoveryInitialized = true;
+        }
+        catch (error) {
+            // Reset promise on error so it can be retried
+            this.autoDiscoveryPromise = null;
+            throw error;
+        }
+        finally {
+            this.autoDiscoveryOptions = null; // Clear after attempt
         }
     }
+    // Perform the actual auto-discovery work
+    async performAutoDiscovery(optionsOverride) {
+        const optionsToUse = optionsOverride || this.autoDiscoveryOptions;
+        if (!optionsToUse)
+            return;
+        this.logger.debug('Starting auto-discovery initialization', 'AutoDiscovery');
+        await this.initializeAutoDiscovery(optionsToUse);
+        this.logger.debug('Auto-discovery initialization completed', 'AutoDiscovery');
+    }
     // Get handler for non-Node.js runtimes
     getHandler() {
+        // Ensure auto-discovery is complete for non-Node.js runtimes
+        // This handles the case where users call getHandler() immediately after createApp()
+        this.ensureAutoDiscoveryComplete().catch(error => {
+            this.logger.error('Auto-discovery initialization failed for runtime handler', 'Framework', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        });
         // Create a unified request handler that works with the runtime adapter
         const handler = async (req, res) => {
             // Add documentation middleware first (if enabled)
@@ -667,7 +785,6 @@ class Moro extends events_1.EventEmitter {
                         }
                         catch (error) {
                             // Handle universal validation errors
-                            const { normalizeValidationError } = require('./core/validation/schema-interface');
                             const normalizedError = normalizeValidationError(error);
                             res.status(400).json({
                                 success: false,
@@ -744,11 +861,11 @@ class Moro extends events_1.EventEmitter {
                 : this.config.security.cors
                     ? this.config.security.cors
                     : {};
-            this.use(http_1.middleware.cors(corsOptions));
+            this.use(middleware.cors(corsOptions));
         }
         // Helmet - check config enabled property OR options.security.helmet.enabled === true
         if (this.config.security.helmet.enabled || options.security?.helmet?.enabled === true) {
-            this.use(http_1.middleware.helmet());
+            this.use(middleware.helmet());
         }
         // Compression - check config enabled property OR options.performance.compression.enabled === true
         if (this.config.performance.compression.enabled ||
@@ -758,14 +875,14 @@ class Moro extends events_1.EventEmitter {
                 : this.config.performance.compression
                     ? this.config.performance.compression
                     : {};
-            this.use(http_1.middleware.compression(compressionOptions));
+            this.use(middleware.compression(compressionOptions));
         }
         // Body size limiting
-        this.use(http_1.middleware.bodySize({ limit: '10mb' }));
+        this.use(middleware.bodySize({ limit: '10mb' }));
     }
     // Enhanced auto-discovery initialization
     async initializeAutoDiscovery(options) {
-        const { ModuleDiscovery } = await Promise.resolve().then(() => __importStar(require('./core/modules/auto-discovery')));
+        const { ModuleDiscovery } = await import('./core/modules/auto-discovery.js');
         // Merge auto-discovery configuration
         const autoDiscoveryConfig = this.mergeAutoDiscoveryConfig(options);
         if (!autoDiscoveryConfig.enabled) {
@@ -777,6 +894,8 @@ class Moro extends events_1.EventEmitter {
             const modules = await this.moduleDiscovery.discoverModulesAdvanced(autoDiscoveryConfig);
             // Load modules based on strategy
             await this.loadDiscoveredModules(modules, autoDiscoveryConfig);
+            // Setup final module handler to run after user middleware (like auth)
+            this.coreFramework.setupFinalModuleHandler();
             // Setup file watching if enabled
             if (autoDiscoveryConfig.watchForChanges) {
                 this.moduleDiscovery.watchModulesAdvanced(autoDiscoveryConfig, async (updatedModules) => {
@@ -930,7 +1049,7 @@ class Moro extends events_1.EventEmitter {
         });
     }
     async importModule(modulePath) {
-        const module = await Promise.resolve(`${modulePath}`).then(s => __importStar(require(s)));
+        const module = await import(modulePath);
         return module.default || module;
     }
     /**
@@ -952,8 +1071,6 @@ class Moro extends events_1.EventEmitter {
      */
     clusterWorkers = new Map();
     startWithClustering(port, host, callback) {
-        const cluster = require('cluster');
-        const os = require('os');
         // Worker count calculation - respect user choice
         let workerCount = this.config.performance?.clustering?.workers || os.cpus().length;
         // Only auto-optimize if user hasn't specified a number or set it to 'auto'
@@ -1045,12 +1162,11 @@ class Moro extends events_1.EventEmitter {
             // Multiple workers writing to same log files creates I/O contention
             if (this.config.logging) {
                 // Workers log less frequently to reduce I/O contention
-                (0, logger_1.applyLoggingConfiguration)(undefined, { level: 'warn' }); // Only warnings and errors
+                applyLoggingConfiguration(undefined, { level: 'warn' }); // Only warnings and errors
             }
             // Research-based memory optimization for workers
-            const os = require('os');
             const totalMemoryGB = os.totalmem() / (1024 * 1024 * 1024);
-            const workerCount = Object.keys(require('cluster').workers || {}).length || 1;
+            const workerCount = Object.keys(cluster.workers || {}).length || 1;
             // Conservative memory allocation
             const heapSizePerWorkerMB = Math.min(Math.floor(((totalMemoryGB * 1024) / workerCount) * 0.8), // 80% of available memory
             1536 // Cap at 1.5GB (GC efficiency threshold from research)
@@ -1132,12 +1248,33 @@ class Moro extends events_1.EventEmitter {
                     worker: process.pid,
                 });
             };
-            if (host) {
-                this.coreFramework.listen(port, host, workerCallback);
-            }
-            else {
-                this.coreFramework.listen(port, workerCallback);
-            }
+            // Ensure WebSocket setup is complete before starting worker
+            this.processQueuedWebSocketRegistrations()
+                .then(() => {
+                if (host) {
+                    this.coreFramework.listen(port, host, workerCallback);
+                }
+                else {
+                    this.coreFramework.listen(port, workerCallback);
+                }
+            })
+                .catch(error => {
+                this.logger.error('WebSocket initialization failed in worker', 'Worker', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                // For WebSocket failures with queued registrations, error will propagate
+                if (error instanceof Error &&
+                    error.message.includes('WebSocket features require a WebSocket adapter')) {
+                    throw error;
+                }
+                // Start anyway for other errors
+                if (host) {
+                    this.coreFramework.listen(port, host, workerCallback);
+                }
+                else {
+                    this.coreFramework.listen(port, workerCallback);
+                }
+            });
         }
     }
     // Simple worker message handler
@@ -1201,31 +1338,30 @@ class Moro extends events_1.EventEmitter {
         this.logger.debug('Moro application closed successfully');
     }
 }
-exports.Moro = Moro;
 // Export convenience function
-function createApp(options) {
+export function createApp(options) {
     return new Moro(options);
 }
 // Runtime-specific convenience functions
-function createAppNode(options) {
+export function createAppNode(options) {
     return new Moro({
         ...options,
         runtime: { type: 'node' },
     });
 }
-function createAppEdge(options) {
+export function createAppEdge(options) {
     return new Moro({
         ...options,
         runtime: { type: 'vercel-edge' },
     });
 }
-function createAppLambda(options) {
+export function createAppLambda(options) {
     return new Moro({
         ...options,
         runtime: { type: 'aws-lambda' },
     });
 }
-function createAppWorker(options) {
+export function createAppWorker(options) {
     return new Moro({
         ...options,
         runtime: { type: 'cloudflare-workers' },