@prisma-next/sql-runtime 0.1.0-dev.14 → 0.1.0-dev.16

package/dist/dist-LBVX6BJW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../node_modules/.pnpm/@electric-sql+pglite-socket@0.0.19_@electric-sql+pglite@0.3.14/node_modules/@electric-sql/pglite-socket/src/index.ts"],"sourcesContent":["import type { PGlite } from '@electric-sql/pglite'\nimport { createServer, Server, Socket } from 'net'\n\n// Connection queue timeout in milliseconds\nexport const CONNECTION_QUEUE_TIMEOUT = 60000 // 60 seconds\n\n/**\n * Options for creating a PGLiteSocketHandler\n */\nexport interface PGLiteSocketHandlerOptions {\n  /** The PGlite database instance */\n  db: PGlite\n  /** Whether to close the socket when detached (default: false) */\n  closeOnDetach?: boolean\n  /** Print the incoming and outgoing data to the console in hex and ascii */\n  inspect?: boolean\n  /** Enable debug logging of method calls */\n  debug?: boolean\n}\n\n/**\n * Low-level handler for a single socket connection to PGLite\n * Handles the raw protocol communication between a socket and PGLite\n */\nexport class PGLiteSocketHandler extends EventTarget {\n  readonly db: PGlite\n  private socket: Socket | null = null\n  private active = false\n  private closeOnDetach: boolean\n  private resolveLock?: () => void\n  private rejectLock?: (err: Error) => void\n  private inspect: boolean\n  private debug: boolean\n  private readonly id: number\n\n  // Static counter for generating unique handler IDs\n  private static nextHandlerId = 1\n\n  /**\n   * Create a new PGLiteSocketHandler\n   * @param options Options for the handler\n   */\n  constructor(options: PGLiteSocketHandlerOptions) {\n    super()\n    this.db = options.db\n    this.closeOnDetach = options.closeOnDetach ?? false\n    this.inspect = options.inspect ?? false\n    this.debug = options.debug ?? false\n    this.id = PGLiteSocketHandler.nextHandlerId++\n\n    this.log('constructor: created new handler')\n  }\n\n  /**\n   * Get the unique ID of this handler\n   */\n  public get handlerId(): number {\n    return this.id\n  }\n\n  /**\n   * Log a message if debug is enabled\n   * @private\n   */\n  private log(message: string, ...args: any[]): void {\n    if (this.debug) {\n      console.log(`[PGLiteSocketHandler#${this.id}] ${message}`, ...args)\n    }\n  }\n\n  /**\n   * Attach a socket to this handler\n   * @param socket The socket to attach\n   * @returns this handler instance\n   * @throws Error if a socket is already attached\n   */\n  public async attach(socket: Socket): Promise<PGLiteSocketHandler> {\n    this.log(\n      `attach: attaching socket from ${socket.remoteAddress}:${socket.remotePort}`,\n    )\n\n    if (this.socket) {\n      throw new Error('Socket already attached')\n    }\n\n    this.socket = socket\n    this.active = true\n\n    // Ensure the PGlite instance is ready\n    this.log(`attach: waiting for PGlite to be ready`)\n    await this.db.waitReady\n\n    // Hold the lock on the PGlite instance\n    this.log(`attach: acquiring exclusive lock on PGlite instance`)\n    await new Promise<void>((resolve) => {\n      this.db.runExclusive(() => {\n        // Ensure we have the lock on the PGlite instance\n        resolve()\n\n        // Use a promise to hold the lock on the PGlite instance\n        // this can be resolved or rejected by the handler to release the lock\n        return new Promise<void>((resolveLock, rejectLock) => {\n          this.resolveLock = resolveLock\n          this.rejectLock = rejectLock\n        })\n      })\n    })\n\n    // Setup event handlers\n    this.log(`attach: setting up socket event handlers`)\n    socket.on('data', async (data) => {\n      try {\n        const result = await this.handleData(data)\n        this.log(`socket on data sent: ${result} bytes`)\n      } catch (err) {\n        this.log('socket on data error: ', err)\n      }\n    })\n    socket.on('error', (err) => this.handleError(err))\n    socket.on('close', () => this.handleClose())\n\n    return this\n  }\n\n  /**\n   * Detach the current socket from this handler\n   * @param close Whether to close the socket when detaching (overrides constructor option)\n   * @returns this handler instance\n   */\n  public detach(close?: boolean): PGLiteSocketHandler {\n    this.log(`detach: detaching socket, close=${close ?? this.closeOnDetach}`)\n\n    if (!this.socket) {\n      this.log(`detach: no socket attached, nothing to do`)\n      return this\n    }\n\n    // Remove all listeners\n    this.socket.removeAllListeners('data')\n    this.socket.removeAllListeners('error')\n    this.socket.removeAllListeners('close')\n\n    // Close the socket if requested\n    if (close ?? this.closeOnDetach) {\n      if (this.socket.writable) {\n        this.log(`detach: closing socket`)\n        this.socket.end()\n        this.socket.destroy()\n      }\n    }\n\n    // Release the lock on the PGlite instance\n    this.log(`detach: releasing exclusive lock on PGlite instance`)\n    this.resolveLock?.()\n\n    this.socket = null\n    this.active = false\n    return this\n  }\n\n  /**\n   * Check if a socket is currently attached\n   */\n  public get isAttached(): boolean {\n    return this.socket !== null\n  }\n\n  /**\n   * Handle incoming data from the socket\n   */\n  private async handleData(data: Buffer): Promise<number> {\n    if (!this.socket || !this.active) {\n      this.log(`handleData: no active socket, ignoring data`)\n      return new Promise((_, reject) => reject(`no active socket`))\n    }\n\n    this.log(`handleData: received ${data.length} bytes`)\n\n    // Print the incoming data to the console\n    this.inspectData('incoming', data)\n\n    try {\n      // Process the raw protocol data\n      this.log(`handleData: sending data to PGlite for processing`)\n      const result = await this.db.execProtocolRaw(new Uint8Array(data))\n\n      this.log(`handleData: received ${result.length} bytes from PGlite`)\n\n      // Print the outgoing data to the console\n      this.inspectData('outgoing', result)\n\n      // Send the result back if the socket is still connected\n      if (this.socket && this.socket.writable && this.active) {\n        if (result.length <= 0) {\n          this.log(`handleData: cowardly refusing to send empty packet`)\n          return new Promise((_, reject) => reject('no data'))\n        }\n\n        const promise = new Promise<number>((resolve, reject) => {\n          this.log(`handleData: writing response to socket`)\n          if (this.socket) {\n            this.socket.write(Buffer.from(result), (err?: Error) => {\n              if (err) {\n                reject(`Error while writing to the socket ${err.toString()}`)\n              } else {\n                resolve(result.length)\n              }\n            })\n          } else {\n            reject(`No socket`)\n          }\n        })\n\n        // Emit data event with byte sizes\n        this.dispatchEvent(\n          new CustomEvent('data', {\n            detail: { incoming: data.length, outgoing: result.length },\n          }),\n        )\n        return promise\n      } else {\n        this.log(\n          `handleData: socket no longer writable or active, discarding response`,\n        )\n        return new Promise((_, reject) =>\n          reject(`No socket, not active or not writeable`),\n        )\n      }\n    } catch (err) {\n      this.log(`handleData: error processing data:`, err)\n      this.handleError(err as Error)\n      return new Promise((_, reject) =>\n        reject(`Error while processing data ${(err as Error).toString()}`),\n      )\n    }\n  }\n\n  /**\n   * Handle errors from the socket\n   */\n  private handleError(err: Error): void {\n    this.log(`handleError:`, err)\n\n    // Emit error event\n    this.dispatchEvent(new CustomEvent('error', { detail: err }))\n\n    // Reject the lock on the PGlite instance\n    this.log(`handleError: rejecting exclusive lock on PGlite instance`)\n    this.rejectLock?.(err)\n    this.resolveLock = undefined\n    this.rejectLock = undefined\n\n    // Close the connection on error\n    this.detach(true)\n  }\n\n  /**\n   * Handle socket close event\n   */\n  private handleClose(): void {\n    this.log(`handleClose: socket closed`)\n\n    this.dispatchEvent(new CustomEvent('close'))\n    this.detach(false) // Already closed, just clean up\n  }\n\n  /**\n   * Print data in hex and ascii to the console\n   */\n  private inspectData(\n    direction: 'incoming' | 'outgoing',\n    data: Buffer | Uint8Array,\n  ): void {\n    if (!this.inspect) return\n    console.log('-'.repeat(75))\n    if (direction === 'incoming') {\n      console.log('-> incoming', data.length, 'bytes')\n    } else {\n      console.log('<- outgoing', data.length, 'bytes')\n    }\n\n    // Process 16 bytes per line\n    for (let offset = 0; offset < data.length; offset += 16) {\n      // Calculate current chunk size (may be less than 16 for the last chunk)\n      const chunkSize = Math.min(16, data.length - offset)\n\n      // Build the hex representation\n      let hexPart = ''\n      for (let i = 0; i < 16; i++) {\n        if (i < chunkSize) {\n          const byte = data[offset + i]\n          hexPart += byte.toString(16).padStart(2, '0') + ' '\n        } else {\n          hexPart += '   ' // 3 spaces for missing bytes\n        }\n      }\n\n      // Build the ASCII representation\n      let asciiPart = ''\n      for (let i = 0; i < chunkSize; i++) {\n        const byte = data[offset + i]\n        // Use printable characters (32-126), replace others with a dot\n        asciiPart += byte >= 32 && byte <= 126 ? String.fromCharCode(byte) : '.'\n      }\n\n      // Print the line with offset in hex, hex values, and ASCII representation\n      console.log(\n        `${offset.toString(16).padStart(8, '0')}  ${hexPart} ${asciiPart}`,\n      )\n    }\n  }\n}\n\n/**\n * Represents a queued connection with timeout\n */\ninterface QueuedConnection {\n  socket: Socket\n  clientInfo: {\n    clientAddress: string\n    clientPort: number\n  }\n  timeoutId: NodeJS.Timeout\n}\n\n/**\n * Options for creating a PGLiteSocketServer\n */\nexport interface PGLiteSocketServerOptions {\n  /** The PGlite database instance */\n  db: PGlite\n  /** The port to listen on (default: 5432) */\n  port?: number\n  /** The host to bind to (default: 127.0.0.1) */\n  host?: string\n  /** Unix socket path to bind to (default: undefined). If specified, takes precedence over host:port */\n  path?: string\n  /** Print the incoming and outgoing data to the console in hex and ascii */\n  inspect?: boolean\n  /** Connection queue timeout in milliseconds (default: 10000) */\n  connectionQueueTimeout?: number\n  /** Enable debug logging of method calls */\n  debug?: boolean\n}\n\n/**\n * High-level server that manages socket connections to PGLite\n * Creates and manages a TCP server and handles client connections\n */\nexport class PGLiteSocketServer extends EventTarget {\n  readonly db: PGlite\n  private server: Server | null = null\n  private port?: number\n  private host?: string\n  private path?: string\n  private active = false\n  private inspect: boolean\n  private debug: boolean\n  private connectionQueueTimeout: number\n  private activeHandler: PGLiteSocketHandler | null = null\n  private connectionQueue: QueuedConnection[] = []\n  private handlerCount: number = 0\n\n  /**\n   * Create a new PGLiteSocketServer\n   * @param options Options for the server\n   */\n  constructor(options: PGLiteSocketServerOptions) {\n    super()\n    this.db = options.db\n    if (options.path) {\n      this.path = options.path\n    } else {\n      if (typeof options.port === 'number') {\n        // Keep port undefined on port 0, will be set by the OS when we start the server.\n        this.port = options.port ?? options.port\n      } else {\n        this.port = 5432\n      }\n      this.host = options.host || '127.0.0.1'\n    }\n    this.inspect = options.inspect ?? false\n    this.debug = options.debug ?? false\n    this.connectionQueueTimeout =\n      options.connectionQueueTimeout ?? CONNECTION_QUEUE_TIMEOUT\n\n    this.log(`constructor: created server on ${this.host}:${this.port}`)\n    this.log(\n      `constructor: connection queue timeout: ${this.connectionQueueTimeout}ms`,\n    )\n  }\n\n  /**\n   * Log a message if debug is enabled\n   * @private\n   */\n  private log(message: string, ...args: any[]): void {\n    if (this.debug) {\n      console.log(`[PGLiteSocketServer] ${message}`, ...args)\n    }\n  }\n\n  /**\n   * Start the socket server\n   * @returns Promise that resolves when the server is listening\n   */\n  public async start(): Promise<void> {\n    this.log(`start: starting server on ${this.getServerConn()}`)\n\n    if (this.server) {\n      throw new Error('Socket server already started')\n    }\n\n    this.active = true\n    this.server = createServer((socket) => this.handleConnection(socket))\n\n    return new Promise<void>((resolve, reject) => {\n      if (!this.server) return reject(new Error('Server not initialized'))\n\n      this.server.on('error', (err) => {\n        this.log(`start: server error:`, err)\n        this.dispatchEvent(new CustomEvent('error', { detail: err }))\n        reject(err)\n      })\n\n      if (this.path) {\n        this.server.listen(this.path, () => {\n          this.log(`start: server listening on ${this.getServerConn()}`)\n          this.dispatchEvent(\n            new CustomEvent('listening', {\n              detail: { path: this.path },\n            }),\n          )\n          resolve()\n        })\n      } else {\n        const server = this.server\n        server.listen(this.port, this.host, () => {\n          const address = server.address()\n          // We are not using pipes, so return type should be AddressInfo\n          if (address === null || typeof address !== 'object') {\n            throw Error('Expected address info')\n          }\n          // Assign the new port number\n          this.port = address.port\n          this.log(`start: server listening on ${this.getServerConn()}`)\n          this.dispatchEvent(\n            new CustomEvent('listening', {\n              detail: { port: this.port, host: this.host },\n            }),\n          )\n          resolve()\n        })\n      }\n    })\n  }\n\n  public getServerConn(): string {\n    if (this.path) return this.path\n    return `${this.host}:${this.port}`\n  }\n\n  /**\n   * Stop the socket server\n   * @returns Promise that resolves when the server is closed\n   */\n  public async stop(): Promise<void> {\n    this.log(`stop: stopping server`)\n\n    this.active = false\n\n    // Clear connection queue\n    this.log(\n      `stop: clearing connection queue (${this.connectionQueue.length} connections)`,\n    )\n\n    this.connectionQueue.forEach((queuedConn) => {\n      clearTimeout(queuedConn.timeoutId)\n      if (queuedConn.socket.writable) {\n        this.log(\n          `stop: closing queued connection from ${queuedConn.clientInfo.clientAddress}:${queuedConn.clientInfo.clientPort}`,\n        )\n        queuedConn.socket.end()\n      }\n    })\n    this.connectionQueue = []\n\n    // Detach active handler if exists\n    if (this.activeHandler) {\n      this.log(`stop: detaching active handler #${this.activeHandlerId}`)\n      this.activeHandler.detach(true)\n      this.activeHandler = null\n    }\n\n    if (!this.server) {\n      this.log(`stop: server not running, nothing to do`)\n      return Promise.resolve()\n    }\n\n    return new Promise<void>((resolve) => {\n      if (!this.server) return resolve()\n\n      this.server.close(() => {\n        this.log(`stop: server closed`)\n        this.server = null\n        this.dispatchEvent(new CustomEvent('close'))\n        resolve()\n      })\n    })\n  }\n\n  /**\n   * Get the active handler ID, or null if no active handler\n   */\n  private get activeHandlerId(): number | null {\n    return this.activeHandler?.handlerId ?? null\n  }\n\n  /**\n   * Handle a new client connection\n   */\n  private async handleConnection(socket: Socket): Promise<void> {\n    const clientInfo = {\n      clientAddress: socket.remoteAddress || 'unknown',\n      clientPort: socket.remotePort || 0,\n    }\n\n    this.log(\n      `handleConnection: new connection from ${clientInfo.clientAddress}:${clientInfo.clientPort}`,\n    )\n\n    // If server is not active, close the connection immediately\n    if (!this.active) {\n      this.log(`handleConnection: server not active, closing connection`)\n      socket.end()\n      return\n    }\n\n    // If we don't have an active handler or it's not attached, we can use this connection immediately\n    if (!this.activeHandler || !this.activeHandler.isAttached) {\n      this.log(`handleConnection: no active handler, attaching socket directly`)\n      this.dispatchEvent(new CustomEvent('connection', { detail: clientInfo }))\n      await this.attachSocketToNewHandler(socket, clientInfo)\n      return\n    }\n\n    // Otherwise, queue the connection\n    this.log(\n      `handleConnection: active handler #${this.activeHandlerId} exists, queueing connection`,\n    )\n    this.enqueueConnection(socket, clientInfo)\n  }\n\n  /**\n   * Add a connection to the queue\n   */\n  private enqueueConnection(\n    socket: Socket,\n    clientInfo: { clientAddress: string; clientPort: number },\n  ): void {\n    this.log(\n      `enqueueConnection: queueing connection from ${clientInfo.clientAddress}:${clientInfo.clientPort}, timeout: ${this.connectionQueueTimeout}ms`,\n    )\n\n    // Set a timeout for this queued connection\n    const timeoutId = setTimeout(() => {\n      this.log(\n        `enqueueConnection: timeout for connection from ${clientInfo.clientAddress}:${clientInfo.clientPort}`,\n      )\n\n      // Remove from queue\n      this.connectionQueue = this.connectionQueue.filter(\n        (queuedConn) => queuedConn.socket !== socket,\n      )\n\n      // End the connection if it's still open\n      if (socket.writable) {\n        this.log(`enqueueConnection: closing timed out connection`)\n        socket.end()\n      }\n\n      this.dispatchEvent(\n        new CustomEvent('queueTimeout', {\n          detail: { ...clientInfo, queueSize: this.connectionQueue.length },\n        }),\n      )\n    }, this.connectionQueueTimeout)\n\n    // Add to queue\n    this.connectionQueue.push({ socket, clientInfo, timeoutId })\n\n    this.log(\n      `enqueueConnection: connection queued, queue size: ${this.connectionQueue.length}`,\n    )\n\n    this.dispatchEvent(\n      new CustomEvent('queuedConnection', {\n        detail: { ...clientInfo, queueSize: this.connectionQueue.length },\n      }),\n    )\n  }\n\n  /**\n   * Process the next connection in the queue\n   */\n  private processNextInQueue(): void {\n    this.log(\n      `processNextInQueue: processing next connection, queue size: ${this.connectionQueue.length}`,\n    )\n\n    // No connections in queue or server not active\n    if (this.connectionQueue.length === 0 || !this.active) {\n      this.log(\n        `processNextInQueue: no connections in queue or server not active, nothing to do`,\n      )\n      return\n    }\n\n    // Get the next connection\n    const nextConn = this.connectionQueue.shift()\n    if (!nextConn) return\n\n    this.log(\n      `processNextInQueue: processing connection from ${nextConn.clientInfo.clientAddress}:${nextConn.clientInfo.clientPort}`,\n    )\n\n    // Clear the timeout\n    clearTimeout(nextConn.timeoutId)\n\n    // Check if the socket is still valid\n    if (!nextConn.socket.writable) {\n      this.log(\n        `processNextInQueue: socket no longer writable, skipping to next connection`,\n      )\n      // Socket closed while waiting, process next in queue\n      this.processNextInQueue()\n      return\n    }\n\n    // Attach this socket to a new handler\n    this.attachSocketToNewHandler(nextConn.socket, nextConn.clientInfo).catch(\n      (err) => {\n        this.log(`processNextInQueue: error attaching socket:`, err)\n        this.dispatchEvent(new CustomEvent('error', { detail: err }))\n        // Try the next connection\n        this.processNextInQueue()\n      },\n    )\n  }\n\n  /**\n   * Attach a socket to a new handler\n   */\n  private async attachSocketToNewHandler(\n    socket: Socket,\n    clientInfo: { clientAddress: string; clientPort: number },\n  ): Promise<void> {\n    this.handlerCount++\n\n    this.log(\n      `attachSocketToNewHandler: creating new handler for ${clientInfo.clientAddress}:${clientInfo.clientPort} (handler #${this.handlerCount})`,\n    )\n\n    // Create a new handler for this connection\n    const handler = new PGLiteSocketHandler({\n      db: this.db,\n      closeOnDetach: true,\n      inspect: this.inspect,\n      debug: this.debug,\n    })\n\n    // Forward error events from the handler\n    handler.addEventListener('error', (event) => {\n      this.log(\n        `handler #${handler.handlerId}: error from handler:`,\n        (event as CustomEvent<Error>).detail,\n      )\n      this.dispatchEvent(\n        new CustomEvent('error', {\n          detail: (event as CustomEvent<Error>).detail,\n        }),\n      )\n    })\n\n    // Handle close event to process next queued connection\n    handler.addEventListener('close', () => {\n      this.log(`handler #${handler.handlerId}: closed`)\n\n      // If this is our active handler, clear it\n      if (this.activeHandler === handler) {\n        this.log(\n          `handler #${handler.handlerId}: was active handler, processing next connection in queue`,\n        )\n        this.activeHandler = null\n        // Process next connection in queue\n        this.processNextInQueue()\n      }\n    })\n\n    try {\n      // Set as active handler\n      this.activeHandler = handler\n\n      this.log(`handler #${handler.handlerId}: attaching socket`)\n\n      // Attach the socket to the handler\n      await handler.attach(socket)\n\n      this.dispatchEvent(new CustomEvent('connection', { detail: clientInfo }))\n    } catch (err) {\n      // If there was an error attaching, clean up\n      this.log(`handler #${handler.handlerId}: error attaching socket:`, err)\n      this.activeHandler = null\n      if (socket.writable) {\n        socket.end()\n      }\n      throw err\n    }\n  }\n}\n"],"mappings":"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","names":["createServer","CONNECTION_QUEUE_TIMEOUT","_PGLiteSocketHandler","options","message","args","socket","resolve","resolveLock","rejectLock","data","result","err","close","_","reject","promise","direction","offset","chunkSize","hexPart","i","byte","asciiPart","PGLiteSocketHandler","PGLiteSocketServer","server","address","queuedConn","clientInfo","timeoutId","nextConn","handler","event"]}

package/dist/dist-LCVVJCGI.js

@@ -0,0 +1,570 @@
+import "./chunk-7D4SUZUM.js";
+
+// ../../../node_modules/.pnpm/@hono+node-server@1.19.7_hono@4.11.1/node_modules/@hono/node-server/dist/index.mjs
+import { createServer as createServerHTTP } from "http";
+import { Http2ServerRequest as Http2ServerRequest2 } from "http2";
+import { Http2ServerRequest } from "http2";
+import { Readable } from "stream";
+import crypto from "crypto";
+var RequestError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RequestError";
+  }
+};
+var toRequestError = (e) => {
+  if (e instanceof RequestError) {
+    return e;
+  }
+  return new RequestError(e.message, { cause: e });
+};
+var GlobalRequest = global.Request;
+var Request = class extends GlobalRequest {
+  constructor(input, options) {
+    if (typeof input === "object" && getRequestCache in input) {
+      input = input[getRequestCache]();
+    }
+    if (typeof options?.body?.getReader !== "undefined") {
+      ;
+      options.duplex ??= "half";
+    }
+    super(input, options);
+  }
+};
+var newHeadersFromIncoming = (incoming) => {
+  const headerRecord = [];
+  const rawHeaders = incoming.rawHeaders;
+  for (let i = 0; i < rawHeaders.length; i += 2) {
+    const { [i]: key, [i + 1]: value } = rawHeaders;
+    if (key.charCodeAt(0) !== /*:*/
+    58) {
+      headerRecord.push([key, value]);
+    }
+  }
+  return new Headers(headerRecord);
+};
+var wrapBodyStream = Symbol("wrapBodyStream");
+var newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
+  const init = {
+    method,
+    headers,
+    signal: abortController.signal
+  };
+  if (method === "TRACE") {
+    init.method = "GET";
+    const req = new Request(url, init);
+    Object.defineProperty(req, "method", {
+      get() {
+        return "TRACE";
+      }
+    });
+    return req;
+  }
+  if (!(method === "GET" || method === "HEAD")) {
+    if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) {
+      init.body = new ReadableStream({
+        start(controller) {
+          controller.enqueue(incoming.rawBody);
+          controller.close();
+        }
+      });
+    } else if (incoming[wrapBodyStream]) {
+      let reader;
+      init.body = new ReadableStream({
+        async pull(controller) {
+          try {
+            reader ||= Readable.toWeb(incoming).getReader();
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      });
+    } else {
+      init.body = Readable.toWeb(incoming);
+    }
+  }
+  return new Request(url, init);
+};
+var getRequestCache = Symbol("getRequestCache");
+var requestCache = Symbol("requestCache");
+var incomingKey = Symbol("incomingKey");
+var urlKey = Symbol("urlKey");
+var headersKey = Symbol("headersKey");
+var abortControllerKey = Symbol("abortControllerKey");
+var getAbortController = Symbol("getAbortController");
+var requestPrototype = {
+  get method() {
+    return this[incomingKey].method || "GET";
+  },
+  get url() {
+    return this[urlKey];
+  },
+  get headers() {
+    return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
+  },
+  [getAbortController]() {
+    this[getRequestCache]();
+    return this[abortControllerKey];
+  },
+  [getRequestCache]() {
+    this[abortControllerKey] ||= new AbortController();
+    return this[requestCache] ||= newRequestFromIncoming(
+      this.method,
+      this[urlKey],
+      this.headers,
+      this[incomingKey],
+      this[abortControllerKey]
+    );
+  }
+};
+[
+  "body",
+  "bodyUsed",
+  "cache",
+  "credentials",
+  "destination",
+  "integrity",
+  "mode",
+  "redirect",
+  "referrer",
+  "referrerPolicy",
+  "signal",
+  "keepalive"
+].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, {
+    get() {
+      return this[getRequestCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, {
+    value: function() {
+      return this[getRequestCache]()[k]();
+    }
+  });
+});
+Object.setPrototypeOf(requestPrototype, Request.prototype);
+var newRequest = (incoming, defaultHostname) => {
+  const req = Object.create(requestPrototype);
+  req[incomingKey] = incoming;
+  const incomingUrl = incoming.url || "";
+  if (incomingUrl[0] !== "/" && // short-circuit for performance. most requests are relative URL.
+  (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
+    if (incoming instanceof Http2ServerRequest) {
+      throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
+    }
+    try {
+      const url2 = new URL(incomingUrl);
+      req[urlKey] = url2.href;
+    } catch (e) {
+      throw new RequestError("Invalid absolute URL", { cause: e });
+    }
+    return req;
+  }
+  const host = (incoming instanceof Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
+  if (!host) {
+    throw new RequestError("Missing host header");
+  }
+  let scheme;
+  if (incoming instanceof Http2ServerRequest) {
+    scheme = incoming.scheme;
+    if (!(scheme === "http" || scheme === "https")) {
+      throw new RequestError("Unsupported scheme");
+    }
+  } else {
+    scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
+  }
+  const url = new URL(`${scheme}://${host}${incomingUrl}`);
+  if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
+    throw new RequestError("Invalid host header");
+  }
+  req[urlKey] = url.href;
+  return req;
+};
+var responseCache = Symbol("responseCache");
+var getResponseCache = Symbol("getResponseCache");
+var cacheKey = Symbol("cache");
+var GlobalResponse = global.Response;
+var Response2 = class _Response {
+  #body;
+  #init;
+  [getResponseCache]() {
+    delete this[cacheKey];
+    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+  }
+  constructor(body, init) {
+    let headers;
+    this.#body = body;
+    if (init instanceof _Response) {
+      const cachedGlobalResponse = init[responseCache];
+      if (cachedGlobalResponse) {
+        this.#init = cachedGlobalResponse;
+        this[getResponseCache]();
+        return;
+      } else {
+        this.#init = init.#init;
+        headers = new Headers(init.#init.headers);
+      }
+    } else {
+      this.#init = init;
+    }
+    if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
+      headers ||= init?.headers || { "content-type": "text/plain; charset=UTF-8" };
+      this[cacheKey] = [init?.status || 200, body, headers];
+    }
+  }
+  get headers() {
+    const cache = this[cacheKey];
+    if (cache) {
+      if (!(cache[2] instanceof Headers)) {
+        cache[2] = new Headers(cache[2]);
+      }
+      return cache[2];
+    }
+    return this[getResponseCache]().headers;
+  }
+  get status() {
+    return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+  }
+  get ok() {
+    const status = this.status;
+    return status >= 200 && status < 300;
+  }
+};
+["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    get() {
+      return this[getResponseCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    value: function() {
+      return this[getResponseCache]()[k]();
+    }
+  });
+});
+Object.setPrototypeOf(Response2, GlobalResponse);
+Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const cancel = (error) => {
+    reader.cancel(error).catch(() => {
+    });
+  };
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+  });
+  function handleStreamError(error) {
+    if (error) {
+      writable.destroy(error);
+    }
+  }
+  function onDrain() {
+    reader.read().then(flow, handleStreamError);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (!writable.write(value)) {
+        writable.once("drain", onDrain);
+      } else {
+        return reader.read().then(flow, handleStreamError);
+      }
+    } catch (e) {
+      handleStreamError(e);
+    }
+  }
+}
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
+var buildOutgoingHttpHeaders = (headers) => {
+  const res = {};
+  if (!(headers instanceof Headers)) {
+    headers = new Headers(headers ?? void 0);
+  }
+  const cookies = [];
+  for (const [k, v] of headers) {
+    if (k === "set-cookie") {
+      cookies.push(v);
+    } else {
+      res[k] = v;
+    }
+  }
+  if (cookies.length > 0) {
+    res["set-cookie"] = cookies;
+  }
+  res["content-type"] ??= "text/plain; charset=UTF-8";
+  return res;
+};
+var X_ALREADY_SENT = "x-hono-already-sent";
+var webFetch = global.fetch;
+if (typeof global.crypto === "undefined") {
+  global.crypto = crypto;
+}
+global.fetch = (info, init) => {
+  init = {
+    // Disable compression handling so people can return the result of a fetch
+    // directly in the loader without messing with the Content-Encoding header.
+    compress: false,
+    ...init
+  };
+  return webFetch(info, init);
+};
+var outgoingEnded = Symbol("outgoingEnded");
+var handleRequestError = () => new Response(null, {
+  status: 400
+});
+var handleFetchError = (e) => new Response(null, {
+  status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
+});
+var handleResponseError = (e, outgoing) => {
+  const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
+  if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
+    console.info("The user aborted a request.");
+  } else {
+    console.error(e);
+    if (!outgoing.headersSent) {
+      outgoing.writeHead(500, { "Content-Type": "text/plain" });
+    }
+    outgoing.end(`Error: ${err.message}`);
+    outgoing.destroy(err);
+  }
+};
+var flushHeaders = (outgoing) => {
+  if ("flushHeaders" in outgoing && outgoing.writable) {
+    outgoing.flushHeaders();
+  }
+};
+var responseViaCache = async (res, outgoing) => {
+  let [status, body, header] = res[cacheKey];
+  if (header instanceof Headers) {
+    header = buildOutgoingHttpHeaders(header);
+  }
+  if (typeof body === "string") {
+    header["Content-Length"] = Buffer.byteLength(body);
+  } else if (body instanceof Uint8Array) {
+    header["Content-Length"] = body.byteLength;
+  } else if (body instanceof Blob) {
+    header["Content-Length"] = body.size;
+  }
+  outgoing.writeHead(status, header);
+  if (typeof body === "string" || body instanceof Uint8Array) {
+    outgoing.end(body);
+  } else if (body instanceof Blob) {
+    outgoing.end(new Uint8Array(await body.arrayBuffer()));
+  } else {
+    flushHeaders(outgoing);
+    await writeFromReadableStream(body, outgoing)?.catch(
+      (e) => handleResponseError(e, outgoing)
+    );
+  }
+  ;
+  outgoing[outgoingEnded]?.();
+};
+var isPromise = (res) => typeof res.then === "function";
+var responseViaResponseObject = async (res, outgoing, options = {}) => {
+  if (isPromise(res)) {
+    if (options.errorHandler) {
+      try {
+        res = await res;
+      } catch (err) {
+        const errRes = await options.errorHandler(err);
+        if (!errRes) {
+          return;
+        }
+        res = errRes;
+      }
+    } else {
+      res = await res.catch(handleFetchError);
+    }
+  }
+  if (cacheKey in res) {
+    return responseViaCache(res, outgoing);
+  }
+  const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+  if (res.body) {
+    const reader = res.body.getReader();
+    const values = [];
+    let done = false;
+    let currentReadPromise = void 0;
+    if (resHeaderRecord["transfer-encoding"] !== "chunked") {
+      let maxReadCount = 2;
+      for (let i = 0; i < maxReadCount; i++) {
+        currentReadPromise ||= reader.read();
+        const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+          console.error(e);
+          done = true;
+        });
+        if (!chunk) {
+          if (i === 1) {
+            await new Promise((resolve) => setTimeout(resolve));
+            maxReadCount = 3;
+            continue;
+          }
+          break;
+        }
+        currentReadPromise = void 0;
+        if (chunk.value) {
+          values.push(chunk.value);
+        }
+        if (chunk.done) {
+          done = true;
+          break;
+        }
+      }
+      if (done && !("content-length" in resHeaderRecord)) {
+        resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+      }
+    }
+    outgoing.writeHead(res.status, resHeaderRecord);
+    values.forEach((value) => {
+      ;
+      outgoing.write(value);
+    });
+    if (done) {
+      outgoing.end();
+    } else {
+      if (values.length === 0) {
+        flushHeaders(outgoing);
+      }
+      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
+    }
+  } else if (resHeaderRecord[X_ALREADY_SENT]) {
+  } else {
+    outgoing.writeHead(res.status, resHeaderRecord);
+    outgoing.end();
+  }
+  ;
+  outgoing[outgoingEnded]?.();
+};
+var getRequestListener = (fetchCallback, options = {}) => {
+  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
+  if (options.overrideGlobalObjects !== false && global.Request !== Request) {
+    Object.defineProperty(global, "Request", {
+      value: Request
+    });
+    Object.defineProperty(global, "Response", {
+      value: Response2
+    });
+  }
+  return async (incoming, outgoing) => {
+    let res, req;
+    try {
+      req = newRequest(incoming, options.hostname);
+      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+      if (!incomingEnded) {
+        ;
+        incoming[wrapBodyStream] = true;
+        incoming.on("end", () => {
+          incomingEnded = true;
+        });
+        if (incoming instanceof Http2ServerRequest2) {
+          ;
+          outgoing[outgoingEnded] = () => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    incoming.destroy();
+                    outgoing.destroy();
+                  });
+                }
+              });
+            }
+          };
+        }
+      }
+      outgoing.on("close", () => {
+        const abortController = req[abortControllerKey];
+        if (abortController) {
+          if (incoming.errored) {
+            req[abortControllerKey].abort(incoming.errored.toString());
+          } else if (!outgoing.writableFinished) {
+            req[abortControllerKey].abort("Client connection prematurely closed.");
+          }
+        }
+        if (!incomingEnded) {
+          setTimeout(() => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                incoming.destroy();
+              });
+            }
+          });
+        }
+      });
+      res = fetchCallback(req, { incoming, outgoing });
+      if (cacheKey in res) {
+        return responseViaCache(res, outgoing);
+      }
+    } catch (e) {
+      if (!res) {
+        if (options.errorHandler) {
+          res = await options.errorHandler(req ? e : toRequestError(e));
+          if (!res) {
+            return;
+          }
+        } else if (!req) {
+          res = handleRequestError();
+        } else {
+          res = handleFetchError(e);
+        }
+      } else {
+        return handleResponseError(e, outgoing);
+      }
+    }
+    try {
+      return await responseViaResponseObject(res, outgoing, options);
+    } catch (e) {
+      return handleResponseError(e, outgoing);
+    }
+  };
+};
+var createAdaptorServer = (options) => {
+  const fetchCallback = options.fetch;
+  const requestListener = getRequestListener(fetchCallback, {
+    hostname: options.hostname,
+    overrideGlobalObjects: options.overrideGlobalObjects,
+    autoCleanupIncoming: options.autoCleanupIncoming
+  });
+  const createServer = options.createServer || createServerHTTP;
+  const server = createServer(options.serverOptions || {}, requestListener);
+  return server;
+};
+var serve = (options, listeningListener) => {
+  const server = createAdaptorServer(options);
+  server.listen(options?.port ?? 3e3, options.hostname, () => {
+    const serverInfo = server.address();
+    listeningListener && listeningListener(serverInfo);
+  });
+  return server;
+};
+export {
+  RequestError,
+  createAdaptorServer,
+  getRequestListener,
+  serve
+};
+//# sourceMappingURL=dist-LCVVJCGI.js.map