noumen 0.1.0 → 0.3.0

package/dist/server/index.js

@@ -0,0 +1,695 @@
+import "../chunk-DGUM43GV.js";
+
+// src/server/index.ts
+import { createServer as createHttpServer } from "http";
+
+// src/server/session-state.ts
+import { randomUUID } from "crypto";
+var DEFAULT_PENDING_TIMEOUT_MS = 12e4;
+function createSessionState(sessions, requestedId, overrides) {
+  if (requestedId && sessions.has(requestedId)) {
+    throw new Error(`Session ${requestedId} already exists`);
+  }
+  const sessionId = requestedId ?? randomUUID();
+  const session = {
+    id: sessionId,
+    abortController: new AbortController(),
+    pendingPermission: null,
+    pendingInput: null,
+    pendingPermissionTimer: null,
+    pendingInputTimer: null,
+    lastActivity: Date.now(),
+    sseResponse: null,
+    sseKeepaliveTimer: null,
+    eventBuffer: [],
+    sequenceNum: 0,
+    done: false,
+    cwd: overrides.cwd
+  };
+  sessions.set(sessionId, session);
+  return session;
+}
+function destroySession(sessions, session) {
+  session.abortController.abort();
+  clearSseKeepalive(session);
+  clearPendingPermissionTimer(session);
+  clearPendingInputTimer(session);
+  if (session.pendingPermission) {
+    session.pendingPermission.reject(new Error("Session aborted"));
+    session.pendingPermission = null;
+  }
+  if (session.pendingInput) {
+    session.pendingInput.reject(new Error("Session aborted"));
+    session.pendingInput = null;
+  }
+  if (session.sseResponse) {
+    session.sseResponse.end();
+    session.sseResponse = null;
+  }
+  sessions.delete(session.id);
+}
+function reapIdleSessions(sessions, timeoutMs) {
+  if (!timeoutMs) return;
+  const now = Date.now();
+  for (const session of sessions.values()) {
+    if (now - session.lastActivity > timeoutMs) {
+      destroySession(sessions, session);
+    }
+  }
+}
+function bridgePermission(sessions, sessionId, timeoutMs) {
+  const session = sessions.get(sessionId);
+  if (!session) return Promise.reject(new Error("Session not found"));
+  return new Promise((resolve, reject) => {
+    session.pendingPermission = { resolve, reject };
+    session.pendingPermissionTimer = setTimeout(() => {
+      session.pendingPermissionTimer = null;
+      if (session.pendingPermission) {
+        session.pendingPermission.reject(new Error("Permission request timed out"));
+        session.pendingPermission = null;
+      }
+    }, timeoutMs);
+  });
+}
+function bridgeUserInput(sessions, sessionId, timeoutMs) {
+  const session = sessions.get(sessionId);
+  if (!session) return Promise.reject(new Error("Session not found"));
+  return new Promise((resolve, reject) => {
+    session.pendingInput = { resolve, reject };
+    session.pendingInputTimer = setTimeout(() => {
+      session.pendingInputTimer = null;
+      if (session.pendingInput) {
+        session.pendingInput.reject(new Error("User input request timed out"));
+        session.pendingInput = null;
+      }
+    }, timeoutMs);
+  });
+}
+function clearPendingPermissionTimer(session) {
+  if (session.pendingPermissionTimer) {
+    clearTimeout(session.pendingPermissionTimer);
+    session.pendingPermissionTimer = null;
+  }
+}
+function clearPendingInputTimer(session) {
+  if (session.pendingInputTimer) {
+    clearTimeout(session.pendingInputTimer);
+    session.pendingInputTimer = null;
+  }
+}
+function clearSseKeepalive(session) {
+  if (session.sseKeepaliveTimer) {
+    clearInterval(session.sseKeepaliveTimer);
+    session.sseKeepaliveTimer = null;
+  }
+}
+
+// src/server/event-buffer.ts
+var MAX_EVENT_BUFFER = 1e3;
+function serializeEvent(event) {
+  if (event.type === "error") {
+    return { type: "error", error: { message: event.error.message, name: event.error.name } };
+  }
+  if (event.type === "retry_exhausted") {
+    return { ...event, error: { message: event.error.message, name: event.error.name } };
+  }
+  if (event.type === "retry_attempt") {
+    return { ...event, error: { message: event.error.message, name: event.error.name } };
+  }
+  return event;
+}
+function pushEvent(session, event) {
+  session.sequenceNum++;
+  const seq = session.sequenceNum;
+  if (session.eventBuffer.length >= MAX_EVENT_BUFFER) {
+    session.eventBuffer.shift();
+  }
+  session.eventBuffer.push({ seq, event });
+  if (session.sseResponse) {
+    writeSseEventRaw(session.sseResponse, seq, serializeEvent(event));
+  }
+}
+function getBufferedEventsAfter(buffer, afterSeq) {
+  if (!afterSeq) return [...buffer];
+  return buffer.filter((e) => e.seq > afterSeq);
+}
+function writeSseEventRaw(res, seq, data) {
+  res.write(`id: ${seq}
+data: ${JSON.stringify(data)}
+
+`);
+}
+
+// src/server/ws-dispatch.ts
+function parseWsMessage(raw) {
+  try {
+    return JSON.parse(typeof raw === "string" ? raw : raw.toString());
+  } catch {
+    return null;
+  }
+}
+async function handleWsMessage(msg, ctx, callbacks) {
+  const msgType = msg.type;
+  if (msgType === "run") {
+    if (ctx.maxSessions && ctx.currentSessionCount >= ctx.maxSessions) {
+      return { type: "error", error: "Maximum sessions reached" };
+    }
+    if (typeof msg.prompt !== "string" || !msg.prompt.trim()) {
+      return { type: "error", error: "Missing or empty prompt" };
+    }
+    try {
+      const sessionId = await callbacks.onRun(
+        msg.prompt,
+        msg.sessionId
+      );
+      return { type: "session_created", sessionId };
+    } catch (err) {
+      return { type: "error", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  if (msgType === "message") {
+    if (typeof msg.prompt !== "string" || !msg.prompt.trim()) {
+      return { type: "error", error: "Missing or empty prompt" };
+    }
+    const sessionId = msg.sessionId;
+    if (!sessionId) {
+      return { type: "error", error: "Missing sessionId" };
+    }
+    callbacks.onMessage(sessionId, msg.prompt);
+    return { type: "ok" };
+  }
+  if (msgType === "permission_response") {
+    const sessionId = msg.sessionId;
+    const { sessionId: _sid, type: _type, ...response } = msg;
+    callbacks.onPermissionResponse(sessionId, response);
+    return { type: "ok" };
+  }
+  if (msgType === "input_response") {
+    const sessionId = msg.sessionId;
+    callbacks.onInputResponse(sessionId, msg.answer ?? "");
+    return { type: "ok" };
+  }
+  if (msgType === "abort") {
+    const sessionId = msg.sessionId;
+    if (sessionId) callbacks.onAbort(sessionId);
+    return { type: "ok" };
+  }
+  return { type: "ok" };
+}
+function wsSend(ws, data) {
+  if (ws.readyState === 1) ws.send(JSON.stringify(data));
+}
+
+// src/server/index.ts
+var SSE_KEEPALIVE_INTERVAL_MS = 15e3;
+var MAX_BODY_BYTES = 1048576;
+var SHUTDOWN_DRAIN_MS = 500;
+var WS_PING_INTERVAL_MS = 3e4;
+var NoumenServer = class {
+  code;
+  options;
+  httpServer = null;
+  wss = null;
+  sessions = /* @__PURE__ */ new Map();
+  idleTimer = null;
+  constructor(code, options) {
+    this.code = code;
+    this.options = options;
+  }
+  async start() {
+    this.httpServer = createHttpServer((req, res) => this.handleRequest(req, res));
+    if (this.options.ws !== false) {
+      await this.initWebSocket();
+    }
+    this.ensureIdleReaper();
+    return new Promise((resolve, reject) => {
+      const host = this.options.host ?? "127.0.0.1";
+      this.httpServer.listen(this.options.port, host, () => resolve());
+      this.httpServer.once("error", reject);
+    });
+  }
+  async stop() {
+    if (this.idleTimer) {
+      clearInterval(this.idleTimer);
+      this.idleTimer = null;
+    }
+    for (const session of this.sessions.values()) {
+      session.abortController.abort();
+    }
+    await new Promise((resolve) => setTimeout(resolve, SHUTDOWN_DRAIN_MS));
+    for (const session of this.sessions.values()) {
+      destroySession(this.sessions, session);
+    }
+    if (this.wss) {
+      await new Promise((resolve) => this.wss.close(() => resolve()));
+      this.wss = null;
+    }
+    if (this.httpServer) {
+      if (typeof this.httpServer.closeAllConnections === "function") {
+        this.httpServer.closeAllConnections();
+      }
+      await new Promise(
+        (resolve, reject) => this.httpServer.close((err) => err ? reject(err) : resolve())
+      );
+      this.httpServer = null;
+    }
+  }
+  getActiveSessions() {
+    const result = /* @__PURE__ */ new Map();
+    for (const [id, s] of this.sessions) {
+      result.set(id, { id: s.id, lastActivity: s.lastActivity, done: s.done });
+    }
+    return result;
+  }
+  // -------------------------------------------------------------------------
+  // WebSocket setup
+  // -------------------------------------------------------------------------
+  async initWebSocket() {
+    let WsServerCtor;
+    try {
+      const ws = await import("ws");
+      WsServerCtor = ws.WebSocketServer ?? ws.default?.WebSocketServer;
+    } catch {
+      throw new Error(
+        "noumen/server: WebSocket support requires the 'ws' package. Install it with: npm install ws\nOr disable WebSocket with { ws: false } in ServerOptions."
+      );
+    }
+    this.wss = new WsServerCtor({ server: this.httpServer });
+    this.wss.on("connection", (ws, req) => {
+      this.handleWsConnection(ws, req).catch(
+        (err) => this.options.onError?.(err instanceof Error ? err : new Error(String(err)))
+      );
+    });
+  }
+  /**
+   * Handle an HTTP request. Used internally by `start()` and exposed for
+   * `createRequestHandler()` so the same logic can be mounted on an
+   * external Express / Fastify / Hono server.
+   */
+  async handleRequest(req, res) {
+    this.ensureIdleReaper();
+    return this.handleHttp(req, res).catch((err) => {
+      this.options.onError?.(err instanceof Error ? err : new Error(String(err)));
+      if (!res.headersSent) jsonResponse(res, 500, { error: "Internal server error" });
+    });
+  }
+  idleReaperStarted = false;
+  ensureIdleReaper() {
+    if (this.idleReaperStarted || !this.options.idleTimeoutMs) return;
+    this.idleReaperStarted = true;
+    const interval = Math.max(this.options.idleTimeoutMs / 2, 1e3);
+    this.idleTimer = setInterval(() => reapIdleSessions(this.sessions, this.options.idleTimeoutMs), interval);
+    this.idleTimer.unref();
+  }
+  // -------------------------------------------------------------------------
+  // HTTP routing
+  // -------------------------------------------------------------------------
+  async handleHttp(req, res) {
+    if (this.options.cors !== false) {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, Last-Event-ID");
+    }
+    const method = req.method ?? "GET";
+    if (method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    const path = url.pathname;
+    if (path === "/health" && method === "GET") {
+      return jsonResponse(res, 200, { status: "ok", sessions: this.sessions.size });
+    }
+    if (this.options.auth) {
+      const authResult = await this.authenticate(req);
+      if (!authResult) {
+        return jsonResponse(res, 401, { error: "Unauthorized" });
+      }
+    }
+    if (path === "/sessions" && method === "POST") {
+      return this.handleCreateSession(req, res);
+    }
+    if (path === "/sessions" && method === "GET") {
+      return this.handleListSessions(res);
+    }
+    const sessionMatch = path.match(/^\/sessions\/([^/]+)(?:\/(.+))?$/);
+    if (sessionMatch) {
+      const sessionId = sessionMatch[1];
+      const sub = sessionMatch[2] ?? "";
+      if (sub === "events" && method === "GET") return this.handleSseStream(sessionId, req, res);
+      if (sub === "permissions" && method === "POST") return this.handlePermissionResponse(sessionId, req, res);
+      if (sub === "input" && method === "POST") return this.handleInputResponse(sessionId, req, res);
+      if (sub === "messages" && method === "POST") return this.handleSendMessage(sessionId, req, res);
+      if (sub === "" && method === "DELETE") return this.handleDeleteSession(sessionId, res);
+    }
+    jsonResponse(res, 404, { error: "Not found" });
+  }
+  // -------------------------------------------------------------------------
+  // Auth
+  // -------------------------------------------------------------------------
+  async authenticate(req) {
+    const auth = this.options.auth;
+    if (!auth) return {};
+    if (auth.type === "bearer") {
+      const header = req.headers.authorization;
+      if (header === `Bearer ${auth.token}`) return {};
+      return null;
+    }
+    return auth.verify(req);
+  }
+  // -------------------------------------------------------------------------
+  // REST handlers
+  // -------------------------------------------------------------------------
+  async handleCreateSession(req, res) {
+    const body = await readBody(req);
+    const { prompt, sessionId: requestedId } = body;
+    if (!prompt || typeof prompt !== "string") {
+      return jsonResponse(res, 400, { error: "Missing required field: prompt" });
+    }
+    if (this.options.maxSessions && this.sessions.size >= this.options.maxSessions) {
+      return jsonResponse(res, 429, { error: "Maximum sessions reached" });
+    }
+    const overrides = await this.resolveConnectionOverrides(req);
+    const session = createSessionState(this.sessions, requestedId, overrides);
+    this.runAgentSse(session, prompt, false);
+    jsonResponse(res, 201, {
+      sessionId: session.id,
+      eventsUrl: `/sessions/${session.id}/events`
+    });
+  }
+  handleListSessions(res) {
+    const sessions = Array.from(this.sessions.values()).map((s) => ({
+      id: s.id,
+      lastActivity: s.lastActivity,
+      done: s.done
+    }));
+    jsonResponse(res, 200, sessions);
+  }
+  handleSseStream(sessionId, req, res) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return jsonResponse(res, 404, { error: "Session not found" });
+    if (session.sseResponse) {
+      const oldRes = session.sseResponse;
+      writeSseEventRaw(oldRes, session.sequenceNum + 1, { type: "subscriber_replaced" });
+      oldRes.end();
+      clearSseKeepalive(session);
+      session.sseResponse = null;
+    }
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive",
+      "X-Accel-Buffering": "no"
+    });
+    const lastEventId = req.headers["last-event-id"];
+    const resumeAfterSeq = lastEventId ? parseInt(lastEventId, 10) : 0;
+    const eventsToReplay = getBufferedEventsAfter(session.eventBuffer, resumeAfterSeq);
+    for (const buffered of eventsToReplay) {
+      writeSseEventRaw(res, buffered.seq, serializeEvent(buffered.event));
+    }
+    session.eventBuffer = [];
+    session.sseResponse = res;
+    this.startSseKeepalive(session);
+    res.on("close", () => {
+      if (session.sseResponse === res) {
+        clearSseKeepalive(session);
+        session.sseResponse = null;
+      }
+    });
+  }
+  async handlePermissionResponse(sessionId, req, res) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return jsonResponse(res, 404, { error: "Session not found" });
+    if (!session.pendingPermission) return jsonResponse(res, 409, { error: "No pending permission request" });
+    const body = await readBody(req);
+    clearPendingPermissionTimer(session);
+    session.pendingPermission.resolve(body);
+    session.pendingPermission = null;
+    jsonResponse(res, 200, { ok: true });
+  }
+  async handleInputResponse(sessionId, req, res) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return jsonResponse(res, 404, { error: "Session not found" });
+    if (!session.pendingInput) return jsonResponse(res, 409, { error: "No pending input request" });
+    const body = await readBody(req);
+    if (typeof body.answer !== "string") {
+      return jsonResponse(res, 400, { error: "Missing required field: answer" });
+    }
+    clearPendingInputTimer(session);
+    session.pendingInput.resolve(body.answer);
+    session.pendingInput = null;
+    jsonResponse(res, 200, { ok: true });
+  }
+  async handleSendMessage(sessionId, req, res) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return jsonResponse(res, 404, { error: "Session not found" });
+    if (!session.done) return jsonResponse(res, 409, { error: "Session is still running" });
+    const body = await readBody(req);
+    if (!body.prompt || typeof body.prompt !== "string") {
+      return jsonResponse(res, 400, { error: "Missing required field: prompt" });
+    }
+    session.done = false;
+    session.abortController = new AbortController();
+    this.runAgentSse(session, body.prompt, true);
+    jsonResponse(res, 200, { ok: true });
+  }
+  handleDeleteSession(sessionId, res) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return jsonResponse(res, 404, { error: "Session not found" });
+    destroySession(this.sessions, session);
+    jsonResponse(res, 200, { ok: true });
+  }
+  // -------------------------------------------------------------------------
+  // WebSocket handling
+  // -------------------------------------------------------------------------
+  async handleWsConnection(ws, req) {
+    if (this.options.auth) {
+      const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+      const tokenParam = url.searchParams.get("token");
+      if (tokenParam && this.options.auth.type === "bearer") {
+        if (tokenParam !== this.options.auth.token) {
+          ws.close();
+          return;
+        }
+      } else {
+        const authResult = await this.authenticate(req);
+        if (!authResult) {
+          ws.close();
+          return;
+        }
+      }
+    }
+    const wsSessions = /* @__PURE__ */ new Set();
+    let pongReceived = true;
+    const pingTimer = setInterval(() => {
+      if (!pongReceived) {
+        ws.close();
+        return;
+      }
+      pongReceived = false;
+      try {
+        ws.ping();
+      } catch {
+      }
+    }, WS_PING_INTERVAL_MS);
+    ws.on("pong", () => {
+      pongReceived = true;
+    });
+    const callbacks = {
+      onRun: async (prompt, requestedSessionId) => {
+        const overrides = await this.resolveConnectionOverrides(req);
+        const session = createSessionState(this.sessions, requestedSessionId, overrides);
+        wsSessions.add(session.id);
+        this.runAgentWs(session, prompt, ws, false);
+        return session.id;
+      },
+      onMessage: (sessionId, prompt) => {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+          wsSend(ws, { type: "error", error: "Session not found" });
+          return;
+        }
+        if (!session.done) {
+          wsSend(ws, { type: "error", error: "Session is still running" });
+          return;
+        }
+        session.done = false;
+        session.abortController = new AbortController();
+        this.runAgentWs(session, prompt, ws, true);
+      },
+      onPermissionResponse: (sessionId, response) => {
+        const session = this.sessions.get(sessionId);
+        if (!session?.pendingPermission) return;
+        clearPendingPermissionTimer(session);
+        session.pendingPermission.resolve(response);
+        session.pendingPermission = null;
+      },
+      onInputResponse: (sessionId, answer) => {
+        const session = this.sessions.get(sessionId);
+        if (!session?.pendingInput) return;
+        clearPendingInputTimer(session);
+        session.pendingInput.resolve(answer);
+        session.pendingInput = null;
+      },
+      onAbort: (sessionId) => {
+        const session = this.sessions.get(sessionId);
+        if (session) destroySession(this.sessions, session);
+      }
+    };
+    ws.on("message", async (raw) => {
+      try {
+        const msg = parseWsMessage(raw);
+        if (!msg) {
+          wsSend(ws, { type: "error", error: "Invalid JSON" });
+          return;
+        }
+        const result = await handleWsMessage(msg, {
+          maxSessions: this.options.maxSessions,
+          currentSessionCount: this.sessions.size
+        }, callbacks);
+        if (result.type === "error") {
+          wsSend(ws, { type: "error", error: result.error });
+        } else if (result.type === "session_created") {
+          wsSend(ws, { type: "session_created", sessionId: result.sessionId });
+        }
+      } catch (err) {
+        wsSend(ws, { type: "error", error: String(err) });
+      }
+    });
+    ws.on("close", () => {
+      clearInterval(pingTimer);
+      for (const sid of wsSessions) {
+        const session = this.sessions.get(sid);
+        if (session) destroySession(this.sessions, session);
+      }
+    });
+    ws.on("error", () => {
+      clearInterval(pingTimer);
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Agent runners
+  // -------------------------------------------------------------------------
+  async makeThread(session, resume) {
+    const timeoutMs = this.options.pendingTimeoutMs ?? DEFAULT_PENDING_TIMEOUT_MS;
+    const handlers = {
+      cwd: session.cwd,
+      permissionHandler: (_req) => bridgePermission(this.sessions, session.id, timeoutMs),
+      userInputHandler: (_q) => bridgeUserInput(this.sessions, session.id, timeoutMs)
+    };
+    return resume ? this.code.resumeThread(session.id, handlers) : this.code.createThread({ sessionId: session.id, ...handlers });
+  }
+  runAgentSse(session, prompt, resume) {
+    const run = async () => {
+      try {
+        const thread = await this.makeThread(session, resume);
+        for await (const event of thread.run(prompt, { signal: session.abortController.signal })) {
+          pushEvent(session, event);
+          session.lastActivity = Date.now();
+        }
+      } catch (err) {
+        if (err.name !== "AbortError") {
+          pushEvent(session, {
+            type: "error",
+            error: err instanceof Error ? err : new Error(String(err))
+          });
+        }
+      } finally {
+        session.done = true;
+      }
+    };
+    run().catch((err) => this.options.onError?.(err instanceof Error ? err : new Error(String(err))));
+  }
+  runAgentWs(session, prompt, ws, resume) {
+    const run = async () => {
+      try {
+        const thread = await this.makeThread(session, resume);
+        for await (const event of thread.run(prompt, { signal: session.abortController.signal })) {
+          session.sequenceNum++;
+          wsSend(ws, { ...serializeEvent(event), sessionId: session.id, seq: session.sequenceNum });
+          session.lastActivity = Date.now();
+        }
+      } catch (err) {
+        if (err.name !== "AbortError") {
+          wsSend(ws, { type: "error", sessionId: session.id, error: String(err) });
+        }
+      } finally {
+        session.done = true;
+      }
+    };
+    run().catch((err) => this.options.onError?.(err instanceof Error ? err : new Error(String(err))));
+  }
+  startSseKeepalive(session) {
+    clearSseKeepalive(session);
+    session.sseKeepaliveTimer = setInterval(() => {
+      if (session.sseResponse && !session.sseResponse.destroyed) {
+        session.sseResponse.write(":keepalive\n\n");
+      }
+    }, SSE_KEEPALIVE_INTERVAL_MS);
+    session.sseKeepaliveTimer.unref();
+  }
+  async resolveConnectionOverrides(req) {
+    if (!this.options.onConnection) return {};
+    const auth = await this.authenticate(req) ?? {};
+    return this.options.onConnection({ auth, remoteAddress: req.socket.remoteAddress });
+  }
+};
+function createServer(code, options) {
+  return new NoumenServer(code, options);
+}
+function createRequestHandler(code, options) {
+  const serverOpts = {
+    port: 0,
+    ws: false,
+    ...options
+  };
+  const server = new NoumenServer(code, serverOpts);
+  return (req, res) => {
+    server.handleRequest(req, res);
+  };
+}
+function jsonResponse(res, status, body) {
+  const json = JSON.stringify(body);
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(json)
+  });
+  res.end(json);
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let totalBytes = 0;
+    let rejected = false;
+    const chunks = [];
+    req.on("data", (chunk) => {
+      if (rejected) return;
+      totalBytes += chunk.length;
+      if (totalBytes > MAX_BODY_BYTES) {
+        rejected = true;
+        req.destroy();
+        reject(new Error("Request body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      if (rejected) return;
+      try {
+        const raw = Buffer.concat(chunks).toString();
+        resolve(raw ? JSON.parse(raw) : {});
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on("error", (err) => {
+      if (!rejected) reject(err);
+    });
+  });
+}
+export {
+  NoumenServer,
+  createRequestHandler,
+  createServer
+};
+//# sourceMappingURL=index.js.map