@spfn/core 0.1.0-alpha.83 → 0.1.0-alpha.85

package/dist/events/index.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Event handler function type
+ */
+type EventHandler<T = any> = (data: T) => Promise<void> | void;
+/**
+ * EventEmitter interface
+ *
+ * All event emitter adapters must implement this interface
+ */
+interface EventEmitter {
+    /**
+     * Subscribe to an event
+     *
+     * @param event - Event name
+     * @param handler - Event handler function
+     */
+    on(event: string, handler: EventHandler): void;
+    /**
+     * Emit an event
+     *
+     * @param event - Event name
+     * @param data - Event data
+     */
+    emit(event: string, data?: any): Promise<void>;
+    /**
+     * Unsubscribe from an event
+     *
+     * @param event - Event name
+     */
+    off(event: string): void;
+    /**
+     * Clear all event subscriptions
+     */
+    clear(): void;
+}
+
+/**
+ * Event Emitter
+ *
+ * Adapter-based event emitter for decoupled communication between packages.
+ *
+ * Default adapter: InMemoryEventEmitter (single-instance)
+ *
+ * @example
+ * ```typescript
+ * // Subscribe to events
+ * import { on } from '@spfn/core/events';
+ *
+ * on('user:created', async (data) => {
+ *   console.log('User created:', data.email);
+ * });
+ *
+ * // Emit events
+ * import { emit } from '@spfn/core/events';
+ *
+ * await emit('user:created', {
+ *   userId: '123',
+ *   email: 'user@example.com'
+ * });
+ *
+ * // Switch to Redis adapter (multi-instance)
+ * import { setEventEmitter } from '@spfn/core/events';
+ * import { RedisEventEmitter } from '@spfn/core/events/adapters';
+ *
+ * setEventEmitter(new RedisEventEmitter({
+ *   host: 'localhost',
+ *   port: 6379
+ * }));
+ * ```
+ */
+
+/**
+ * Set the event emitter adapter
+ *
+ * @param adapter - EventEmitter adapter implementation
+ *
+ * @example
+ * ```typescript
+ * import { setEventEmitter } from '@spfn/core/events';
+ * import { InMemoryEventEmitter } from '@spfn/core/events/adapters';
+ *
+ * setEventEmitter(new InMemoryEventEmitter());
+ * ```
+ */
+declare function setEventEmitter(adapter: EventEmitter): void;
+/**
+ * Get the current event emitter adapter
+ *
+ * @returns Current EventEmitter instance
+ */
+declare function getEventEmitter(): EventEmitter;
+/**
+ * Subscribe to an event
+ *
+ * @param event - Event name
+ * @param handler - Event handler function
+ *
+ * @example
+ * ```typescript
+ * on('user:created', async (data) => {
+ *   console.log('User created:', data.email);
+ * });
+ * ```
+ */
+declare function on(event: string, handler: EventHandler): void;
+/**
+ * Emit an event
+ *
+ * @param event - Event name
+ * @param data - Event data
+ *
+ * @example
+ * ```typescript
+ * await emit('user:created', {
+ *   userId: '123',
+ *   email: 'user@example.com'
+ * });
+ * ```
+ */
+declare function emit(event: string, data?: any): Promise<void>;
+/**
+ * Unsubscribe from an event
+ *
+ * @param event - Event name
+ *
+ * @example
+ * ```typescript
+ * off('user:created');
+ * ```
+ */
+declare function off(event: string): void;
+/**
+ * Clear all event subscriptions
+ *
+ * Useful for testing or cleanup
+ *
+ * @example
+ * ```typescript
+ * // In tests
+ * beforeEach(() => {
+ *   clear();
+ * });
+ * ```
+ */
+declare function clear(): void;
+
+/**
+ * In-Memory Event Emitter
+ *
+ * Simple in-process event emitter for single-instance deployments.
+ * Events are not shared across multiple server instances.
+ *
+ * Use this adapter for:
+ * - Development
+ * - Single-instance production deployments
+ * - When you don't need distributed events
+ *
+ * @example
+ * ```typescript
+ * import { setEventEmitter } from '@spfn/core/events';
+ * import { InMemoryEventEmitter } from '@spfn/core/events/adapters';
+ *
+ * setEventEmitter(new InMemoryEventEmitter());
+ * ```
+ */
+
+declare class InMemoryEventEmitter implements EventEmitter {
+    private listeners;
+    on(event: string, handler: EventHandler): void;
+    emit(event: string, data?: any): Promise<void>;
+    off(event: string): void;
+    clear(): void;
+    /**
+     * Get list of registered events (for debugging)
+     */
+    getEvents(): string[];
+    /**
+     * Get number of handlers for an event (for debugging)
+     */
+    getHandlerCount(event: string): number;
+}
+
+export { type EventEmitter, type EventHandler, InMemoryEventEmitter, clear, emit, getEventEmitter, off, on, setEventEmitter };

package/dist/events/index.js

@@ -0,0 +1,77 @@
+// src/events/adapters/memory.ts
+var InMemoryEventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    this.listeners.get(event).push(handler);
+  }
+  async emit(event, data) {
+    const handlers = this.listeners.get(event) || [];
+    if (handlers.length === 0) {
+      return;
+    }
+    const results = await Promise.allSettled(
+      handlers.map(async (handler) => {
+        try {
+          return await handler(data);
+        } catch (error) {
+          throw error;
+        }
+      })
+    );
+    const failed = results.filter((r) => r.status === "rejected");
+    if (failed.length > 0) {
+      console.error(
+        `[Events] ${failed.length}/${handlers.length} handlers failed for event "${event}"`,
+        {
+          errors: failed.map((r) => r.reason)
+        }
+      );
+    }
+  }
+  off(event) {
+    this.listeners.delete(event);
+  }
+  clear() {
+    this.listeners.clear();
+  }
+  /**
+   * Get list of registered events (for debugging)
+   */
+  getEvents() {
+    return Array.from(this.listeners.keys());
+  }
+  /**
+   * Get number of handlers for an event (for debugging)
+   */
+  getHandlerCount(event) {
+    return this.listeners.get(event)?.length || 0;
+  }
+};
+
+// src/events/emitter.ts
+var emitter = new InMemoryEventEmitter();
+function setEventEmitter(adapter) {
+  emitter = adapter;
+}
+function getEventEmitter() {
+  return emitter;
+}
+function on(event, handler) {
+  emitter.on(event, handler);
+}
+async function emit(event, data) {
+  await emitter.emit(event, data);
+}
+function off(event) {
+  emitter.off(event);
+}
+function clear() {
+  emitter.clear();
+}
+
+export { InMemoryEventEmitter, clear, emit, getEventEmitter, off, on, setEventEmitter };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/events/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/events/adapters/memory.ts","../../src/events/emitter.ts"],"names":[],"mappings":";AAsBO,IAAM,uBAAN,MACP;AAAA,EACY,SAAA,uBAAgB,GAAA,EAA4B;AAAA,EAEpD,EAAA,CAAG,OAAe,OAAA,EAClB;AACI,IAAA,IAAI,CAAC,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,KAAK,CAAA,EAC7B;AACI,MAAA,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,KAAA,EAAO,EAAE,CAAA;AAAA,IAChC;AACA,IAAA,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,KAAK,CAAA,CAAG,KAAK,OAAO,CAAA;AAAA,EAC3C;AAAA,EAEA,MAAM,IAAA,CAAK,KAAA,EAAe,IAAA,EAC1B;AACI,IAAA,MAAM,WAAW,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,KAAK,KAAK,EAAC;AAE/C,IAAA,IAAI,QAAA,CAAS,WAAW,CAAA,EACxB;AACI,MAAA;AAAA,IACJ;AAIA,IAAA,MAAM,OAAA,GAAU,MAAM,OAAA,CAAQ,UAAA;AAAA,MAC1B,QAAA,CAAS,GAAA,CAAI,OAAO,OAAA,KACpB;AACI,QAAA,IACA;AACI,UAAA,OAAO,MAAM,QAAQ,IAAI,CAAA;AAAA,QAC7B,SACO,KAAA,EACP;AAEI,UAAA,MAAM,KAAA;AAAA,QACV;AAAA,MACJ,CAAC;AAAA,KACL;AAGA,IAAA,MAAM,SAAS,OAAA,CAAQ,MAAA,CAAO,CAAA,CAAA,KAAK,CAAA,CAAE,WAAW,UAAU,CAAA;AAC1D,IAAA,IAAI,MAAA,CAAO,SAAS,CAAA,EACpB;AACI,MAAA,OAAA,CAAQ,KAAA;AAAA,QACJ,YAAY,MAAA,CAAO,MAAM,IAAI,QAAA,CAAS,MAAM,+BAA+B,KAAK,CAAA,CAAA,CAAA;AAAA,QAChF;AAAA,UACI,MAAA,EAAQ,MAAA,CAAO,GAAA,CAAI,CAAA,CAAA,KAAM,EAA4B,MAAM;AAAA;AAC/D,OACJ;AAAA,IACJ;AAAA,EACJ;AAAA,EAEA,IAAI,KAAA,EACJ;AACI,IAAA,IAAA,CAAK,SAAA,CAAU,OAAO,KAAK,CAAA;AAAA,EAC/B;AAAA,EAEA,KAAA,GACA;AACI,IAAA,IAAA,CAAK,UAAU,KAAA,EAAM;AAAA,EACzB;AAAA;AAAA;AAAA;AAAA,EAKA,SAAA,GACA;AACI,IAAA,OAAO,KAAA,CAAM,IAAA,CAAK,IAAA,CAAK,SAAA,CAAU,MAAM,CAAA;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA,EAKA,gBAAgB,KAAA,EAChB;AACI,IAAA,OAAO,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,KAAK,GAAG,MAAA,IAAU,CAAA;AAAA,EAChD;AACJ;;;AC7DA,IAAI,OAAA,GAAwB,IAAI,oBAAA,EAAqB;AAe9C,SAAS,gBAAgB,OAAA,EAChC;AACI,EAAA,OAAA,GAAU,OAAA;AACd;AAOO,SAAS,eAAA,GAChB;AACI,EAAA,OAAO,OAAA;AACX;AAeO,SAAS,EAAA,CAAG,OAAe,OAAA,EAClC;AACI,EAAA,OAAA,CAAQ,EAAA,CAAG,OAAO,OAAO,CAAA;AAC7B;AAgBA,eAAsB,IAAA,CAAK,OAAe,IAAA,EAC1C;AACI,EAAA,MAAM,OAAA,CAAQ,IAAA,CAAK,KAAA,EAAO,IAAI,CAAA;AAClC;AAYO,SAAS,IAAI,KAAA,EACpB;AACI,EAAA,OAAA,CAAQ,IAAI,KAAK,CAAA;AACrB;AAeO,SAAS,KAAA,GAChB;AACI,EAAA,OAAA,CAAQ,KAAA,EAAM;AAClB","file":"index.js","sourcesContent":["/**\n * In-Memory Event Emitter\n *\n * Simple in-process event emitter for single-instance deployments.\n * Events are not shared across multiple server instances.\n *\n * Use this adapter for:\n * - Development\n * - Single-instance production deployments\n * - When you don't need distributed events\n *\n * @example\n * ```typescript\n * import { setEventEmitter } from '@spfn/core/events';\n * import { InMemoryEventEmitter } from '@spfn/core/events/adapters';\n *\n * setEventEmitter(new InMemoryEventEmitter());\n * ```\n */\n\nimport type { EventEmitter, EventHandler } from '../types';\n\nexport class InMemoryEventEmitter implements EventEmitter\n{\n    private listeners = new Map<string, EventHandler[]>();\n\n    on(event: string, handler: EventHandler): void\n    {\n        if (!this.listeners.has(event))\n        {\n            this.listeners.set(event, []);\n        }\n        this.listeners.get(event)!.push(handler);\n    }\n\n    async emit(event: string, data?: any): Promise<void>\n    {\n        const handlers = this.listeners.get(event) || [];\n\n        if (handlers.length === 0)\n        {\n            return;\n        }\n\n        // Execute all handlers in parallel\n        // Failures in individual handlers don't affect others\n        const results = await Promise.allSettled(\n            handlers.map(async (handler) =>\n            {\n                try\n                {\n                    return await handler(data);\n                }\n                catch (error)\n                {\n                    // Catch and re-throw for Promise.allSettled\n                    throw error;\n                }\n            })\n        );\n\n        // Log failed handlers for debugging\n        const failed = results.filter(r => r.status === 'rejected');\n        if (failed.length > 0)\n        {\n            console.error(\n                `[Events] ${failed.length}/${handlers.length} handlers failed for event \"${event}\"`,\n                {\n                    errors: failed.map(r => (r as PromiseRejectedResult).reason),\n                }\n            );\n        }\n    }\n\n    off(event: string): void\n    {\n        this.listeners.delete(event);\n    }\n\n    clear(): void\n    {\n        this.listeners.clear();\n    }\n\n    /**\n     * Get list of registered events (for debugging)\n     */\n    getEvents(): string[]\n    {\n        return Array.from(this.listeners.keys());\n    }\n\n    /**\n     * Get number of handlers for an event (for debugging)\n     */\n    getHandlerCount(event: string): number\n    {\n        return this.listeners.get(event)?.length || 0;\n    }\n}","/**\n * Event Emitter\n *\n * Adapter-based event emitter for decoupled communication between packages.\n *\n * Default adapter: InMemoryEventEmitter (single-instance)\n *\n * @example\n * ```typescript\n * // Subscribe to events\n * import { on } from '@spfn/core/events';\n *\n * on('user:created', async (data) => {\n *   console.log('User created:', data.email);\n * });\n *\n * // Emit events\n * import { emit } from '@spfn/core/events';\n *\n * await emit('user:created', {\n *   userId: '123',\n *   email: 'user@example.com'\n * });\n *\n * // Switch to Redis adapter (multi-instance)\n * import { setEventEmitter } from '@spfn/core/events';\n * import { RedisEventEmitter } from '@spfn/core/events/adapters';\n *\n * setEventEmitter(new RedisEventEmitter({\n *   host: 'localhost',\n *   port: 6379\n * }));\n * ```\n */\n\nimport type { EventEmitter, EventHandler } from './types';\nimport { InMemoryEventEmitter } from './adapters/memory';\n\nlet emitter: EventEmitter = new InMemoryEventEmitter();\n\n/**\n * Set the event emitter adapter\n *\n * @param adapter - EventEmitter adapter implementation\n *\n * @example\n * ```typescript\n * import { setEventEmitter } from '@spfn/core/events';\n * import { InMemoryEventEmitter } from '@spfn/core/events/adapters';\n *\n * setEventEmitter(new InMemoryEventEmitter());\n * ```\n */\nexport function setEventEmitter(adapter: EventEmitter): void\n{\n    emitter = adapter;\n}\n\n/**\n * Get the current event emitter adapter\n *\n * @returns Current EventEmitter instance\n */\nexport function getEventEmitter(): EventEmitter\n{\n    return emitter;\n}\n\n/**\n * Subscribe to an event\n *\n * @param event - Event name\n * @param handler - Event handler function\n *\n * @example\n * ```typescript\n * on('user:created', async (data) => {\n *   console.log('User created:', data.email);\n * });\n * ```\n */\nexport function on(event: string, handler: EventHandler): void\n{\n    emitter.on(event, handler);\n}\n\n/**\n * Emit an event\n *\n * @param event - Event name\n * @param data - Event data\n *\n * @example\n * ```typescript\n * await emit('user:created', {\n *   userId: '123',\n *   email: 'user@example.com'\n * });\n * ```\n */\nexport async function emit(event: string, data?: any): Promise<void>\n{\n    await emitter.emit(event, data);\n}\n\n/**\n * Unsubscribe from an event\n *\n * @param event - Event name\n *\n * @example\n * ```typescript\n * off('user:created');\n * ```\n */\nexport function off(event: string): void\n{\n    emitter.off(event);\n}\n\n/**\n * Clear all event subscriptions\n *\n * Useful for testing or cleanup\n *\n * @example\n * ```typescript\n * // In tests\n * beforeEach(() => {\n *   clear();\n * });\n * ```\n */\nexport function clear(): void\n{\n    emitter.clear();\n}"]}

package/dist/index.js

@@ -3116,29 +3116,133 @@ function buildStartupConfig(config, timeouts) {
   };
 }
 
+// src/server/plugin-discovery.ts
+init_logger2();
+var pluginLogger = logger.child("plugin");
+async function discoverPlugins(cwd = process.cwd()) {
+  const plugins = [];
+  const nodeModulesPath = join(cwd, "node_modules");
+  try {
+    const projectPkgPath = join(cwd, "package.json");
+    if (!existsSync(projectPkgPath)) {
+      pluginLogger.debug("No package.json found, skipping plugin discovery");
+      return plugins;
+    }
+    const projectPkg = JSON.parse(readFileSync(projectPkgPath, "utf-8"));
+    const dependencies = {
+      ...projectPkg.dependencies,
+      ...projectPkg.devDependencies
+    };
+    for (const [packageName] of Object.entries(dependencies)) {
+      if (!packageName.startsWith("@spfn/")) {
+        continue;
+      }
+      try {
+        const plugin = await loadPluginFromPackage(packageName, nodeModulesPath);
+        if (plugin) {
+          plugins.push(plugin);
+          pluginLogger.info("Plugin discovered", {
+            name: plugin.name,
+            hooks: getPluginHookNames(plugin)
+          });
+        }
+      } catch (error) {
+        pluginLogger.debug("Failed to load plugin", {
+          package: packageName,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+    }
+  } catch (error) {
+    pluginLogger.warn("Plugin discovery failed", {
+      error: error instanceof Error ? error.message : "Unknown error"
+    });
+  }
+  return plugins;
+}
+async function loadPluginFromPackage(packageName, nodeModulesPath) {
+  const pkgPath = join(nodeModulesPath, ...packageName.split("/"), "package.json");
+  if (!existsSync(pkgPath)) {
+    return null;
+  }
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  const packageDir = dirname(pkgPath);
+  const mainEntry = pkg.main || "dist/index.js";
+  const mainPath = join(packageDir, mainEntry);
+  if (!existsSync(mainPath)) {
+    return null;
+  }
+  try {
+    const module = await import(mainPath);
+    if (module.spfnPlugin && isValidPlugin(module.spfnPlugin)) {
+      return module.spfnPlugin;
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+function isValidPlugin(plugin) {
+  return plugin && typeof plugin === "object" && typeof plugin.name === "string" && (typeof plugin.afterInfrastructure === "function" || typeof plugin.beforeRoutes === "function" || typeof plugin.afterRoutes === "function" || typeof plugin.afterStart === "function" || typeof plugin.beforeShutdown === "function");
+}
+function getPluginHookNames(plugin) {
+  const hooks = [];
+  if (plugin.afterInfrastructure) hooks.push("afterInfrastructure");
+  if (plugin.beforeRoutes) hooks.push("beforeRoutes");
+  if (plugin.afterRoutes) hooks.push("afterRoutes");
+  if (plugin.afterStart) hooks.push("afterStart");
+  if (plugin.beforeShutdown) hooks.push("beforeShutdown");
+  return hooks;
+}
+async function executePluginHooks(plugins, hookName, ...args) {
+  for (const plugin of plugins) {
+    const hook = plugin[hookName];
+    if (typeof hook === "function") {
+      try {
+        pluginLogger.debug("Executing plugin hook", {
+          plugin: plugin.name,
+          hook: hookName
+        });
+        await hook(...args);
+      } catch (error) {
+        pluginLogger.error("Plugin hook failed", {
+          plugin: plugin.name,
+          hook: hookName,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+        throw new Error(
+          `Plugin ${plugin.name} failed in ${hookName} hook: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+  }
+}
+
 // src/server/create-server.ts
 var serverLogger = logger.child("server");
-async function createServer(config) {
+async function createServer(config, plugins = []) {
   const cwd = process.cwd();
   const appPath = join(cwd, "src", "server", "app.ts");
   const appJsPath = join(cwd, "src", "server", "app.js");
   if (existsSync(appPath) || existsSync(appJsPath)) {
-    return await loadCustomApp(appPath, appJsPath, config);
+    return await loadCustomApp(appPath, appJsPath, config, plugins);
   }
-  return await createAutoConfiguredApp(config);
+  return await createAutoConfiguredApp(config, plugins);
 }
-async function loadCustomApp(appPath, appJsPath, config) {
+async function loadCustomApp(appPath, appJsPath, config, plugins = []) {
   const appModule = await (existsSync(appPath) ? import(appPath) : import(appJsPath));
   const appFactory = appModule.default;
   if (!appFactory) {
     throw new Error("app.ts must export a default function that returns a Hono app");
   }
   const app = await appFactory();
+  await executePluginHooks(plugins, "beforeRoutes", app);
   const debug = config?.debug ?? process.env.NODE_ENV === "development";
   await loadRoutes(app, { routesDir: config?.routesPath, debug });
+  await executePluginHooks(plugins, "afterRoutes", app);
   return app;
 }
-async function createAutoConfiguredApp(config) {
+async function createAutoConfiguredApp(config, plugins = []) {
   const app = new Hono();
   const middlewareConfig = config?.middleware ?? {};
   const enableLogger = middlewareConfig.logger !== false;
@@ -3154,8 +3258,10 @@ async function createAutoConfiguredApp(config) {
   config?.use?.forEach((mw) => app.use("*", mw));
   registerHealthCheckEndpoint(app, config);
   await executeBeforeRoutesHook(app, config);
+  await executePluginHooks(plugins, "beforeRoutes", app);
   await loadAppRoutes(app, config);
   await executeAfterRoutesHook(app, config);
+  await executePluginHooks(plugins, "afterRoutes", app);
   if (enableErrorHandler) {
     app.onError(ErrorHandler());
   }
@@ -3300,9 +3406,17 @@ async function startServer(config) {
   if (debug) {
     logMiddlewareOrder(finalConfig);
   }
+  serverLogger2.debug("Discovering plugins...");
+  const plugins = await discoverPlugins();
+  if (plugins.length > 0) {
+    serverLogger2.info("Plugins discovered", {
+      count: plugins.length,
+      plugins: plugins.map((p) => p.name)
+    });
+  }
   try {
-    await initializeInfrastructure(finalConfig);
-    const app = await createServer(finalConfig);
+    await initializeInfrastructure(finalConfig, plugins);
+    const app = await createServer(finalConfig, plugins);
     const server = startHttpServer(app, host, port);
     const timeouts = getTimeoutConfig(finalConfig.timeout);
     applyServerTimeouts(server, timeouts);
@@ -3313,7 +3427,7 @@ async function startServer(config) {
       port
     });
     logServerStarted(debug, host, port, finalConfig, timeouts);
-    const shutdownServer = createShutdownHandler(server, finalConfig);
+    const shutdownServer = createShutdownHandler(server, finalConfig, plugins);
     const shutdown = createGracefulShutdown(shutdownServer, finalConfig);
     registerShutdownHandlers(shutdown);
     const serverInstance = {
@@ -3333,6 +3447,7 @@ async function startServer(config) {
         serverLogger2.error("afterStart hook failed", error);
       }
     }
+    await executePluginHooks(plugins, "afterStart", serverInstance);
     return serverInstance;
   } catch (error) {
     const err = error;
@@ -3374,7 +3489,7 @@ function logMiddlewareOrder(config) {
     order: middlewareOrder
   });
 }
-async function initializeInfrastructure(config) {
+async function initializeInfrastructure(config, plugins) {
   if (config.lifecycle?.beforeInfrastructure) {
     serverLogger2.debug("Executing beforeInfrastructure hook...");
     try {
@@ -3407,14 +3522,16 @@ async function initializeInfrastructure(config) {
       throw new Error("Server initialization failed in afterInfrastructure hook");
     }
   }
+  await executePluginHooks(plugins, "afterInfrastructure");
 }
 function startHttpServer(app, host, port) {
   serverLogger2.debug(`Starting server on ${host}:${port}...`);
-  return serve({
+  const server = serve({
     fetch: app.fetch,
     port,
     hostname: host
   });
+  return server;
 }
 function logServerTimeouts(timeouts) {
   serverLogger2.info("Server timeouts configured", {
@@ -3432,7 +3549,7 @@ function logServerStarted(debug, host, port, config, timeouts) {
     config: startupConfig
   });
 }
-function createShutdownHandler(server, config) {
+function createShutdownHandler(server, config, plugins) {
   return async () => {
     serverLogger2.debug("Closing HTTP server...");
     await new Promise((resolve) => {
@@ -3449,6 +3566,11 @@ function createShutdownHandler(server, config) {
         serverLogger2.error("beforeShutdown hook failed", error);
       }
     }
+    try {
+      await executePluginHooks(plugins, "beforeShutdown");
+    } catch (error) {
+      serverLogger2.error("Plugin beforeShutdown hooks failed", error);
+    }
     const shouldCloseDatabase = config.infrastructure?.database !== false;
     const shouldCloseRedis = config.infrastructure?.redis !== false;
     if (shouldCloseDatabase) {
@@ -3494,15 +3616,28 @@ function registerShutdownHandlers(shutdown) {
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGINT", () => shutdown("SIGINT"));
   process.on("uncaughtException", (error) => {
-    serverLogger2.error("Uncaught exception", error);
-    shutdown("UNCAUGHT_EXCEPTION");
+    if (error.message?.includes("EADDRINUSE")) {
+      serverLogger2.error("Port conflict detected - detailed trace:", {
+        error: error.message,
+        stack: error.stack,
+        code: error.code,
+        port: error.port,
+        address: error.address,
+        syscall: error.syscall
+      });
+    } else {
+      serverLogger2.error("Uncaught exception", error);
+    }
+    serverLogger2.info("Exiting immediately for clean restart");
+    process.exit(1);
   });
   process.on("unhandledRejection", (reason, promise) => {
     serverLogger2.error("Unhandled promise rejection", {
       reason,
       promise
     });
-    shutdown("UNHANDLED_REJECTION");
+    serverLogger2.info("Exiting immediately for clean restart");
+    process.exit(1);
   });
 }
 async function cleanupOnFailure(config) {