v6.0.0

- Removed legacy servertools and Express dependencies in favor of SmartServe.
- Introduced DevToolsHandler and TypedRequestHandler for handling specific routes.
- Added support for custom route registration with regex parsing.
- Implemented sitemap and feed handling with dedicated helper classes.
- Enhanced HTML response handling with reload script injection.
- Updated UtilityServiceServer and UtilityWebsiteServer to utilize new TypedServer API.
- Removed deprecated compression options and Express-based route handling.
- Added comprehensive request handling for various endpoints including robots.txt, manifest.json, and sitemap.
- Improved error handling and response formatting across the server.

changelog.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 2025-12-03 - 6.0.0 - BREAKING CHANGE(servertools.Server.addTypedSocket)
+Deprecate Server.addTypedSocket and upgrade typedsocket to v4; make addTypedSocket a no-op and log a deprecation warning. Bump tsbundle devDependency.
+
+- Upgrade dependency @api.global/typedsocket to ^4.0.0. TypedSocket v4 no longer supports attaching to an existing Express server.
+- Deprecate servertools.Server.addTypedSocket(): the method is now a no-op and emits a console.warn directing users to use TypedServer with SmartServe integration for WebSocket support.
+- Bump devDependency @git.zone/tsbundle to ^2.6.3.
+- Breaking change: any consumer code that relied on addTypedSocket to attach a WebSocket server to an existing Express instance will need to migrate to the new SmartServe/TypedServer integration.
+
+## 2025-12-02 - 5.0.0 - BREAKING CHANGE(devtools)
+Switch /reloadcheck endpoint from GET to POST in DevToolsController
+
+- Updated ts/controllers/controller.devtools.ts: decorator changed from @plugins.smartserve.Get('/reloadcheck') to @plugins.smartserve.Post('/reloadcheck').
+- Clients that previously performed GET requests against /reloadcheck must be updated to use POST. This is a breaking API change.
+- Bump major version to reflect the change in the public HTTP API.
+
+## 2025-12-02 - 4.1.1 - fix(classes.typedserver)
+Instantiate and register DevToolsController only when injectReload is enabled; compile ControllerRegistry routes after registration
+
+- DevToolsController is now created and registered only if options.injectReload is true to avoid unnecessary/invalid registrations when live reload is disabled.
+- ControllerRegistry.compileRoutes() is invoked after registering controllers to precompile decorated routes for faster route matching.
+
+## 2025-12-02 - 4.1.0 - feat(TypedServer)
+Integrate SmartServe controller routing; add built-in routes controller and refactor TypedServer to use controllers and FileServer
+
+- Add BuiltInRoutesController exposing /robots.txt, /manifest.json, /sitemap, /sitemap-news, /feed and /appversion
+- Refactor TypedRequestHandler into a SmartServe-decorated TypedRequestController and register it with ControllerRegistry
+- Refactor TypedServer to use SmartServe: register controller instances, use ControllerRegistry matching, and delegate WebSocket integration to SmartServe
+- Introduce FileServer-based static serving with HTML reload script injection and improved default root handling
+- Expand supported HTTP methods to include HEAD and OPTIONS
+- Remove legacy FeedHelper and consolidate sitemap/feed handling into controllers and helpers
+- Enhance servertools legacy Express utilities: improved HandlerProxy, HandlerStatic, Compressor with caching and preferred compression support
+- Service worker subsystem improvements: CacheManager, NetworkManager, UpdateManager and backend enhancements for robust caching, revalidation and client reloads
+- Web-inject LitElement properties switched from private fields to accessor syntax (typedserver_web.infoscreen)
+
 ## 2025-12-02 - 4.0.0 - BREAKING CHANGE(typedserver)
 Migrate to new push.rocks packages and async smartfs API; replace smartchok with smartwatch; update deps and service worker handling
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@api.global/typedserver",
-  "version": "4.0.0",
+  "version": "6.0.0",
   "description": "A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.",
   "type": "module",
   "exports": {
@@ -60,7 +60,7 @@
   "dependencies": {
     "@api.global/typedrequest": "^3.1.10",
     "@api.global/typedrequest-interfaces": "^3.0.19",
-    "@api.global/typedsocket": "^3.0.1",
+    "@api.global/typedsocket": "^4.0.0",
     "@cloudflare/workers-types": "^4.20251202.0",
     "@design.estate/dees-comms": "^1.0.27",
     "@push.rocks/lik": "^6.2.2",
@@ -82,6 +82,7 @@
     "@push.rocks/smartpromise": "^4.2.3",
     "@push.rocks/smartrequest": "^5.0.1",
     "@push.rocks/smartrx": "^3.0.10",
+    "@push.rocks/smartserve": "^1.1.0",
     "@push.rocks/smartsitemap": "^2.0.4",
     "@push.rocks/smartstream": "^3.2.5",
     "@push.rocks/smarttime": "^4.1.1",
@@ -99,7 +100,7 @@
   },
   "devDependencies": {
     "@git.zone/tsbuild": "^3.1.2",
-    "@git.zone/tsbundle": "^2.6.2",
+    "@git.zone/tsbundle": "^2.6.3",
     "@git.zone/tsrun": "^2.0.0",
     "@git.zone/tstest": "^3.1.3",
     "@types/node": "^24.10.1"

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@api.global/typedserver',
-  version: '4.0.0',
+  version: '6.0.0',
   description: 'A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.'
 }

ts/classes.typedserver.ts

@@ -1,8 +1,9 @@
 import * as plugins from './plugins.js';
 import * as paths from './paths.js';
 import * as interfaces from '../dist_ts_interfaces/index.js';
-import * as servertools from './servertools/index.js';
-import { type TCompressionMethod } from './servertools/classes.compressor.js';
+import { DevToolsController } from './controllers/controller.devtools.js';
+import { TypedRequestController } from './controllers/controller.typedrequest.js';
+import { BuiltInRoutesController } from './controllers/controller.builtin.js';
 
 export interface IServerOptions {
   /**
@@ -15,16 +16,6 @@ export interface IServerOptions {
    */
   injectReload?: boolean;
 
-  /**
-   * enable compression
-   */
-  enableCompression?: boolean;
-
-  /**
-   * choose a preferred compression method
-   */
-  preferredCompressionMethod?: TCompressionMethod;
-
   /**
    * watch the serve directory?
    */
@@ -34,7 +25,6 @@ export interface IServerOptions {
 
   /**
    * a default answer given in case there is no other handler.
-   * @returns
    */
   defaultAnswer?: () => Promise<string>;
 
@@ -42,13 +32,14 @@ export interface IServerOptions {
    * will try to reroute traffic to an ssl connection using headers
    */
   forceSsl?: boolean;
+
   /**
    * allows serving manifests
    */
   manifest?: plugins.smartmanifest.ISmartManifestConstructorOptions;
+
   /**
    * the port to listen on
-   * can be overwritten when actually starting the server
    */
   port?: number | string;
   publicKey?: string;
@@ -57,6 +48,7 @@ export interface IServerOptions {
   feed?: boolean;
   robots?: boolean;
   domain?: string;
+
   /**
    * convey information about the app being served
    */
@@ -66,22 +58,48 @@ export interface IServerOptions {
   blockWaybackMachine?: boolean;
 }
 
-export class TypedServer {
-  // static
-  // nothing here yet
+export type THttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'ALL';
 
+export interface IRouteHandler {
+  (request: Request): Promise<Response | null>;
+}
+
+export interface IRegisteredRoute {
+  pattern: string;
+  regex: RegExp;
+  paramNames: string[];
+  method: THttpMethod;
+  handler: IRouteHandler;
+}
+
+export class TypedServer {
   // instance
   public options: IServerOptions;
-  public server: servertools.Server;
+  public smartServe: plugins.smartserve.SmartServe;
   public smartwatchInstance: plugins.smartwatch.Smartwatch;
   public serveDirHashSubject = new plugins.smartrx.rxjs.ReplaySubject<string>(1);
   public serveHash: string = '000000';
   public typedsocket: plugins.typedsocket.TypedSocket;
   public typedrouter = new plugins.typedrequest.TypedRouter();
 
+  // Sitemap helper
+  private sitemapHelper: SitemapHelper;
+  private smartmanifestInstance: plugins.smartmanifest.SmartManifest;
+
+  // Decorated controllers
+  private devToolsController: DevToolsController;
+  private typedRequestController: TypedRequestController;
+  private builtInRoutesController: BuiltInRoutesController;
+
+  // File server for static files
+  private fileServer: plugins.smartserve.FileServer;
+
+  // Custom route handlers (for addRoute API)
+  private customRoutes: IRegisteredRoute[] = [];
+
   public lastReload: number = Date.now();
   public ended = false;
-  
+
   constructor(optionsArg: IServerOptions) {
     const standardOptions: IServerOptions = {
       port: 3000,
@@ -94,44 +112,64 @@ export class TypedServer {
       ...standardOptions,
       ...optionsArg,
     };
+  }
 
-    this.server = new servertools.Server(this.options);
-    // add routes to the smartexpress instance
-    this.server.addRoute(
-      '/typedserver/:request',
-      new servertools.Handler('ALL', async (req, res) => {
-        switch (req.params.request) {
-          case 'devtools':
-            res.setHeader('Content-Type', 'text/javascript');
-            res.status(200);
-            const devtoolsContent = await plugins.fsInstance.file(paths.injectBundlePath).encoding('utf8').read();
-            res.write(devtoolsContent);
-            res.end();
-            break;
-          case 'reloadcheck':
-            console.log('got request for reloadcheck');
-            res.setHeader('Content-Type', 'text/plain');
-            res.status(200);
-            if (this.ended) {
-              res.write('end');
-              res.end();
-              return;
-            }
-            res.write(this.lastReload.toString());
-            res.end();
-            break;
-          default:
-            res.status(404);
-            res.write('Unknown request type');
-            res.end();
-            break;
-        }
+  /**
+   * Access sitemap URLs (for adding/replacing)
+   */
+  public get sitemap() {
+    return this.sitemapHelper;
+  }
+
+  /**
+   * Add a custom route handler
+   * Supports Express-style path patterns like '/path/:param' and '/path/*splat'
+   * @param path - The route path pattern
+   * @param method - HTTP method (GET, POST, PUT, DELETE, PATCH, ALL)
+   * @param handler - Async function that receives Request and returns Response or null
+   */
+  public addRoute(path: string, method: THttpMethod, handler: IRouteHandler): void {
+    // Convert Express-style path to regex
+    const paramNames: string[] = [];
+    let regexPattern = path
+      // Handle named parameters :param
+      .replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, paramName) => {
+        paramNames.push(paramName);
+        return '([^/]+)';
       })
-    );
-    this.server.addRoute(
-      '/typedrequest',
-      new servertools.HandlerTypedRouter(this.typedrouter)
-    );
+      // Handle wildcard *splat (matches everything including slashes)
+      .replace(/\*([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, paramName) => {
+        paramNames.push(paramName);
+        return '(.*)';
+      });
+
+    // Ensure exact match
+    regexPattern = `^${regexPattern}$`;
+
+    this.customRoutes.push({
+      pattern: path,
+      regex: new RegExp(regexPattern),
+      paramNames,
+      method,
+      handler,
+    });
+  }
+
+  /**
+   * Parse route parameters from a path using a registered route
+   */
+  private parseRouteParams(
+    route: IRegisteredRoute,
+    pathname: string
+  ): Record<string, string> | null {
+    const match = pathname.match(route.regex);
+    if (!match) return null;
+
+    const params: Record<string, string> = {};
+    route.paramNames.forEach((name, index) => {
+      params[name] = match[index + 1];
+    });
+    return params;
   }
 
   /**
@@ -145,52 +183,92 @@ export class TypedServer {
       );
     }
 
-    if (this.options.serveDir) {
-      this.server.addRoute(
-        '/{*splat}',
-        new servertools.HandlerStatic(this.options.serveDir, {
-          responseModifier: async (responseArg) => {
-            if (plugins.path.parse(responseArg.path).ext === '.html') {
-              let fileString = responseArg.responseContent.toString();
-              const fileStringArray = fileString.split('<head>');
-              if (this.options.injectReload && fileStringArray.length === 2) {
-                fileStringArray[0] = `${fileStringArray[0]}<head>
-                  <!-- injected by @apiglobal/typedserver start -->
-                  <script async defer type="module" src="/typedserver/devtools"></script>
-                  <script>
-                    globalThis.typedserver = {
-                      lastReload: ${this.lastReload},
-                      versionInfo: ${JSON.stringify({}, null, 2)},
-                    }
-                  </script>
-                  <!-- injected by @apiglobal/typedserver stop -->
-                `;
-                fileString = fileStringArray.join('');
-                console.log('injected typedserver script.');
-                responseArg.responseContent = Buffer.from(fileString);
-              } else if (this.options.injectReload) {
-                console.log('Could not insert typedserver script - no <head> tag found');
-              }
-            }
-            const headers = responseArg.headers;
-            headers.appHash = this.serveHash;
-            headers['Cache-Control'] = 'no-cache, no-store, must-revalidate';
-            headers['Pragma'] = 'no-cache';
-            headers['Expires'] = '0';
-            return {
-              headers,
-              path: responseArg.path,
-              responseContent: responseArg.responseContent,
-              travelData: responseArg.travelData,
-            };
-          },
-          serveIndexHtmlDefault: true,
-          enableCompression: this.options.enableCompression,
-          preferredCompressionMethod: this.options.preferredCompressionMethod,
-        })
-      );
+    const port =
+      typeof this.options.port === 'string'
+        ? parseInt(this.options.port, 10)
+        : this.options.port || 3000;
+
+    // Initialize optional helpers
+    if (this.options.sitemap) {
+      this.sitemapHelper = new SitemapHelper(this.options.domain);
     }
-    
+    if (this.options.manifest) {
+      this.smartmanifestInstance = new plugins.smartmanifest.SmartManifest(this.options.manifest);
+    }
+
+    // Initialize file server for static files
+    if (this.options.serveDir) {
+      this.fileServer = new plugins.smartserve.FileServer({
+        root: this.options.serveDir,
+        index: ['index.html'],
+        etag: true,
+      });
+    }
+
+    // Initialize decorated controllers
+    if (this.options.injectReload) {
+      this.devToolsController = new DevToolsController({
+        getLastReload: () => this.lastReload,
+        getEnded: () => this.ended,
+      });
+    }
+
+    this.typedRequestController = new TypedRequestController(this.typedrouter);
+
+    this.builtInRoutesController = new BuiltInRoutesController({
+      domain: this.options.domain,
+      robots: this.options.robots,
+      manifest: this.smartmanifestInstance,
+      sitemap: this.options.sitemap,
+      feed: this.options.feed,
+      appVersion: this.options.appVersion,
+      feedMetadata: this.options.feedMetadata,
+      articleGetterFunction: this.options.articleGetterFunction,
+      blockWaybackMachine: this.options.blockWaybackMachine,
+      getSitemapUrls: () => this.sitemapHelper?.urls || [],
+    });
+
+    // Register controllers with SmartServe's ControllerRegistry
+    if (this.options.injectReload) {
+      plugins.smartserve.ControllerRegistry.registerInstance(this.devToolsController);
+    }
+    plugins.smartserve.ControllerRegistry.registerInstance(this.typedRequestController);
+    plugins.smartserve.ControllerRegistry.registerInstance(this.builtInRoutesController);
+
+    // Compile routes for fast matching
+    plugins.smartserve.ControllerRegistry.compileRoutes();
+
+    // Build SmartServe options
+    const smartServeOptions: plugins.smartserve.ISmartServeOptions = {
+      port,
+      hostname: '0.0.0.0',
+      tls:
+        this.options.privateKey && this.options.publicKey
+          ? {
+              key: this.options.privateKey,
+              cert: this.options.publicKey,
+            }
+          : undefined,
+      websocket: {
+        typedRouter: this.typedrouter,
+        onConnectionOpen: (peer) => {
+          peer.tags.add('typedserver_frontend');
+          console.log(`WebSocket connected: ${peer.id}`);
+        },
+        onConnectionClose: (peer) => {
+          console.log(`WebSocket disconnected: ${peer.id}`);
+        },
+      },
+    };
+
+    this.smartServe = new plugins.smartserve.SmartServe(smartServeOptions);
+
+    // Set up custom request handler that integrates with ControllerRegistry
+    this.smartServe.setHandler(async (request: Request): Promise<Response> => {
+      return this.handleRequest(request);
+    });
+
+    // Setup file watching
     if (this.options.watch && this.options.serveDir) {
       try {
         this.smartwatchInstance = new plugins.smartwatch.Smartwatch([this.options.serveDir]);
@@ -202,20 +280,21 @@ export class TypedServer {
         await this.createServeDirHash();
       } catch (error) {
         console.error('Failed to initialize file watching:', error);
-        // Continue without file watching rather than crashing
       }
     }
 
-    // lets start the server
-    await this.server.start();
+    // Start the server
+    await this.smartServe.start();
+    console.log(`TypedServer listening on port ${port}`);
 
+    // Setup TypedSocket using SmartServe integration
     try {
-      this.typedsocket = await plugins.typedsocket.TypedSocket.createServer(
-        this.typedrouter,
-        this.server
+      this.typedsocket = plugins.typedsocket.TypedSocket.fromSmartServe(
+        this.smartServe,
+        this.typedrouter
       );
 
-      // lets setup typedrouter
+      // Setup typedrouter handlers
       this.typedrouter.addTypedHandler<interfaces.IReq_GetLatestServerChangeTime>(
         new plugins.typedrequest.TypedHandler('getLatestServerChangeTime', async () => {
           return {
@@ -225,10 +304,188 @@ export class TypedServer {
       );
     } catch (error) {
       console.error('Failed to initialize TypedSocket:', error);
-      // Continue without WebSocket support rather than crashing
     }
   }
 
+  /**
+   * Create an IRequestContext from a Request
+   */
+  private async createContext(
+    request: Request,
+    params: Record<string, string>
+  ): Promise<plugins.smartserve.IRequestContext> {
+    const url = new URL(request.url);
+    const method = request.method.toUpperCase() as THttpMethod;
+
+    // Parse query params
+    const query: Record<string, string> = {};
+    url.searchParams.forEach((value, key) => {
+      query[key] = value;
+    });
+
+    // Parse body
+    let body: unknown = undefined;
+    const contentType = request.headers.get('content-type');
+    if (contentType?.includes('application/json')) {
+      try {
+        body = await request.clone().json();
+      } catch {
+        body = {};
+      }
+    }
+
+    return {
+      request,
+      body,
+      params,
+      query,
+      headers: request.headers,
+      path: url.pathname,
+      method,
+      url,
+      runtime: 'node' as const,
+      state: {},
+    };
+  }
+
+  /**
+   * Main request handler - routes to appropriate sub-handlers
+   */
+  private async handleRequest(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+    const path = url.pathname;
+    const method = request.method.toUpperCase() as THttpMethod;
+
+    // First, try to match via ControllerRegistry (decorated routes)
+    const match = plugins.smartserve.ControllerRegistry.matchRoute(path, method);
+    if (match) {
+      try {
+        const context = await this.createContext(request, match.params);
+        const result = await match.route.handler(context);
+
+        // Handle Response or convert to Response
+        if (result instanceof Response) {
+          return result;
+        }
+        return new Response(JSON.stringify(result), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        });
+      } catch (error) {
+        if (error instanceof plugins.smartserve.RouteNotFoundError) {
+          // Route explicitly threw "not found", continue to other handlers
+        } else {
+          console.error('Controller error:', error);
+          return new Response('Internal Server Error', { status: 500 });
+        }
+      }
+    }
+
+    // Custom routes (registered via addRoute)
+    for (const route of this.customRoutes) {
+      if (route.method === 'ALL' || route.method === method) {
+        const params = this.parseRouteParams(route, path);
+        if (params !== null) {
+          (request as any).params = params;
+          const response = await route.handler(request);
+          if (response) return response;
+        }
+      }
+    }
+
+    // HTML injection for reload (if enabled)
+    if (this.options.injectReload && this.options.serveDir) {
+      const response = await this.handleHtmlWithInjection(request);
+      if (response) return response;
+    }
+
+    // Try static file serving
+    if (this.fileServer && (method === 'GET' || method === 'HEAD')) {
+      try {
+        const staticResponse = await this.fileServer.serve(request);
+        if (staticResponse) {
+          return staticResponse;
+        }
+      } catch (error) {
+        // Fall through to 404
+      }
+    }
+
+    // Default answer for root
+    if (path === '/' && method === 'GET' && this.options.defaultAnswer) {
+      const html = await this.options.defaultAnswer();
+      return new Response(html, {
+        status: 200,
+        headers: { 'Content-Type': 'text/html' },
+      });
+    }
+
+    // Not found
+    return new Response('Not Found', { status: 404 });
+  }
+
+  /**
+   * Handle HTML files with reload script injection
+   */
+  private async handleHtmlWithInjection(request: Request): Promise<Response | null> {
+    const url = new URL(request.url);
+    const requestPath = url.pathname;
+
+    // Check if this is a request for an HTML file or root
+    if (requestPath === '/' || requestPath.endsWith('.html') || !requestPath.includes('.')) {
+      try {
+        let filePath = requestPath === '/' ? 'index.html' : requestPath.slice(1);
+        if (!filePath.endsWith('.html') && !filePath.includes('.')) {
+          filePath = plugins.path.join(filePath, 'index.html');
+        }
+
+        const fullPath = plugins.path.join(this.options.serveDir, filePath);
+
+        // Security check
+        if (!fullPath.startsWith(this.options.serveDir)) {
+          return new Response('Forbidden', { status: 403 });
+        }
+
+        let fileContent = (await plugins.fsInstance
+          .file(fullPath)
+          .encoding('utf8')
+          .read()) as string;
+
+        // Inject reload script
+        if (fileContent.includes('<head>')) {
+          const injection = `<head>
+                <!-- injected by @apiglobal/typedserver start -->
+                <script async defer type="module" src="/typedserver/devtools"></script>
+                <script>
+                  globalThis.typedserver = {
+                    lastReload: ${this.lastReload},
+                    versionInfo: ${JSON.stringify({}, null, 2)},
+                  }
+                </script>
+                <!-- injected by @apiglobal/typedserver stop -->
+              `;
+          fileContent = fileContent.replace('<head>', injection);
+          console.log('injected typedserver script.');
+        }
+
+        return new Response(fileContent, {
+          status: 200,
+          headers: {
+            'Content-Type': 'text/html; charset=utf-8',
+            'Cache-Control': 'no-cache, no-store, must-revalidate',
+            Pragma: 'no-cache',
+            Expires: '0',
+            appHash: this.serveHash,
+          },
+        });
+      } catch (error) {
+        // Fall through to default handling
+      }
+    }
+
+    return null;
+  }
+
   /**
    * reloads the page
    */
@@ -238,14 +495,17 @@ export class TypedServer {
       console.warn('TypedSocket not initialized, skipping client notifications');
       return;
     }
-    
+
     try {
-      const connections = await this.typedsocket.findAllTargetConnectionsByTag('typedserver_frontend');
+      const connections = await this.typedsocket.findAllTargetConnectionsByTag(
+        'typedserver_frontend'
+      );
       for (const connection of connections) {
-        const pushTime = this.typedsocket.createTypedRequest<interfaces.IReq_PushLatestServerChangeTime>(
-          'pushLatestServerChangeTime',
-          connection
-        );
+        const pushTime =
+          this.typedsocket.createTypedRequest<interfaces.IReq_PushLatestServerChangeTime>(
+            'pushLatestServerChangeTime',
+            connection
+          );
         pushTime.fire({
           time: this.lastReload,
         });
@@ -260,7 +520,7 @@ export class TypedServer {
    */
   public async stop(): Promise<void> {
     this.ended = true;
-    
+
     const stopWithErrorHandling = async (
       stopFn: () => Promise<unknown>,
       componentName: string
@@ -271,24 +531,24 @@ export class TypedServer {
         console.error(`Error stopping ${componentName}:`, err);
       }
     };
-    
+
     const tasks: Promise<void>[] = [];
-    
-    // Stop server
-    if (this.server) {
-      tasks.push(stopWithErrorHandling(() => this.server.stop(), 'server'));
+
+    // Stop SmartServe
+    if (this.smartServe) {
+      tasks.push(stopWithErrorHandling(() => this.smartServe.stop(), 'SmartServe'));
     }
-    
-    // Stop TypedSocket
+
+    // Stop TypedSocket (in SmartServe mode, this is a no-op but good for cleanup)
     if (this.typedsocket) {
       tasks.push(stopWithErrorHandling(() => this.typedsocket.stop(), 'TypedSocket'));
     }
-    
+
     // Stop file watcher
     if (this.smartwatchInstance) {
       tasks.push(stopWithErrorHandling(() => this.smartwatchInstance.stop(), 'file watcher'));
     }
-    
+
     await Promise.all(tasks);
   }
 
@@ -306,11 +566,48 @@ export class TypedServer {
       this.serveDirHashSubject.next(this.serveHash);
     } catch (error) {
       console.error('Failed to create serve directory hash:', error);
-      // Use a timestamp-based hash as fallback
       const fallbackHash = Date.now().toString(16).slice(-6);
       this.serveHash = fallbackHash;
       console.log('Using fallback hash: ' + fallbackHash);
       this.serveDirHashSubject.next(fallbackHash);
     }
   }
-}
+}
+
+// ============================================================================
+// Helper Classes
+// ============================================================================
+
+/**
+ * Sitemap helper class
+ */
+class SitemapHelper {
+  private smartSitemap = new plugins.smartsitemap.SmartSitemap();
+  public urls: plugins.smartsitemap.IUrlInfo[] = [];
+
+  constructor(domain?: string) {
+    if (domain) {
+      this.urls.push({
+        url: `https://${domain}/`,
+        timestamp: Date.now(),
+        frequency: 'daily',
+      });
+    }
+  }
+
+  async createSitemap(): Promise<string> {
+    return this.smartSitemap.createSitemapFromUrlInfoArray(this.urls);
+  }
+
+  async createSitemapNews(articles: plugins.tsclass.content.IArticle[]): Promise<string> {
+    return this.smartSitemap.createSitemapNewsFromArticleArray(articles);
+  }
+
+  replaceUrls(urlsArg: plugins.smartsitemap.IUrlInfo[]) {
+    this.urls = urlsArg;
+  }
+
+  addUrls(urlsArg: plugins.smartsitemap.IUrlInfo[]) {
+    this.urls = this.urls.concat(urlsArg);
+  }
+}

ts/controllers/controller.builtin.ts

@@ -0,0 +1,125 @@
+import * as plugins from '../plugins.js';
+
+/**
+ * Built-in routes controller for TypedServer
+ * Handles robots.txt, manifest.json, sitemap, feed, appversion
+ */
+@plugins.smartserve.Route('')
+export class BuiltInRoutesController {
+  private options: {
+    domain?: string;
+    robots?: boolean;
+    manifest?: plugins.smartmanifest.SmartManifest;
+    sitemap?: boolean;
+    feed?: boolean;
+    appVersion?: string;
+    feedMetadata?: plugins.smartfeed.IFeedOptions;
+    articleGetterFunction?: () => Promise<plugins.tsclass.content.IArticle[]>;
+    blockWaybackMachine?: boolean;
+    getSitemapUrls: () => plugins.smartsitemap.IUrlInfo[];
+  };
+
+  constructor(options: typeof BuiltInRoutesController.prototype.options) {
+    this.options = options;
+  }
+
+  @plugins.smartserve.Get('/robots.txt')
+  async getRobots(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.robots || !this.options.domain) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    const robotsContent = [
+      'User-agent: *',
+      'Allow: /',
+      `Sitemap: https://${this.options.domain}/sitemap`,
+    ];
+
+    if (this.options.blockWaybackMachine) {
+      robotsContent.push('', 'User-agent: ia_archiver', 'Disallow: /');
+    }
+
+    return new Response(robotsContent.join('\n'), {
+      status: 200,
+      headers: { 'Content-Type': 'text/plain' },
+    });
+  }
+
+  @plugins.smartserve.Get('/manifest.json')
+  async getManifest(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.manifest) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    return new Response(this.options.manifest.jsonString(), {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  @plugins.smartserve.Get('/sitemap')
+  async getSitemap(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.sitemap || !this.options.domain) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    const smartsitemap = new plugins.smartsitemap.SmartSitemap();
+    const urls = this.options.getSitemapUrls();
+    const sitemapXml = await smartsitemap.createSitemapFromUrlInfoArray(urls);
+
+    return new Response(sitemapXml, {
+      status: 200,
+      headers: { 'Content-Type': 'application/xml' },
+    });
+  }
+
+  @plugins.smartserve.Get('/sitemap-news')
+  async getSitemapNews(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.sitemap || !this.options.domain || !this.options.articleGetterFunction) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    const smartsitemap = new plugins.smartsitemap.SmartSitemap();
+    const articles = await this.options.articleGetterFunction();
+    const sitemapNewsXml = await smartsitemap.createSitemapNewsFromArticleArray(articles);
+
+    return new Response(sitemapNewsXml, {
+      status: 200,
+      headers: { 'Content-Type': 'application/xml' },
+    });
+  }
+
+  @plugins.smartserve.Get('/feed')
+  async getFeed(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.feed || !this.options.feedMetadata) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    const smartfeed = new plugins.smartfeed.Smartfeed();
+    const articles = this.options.articleGetterFunction
+      ? await this.options.articleGetterFunction()
+      : [];
+
+    const feedXml = await smartfeed.createFeedFromArticleArray(
+      this.options.feedMetadata,
+      articles
+    );
+
+    return new Response(feedXml, {
+      status: 200,
+      headers: { 'Content-Type': 'application/atom+xml' },
+    });
+  }
+
+  @plugins.smartserve.Get('/appversion')
+  async getAppVersion(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    if (!this.options.appVersion) {
+      throw new plugins.smartserve.RouteNotFoundError(ctx.path, ctx.method);
+    }
+
+    return new Response(this.options.appVersion, {
+      status: 200,
+      headers: { 'Content-Type': 'text/plain' },
+    });
+  }
+}

ts/controllers/controller.devtools.ts

@@ -0,0 +1,53 @@
+import * as plugins from '../plugins.js';
+import * as paths from '../paths.js';
+
+/**
+ * DevTools controller for TypedServer
+ * Handles /typedserver/devtools and /typedserver/reloadcheck endpoints
+ */
+@plugins.smartserve.Route('/typedserver')
+export class DevToolsController {
+  private getLastReload: () => number;
+  private getEnded: () => boolean;
+
+  constructor(options: { getLastReload: () => number; getEnded: () => boolean }) {
+    this.getLastReload = options.getLastReload;
+    this.getEnded = options.getEnded;
+  }
+
+  @plugins.smartserve.Get('/devtools')
+  async getDevtools(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    const devtoolsContent = (await plugins.fsInstance
+      .file(paths.injectBundlePath)
+      .encoding('utf8')
+      .read()) as string;
+
+    return new Response(devtoolsContent, {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/javascript',
+      },
+    });
+  }
+
+  @plugins.smartserve.Post('/reloadcheck')
+  async reloadCheck(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    console.log('got request for reloadcheck');
+
+    if (this.getEnded()) {
+      return new Response('end', {
+        status: 200,
+        headers: {
+          'Content-Type': 'text/plain',
+        },
+      });
+    }
+
+    return new Response(this.getLastReload().toString(), {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/plain',
+      },
+    });
+  }
+}

ts/controllers/controller.typedrequest.ts

@@ -0,0 +1,34 @@
+import * as plugins from '../plugins.js';
+
+/**
+ * TypedRequest controller for type-safe RPC endpoint
+ */
+@plugins.smartserve.Route('/typedrequest')
+export class TypedRequestController {
+  private typedRouter: plugins.typedrequest.TypedRouter;
+
+  constructor(typedRouter: plugins.typedrequest.TypedRouter) {
+    this.typedRouter = typedRouter;
+  }
+
+  @plugins.smartserve.Post('/')
+  async handleTypedRequest(ctx: plugins.smartserve.IRequestContext): Promise<Response> {
+    try {
+      const response = await this.typedRouter.routeAndAddResponse(ctx.body as plugins.typedrequestInterfaces.ITypedRequest);
+
+      return new Response(plugins.smartjson.stringify(response), {
+        status: 200,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+    } catch (error) {
+      return new Response(JSON.stringify({ error: 'Invalid request' }), {
+        status: 400,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+    }
+  }
+}

ts/controllers/index.ts

@@ -0,0 +1,3 @@
+export * from './controller.devtools.js';
+export * from './controller.typedrequest.js';
+export * from './controller.builtin.js';

ts/index.ts

@@ -5,10 +5,10 @@ import * as servertools from './servertools/index.js';
 export { servertools };
 
 export * from './classes.typedserver.js';
-// Type helpers
-export type Request = plugins.express.Request;
-export type Response = plugins.express.Response;
 
+// Type helpers - using native Web API Request/Response types
+// Native Request and Response are available in Node.js 18+ and all modern browsers
+// Legacy Express types are available via servertools for backward compatibility
 
 // lets export utilityservers
 import * as utilityservers from './utilityservers/index.js';

ts/plugins.ts

@@ -61,11 +61,16 @@ export {
 // Create a ready-to-use smartfs instance with Node.js provider
 export const fsInstance = new smartfs.SmartFs(new smartfs.SmartFsProviderNode());
 
-// express
+// @push.rocks/smartserve
+import * as smartserve from '@push.rocks/smartserve';
+
+export { smartserve };
+
+// Legacy Express dependencies - kept for backward compatibility with deprecated servertools
+// These will be removed in the next major version
+import express from 'express';
 import bodyParser from 'body-parser';
 import cors from 'cors';
-import express from 'express';
-// @ts-ignore
 import expressForceSsl from 'express-force-ssl';
 
-export { bodyParser, cors, express, expressForceSsl };
+export { express, bodyParser, cors, expressForceSsl };

ts/servertools/classes.server.ts

@@ -53,10 +53,17 @@ export class Server {
     this.addRoute('/typedrequest', new HandlerTypedRouter(typedrouter));
   }
 
+  /**
+   * @deprecated This method is deprecated. Use TypedServer with SmartServe integration instead.
+   * TypedSocket v4 no longer supports attaching to an existing Express server.
+   */
   public addTypedSocket(typedrouter: plugins.typedrequest.TypedRouter): void {
-    this.executeAfterStartFunctions.push(async () => {
-      plugins.typedsocket.TypedSocket.createServer(typedrouter, this);
-    });
+    console.warn(
+      '[DEPRECATED] servertools.Server.addTypedSocket() is deprecated and has no effect. ' +
+      'Use TypedServer with SmartServe integration for WebSocket support.'
+    );
+    // TypedSocket v4 creates its own server, which would conflict with Express.
+    // This method is now a no-op for backward compatibility.
   }
 
   public addRoute(routeStringArg: string, handlerArg?: Handler) {

ts/servertools/index.ts

@@ -1,12 +1,22 @@
-export * from './classes.server.js';
-export * from './classes.route.js';
-export * from './classes.handler.js';
-export * from './classes.handlerstatic.js';
-export * from './classes.handlerproxy.js';
-export * from './classes.handlertypedrouter.js';
+// Core utilities that don't depend on Express
 export * from './classes.compressor.js';
-import * as serviceworker from './tools.serviceworker.js';
 
-export {
-  serviceworker,
-}
+// Legacy Express-based classes - deprecated, will be removed in next major version
+// These are kept for backward compatibility but should not be used for new code
+// Use SmartServe decorator-based controllers instead
+/** @deprecated Use SmartServe directly */
+export * from './classes.server.js';
+/** @deprecated Use SmartServe @Route decorator */
+export * from './classes.route.js';
+/** @deprecated Use SmartServe @Get/@Post decorators */
+export * from './classes.handler.js';
+/** @deprecated Use SmartServe static file serving */
+export * from './classes.handlerstatic.js';
+/** @deprecated Use SmartServe custom handler */
+export * from './classes.handlerproxy.js';
+/** @deprecated Use SmartServe TypedRouter integration */
+export * from './classes.handlertypedrouter.js';
+
+// Service worker utilities - uses legacy patterns, will be migrated
+import * as serviceworker from './tools.serviceworker.js';
+export { serviceworker };

ts/servertools/tools.serviceworker.ts

@@ -1,10 +1,8 @@
 import * as plugins from '../plugins.js';
 import * as paths from '../paths.js';
 
-import * as interfaces from '../../dist_ts_interfaces/index.js'
-import { Handler } from './classes.handler.js';
+import * as interfaces from '../../dist_ts_interfaces/index.js';
 import type { TypedServer } from '../classes.typedserver.js';
-import { HandlerTypedRouter } from './classes.handlertypedrouter.js';
 
 // Lazy-loaded service worker bundle content
 let swBundleJs: string | null = null;
@@ -12,64 +10,83 @@ let swBundleJsMap: string | null = null;
 
 const loadServiceWorkerBundle = async (): Promise<void> => {
   if (swBundleJs === null) {
-    swBundleJs = await plugins.fsInstance
+    swBundleJs = (await plugins.fsInstance
       .file(plugins.path.join(paths.serviceworkerBundleDir, './serviceworker.bundle.js'))
       .encoding('utf8')
-      .read() as string;
+      .read()) as string;
   }
   if (swBundleJsMap === null) {
-    swBundleJsMap = await plugins.fsInstance
+    swBundleJsMap = (await plugins.fsInstance
       .file(plugins.path.join(paths.serviceworkerBundleDir, './serviceworker.bundle.js.map'))
       .encoding('utf8')
-      .read() as string;
+      .read()) as string;
   }
 };
 
 let swVersionInfo: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'] =
   null;
 
-const serviceworkerHandler = new Handler(
-  'GET',
-  async (req, res) => {
-    await loadServiceWorkerBundle();
-    if (req.path === '/serviceworker.bundle.js') {
-      res.status(200);
-      res.set('Content-Type', 'text/javascript');
-      res.write(swBundleJs + '\n' + `/** appSemVer: ${swVersionInfo?.appSemVer || 'not set'} */`);
-    } else if (req.path === '/serviceworker.bundle.js.map') {
-      res.status(200);
-      res.set('Content-Type', 'application/json');
-      res.write(swBundleJsMap);
-    }
-    res.end();
-  }
-);
-
 export const addServiceWorkerRoute = (
   typedserverInstance: TypedServer,
   swDataFunc: () => interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response']
 ) => {
-  // lets the version info as unique string;
+  // Set the version info
   swVersionInfo = swDataFunc();
 
-  // the basic stuff
-  typedserverInstance.server.addRoute('/serviceworker/*splat', serviceworkerHandler);
+  // Service worker bundle handler
+  typedserverInstance.addRoute('/serviceworker/*splat', 'GET', async (request: Request) => {
+    await loadServiceWorkerBundle();
+    const url = new URL(request.url);
+    const path = url.pathname;
 
-  // the typed stuff
-  const typedrouter = new plugins.typedrequest.TypedRouter();
+    if (path === '/serviceworker/serviceworker.bundle.js' || path === '/serviceworker.bundle.js') {
+      return new Response(
+        swBundleJs + '\n' + `/** appSemVer: ${swVersionInfo?.appSemVer || 'not set'} */`,
+        {
+          status: 200,
+          headers: { 'Content-Type': 'text/javascript' },
+        }
+      );
+    } else if (
+      path === '/serviceworker/serviceworker.bundle.js.map' ||
+      path === '/serviceworker.bundle.js.map'
+    ) {
+      return new Response(swBundleJsMap, {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }
 
-  typedrouter.addTypedHandler(
-    new plugins.typedrequest.TypedHandler<interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo>(
-      'serviceworker_versionInfo',
-      async (req) => {
-        const versionInfoResponse = swDataFunc();
-        return versionInfoResponse;
-      }
-    )
-  );
+    return null;
+  });
 
-  typedserverInstance.server.addRoute(
-    '/sw-typedrequest',
-    new HandlerTypedRouter(typedrouter)
-  );
+  // Typed request handler for service worker
+  typedserverInstance.addRoute('/sw-typedrequest', 'POST', async (request: Request) => {
+    try {
+      const body = await request.json();
+
+      // Create a local typed router for service worker requests
+      const typedrouter = new plugins.typedrequest.TypedRouter();
+
+      typedrouter.addTypedHandler(
+        new plugins.typedrequest.TypedHandler<interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo>(
+          'serviceworker_versionInfo',
+          async () => {
+            return swDataFunc();
+          }
+        )
+      );
+
+      const response = await typedrouter.routeAndAddResponse(body);
+      return new Response(plugins.smartjson.stringify(response), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    } catch (error) {
+      return new Response(JSON.stringify({ error: 'Invalid request' }), {
+        status: 400,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }
+  });
 };

ts/utilityservers/classes.serviceserver.ts

@@ -1,9 +1,7 @@
 import { TypedServer } from '../classes.typedserver.js';
-import * as servertools from '../servertools/index.js';
-import * as plugins from '../plugins.js';
 
 export interface ILoleServiceServerConstructorOptions {
-  addCustomRoutes?: (serverArg: servertools.Server) => Promise<any>;
+  addCustomRoutes?: (typedserver: TypedServer) => Promise<any>;
   serviceName: string;
   serviceVersion: string;
   serviceDomain: string;
@@ -20,12 +18,12 @@ export class UtilityServiceServer {
   }
 
   public async start() {
-    console.log('starting lole-serviceserver...')
+    console.log('starting lole-serviceserver...');
     this.typedServer = new TypedServer({
       cors: true,
       domain: this.options.serviceDomain,
       forceSsl: false,
-      port: this.options.port || 3000,
+      port: this.options.port || 3000,
       robots: true,
       defaultAnswer: async () => {
         const InfoHtml = (await import('../infohtml/index.js')).InfoHtml;
@@ -37,9 +35,9 @@ export class UtilityServiceServer {
       },
     });
 
-    // lets add any custom routes
+    // Add any custom routes
     if (this.options.addCustomRoutes) {
-      await this.options.addCustomRoutes(this.typedServer.server);
+      await this.options.addCustomRoutes(this.typedServer);
     }
 
     await this.typedServer.start();

ts/utilityservers/classes.websiteserver.ts

@@ -1,11 +1,10 @@
 import * as interfaces from '../../dist_ts_interfaces/index.js';
 import { type IServerOptions, TypedServer } from '../classes.typedserver.js';
-import type { Request, Response } from '../index.js';
 import * as plugins from '../plugins.js';
 import * as servertools from '../servertools/index.js';
 
 export interface IUtilityWebsiteServerConstructorOptions {
-  addCustomRoutes?: (serverArg: servertools.Server) => Promise<any>;
+  addCustomRoutes?: (typedserver: TypedServer) => Promise<any>;
   appSemVer?: string;
   domain: string;
   serveDir: string;
@@ -16,7 +15,6 @@ export interface IUtilityWebsiteServerConstructorOptions {
  * the utility website server implements a best practice server for websites
  * It supports:
  *  * live reload
- *  * compression
  *  * serviceworker
  *  * pwa manifest
  */
@@ -30,7 +28,7 @@ export class UtilityWebsiteServer {
   }
 
   /**
-   *
+   * Start the website server
    */
   public async start(portArg = 3000) {
     this.typedserver = new TypedServer({
@@ -38,8 +36,6 @@ export class UtilityWebsiteServer {
       injectReload: true,
       watch: true,
       serveDir: this.options.serveDir,
-      enableCompression: true,
-      preferredCompressionMethod: 'gzip',
       domain: this.options.domain,
       forceSsl: false,
       manifest: {
@@ -58,33 +54,32 @@ export class UtilityWebsiteServer {
       sitemap: true,
     });
 
-    let lswData: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'] =
-      {
-        appHash: 'xxxxxx',
-        appSemVer: this.options.appSemVer || 'x.x.x',
-      };
+    let lswData: interfaces.serviceworker.IRequest_Serviceworker_Backend_VersionInfo['response'] = {
+      appHash: 'xxxxxx',
+      appSemVer: this.options.appSemVer || 'x.x.x',
+    };
 
     // -> /lsw* - anything regarding serviceworker
     servertools.serviceworker.addServiceWorkerRoute(this.typedserver, () => {
       return lswData;
     });
 
-    // lets add ads.txt
-    this.typedserver.server.addRoute(
-      '/ads.txt',
-      new servertools.Handler('GET', async (req, res) => {
-        res.type('txt/plain');
-        const adsTxt =
-          ['google.com, pub-4104137977476459, DIRECT, f08c47fec0942fa0'].join('\n') + '\n';
-        res.write(adsTxt);
-        res.end();
-      })
-    );
+    // ads.txt handler
+    this.typedserver.addRoute('/ads.txt', 'GET', async () => {
+      const adsTxt =
+        ['google.com, pub-4104137977476459, DIRECT, f08c47fec0942fa0'].join('\n') + '\n';
+      return new Response(adsTxt, {
+        status: 200,
+        headers: { 'Content-Type': 'text/plain' },
+      });
+    });
 
-    this.typedserver.server.addRoute(
+    // Asset broker manifest handler
+    this.typedserver.addRoute(
       '/assetbroker/manifest/:manifestAsset',
-      new servertools.Handler('GET', async (req, res) => {
-        let manifestAssetName = req.params.manifestAsset;
+      'GET',
+      async (request: Request) => {
+        let manifestAssetName = (request as any).params?.manifestAsset;
         if (manifestAssetName === 'favicon.png') {
           manifestAssetName = `favicon_${this.options.domain
             .replace('.', '')
@@ -95,19 +90,19 @@ export class UtilityWebsiteServer {
         const smartRequest = plugins.smartrequest.SmartRequest.create();
         const response = await smartRequest.url(fullOriginAssetUrl).get();
         const arrayBuffer = await response.arrayBuffer();
-        const dataBuffer: Buffer = Buffer.from(arrayBuffer);
-        res.type('.png');
-        res.write(dataBuffer);
-        res.end();
-      })
+        return new Response(arrayBuffer, {
+          status: 200,
+          headers: { 'Content-Type': 'image/png' },
+        });
+      }
     );
 
-    // lets add any custom routes
+    // Add any custom routes
     if (this.options.addCustomRoutes) {
-      await this.options.addCustomRoutes(this.typedserver.server);
+      await this.options.addCustomRoutes(this.typedserver);
     }
 
-    // -> /*  - serve the files
+    // Subscribe to serve directory hash changes
     this.typedserver.serveDirHashSubject.subscribe((appHash: string) => {
       lswData = {
         appHash,
@@ -115,11 +110,11 @@ export class UtilityWebsiteServer {
       };
     });
 
-    // lets setup the typedrouter chain
+    // Setup the typedrouter chain
     this.typedserver.typedrouter.addTypedRouter(this.typedrouter);
 
-    // lets start everything
-    console.log('routes are all set. Startin up now!');
+    // Start everything
+    console.log('routes are all set. Starting up now!');
     await this.typedserver.start();
     console.log('typedserver started!');
   }
@@ -127,14 +122,4 @@ export class UtilityWebsiteServer {
   public async stop() {
     await this.typedserver.stop();
   }
-
-  /**
-   * allows you to hanlde requests from other server instances without the need to listen for yourself
-   * note smartexpress allows you start the instance wuith passing >>false<< as second parameter to .start();
-   * @param req
-   * @param res
-   */
-  public async handleRequest(req: Request, res: Response) {
-    await this.typedserver.server.handleReqRes(req, res);
-  }
 }

ts_web_inject/typedserver_web.infoscreen.ts

@@ -14,10 +14,10 @@ export class TypedserverInfoscreen extends LitElement {
   //INSTANCE
 
   @property()
-  private text = 'Hello';
+  accessor text = 'Hello';
 
   @property()
-  private success = false;
+  accessor success = false;
 
   public static styles = [
     css`

tsconfig.json

@@ -1,7 +1,5 @@
 {
   "compilerOptions": {
-    "experimentalDecorators": true,
-    "useDefineForClassFields": false,
     "target": "ES2022",
     "module": "NodeNext",
     "moduleResolution": "NodeNext",