bareserver 0.0.0-stage → 0.1.1

package/index.d.ts

@@ -0,0 +1,118 @@
+import { Buffer } from 'node:buffer';
+import { Readable } from 'node:stream';
+
+export interface CookieOptions {
+  maxAge?: number;
+  domain?: string;
+  path?: string;
+  expires?: Date;
+  httpOnly?: boolean;
+  secure?: boolean;
+  sameSite?: boolean | 'lax' | 'strict' | 'none';
+}
+
+export interface BareRequest extends Readable {
+  method: string;
+  path: string;
+  url: string;
+  originalUrl: string;
+  baseUrl: string;
+  query: Record<string, string>;
+  params: Record<string, string>;
+  headers: Record<string, string | undefined>;
+  cookies: Record<string, string>;
+  ip: string;
+  ips: string[];
+  protocol: string;
+  secure: boolean;
+  hostname: string;
+  get(header: string): string | undefined;
+  header(header: string): string | undefined;
+  is(type: string): boolean;
+  body: any;
+  [key: string]: any;
+}
+
+export interface BareResponse {
+  statusCode: number;
+  headersSent: boolean;
+  status(code: number): this;
+  sendStatus(code: number): void;
+  set(field: string, val: string | number | string[]): this;
+  set(fields: Record<string, string | number | string[]>): this;
+  setHeader(field: string, val: string | number | string[]): this;
+  getHeader(field: string): any;
+  getHeaders(): Record<string, any>;
+  hasHeader(field: string): boolean;
+  removeHeader(field: string): this;
+  writeHead(statusCode: number, headers?: Record<string, any>): this;
+  redirect(url: string): void;
+  redirect(status: number, url: string): void;
+  cookie(name: string, val: string, options?: CookieOptions): this;
+  clearCookie(name: string, options?: CookieOptions): this;
+  type(type: string): this;
+  append(field: string, val: string | string[]): this;
+  send(body?: string | Buffer | object | null): void;
+  json(body: any): void;
+  end(data?: string | Buffer): void;
+}
+
+export type NextFunction = (err?: any) => void;
+export type MiddlewareHandler = (req: BareRequest, res: BareResponse, next: NextFunction) => void;
+export type ErrorHandler = (err: any, req: BareRequest, res: BareResponse, next: NextFunction) => void;
+export type RouteHandler = (req: BareRequest, res: BareResponse) => void;
+export type Handler = MiddlewareHandler | ErrorHandler | RouteHandler;
+
+export interface BareServerOptions {
+  port?: number;
+  maxBodySize?: number;
+  keepAlive?: boolean;
+}
+
+export interface Router {
+  use(prefix: string, ...handlers: (Handler | Router)[]): this;
+  use(...handlers: (Handler | Router)[]): this;
+  get(path: string, ...handlers: Handler[]): this;
+  post(path: string, ...handlers: Handler[]): this;
+  put(path: string, ...handlers: Handler[]): this;
+  delete(path: string, ...handlers: Handler[]): this;
+  patch(path: string, ...handlers: Handler[]): this;
+  all(path: string, ...handlers: Handler[]): this;
+}
+
+export class BareServer {
+  port: number;
+  constructor(options?: BareServerOptions | number);
+  cors(): this;
+  static(path: string, body: any): this;
+  static(path: string, status: number, body: any): this;
+  use(prefix: string, ...handlers: (Handler | Router)[]): this;
+  use(...handlers: (Handler | Router)[]): this;
+  get(path: string, ...handlers: Handler[]): this;
+  post(path: string, ...handlers: Handler[]): this;
+  put(path: string, ...handlers: Handler[]): this;
+  delete(path: string, ...handlers: Handler[]): this;
+  patch(path: string, ...handlers: Handler[]): this;
+  all(path: string, ...handlers: Handler[]): this;
+  listen(port?: number, callback?: (url: string) => void): Promise<string>;
+  listen(callback?: (url: string) => void): Promise<string>;
+  setBodyLimit(bytes: number): this;
+  setKeepAlive(enabled: boolean): this;
+  close(callback?: (err?: Error | null) => void): Promise<void>;
+}
+
+export interface ExpressApp extends BareServer {}
+
+declare function express(options?: BareServerOptions | number): ExpressApp;
+
+declare namespace express {
+  export const BareServer: typeof import('./index.js').BareServer;
+  export function Router(): Router;
+  export function json(): MiddlewareHandler;
+  export function urlencoded(options?: any): MiddlewareHandler;
+  export function raw(): MiddlewareHandler;
+  export function text(): MiddlewareHandler;
+}
+
+export default express;
+export { express, Router };

package/index.js

@@ -0,0 +1,656 @@
+const { Readable } = require('node:stream');
+const { STATUS_CODES } = require('node:http');
+
+let native;
+try {
+  native = require('./index.node');
+} catch (e) {
+  const { platform, arch } = process;
+  const candidates = [];
+  if (platform === 'darwin') {
+    candidates.push(`bareserver-darwin-${arch}`, `@bareserver/darwin-${arch}`);
+  } else if (platform === 'win32') {
+    candidates.push(`bareserver-win32-${arch}-msvc`, `@bareserver/win32-${arch}-msvc`);
+  } else if (platform === 'linux') {
+    candidates.push(`bareserver-linux-${arch}-gnu`, `@bareserver/linux-${arch}-gnu`);
+  }
+
+  for (const pkg of candidates) {
+    try {
+      native = require(pkg);
+      if (native) break;
+    } catch {}
+  }
+
+  if (!native) {
+    throw new Error(`Failed to load bareserver native binary for ${platform}-${arch}: ${e.message}`);
+  }
+}
+
+class BareRequest extends Readable {
+  constructor(raw) {
+    super();
+    this._raw = raw;
+    this._headers = null;
+    this._rawBody = raw.rawBody;
+    this._parsedBody = undefined;
+    this._cookies = undefined;
+    this._streamEnded = false;
+    this.method = raw.method;
+    this.path = raw.path;
+    this.url = raw.query ? `${raw.path}?${raw.query}` : raw.path;
+    this.originalUrl = this.url;
+    this.baseUrl = '';
+    this.query = raw.query ? Object.fromEntries(new URLSearchParams(raw.query)) : {};
+    const params = raw.params || {};
+    if (raw.params) {
+      for (const k in raw.params) {
+        const val = raw.params[k];
+        if (typeof val === 'string' && val.includes('%')) {
+          try {
+            params[k] = decodeURIComponent(val);
+          } catch {
+            // Keep raw if invalid encoding
+          }
+        }
+      }
+    }
+    this.params = params;
+  }
+
+  _read() {
+    if (!this._streamEnded) {
+      this._streamEnded = true;
+      if (this._rawBody && this._rawBody.length > 0) {
+        this.push(this._rawBody);
+      }
+      this.push(null);
+    }
+  }
+
+  get headers() {
+    if (this._headers !== null) return this._headers;
+    const obj = {};
+    const arr = this._raw.rawHeaders;
+    if (arr) {
+      for (let i = 0; i < arr.length; i += 2) {
+        obj[arr[i].toLowerCase()] = arr[i + 1];
+      }
+    }
+    return (this._headers = obj);
+  }
+
+  get(field) {
+    const lower = field.toLowerCase();
+    const arr = this._raw.rawHeaders;
+    if (!arr) return undefined;
+    for (let i = 0; i < arr.length; i += 2) {
+      if (arr[i].toLowerCase() === lower) return arr[i + 1];
+    }
+    return undefined;
+  }
+
+  header(field) {
+    return this.get(field);
+  }
+
+  get body() {
+    if (this._parsedBody !== undefined) return this._parsedBody;
+    if (this._rawBody && this._rawBody.length > 0) {
+      const ct = this.get('content-type') || '';
+      if (ct.includes('application/json')) {
+        try {
+          return (this._parsedBody = JSON.parse(this._rawBody.toString('utf8')));
+        } catch {
+          return (this._parsedBody = this._rawBody);
+        }
+      }
+      return (this._parsedBody = this._rawBody);
+    }
+    return (this._parsedBody = {});
+  }
+
+  get cookies() {
+    if (this._cookies !== undefined) return this._cookies;
+    const cookieHeader = this.get('cookie');
+    if (!cookieHeader) return (this._cookies = {});
+    const parsed = {};
+    const pairs = cookieHeader.split(';');
+    for (let i = 0; i < pairs.length; i++) {
+      const pair = pairs[i].trim();
+      const eqIdx = pair.indexOf('=');
+      if (eqIdx !== -1) {
+        parsed[decodeURIComponent(pair.slice(0, eqIdx).trim())] = decodeURIComponent(pair.slice(eqIdx + 1).trim());
+      }
+    }
+    return (this._cookies = parsed);
+  }
+
+  set cookies(val) {
+    this._cookies = val;
+  }
+
+  get ip() {
+    const forwarded = this.get('x-forwarded-for');
+    if (forwarded) return forwarded.split(',')[0].trim();
+    return '127.0.0.1';
+  }
+
+  get ips() {
+    const forwarded = this.get('x-forwarded-for');
+    return forwarded ? forwarded.split(',').map((s) => s.trim()) : [];
+  }
+
+  get protocol() {
+    return this.get('x-forwarded-proto') || 'http';
+  }
+
+  get secure() {
+    return this.protocol === 'https';
+  }
+
+  get hostname() {
+    const host = this.get('host') || 'localhost';
+    return host.split(':')[0];
+  }
+
+  is(type) {
+    const ct = this.get('content-type');
+    if (!ct) return false;
+    return ct.includes(type);
+  }
+}
+
+class BareResponse {
+  constructor(server, raw) {
+    this._server = server;
+    this._raw = raw;
+    this.statusCode = 200;
+    this.contentType = null;
+    this.extraHeaders = null;
+    this.responded = false;
+  }
+
+  get headersSent() {
+    return this.responded;
+  }
+
+  status(code) {
+    if (this.responded) return this;
+    this.statusCode = code;
+    return this;
+  }
+
+  set(field, val) {
+    if (this.responded) return this;
+    if (typeof field === 'object') {
+      for (const [k, v] of Object.entries(field)) {
+        this.set(k, v);
+      }
+    } else {
+      const lower = field.toLowerCase();
+      if (lower === 'content-type') {
+        this.contentType = String(val);
+      } else {
+        if (!this.extraHeaders) this.extraHeaders = {};
+        this.extraHeaders[lower] = Array.isArray(val) ? val.map(String) : String(val);
+      }
+    }
+    return this;
+  }
+
+  setHeader(field, val) {
+    return this.set(field, val);
+  }
+
+  getHeader(field) {
+    const lower = field.toLowerCase();
+    if (lower === 'content-type') return this.contentType;
+    return this.extraHeaders ? this.extraHeaders[lower] : undefined;
+  }
+
+  getHeaders() {
+    const headers = { ...this.extraHeaders };
+    if (this.contentType) headers['content-type'] = this.contentType;
+    return headers;
+  }
+
+  hasHeader(field) {
+    return this.getHeader(field) !== undefined;
+  }
+
+  removeHeader(field) {
+    const lower = field.toLowerCase();
+    if (lower === 'content-type') {
+      this.contentType = null;
+    } else if (this.extraHeaders) {
+      delete this.extraHeaders[lower];
+    }
+    return this;
+  }
+
+  writeHead(statusCode, reasonOrHeaders, maybeHeaders) {
+    this.statusCode = statusCode;
+    const headers = typeof reasonOrHeaders === 'object' ? reasonOrHeaders : maybeHeaders;
+    if (headers) {
+      this.set(headers);
+    }
+    return this;
+  }
+
+  sendStatus(code) {
+    const body = STATUS_CODES[code] || String(code);
+    this.status(code).type('text/plain').send(body);
+  }
+
+  redirect(statusOrUrl, maybeUrl) {
+    let status = 302;
+    let url = statusOrUrl;
+    if (typeof statusOrUrl === 'number') {
+      status = statusOrUrl;
+      url = maybeUrl;
+    }
+    this.status(status);
+    this.set('location', url);
+    this.send(`Found. Redirecting to ${url}`);
+  }
+
+  cookie(name, val, options = {}) {
+    let str = `${encodeURIComponent(name)}=${encodeURIComponent(val)}`;
+    if (options.maxAge) str += `; Max-Age=${Math.floor(options.maxAge / 1000)}`;
+    if (options.domain) str += `; Domain=${options.domain}`;
+    if (options.path) str += `; Path=${options.path}`;
+    else str += '; Path=/';
+    if (options.expires) str += `; Expires=${options.expires.toUTCString()}`;
+    if (options.httpOnly) str += '; HttpOnly';
+    if (options.secure) str += '; Secure';
+    if (options.sameSite) {
+      const ss = typeof options.sameSite === 'string' ? options.sameSite.toLowerCase() : 'strict';
+      str += `; SameSite=${ss.charAt(0).toUpperCase() + ss.slice(1)}`;
+    }
+    const prev = this.getHeader('set-cookie');
+    if (!prev) {
+      this.set('set-cookie', str);
+    } else if (Array.isArray(prev)) {
+      this.set('set-cookie', [...prev, str]);
+    } else {
+      this.set('set-cookie', [prev, str]);
+    }
+    return this;
+  }
+
+  clearCookie(name, options = {}) {
+    return this.cookie(name, '', { ...options, expires: new Date(1), maxAge: 0 });
+  }
+
+  type(type) {
+    let ct = type;
+    if (!type.includes('/')) {
+      if (type === 'json') ct = 'application/json';
+      else if (type === 'html') ct = 'text/html; charset=utf-8';
+      else if (type === 'text' || type === 'txt') ct = 'text/plain; charset=utf-8';
+      else ct = `text/${type}`;
+    }
+    this.contentType = ct;
+    return this;
+  }
+
+  append(field, val) {
+    const prev = this.getHeader(field);
+    if (!prev) {
+      return this.set(field, val);
+    }
+    if (Array.isArray(prev)) {
+      return this.set(field, [...prev, val]);
+    }
+    return this.set(field, [prev, val]);
+  }
+
+  _getHeadersArray() {
+    if (!this.extraHeaders) return null;
+    const arr = [];
+    for (const k in this.extraHeaders) {
+      const v = this.extraHeaders[k];
+      if (Array.isArray(v)) {
+        for (let i = 0; i < v.length; i++) {
+          arr.push(k, v[i]);
+        }
+      } else {
+        arr.push(k, v);
+      }
+    }
+    return arr;
+  }
+
+  send(body) {
+    if (this.responded) return;
+    this.responded = true;
+    const headers = this._getHeadersArray();
+
+    if (Buffer.isBuffer(body)) {
+      this.contentType = this.contentType || 'application/octet-stream';
+      this._server.native.respond(this._raw.reqId, this.statusCode, this.contentType, body, headers);
+    } else if (typeof body === 'object' && body !== null) {
+      this.contentType = this.contentType || 'application/json';
+      this._server.native.respond(this._raw.reqId, this.statusCode, this.contentType, JSON.stringify(body), headers);
+    } else {
+      this.contentType = this.contentType || 'text/plain; charset=utf-8';
+      this._server.native.respond(this._raw.reqId, this.statusCode, this.contentType, String(body ?? ''), headers);
+    }
+  }
+
+  json(body) {
+    if (this.responded) return;
+    this.responded = true;
+    this.contentType = 'application/json';
+    this._server.native.respond(this._raw.reqId, this.statusCode, this.contentType, JSON.stringify(body), this._getHeadersArray());
+  }
+
+  end(data) {
+    this.send(data || '');
+  }
+}
+
+class Router {
+  constructor() {
+    this.routes = [];
+    this.middlewares = [];
+    this._mounted = [];
+  }
+
+  use(prefixOrFn, ...handlers) {
+    if (typeof prefixOrFn === 'string') {
+      const prefix = prefixOrFn;
+      for (const h of handlers) {
+        if (h instanceof Router) {
+          h._mount(this, prefix);
+        } else if (typeof h === 'function') {
+          this.middlewares.push({ prefix, fn: h });
+        }
+      }
+    } else if (prefixOrFn instanceof Router) {
+      prefixOrFn._mount(this, '');
+    } else if (typeof prefixOrFn === 'function') {
+      const all = [prefixOrFn, ...handlers];
+      for (const fn of all) {
+        this.middlewares.push({ prefix: '', fn });
+      }
+    }
+    return this;
+  }
+
+  _addRoute(method, path, ...handlers) {
+    const handler = handlers.pop();
+    const routeMiddlewares = handlers;
+    this.routes.push({ method, path, middlewares: routeMiddlewares, handler });
+    for (const { target, prefix } of this._mounted) {
+      const fullPath = `${prefix}/${path}`.replace(/\/+/g, '/');
+      target._addRoute(method, fullPath, ...routeMiddlewares, handler);
+    }
+    return this;
+  }
+
+  _mount(target, prefix = '') {
+    this._mounted.push({ target, prefix });
+    for (const r of this.routes) {
+      const fullPath = `${prefix}/${r.path}`.replace(/\/+/g, '/');
+      const scopedMiddlewares = this.middlewares
+        .filter((m) => !m.prefix || fullPath.startsWith(m.prefix))
+        .map((m) => m.fn);
+      target._addRoute(r.method, fullPath, ...scopedMiddlewares, ...r.middlewares, r.handler);
+    }
+  }
+
+  get(path, ...handlers) { return this._addRoute('GET', path, ...handlers); }
+  post(path, ...handlers) { return this._addRoute('POST', path, ...handlers); }
+  put(path, ...handlers) { return this._addRoute('PUT', path, ...handlers); }
+  delete(path, ...handlers) { return this._addRoute('DELETE', path, ...handlers); }
+  patch(path, ...handlers) { return this._addRoute('PATCH', path, ...handlers); }
+  all(path, ...handlers) {
+    for (const m of ['GET', 'POST', 'PUT', 'DELETE', 'PATCH']) {
+      this._addRoute(m, path, ...handlers);
+    }
+    return this;
+  }
+}
+
+class BareServer {
+  constructor(options = {}) {
+    const port = typeof options === 'number' ? options : (options.port || 3000);
+    const maxBodySize = typeof options === 'object' && options.maxBodySize ? options.maxBodySize : 52428800;
+    const keepAlive = typeof options === 'object' && options.keepAlive !== undefined ? options.keepAlive : true;
+    this.port = port;
+    this.native = new native.NativeServer(this.port, maxBodySize, keepAlive);
+    this.middlewares = [];
+    this.routes = [];
+    this.handlerCount = 0;
+    this._pathMiddlewares = [];
+
+    this.native.setDispatcher((err, raw) => {
+      if (err || !raw) return;
+      const route = this.routes[raw.handlerId];
+      if (!route) {
+        this.native.respond(raw.reqId, 404, 'text/plain', 'Not Found');
+        return;
+      }
+
+      const req = new BareRequest(raw);
+      const res = new BareResponse(this, raw);
+
+      // Monomorphic fast-path: single handler without middleware
+      if (route.chain.length === 1) {
+        try {
+          const ret = route.handler(req, res);
+          if (ret && typeof ret.catch === 'function') {
+            ret.catch((e) => {
+              if (!res.responded) res.status(500).send(e.message || 'Internal Server Error');
+            });
+          }
+        } catch (e) {
+          if (!res.responded) res.status(500).send(e.message || 'Internal Server Error');
+        }
+        return;
+      }
+
+      // Pre-compiled middleware pipeline with error-handling support
+      const chain = route.chain;
+      let idx = 0;
+
+      function next(err) {
+        if (idx >= chain.length) {
+          if (err && !res.responded) {
+            res.status(500).send(err.message || 'Internal Server Error');
+          }
+          return;
+        }
+        const fn = chain[idx++];
+        let called = false;
+        const stepNext = (nextErr) => {
+          if (called) return;
+          called = true;
+          next(nextErr);
+        };
+
+        try {
+          let ret;
+          if (err) {
+            if (fn.length === 4) {
+              ret = fn(err, req, res, stepNext);
+            } else {
+              next(err);
+            }
+          } else {
+            if (fn.length === 4) {
+              next();
+            } else {
+              ret = fn(req, res, stepNext);
+            }
+          }
+          if (ret && typeof ret.catch === 'function') {
+            ret.catch(stepNext);
+          }
+        } catch (e) {
+          stepNext(e);
+        }
+      }
+
+      next();
+    });
+  }
+
+  cors() {
+    this.native.enableCors();
+    return this;
+  }
+
+  static(path, statusOrBody, maybeBody) {
+    let status = 200;
+    let body = statusOrBody;
+    let contentType = 'text/plain; charset=utf-8';
+
+    if (typeof statusOrBody === 'number') {
+      status = statusOrBody;
+      body = maybeBody;
+    }
+
+    let buf;
+    if (Buffer.isBuffer(body)) {
+      buf = body;
+    } else if (typeof body === 'object' && body !== null) {
+      contentType = 'application/json';
+      buf = Buffer.from(JSON.stringify(body));
+    } else {
+      buf = Buffer.from(String(body ?? ''));
+    }
+
+    this.native.addStaticRoute('GET', path, status, contentType, buf);
+    return this;
+  }
+
+  _buildChain(path, routeMiddlewares, handler) {
+    const all = [
+      ...this.middlewares,
+      ...this._pathMiddlewares.filter((m) => path.startsWith(m.prefix)).map((m) => m.fn),
+      ...routeMiddlewares,
+    ];
+    const normal = all.filter((fn) => fn.length !== 4);
+    const errorHandlers = all.filter((fn) => fn.length === 4);
+    return [...normal, handler, ...errorHandlers];
+  }
+
+  use(prefixOrFn, ...handlers) {
+    if (typeof prefixOrFn === 'string') {
+      const prefix = prefixOrFn;
+      for (const h of handlers) {
+        if (h instanceof Router) {
+          h._mount(this, prefix);
+        } else if (typeof h === 'function') {
+          this._pathMiddlewares.push({ prefix, fn: h });
+        }
+      }
+    } else if (prefixOrFn instanceof Router) {
+      prefixOrFn._mount(this, '');
+    } else if (typeof prefixOrFn === 'function') {
+      const all = [prefixOrFn, ...handlers];
+      for (const fn of all) {
+        this.middlewares.push(fn);
+      }
+      // Re-compile chains for existing routes
+      for (const route of this.routes) {
+        if (route) {
+          route.chain = this._buildChain(route.path, route.middlewares, route.handler);
+        }
+      }
+    }
+    return this;
+  }
+
+  _addRoute(method, path, ...handlers) {
+    const handler = handlers.pop();
+    const routeMiddlewares = handlers;
+    const handlerId = this.handlerCount++;
+
+    const normalizedPath = path.replace(/:([a-zA-Z0-9_]+)/g, '{$1}');
+    const chain = this._buildChain(path, routeMiddlewares, handler);
+
+    this.routes[handlerId] = { path, handler, middlewares: routeMiddlewares, chain };
+    this.native.addRoute(method, normalizedPath, handlerId);
+    return this;
+  }
+
+  get(path, ...handlers) { return this._addRoute('GET', path, ...handlers); }
+  post(path, ...handlers) { return this._addRoute('POST', path, ...handlers); }
+  put(path, ...handlers) { return this._addRoute('PUT', path, ...handlers); }
+  delete(path, ...handlers) { return this._addRoute('DELETE', path, ...handlers); }
+  patch(path, ...handlers) { return this._addRoute('PATCH', path, ...handlers); }
+  all(path, ...handlers) {
+    for (const m of ['GET', 'POST', 'PUT', 'DELETE', 'PATCH']) {
+      this._addRoute(m, path, ...handlers);
+    }
+    return this;
+  }
+
+  async listen(portOrCallback, hostOrCallback, maybeCallback) {
+    let port = this.port;
+    let callback;
+
+    if (typeof portOrCallback === 'number') {
+      port = portOrCallback;
+      this.port = port;
+      if (typeof hostOrCallback === 'function') {
+        callback = hostOrCallback;
+      } else if (typeof maybeCallback === 'function') {
+        callback = maybeCallback;
+      }
+    } else if (typeof portOrCallback === 'function') {
+      callback = portOrCallback;
+    }
+
+    const url = await this.native.listen(port);
+    if (callback) callback(url);
+    return url;
+  }
+
+  setBodyLimit(bytes) {
+    this.native.setMaxBodySize(bytes);
+    return this;
+  }
+
+  setKeepAlive(enabled) {
+    this.native.setKeepAlive(enabled);
+    return this;
+  }
+
+  close(callback) {
+    const p = this.native.stop();
+    if (typeof callback === 'function') {
+      p.then(() => callback(null), (err) => callback(err));
+    }
+    return p;
+  }
+}
+
+function express(options) {
+  return new BareServer(options);
+}
+
+express.BareServer = BareServer;
+express.Router = () => new Router();
+express.json = () => (req, res, next) => {
+  const ct = req.get('content-type') || '';
+  if (ct.includes('application/json') && req._rawBody && req._rawBody.length > 0) {
+    try {
+      JSON.parse(req._rawBody.toString('utf8'));
+    } catch {
+      res.status(400).json({ error: 'Invalid JSON payload' });
+      return;
+    }
+  }
+  next();
+};
+express.urlencoded = () => (req, res, next) => next();
+express.raw = () => (req, res, next) => next();
+express.text = () => (req, res, next) => next();
+express.default = express;
+
+module.exports = express;

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "bareserver",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Zero-dependency, native-fast HTTP server for Node.js",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "optionalDependencies": {
+    "bareserver-darwin-arm64": "0.1.1",
+    "bareserver-darwin-x64": "0.1.1",
+    "bareserver-linux-x64-gnu": "0.1.1",
+    "bareserver-win32-x64-msvc": "0.1.1"
+  },
+  "scripts": {
+    "build": "cargo build --release && (cp target/release/libbareserver.dylib index.node 2>/dev/null || cp target/release/libbareserver.so index.node 2>/dev/null || true)",
+    "test": "node test.js",
+    "test:chaos": "node test_chaos.js"
+  },
+  "devDependencies": {
+    "@hono/node-server": "^2.1.6",
+    "autocannon": "^8.0.0",
+    "cookie-parser": "^1.4.7",
+    "cpeak": "^2.10.0",
+    "express": "^4.21.0",
+    "fastify": "^5.0.0",
+    "helmet": "^8.0.0",
+    "hono": "^4.13.17",
+    "hyper-express": "^7.0.2",
+    "ultimate-express": "^2.2.4"
+  },
+  "keywords": [
+    "http",
+    "fastify",
+    "express",
+    "rust",
+    "native"
+  ],
+  "author": "tarunbtw",
+  "license": "MIT"
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.