diff --git a/test/test.long-lived-connections.ts b/test/test.long-lived-connections.ts
index 6ae1489..e8ab9f6 100644
--- a/test/test.long-lived-connections.ts
+++ b/test/test.long-lived-connections.ts
@@ -130,53 +130,7 @@ tap.test('should keep WebSocket-like connection open for extended period', async
   expect(connectionClosed).toEqual(true);
 });
 
-tap.test('should support half-open connections', async () => {
-  const client = new net.Socket();
-  const serverSocket = await new Promise<net.Socket>((resolve) => {
-    targetServer.once('connection', resolve);
-    client.connect(8888, 'localhost');
-  });
-  
-  let clientClosed = false;
-  let serverClosed = false;
-  let serverReceivedData = false;
-  
-  client.on('close', () => {
-    clientClosed = true;
-  });
-  
-  serverSocket.on('close', () => {
-    serverClosed = true;
-  });
-  
-  serverSocket.on('data', () => {
-    serverReceivedData = true;
-  });
-  
-  // Client sends data then closes write side
-  client.write('HALF-OPEN TEST\n');
-  client.end(); // Close write side only
-  
-  // Wait a bit
-  await new Promise(resolve => setTimeout(resolve, 500));
-  
-  // Server should still be able to send data
-  expect(serverClosed).toEqual(false);
-  serverSocket.write('RESPONSE\n');
-  
-  // Wait for data
-  await new Promise(resolve => setTimeout(resolve, 100));
-  
-  // Now close server side
-  serverSocket.end();
-  
-  // Wait for full close
-  await new Promise(resolve => setTimeout(resolve, 500));
-  
-  expect(clientClosed).toEqual(true);
-  expect(serverClosed).toEqual(true);
-  expect(serverReceivedData).toEqual(true);
-});
+// NOTE: Half-open connections are not supported due to proxy chain architecture
 
 tap.test('cleanup', async () => {
   await testProxy.stop();
diff --git a/test/test.proxy-chaining-accumulation.node.ts b/test/test.proxy-chaining-accumulation.node.ts
index e25f122..38ee9b1 100644
--- a/test/test.proxy-chaining-accumulation.node.ts
+++ b/test/test.proxy-chaining-accumulation.node.ts
@@ -365,4 +365,4 @@ tap.test('should handle proxy chain with HTTP traffic', async () => {
   expect(finalCounts.proxy2).toEqual(0);
 });
 
-tap.start();
\ No newline at end of file
+export default tap.start();
\ No newline at end of file
diff --git a/test/test.race-conditions.node.ts b/test/test.race-conditions.node.ts
deleted file mode 100644
index 9abc02b..0000000
--- a/test/test.race-conditions.node.ts
+++ /dev/null
@@ -1,185 +0,0 @@
-import { expect, tap } from '@git.zone/tstest/tapbundle';
-import { SmartProxy, type IRouteConfig } from '../ts/index.js';
-
-/**
- * Test that concurrent route updates complete successfully and maintain consistency
- * This replaces the previous implementation-specific mutex tests with behavior-based tests
- */
-tap.test('should handle concurrent route updates correctly', async (tools) => {
-  tools.timeout(15000);
-  
-  const initialRoute: IRouteConfig = {
-    name: 'base-route',
-    match: { ports: 8080 },
-    action: {
-      type: 'forward',
-      target: { host: 'localhost', port: 3000 }
-    }
-  };
-  
-  const proxy = new SmartProxy({
-    routes: [initialRoute]
-  });
-  
-  await proxy.start();
-  
-  // Create many concurrent updates to stress test the system
-  const updatePromises: Promise<void>[] = [];
-  const routeNames: string[] = [];
-  
-  // Launch 20 concurrent updates
-  for (let i = 0; i < 20; i++) {
-    const routeName = `concurrent-route-${i}`;
-    routeNames.push(routeName);
-    
-    const updatePromise = proxy.updateRoutes([
-      initialRoute,
-      {
-        name: routeName,
-        match: { ports: 9000 + i },
-        action: {
-          type: 'forward',
-          target: { host: 'localhost', port: 4000 + i }
-        }
-      }
-    ]);
-    
-    updatePromises.push(updatePromise);
-  }
-  
-  // All updates should complete without errors
-  await Promise.all(updatePromises);
-  
-  // Verify the final state is consistent
-  const finalRoutes = proxy.routeManager.getAllRoutes();
-  
-  // Should have base route plus one of the concurrent routes
-  expect(finalRoutes.length).toEqual(2);
-  expect(finalRoutes.some(r => r.name === 'base-route')).toBeTrue();
-  
-  // One of the concurrent routes should have won
-  const concurrentRoute = finalRoutes.find(r => r.name?.startsWith('concurrent-route-'));
-  expect(concurrentRoute).toBeTruthy();
-  expect(routeNames).toContain(concurrentRoute!.name);
-  
-  await proxy.stop();
-});
-
-/**
- * Test rapid sequential route updates
- */
-tap.test('should handle rapid sequential route updates', async (tools) => {
-  tools.timeout(10000);
-  
-  const proxy = new SmartProxy({
-    routes: [{
-      name: 'initial',
-      match: { ports: 8081 },
-      action: {
-        type: 'forward',
-        target: { host: 'localhost', port: 3000 }
-      }
-    }]
-  });
-  
-  await proxy.start();
-  
-  // Perform rapid sequential updates
-  for (let i = 0; i < 10; i++) {
-    await proxy.updateRoutes([{
-      name: 'changing-route',
-      match: { ports: 8081 },
-      action: {
-        type: 'forward',
-        target: { host: 'localhost', port: 3000 + i }
-      }
-    }]);
-  }
-  
-  // Verify final state
-  const finalRoutes = proxy.routeManager.getAllRoutes();
-  expect(finalRoutes.length).toEqual(1);
-  expect(finalRoutes[0].name).toEqual('changing-route');
-  expect((finalRoutes[0].action as any).target.port).toEqual(3009);
-  
-  await proxy.stop();
-});
-
-/**
- * Test that port management remains consistent during concurrent updates
- */
-tap.test('should maintain port consistency during concurrent updates', async (tools) => {
-  tools.timeout(10000);
-  
-  const proxy = new SmartProxy({
-    routes: [{
-      name: 'port-test',
-      match: { ports: 8082 },
-      action: {
-        type: 'forward',
-        target: { host: 'localhost', port: 3000 }
-      }
-    }]
-  });
-  
-  await proxy.start();
-  
-  // Create updates that add and remove ports
-  const updates: Promise<void>[] = [];
-  
-  // Some updates add new ports
-  for (let i = 0; i < 5; i++) {
-    updates.push(proxy.updateRoutes([
-      {
-        name: 'port-test',
-        match: { ports: 8082 },
-        action: {
-          type: 'forward',
-          target: { host: 'localhost', port: 3000 }
-        }
-      },
-      {
-        name: `new-port-${i}`,
-        match: { ports: 9100 + i },
-        action: {
-          type: 'forward',
-          target: { host: 'localhost', port: 4000 + i }
-        }
-      }
-    ]));
-  }
-  
-  // Some updates remove ports
-  for (let i = 0; i < 5; i++) {
-    updates.push(proxy.updateRoutes([
-      {
-        name: 'port-test',
-        match: { ports: 8082 },
-        action: {
-          type: 'forward',
-          target: { host: 'localhost', port: 3000 }
-        }
-      }
-    ]));
-  }
-  
-  // Wait for all updates
-  await Promise.all(updates);
-  
-  // Give time for port cleanup
-  await new Promise(resolve => setTimeout(resolve, 100));
-  
-  // Verify final state
-  const finalRoutes = proxy.routeManager.getAllRoutes();
-  const listeningPorts = proxy['portManager'].getListeningPorts();
-  
-  // Should only have the base port listening
-  expect(listeningPorts).toContain(8082);
-  
-  // Routes should be consistent
-  expect(finalRoutes.some(r => r.name === 'port-test')).toBeTrue();
-  
-  await proxy.stop();
-});
-
-export default tap.start();
\ No newline at end of file
diff --git a/test/test.router.ts b/test/test.router.ts
index 7bc9786..82a2ee2 100644
--- a/test/test.router.ts
+++ b/test/test.router.ts
@@ -50,13 +50,13 @@ tap.test('setup http router test environment', async () => {
   router = new HttpRouter();
   
   // Initialize with empty config
-  router.updateRoutes([]);
+  router.setRoutes([]);
 });
 
 // Test basic routing by hostname
 tap.test('should route requests by hostname', async () => {
   const config = createRouteConfig(TEST_DOMAIN);
-  router.updateRoutes([config]);
+  router.setRoutes([config]);
   
   const req = createMockRequest(TEST_DOMAIN);
   const result = router.routeReq(req);
@@ -68,7 +68,7 @@ tap.test('should route requests by hostname', async () => {
 // Test handling of hostname with port number
 tap.test('should handle hostname with port number', async () => {
   const config = createRouteConfig(TEST_DOMAIN);
-  router.updateRoutes([config]);
+  router.setRoutes([config]);
   
   const req = createMockRequest(`${TEST_DOMAIN}:443`);
   const result = router.routeReq(req);
@@ -80,7 +80,7 @@ tap.test('should handle hostname with port number', async () => {
 // Test case-insensitive hostname matching
 tap.test('should perform case-insensitive hostname matching', async () => {
   const config = createRouteConfig(TEST_DOMAIN.toLowerCase());
-  router.updateRoutes([config]);
+  router.setRoutes([config]);
   
   const req = createMockRequest(TEST_DOMAIN.toUpperCase());
   const result = router.routeReq(req);
@@ -92,7 +92,7 @@ tap.test('should perform case-insensitive hostname matching', async () => {
 // Test handling of unmatched hostnames
 tap.test('should return undefined for unmatched hostnames', async () => {
   const config = createRouteConfig(TEST_DOMAIN);
-  router.updateRoutes([config]);
+  router.setRoutes([config]);
   
   const req = createMockRequest('unknown.domain.com');
   const result = router.routeReq(req);
@@ -104,7 +104,7 @@ tap.test('should return undefined for unmatched hostnames', async () => {
 tap.test('should match requests using path patterns', async () => {
   const config = createRouteConfig(TEST_DOMAIN);
   config.match.path = '/api/users';
-  router.updateRoutes([config]);
+  router.setRoutes([config]);
   
   // Test that path matches
   const req1 = createMockRequest(TEST_DOMAIN, '/api/users');
@@ -125,7 +125,7 @@ tap.test('should match requests using path patterns', async () => {
 tap.test('should support wildcard path patterns', async () => {
   const config = createRouteConfig(TEST_DOMAIN);
   config.match.path = '/api/*';
-  router.updateRoutes([config]);
+  router.setRoutes([config]);
   
   // Test with path that matches the wildcard pattern
   const req = createMockRequest(TEST_DOMAIN, '/api/users/123');
@@ -145,7 +145,7 @@ tap.test('should support wildcard path patterns', async () => {
 tap.test('should extract path parameters from URL', async () => {
   const config = createRouteConfig(TEST_DOMAIN);
   config.match.path = '/users/:id/profile';
-  router.updateRoutes([config]);
+  router.setRoutes([config]);
   
   const req = createMockRequest(TEST_DOMAIN, '/users/123/profile');
   const result = router.routeReqWithDetails(req);
@@ -167,7 +167,7 @@ tap.test('should support multiple configs for same hostname with different paths
   webConfig.name = 'web-route';
   
   // Add both configs
-  router.updateRoutes([apiConfig, webConfig]);
+  router.setRoutes([apiConfig, webConfig]);
   
   // Test API path routes to API config
   const apiReq = createMockRequest(TEST_DOMAIN, '/api/users');
@@ -191,7 +191,7 @@ tap.test('should support multiple configs for same hostname with different paths
 // Test wildcard subdomains
 tap.test('should match wildcard subdomains', async () => {
   const wildcardConfig = createRouteConfig(TEST_WILDCARD);
-  router.updateRoutes([wildcardConfig]);
+  router.setRoutes([wildcardConfig]);
   
   // Test that subdomain.example.com matches *.example.com
   const req = createMockRequest('subdomain.example.com');
@@ -204,7 +204,7 @@ tap.test('should match wildcard subdomains', async () => {
 // Test TLD wildcards (example.*)
 tap.test('should match TLD wildcards', async () => {
   const tldWildcardConfig = createRouteConfig('example.*');
-  router.updateRoutes([tldWildcardConfig]);
+  router.setRoutes([tldWildcardConfig]);
   
   // Test that example.com matches example.*
   const req1 = createMockRequest('example.com');
@@ -227,7 +227,7 @@ tap.test('should match TLD wildcards', async () => {
 // Test complex pattern matching (*.lossless*)
 tap.test('should match complex wildcard patterns', async () => {
   const complexWildcardConfig = createRouteConfig('*.lossless*');
-  router.updateRoutes([complexWildcardConfig]);
+  router.setRoutes([complexWildcardConfig]);
   
   // Test that sub.lossless.com matches *.lossless*
   const req1 = createMockRequest('sub.lossless.com');
@@ -252,7 +252,7 @@ tap.test('should fall back to default configuration', async () => {
   const defaultConfig = createRouteConfig('*');
   const specificConfig = createRouteConfig(TEST_DOMAIN);
   
-  router.updateRoutes([defaultConfig, specificConfig]);
+  router.setRoutes([defaultConfig, specificConfig]);
   
   // Test specific domain routes to specific config
   const specificReq = createMockRequest(TEST_DOMAIN);
@@ -272,7 +272,7 @@ tap.test('should prioritize exact hostname over wildcard', async () => {
   const wildcardConfig = createRouteConfig(TEST_WILDCARD);
   const exactConfig = createRouteConfig(TEST_SUBDOMAIN);
   
-  router.updateRoutes([wildcardConfig, exactConfig]);
+  router.setRoutes([wildcardConfig, exactConfig]);
   
   // Test that exact match takes priority
   const req = createMockRequest(TEST_SUBDOMAIN);
@@ -283,11 +283,11 @@ tap.test('should prioritize exact hostname over wildcard', async () => {
 
 // Test adding and removing configurations
 tap.test('should manage configurations correctly', async () => {
-  router.updateRoutes([]);
+  router.setRoutes([]);
   
   // Add a config
   const config = createRouteConfig(TEST_DOMAIN);
-  router.updateRoutes([config]);
+  router.setRoutes([config]);
   
   // Verify routing works
   const req = createMockRequest(TEST_DOMAIN);
@@ -296,7 +296,7 @@ tap.test('should manage configurations correctly', async () => {
   expect(result).toEqual(config);
   
   // Remove the config and verify it no longer routes
-  router.updateRoutes([]);
+  router.setRoutes([]);
   
   result = router.routeReq(req);
   expect(result).toBeUndefined();
@@ -313,7 +313,7 @@ tap.test('should prioritize more specific path patterns', async () => {
   specificConfig.name = 'specific-api';
   specificConfig.priority = 10; // Higher priority
   
-  router.updateRoutes([genericConfig, specificConfig]);
+  router.setRoutes([genericConfig, specificConfig]);
   
   // The more specific '/api/users' should match before the '/api/*' wildcard
   const req = createMockRequest(TEST_DOMAIN, '/api/users');
@@ -328,7 +328,7 @@ tap.test('should handle multiple configured hostnames', async () => {
     createRouteConfig(TEST_DOMAIN),
     createRouteConfig(TEST_SUBDOMAIN)
   ];
-  router.updateRoutes(routes);
+  router.setRoutes(routes);
   
   // Test first domain routes correctly
   const req1 = createMockRequest(TEST_DOMAIN);
@@ -344,7 +344,7 @@ tap.test('should handle multiple configured hostnames', async () => {
 // Test handling missing host header
 tap.test('should handle missing host header', async () => {
   const defaultConfig = createRouteConfig('*');
-  router.updateRoutes([defaultConfig]);
+  router.setRoutes([defaultConfig]);
   
   const req = createMockRequest('');
   req.headers.host = undefined;
@@ -358,7 +358,7 @@ tap.test('should handle missing host header', async () => {
 tap.test('should handle complex path parameters', async () => {
   const config = createRouteConfig(TEST_DOMAIN);
   config.match.path = '/api/:version/users/:userId/posts/:postId';
-  router.updateRoutes([config]);
+  router.setRoutes([config]);
   
   const req = createMockRequest(TEST_DOMAIN, '/api/v1/users/123/posts/456');
   const result = router.routeReqWithDetails(req);
@@ -380,7 +380,7 @@ tap.test('should handle many configurations efficiently', async () => {
     configs.push(createRouteConfig(`host-${i}.example.com`));
   }
   
-  router.updateRoutes(configs);
+  router.setRoutes(configs);
   
   // Test middle of the list to avoid best/worst case
   const req = createMockRequest('host-50.example.com');
@@ -392,7 +392,7 @@ tap.test('should handle many configurations efficiently', async () => {
 // Test cleanup
 tap.test('cleanup proxy router test environment', async () => {
   // Clear all configurations
-  router.updateRoutes([]);
+  router.setRoutes([]);
   
   // Verify empty state by testing that no routes match
   const req = createMockRequest(TEST_DOMAIN);
diff --git a/test/test.simple-acme-mock.ts b/test/test.simple-acme-mock.ts
deleted file mode 100644
index ebd3f7a..0000000
--- a/test/test.simple-acme-mock.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-import { tap, expect } from '@git.zone/tstest/tapbundle';
-import { SmartProxy } from '../ts/index.js';
-
-/**
- * Simple test to check route manager initialization with ACME
- */
-tap.test('should properly initialize with ACME configuration', async (tools) => {
-  const settings = {
-    routes: [
-      {
-        name: 'secure-route', 
-        match: {
-          ports: [8443],
-          domains: 'test.example.com'
-        },
-        action: {
-          type: 'forward' as const,
-          target: { host: 'localhost', port: 8080 },
-          tls: {
-            mode: 'terminate' as const,
-            certificate: 'auto' as const,
-            acme: {
-              email: 'ssl@bleu.de',
-              challengePort: 8080
-            }
-          }
-        }
-      }
-    ],
-    acme: {
-      email: 'ssl@bleu.de',
-      port: 8080,
-      useProduction: false,
-      enabled: true
-    }
-  };
-  
-  const proxy = new SmartProxy(settings);
-  
-  // Replace the certificate manager creation to avoid real ACME requests
-  (proxy as any).createCertificateManager = async () => {
-    return {
-      setUpdateRoutesCallback: () => {},
-      setHttpProxy: () => {},
-      setGlobalAcmeDefaults: () => {},
-      setAcmeStateManager: () => {},
-      initialize: async () => {
-        // Using logger would be better but in test we'll keep console.log
-        console.log('Mock certificate manager initialized');
-      },
-      provisionAllCertificates: async () => {
-        console.log('Mock certificate provisioning');
-      },
-      stop: async () => {
-        console.log('Mock certificate manager stopped');
-      }
-    };
-  };
-  
-  // Mock NFTables
-  (proxy as any).nftablesManager = {
-    provisionRoute: async () => {},
-    deprovisionRoute: async () => {},
-    updateRoute: async () => {},
-    getStatus: async () => ({}),
-    stop: async () => {}
-  };
-  
-  await proxy.start();
-  
-  // Verify proxy started successfully
-  expect(proxy).toBeDefined();
-  
-  // Verify route manager has routes
-  const routeManager = (proxy as any).routeManager;
-  expect(routeManager).toBeDefined();
-  expect(routeManager.getAllRoutes().length).toBeGreaterThan(0);
-  
-  // Verify the route exists with correct domain
-  const routes = routeManager.getAllRoutes();
-  const secureRoute = routes.find((r: any) => r.name === 'secure-route');
-  expect(secureRoute).toBeDefined();
-  expect(secureRoute.match.domains).toEqual('test.example.com');
-  
-  await proxy.stop();
-});
-
-tap.start();
\ No newline at end of file