@nextrush/runtime

// Runtime detection
import {
  detectRuntime,
  getRuntime,
  getRuntimeVersion,
  getRuntimeInfo,
  getRuntimeCapabilities,
  detectEdgeRuntime,
  resetRuntimeCache,
} from '@nextrush/runtime';

// Runtime checks
import { isRuntime, isNode, isBun, isDeno, isEdge } from '@nextrush/runtime';

// Body source abstraction
import {
  AbstractBodySource,
  WebBodySource,
  EmptyBodySource,
  createWebBodySource,
  createEmptyBodySource,
  BodyConsumedError,
  BodyTooLargeError,
  DEFAULT_BODY_LIMIT,
} from '@nextrush/runtime';

// Query string parsing
import { parseQueryString } from '@nextrush/runtime';

// Headers utilities
import { headersToRecord, getClientIp, getEdgeClientIp } from '@nextrush/runtime';

// Constants
import { METHODS_WITHOUT_BODY } from '@nextrush/runtime';

// Types
import type {
  Runtime,
  RuntimeInfo,
  RuntimeCapabilities,
  BodySource,
  BodySourceOptions,
  EdgeRuntimeInfo,
} from '@nextrush/runtime';

import { getRuntime, getRuntimeVersion } from '@nextrush/runtime';

const runtime = getRuntime();
// 'node' | 'bun' | 'deno' | 'deno-deploy' | 'cloudflare-workers'
// | 'vercel-edge' | 'edge' | 'unknown'

const version = getRuntimeVersion();
// '20.10.0' (Node.js)
// '1.0.0' (Bun)
// '1.38.0' (Deno)

import { detectRuntime, getRuntime } from '@nextrush/runtime';

// detectRuntime() — always runs full detection logic
const runtime1 = detectRuntime();

// getRuntime() — caches the result after first call (recommended)
const runtime2 = getRuntime(); // First call: detects and caches
const runtime3 = getRuntime(); // Subsequent calls: returns cached value

import { isNode, isBun, isDeno, isEdge, isRuntime } from '@nextrush/runtime';

if (isNode()) {
  // Node.js specific code
}

if (isBun()) {
  // Bun specific optimization
}

if (isDeno()) {
  // Deno specific code (does NOT match Deno Deploy)
}

if (isEdge()) {
  // Returns true for Cloudflare Workers, Vercel Edge, and generic edge
}

// Check for a specific runtime
if (isRuntime('cloudflare-workers')) {
  // Cloudflare Workers specific code
}

if (isRuntime('deno-deploy')) {
  // Deno Deploy specific code
}

import { getRuntimeCapabilities } from '@nextrush/runtime';

const caps = getRuntimeCapabilities();

if (caps.fileSystem) {
  // Safe to use fs operations
}

if (caps.webStreams) {
  // Safe to use ReadableStream
}

if (caps.cryptoSubtle) {
  // Safe to use crypto.subtle
}

import { detectEdgeRuntime } from '@nextrush/runtime';
import type { EdgeRuntimeInfo } from '@nextrush/runtime';

const edgeInfo: EdgeRuntimeInfo = detectEdgeRuntime();
// {
//   runtime: 'cloudflare-workers',
//   isCloudflare: true,
//   isVercel: false,
//   isNetlify: false,
//   isGenericEdge: false,
// }

import { getRuntimeInfo } from '@nextrush/runtime';

const info = getRuntimeInfo();

interface BodySource {
  text(): Promise<string>;
  buffer(): Promise<Uint8Array>;
  json<T = unknown>(): Promise<T>;
  stream(): NodeStreamLike | WebStreamLike;
  readonly consumed: boolean;
  readonly contentLength: number | undefined;
  readonly contentType: string | undefined;
}

import { WebBodySource, createWebBodySource } from '@nextrush/runtime';

const request = new Request('https://example.com', {
  method: 'POST',
  body: JSON.stringify({ name: 'Alice' }),
  headers: { 'Content-Type': 'application/json' },
});

// Using factory function
const bodySource = createWebBodySource(request, {
  limit: 1024 * 1024, // 1MB limit (default)
});

const data = await bodySource.json();
// { name: 'Alice' }

// Or using the class directly
const bodySource2 = new WebBodySource(request, { limit: 512 * 1024 });

import { createEmptyBodySource } from '@nextrush/runtime';

const emptyBody = createEmptyBodySource();

await emptyBody.text(); // ''
await emptyBody.buffer(); // Uint8Array(0)
await emptyBody.json(); // throws BadRequestError (code: 'EMPTY_BODY_JSON')

import { AbstractBodySource } from '@nextrush/runtime';
import type { IncomingMessage } from 'node:http';

export class NodeBodySource extends AbstractBodySource {
  private readonly req: IncomingMessage;

  constructor(req: IncomingMessage) {
    super(req.headers['content-length'], req.headers['content-type']);
    this.req = req;
  }

  protected async _buffer(): Promise<Uint8Array> {
    const chunks: Buffer[] = [];
    for await (const chunk of this.req) {
      chunks.push(chunk);
    }
    return Buffer.concat(chunks);
  }

  protected _stream() {
    return this.req;
  }
}

import { BodyConsumedError, BodyTooLargeError } from '@nextrush/runtime';

// BodyConsumedError — thrown when body is read twice
try {
  await bodySource.text();
  await bodySource.json(); // throws BodyConsumedError
} catch (err) {
  if (err instanceof BodyConsumedError) {
    // Body was already read
  }
}

// BodyTooLargeError — thrown when body exceeds size limit
const limited = new WebBodySource(request, { limit: 1024 });

try {
  await limited.buffer();
} catch (err) {
  if (err instanceof BodyTooLargeError) {
    console.log(`Limit: ${err.limit}, Received: ${err.received}`);
  }
}

import { parseQueryString } from '@nextrush/runtime';

const params = parseQueryString('name=Alice&age=30&tag=a&tag=b');
// { name: 'Alice', age: '30', tag: ['a', 'b'] }

import { headersToRecord } from '@nextrush/runtime';

const headers = new Headers();
headers.append('Content-Type', 'application/json');
headers.append('Accept', 'text/html');
headers.append('Accept', 'application/json');

const record = headersToRecord(headers);
// { 'content-type': 'application/json', accept: ['text/html', 'application/json'] }

import { getClientIp } from '@nextrush/runtime';

const ip = getClientIp(request, directSocketIp, trustProxy);

import { getEdgeClientIp } from '@nextrush/runtime';

const ip = getEdgeClientIp(request, trustProxy);

import { METHODS_WITHOUT_BODY } from '@nextrush/runtime';

// ReadonlySet<string> containing: 'GET', 'HEAD', 'OPTIONS', 'TRACE'
// DELETE is intentionally excluded — RFC 7231 §4.3.5 permits a body on DELETE

import type {
  Runtime,
  RuntimeInfo,
  RuntimeCapabilities,
  BodySource,
  BodySourceOptions,
  EdgeRuntimeInfo,
} from '@nextrush/runtime';

type Runtime =
  | 'node'
  | 'bun'
  | 'deno'
  | 'deno-deploy'
  | 'cloudflare-workers'
  | 'vercel-edge'
  | 'edge'
  | 'unknown';

interface RuntimeCapabilities {
  nodeStreams: boolean;
  webStreams: boolean;
  fileSystem: boolean;
  webSocket: boolean;
  fetch: boolean;
  cryptoSubtle: boolean;
  workers: boolean;
}

interface RuntimeInfo {
  runtime: Runtime;
  version: string | undefined;
  capabilities: RuntimeCapabilities;
}