@linebridge/engine-neo 1.1.0 → 1.3.0

package/README.md

@@ -5,7 +5,7 @@ The official, high-performance HTTP and WebSocket engine for [Linebridge](https:
 ## Installation
 
 ```bash
-npm install @linebridge/engine-neo
+pnpm add @linebridge/engine-neo
 ```
 
 ## Usage
@@ -22,5 +22,4 @@ import "@linebridge/engine-neo"
 
 This project is licensed under the **MIT License**.
 
-It includes software developed by uNetworking AB and uWebSockets.js contributors, which is licensed under the **Apache License 2.0**.
-See the [LICENSE](./LICENSE) file for more details.
+It includes software developed by uNetworking AB and uWebSockets.js contributors, which is licensed under the **Apache License 2.0**. See the [LICENSE](./LICENSE) file for more details.

package/lib/engine.d.ts

@@ -15,6 +15,8 @@ import uws_wrapper, { type uWebsockets } from "./uws.js";
 import RTEngine from "linebridge/classes/RtEngine/index";
 import { EngineAdaptor } from "linebridge/classes/EngineAdaptor/index";
 import { Route } from "linebridge/classes/Route/index";
+import route_register from "./route_register.js";
+import middleware_register from "./register_middleware.js";
 /**
  * Options that control the engine's behaviour.
  */
@@ -76,9 +78,9 @@ export declare class NeoEngine extends EngineAdaptor {
     /** Gracefully shuts down the server. Bound to the engine instance. */
     close: () => Promise<boolean>;
     /** Registers a route (HTTP method + path + handler). */
-    register: (route: import("linebridge/classes/Route/index").RouteAlike) => void;
+    register: OmitThisParameter<typeof route_register>;
     /** Registers a global middleware that runs before every route handler. */
-    register_middleware: (middleware: any) => void;
+    register_middleware: OmitThisParameter<typeof middleware_register>;
     /**
      * Publish a message to a topic in MQTT syntax to all WebSocket connections on this Server instance.
      * You cannot publish using wildcards, only fully specified topics.
@@ -91,7 +93,7 @@ export declare class NeoEngine extends EngineAdaptor {
     /** Incoming HTTP request handler. Bound to the engine instance. */
     on_request: (native_req: uWebsockets.HttpRequest, native_res: uWebsockets.HttpResponse, route: Route<any, "server"[]>, socket?: uWebsockets.us_socket_context_t | null | undefined) => any;
     /** Middleware/route iteration loop. Bound to the engine instance. */
-    request_iterator: (request: Request<any>, response: Response<any>, route: Route<Server<"neo">, "server"[]>, allMiddlewares: Handler<HandlerKind>[], cursor?: number | undefined) => Promise<void>;
+    request_iterator: (request: Request<any>, response: Response<any>, route: Route<Server<"neo">, "server"[]>, allMiddlewares: Handler<HandlerKind.middleware>[], cursor?: number | undefined) => Promise<void>;
     /**
      * Decrements the pending request counter and fires the zero-handler
      * when no requests remain in flight.

package/lib/engine.js

@@ -14,7 +14,7 @@ import toBoolean from "linebridge/utils/toBoolean";
 import RTEngine from "linebridge/classes/RtEngine/index";
 import { EngineAdaptor } from "linebridge/classes/EngineAdaptor/index";
 import { Route } from "linebridge/classes/Route/index";
-import WebsocketPolyfill from "./ws/Websocket.js";
+import Websocket from "./ws/Websocket.js";
 import route_register from "./route_register.js";
 import middleware_register from "./register_middleware.js";
 import listen from "./listen.js";
@@ -128,7 +128,7 @@ export class NeoEngine extends EngineAdaptor {
                 upgrade: (res, req, _context) => this.ws.handleUpgrade(req, res),
                 // wrap raw uWS websocket with the polyfill so RTEngine gets EventEmitter + helpers
                 open: (ws) => {
-                    const poly = new WebsocketPolyfill(ws);
+                    const poly = new Websocket(ws);
                     ws.poly = poly;
                     //@ts-ignore polyfill context is Object vs RtEngineSocket's typed shape, but runtime is correct
                     this.ws.handleConnection(poly);
@@ -151,12 +151,15 @@ export class NeoEngine extends EngineAdaptor {
             // @ts-ignore
             global.websockets = this.ws;
         }
-        // create the default route
-        const defaultRoute = new Route();
-        defaultRoute.method = "any";
-        defaultRoute.path = "/*";
-        defaultRoute.fn = this._defaultResponse;
-        this.register(defaultRoute);
+        if (!toBoolean(process.env.LB_SOCKET_MODE)) {
+            // create the default route
+            const defaultRoute = new Route();
+            defaultRoute.method = "any";
+            defaultRoute.path = "/*";
+            defaultRoute.fn = this._defaultResponse;
+            defaultRoute._initialize(this.server);
+            this.register(defaultRoute);
+        }
     };
     /** Starts the server. Bound to the engine instance. */
     listen = listen.bind(this);
@@ -200,7 +203,9 @@ export class NeoEngine extends EngineAdaptor {
      * Default handler for unmatched routes. Responds with a 404 JSON body.
      */
     _defaultResponse(req, res) {
-        res.status(404).json({ error: "Not found" });
+        res.status(404)
+            .setHeader("content-type", "application/json")
+            ._sendFast(`{"error":"Not found"}`);
     }
 }
 export { uws_wrapper as uWebsockets };

package/lib/listen.js

@@ -25,7 +25,9 @@ export default async function () {
                 this.listen_socket = listen_socket;
                 // optionally register process-exit listeners for graceful shutdown
                 if (this.options.auto_close) {
-                    EXIT_EVENTS.forEach((type) => process.once(type, () => this.close()));
+                    EXIT_EVENTS.forEach((type) => process.once(type, () => {
+                        void this.server._fireClose();
+                    }));
                 }
                 resolve();
             }

package/lib/request_iterator.d.ts

@@ -9,7 +9,7 @@ import type Engine from "./engine.js";
 import type Request from "./request.js";
 import type Response from "./response.js";
 import type { Route } from "linebridge/classes/Route/index";
-import type { Handler } from "linebridge/classes/Handler/index";
+import type { Handler, HandlerKind } from "linebridge/classes/Handler/index";
 /**
  * Recursively iterates the middleware chain, then calls the route handler.
  *
@@ -19,4 +19,4 @@ import type { Handler } from "linebridge/classes/Handler/index";
  *
  * @param cursor - Zero-based index into the middleware array. Increments on each recursion.
  */
-export default function (this: Engine, request: Request<any>, response: Response<any>, route: Route<typeof this.server>, allMiddlewares: Handler[], cursor?: number): Promise<void>;
+export default function (this: Engine, request: Request<any>, response: Response<any>, route: Route<typeof this.server>, allMiddlewares: Handler<HandlerKind.middleware>[], cursor?: number): Promise<void>;

package/lib/response.d.ts

@@ -43,6 +43,10 @@ export default class Response<TServer = Server<any>> implements BaseHttpResponse
     _status_code: number;
     /** Custom status message (overrides the default from STATUS_CODES). */
     _status_message: string | null;
+    /** Cached engine reference to avoid walking route.server on every response. */
+    _engine: EngineAdaptor | null;
+    /** Whether at least one header was queued. Avoids enumerating an empty object. */
+    _has_headers: boolean;
     /** Response headers (key → value or key → string[]). */
     _headers: Record<string, string | string[]>;
     /** Set-Cookie headers (name → serialized cookie string). */
@@ -141,11 +145,16 @@ export default class Response<TServer = Server<any>> implements BaseHttpResponse
      *   Must return `true` if the chunk was successfully written.
      */
     drain(handler: (offset: number) => boolean): void;
+    /**
+     * Marks the response as completed and fires the lifecycle listeners.
+     * Used by every path that finishes a response, including streaming.
+     */
+    _mark_completed(): void;
     /**
      * Sends the response body and marks the response as completed.
      *
-     * Supports corked (batched) and uncorked paths, streaming mode, and
-     * `endWithoutBody` when a custom `content-length` header is set.
+     * All uWS writes are wrapped in a single cork callback so status,
+     * headers and body are flushed atomically.
      *
      * Fires `finish` and `close` event listeners.
      */
@@ -178,7 +187,7 @@ export default class Response<TServer = Server<any>> implements BaseHttpResponse
     redirect(url: string): boolean;
     /**
      * Fast-path send used by the `_invokeHandler`.
-     * Skips cork/uncork logic and writes directly.
+     * Corks the writes so status, headers and body are flushed atomically.
      */
     _sendFast(body: any): void;
     /**

package/lib/response.js

@@ -46,6 +46,10 @@ export default class Response {
     _status_code;
     /** Custom status message (overrides the default from STATUS_CODES). */
     _status_message;
+    /** Cached engine reference to avoid walking route.server on every response. */
+    _engine;
+    /** Whether at least one header was queued. Avoids enumerating an empty object. */
+    _has_headers;
     /** Response headers (key → value or key → string[]). */
     _headers;
     /** Set-Cookie headers (name → serialized cookie string). */
@@ -79,26 +83,36 @@ export default class Response {
         const res = new Response();
         res._raw_response = raw_response;
         res.route = route;
+        res._engine = route.engine ?? null;
         res._wrapped_request = request;
         res._upgrade_socket = socket || null;
-        res._headers = {};
+        res._headers = Object.create(null);
+        res._has_headers = false;
+        res._cookies = null;
+        res._events = null;
+        res._streaming = false;
+        res._cork = false;
+        res._corked = false;
+        res._drain_handler = null;
         res._status_code = 200;
+        res._status_message = null;
         res._middleware_cursor = -1;
         // handle uWS abort (client disconnects before response is sent)
         raw_response.onAborted(() => {
             if (res.completed)
                 return;
             res.completed = true;
-            res.route?.server.engine._resolve_pending_request();
+            res._engine?._resolve_pending_request();
             //res._wrapped_request.pause()
-            if (res._events?.abort) {
-                for (let i = 0; i < res._events.abort.length; i++) {
-                    res._events.abort[i](res._wrapped_request, res);
+            const events = res._events;
+            if (events?.abort) {
+                for (let i = 0; i < events.abort.length; i++) {
+                    events.abort[i](res._wrapped_request, res);
                 }
             }
-            if (res._events?.close) {
-                for (let i = 0; i < res._events.close.length; i++) {
-                    res._events.close[i](res._wrapped_request, res);
+            if (events?.close) {
+                for (let i = 0; i < events.close.length; i++) {
+                    events.close[i](res._wrapped_request, res);
                 }
             }
         });
@@ -187,6 +201,7 @@ export default class Response {
         }
         this._headers["content-type"] =
             mime_types.contentType(mime_type) || "text/plain";
+        this._has_headers = true;
         return this;
     }
     /**
@@ -197,6 +212,7 @@ export default class Response {
         name = name.toLowerCase();
         if (overwrite || this._headers[name] === undefined) {
             this._headers[name] = value;
+            this._has_headers = true;
             return this;
         }
         const existing = this._headers[name];
@@ -269,7 +285,7 @@ export default class Response {
         // perform the uWS upgrade with the stored socket handle
         this._raw_response.upgrade({ context }, headers["sec-websocket-key"], headers["sec-websocket-protocol"], headers["sec-websocket-extensions"], this._upgrade_socket);
         this.completed = true;
-        this.engine?._resolve_pending_request();
+        this._engine?._resolve_pending_request();
     }
     /**
      * Writes the status line and all accumulated headers to the uWS response.
@@ -281,31 +297,34 @@ export default class Response {
             return false;
         this.initiated = true;
         const raw = this._raw_response;
-        if (this._status_message) {
-            raw.writeStatus(`${this._status_code} ${this._status_message}`);
-        }
-        else {
-            raw.writeStatus(STATUS_CACHE[this._status_code] || `${this._status_code} OK`);
-        }
-        const headerKeys = Object.keys(this._headers);
-        for (let i = 0; i < headerKeys.length; i++) {
-            const name = headerKeys[i];
-            if (name === "content-length")
-                continue;
-            const values = this._headers[name];
-            if (Array.isArray(values)) {
-                for (let j = 0; j < values.length; j++) {
-                    raw.writeHeader(name, values[j]);
+        const status_code = this._status_code;
+        const status_message = this._status_message;
+        if (status_message) {
+            raw.writeStatus(`${status_code} ${status_message}`);
+        }
+        else if (status_code !== 200) {
+            raw.writeStatus(STATUS_CACHE[status_code] || `${status_code} OK`);
+        }
+        if (this._has_headers) {
+            const headers = this._headers;
+            for (const name in headers) {
+                if (name === "content-length")
+                    continue;
+                const values = headers[name];
+                if (Array.isArray(values)) {
+                    for (let j = 0; j < values.length; j++) {
+                        raw.writeHeader(name, values[j]);
+                    }
+                }
+                else {
+                    raw.writeHeader(name, values);
                 }
-            }
-            else {
-                raw.writeHeader(name, values);
             }
         }
         if (this._cookies) {
-            const cookieKeys = Object.keys(this._cookies);
-            for (let i = 0; i < cookieKeys.length; i++) {
-                raw.writeHeader("set-cookie", this._cookies[cookieKeys[i]]);
+            const cookies = this._cookies;
+            for (const name in cookies) {
+                raw.writeHeader("set-cookie", cookies[name]);
             }
         }
         return true;
@@ -329,71 +348,64 @@ export default class Response {
             });
         }
     }
+    /**
+     * Marks the response as completed and fires the lifecycle listeners.
+     * Used by every path that finishes a response, including streaming.
+     */
+    _mark_completed() {
+        if (this.completed)
+            return;
+        const events = this._events;
+        if (!events) {
+            this.completed = true;
+            this._engine?._resolve_pending_request();
+            return;
+        }
+        const finish = events.finish;
+        if (!this._streaming && finish) {
+            for (let i = 0; i < finish.length; i++) {
+                finish[i](this._wrapped_request, this);
+            }
+        }
+        this.completed = true;
+        this._engine?._resolve_pending_request();
+        const close = events.close;
+        if (close) {
+            for (let i = 0; i < close.length; i++) {
+                close[i](this._wrapped_request, this);
+            }
+        }
+    }
     /**
      * Sends the response body and marks the response as completed.
      *
-     * Supports corked (batched) and uncorked paths, streaming mode, and
-     * `endWithoutBody` when a custom `content-length` header is set.
+     * All uWS writes are wrapped in a single cork callback so status,
+     * headers and body are flushed atomically.
      *
      * Fires `finish` and `close` event listeners.
      */
     send(body, close_connection) {
         if (this.completed)
             return this;
-        if (this._cork && !this._corked) {
-            this._corked = true;
-            this._raw_response.cork(() => {
-                this._initiate_response();
-                if (body !== undefined || this._streaming) {
-                    this._raw_response.end(body, close_connection);
-                }
-                else {
-                    const custom_length = this._headers["content-length"];
-                    if (custom_length) {
-                        const content_length = typeof custom_length === "string"
-                            ? custom_length
-                            : custom_length[custom_length.length - 1];
-                        this._raw_response.endWithoutBody(content_length, close_connection);
-                    }
-                    else {
-                        this._raw_response.end(body, close_connection);
-                    }
-                }
-            });
-        }
-        else {
+        const raw = this._raw_response;
+        raw.cork(() => {
             this._initiate_response();
-            const raw = this._raw_response;
             if (body !== undefined || this._streaming) {
                 raw.end(body, close_connection);
+                return;
             }
-            else {
-                const custom_length = this._headers["content-length"];
-                if (custom_length) {
-                    const content_length = typeof custom_length === "string"
-                        ? custom_length
-                        : custom_length[custom_length.length - 1];
-                    raw.endWithoutBody(content_length, close_connection);
-                }
-                else {
-                    raw.end(body, close_connection);
-                }
-            }
-        }
-        if (!this._streaming && this.listenerCount("finish") > 0) {
-            const handlers = this._events.finish;
-            for (let i = 0; i < handlers.length; i++) {
-                handlers[i](this._wrapped_request, this);
-            }
-        }
-        this.completed = true;
-        this.engine?._resolve_pending_request();
-        if (this.listenerCount("close") > 0) {
-            const handlers = this._events.close;
-            for (let i = 0; i < handlers.length; i++) {
-                handlers[i](this._wrapped_request, this);
+            const custom_length = this._headers["content-length"];
+            if (!custom_length) {
+                raw.end(body, close_connection);
+                return;
             }
-        }
+            const content_length = typeof custom_length === "string"
+                ? custom_length
+                : custom_length[custom_length.length - 1];
+            raw.endWithoutBody(content_length, close_connection);
+        });
+        this._corked = true;
+        this._mark_completed();
         return this;
     }
     _uws_write_chunk(chunk, total_size) {
@@ -407,17 +419,16 @@ export default class Response {
      * Initiates headers if not yet sent. Returns false under backpressure.
      */
     write(chunk) {
-        if (this._cork && !this._corked) {
-            this._corked = true;
-            let ok = false;
-            this._raw_response.cork(() => {
-                this._initiate_response();
-                ok = this._raw_response.write(chunk);
-            });
-            return ok;
-        }
-        this._initiate_response();
-        return this._raw_response.write(chunk);
+        if (this.completed)
+            return false;
+        const raw = this._raw_response;
+        let ok = false;
+        raw.cork(() => {
+            this._initiate_response();
+            ok = raw.write(chunk);
+        });
+        this._corked = true;
+        return ok;
     }
     /**
      * Streams a single chunk with backpressure support.
@@ -427,30 +438,44 @@ export default class Response {
         if (this.completed)
             return Promise.resolve();
         return new Promise((resolve) => {
-            if (this._cork && !this._corked) {
-                this._corked = true;
-                this._raw_response.cork(() => this._initiate_response());
-            }
-            else {
+            const raw = this._raw_response;
+            let sent = false;
+            let responded = false;
+            let write_offset = 0;
+            raw.cork(() => {
                 this._initiate_response();
-            }
-            if (this.completed)
+                write_offset = raw.getWriteOffset();
+                [sent, responded] = this._uws_write_chunk(chunk, total_size);
+                if (sent || responded)
+                    return;
+                this.drain((offset) => {
+                    if (this.completed || !total_size) {
+                        resolve();
+                        return true;
+                    }
+                    const remaining = chunk.slice(offset - write_offset);
+                    let flushed = false;
+                    let has_responded = false;
+                    raw.cork(() => {
+                        ;
+                        [flushed, has_responded] = this._uws_write_chunk(remaining, total_size);
+                    });
+                    if (has_responded) {
+                        this._mark_completed();
+                        resolve();
+                        return true;
+                    }
+                    if (flushed)
+                        resolve();
+                    return flushed;
+                });
+            });
+            if (responded) {
+                this._mark_completed();
                 return resolve();
-            const write_offset = this._raw_response.getWriteOffset();
-            const [sent] = this._uws_write_chunk(chunk, total_size);
+            }
             if (sent)
-                return resolve();
-            this.drain((offset) => {
-                if (this.completed || !total_size) {
-                    resolve();
-                    return true;
-                }
-                const remaining = chunk.slice(offset - write_offset);
-                const [flushed] = this._uws_write_chunk(remaining, total_size);
-                if (flushed)
-                    resolve();
-                return flushed;
-            });
+                resolve();
         });
     }
     /**
@@ -483,7 +508,7 @@ export default class Response {
         }
         if (!this.completed) {
             if (total_size)
-                this.engine?._resolve_pending_request();
+                this._engine?._resolve_pending_request();
             else
                 this.send();
         }
@@ -495,7 +520,7 @@ export default class Response {
         if (this.completed)
             return;
         this.completed = true;
-        this.engine?._resolve_pending_request();
+        this._engine?._resolve_pending_request();
         //this._wrapped_request.pause()
         this._raw_response.close();
     }
@@ -509,24 +534,18 @@ export default class Response {
     }
     /**
      * Fast-path send used by the `_invokeHandler`.
-     * Skips cork/uncork logic and writes directly.
+     * Corks the writes so status, headers and body are flushed atomically.
      */
     _sendFast(body) {
+        if (this.completed)
+            return;
+        const raw = this._raw_response;
+        raw.cork(() => {
+            this._initiate_response();
+            raw.end(body);
+        });
         this._corked = true;
-        this._initiate_response();
-        this._raw_response.end(body);
-        this.completed = true;
-        this.engine?._resolve_pending_request();
-        if (this._events?.finish) {
-            for (let i = 0; i < this._events.finish.length; i++) {
-                this._events.finish[i](this._wrapped_request, this);
-            }
-        }
-        if (this._events?.close) {
-            for (let i = 0; i < this._events.close.length; i++) {
-                this._events.close[i](this._wrapped_request, this);
-            }
-        }
+        this._mark_completed();
     }
     /**
      * Sends a JSON response. Sets `Content-Type: application/json` and
@@ -534,6 +553,7 @@ export default class Response {
      */
     json(body) {
         this._headers["content-type"] = "application/json";
+        this._has_headers = true;
         return this.send(stringify(body));
     }
     /**
@@ -541,6 +561,7 @@ export default class Response {
      */
     html(body) {
         this._headers["content-type"] = "text/html";
+        this._has_headers = true;
         return this.send(body);
     }
     /**
@@ -711,6 +732,7 @@ export default class Response {
      */
     location(path) {
         this._headers["location"] = path;
+        this._has_headers = true;
         return this;
     }
     /**
@@ -737,6 +759,7 @@ export default class Response {
      */
     vary(name) {
         this._headers["vary"] = name;
+        this._has_headers = true;
         return this;
     }
 }

package/lib/route_register.d.ts

@@ -1,5 +1,5 @@
-import type Engine from "./engine.js";
-import { RouteAlike } from "linebridge/classes/Route/index";
+import type { Route } from "linebridge/classes/Route/index";
+import type { NeoEngine } from "./engine.js";
 /**
  * Registers a route with the engine's uWS app.
  *
@@ -7,4 +7,4 @@ import { RouteAlike } from "linebridge/classes/Route/index";
  *
  * @throws {Error} If the engine is not initialized or the route is invalid.
  */
-export default function (this: Engine, route: RouteAlike): void;
+export default function (this: NeoEngine, route: Route): void;