@cequrebackends/cequre-ts 0.11.4

package/dist/adapters/node/index.js

@@ -0,0 +1,902 @@
+// @bun
+import {
+  CequreQueueManager,
+  exports_logger,
+  init_logger,
+  logger
+} from "../../index-rf1kdn5b.js";
+import {
+  CequreError,
+  __toCommonJS,
+  ulid
+} from "../../index-17yswtmg.js";
+
+// adapters/node/node-server.ts
+import http from "http";
+import https from "https";
+import fs from "fs";
+import { createServerAdapter } from "@whatwg-node/server";
+function compilePathRegex(path) {
+  let regexStr = "^" + path.replace(/\/?\*/g, "(?:/.*)?").replace(/:([a-zA-Z0-9_]+)/g, "(?<$1>[^/]+)");
+  if (!regexStr.endsWith(")?") && !regexStr.endsWith(".*")) {
+    regexStr += "$";
+  }
+  return new RegExp(regexStr);
+}
+
+class NodeServerProvider {
+  server = null;
+  start(config) {
+    const routeMatchers = [];
+    if (config.routes) {
+      for (const path of Object.keys(config.routes)) {
+        routeMatchers.push({ path, regex: compilePathRegex(path) });
+      }
+    }
+    const fetchHandler = async (req) => {
+      const url = new URL(req.url);
+      let handler = config.routes?.[url.pathname]?.[req.method] || config.routes?.[url.pathname]?.["ALL"];
+      if (!handler && routeMatchers.length > 0) {
+        for (const matcher of routeMatchers) {
+          const match = url.pathname.match(matcher.regex);
+          if (match) {
+            const h = config.routes[matcher.path]?.[req.method] || config.routes[matcher.path]?.["ALL"];
+            if (h) {
+              handler = h;
+              req.params = match.groups || {};
+              break;
+            }
+          }
+        }
+      }
+      if (handler) {
+        return handler(req, this.server);
+      }
+      return config.fetch(req, this.server);
+    };
+    const adapter = createServerAdapter(fetchHandler);
+    if (config.tls?.cert && config.tls?.key) {
+      this.server = https.createServer({
+        cert: fs.readFileSync(config.tls.cert),
+        key: fs.readFileSync(config.tls.key)
+      }, adapter);
+    } else {
+      this.server = http.createServer(adapter);
+    }
+    const port = config.port ?? (process.env.PORT ? parseInt(process.env.PORT, 10) : 3000);
+    this.server.listen(port, config.hostname);
+    this.server.on("upgrade", (req, socket, head) => {
+      const protocol = config.tls ? "https" : "http";
+      const host = req.headers.host || config.hostname || "localhost";
+      const url = `${protocol}://${host}${req.url}`;
+      const headers = new Headers;
+      for (const [key, value] of Object.entries(req.headers)) {
+        if (value !== undefined) {
+          if (Array.isArray(value)) {
+            value.forEach((v) => headers.append(key, v));
+          } else {
+            headers.set(key, value);
+          }
+        }
+      }
+      const webReq = new Request(url, {
+        method: req.method,
+        headers
+      });
+      webReq.rawNodeReq = req;
+      webReq.rawNodeSocket = socket;
+      webReq.rawNodeHead = head;
+      Promise.resolve(config.fetch(webReq, this.server)).catch((err) => {
+        console.error("Cequre node upgrade handler error:", err);
+        socket.destroy();
+      });
+    });
+    console.log(`\uD83D\uDE80 Cequre starting on http://${config.hostname || "localhost"}:${port}`);
+    const serverObj = this.server;
+    serverObj.stop = this.stop.bind(this);
+    return serverObj;
+  }
+  async stop() {
+    if (this.server) {
+      if (typeof this.server.closeAllConnections === "function") {
+        this.server.closeAllConnections();
+      }
+      await new Promise((resolve) => {
+        this.server.close(() => {
+          resolve();
+        });
+      });
+    }
+  }
+}
+// adapters/node/node-cron.ts
+import cron from "node-cron";
+init_logger();
+
+class NodeCronProvider {
+  localJobs = new Map;
+  useBullMQ = false;
+  constructor() {
+    try {
+      CequreQueueManager.getInstance();
+      this.useBullMQ = true;
+    } catch {
+      this.useBullMQ = false;
+    }
+  }
+  registerJob(name, schedule, handler) {
+    if (this.useBullMQ) {
+      const qm = CequreQueueManager.getInstance();
+      qm.registerWorker("cequre_cron", async (job) => {
+        if (job.name === name) {
+          try {
+            await Promise.resolve(handler());
+          } catch (err) {
+            logger.error(err, `[Cequre Cron (BullMQ)] Job "${name}" failed:`);
+            throw new Error(String(err instanceof Error ? err.message : err));
+          }
+        }
+      }).catch((err) => {
+        logger.error(err, `[Cequre Cron (BullMQ)] Failed to register worker for "${name}":`);
+      });
+      qm.addJob("cequre_cron", name, {}, {
+        repeat: { pattern: schedule },
+        jobId: `cron_${name}`,
+        removeOnComplete: true,
+        removeOnFail: 100
+      }).catch((err) => {
+        logger.error(err, `[Cequre Cron (BullMQ)] Failed to register job "${name}":`);
+      });
+    } else {
+      if (this.localJobs.has(name)) {
+        throw CequreError.Conflict(`[Cequre Cron] A cron job with the name "${name}" is already registered.`);
+      }
+      const job = cron.schedule(schedule, async () => {
+        try {
+          await handler();
+        } catch (err) {
+          logger.error(err, `[Cequre Cron] Job "${name}" failed:`);
+        }
+      });
+      this.localJobs.set(name, job);
+    }
+  }
+  async stop(name) {
+    if (this.useBullMQ) {
+      const qm = CequreQueueManager.getInstance();
+      const queue = qm.getQueue("cequre_cron");
+      const repeatableJobs = await queue.getRepeatableJobs();
+      const job = repeatableJobs.find((j) => j.name === name);
+      if (job) {
+        await queue.removeRepeatableByKey(job.key);
+        return true;
+      }
+      return false;
+    } else {
+      const job = this.localJobs.get(name);
+      if (job && typeof job.stop === "function") {
+        job.stop();
+        this.localJobs.delete(name);
+        return true;
+      }
+      return false;
+    }
+  }
+  async stopAll() {
+    if (this.useBullMQ) {
+      const qm = CequreQueueManager.getInstance();
+      const queue = qm.getQueue("cequre_cron");
+      const repeatableJobs = await queue.getRepeatableJobs();
+      for (const job of repeatableJobs) {
+        await queue.removeRepeatableByKey(job.key);
+      }
+    } else {
+      for (const [name, job] of this.localJobs.entries()) {
+        if (typeof job.stop === "function") {
+          try {
+            job.stop();
+          } catch (e) {
+            logger.error(e, `[Cequre Cron] Error stopping job "${name}":`);
+          }
+        }
+      }
+      this.localJobs.clear();
+    }
+  }
+  async list() {
+    if (this.useBullMQ) {
+      const qm = CequreQueueManager.getInstance();
+      const queue = qm.getQueue("cequre_cron");
+      const jobs = await queue.getRepeatableJobs();
+      return jobs.map((j) => j.name);
+    } else {
+      return Array.from(this.localJobs.keys());
+    }
+  }
+  startAll() {}
+}
+// adapters/node/node-websocket.ts
+import { WebSocketServer } from "ws";
+class NodeWebSocketManager {
+  connections = new Map;
+  rooms = new Map;
+  connectionRooms = new Map;
+  metadata = new Map;
+  lastPong = new Map;
+  heartbeatTimer = null;
+  register(ws) {
+    this.connections.set(ws.id, ws);
+    this.connectionRooms.set(ws.id, new Set);
+    this.metadata.set(ws.id, {});
+    this.lastPong.set(ws.id, Date.now());
+  }
+  remove(wsOrId) {
+    const id = typeof wsOrId === "string" ? wsOrId : wsOrId.id;
+    for (const room of this.connectionRooms.get(id) ?? []) {
+      this.leaveRoom(id, room);
+    }
+    this.connections.delete(id);
+    this.connectionRooms.delete(id);
+    this.metadata.delete(id);
+    this.lastPong.delete(id);
+  }
+  pong(id) {
+    if (this.lastPong.has(id))
+      this.lastPong.set(id, Date.now());
+  }
+  startHeartbeat(intervalMs = 30000, timeoutMs = 1e4) {
+    if (this.heartbeatTimer !== null)
+      return;
+    const deadline = intervalMs + timeoutMs;
+    this.heartbeatTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [id, lastSeen] of this.lastPong) {
+        if (now - lastSeen > deadline)
+          this.remove(id);
+      }
+      for (const ws of this.connections.values()) {
+        ws.send(JSON.stringify({ type: "ping" }));
+      }
+    }, intervalMs);
+    if (this.heartbeatTimer.unref)
+      this.heartbeatTimer.unref();
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer)
+      clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = null;
+  }
+  joinRoom(id, room) {
+    if (!this.rooms.has(room))
+      this.rooms.set(room, new Set);
+    this.rooms.get(room).add(id);
+    this.connectionRooms.get(id)?.add(room);
+  }
+  leaveRoom(id, room) {
+    this.rooms.get(room)?.delete(id);
+    if (this.rooms.get(room)?.size === 0)
+      this.rooms.delete(room);
+    this.connectionRooms.get(id)?.delete(room);
+  }
+  getRoomMembers(room) {
+    return [...this.rooms.get(room) ?? []];
+  }
+  getConnectionRooms(id) {
+    return [...this.connectionRooms.get(id) ?? []];
+  }
+  listRooms() {
+    return [...this.rooms.keys()];
+  }
+  sendTo(id, payload) {
+    const ws = this.connections.get(id);
+    if (!ws)
+      return false;
+    ws.send(JSON.stringify(payload));
+    return true;
+  }
+  broadcastToRoom(room, payload, { exclude = [] } = {}) {
+    const ids = this.rooms.get(room);
+    if (!ids)
+      return 0;
+    let sent = 0;
+    for (const id of ids) {
+      if (exclude.includes(id))
+        continue;
+      if (this.sendTo(id, payload))
+        sent++;
+    }
+    return sent;
+  }
+  broadcastAll(payload, { exclude = [] } = {}) {
+    let sent = 0;
+    for (const id of this.connections.keys()) {
+      if (exclude.includes(id))
+        continue;
+      if (this.sendTo(id, payload))
+        sent++;
+    }
+    return sent;
+  }
+  setMeta(id, key, value) {
+    const meta = this.metadata.get(id);
+    if (meta)
+      meta[key] = value;
+  }
+  getMeta(id, key) {
+    return this.metadata.get(id)?.[key];
+  }
+  get connectionCount() {
+    return this.connections.size;
+  }
+  get roomCount() {
+    return this.rooms.size;
+  }
+  getStats() {
+    return {
+      connections: this.connectionCount,
+      rooms: Object.fromEntries([...this.rooms.entries()].map(([room, ids]) => [room, ids.size])),
+      heartbeatActive: this.heartbeatTimer !== null
+    };
+  }
+}
+var wsManager = new NodeWebSocketManager;
+function parseMessage(message) {
+  if (typeof message !== "string") {
+    return { type: "binary", payload: message };
+  }
+  try {
+    const parsed = JSON.parse(message);
+    return parsed && typeof parsed === "object" ? parsed : { type: "message", payload: parsed };
+  } catch {
+    return { type: "message", payload: message };
+  }
+}
+function createWebSocketHandler({
+  heartbeat,
+  onJoinRoom
+} = {}) {
+  const startHeartbeat = () => {
+    if (heartbeat === false)
+      return;
+    wsManager.startHeartbeat(heartbeat?.interval, heartbeat?.timeout);
+  };
+  return {
+    open(wrapped) {
+      wsManager.register(wrapped);
+      startHeartbeat();
+      wrapped.send(JSON.stringify({ type: "connected", id: wrapped.id }));
+    },
+    async message(wrapped, rawMessage) {
+      const message = parseMessage(rawMessage);
+      const { id } = wrapped;
+      switch (message.type) {
+        case "join":
+          if (!message.room)
+            return;
+          if (onJoinRoom && !await onJoinRoom(message.room, wrapped)) {
+            wrapped.send(JSON.stringify({ type: "error", message: `Access denied to room '${message.room}'` }));
+            return;
+          }
+          wsManager.joinRoom(id, message.room);
+          wrapped.send(JSON.stringify({ type: "joined", room: message.room }));
+          return;
+        case "leave":
+          if (!message.room)
+            return;
+          wsManager.leaveRoom(id, message.room);
+          wrapped.send(JSON.stringify({ type: "left", room: message.room }));
+          return;
+        case "broadcast":
+          if (message.room) {
+            if (!wsManager.getConnectionRooms(id).includes(message.room)) {
+              wrapped.send(JSON.stringify({ type: "error", message: "Not in room" }));
+              return;
+            }
+            wsManager.broadcastToRoom(message.room, { type: "message", from: id, payload: message.payload }, { exclude: [id] });
+          }
+          return;
+        case "ping":
+          wrapped.send(JSON.stringify({ type: "pong" }));
+          return;
+        case "pong":
+          wsManager.pong(id);
+          return;
+        default:
+          wrapped.send(JSON.stringify({ type: "error", message: `Unknown type: ${message.type}` }));
+      }
+    },
+    close(wrapped) {
+      wsManager.remove(wrapped.id);
+    }
+  };
+}
+function createNodeWebSocketRoute({
+  path = "/ws",
+  heartbeat,
+  onJoinRoom
+} = {}) {
+  const handler = createWebSocketHandler({ heartbeat, onJoinRoom });
+  const wss = new WebSocketServer({ noServer: true });
+  wss.on("connection", (ws, req) => {
+    const id = ulid();
+    const wrapped = {
+      id,
+      data: {},
+      send: (message) => {
+        ws.send(message);
+        return typeof message === "string" ? Buffer.byteLength(message) : message.byteLength || 0;
+      }
+    };
+    if (handler.open)
+      handler.open(wrapped);
+    ws.on("message", (message) => {
+      if (handler.message)
+        handler.message(wrapped, message);
+    });
+    ws.on("close", (code, reason) => {
+      if (handler.close)
+        handler.close(wrapped, code, reason.toString());
+    });
+  });
+  return async (request, server) => {
+    const rawReq = request.rawNodeReq;
+    const socket = request.rawNodeSocket;
+    const head = request.rawNodeHead;
+    if (rawReq && socket && head) {
+      wss.handleUpgrade(rawReq, socket, head, (ws) => {
+        wss.emit("connection", ws, rawReq);
+      });
+      return;
+    }
+    return new Response(JSON.stringify({ message: "WebSocket upgrade failed or not an upgrade request" }), { status: 400 });
+  };
+}
+
+class CequreWebsocket {
+  static get manager() {
+    return wsManager;
+  }
+  static route(options = {}) {
+    return createNodeWebSocketRoute(options);
+  }
+  static handler(options = {}) {
+    return createWebSocketHandler(options);
+  }
+  static register(ws) {
+    return wsManager.register(ws);
+  }
+  static remove(wsOrId) {
+    return wsManager.remove(wsOrId);
+  }
+  static pong(id) {
+    return wsManager.pong(id);
+  }
+  static startHeartbeat(intervalMs, timeoutMs) {
+    return wsManager.startHeartbeat(intervalMs, timeoutMs);
+  }
+  static stopHeartbeat() {
+    return wsManager.stopHeartbeat();
+  }
+  static joinRoom(id, room) {
+    return wsManager.joinRoom(id, room);
+  }
+  static leaveRoom(id, room) {
+    return wsManager.leaveRoom(id, room);
+  }
+  static getRoomMembers(room) {
+    return wsManager.getRoomMembers(room);
+  }
+  static getConnectionRooms(id) {
+    return wsManager.getConnectionRooms(id);
+  }
+  static listRooms() {
+    return wsManager.listRooms();
+  }
+  static sendTo(id, payload) {
+    return wsManager.sendTo(id, payload);
+  }
+  static broadcastToRoom(room, payload, opts) {
+    return wsManager.broadcastToRoom(room, payload, opts);
+  }
+  static broadcastAll(payload, opts) {
+    return wsManager.broadcastAll(payload, opts);
+  }
+  static setMeta(id, key, value) {
+    return wsManager.setMeta(id, key, value);
+  }
+  static getMeta(id, key) {
+    return wsManager.getMeta(id, key);
+  }
+  static get connectionCount() {
+    return wsManager.connectionCount;
+  }
+  static get roomCount() {
+    return wsManager.roomCount;
+  }
+  static getStats() {
+    return wsManager.getStats();
+  }
+}
+// adapters/node/node-storage.ts
+import fs2 from "fs";
+import path from "path";
+class NodeLocalStorageProvider {
+  uploadDir;
+  apiPrefix;
+  constructor(uploadDir = "uploads", apiPrefix = "/api") {
+    this.apiPrefix = apiPrefix;
+    this.uploadDir = path.resolve(process.cwd(), uploadDir);
+    if (!fs2.existsSync(this.uploadDir)) {
+      fs2.mkdirSync(this.uploadDir, { recursive: true });
+    }
+  }
+  async saveFile(file, options) {
+    const ext = file.name ? path.extname(file.name) : "";
+    const safeName = options?.filename ? options.filename : `${ulid()}${ext}`;
+    const filePath = path.join(this.uploadDir, safeName);
+    const buffer = Buffer.from(await file.arrayBuffer());
+    await fs2.promises.writeFile(filePath, buffer);
+    return {
+      filename: safeName,
+      originalName: file.name || "upload",
+      mimetype: file.type || "application/octet-stream",
+      size: file.size,
+      url: `${this.apiPrefix}/uploads/${safeName}`
+    };
+  }
+  async deleteFile(filename) {
+    const filePath = path.join(this.uploadDir, filename);
+    try {
+      if (fs2.existsSync(filePath)) {
+        await fs2.promises.unlink(filePath);
+      }
+    } catch (e) {
+      console.error(`Failed to delete file ${filePath}`, e);
+    }
+  }
+}
+// adapters/node/node-redis-cache.ts
+import Redis from "ioredis";
+var _log = null;
+function getLog() {
+  if (!_log)
+    _log = (init_logger(), __toCommonJS(exports_logger)).createLogger("kv-redis");
+  return _log;
+}
+
+class RedisAdapter {
+  redis;
+  constructor(options) {
+    this.redis = new Redis(options?.url || process.env.REDIS_URL || "redis://localhost:6379");
+    getLog().debug("Redis KV adapter initialized (ioredis)");
+  }
+  async get(key) {
+    const value = await this.redis.get(key);
+    if (value === null)
+      return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  async getMany(keys) {
+    const result = new Map;
+    if (keys.length === 0)
+      return result;
+    const values = await this.redis.mget(...keys);
+    for (let i = 0;i < keys.length; i++) {
+      const key = keys[i];
+      if (key === undefined)
+        continue;
+      const value = values[i];
+      if (value !== null && value !== undefined) {
+        try {
+          result.set(key, JSON.parse(value));
+        } catch {
+          result.set(key, value);
+        }
+      }
+    }
+    return result;
+  }
+  async set(key, value, ttl) {
+    const serialized = JSON.stringify(value);
+    if (ttl != null && ttl > 0) {
+      await this.redis.setex(key, ttl, serialized);
+    } else {
+      await this.redis.set(key, serialized);
+    }
+  }
+  async setMany(entries) {
+    const pipeline = this.redis.pipeline();
+    for (const { key, value, ttl } of entries) {
+      const serialized = JSON.stringify(value);
+      if (ttl != null && ttl > 0) {
+        pipeline.setex(key, ttl, serialized);
+      } else {
+        pipeline.set(key, serialized);
+      }
+    }
+    await pipeline.exec();
+  }
+  async delete(key) {
+    const deleted = await this.redis.del(key);
+    return deleted > 0;
+  }
+  async deleteMany(keys) {
+    if (keys.length === 0)
+      return 0;
+    return await this.redis.del(...keys);
+  }
+  async has(key) {
+    const exists = await this.redis.exists(key);
+    return exists > 0;
+  }
+  async keys(prefix) {
+    if (!prefix) {
+      return await this.redis.keys("*");
+    }
+    return await this.redis.keys(`${prefix}*`);
+  }
+  async count() {
+    return await this.redis.dbsize();
+  }
+  async clear() {
+    await this.redis.flushdb();
+  }
+  cleanup() {
+    return 0;
+  }
+  close() {
+    this.redis.quit().catch(() => {});
+    getLog().debug("Redis KV adapter closed (ioredis)");
+  }
+}
+// adapters/node/node-response.ts
+import fs3 from "fs";
+import { Readable } from "stream";
+var UPGRADED = Symbol("cequre.bun.upgraded");
+var JSON_CONTENT_TYPE = "application/json";
+var DEFAULT_JSON_HEADERS = { "Content-Type": JSON_CONTENT_TYPE };
+function mergeHeaders(init, headers) {
+  const merged = new Headers(init?.headers);
+  if (headers) {
+    for (const [key, value] of new Headers(headers)) {
+      merged.set(key, value);
+    }
+  }
+  return merged;
+}
+function json(data, init = {}) {
+  if (!init.headers && init.status === undefined && init.statusText === undefined) {
+    return new Response(JSON.stringify(data), { headers: DEFAULT_JSON_HEADERS });
+  }
+  const headers = mergeHeaders(init, { "Content-Type": JSON_CONTENT_TYPE });
+  return new Response(JSON.stringify(data), { ...init, headers });
+}
+function empty(status = 204, init = {}) {
+  return new Response(null, { ...init, status });
+}
+function redirect(location, status = 302, init = {}) {
+  const headers = mergeHeaders(init, { Location: location });
+  return new Response(null, { ...init, status, headers });
+}
+function error(message, status = 500, code = "INTERNAL_ERROR", init = {}) {
+  return json({
+    error: code,
+    message
+  }, { ...init, status });
+}
+function notFound(message = "Not found") {
+  return error(message, 404, "NOT_FOUND");
+}
+function methodNotAllowed(allowedMethods) {
+  return error("Method not allowed", 405, "METHOD_NOT_ALLOWED", {
+    headers: { Allow: allowedMethods.join(", ") }
+  });
+}
+function file(file2, init = {}) {
+  if (typeof file2 === "string") {
+    const stream = fs3.createReadStream(file2);
+    let readable;
+    if (Readable.toWeb) {
+      readable = Readable.toWeb(stream);
+    } else {
+      readable = new ReadableStream({
+        start(controller) {
+          stream.on("data", (chunk) => controller.enqueue(chunk));
+          stream.on("end", () => controller.close());
+          stream.on("error", (e) => controller.error(e));
+        },
+        cancel() {
+          stream.destroy();
+        }
+      });
+    }
+    return new Response(readable, init);
+  }
+  if (file2 instanceof Uint8Array) {
+    return new Response(new Uint8Array(file2).buffer, init);
+  }
+  return new Response(file2, init);
+}
+function stream(data, init = {}) {
+  if (data instanceof ReadableStream) {
+    const headers2 = mergeHeaders(init, { "Content-Type": "text/plain" });
+    return new Response(data, { ...init, headers: headers2 });
+  }
+  const iterator = Symbol.asyncIterator in data ? data[Symbol.asyncIterator]() : data[Symbol.iterator]();
+  const encoder = new TextEncoder;
+  const readable = new ReadableStream({
+    async pull(controller) {
+      try {
+        const { value, done } = await iterator.next();
+        if (done) {
+          controller.close();
+        } else {
+          let chunk = value;
+          if (typeof chunk !== "string" && !(chunk instanceof Uint8Array)) {
+            chunk = JSON.stringify(chunk) + `
+`;
+          }
+          if (typeof chunk === "string") {
+            chunk = encoder.encode(chunk);
+          }
+          controller.enqueue(chunk);
+        }
+      } catch (err) {
+        if (typeof iterator.return === "function") {
+          try {
+            await iterator.return();
+          } catch {}
+        }
+        controller.error(err);
+      }
+    },
+    cancel() {
+      if (typeof iterator.return === "function") {
+        iterator.return();
+      }
+    }
+  });
+  const headers = mergeHeaders(init, { "Content-Type": "text/plain" });
+  return new Response(readable, { ...init, headers });
+}
+function toResponse(result) {
+  if (result === UPGRADED)
+    return;
+  if (result instanceof Response)
+    return result;
+  if (result === undefined)
+    return empty();
+  if (typeof result === "string")
+    return new Response(result);
+  if (result !== null && typeof result === "object") {
+    if (typeof result.next === "function" && ((Symbol.asyncIterator in result) || (Symbol.iterator in result))) {
+      return stream(result);
+    }
+  }
+  return json(result);
+}
+function routeErrorToResponse(errorValue, request) {
+  console.error("Cequre Unhandled Route Error:", errorValue);
+  const message = errorValue instanceof Error ? errorValue.message : String(errorValue);
+  return error(message, 500, "INTERNAL_ERROR", {
+    headers: request ? { "X-Cequre-Path": new URL(request.url).pathname } : undefined
+  });
+}
+// adapters/node/node-media.ts
+import fs4 from "fs";
+import { Readable as Readable2 } from "stream";
+function CequreStreamMedia(request, absolutePathOrUrl, options = {}) {
+  const provider = options.provider || "local";
+  if (provider === "s3") {
+    return new Response(null, {
+      status: 302,
+      headers: {
+        Location: absolutePathOrUrl
+      }
+    });
+  }
+  const rangeHeader = request.headers.get("Range");
+  const maxChunkSize = options.maxChunkSize || 1024 * 1024 * 2;
+  let stat;
+  try {
+    stat = fs4.statSync(absolutePathOrUrl);
+  } catch (e) {
+    return new Response("Not Found", { status: 404 });
+  }
+  if (!rangeHeader) {
+    const stream3 = fs4.createReadStream(absolutePathOrUrl);
+    const readable2 = Readable2.toWeb ? Readable2.toWeb(stream3) : new ReadableStream({
+      start(controller) {
+        stream3.on("data", (chunk) => controller.enqueue(chunk));
+        stream3.on("end", () => controller.close());
+        stream3.on("error", (e) => controller.error(e));
+      },
+      cancel() {
+        stream3.destroy();
+      }
+    });
+    return new Response(readable2, {
+      headers: {
+        "Content-Length": stat.size.toString(),
+        "Content-Type": "application/octet-stream"
+      }
+    });
+  }
+  const parts = rangeHeader.replace(/bytes=/, "").split("-");
+  const reqStart = parseInt(parts[0], 10);
+  const reqEnd = parts[1] ? parseInt(parts[1], 10) : stat.size - 1;
+  if (isNaN(reqStart) || reqStart >= stat.size) {
+    return new Response("Requested range not satisfiable", {
+      status: 416,
+      headers: {
+        "Content-Range": `bytes */${stat.size}`
+      }
+    });
+  }
+  let end = reqEnd;
+  if (end - reqStart + 1 > maxChunkSize) {
+    end = reqStart + maxChunkSize - 1;
+  }
+  if (end >= stat.size) {
+    end = stat.size - 1;
+  }
+  const stream2 = fs4.createReadStream(absolutePathOrUrl, { start: reqStart, end });
+  const readable = Readable2.toWeb ? Readable2.toWeb(stream2) : new ReadableStream({
+    start(controller) {
+      stream2.on("data", (chunk) => controller.enqueue(chunk));
+      stream2.on("end", () => controller.close());
+      stream2.on("error", (e) => controller.error(e));
+    },
+    cancel() {
+      stream2.destroy();
+    }
+  });
+  const chunkSize = end - reqStart + 1;
+  return new Response(readable, {
+    status: 206,
+    headers: {
+      "Content-Range": `bytes ${reqStart}-${end}/${stat.size}`,
+      "Accept-Ranges": "bytes",
+      "Content-Length": chunkSize.toString(),
+      "Content-Type": "application/octet-stream"
+    }
+  });
+}
+// adapters/node/index.ts
+function withNode(config) {
+  return {
+    ...config,
+    serverProvider: config.serverProvider || new NodeServerProvider,
+    cronProvider: config.cronProvider || new NodeCronProvider,
+    realtimeProvider: config.realtimeProvider || { websocket: CequreWebsocket },
+    storageProvider: config.storageProvider || new NodeLocalStorageProvider
+  };
+}
+export {
+  wsManager,
+  withNode,
+  toResponse,
+  stream,
+  routeErrorToResponse,
+  redirect,
+  notFound,
+  methodNotAllowed,
+  json,
+  file,
+  error,
+  empty,
+  createWebSocketHandler,
+  createNodeWebSocketRoute,
+  UPGRADED,
+  RedisAdapter,
+  NodeWebSocketManager,
+  NodeServerProvider,
+  NodeLocalStorageProvider,
+  NodeCronProvider,
+  CequreWebsocket,
+  CequreStreamMedia
+};