zastro-websockets-node 0.0.0-729d313

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { AstroAdapter, AstroIntegration } from 'astro';
+import type { Options, UserOptions } from './types.js';
+export declare function getAdapter(options: Options): AstroAdapter;
+export default function createIntegration(userOptions: UserOptions): AstroIntegration;

package/dist/index.js

@@ -0,0 +1,112 @@
+import { fileURLToPath } from "node:url";
+import { writeJson } from "@astrojs/internal-helpers/fs";
+import { AstroError } from "astro/errors";
+import { STATIC_HEADERS_FILE } from "./shared.js";
+function getAdapter(options) {
+  return {
+    name: "zastro-websockets-node",
+    serverEntrypoint: "zastro-websockets-node/server.js",
+    previewEntrypoint: "zastro-websockets-node/preview.js",
+    exports: ["handler", "startServer", "options"],
+    args: options,
+    adapterFeatures: {
+      buildOutput: "server",
+      edgeMiddleware: false,
+      experimentalStaticHeaders: options.experimentalStaticHeaders
+    },
+    supportedAstroFeatures: {
+      hybridOutput: "stable",
+      staticOutput: "stable",
+      serverOutput: "stable",
+      sharpImageService: "stable",
+      i18nDomains: "experimental",
+      envGetSecret: "stable"
+    }
+  };
+}
+function createIntegration(userOptions) {
+  if (!userOptions?.mode) {
+    throw new AstroError(`Setting the 'mode' option is required.`);
+  }
+  let _options;
+  let _config = void 0;
+  let _routeToHeaders = void 0;
+  return {
+    name: "zastro-websockets-node",
+    hooks: {
+      "astro:config:setup": async ({ updateConfig, config, logger }) => {
+        let session = config.session;
+        _config = config;
+        if (!session?.driver) {
+          logger.info("Enabling sessions with filesystem storage");
+          session = {
+            ...session,
+            driver: "fs-lite",
+            options: {
+              base: fileURLToPath(new URL("sessions", config.cacheDir))
+            }
+          };
+        }
+        updateConfig({
+          image: {
+            endpoint: {
+              route: config.image.endpoint.route ?? "_image",
+              entrypoint: config.image.endpoint.entrypoint ?? "astro/assets/endpoint/node"
+            }
+          },
+          session,
+          vite: {
+            ssr: {
+              noExternal: ["@astrojs/node"]
+            }
+          }
+        });
+      },
+      "astro:build:generated": ({ experimentalRouteToHeaders }) => {
+        _routeToHeaders = experimentalRouteToHeaders;
+      },
+      "astro:config:done": ({ setAdapter, config }) => {
+        _options = {
+          ...userOptions,
+          client: config.build.client?.toString(),
+          server: config.build.server?.toString(),
+          host: config.server.host,
+          port: config.server.port,
+          assets: config.build.assets,
+          experimentalStaticHeaders: userOptions.experimentalStaticHeaders ?? false
+        };
+        setAdapter(getAdapter(_options));
+      },
+      "astro:build:done": async () => {
+        if (!_config) {
+          return;
+        }
+        if (_routeToHeaders && _routeToHeaders.size > 0) {
+          const headersFileUrl = new URL(STATIC_HEADERS_FILE, _config.outDir);
+          const headersValue = [];
+          for (const [pathname, { headers }] of _routeToHeaders.entries()) {
+            if (_config.experimental.csp) {
+              const csp = headers.get("Content-Security-Policy");
+              if (csp) {
+                headersValue.push({
+                  pathname,
+                  headers: [
+                    {
+                      key: "Content-Security-Policy",
+                      value: csp
+                    }
+                  ]
+                });
+              }
+            }
+          }
+          await writeJson(headersFileUrl, headersValue);
+        }
+      }
+    }
+  };
+}
+export {
+  createIntegration as default,
+  getAdapter
+};

package/dist/log-listening-on.d.ts

@@ -0,0 +1,4 @@
+import type http from 'node:http';
+import https from 'node:https';
+import type { AstroIntegrationLogger } from 'astro';
+export declare function logListeningOn(logger: AstroIntegrationLogger, server: http.Server | https.Server, configuredHost: string | boolean | undefined): Promise<void>;

package/dist/log-listening-on.js

@@ -0,0 +1,57 @@
+import https from "node:https";
+import os from "node:os";
+const wildcardHosts = /* @__PURE__ */ new Set(["0.0.0.0", "::", "0000:0000:0000:0000:0000:0000:0000:0000"]);
+async function logListeningOn(logger, server, configuredHost) {
+  await new Promise((resolve) => server.once("listening", resolve));
+  const protocol = server instanceof https.Server ? "https" : "http";
+  const host = getResolvedHostForHttpServer(configuredHost);
+  const { port } = server.address();
+  const address = getNetworkAddress(protocol, host, port);
+  if (host === void 0 || wildcardHosts.has(host)) {
+    logger.info(
+      `Server listening on 
+  local: ${address.local[0]} 	
+  network: ${address.network[0]}
+`
+    );
+  } else {
+    logger.info(`Server listening on ${address.local[0]}`);
+  }
+}
+function getResolvedHostForHttpServer(host) {
+  if (host === false) {
+    return "localhost";
+  } else if (host === true) {
+    return void 0;
+  } else {
+    return host;
+  }
+}
+function getNetworkAddress(protocol = "http", hostname, port, base) {
+  const NetworkAddress = {
+    local: [],
+    network: []
+  };
+  Object.values(os.networkInterfaces()).flatMap((nInterface) => nInterface ?? []).filter(
+    (detail) => detail && detail.address && (detail.family === "IPv4" || // @ts-expect-error Node 18.0 - 18.3 returns number
+    detail.family === 4)
+  ).forEach((detail) => {
+    let host = detail.address.replace(
+      "127.0.0.1",
+      hostname === void 0 || wildcardHosts.has(hostname) ? "localhost" : hostname
+    );
+    if (host.includes(":")) {
+      host = `[${host}]`;
+    }
+    const url = `${protocol}://${host}:${port}${base ? base : ""}`;
+    if (detail.address.includes("127.0.0.1")) {
+      NetworkAddress.local.push(url);
+    } else {
+      NetworkAddress.network.push(url);
+    }
+  });
+  return NetworkAddress;
+}
+export {
+  logListeningOn
+};

package/dist/middleware/index.d.ts

@@ -0,0 +1,2 @@
+import type { MiddlewareHandler } from 'astro';
+export declare function createStatsMiddleware(): MiddlewareHandler;

package/dist/middleware/index.js

@@ -0,0 +1,8 @@
+function createStatsMiddleware() {
+  return async (_context, next) => {
+    return next();
+  };
+}
+export {
+  createStatsMiddleware
+};

package/dist/middleware/types.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    namespace App {
+        interface Locals {
+            websocketStats?: any;
+        }
+    }
+}
+export {};

package/dist/middleware.d.ts

@@ -0,0 +1,11 @@
+import type { NodeApp } from 'astro/app/node';
+import type { RequestHandler } from './types.js';
+/**
+ * Creates a middleware that can be used with Express, Connect, etc.
+ *
+ * Similar to `createAppHandler` but can additionally be placed in the express
+ * chain as an error middleware.
+ *
+ * https://expressjs.com/en/guide/using-middleware.html#middleware.error-handling
+ */
+export default function createMiddleware(app: NodeApp): RequestHandler;

package/dist/middleware.js

@@ -0,0 +1,29 @@
+import { createAppHandler } from "./serve-app.js";
+function createMiddleware(app) {
+  const handler = createAppHandler(app);
+  const logger = app.getAdapterLogger();
+  return async (...args) => {
+    const [req, res, next, locals] = args;
+    if (req instanceof Error) {
+      const error = req;
+      if (next) {
+        return next(error);
+      } else {
+        throw error;
+      }
+    }
+    try {
+      await handler(req, res, next, locals);
+    } catch (err) {
+      logger.error(`Could not render ${req.url}`);
+      console.error(err);
+      if (!res.headersSent) {
+        res.writeHead(500, `Server error`);
+        res.end();
+      }
+    }
+  };
+}
+export {
+  createMiddleware as default
+};

package/dist/polyfill.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/polyfill.js

@@ -0,0 +1,2 @@
+import { applyPolyfills } from "astro/app/node";
+applyPolyfills();

package/dist/preview.d.ts

@@ -0,0 +1,3 @@
+import type { CreatePreviewServer } from 'astro';
+declare const createPreviewServer: CreatePreviewServer;
+export { createPreviewServer as default };

package/dist/preview.js

@@ -0,0 +1,50 @@
+import { fileURLToPath } from "node:url";
+import { AstroError } from "astro/errors";
+import { logListeningOn } from "./log-listening-on.js";
+import { createServer } from "./standalone.js";
+const createPreviewServer = async (preview) => {
+  let ssrHandler;
+  try {
+    process.env.ASTRO_NODE_AUTOSTART = "disabled";
+    const ssrModule = await import(preview.serverEntrypoint.toString());
+    if (typeof ssrModule.handler === "function") {
+      ssrHandler = ssrModule.handler;
+    } else {
+      throw new AstroError(
+        `The server entrypoint doesn't have a handler. Are you sure this is the right file?`
+      );
+    }
+  } catch (err) {
+    if (err.code === "ERR_MODULE_NOT_FOUND" && err.url === preview.serverEntrypoint.href) {
+      throw new AstroError(
+        `The server entrypoint ${fileURLToPath(
+          preview.serverEntrypoint
+        )} does not exist. Have you ran a build yet?`
+      );
+    } else {
+      throw err;
+    }
+  }
+  const host = process.env.HOST ?? preview.host ?? "0.0.0.0";
+  const port = preview.port ?? 4321;
+  const server = createServer(ssrHandler, host, port);
+  if (preview.headers) {
+    server.server.addListener("request", (_, res) => {
+      if (res.statusCode === 200) {
+        for (const [name, value] of Object.entries(preview.headers ?? {})) {
+          if (value) res.setHeader(name, value);
+        }
+      }
+    });
+  }
+  logListeningOn(preview.logger, server.server, host);
+  await new Promise((resolve, reject) => {
+    server.server.once("listening", resolve);
+    server.server.once("error", reject);
+    server.server.listen(port, host);
+  });
+  return server;
+};
+export {
+  createPreviewServer as default
+};

package/dist/serve-app.d.ts

@@ -0,0 +1,8 @@
+import { NodeApp } from 'astro/app/node';
+import type { 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;

package/dist/serve-app.js

@@ -0,0 +1,49 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { NodeApp } from "astro/app/node";
+function createAppHandler(app) {
+  const als = new AsyncLocalStorage();
+  const logger = app.getAdapterLogger();
+  process.on("unhandledRejection", (reason) => {
+    const requestUrl = als.getStore();
+    logger.error(`Unhandled rejection while rendering ${requestUrl}`);
+    console.error(reason);
+  });
+  return async (req, res, next, locals = {}) => {
+    let request;
+    try {
+      request = NodeApp.createRequest(req);
+    } catch (err) {
+      logger.error(`Could not render ${req.url}`);
+      console.error(err);
+      res.statusCode = 500;
+      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);
+    if (routeData) {
+      const response = await als.run(
+        request.url,
+        () => app.render(request, {
+          addCookieHeader: true,
+          locals,
+          routeData
+        })
+      );
+      await NodeApp.writeResponse(response, res);
+    } else if (next) {
+      return next();
+    } else {
+      const response = await app.render(req);
+      await NodeApp.writeResponse(response, res);
+    }
+  };
+}
+export {
+  createAppHandler
+};

package/dist/serve-static.d.ts

@@ -0,0 +1,10 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { NodeApp } from 'astro/app/node';
+import type { Options } from './types.js';
+/**
+ * Creates a Node.js http listener for static files and prerendered pages.
+ * In standalone mode, the static handler is queried first for the static files.
+ * If one matching the request path is not found, it relegates to the SSR handler.
+ * Intended to be used only in the standalone mode.
+ */
+export declare function createStaticHandler(app: NodeApp, options: Options): (req: IncomingMessage, res: ServerResponse, ssr: () => unknown) => ServerResponse<IncomingMessage> | undefined;

package/dist/serve-static.js

@@ -0,0 +1,111 @@
+import fs from "node:fs";
+import path from "node:path";
+import url from "node:url";
+import { hasFileExtension } 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("?");
+      const filePath = path.join(client, app.removeBase(urlPath));
+      let isDirectory = false;
+      try {
+        isDirectory = fs.lstatSync(filePath).isDirectory();
+      } catch {
+      }
+      const { trailingSlash = "ignore" } = options;
+      const hasSlash = urlPath.endsWith("/");
+      let pathname = urlPath;
+      if (app.headersMap && app.headersMap.length > 0) {
+        const routeData = app.match(req, true);
+        if (routeData && routeData.prerender) {
+          const matchedRoute = app.headersMap.find((header) => header.pathname.includes(pathname));
+          if (matchedRoute) {
+            for (const header of matchedRoute.headers) {
+              res.setHeader(header.key, header.value);
+            }
+          }
+        }
+      }
+      switch (trailingSlash) {
+        case "never": {
+          if (isDirectory && urlPath !== "/" && hasSlash) {
+            pathname = urlPath.slice(0, -1) + (urlQuery ? "?" + urlQuery : "");
+            res.statusCode = 301;
+            res.setHeader("Location", pathname);
+            return res.end();
+          }
+          if (isDirectory && !hasSlash) {
+            pathname = `${urlPath}/index.html`;
+          }
+          break;
+        }
+        case "ignore": {
+          if (isDirectory && !hasSlash) {
+            pathname = `${urlPath}/index.html`;
+          }
+          break;
+        }
+        case "always": {
+          if (!hasSlash && !hasFileExtension(urlPath)) {
+            pathname = urlPath + "/" + (urlQuery ? "?" + urlQuery : "");
+            res.statusCode = 301;
+            res.setHeader("Location", pathname);
+            return res.end();
+          }
+          break;
+        }
+      }
+      pathname = prependForwardSlash(app.removeBase(pathname));
+      const stream = send(req, pathname, {
+        root: client,
+        dotfiles: pathname.startsWith("/.well-known/") ? "allow" : "deny"
+      });
+      let forwardError = false;
+      stream.on("error", (err) => {
+        if (forwardError) {
+          console.error(err.toString());
+          res.writeHead(500);
+          res.end("Internal server error");
+          return;
+        }
+        ssr();
+      });
+      stream.on("headers", (_res) => {
+        if (pathname.startsWith(`/${options.assets}/`)) {
+          _res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+        }
+      });
+      stream.on("file", () => {
+        forwardError = true;
+      });
+      stream.pipe(res);
+    } else {
+      ssr();
+    }
+  };
+}
+function resolveClientDir(options) {
+  const clientURLRaw = new URL(options.client);
+  const serverURLRaw = new URL(options.server);
+  const rel = path.relative(url.fileURLToPath(serverURLRaw), url.fileURLToPath(clientURLRaw));
+  const serverFolder = path.basename(options.server);
+  let serverEntryFolderURL = path.dirname(import.meta.url);
+  while (!serverEntryFolderURL.endsWith(serverFolder)) {
+    serverEntryFolderURL = path.dirname(serverEntryFolderURL);
+  }
+  const serverEntryURL = serverEntryFolderURL + "/entry.mjs";
+  const clientURL = new URL(appendForwardSlash(rel), serverEntryURL);
+  const client = url.fileURLToPath(clientURL);
+  return client;
+}
+function prependForwardSlash(pth) {
+  return pth.startsWith("/") ? pth : "/" + pth;
+}
+function appendForwardSlash(pth) {
+  return pth.endsWith("/") ? pth : pth + "/";
+}
+export {
+  createStaticHandler
+};

package/dist/server.d.ts

@@ -0,0 +1,18 @@
+import './polyfill.js';
+import type { SSRManifest } from 'astro';
+import type { Options } from './types.js';
+export declare function createExports(manifest: SSRManifest, options: Options): {
+    options: Options;
+    handler: import("./types.js").RequestHandler;
+    startServer: () => {
+        server: {
+            host: string;
+            port: number;
+            closed(): Promise<void>;
+            stop(): Promise<void>;
+            server: import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> | import("https").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+        };
+        done: Promise<void>;
+    };
+};
+export declare function start(manifest: SSRManifest, options: Options): void;

package/dist/server.js

@@ -0,0 +1,56 @@
+import "./polyfill.js";
+import { existsSync, readFileSync } from "node:fs";
+import { NodeApp } from "astro/app/node";
+import { setGetEnv } from "astro/env/setup";
+import createMiddleware from "./middleware.js";
+import { STATIC_HEADERS_FILE } from "./shared.js";
+import startServer, { createStandaloneHandler } from "./standalone.js";
+setGetEnv((key) => process.env[key]);
+function createExports(manifest, options) {
+  const app = new NodeApp(manifest, !options.experimentalDisableStreaming);
+  let headersMap = void 0;
+  if (options.experimentalStaticHeaders) {
+    headersMap = readHeadersJson(manifest.outDir);
+  }
+  if (headersMap) {
+    app.setHeadersMap(headersMap);
+  }
+  options.trailingSlash = manifest.trailingSlash;
+  return {
+    options,
+    handler: options.mode === "middleware" ? createMiddleware(app) : createStandaloneHandler(app, options),
+    startServer: () => startServer(app, options)
+  };
+}
+function start(manifest, options) {
+  if (options.mode !== "standalone" || process.env.ASTRO_NODE_AUTOSTART === "disabled") {
+    return;
+  }
+  let headersMap = void 0;
+  if (options.experimentalStaticHeaders) {
+    headersMap = readHeadersJson(manifest.outDir);
+  }
+  const app = new NodeApp(manifest, !options.experimentalDisableStreaming);
+  if (headersMap) {
+    app.setHeadersMap(headersMap);
+  }
+  startServer(app, options);
+}
+function readHeadersJson(outDir) {
+  let headersMap = void 0;
+  const headersUrl = new URL(STATIC_HEADERS_FILE, outDir);
+  if (existsSync(headersUrl)) {
+    const content = readFileSync(headersUrl, "utf-8");
+    try {
+      headersMap = JSON.parse(content);
+    } catch (e) {
+      console.error("[@astrojs/node] Error parsing _headers.json: " + e.message);
+      console.error("[@astrojs/node] Please make sure your _headers.json is valid JSON.");
+    }
+  }
+  return headersMap;
+}
+export {
+  createExports,
+  start
+};

package/dist/shared.d.ts

@@ -0,0 +1 @@
+export declare const STATIC_HEADERS_FILE = "_experimentalHeaders.json";

package/dist/shared.js

@@ -0,0 +1,4 @@
+const STATIC_HEADERS_FILE = "_experimentalHeaders.json";
+export {
+  STATIC_HEADERS_FILE
+};

package/dist/standalone.d.ts

@@ -0,0 +1,23 @@
+import http from 'node:http';
+import https from 'node:https';
+import type { NodeApp } from 'astro/app/node';
+import type { Options } from './types.js';
+export declare const hostOptions: (host: Options["host"]) => string;
+export default function standalone(app: NodeApp, options: Options): {
+    server: {
+        host: string;
+        port: number;
+        closed(): Promise<void>;
+        stop(): Promise<void>;
+        server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | https.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    };
+    done: Promise<void>;
+};
+export declare function createStandaloneHandler(app: NodeApp, options: Options): (req: http.IncomingMessage, res: http.ServerResponse) => void;
+export declare function createServer(listener: http.RequestListener, host: string, port: number): {
+    host: string;
+    port: number;
+    closed(): Promise<void>;
+    stop(): Promise<void>;
+    server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | https.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+};

package/dist/standalone.js

@@ -0,0 +1,84 @@
+import fs from "node:fs";
+import http from "node:http";
+import https from "node:https";
+import enableDestroy from "server-destroy";
+import { logListeningOn } from "./log-listening-on.js";
+import { createAppHandler } from "./serve-app.js";
+import { createStaticHandler } from "./serve-static.js";
+import { createWebsocketHandler } from "./websocket/serve-websocket.js";
+const hostOptions = (host) => {
+  if (typeof host === "boolean") {
+    return host ? "0.0.0.0" : "localhost";
+  }
+  return host;
+};
+function standalone(app, options) {
+  const port = process.env.PORT ? Number(process.env.PORT) : options.port ?? 8080;
+  const host = process.env.HOST ?? hostOptions(options.host);
+  const handler = createStandaloneHandler(app, options);
+  const server = createServer(handler, host, port);
+  server.server.on("upgrade", createWebsocketHandler(app));
+  server.server.listen(port, host);
+  if (process.env.ASTRO_NODE_LOGGING !== "disabled") {
+    logListeningOn(app.getAdapterLogger(), server.server, host);
+  }
+  return {
+    server,
+    done: server.closed()
+  };
+}
+function createStandaloneHandler(app, options) {
+  const appHandler = createAppHandler(app);
+  const staticHandler = createStaticHandler(app, options);
+  return (req, res) => {
+    try {
+      decodeURI(req.url);
+    } catch {
+      res.writeHead(400);
+      res.end("Bad request.");
+      return;
+    }
+    staticHandler(req, res, () => appHandler(req, res));
+  };
+}
+function createServer(listener, host, port) {
+  let httpServer;
+  if (process.env.SERVER_CERT_PATH && process.env.SERVER_KEY_PATH) {
+    httpServer = https.createServer(
+      {
+        key: fs.readFileSync(process.env.SERVER_KEY_PATH),
+        cert: fs.readFileSync(process.env.SERVER_CERT_PATH)
+      },
+      listener
+    );
+  } else {
+    httpServer = http.createServer(listener);
+  }
+  enableDestroy(httpServer);
+  const closed = new Promise((resolve, reject) => {
+    httpServer.addListener("close", resolve);
+    httpServer.addListener("error", reject);
+  });
+  const previewable = {
+    host,
+    port,
+    closed() {
+      return closed;
+    },
+    async stop() {
+      await new Promise((resolve, reject) => {
+        httpServer.destroy((err) => err ? reject(err) : resolve(void 0));
+      });
+    }
+  };
+  return {
+    server: httpServer,
+    ...previewable
+  };
+}
+export {
+  createServer,
+  createStandaloneHandler,
+  standalone as default,
+  hostOptions
+};

package/dist/types.d.ts

@@ -0,0 +1,40 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { SSRManifest } from 'astro';
+export interface UserOptions {
+    /**
+     * Specifies the mode that the adapter builds to.
+     *
+     * - 'middleware' - Build to middleware, to be used within another Node.js server, such as Express.
+     * - 'standalone' - Build to a standalone server. The server starts up just by running the built script.
+     */
+    mode: 'middleware' | 'standalone';
+    /**
+     * Disables HTML streaming. This is useful for example if there are constraints from your host.
+     */
+    experimentalDisableStreaming?: boolean;
+    /**
+     * If enabled, the adapter will save [static headers in the framework API file](https://docs.netlify.com/frameworks-api/#headers).
+     *
+     * Here the list of the headers that are added:
+     * - The CSP header of the static pages is added when CSP support is enabled.
+     */
+    experimentalStaticHeaders?: boolean;
+}
+export interface Options extends UserOptions {
+    host: string | boolean;
+    port: number;
+    server: string;
+    client: string;
+    assets: string;
+    trailingSlash?: SSRManifest['trailingSlash'];
+    experimentalStaticHeaders: boolean;
+}
+export type RequestHandler = (...args: RequestHandlerParams) => void | Promise<void>;
+export type RequestHandlerParams = [
+    req: IncomingMessage,
+    res: ServerResponse,
+    next?: (err?: unknown) => void,
+    locals?: {
+        [key: string]: any;
+    }
+];

package/dist/websocket/attach.d.ts

@@ -0,0 +1,3 @@
+import type * as ws from "ws";
+import type { WebSocket } from "./websocket.js";
+export declare function attach(standard: WebSocket, ws: ws.WebSocket): void;

package/dist/websocket/attach.js

@@ -0,0 +1,15 @@
+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
+};

package/dist/websocket/connection-manager.d.ts

@@ -0,0 +1,12 @@
+import type * as ws from "ws";
+import type { WebSocket } from "./websocket.js";
+export declare class ConnectionManager {
+    private connections;
+    registerConnection(socket: WebSocket, wsSocket: ws.WebSocket): string;
+}
+export declare const ConnectionManagerAPI: {
+    getInstance: () => ConnectionManager;
+    getStats: () => {
+        totalConnections: number;
+    };
+};

package/dist/websocket/connection-manager.js

@@ -0,0 +1,16 @@
+class ConnectionManager {
+  connections = /* @__PURE__ */ new Map();
+  registerConnection(socket, wsSocket) {
+    const id = `conn_${Date.now()}`;
+    this.connections.set(id, { socket, wsSocket });
+    return id;
+  }
+}
+const ConnectionManagerAPI = {
+  getInstance: () => new ConnectionManager(),
+  getStats: () => ({ totalConnections: 0 })
+};
+export {
+  ConnectionManager,
+  ConnectionManagerAPI
+};

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

@@ -0,0 +1 @@
+export declare const onRequest: (context: any, next: () => Promise<Response>) => Promise<Response>;

package/dist/websocket/dev-middleware.js

@@ -0,0 +1,12 @@
+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();
+};
+export {
+  onRequest
+};

package/dist/websocket/response.d.ts

@@ -0,0 +1,5 @@
+export declare class UpgradeResponse extends Response {
+    readonly status = 101;
+    constructor();
+}
+export declare function writeResponseToSocket(socket: import("node:stream").Duplex, response: Response): Promise<void>;

package/dist/websocket/response.js

@@ -0,0 +1,32 @@
+import { pipeline } from "node:stream/promises";
+class UpgradeResponse extends Response {
+  status = 101;
+  constructor() {
+    super(null, {
+      status: 101,
+      statusText: "Switching Protocols",
+      headers: {
+        "Upgrade": "websocket",
+        "Connection": "Upgrade"
+      }
+    });
+  }
+}
+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
+`;
+  }
+  socket.write(head + "\r\n");
+  if (response.body) {
+    await pipeline(response.clone().body, socket);
+  }
+}
+export {
+  UpgradeResponse,
+  writeResponseToSocket
+};

package/dist/websocket/serve-websocket.d.ts

@@ -0,0 +1,3 @@
+import { NodeApp } from "astro/app/node";
+export type UpgradeHandler = import("node:http").Server["on"] extends (event: "upgrade", callback: infer UpgradeHandler) => unknown ? UpgradeHandler : never;
+export declare function createWebsocketHandler(app: NodeApp): UpgradeHandler;

package/dist/websocket/serve-websocket.js

@@ -0,0 +1,32 @@
+import * as ws from "ws";
+import { NodeApp } from "astro/app/node";
+import { WebSocket } from "./websocket.js";
+import { attach } from "./attach.js";
+import { UpgradeResponse, writeResponseToSocket } from "./response.js";
+function createWebsocketHandler(app) {
+  const responseToSocketMap = /* @__PURE__ */ new WeakMap();
+  const server = new ws.WebSocketServer({ noServer: true });
+  return async (req, socket, head) => {
+    const response = await app.render(NodeApp.createRequest(req), {
+      addCookieHeader: true,
+      locals: {
+        isUpgradeRequest: true,
+        upgradeWebSocket() {
+          const socket2 = new WebSocket();
+          const response2 = new UpgradeResponse();
+          responseToSocketMap.set(response2, socket2);
+          return { socket: socket2, response: response2 };
+        }
+      }
+    });
+    if (response instanceof UpgradeResponse) {
+      const websocket = responseToSocketMap.get(response);
+      server.handleUpgrade(req, socket, head, (wsSocket) => attach(websocket, wsSocket));
+    } else {
+      await writeResponseToSocket(socket, response);
+    }
+  };
+}
+export {
+  createWebsocketHandler
+};

package/dist/websocket/stats.d.ts

@@ -0,0 +1,10 @@
+import type * as ws from "ws";
+import type { WebSocket } from "./websocket.js";
+export declare const WebSocketStats: {
+    getConnectionCount: () => number;
+    getConnectionStats: () => {
+        totalConnections: number;
+    };
+    shutdown: () => void;
+};
+export declare function registerConnection(socket: WebSocket, wsSocket: ws.WebSocket): string;

package/dist/websocket/stats.js

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

package/dist/websocket/websocket.d.ts

@@ -0,0 +1,58 @@
+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 {
+    static readonly CONNECTING: 0;
+    static readonly OPEN: 1;
+    static readonly CLOSING: 2;
+    static readonly CLOSED: 3;
+    get url(): string;
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+    readonly CLOSING: 2;
+    readonly CLOSED: 3;
+    get readyState(): 0 | 2 | 3 | 1;
+    get bufferedAmount(): number;
+    onopen: WebSocketInterface["onopen"];
+    onerror: WebSocketInterface["onerror"];
+    onclose: WebSocketInterface["onclose"];
+    get extensions(): string;
+    get protocol(): string;
+    close(): void;
+    onmessage: WebSocketInterface["onmessage"];
+    get binaryType(): "arraybuffer" | "blob";
+    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;
+    constructor(error: Error, message: string);
+}
+export declare class CloseEvent extends Event implements globalThis.CloseEvent {
+    readonly code: number;
+    readonly reason: string;
+    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;
+    wasClean?: boolean;
+}
+declare global {
+    namespace App {
+        interface Locals {
+            isUpgradeRequest?: boolean;
+            upgradeWebSocket?: () => {
+                socket: WebSocket;
+                response: import("./response.js").UpgradeResponse;
+            };
+        }
+    }
+}
+export {};

package/dist/websocket/websocket.js

@@ -0,0 +1,130 @@
+const wsMap = /* @__PURE__ */ new WeakMap();
+const attacher = { attach: null };
+class WebSocket extends EventTarget {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  get url() {
+    const ws = wsMap.get(this);
+    return ws?.url ?? "";
+  }
+  get readyState() {
+    const ws = wsMap.get(this);
+    return ws?.readyState ?? this.CONNECTING;
+  }
+  get bufferedAmount() {
+    const ws = wsMap.get(this);
+    return ws?.bufferedAmount ?? 0;
+  }
+  // networking
+  onopen = null;
+  onerror = null;
+  onclose = null;
+  get extensions() {
+    const ws = wsMap.get(this);
+    return ws?.extensions ?? "";
+  }
+  get protocol() {
+    const ws = wsMap.get(this);
+    return ws?.protocol ?? "";
+  }
+  close() {
+    const ws = wsMap.get(this);
+    if (ws) ws.close();
+    else this.addEventListener("open", () => this.close(), { once: true });
+  }
+  // messaging
+  onmessage = null;
+  get binaryType() {
+    const ws = wsMap.get(this);
+    return ws?.binaryType ?? "blob";
+  }
+  set binaryType(value) {
+    const ws = wsMap.get(this);
+    if (ws) {
+      Object.assign(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);
+  }
+  static {
+    Object.assign(this.prototype, {
+      CONNECTING: 0,
+      OPEN: 1,
+      CLOSING: 2,
+      CLOSED: 3
+    });
+    Object.freeze(this.prototype);
+    Object.freeze(this);
+    attacher.attach = attachImpl;
+  }
+}
+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" });
+  if (ws.readyState === ws.OPEN) {
+    const event = new Event("open");
+    standard.onopen?.(event);
+    standard.dispatchEvent(event);
+  }
+  ws.on("open", function onOpen() {
+    const event = new Event("open");
+    standard.onopen?.(event);
+    standard.dispatchEvent(event);
+  });
+  ws.on("message", function onMessage(data, isBinary) {
+    const event = new MessageEvent("message", { data: isBinary ? data : data.toString() });
+    standard.onmessage?.(event);
+    standard.dispatchEvent(event);
+  });
+  ws.on("error", function onError(error) {
+    const event = new ErrorEvent(error, error.message);
+    standard.onerror?.(event);
+    standard.dispatchEvent(event);
+  });
+  ws.addEventListener("close", function onClose(ev) {
+    const event = new (globalThis.CloseEvent ?? CloseEvent)("close", ev);
+    standard.onclose?.(event);
+    standard.dispatchEvent(event);
+  });
+}
+class ErrorEvent extends Event {
+  constructor(error, message) {
+    super("error");
+    this.error = error;
+    this.message = message;
+  }
+}
+class CloseEvent extends Event {
+  code;
+  reason;
+  wasClean;
+  constructor(type, eventInitDict) {
+    super(type, eventInitDict);
+    this.code = eventInitDict.code ?? 0;
+    this.reason = eventInitDict.reason ?? "";
+    this.wasClean = eventInitDict.wasClean ?? false;
+  }
+}
+function attach(standard, ws) {
+  return attacher.attach?.(standard, ws);
+}
+export {
+  CloseEvent,
+  ErrorEvent,
+  WebSocket,
+  attach,
+  attacher
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "zastro-websockets-node",
+  "description": "Deploy your site to a Node.js server with WebSocket support",
+  "version": "0.0.0-729d313",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "author": "Zach Handley <zach@zachhandley.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zachhandley/ZAstroWebsockets.git"
+  },
+  "keywords": [
+    "withastro",
+    "astro-adapter",
+    "websockets"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./server.js": "./dist/server.js",
+    "./preview.js": "./dist/preview.js",
+    "./package.json": "./package.json",
+    "./websocket": "./dist/websocket/index.js",
+    "./stats": "./dist/websocket/stats.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@astrojs/internal-helpers": "^0.6.1",
+    "send": "^1.2.0",
+    "server-destroy": "^1.0.1",
+    "ws": "^8.18.0"
+  },
+  "peerDependencies": {
+    "astro": "^5.3.0"
+  }
+}