zastro-websockets-node 9.3.1-1 → 9.5.2-2

package/dist/index.d.ts

@@ -1,4 +1,15 @@
 import type { AstroAdapter, AstroIntegration } from 'astro';
 import type { Options, UserOptions } from './types.js';
 export declare function getAdapter(options: Options): AstroAdapter;
+declare global {
+    namespace App {
+        interface Locals {
+            isUpgradeRequest?: boolean;
+            upgradeWebSocket?: () => {
+                socket: import('./websocket/websocket.js').WebSocket;
+                response: import('./websocket/response.js').UpgradeResponse;
+            };
+        }
+    }
+}
 export default function createIntegration(userOptions: UserOptions): AstroIntegration;

package/dist/index.js

@@ -24,17 +24,24 @@ function getAdapter(options) {
     }
   };
 }
+const protocols = ["http:", "https:"];
 function createIntegration(userOptions) {
   if (!userOptions?.mode) {
     throw new AstroError(`Setting the 'mode' option is required.`);
   }
+  const { experimentalErrorPageHost } = userOptions;
+  if (experimentalErrorPageHost && (!URL.canParse(experimentalErrorPageHost) || !protocols.includes(new URL(experimentalErrorPageHost).protocol))) {
+    throw new AstroError(
+      `Invalid experimentalErrorPageHost: ${experimentalErrorPageHost}. It should be a valid URL.`
+    );
+  }
   let _options;
   let _config = void 0;
   let _routeToHeaders = void 0;
   return {
     name: "zastro-websockets-node",
     hooks: {
-      "astro:config:setup": async ({ updateConfig, config, logger }) => {
+      "astro:config:setup": async ({ updateConfig, config, logger, command }) => {
         let session = config.session;
         _config = config;
         if (!session?.driver) {
@@ -48,10 +55,13 @@ function createIntegration(userOptions) {
           };
         }
         updateConfig({
+          build: {
+            redirects: false
+          },
           image: {
             endpoint: {
               route: config.image.endpoint.route ?? "_image",
-              entrypoint: config.image.endpoint.entrypoint ?? "astro/assets/endpoint/node"
+              entrypoint: config.image.endpoint.entrypoint ?? (command === "dev" ? "astro/assets/endpoint/dev" : "astro/assets/endpoint/node")
             }
           },
           session,
@@ -73,7 +83,8 @@ function createIntegration(userOptions) {
           host: config.server.host,
           port: config.server.port,
           assets: config.build.assets,
-          experimentalStaticHeaders: userOptions.experimentalStaticHeaders ?? false
+          experimentalStaticHeaders: userOptions.experimentalStaticHeaders ?? false,
+          experimentalErrorPageHost
         };
         setAdapter(getAdapter(_options));
       },

package/dist/middleware.d.ts

@@ -1,5 +1,5 @@
 import type { NodeApp } from 'astro/app/node';
-import type { RequestHandler } from './types.js';
+import type { Options, RequestHandler } from './types.js';
 /**
  * Creates a middleware that can be used with Express, Connect, etc.
  *
@@ -8,4 +8,4 @@ import type { RequestHandler } from './types.js';
  *
  * https://expressjs.com/en/guide/using-middleware.html#middleware.error-handling
  */
-export default function createMiddleware(app: NodeApp): RequestHandler;
+export default function createMiddleware(app: NodeApp, options: Options): RequestHandler;

package/dist/middleware.js

@@ -1,6 +1,6 @@
 import { createAppHandler } from "./serve-app.js";
-function createMiddleware(app) {
-  const handler = createAppHandler(app);
+function createMiddleware(app, options) {
+  const handler = createAppHandler(app, options);
   const logger = app.getAdapterLogger();
   return async (...args) => {
     const [req, res, next, locals] = args;

package/dist/serve-app.d.ts

@@ -1,8 +1,8 @@
 import { NodeApp } from 'astro/app/node';
-import type { RequestHandler } from './types.js';
+import type { Options, RequestHandler } from './types.js';
 /**
  * Creates a Node.js http listener for on-demand rendered pages, compatible with http.createServer and Connect middleware.
  * If the next callback is provided, it will be called if the request does not have a matching route.
  * Intended to be used in both standalone and middleware mode.
  */
-export declare function createAppHandler(app: NodeApp): RequestHandler;
+export declare function createAppHandler(app: NodeApp, options: Options): RequestHandler;

package/dist/serve-app.js

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { NodeApp } from "astro/app/node";
-function createAppHandler(app) {
+function createAppHandler(app, options) {
   const als = new AsyncLocalStorage();
   const logger = app.getAdapterLogger();
   process.on("unhandledRejection", (reason) => {
@@ -8,10 +8,19 @@ function createAppHandler(app) {
     logger.error(`Unhandled rejection while rendering ${requestUrl}`);
     console.error(reason);
   });
+  const originUrl = options.experimentalErrorPageHost ? new URL(options.experimentalErrorPageHost) : void 0;
+  const prerenderedErrorPageFetch = originUrl ? (url) => {
+    const errorPageUrl = new URL(url);
+    errorPageUrl.protocol = originUrl.protocol;
+    errorPageUrl.host = originUrl.host;
+    return fetch(errorPageUrl);
+  } : void 0;
   return async (req, res, next, locals = {}) => {
     let request;
     try {
-      request = NodeApp.createRequest(req);
+      request = NodeApp.createRequest(req, {
+        allowedDomains: app.getAllowedDomains?.() ?? []
+      });
     } catch (err) {
       logger.error(`Could not render ${req.url}`);
       console.error(err);
@@ -19,27 +28,22 @@ function createAppHandler(app) {
       res.end("Internal Server Error");
       return;
     }
-    Object.assign(locals, {
-      isUpgradeRequest: false,
-      upgradeWebSocket() {
-        throw new Error("The request must be an upgrade request to upgrade the connection to a WebSocket.");
-      }
-    });
-    const routeData = app.match(request);
+    const routeData = app.match(request, true);
     if (routeData) {
       const response = await als.run(
         request.url,
         () => app.render(request, {
           addCookieHeader: true,
           locals,
-          routeData
+          routeData,
+          prerenderedErrorPageFetch
         })
       );
       await NodeApp.writeResponse(response, res);
     } else if (next) {
       return next();
     } else {
-      const response = await app.render(req, { addCookieHeader: true });
+      const response = await app.render(req, { addCookieHeader: true, prerenderedErrorPageFetch });
       await NodeApp.writeResponse(response, res);
     }
   };

package/dist/serve-static.js

@@ -1,13 +1,17 @@
 import fs from "node:fs";
 import path from "node:path";
 import url from "node:url";
-import { hasFileExtension } from "@astrojs/internal-helpers/path";
+import { hasFileExtension, isInternalPath } from "@astrojs/internal-helpers/path";
 import send from "send";
 function createStaticHandler(app, options) {
   const client = resolveClientDir(options);
   return (req, res, ssr) => {
     if (req.url) {
-      const [urlPath, urlQuery] = req.url.split("?");
+      let fullUrl = req.url;
+      if (req.url.includes("#")) {
+        fullUrl = fullUrl.slice(0, req.url.indexOf("#"));
+      }
+      const [urlPath, urlQuery] = fullUrl.split("?");
       const filePath = path.join(client, app.removeBase(urlPath));
       let isDirectory = false;
       try {
@@ -48,7 +52,7 @@ function createStaticHandler(app, options) {
           break;
         }
         case "always": {
-          if (!hasSlash && !hasFileExtension(urlPath)) {
+          if (!hasSlash && !hasFileExtension(urlPath) && !isInternalPath(urlPath)) {
             pathname = urlPath + "/" + (urlQuery ? "?" + urlQuery : "");
             res.statusCode = 301;
             res.setHeader("Location", pathname);

package/dist/server.d.ts

@@ -14,5 +14,6 @@ export declare function createExports(manifest: SSRManifest, options: Options):
         };
         done: Promise<void>;
     };
+    websocketHandler: (req: import("http").IncomingMessage, socket: import("stream").Duplex, head: NonSharedBuffer) => void;
 };
 export declare function start(manifest: SSRManifest, options: Options): void;

package/dist/server.js

@@ -5,6 +5,7 @@ import { setGetEnv } from "astro/env/setup";
 import createMiddleware from "./middleware.js";
 import { STATIC_HEADERS_FILE } from "./shared.js";
 import startServer, { createStandaloneHandler } from "./standalone.js";
+import { createWebsocketHandler } from "./websocket/serve-websocket.js";
 setGetEnv((key) => process.env[key]);
 function createExports(manifest, options) {
   const app = new NodeApp(manifest, !options.experimentalDisableStreaming);
@@ -18,8 +19,9 @@ function createExports(manifest, options) {
   options.trailingSlash = manifest.trailingSlash;
   return {
     options,
-    handler: options.mode === "middleware" ? createMiddleware(app) : createStandaloneHandler(app, options),
-    startServer: () => startServer(app, options)
+    handler: options.mode === "middleware" ? createMiddleware(app, options) : createStandaloneHandler(app, options),
+    startServer: () => startServer(app, options),
+    websocketHandler: createWebsocketHandler(app)
   };
 }
 function start(manifest, options) {

package/dist/standalone.js

@@ -28,7 +28,7 @@ function standalone(app, options) {
   };
 }
 function createStandaloneHandler(app, options) {
-  const appHandler = createAppHandler(app);
+  const appHandler = createAppHandler(app, options);
   const staticHandler = createStaticHandler(app, options);
   return (req, res) => {
     try {

package/dist/types.d.ts

@@ -19,6 +19,14 @@ export interface UserOptions {
      * - The CSP header of the static pages is added when CSP support is enabled.
      */
     experimentalStaticHeaders?: boolean;
+    /**
+     * The host that should be used if the server needs to fetch the prerendered error page.
+     * If not provided, this will default to the host of the server. This should be set if the server
+     * should fetch prerendered error pages from a different host than the public URL of the server.
+     * This is useful for example if the server is behind a reverse proxy or a load balancer, or if
+     * static files are hosted on a different domain. Do not include a path in the URL: it will be ignored.
+     */
+    experimentalErrorPageHost?: string | URL;
 }
 export interface Options extends UserOptions {
     host: string | boolean;

package/dist/websocket/attach.d.ts

@@ -1,3 +1,15 @@
 import type * as ws from "ws";
 import type { WebSocket } from "./websocket.js";
+/**
+ * To keep the internals hidden, the function that attaches the
+ * ws.WebSocket to the WebSocket instance is created within
+ * WebSocket's static block, and assigned to this variable.
+ */
+export declare const attacher: {
+    attach: null | typeof attach;
+};
+/**
+ * Attach a ws.WebSocket connected to I/O to the implementation
+ * of the standard WebSocket class exposed to the public API.
+ */
 export declare function attach(standard: WebSocket, ws: ws.WebSocket): void;

package/dist/websocket/attach.js

@@ -1,15 +1,8 @@
-const wsMap = /* @__PURE__ */ new WeakMap();
 const attacher = { attach: null };
-function attachImpl(standard, ws) {
-  if (wsMap.has(standard)) {
-    throw new Error("WebSocket already attached");
-  }
-  wsMap.set(standard, ws);
-}
-attacher.attach = attachImpl;
 function attach(standard, ws) {
   return attacher.attach?.(standard, ws);
 }
 export {
-  attach
+  attach,
+  attacher
 };

package/dist/websocket/dev-middleware.d.ts

@@ -1 +1,12 @@
-export declare const onRequest: (context: any, next: () => Promise<Response>) => Promise<Response>;
+import type { APIContext, AstroIntegration, MiddlewareNext } from "astro";
+export type ViteDevServer = Parameters<NonNullable<AstroIntegration["hooks"]["astro:server:setup"]>>[0]["server"];
+/**
+ * This dev-only middleware is responsible for all requests
+ * that have been made as a result of an upgrade request.
+ *
+ * It checks whether the request is running within the context
+ * of an `upgradeRequestStorage`, which are created below in
+ * `hookIntoViteDevServer()`, and only runs if it is.
+ */
+export declare const onRequest: (context: APIContext, next: MiddlewareNext) => Promise<Response>;
+export declare function handleUpgradeRequests(viteDevServer: ViteDevServer): void;

package/dist/websocket/dev-middleware.js

@@ -1,12 +1,95 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import * as ws from "ws";
+import { UpgradeResponse, writeResponseToSocket } from "./response.js";
+import { WebSocket } from "./websocket.js";
+import { attach as _attach } from "./attach.js";
+const upgradeRequestStorage = (
+  // @ts-expect-error
+  globalThis.__upgradeRequestStorage ??= new AsyncLocalStorage()
+);
+const responseToSocketMap = (
+  // @ts-expect-error
+  globalThis.__responseToSocketMap ??= /* @__PURE__ */ new WeakMap()
+);
+globalThis.__UpgradeResponse = UpgradeResponse;
+function newUpgradeResponse() {
+  return new globalThis.__UpgradeResponse();
+}
+globalThis.__WebSocket = WebSocket;
+function newWebSocket() {
+  return new globalThis.__WebSocket();
+}
+globalThis.__attach = _attach;
+function attach(...args) {
+  return globalThis.__attach(...args);
+}
 const onRequest = async function websocketDevMiddleware(context, next) {
-  const { request, locals } = context;
-  const isUpgradeRequest = request.headers.get("upgrade") === "websocket";
-  locals.isUpgradeRequest = isUpgradeRequest;
-  locals.upgradeWebSocket = () => {
-    throw new Error("The request must be an upgrade request to upgrade the connection to a WebSocket.");
-  };
-  return next();
+  const upgradeRequest = upgradeRequestStorage.getStore();
+  if (upgradeRequest === void 0) {
+    if (!context.locals.isUpgradeRequest) {
+      Object.assign(context.locals, {
+        isUpgradeRequest: false,
+        upgradeWebSocket() {
+          throw new Error("The request must be an upgrade request to upgrade the connection to a WebSocket.");
+        }
+      });
+    }
+    return next();
+  }
+  let response;
+  let error;
+  try {
+    response = await next();
+  } catch (e) {
+    error = e;
+  }
+  if (response) {
+    if (response instanceof UpgradeResponse) {
+      const standardWebSocket = responseToSocketMap.get(response);
+      const [wsServer, req, socket, head] = upgradeRequest;
+      wsServer.handleUpgrade(req, socket, head, (ws2) => attach(standardWebSocket, ws2));
+    } else {
+      const socket = upgradeRequest[2];
+      await writeResponseToSocket(socket, response);
+    }
+    return response;
+  }
+  await writeResponseToSocket(upgradeRequest[2], new Response(null, { status: 500 }));
+  if (error && error instanceof Error) throw error;
+  throw new Error("Unknown error", { cause: error });
+};
+const devLocals = {
+  isUpgradeRequest: true,
+  upgradeWebSocket() {
+    const response = newUpgradeResponse();
+    const socket = newWebSocket();
+    responseToSocketMap.set(response, socket);
+    return { socket, response };
+  }
+};
+function handleUpgradeRequests(viteDevServer) {
+  const astroDevHandler = viteDevServer.middlewares.stack.find((stackItem) => "name" in stackItem.handle && stackItem.handle.name === "astroDevHandler").handle;
+  const wsServer = new ws.WebSocketServer({ noServer: true });
+  const httpServer = viteDevServer.httpServer;
+  httpServer.on("upgrade", (req, socket, head) => {
+    if (req.headers["sec-websocket-protocol"] === "vite-hmr") return;
+    req[Symbol.for("astro.locals")] = devLocals;
+    upgradeRequestStorage.run([wsServer, req, socket, head], astroDevHandler, req, fakeResponse);
+  });
+}
+const fakeResponse = {
+  setHeader() {
+  },
+  write() {
+  },
+  writeHead() {
+  },
+  end() {
+  },
+  on() {
+  }
 };
 export {
+  handleUpgradeRequests,
   onRequest
 };

package/dist/websocket/response.d.ts

@@ -1,5 +1,13 @@
+/**
+ * Custom subclass because spec-compliant Response objects can't have a status of 101.
+ */
 export declare class UpgradeResponse extends Response {
     readonly status = 101;
-    constructor();
 }
+/**
+ * The "upgrade" event callback doesn't provide a response object.
+ * If the userland code decides that protocol should not be upgraded,
+ * the rejection response must be manually streamed into the lower
+ * level socket.
+ */
 export declare function writeResponseToSocket(socket: import("node:stream").Duplex, response: Response): Promise<void>;

package/dist/websocket/response.js

@@ -1,32 +1,16 @@
 import { pipeline } from "node:stream/promises";
 class UpgradeResponse extends Response {
   status = 101;
-  constructor() {
-    super(null, {
-      status: 200,
-      statusText: "Switching Protocols",
-      headers: {
-        "Upgrade": "websocket",
-        "Connection": "Upgrade"
-      }
-    });
-    Object.defineProperty(this, "status", {
-      value: 101,
-      writable: false,
-      enumerable: true,
-      configurable: false
-    });
-  }
 }
+const { Headers } = globalThis;
 async function writeResponseToSocket(socket, response) {
-  let head = `HTTP/1.1 ${response.status}`;
-  if (response.statusText) head += ` ${response.statusText}`;
-  head += `\r
-`;
-  for (const [name, value] of response.headers) {
-    head += `${name}: ${value}\r
+  const { headers, status, statusText } = response;
+  let head = `HTTP/1.1 ${status} ${statusText}\r
 `;
+  for (const [header, value] of new Headers(headers).entries()) {
+    head += header + ": " + value + "\r\n";
   }
+  socket.on("error", console.error);
   socket.write(head + "\r\n");
   if (response.body) {
     await pipeline(response.clone().body, socket);

package/dist/websocket/serve-websocket.js

@@ -3,6 +3,7 @@ import { NodeApp } from "astro/app/node";
 import { WebSocket } from "./websocket.js";
 import { attach } from "./attach.js";
 import { UpgradeResponse, writeResponseToSocket } from "./response.js";
+import { registerConnection } from "./stats.js";
 function createWebsocketHandler(app) {
   const responseToSocketMap = /* @__PURE__ */ new WeakMap();
   const server = new ws.WebSocketServer({ noServer: true });
@@ -12,16 +13,19 @@ function createWebsocketHandler(app) {
       locals: {
         isUpgradeRequest: true,
         upgradeWebSocket() {
-          const socket2 = new WebSocket();
+          const websocket = new WebSocket();
           const response2 = new UpgradeResponse();
-          responseToSocketMap.set(response2, socket2);
-          return { socket: socket2, response: response2 };
+          responseToSocketMap.set(response2, websocket);
+          return { socket: websocket, response: response2 };
         }
       }
     });
     if (response instanceof UpgradeResponse) {
       const websocket = responseToSocketMap.get(response);
-      server.handleUpgrade(req, socket, head, (wsSocket) => attach(websocket, wsSocket));
+      server.handleUpgrade(req, socket, head, (wsSocket) => {
+        registerConnection(websocket, wsSocket);
+        attach(websocket, wsSocket);
+      });
     } else {
       await writeResponseToSocket(socket, response);
     }

package/dist/websocket/stats.d.ts

@@ -4,6 +4,7 @@ export declare const WebSocketStats: {
     getConnectionCount: () => number;
     getConnectionStats: () => {
         totalConnections: number;
+        totalConnectionsEver: number;
     };
     shutdown: () => void;
 };

package/dist/websocket/stats.js

@@ -1,19 +1,30 @@
 class WebSocketStatsManager {
   connections = /* @__PURE__ */ new Map();
   connectionCounter = 0;
+  lifetimeConnections = 0;
   registerConnection(socket, wsSocket) {
     const id = `ws_${++this.connectionCounter}_${Date.now()}`;
     this.connections.set(id, { socket, wsSocket });
+    this.lifetimeConnections++;
+    wsSocket.on("close", () => {
+      this.connections.delete(id);
+    });
     return id;
   }
   getConnectionCount() {
     return this.connections.size;
   }
+  getConnectionStats() {
+    return {
+      totalConnections: this.connections.size,
+      totalConnectionsEver: this.lifetimeConnections
+    };
+  }
 }
 const statsManager = new WebSocketStatsManager();
 const WebSocketStats = {
   getConnectionCount: () => statsManager.getConnectionCount(),
-  getConnectionStats: () => ({ totalConnections: statsManager.getConnectionCount() }),
+  getConnectionStats: () => statsManager.getConnectionStats(),
   shutdown: () => {
   }
 };

package/dist/websocket/websocket.d.ts

@@ -1,9 +1,6 @@
-import type * as ws from "ws";
 type WebSocketInterface = globalThis.WebSocket;
-export declare const attacher: {
-    attach: null | typeof attachImpl;
-};
 export declare class WebSocket extends EventTarget implements WebSocketInterface {
+    #private;
     static readonly CONNECTING: 0;
     static readonly OPEN: 1;
     static readonly CLOSING: 2;
@@ -26,7 +23,6 @@ export declare class WebSocket extends EventTarget implements WebSocketInterface
     set binaryType(value: "arraybuffer" | "blob");
     send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
 }
-declare function attachImpl(standard: WebSocket, ws: ws.WebSocket): void;
 export declare class ErrorEvent extends Event {
     readonly error: Error;
     readonly message: string;
@@ -38,7 +34,6 @@ export declare class CloseEvent extends Event implements globalThis.CloseEvent {
     readonly wasClean: boolean;
     constructor(type: string, eventInitDict: CloseEventInit);
 }
-export declare function attach(standard: WebSocket, ws: ws.WebSocket): void;
 interface CloseEventInit extends EventInit {
     code?: number;
     reason?: string;

package/dist/websocket/websocket.js

@@ -1,57 +1,49 @@
-const wsMap = /* @__PURE__ */ new WeakMap();
-const attacher = { attach: null };
+import { attacher } from "./attach.js";
 class WebSocket extends EventTarget {
+  // Use private field like the original patch
+  #ws;
   static CONNECTING = 0;
   static OPEN = 1;
   static CLOSING = 2;
   static CLOSED = 3;
   get url() {
-    const ws = wsMap.get(this);
-    return ws?.url ?? "";
+    return this.#ws?.url ?? "";
   }
   get readyState() {
-    const ws = wsMap.get(this);
-    return ws?.readyState ?? this.CONNECTING;
+    return this.#ws?.readyState ?? this.CONNECTING;
   }
   get bufferedAmount() {
-    const ws = wsMap.get(this);
-    return ws?.bufferedAmount ?? 0;
+    return this.#ws?.bufferedAmount ?? 0;
   }
-  // networking
+  // networking event handlers
   onopen = null;
   onerror = null;
   onclose = null;
   get extensions() {
-    const ws = wsMap.get(this);
-    return ws?.extensions ?? "";
+    return this.#ws?.extensions ?? "";
   }
   get protocol() {
-    const ws = wsMap.get(this);
-    return ws?.protocol ?? "";
+    return this.#ws?.protocol ?? "";
   }
   close() {
-    const ws = wsMap.get(this);
-    if (ws) ws.close();
+    if (this.#ws) this.#ws.close();
     else this.addEventListener("open", () => this.close(), { once: true });
   }
   // messaging
   onmessage = null;
   get binaryType() {
-    const ws = wsMap.get(this);
-    return ws?.binaryType ?? "blob";
+    return this.#ws?.binaryType ?? "blob";
   }
   set binaryType(value) {
-    const ws = wsMap.get(this);
-    if (ws) {
-      Object.assign(ws, { binaryType: value });
+    if (this.#ws) {
+      this.#ws.binaryType = value;
     } else {
       this.addEventListener("open", () => this.binaryType = value, { once: true });
     }
   }
   send(data) {
-    const ws = wsMap.get(this);
-    if (data instanceof Blob) data.arrayBuffer().then((buffer) => ws.send(buffer));
-    else ws.send(data);
+    if (data instanceof Blob) data.arrayBuffer().then((buffer) => this.#ws.send(buffer));
+    else this.#ws.send(data);
   }
   static {
     Object.assign(this.prototype, {
@@ -62,18 +54,18 @@ class WebSocket extends EventTarget {
     });
     Object.freeze(this.prototype);
     Object.freeze(this);
-    attacher.attach = attachImpl;
+    attacher.attach = (standard, ws) => {
+      if (standard.#ws) {
+        throw new Error("WebSocket already attached");
+      }
+      standard.#ws = ws;
+      init(standard, ws);
+      return standard;
+    };
   }
 }
-function attachImpl(standard, ws) {
-  if (wsMap.has(standard)) {
-    throw new Error("WebSocket already attached");
-  }
-  wsMap.set(standard, ws);
-  init(standard, ws);
-}
 function init(standard, ws) {
-  Object.assign(ws, { binaryType: "blob" });
+  ws.binaryType = "blob";
   if (ws.readyState === ws.OPEN) {
     const event = new Event("open");
     standard.onopen?.(event);
@@ -118,13 +110,8 @@ class CloseEvent extends Event {
     this.wasClean = eventInitDict.wasClean ?? false;
   }
 }
-function attach(standard, ws) {
-  return attacher.attach?.(standard, ws);
-}
 export {
   CloseEvent,
   ErrorEvent,
-  WebSocket,
-  attach,
-  attacher
+  WebSocket
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zastro-websockets-node",
   "description": "Deploy your site to a Node.js server with WebSocket support",
-  "version": "9.3.1-1",
+  "version": "9.5.2-2",
   "type": "module",
   "types": "./dist/index.d.ts",
   "author": "Zach Handley <zach@zachhandley.com>",
@@ -20,19 +20,25 @@
     "./server.js": "./dist/server.js",
     "./preview.js": "./dist/preview.js",
     "./package.json": "./package.json",
+    "./stats": "./dist/websocket/stats.js",
     "./websocket": "./dist/websocket/index.js",
-    "./stats": "./dist/websocket/stats.js"
+    "./websocket/dev-middleware.js": "./dist/websocket/dev-middleware.js",
+    "./websocket/websocket.js": "./dist/websocket/websocket.js",
+    "./websocket/response.js": "./dist/websocket/response.js",
+    "./websocket/serve-websocket.js": "./dist/websocket/serve-websocket.js",
+    "./websocket/attach.js": "./dist/websocket/attach.js",
+    "./websocket/stats.js": "./dist/websocket/stats.js"
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@astrojs/internal-helpers": "^0.6.1",
-    "send": "^1.2.0",
+    "@astrojs/internal-helpers": "^0.7.5",
+    "send": "^1.2.1",
     "server-destroy": "^1.0.1",
     "ws": "^8.18.0"
   },
   "peerDependencies": {
-    "astro": "^5.3.0"
+    "astro": "^5.14.3"
   }
 }