4.0.1

fix:(exports)
BREAKING CHANGE(core): major architectural refactoring with cross-platform support and SmartRequest rename
2025-07-29 00:19:30 +00:00 · 2025-07-29 00:19:19 +00:00 · 2025-07-28 23:20:52 +00:00 · 2025-07-28 22:50:12 +00:00 · 2025-07-28 22:37:36 +00:00 · 2025-07-28 17:23:48 +00:00
35 changed files with 2934 additions and 3369 deletions
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,34 @@
 # Changelog
 ## 2025-07-28 - 4.0.0 - BREAKING CHANGE(core)
 Complete architectural overhaul with cross-platform support
 **Breaking Changes:**
 - Renamed `SmartRequestClient` to `SmartRequest` for simpler, cleaner API
 - Removed legacy API entirely (no more `/legacy` import path)
 - Major architectural refactoring:
  - Added abstraction layer with `core_base` containing abstract classes
  - Split implementations into `core_node` (Node.js) and `core_fetch` (browser)
  - Dynamic implementation selection based on environment
 - Response streaming API changes:
  - `stream()` now always returns web-style `ReadableStream<Uint8Array>`
  - Added `streamNode()` for Node.js streams (throws error in browser)
 - Unified type system with single `ICoreRequestOptions` interface
 - Removed all "Abstract" prefixes from type names
 **Features:**
 - Full cross-platform support (Node.js and browsers)
 - Automatic platform detection using @push.rocks/smartenv
 - Consistent API across platforms with platform-specific capabilities
 - Web Streams API support in both environments
 - Better error messages for unsupported platform features
 **Documentation:**
 - Completely rewritten README with platform-specific examples
 - Added architecture overview section
 - Added migration guide from v2.x and v3.x
 - Updated all examples to use the new `SmartRequest` class name
 ## 2025-07-27 - 3.0.0 - BREAKING CHANGE(core)
 Major architectural refactoring with fetch-like API
--- a/package.json
+++ b/package.json
@@ -1,15 +1,16 @@
 {
  "name": "@push.rocks/smartrequest",
-  "version": "3.0.0",
+  "version": "4.0.1",
  "private": false,
  "description": "A module for modern HTTP/HTTPS requests with support for form data, file uploads, JSON, binary data, streams, and more.",
  "exports": {
-    ".": "./dist_ts_web/index.js",
+    ".": "./dist_ts/index.js",
-    "./legacy": "./dist_ts/legacy/index.js"
+    "./core_node": "./dist_ts/core_node/index.js",
    "./core_fetch": "./dist_ts/core_fetch/index.js"
  },
  "type": "module",
  "scripts": {
-    "test": "(tstest test/ --web)",
+    "test": "(tstest test/ --verbose)",
    "build": "(tsbuild --web)",
    "buildDocs": "tsdoc"
  },
@@ -38,16 +39,17 @@
  },
  "homepage": "https://code.foss.global/push.rocks/smartrequest",
  "dependencies": {
    "@push.rocks/smartenv": "^5.0.13",
    "@push.rocks/smartpath": "^6.0.0",
    "@push.rocks/smartpromise": "^4.0.4",
    "@push.rocks/smarturl": "^3.1.0",
    "agentkeepalive": "^4.5.0",
-    "form-data": "^4.0.1"
+    "form-data": "^4.0.4"
  },
  "devDependencies": {
-    "@git.zone/tsbuild": "^2.2.0",
+    "@git.zone/tsbuild": "^2.6.4",
    "@git.zone/tsrun": "^1.3.3",
-    "@git.zone/tstest": "^1.0.90",
+    "@git.zone/tstest": "^2.3.2",
    "@pushrocks/tapbundle": "^5.0.8",
    "@types/node": "^22.9.0"
  },
  "files": [
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/readme.hints.md
+++ b/readme.hints.md
@@ -11,44 +11,69 @@
 - written in TypeScript
 - continuously updated
 - uses node native http and https modules
 - supports both Node.js and browser environments
 - used in modules like @push.rocks/smartproxy and @api.global/typedrequest
-## Architecture Overview (as of latest refactoring)
+## Architecture Overview (as of v3.0.0 major refactoring)
- The project is now structured with a clean separation between core functionality and API layers
+- The project now has a multi-layer architecture with platform abstraction
- Core module (ts/core/) contains the essential HTTP request logic using Node.js http/https modules
+- Base layer (ts/core_base/) contains abstract classes and unified types
- **Core always returns raw streams** - no parsing or body collection happens in the core request function
+- Node.js implementation (ts/core_node/) uses native http/https modules
- Modern API (ts/modern/) provides a fluent, chainable interface with fetch-like Response objects
+- Fetch implementation (ts/core_fetch/) uses Fetch API for browser compatibility
- Legacy API is maintained through a thin adapter layer for backward compatibility
+- Core module (ts/core/) dynamically selects the appropriate implementation based on environment
 - Client API (ts/client/) provides a fluent, chainable interface  
 - Legacy API has been completely removed in v3.0.0
 ## Key Components
-### Core Module (ts/core/)
+### Core Base Module (ts/core_base/)
- `request.ts`: Core HTTP/HTTPS request logic with unix socket support and keep-alive agents
+- `request.ts`: Abstract CoreRequest class defining the request interface
-  - `coreRequest()` always returns a raw Node.js IncomingMessage stream
+- `response.ts`: Abstract CoreResponse class with fetch-like API
-  - No response parsing or body collection happens here
+  - Defines `stream()` method that always returns web-style ReadableStream
 - `response.ts`: SmartResponse class providing fetch-like API
  - Methods like `json()`, `text()`, `arrayBuffer()` handle all parsing and body collection
  - Response body is streamed and collected only when these methods are called
  - Body can only be consumed once (throws error on second attempt)
- `types.ts`: Core TypeScript interfaces and types
+- `types.ts`: Unified TypeScript interfaces and types
- `plugins.ts`: Centralized dependencies
+  - Single `ICoreRequestOptions` interface for all implementations
  - Implementations handle unsupported options by throwing errors
-### Modern API
+### Core Node Module (ts/core_node/)
- SmartRequestClient: Fluent API with method chaining
+- `request.ts`: Node.js implementation using http/https modules
- Returns SmartResponse objects with fetch-like methods
+  - Supports unix socket connections and keep-alive agents
  - Converts Node.js specific options from unified interface
 - `response.ts`: Node.js CoreResponse implementation
  - `stream()` method converts Node.js stream to web ReadableStream
  - `streamNode()` method returns native Node.js stream
  - Methods like `json()`, `text()`, `arrayBuffer()` handle parsing
 ### Core Fetch Module (ts/core_fetch/)
 - `request.ts`: Fetch API implementation for browsers
  - Throws errors for Node.js specific options (agent, socketPath)
  - Native support for CORS, credentials, and other browser features
 - `response.ts`: Fetch-based CoreResponse implementation
  - `stream()` returns native web ReadableStream from response.body
  - `streamNode()` throws error explaining it's not available in browser
 ### Core Module (ts/core/)
 - Dynamically loads appropriate implementation based on environment
 - Uses @push.rocks/smartenv for environment detection
 - Exports unified types from core_base
 ### Client API (ts/client/)
 - SmartRequest: Fluent API with method chaining
 - Returns CoreResponse objects with fetch-like methods
 - Supports pagination, retries, timeouts, and various response types
-### Binary Request Handling
+### Stream Handling
- Binary requests are handled correctly when `responseType: 'binary'` is set
+- `stream()` method always returns web-style ReadableStream<Uint8Array>
- Response body is kept as Buffer without string conversion
+- In Node.js, converts native streams to web streams
- No automatic transformations applied to binary data
+- `streamNode()` available only in Node.js environment for native streams
 - Consistent API across platforms while preserving platform-specific capabilities
-### Legacy Compatibility
+### Binary Request Handling
- All legacy functions (getJson, postJson, etc.) are maintained through adapter.ts
+- Binary requests handled through ArrayBuffer API
- Legacy API returns IExtendedIncomingMessage for backward compatibility
+- Response body kept as Buffer/ArrayBuffer without string conversion
- Modern API can be accessed alongside legacy API
+- No automatic transformations applied to binary data
 ## Testing
 - Use `pnpm test` to run all tests
- Modern API tests use the new SmartResponse methods (response.json(), response.text())
+- Tests use @git.zone/tstest/tapbundle for assertions
- Legacy API tests continue to use the body property directly
+- Separate test files for Node.js (test.node.ts) and browser (test.browser.ts)
 - Browser tests run in headless Chromium via puppeteer
--- a/readme.md
+++ b/readme.md
@@ -1,9 +1,7 @@
 # @push.rocks/smartrequest
-A modern HTTP/HTTPS request library for Node.js with support for form data, file uploads, JSON, binary data, streams, and unix sockets. Features both a legacy API for backward compatibility and a modern fetch-like API for new projects.
+A modern, cross-platform HTTP/HTTPS request library for Node.js and browsers with a unified API, supporting form data, file uploads, JSON, binary data, streams, and unix sockets.
 ## Install
 To install `@push.rocks/smartrequest`, use one of the following commands:
 ```bash
 # Using npm
 npm install @push.rocks/smartrequest --save
@@ -15,156 +13,41 @@ pnpm add @push.rocks/smartrequest
 yarn add @push.rocks/smartrequest
 ```
 This will add `@push.rocks/smartrequest` to your project's dependencies.
 ## Key Features
 - 🚀 **Modern Fetch-like API** - Familiar response methods (`.json()`, `.text()`, `.arrayBuffer()`, `.stream()`)
- 🔄 **Two API Styles** - Legacy function-based API and modern fluent chainable API
+- 🌐 **Cross-Platform** - Works in both Node.js and browsers with a unified API
- 🌐 **Unix Socket Support** - Connect to local services like Docker
+- 🔌 **Unix Socket Support** - Connect to local services like Docker (Node.js only)
 - 📦 **Form Data & File Uploads** - Built-in support for multipart/form-data
 - 🔁 **Pagination Support** - Multiple strategies (offset, cursor, Link headers)
- ⚡ **Keep-Alive Connections** - Efficient connection pooling
+- ⚡ **Keep-Alive Connections** - Efficient connection pooling in Node.js
 - 🛡️ **TypeScript First** - Full type safety and IntelliSense support
 - 🎯 **Zero Magic Defaults** - Explicit configuration following fetch API principles
- 🔌 **Streaming Support** - Handle large files and real-time data
+- 📡 **Streaming Support** - Handle large files and real-time data
 - 🔧 **Highly Configurable** - Timeouts, retries, headers, and more
 ## Architecture
 SmartRequest v3.0 features a multi-layer architecture that provides consistent behavior across platforms:
 - **Core Base** - Abstract classes and unified types shared across implementations
 - **Core Node** - Node.js implementation using native http/https modules
 - **Core Fetch** - Browser implementation using the Fetch API
 - **Core** - Dynamic implementation selection based on environment
 - **Client** - High-level fluent API for everyday use
 ## Usage
-`@push.rocks/smartrequest` is designed as a versatile, modern HTTP client library for making HTTP/HTTPS requests in Node.js environments. It provides a clean, type-safe API inspired by the native fetch API but with additional features needed for server-side applications.
+`@push.rocks/smartrequest` provides a clean, type-safe API inspired by the native fetch API but with additional features needed for modern applications.
-The library provides two distinct APIs:
+### Basic Usage
 1. **Legacy API** - Simple function-based API for quick requests and backward compatibility
 2. **Modern Fluent API** - A chainable, fetch-like API for more complex scenarios
 Below we will cover key usage scenarios of `@push.rocks/smartrequest`, showcasing its capabilities and providing you with a solid starting point to integrate it into your projects.
 ### Import Guide
 ```typescript
-// Modern API (recommended for new projects)
+import { SmartRequest } from '@push.rocks/smartrequest';
 import { SmartRequestClient } from '@push.rocks/smartrequest';
 // Legacy API (for backward compatibility)
 import { getJson, postJson, request } from '@push.rocks/smartrequest/legacy';
 ```
 ### Simple GET Request
 For fetching data from a REST API or any web service that returns JSON:
 ```typescript
 import { getJson } from '@push.rocks/smartrequest/legacy';
 async function fetchGitHubUserInfo(username: string) {
  const response = await getJson(`https://api.github.com/users/${username}`);
  console.log(response.body); // The body contains the JSON response
 }
 fetchGitHubUserInfo('octocat');
 ```
 The `getJson` function simplifies the process of sending a GET request and parsing the JSON response.
 ### POST Requests with JSON
 When you need to send JSON data to a server, for example, creating a new resource:
 ```typescript
 import { postJson } from '@push.rocks/smartrequest/legacy';
 async function createTodoItem(todoDetails: { title: string; completed: boolean }) {
  const response = await postJson('https://jsonplaceholder.typicode.com/todos', {
    requestBody: todoDetails
  });
  console.log(response.body); // Log the created todo item
 }
 createTodoItem({ title: 'Implement smartrequest', completed: false });
 ```
 `postJson` handles setting the appropriate content-type header and stringifies the JSON body.
 ### Handling Form Data and File Uploads
 `@push.rocks/smartrequest` simplifies the process of uploading files and submitting form data to a server:
 ```typescript
 import { postFormData, IFormField } from '@push.rocks/smartrequest/legacy';
 async function uploadProfilePicture(formDataFields: IFormField[]) {
  await postFormData('https://api.example.com/upload', {}, formDataFields);
 }
 uploadProfilePicture([
  { name: 'avatar', type: 'filePath', payload: './path/to/avatar.jpg', fileName: 'avatar.jpg', contentType: 'image/jpeg' },
  { name: 'user_id', type: 'string', payload: '12345' }
 ]);
 ```
 ### Streaming Support
 For cases when dealing with large datasets or streaming APIs, `@push.rocks/smartrequest` provides streaming capabilities:
 ```typescript
 import { getStream } from '@push.rocks/smartrequest/legacy';
 async function streamLargeFile(url: string) {
  const stream = await getStream(url);
  stream.on('data', (chunk) => {
    console.log('Received chunk of data.');
  });
  stream.on('end', () => {
    console.log('Stream ended.');
  });
 }
 streamLargeFile('https://example.com/largefile');
 ```
 `getStream` allows you to handle data as it's received, which can be beneficial for performance and scalability.
 ### Advanced Options and Customization
 `@push.rocks/smartrequest` is built to be flexible, allowing you to specify additional options to tailor requests to your needs:
 ```typescript
 import { request, ISmartRequestOptions } from '@push.rocks/smartrequest/legacy';
 async function customRequestExample() {
  const options: ISmartRequestOptions = {
    method: 'GET',
    headers: {
      'Custom-Header': 'Value'
    },
    keepAlive: true // Enables connection keep-alive
  };
  const response = await request('https://example.com/data', options);
  console.log(response.body);
 }
 customRequestExample();
 ```
 `request` is the underlying function that powers the simpler `getJson`, `postJson`, etc., and provides you with full control over the HTTP request.
 ## Modern Fluent API
 In addition to the legacy API shown above, `@push.rocks/smartrequest` provides a modern, fluent API with a fetch-like response interface that offers a more chainable and TypeScript-friendly approach to making HTTP requests.
 ### Basic Usage with the Modern API
 ```typescript
 import { SmartRequestClient } from '@push.rocks/smartrequest';
 // Simple GET request
 async function fetchUserData(userId: number) {
-  const response = await SmartRequestClient.create()
+  const response = await SmartRequest.create()
    .url(`https://jsonplaceholder.typicode.com/users/${userId}`)
    .get();
@@ -175,7 +58,7 @@ async function fetchUserData(userId: number) {
 // POST request with JSON body
 async function createPost(title: string, body: string, userId: number) {
-  const response = await SmartRequestClient.create()
+  const response = await SmartRequest.create()
    .url('https://jsonplaceholder.typicode.com/posts')
    .json({ title, body, userId })
    .post();
@@ -185,13 +68,34 @@ async function createPost(title: string, body: string, userId: number) {
 }
 ```
 ### Direct Core API Usage
 For advanced use cases, you can use the Core API directly:
 ```typescript
 import { CoreRequest } from '@push.rocks/smartrequest';
 async function directCoreRequest() {
  const request = new CoreRequest('https://api.example.com/data', {
    method: 'GET',
    headers: {
      'Accept': 'application/json'
    }
  });
  const response = await request.fire();
  const data = await response.json();
  return data;
 }
 ```
 ### Setting Headers and Query Parameters
 ```typescript
-import { SmartRequestClient } from '@push.rocks/smartrequest';
+import { SmartRequest } from '@push.rocks/smartrequest';
 async function searchRepositories(query: string, perPage: number = 10) {
-  const response = await SmartRequestClient.create()
+  const response = await SmartRequest.create()
    .url('https://api.github.com/search/repositories')
    .header('Accept', 'application/vnd.github.v3+json')
    .query({
@@ -208,10 +112,10 @@ async function searchRepositories(query: string, perPage: number = 10) {
 ### Handling Timeouts and Retries
 ```typescript
-import { SmartRequestClient } from '@push.rocks/smartrequest';
+import { SmartRequest } from '@push.rocks/smartrequest';
 async function fetchWithRetry(url: string) {
-  const response = await SmartRequestClient.create()
+  const response = await SmartRequest.create()
    .url(url)
    .timeout(5000) // 5 seconds timeout
    .retry(3) // Retry up to 3 times on failure
@@ -223,14 +127,14 @@ async function fetchWithRetry(url: string) {
 ### Working with Different Response Types
-The modern API provides a fetch-like interface for handling different response types:
+The API provides a fetch-like interface for handling different response types:
 ```typescript
-import { SmartRequestClient } from '@push.rocks/smartrequest';
+import { SmartRequest } from '@push.rocks/smartrequest';
 // JSON response (default)
 async function fetchJson(url: string) {
-  const response = await SmartRequestClient.create()
+  const response = await SmartRequest.create()
    .url(url)
    .get();
@@ -239,7 +143,7 @@ async function fetchJson(url: string) {
 // Text response
 async function fetchText(url: string) {
-  const response = await SmartRequestClient.create()
+  const response = await SmartRequest.create()
    .url(url)
    .get();
@@ -248,7 +152,7 @@ async function fetchText(url: string) {
 // Binary data
 async function downloadImage(url: string) {
-  const response = await SmartRequestClient.create()
+  const response = await SmartRequest.create()
    .url(url)
    .accept('binary') // Optional: hints to server we want binary
    .get();
@@ -257,36 +161,113 @@ async function downloadImage(url: string) {
  return Buffer.from(buffer); // Convert ArrayBuffer to Buffer if needed
 }
-// Streaming response
+// Streaming response (Web Streams API)
 async function streamLargeFile(url: string) {
-  const response = await SmartRequestClient.create()
+  const response = await SmartRequest.create()
    .url(url)
    .get();
-  // Get the underlying Node.js stream
+  // Get a web-style ReadableStream (works in both Node.js and browsers)
  const stream = response.stream();
-  stream.on('data', (chunk) => {
+  if (stream) {
    const reader = stream.getReader();
    try {
      while (true) {
        const { done, value } = await reader.read();
        if (done) break;
        console.log(`Received ${value.length} bytes of data`);
      }
    } finally {
      reader.releaseLock();
    }
  }
 }
 // Node.js specific stream (only in Node.js environment)
 async function streamWithNodeApi(url: string) {
  const response = await SmartRequest.create()
    .url(url)
    .get();
  // Only available in Node.js, throws error in browser
  const nodeStream = response.streamNode();
  nodeStream.on('data', (chunk) => {
    console.log(`Received ${chunk.length} bytes of data`);
  });
  return new Promise((resolve, reject) => {
-    stream.on('end', resolve);
+    nodeStream.on('end', resolve);
-    stream.on('error', reject);
+    nodeStream.on('error', reject);
  });
 }
 ```
 ### Response Object Methods
 The response object provides these methods:
 - `json<T>(): Promise<T>` - Parse response as JSON
 - `text(): Promise<string>` - Get response as text
 - `arrayBuffer(): Promise<ArrayBuffer>` - Get response as ArrayBuffer
 - `stream(): ReadableStream<Uint8Array> | null` - Get web-style ReadableStream (cross-platform)
 - `streamNode(): NodeJS.ReadableStream` - Get Node.js stream (Node.js only, throws in browser)
 - `raw(): Response | http.IncomingMessage` - Get the underlying platform response
 Each body method can only be called once per response, similar to the fetch API.
 ## Advanced Features
 ### Form Data with File Uploads
 ```typescript
 import { SmartRequest } from '@push.rocks/smartrequest';
 import * as fs from 'fs';
 async function uploadMultipleFiles(files: Array<{name: string, path: string}>) {
  const formFields = files.map(file => ({
    name: 'files',
    value: fs.readFileSync(file.path),
    filename: file.name,
    contentType: 'application/octet-stream'
  }));
  const response = await SmartRequest.create()
    .url('https://api.example.com/upload')
    .formData(formFields)
    .post();
  return await response.json();
 }
 ```
 ### Unix Socket Support (Node.js only)
 ```typescript
 import { SmartRequest } from '@push.rocks/smartrequest';
 // Connect to a service via Unix socket
 async function queryViaUnixSocket() {
  const response = await SmartRequest.create()
    .url('http://unix:/var/run/docker.sock:/v1.24/containers/json')
    .get();
  return await response.json();
 }
 ```
 ### Pagination Support
-The modern API includes built-in support for various pagination strategies:
+The library includes built-in support for various pagination strategies:
 ```typescript
-import { SmartRequestClient, PaginationStrategy } from '@push.rocks/smartrequest';
+import { SmartRequest } from '@push.rocks/smartrequest';
 // Offset-based pagination (page & limit)
 async function fetchAllUsers() {
-  const client = SmartRequestClient.create()
+  const client = SmartRequest.create()
    .url('https://api.example.com/users')
    .withOffsetPagination({
      pageParam: 'page',
@@ -314,7 +295,7 @@ async function fetchAllUsers() {
 // Cursor-based pagination
 async function fetchAllPosts() {
-  const allPosts = await SmartRequestClient.create()
+  const allPosts = await SmartRequest.create()
    .url('https://api.example.com/posts')
    .withCursorPagination({
      cursorParam: 'cursor',
@@ -328,7 +309,7 @@ async function fetchAllPosts() {
 // Link header-based pagination (GitHub API style)
 async function fetchAllIssues(repo: string) {
-  const paginatedResponse = await SmartRequestClient.create()
+  const paginatedResponse = await SmartRequest.create()
    .url(`https://api.github.com/repos/${repo}/issues`)
    .header('Accept', 'application/vnd.github.v3+json')
    .withLinkPagination()
@@ -338,56 +319,17 @@ async function fetchAllIssues(repo: string) {
 }
 ```
-### Advanced Features
+### Keep-Alive Connections (Node.js)
 #### Unix Socket Support
 ```typescript
-import { SmartRequestClient } from '@push.rocks/smartrequest';
+import { SmartRequest } from '@push.rocks/smartrequest';
 // Connect to a service via Unix socket
 async function queryViaUnixSocket() {
  const response = await SmartRequestClient.create()
    .url('http://unix:/var/run/docker.sock:/v1.24/containers/json')
    .get();
  return await response.json();
 }
 ```
 #### Form Data with File Uploads
 ```typescript
 import { SmartRequestClient } from '@push.rocks/smartrequest';
 async function uploadMultipleFiles(files: Array<{name: string, path: string}>) {
  const formFields = files.map(file => ({
    name: 'files',
    value: fs.readFileSync(file.path),
    filename: file.name,
    contentType: 'application/octet-stream'
  }));
  const response = await SmartRequestClient.create()
    .url('https://api.example.com/upload')
    .formData(formFields)
    .post();
  return await response.json();
 }
 ```
 #### Keep-Alive Connections
 ```typescript
 import { SmartRequestClient } from '@push.rocks/smartrequest';
 // Enable keep-alive for better performance with multiple requests
 async function performMultipleRequests() {
-  const client = SmartRequestClient.create()
+  const client = SmartRequest.create()
    .header('Connection', 'keep-alive');
-  // Requests will reuse the same connection
+  // Requests will reuse the same connection in Node.js
  const results = await Promise.all([
    client.url('https://api.example.com/endpoint1').get(),
    client.url('https://api.example.com/endpoint2').get(),
@@ -398,44 +340,46 @@ async function performMultipleRequests() {
 }
 ```
-### Response Object Methods
+## Platform-Specific Features
-The modern API returns a `SmartResponse` object with the following methods:
+### Browser-Specific Options
- `json<T>(): Promise<T>` - Parse response as JSON
+When running in a browser, you can use browser-specific fetch options:
 - `text(): Promise<string>` - Get response as text
 - `arrayBuffer(): Promise<ArrayBuffer>` - Get response as ArrayBuffer
 - `stream(): NodeJS.ReadableStream` - Get the underlying Node.js stream
 - `raw(): http.IncomingMessage` - Get the raw http.IncomingMessage
 Each body method can only be called once per response, similar to the fetch API.
 Through its comprehensive set of features tailored for modern web development, `@push.rocks/smartrequest` aims to provide developers with a powerful tool for handling HTTP/HTTPS requests efficiently. Whether it's a simple API call, handling form data, processing streams, or working with paginated APIs, `@push.rocks/smartrequest` delivers a robust, type-safe solution to fit your project's requirements.
 ## Migration Guide: Legacy API to Modern API
 If you're currently using the legacy API and want to migrate to the modern fluent API, here's a quick reference guide:
 | Legacy API | Modern API |
 |------------|------------|
 | `getJson(url)` | `SmartRequestClient.create().url(url).get()` |
 | `postJson(url, { requestBody: data })` | `SmartRequestClient.create().url(url).json(data).post()` |
 | `putJson(url, { requestBody: data })` | `SmartRequestClient.create().url(url).json(data).put()` |
 | `delJson(url)` | `SmartRequestClient.create().url(url).delete()` |
 | `postFormData(url, {}, fields)` | `SmartRequestClient.create().url(url).formData(fields).post()` |
 | `getStream(url)` | `SmartRequestClient.create().url(url).accept('stream').get()` |
 | `request(url, options)` | `SmartRequestClient.create().url(url).[...configure options...].get()` |
 The modern API provides more flexibility and better TypeScript integration, making it the recommended approach for new projects.
 ## Complete Examples
 ### Building a REST API Client
 Here's a complete example of building a typed API client using smartrequest:
 ```typescript
-import { SmartRequestClient, type SmartResponse } from '@push.rocks/smartrequest';
+const response = await SmartRequest.create()
  .url('https://api.example.com/data')
  .option({
    credentials: 'include', // Include cookies
    mode: 'cors',          // CORS mode
    cache: 'no-cache',     // Cache mode
    referrerPolicy: 'no-referrer'
  })
  .get();
 ```
 ### Node.js-Specific Options
 When running in Node.js, you can use Node-specific options:
 ```typescript
 import { Agent } from 'https';
 const response = await SmartRequest.create()
  .url('https://api.example.com/data')
  .option({
    agent: new Agent({ keepAlive: true }), // Custom agent
    socketPath: '/var/run/api.sock',       // Unix socket
  })
  .get();
 ```
 ## Complete Example: Building a REST API Client
 Here's a complete example of building a typed API client:
 ```typescript
 import { SmartRequest, type CoreResponse } from '@push.rocks/smartrequest';
 interface User {
  id: number;
@@ -454,7 +398,7 @@ class BlogApiClient {
  private baseUrl = 'https://jsonplaceholder.typicode.com';
  private async request(path: string) {
-    return SmartRequestClient.create()
+    return SmartRequest.create()
      .url(`${this.baseUrl}${path}`)
      .header('Accept', 'application/json');
  }
@@ -497,14 +441,14 @@ const user = await api.getUser(1);
 const posts = await api.getAllPosts(user.id);
 ```
-### Error Handling
+## Error Handling
 ```typescript
-import { SmartRequestClient } from '@push.rocks/smartrequest';
+import { SmartRequest } from '@push.rocks/smartrequest';
 async function fetchWithErrorHandling(url: string) {
  try {
-    const response = await SmartRequestClient.create()
+    const response = await SmartRequest.create()
      .url(url)
      .timeout(5000)
      .retry(2)
@@ -530,6 +474,8 @@ async function fetchWithErrorHandling(url: string) {
      console.error('Connection refused - is the server running?');
    } else if (error.code === 'ETIMEDOUT') {
      console.error('Request timed out');
    } else if (error.name === 'AbortError') {
      console.error('Request was aborted');
    } else {
      console.error('Request failed:', error.message);
    }
@@ -538,6 +484,15 @@ async function fetchWithErrorHandling(url: string) {
 }
 ```
 ## Migrating from v2.x to v3.x
 Version 3.0 brings significant architectural improvements and a more consistent API:
 1. **Legacy API Removed**: The function-based API (getJson, postJson, etc.) has been removed. Use SmartRequest instead.
 2. **Unified Response API**: All responses now use the same fetch-like interface regardless of platform.
 3. **Stream Changes**: The `stream()` method now returns a web-style ReadableStream on all platforms. Use `streamNode()` for Node.js streams.
 4. **Cross-Platform by Default**: The library now works in browsers out of the box with automatic platform detection.
 ## License and Legal Information
 This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. 
--- a/readme.plan.md
+++ b/readme.plan.md
@@ -1,53 +0,0 @@
 # Smartrequest Refactoring Plan
 Command to reread CLAUDE.md: `cat /home/philkunz/.claude/CLAUDE.md`
 ## Objective
 Refactor smartrequest to use native fetch-like API with a streamlined core that supports unix sockets and keep-alive.
 ## Architecture Overview
 - Rename `legacy/` to `core/` and remove "smartrequest." prefix from filenames
 - Create a modern Response class similar to fetch API
 - Use core as foundation for modern API, not as legacy adapter
 - Maintain unix socket and keep-alive support
 ## Task Checklist
 - [x] Reread /home/philkunz/.claude/CLAUDE.md
 - [x] Create ts/core directory structure with request.ts, types.ts, and plugins.ts
 - [x] Migrate core request logic from legacy to core/request.ts
 - [x] Create modern Response class with fetch-like API
 - [x] Update modern API to use new core module  
 - [x] Create legacy adapter for backward compatibility
 - [x] Update exports in ts/index.ts
 - [x] Run tests and fix any issues
 - [x] Clean up old legacy files
 ## Implementation Details
 ### Core Module Structure
 ```
 ts/core/
 ├── request.ts    # Core HTTP/HTTPS request logic with unix socket support
 ├── types.ts      # Core interfaces and types
 ├── plugins.ts    # Dependencies (http, https, agentkeepalive, etc.)
 └── response.ts   # Modern Response class
 ```
 ### Response Class API
 The new Response class will provide fetch-like methods:
 - `json()`: Promise<T> - Parse response as JSON
 - `text()`: Promise<string> - Get response as text
 - `arrayBuffer()`: Promise<ArrayBuffer> - Get response as ArrayBuffer
 - `stream()`: ReadableStream - Get response as stream
 - `ok`: boolean - Status is 2xx
 - `status`: number - HTTP status code
 - `statusText`: string - HTTP status text
 - `headers`: Headers - Response headers
 ### Migration Strategy
 1. Move core request logic without breaking changes
 2. Create Response wrapper that provides modern API
 3. Update SmartRequestClient to use new core
 4. Add legacy adapter for backward compatibility
 5. Ensure all tests pass throughout migration
--- a/test/test.browser.ts
+++ b/test/test.browser.ts
@@ -0,0 +1,102 @@
 import { tap, expect } from '@git.zone/tstest/tapbundle';
 // For browser tests, we need to import from a browser-safe path
 // that doesn't trigger Node.js module imports
 import { CoreRequest, CoreResponse } from '../ts/core/index.js';
 import type { ICoreRequestOptions } from '../ts/core_base/types.js';
 tap.test('browser: should request a JSON document over https', async () => {
  const request = new CoreRequest('https://jsonplaceholder.typicode.com/posts/1');
  const response = await request.fire();
  expect(response).not.toBeNull();
  expect(response).toHaveProperty('status');
  expect(response.status).toEqual(200);
  const data = await response.json();
  expect(data).toHaveProperty('id');
  expect(data.id).toEqual(1);
  expect(data).toHaveProperty('title');
 });
 tap.test('browser: should handle CORS requests', async () => {
  const options: ICoreRequestOptions = {
    headers: {
      'Accept': 'application/vnd.github.v3+json'
    }
  };
  const request = new CoreRequest('https://api.github.com/users/github', options);
  const response = await request.fire();
  expect(response).not.toBeNull();
  expect(response.status).toEqual(200);
  const data = await response.json();
  expect(data).toHaveProperty('login');
  expect(data.login).toEqual('github');
 });
 tap.test('browser: should handle request timeouts', async () => {
  let timedOut = false;
  const options: ICoreRequestOptions = {
    timeout: 1000
  };
  try {
    const request = new CoreRequest('https://httpbin.org/delay/10', options);
    await request.fire();
  } catch (error) {
    timedOut = true;
    expect(error.message).toContain('timed out');
  }
  expect(timedOut).toEqual(true);
 });
 tap.test('browser: should handle POST requests with JSON', async () => {
  const testData = {
    title: 'foo',
    body: 'bar',
    userId: 1
  };
  const options: ICoreRequestOptions = {
    method: 'POST',
    requestBody: testData
  };
  const request = new CoreRequest('https://jsonplaceholder.typicode.com/posts', options);
  const response = await request.fire();
  expect(response.status).toEqual(201);
  const responseData = await response.json();
  expect(responseData).toHaveProperty('id');
  expect(responseData.title).toEqual(testData.title);
  expect(responseData.body).toEqual(testData.body);
  expect(responseData.userId).toEqual(testData.userId);
 });
 tap.test('browser: should handle query parameters', async () => {
  const options: ICoreRequestOptions = {
    queryParams: {
      foo: 'bar',
      baz: 'qux'
    }
  };
  const request = new CoreRequest('https://httpbin.org/get', options);
  const response = await request.fire();
  expect(response.status).toEqual(200);
  const data = await response.json();
  expect(data.args).toHaveProperty('foo');
  expect(data.args.foo).toEqual('bar');
  expect(data.args).toHaveProperty('baz');
  expect(data.args.baz).toEqual('qux');
 });
 export default tap.start();
--- a/test/test.legacy.ts
+++ b/test/test.legacy.ts
@@ -1,45 +0,0 @@
 import { tap, expect, expectAsync } from '@pushrocks/tapbundle';
 import * as smartrequest from '../ts/legacy/index.js';
 tap.test('should request a html document over https', async () => {
  await expectAsync(smartrequest.getJson('https://encrypted.google.com/')).toHaveProperty('body');
 });
 tap.test('should request a JSON document over https', async () => {
  await expectAsync(smartrequest.getJson('https://jsonplaceholder.typicode.com/posts/1'))
    .property('body')
    .property('id')
    .toEqual(1);
 });
 tap.test('should post a JSON document over http', async () => {
  const testData = { text: 'example_text' };
  await expectAsync(smartrequest.postJson('https://httpbin.org/post', { requestBody: testData }))
    .property('body')
    .property('json')
    .property('text')
    .toEqual('example_text');
 });
 tap.test('should safe get stuff', async () => {
  smartrequest.safeGet('http://coffee.link/');
  smartrequest.safeGet('https://coffee.link/');
 });
 tap.skip.test('should deal with unix socks', async () => {
  const socketResponse = await smartrequest.request(
    'http://unix:/var/run/docker.sock:/containers/json',
    {
      headers: {
        'Content-Type': 'application/json',
        Host: 'docker.sock',
      },
    }
  );
  console.log(socketResponse.body);
 });
 tap.skip.test('should correctly upload a file using formData', async () => {});
 tap.start();
--- a/test/test.modern.ts
+++ b/test/test.modern.ts
@@ -1,9 +1,9 @@
-import { tap, expect } from '@pushrocks/tapbundle';
+import { tap, expect } from '@git.zone/tstest/tapbundle';
-import { SmartRequestClient } from '../ts/modern/index.js';
+import { SmartRequest } from '../ts/client/index.js';
-tap.test('modern: should request a html document over https', async () => {
+tap.test('client: should request a html document over https', async () => {
-  const response = await SmartRequestClient.create()
+  const response = await SmartRequest.create()
    .url('https://encrypted.google.com/')
    .get();
@@ -14,8 +14,8 @@ tap.test('modern: should request a html document over https', async () => {
  expect(text.length).toBeGreaterThan(0);
 });
-tap.test('modern: should request a JSON document over https', async () => {
+tap.test('client: should request a JSON document over https', async () => {
-  const response = await SmartRequestClient.create()
+  const response = await SmartRequest.create()
    .url('https://jsonplaceholder.typicode.com/posts/1')
    .get();
@@ -24,9 +24,9 @@ tap.test('modern: should request a JSON document over https', async () => {
  expect(body.id).toEqual(1);
 });
-tap.test('modern: should post a JSON document over http', async () => {
+tap.test('client: should post a JSON document over http', async () => {
  const testData = { text: 'example_text' };
-  const response = await SmartRequestClient.create()
+  const response = await SmartRequest.create()
    .url('https://httpbin.org/post')
    .json(testData)
    .post();
@@ -37,11 +37,11 @@ tap.test('modern: should post a JSON document over http', async () => {
  expect(body.json.text).toEqual('example_text');
 });
-tap.test('modern: should set headers correctly', async () => {
+tap.test('client: should set headers correctly', async () => {
  const customHeader = 'X-Custom-Header';
  const headerValue = 'test-value';
-  const response = await SmartRequestClient.create()
+  const response = await SmartRequest.create()
    .url('https://httpbin.org/headers')
    .header(customHeader, headerValue)
    .get();
@@ -54,10 +54,10 @@ tap.test('modern: should set headers correctly', async () => {
  expect(body.headers[customHeader]).toEqual(headerValue);
 });
-tap.test('modern: should handle query parameters', async () => {
+tap.test('client: should handle query parameters', async () => {
  const params = { param1: 'value1', param2: 'value2' };
-  const response = await SmartRequestClient.create()
+  const response = await SmartRequest.create()
    .url('https://httpbin.org/get')
    .query(params)
    .get();
@@ -70,9 +70,9 @@ tap.test('modern: should handle query parameters', async () => {
  expect(body.args.param2).toEqual('value2');
 });
-tap.test('modern: should handle timeout configuration', async () => {
+tap.test('client: should handle timeout configuration', async () => {
  // This test just verifies that the timeout method doesn't throw
-  const client = SmartRequestClient.create()
+  const client = SmartRequest.create()
    .url('https://httpbin.org/get')
    .timeout(5000);
@@ -81,9 +81,9 @@ tap.test('modern: should handle timeout configuration', async () => {
  expect(response.ok).toBeTrue();
 });
-tap.test('modern: should handle retry configuration', async () => {
+tap.test('client: should handle retry configuration', async () => {
  // This test just verifies that the retry method doesn't throw
-  const client = SmartRequestClient.create()
+  const client = SmartRequest.create()
    .url('https://httpbin.org/get')
    .retry(1);
--- a/ts/client/features/pagination.ts
+++ b/ts/client/features/pagination.ts
@@ -1,17 +1,18 @@
-import { type SmartResponse } from '../../core/index.js';
+import { type CoreResponse } from '../../core/index.js';
 import type { ICoreResponse } from '../../core_base/types.js';
 import { type TPaginationConfig, PaginationStrategy, type TPaginatedResponse } from '../types/pagination.js';
 /**
 * Creates a paginated response from a regular response
 */
 export async function createPaginatedResponse<T>(
-  response: SmartResponse<any>,
+  response: ICoreResponse<any>,
  paginationConfig: TPaginationConfig,
  queryParams: Record<string, string>,
  fetchNextPage: (params: Record<string, string>) => Promise<TPaginatedResponse<T>>
 ): Promise<TPaginatedResponse<T>> {
  // Parse response body first
-  const body = await response.json();
+  const body = await response.json() as any;
  // Default to response.body for items if response is JSON
  let items: T[] = Array.isArray(body)
--- a/ts/client/index.ts
+++ b/ts/client/index.ts
@@ -1,8 +1,8 @@
 // Export the main client
-export { SmartRequestClient } from './smartrequestclient.js';
+export { SmartRequest } from './smartrequest.js';
 // Export response type from core
-export { SmartResponse } from '../core/index.js';
+export { CoreResponse } from '../core/index.js';
 // Export types
 export type { HttpMethod, ResponseType, FormField, RetryConfig, TimeoutConfig } from './types/common.js';
@@ -17,32 +17,32 @@ export {
 } from './types/pagination.js';
 // Convenience factory functions
-import { SmartRequestClient } from './smartrequestclient.js';
+import { SmartRequest } from './smartrequest.js';
 /**
 * Create a client pre-configured for JSON requests
 */
 export function createJsonClient<T = any>() {
-  return SmartRequestClient.create<T>();
+  return SmartRequest.create<T>();
 }
 /**
 * Create a client pre-configured for form data requests
 */
 export function createFormClient<T = any>() {
-  return SmartRequestClient.create<T>();
+  return SmartRequest.create<T>();
 }
 /**
 * Create a client pre-configured for binary data
 */
 export function createBinaryClient<T = any>() {
-  return SmartRequestClient.create<T>().accept('binary');
+  return SmartRequest.create<T>().accept('binary');
 }
 /**
 * Create a client pre-configured for streaming
 */
 export function createStreamClient() {
-  return SmartRequestClient.create().accept('stream');
+  return SmartRequest.create().accept('stream');
 }
--- a/ts/client/plugins.ts
+++ b/ts/client/plugins.ts
@@ -0,0 +1,6 @@
 // plugins for client module
 import FormData from 'form-data';
 export {
  FormData as formData
 };
--- a/ts/modern/smartrequestclient.ts
+++ b/ts/modern/smartrequestclient.ts
@@ -1,5 +1,7 @@
-import { request, SmartResponse, type ICoreRequestOptions } from '../core/index.js';
+import { CoreRequest, CoreResponse } from '../core/index.js';
-import * as plugins from '../core/plugins.js';
+import type { ICoreResponse } from '../core_base/types.js';
 import * as plugins from './plugins.js';
 import type { ICoreRequestOptions } from '../core_base/types.js';
 import type { HttpMethod, ResponseType, FormField } from './types/common.js';
 import {
@@ -15,7 +17,7 @@ import { createPaginatedResponse } from './features/pagination.js';
 /**
 * Modern fluent client for making HTTP requests
 */
-export class SmartRequestClient<T = any> {
+export class SmartRequest<T = any> {
  private _url: string;
  private _options: ICoreRequestOptions = {};
  private _retries: number = 0;
@@ -23,10 +25,10 @@ export class SmartRequestClient<T = any> {
  private _paginationConfig?: TPaginationConfig;
  /**
-   * Create a new SmartRequestClient instance
+   * Create a new SmartRequest instance
   */
-  static create<T = any>(): SmartRequestClient<T> {
+  static create<T = any>(): SmartRequest<T> {
-    return new SmartRequestClient<T>();
+    return new SmartRequest<T>();
  }
  /**
@@ -223,35 +225,35 @@ export class SmartRequestClient<T = any> {
  /**
   * Make a GET request
   */
-  async get<R = T>(): Promise<SmartResponse<R>> {
+  async get<R = T>(): Promise<ICoreResponse<R>> {
    return this.execute<R>('GET');
  }
  /**
   * Make a POST request
   */
-  async post<R = T>(): Promise<SmartResponse<R>> {
+  async post<R = T>(): Promise<ICoreResponse<R>> {
    return this.execute<R>('POST');
  }
  /**
   * Make a PUT request
   */
-  async put<R = T>(): Promise<SmartResponse<R>> {
+  async put<R = T>(): Promise<ICoreResponse<R>> {
    return this.execute<R>('PUT');
  }
  /**
   * Make a DELETE request
   */
-  async delete<R = T>(): Promise<SmartResponse<R>> {
+  async delete<R = T>(): Promise<ICoreResponse<R>> {
    return this.execute<R>('DELETE');
  }
  /**
   * Make a PATCH request
   */
-  async patch<R = T>(): Promise<SmartResponse<R>> {
+  async patch<R = T>(): Promise<ICoreResponse<R>> {
    return this.execute<R>('PATCH');
  }
@@ -276,7 +278,7 @@ export class SmartRequestClient<T = any> {
      this._queryParams,
      (nextPageParams) => {
        // Create a new client with the same configuration but updated query params
-        const nextClient = new SmartRequestClient<ItemType>();
+        const nextClient = new SmartRequest<ItemType>();
        Object.assign(nextClient, this);
        nextClient._queryParams = nextPageParams;
@@ -296,7 +298,7 @@ export class SmartRequestClient<T = any> {
  /**
   * Execute the HTTP request
   */
-  private async execute<R = T>(method?: HttpMethod): Promise<SmartResponse<R>> {
+  private async execute<R = T>(method?: HttpMethod): Promise<ICoreResponse<R>> {
    if (method) {
      this._options.method = method;
    }
@@ -308,8 +310,9 @@ export class SmartRequestClient<T = any> {
    for (let attempt = 0; attempt <= this._retries; attempt++) {
      try {
-        const response = await request(this._url, this._options);
+        const request = new CoreRequest(this._url, this._options as any);
-        return response as SmartResponse<R>;
+        const response = await request.fire();
        return response as ICoreResponse<R>;
      } catch (error) {
        lastError = error as Error;
--- a/ts/client/types/common.ts
+++ b/ts/client/types/common.ts
--- a/ts/client/types/pagination.ts
+++ b/ts/client/types/pagination.ts
@@ -1,4 +1,5 @@
-import { type SmartResponse } from '../../core/index.js';
+import { type CoreResponse } from '../../core/index.js';
 import type { ICoreResponse } from '../../core_base/types.js';
 /**
 * Pagination strategy options
@@ -45,8 +46,8 @@ export interface LinkPaginationConfig {
 */
 export interface CustomPaginationConfig {
  strategy: PaginationStrategy.CUSTOM;
-  hasNextPage: (response: SmartResponse<any>) => boolean;
+  hasNextPage: (response: ICoreResponse<any>) => boolean;
-  getNextPageParams: (response: SmartResponse<any>, currentParams: Record<string, string>) => Record<string, string>;
+  getNextPageParams: (response: ICoreResponse<any>, currentParams: Record<string, string>) => Record<string, string>;
 }
 /**
@@ -62,5 +63,5 @@ export interface TPaginatedResponse<T> {
  hasNextPage: boolean;         // Whether there are more pages
  getNextPage: () => Promise<TPaginatedResponse<T>>;  // Function to get the next page
  getAllPages: () => Promise<T[]>;  // Function to get all remaining pages and combine
-  response: SmartResponse<any>;  // Original response
+  response: ICoreResponse<any>;  // Original response
 }
--- a/ts/core/index.ts
+++ b/ts/core/index.ts
@@ -1,4 +1,30 @@
-// Core exports
+import * as plugins from './plugins.js';
-export * from './types.js';
+
-export * from './response.js';
+// Export all base types - these are the public API
-export { request, coreRequest, isUnixSocket, parseUnixSocketUrl } from './request.js';
+export * from '../core_base/types.js';
 const smartenvInstance = new plugins.smartenv.Smartenv();
 // Dynamically load the appropriate implementation
 let CoreRequest: any;
 let CoreResponse: any;
 if (smartenvInstance.isNode) {
  // In Node.js, load the node implementation
  const modulePath = plugins.smartpath.join(
    plugins.smartpath.dirname(import.meta.url),
    '../core_node/index.js'
  )
  console.log(modulePath);
  const impl = await smartenvInstance.getSafeNodeModule(modulePath);
  CoreRequest = impl.CoreRequest;
  CoreResponse = impl.CoreResponse;
 } else {
  // In browser, load the fetch implementation
  const impl = await import('../core_fetch/index.js');
  CoreRequest = impl.CoreRequest;
  CoreResponse = impl.CoreResponse;
 }
 // Export the loaded implementations
 export { CoreRequest, CoreResponse };
--- a/ts/core/plugins.ts
+++ b/ts/core/plugins.ts
@@ -1,19 +1,4 @@
-// node native scope
+import * as smartenv from '@push.rocks/smartenv';
-import * as fs from 'fs';
+import * as smartpath from '@push.rocks/smartpath/iso';
 import * as http from 'http';
 import * as https from 'https';
 import * as path from 'path';
-export { http, https, fs, path };
+export { smartenv, smartpath };
 // pushrocks scope
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smarturl from '@push.rocks/smarturl';
 export { smartpromise, smarturl };
 // third party scope
 import agentkeepalive from 'agentkeepalive';
 import formData from 'form-data';
 export { agentkeepalive, formData };
--- a/ts/core/request.ts
+++ b/ts/core/request.ts
@@ -1,159 +0,0 @@
 import * as plugins from './plugins.js';
 import * as types from './types.js';
 import { SmartResponse } from './response.js';
 // Keep-alive agents for connection pooling
 const httpAgent = new plugins.agentkeepalive({
  keepAlive: true,
  maxFreeSockets: 10,
  maxSockets: 100,
  maxTotalSockets: 1000,
 });
 const httpAgentKeepAliveFalse = new plugins.agentkeepalive({
  keepAlive: false,
 });
 const httpsAgent = new plugins.agentkeepalive.HttpsAgent({
  keepAlive: true,
  maxFreeSockets: 10,
  maxSockets: 100,
  maxTotalSockets: 1000,
 });
 const httpsAgentKeepAliveFalse = new plugins.agentkeepalive.HttpsAgent({
  keepAlive: false,
 });
 /**
 * Tests if a URL is a unix socket
 */
 export const isUnixSocket = (url: string): boolean => {
  const unixRegex = /^(http:\/\/|https:\/\/|)unix:/;
  return unixRegex.test(url);
 };
 /**
 * Parses socket path and route from unix socket URL
 */
 export const parseUnixSocketUrl = (url: string): { socketPath: string; path: string } => {
  const parseRegex = /(.*):(.*)/;
  const result = parseRegex.exec(url);
  return {
    socketPath: result[1],
    path: result[2],
  };
 };
 /**
 * Core request function that handles all HTTP/HTTPS requests
 */
 export async function coreRequest(
  urlArg: string,
  optionsArg: types.ICoreRequestOptions = {},
  requestDataFunc: ((req: plugins.http.ClientRequest) => void) | null = null
 ): Promise<plugins.http.IncomingMessage> {
  const done = plugins.smartpromise.defer<plugins.http.IncomingMessage>();
  // No defaults - let users explicitly set options to match fetch behavior
  // Parse URL
  const parsedUrl = plugins.smarturl.Smarturl.createFromUrl(urlArg, {
    searchParams: optionsArg.queryParams || {},
  });
  optionsArg.hostname = parsedUrl.hostname;
  if (parsedUrl.port) {
    optionsArg.port = parseInt(parsedUrl.port, 10);
  }
  optionsArg.path = parsedUrl.path;
  // Handle unix socket URLs
  if (isUnixSocket(urlArg)) {
    const { socketPath, path } = parseUnixSocketUrl(optionsArg.path);
    optionsArg.socketPath = socketPath;
    optionsArg.path = path;
  }
  // Determine agent based on protocol and keep-alive setting
  if (!optionsArg.agent) {
    // Only use keep-alive agents if explicitly requested
    if (optionsArg.keepAlive === true) {
      optionsArg.agent = parsedUrl.protocol === 'https:' ? httpsAgent : httpAgent;
    } else if (optionsArg.keepAlive === false) {
      optionsArg.agent = parsedUrl.protocol === 'https:' ? httpsAgentKeepAliveFalse : httpAgentKeepAliveFalse;
    }
    // If keepAlive is undefined, don't set any agent (more fetch-like behavior)
  }
  // Determine request module
  const requestModule = parsedUrl.protocol === 'https:' ? plugins.https : plugins.http;
  if (!requestModule) {
    throw new Error(`The request to ${urlArg} is missing a viable protocol. Must be http or https`);
  }
  // Perform the request
  const request = requestModule.request(optionsArg, async (response) => {
    // Handle hard timeout
    if (optionsArg.hardDataCuttingTimeout) {
      setTimeout(() => {
        response.destroy();
        done.reject(new Error('Request timed out'));
      }, optionsArg.hardDataCuttingTimeout);
    }
    // Always return the raw stream
    done.resolve(response);
  });
  // Write request body
  if (optionsArg.requestBody) {
    if (optionsArg.requestBody instanceof plugins.formData) {
      optionsArg.requestBody.pipe(request).on('finish', () => {
        request.end();
      });
    } else {
      // Write body as-is - caller is responsible for serialization
      const bodyData = typeof optionsArg.requestBody === 'string' 
        ? optionsArg.requestBody 
        : optionsArg.requestBody instanceof Buffer 
          ? optionsArg.requestBody
          : JSON.stringify(optionsArg.requestBody); // Still stringify for backward compatibility
      request.write(bodyData);
      request.end();
    }
  } else if (requestDataFunc) {
    requestDataFunc(request);
  } else {
    request.end();
  }
  // Handle request errors
  request.on('error', (e) => {
    console.error(e);
    request.destroy();
    done.reject(e);
  });
  // Get response and handle response errors
  const response = await done.promise;
  response.on('error', (err) => {
    console.error(err);
    response.destroy();
  });
  return response;
 }
 /**
 * Modern request function that returns a SmartResponse
 */
 export async function request(
  urlArg: string,
  optionsArg: types.ICoreRequestOptions = {}
 ): Promise<SmartResponse> {
  const response = await coreRequest(urlArg, optionsArg);
  return new SmartResponse(response, urlArg);
 }
--- a/ts/core/types.ts
+++ b/ts/core/types.ts
@@ -1,67 +0,0 @@
 import * as plugins from './plugins.js';
 /**
 * Core request options extending Node.js RequestOptions
 */
 export interface ICoreRequestOptions extends plugins.https.RequestOptions {
  keepAlive?: boolean;
  requestBody?: any;
  queryParams?: { [key: string]: string };
  hardDataCuttingTimeout?: number;
 }
 /**
 * HTTP Methods supported
 */
 export type THttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
 /**
 * Response types supported
 */
 export type ResponseType = 'json' | 'text' | 'binary' | 'stream';
 /**
 * Extended IncomingMessage with body property (legacy compatibility)
 */
 export interface IExtendedIncomingMessage<T = any> extends plugins.http.IncomingMessage {
  body: T;
 }
 /**
 * Form field data for multipart/form-data requests
 */
 export interface IFormField {
  name: string;
  value: string | Buffer;
  filename?: string;
  contentType?: string;
 }
 /**
 * URL encoded form field
 */
 export interface IUrlEncodedField {
  key: string;
  value: string;
 }
 /**
 * Core response object that provides fetch-like API
 */
 export interface ICoreResponse<T = any> {
  // Properties
  ok: boolean;
  status: number;
  statusText: string;
  headers: plugins.http.IncomingHttpHeaders;
  url: string;
  // Methods
  json(): Promise<T>;
  text(): Promise<string>;
  arrayBuffer(): Promise<ArrayBuffer>;
  stream(): NodeJS.ReadableStream;
  // Legacy compatibility
  raw(): plugins.http.IncomingMessage;
 }
--- a/ts/core_base/index.ts
+++ b/ts/core_base/index.ts
@@ -0,0 +1,4 @@
 // Core base exports - abstract classes and platform-agnostic types
 export * from './types.js';
 export * from './request.js';
 export * from './response.js';
--- a/ts/core_base/request.ts
+++ b/ts/core_base/request.ts
@@ -0,0 +1,45 @@
 import * as types from './types.js';
 /**
 * Abstract Core Request class that defines the interface for all HTTP/HTTPS requests
 */
 export abstract class CoreRequest<TOptions extends types.ICoreRequestOptions = types.ICoreRequestOptions, TResponse = any> {
  /**
   * Tests if a URL is a unix socket
   */
  static isUnixSocket(url: string): boolean {
    const unixRegex = /^(http:\/\/|https:\/\/|)unix:/;
    return unixRegex.test(url);
  }
  /**
   * Parses socket path and route from unix socket URL
   */
  static parseUnixSocketUrl(url: string): { socketPath: string; path: string } {
    const parseRegex = /(.*):(.*)/;
    const result = parseRegex.exec(url);
    return {
      socketPath: result[1],
      path: result[2],
    };
  }
  protected url: string;
  protected options: TOptions;
  constructor(url: string, options?: TOptions) {
    this.url = url;
    this.options = options || ({} as TOptions);
  }
  /**
   * Fire the request and return a response
   */
  abstract fire(): Promise<TResponse>;
  /**
   * Fire the request and return the raw response (platform-specific)
   */
  abstract fireCore(): Promise<any>;
 }
--- a/ts/core_base/response.ts
+++ b/ts/core_base/response.ts
@@ -0,0 +1,45 @@
 import * as types from './types.js';
 /**
 * Abstract Core Response class that provides a fetch-like API
 */
 export abstract class CoreResponse<T = any> implements types.ICoreResponse<T> {
  protected consumed = false;
  // Public properties
  public abstract readonly ok: boolean;
  public abstract readonly status: number;
  public abstract readonly statusText: string;
  public abstract readonly headers: types.Headers;
  public abstract readonly url: string;
  /**
   * Ensures the body can only be consumed once
   */
  protected ensureNotConsumed(): void {
    if (this.consumed) {
      throw new Error('Body has already been consumed');
    }
    this.consumed = true;
  }
  /**
   * Parse response as JSON
   */
  abstract json(): Promise<T>;
  /**
   * Get response as text
   */
  abstract text(): Promise<string>;
  /**
   * Get response as ArrayBuffer
   */
  abstract arrayBuffer(): Promise<ArrayBuffer>;
  /**
   * Get response as a web-style ReadableStream
   */
  abstract stream(): ReadableStream<Uint8Array> | null;
 }
--- a/ts/core_base/types.ts
+++ b/ts/core_base/types.ts
@@ -0,0 +1,81 @@
 /**
 * HTTP Methods supported
 */
 export type THttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
 /**
 * Response types supported
 */
 export type ResponseType = 'json' | 'text' | 'binary' | 'stream';
 /**
 * Form field data for multipart/form-data requests
 */
 export interface IFormField {
  name: string;
  value: string | Buffer;
  filename?: string;
  contentType?: string;
 }
 /**
 * URL encoded form field
 */
 export interface IUrlEncodedField {
  key: string;
  value: string;
 }
 /**
 * Core request options - unified interface for all implementations
 */
 export interface ICoreRequestOptions {
  // Common options
  method?: THttpMethod | string; // Allow string for compatibility
  headers?: any; // Allow any for platform compatibility
  keepAlive?: boolean;
  requestBody?: any;
  queryParams?: { [key: string]: string };
  timeout?: number;
  hardDataCuttingTimeout?: number;
  // Node.js specific options (ignored in fetch implementation)
  agent?: any;
  socketPath?: string;
  hostname?: string;
  port?: number;
  path?: string;
  // Fetch API specific options (ignored in Node.js implementation)
  credentials?: RequestCredentials;
  mode?: RequestMode;
  cache?: RequestCache;
  redirect?: RequestRedirect;
  referrer?: string;
  referrerPolicy?: ReferrerPolicy;
  integrity?: string;
  signal?: AbortSignal;
 }
 /**
 * Response headers - platform agnostic
 */
 export type Headers = Record<string, string | string[]>;
 /**
 * Core response interface - platform agnostic
 */
 export interface ICoreResponse<T = any> {
  // Properties
  ok: boolean;
  status: number;
  statusText: string;
  headers: Headers;
  url: string;
  // Methods
  json(): Promise<T>;
  text(): Promise<string>;
  arrayBuffer(): Promise<ArrayBuffer>;
  stream(): ReadableStream<Uint8Array> | null; // Always returns web-style stream
 }
--- a/ts/core_fetch/index.ts
+++ b/ts/core_fetch/index.ts
@@ -0,0 +1,3 @@
 // Core fetch exports - native fetch implementation
 export * from './response.js';
 export { CoreRequest } from './request.js';
--- a/ts/core_fetch/request.ts
+++ b/ts/core_fetch/request.ts
@@ -0,0 +1,131 @@
 import * as types from './types.js';
 import { CoreResponse } from './response.js';
 import { CoreRequest as AbstractCoreRequest } from '../core_base/request.js';
 /**
 * Fetch-based implementation of Core Request class
 */
 export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions, CoreResponse> {
  constructor(url: string, options: types.ICoreRequestOptions = {}) {
    super(url, options);
    // Check for unsupported Node.js-specific options
    if (options.agent || options.socketPath) {
      throw new Error('Node.js specific options (agent, socketPath) are not supported in browser/fetch implementation');
    }
  }
  /**
   * Build the full URL with query parameters
   */
  private buildUrl(): string {
    if (!this.options.queryParams || Object.keys(this.options.queryParams).length === 0) {
      return this.url;
    }
    const url = new URL(this.url);
    Object.entries(this.options.queryParams).forEach(([key, value]) => {
      url.searchParams.append(key, value);
    });
    return url.toString();
  }
  /**
   * Convert our options to fetch RequestInit
   */
  private buildFetchOptions(): RequestInit {
    const fetchOptions: RequestInit = {
      method: this.options.method,
      headers: this.options.headers,
      credentials: this.options.credentials,
      mode: this.options.mode,
      cache: this.options.cache,
      redirect: this.options.redirect,
      referrer: this.options.referrer,
      referrerPolicy: this.options.referrerPolicy,
      integrity: this.options.integrity,
      keepalive: this.options.keepAlive,
      signal: this.options.signal,
    };
    // Handle request body
    if (this.options.requestBody !== undefined) {
      if (typeof this.options.requestBody === 'string' || 
          this.options.requestBody instanceof ArrayBuffer ||
          this.options.requestBody instanceof FormData ||
          this.options.requestBody instanceof URLSearchParams ||
          this.options.requestBody instanceof ReadableStream) {
        fetchOptions.body = this.options.requestBody;
      } else {
        // Convert objects to JSON
        fetchOptions.body = JSON.stringify(this.options.requestBody);
        // Set content-type if not already set
        if (!fetchOptions.headers) {
          fetchOptions.headers = { 'Content-Type': 'application/json' };
        } else if (fetchOptions.headers instanceof Headers) {
          if (!fetchOptions.headers.has('Content-Type')) {
            fetchOptions.headers.set('Content-Type', 'application/json');
          }
        } else if (typeof fetchOptions.headers === 'object' && !Array.isArray(fetchOptions.headers)) {
          const headersObj = fetchOptions.headers as Record<string, string>;
          if (!headersObj['Content-Type']) {
            headersObj['Content-Type'] = 'application/json';
          }
        }
      }
    }
    // Handle timeout
    if (this.options.timeout || this.options.hardDataCuttingTimeout) {
      const timeout = this.options.hardDataCuttingTimeout || this.options.timeout;
      const controller = new AbortController();
      setTimeout(() => controller.abort(), timeout);
      fetchOptions.signal = controller.signal;
    }
    return fetchOptions;
  }
  /**
   * Fire the request and return a CoreResponse
   */
  async fire(): Promise<CoreResponse> {
    const response = await this.fireCore();
    return new CoreResponse(response);
  }
  /**
   * Fire the request and return the raw Response
   */
  async fireCore(): Promise<Response> {
    const url = this.buildUrl();
    const options = this.buildFetchOptions();
    try {
      const response = await fetch(url, options);
      return response;
    } catch (error) {
      if (error.name === 'AbortError') {
        throw new Error('Request timed out');
      }
      throw error;
    }
  }
  /**
   * Static factory method to create and fire a request
   */
  static async create(
    url: string,
    options: types.ICoreRequestOptions = {}
  ): Promise<CoreResponse> {
    const request = new CoreRequest(url, options);
    return request.fire();
  }
 }
 /**
 * Convenience exports for backward compatibility
 */
 export const isUnixSocket = CoreRequest.isUnixSocket;
 export const parseUnixSocketUrl = CoreRequest.parseUnixSocketUrl;
--- a/ts/core_fetch/response.ts
+++ b/ts/core_fetch/response.ts
@@ -0,0 +1,85 @@
 import * as types from './types.js';
 import { CoreResponse as AbstractCoreResponse } from '../core_base/response.js';
 /**
 * Fetch-based implementation of Core Response class
 */
 export class CoreResponse<T = any> extends AbstractCoreResponse<T> implements types.IFetchResponse<T> {
  private response: Response;
  private responseClone: Response;
  // Public properties
  public readonly ok: boolean;
  public readonly status: number;
  public readonly statusText: string;
  public readonly headers: types.Headers;
  public readonly url: string;
  constructor(response: Response) {
    super();
    // Clone the response so we can read the body multiple times if needed
    this.response = response;
    this.responseClone = response.clone();
    this.ok = response.ok;
    this.status = response.status;
    this.statusText = response.statusText;
    this.url = response.url;
    // Convert Headers to plain object
    this.headers = {};
    response.headers.forEach((value, key) => {
      this.headers[key] = value;
    });
  }
  /**
   * Parse response as JSON
   */
  async json(): Promise<T> {
    this.ensureNotConsumed();
    try {
      return await this.response.json();
    } catch (error) {
      throw new Error(`Failed to parse JSON: ${error.message}`);
    }
  }
  /**
   * Get response as text
   */
  async text(): Promise<string> {
    this.ensureNotConsumed();
    return await this.response.text();
  }
  /**
   * Get response as ArrayBuffer
   */
  async arrayBuffer(): Promise<ArrayBuffer> {
    this.ensureNotConsumed();
    return await this.response.arrayBuffer();
  }
  /**
   * Get response as a readable stream (Web Streams API)
   */
  stream(): ReadableStream<Uint8Array> | null {
    this.ensureNotConsumed();
    return this.response.body;
  }
  /**
   * Node.js stream method - not available in browser
   */
  streamNode(): never {
    throw new Error('streamNode() is not available in browser/fetch environment. Use stream() for web-style ReadableStream.');
  }
  /**
   * Get the raw Response object
   */
  raw(): Response {
    return this.responseClone;
  }
 }
--- a/ts/core_fetch/types.ts
+++ b/ts/core_fetch/types.ts
@@ -0,0 +1,15 @@
 import * as baseTypes from '../core_base/types.js';
 // Re-export base types
 export * from '../core_base/types.js';
 /**
 * Fetch-specific response extensions
 */
 export interface IFetchResponse<T = any> extends baseTypes.ICoreResponse<T> {
  // Node.js stream method that throws in browser
  streamNode(): never;
  // Access to raw Response object
  raw(): Response;
 }
--- a/ts/core_node/index.ts
+++ b/ts/core_node/index.ts
@@ -0,0 +1,3 @@
 // Core exports
 export * from './response.js';
 export { CoreRequest } from './request.js';
--- a/ts/core_node/plugins.ts
+++ b/ts/core_node/plugins.ts
@@ -0,0 +1,20 @@
 // node native scope
 import * as fs from 'fs';
 import * as http from 'http';
 import * as https from 'https';
 import * as path from 'path';
 export { http, https, fs, path };
 // pushrocks scope
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smarturl from '@push.rocks/smarturl';
 export { smartpromise, smarturl };
 // third party scope
 import { HttpAgent, HttpsAgent } from 'agentkeepalive';
 const agentkeepalive = { HttpAgent, HttpsAgent };
 import formData from 'form-data';
 export { agentkeepalive, formData };
--- a/ts/core_node/request.ts
+++ b/ts/core_node/request.ts
@@ -0,0 +1,163 @@
 import * as plugins from './plugins.js';
 import * as types from './types.js';
 import { CoreResponse } from './response.js';
 import { CoreRequest as AbstractCoreRequest } from '../core_base/request.js';
 // Keep-alive agents for connection pooling
 const httpAgent = new plugins.agentkeepalive.HttpAgent({
  keepAlive: true,
  maxFreeSockets: 10,
  maxSockets: 100,
  maxTotalSockets: 1000,
 });
 const httpAgentKeepAliveFalse = new plugins.agentkeepalive.HttpAgent({
  keepAlive: false,
 });
 const httpsAgent = new plugins.agentkeepalive.HttpsAgent({
  keepAlive: true,
  maxFreeSockets: 10,
  maxSockets: 100,
  maxTotalSockets: 1000,
 });
 const httpsAgentKeepAliveFalse = new plugins.agentkeepalive.HttpsAgent({
  keepAlive: false,
 });
 /**
 * Node.js implementation of Core Request class that handles all HTTP/HTTPS requests
 */
 export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions, CoreResponse> {
  private requestDataFunc: ((req: plugins.http.ClientRequest) => void) | null;
  constructor(
    url: string,
    options: types.ICoreRequestOptions = {},
    requestDataFunc: ((req: plugins.http.ClientRequest) => void) | null = null
  ) {
    super(url, options);
    this.requestDataFunc = requestDataFunc;
    // Check for unsupported fetch-specific options
    if (options.credentials || options.mode || options.cache || options.redirect || 
        options.referrer || options.referrerPolicy || options.integrity) {
      throw new Error('Fetch API specific options (credentials, mode, cache, redirect, referrer, referrerPolicy, integrity) are not supported in Node.js implementation');
    }
  }
  /**
   * Fire the request and return a CoreResponse
   */
  async fire(): Promise<CoreResponse> {
    const incomingMessage = await this.fireCore();
    return new CoreResponse(incomingMessage, this.url);
  }
  /**
   * Fire the request and return the raw IncomingMessage
   */
  async fireCore(): Promise<plugins.http.IncomingMessage> {
    const done = plugins.smartpromise.defer<plugins.http.IncomingMessage>();
    // Parse URL
    const parsedUrl = plugins.smarturl.Smarturl.createFromUrl(this.url, {
      searchParams: this.options.queryParams || {},
    });
    this.options.hostname = parsedUrl.hostname;
    if (parsedUrl.port) {
      this.options.port = parseInt(parsedUrl.port, 10);
    }
    this.options.path = parsedUrl.path;
    // Handle unix socket URLs
    if (CoreRequest.isUnixSocket(this.url)) {
      const { socketPath, path } = CoreRequest.parseUnixSocketUrl(this.options.path);
      this.options.socketPath = socketPath;
      this.options.path = path;
    }
    // Determine agent based on protocol and keep-alive setting
    if (!this.options.agent) {
      // Only use keep-alive agents if explicitly requested
      if (this.options.keepAlive === true) {
        this.options.agent = parsedUrl.protocol === 'https:' ? httpsAgent : httpAgent;
      } else if (this.options.keepAlive === false) {
        this.options.agent = parsedUrl.protocol === 'https:' ? httpsAgentKeepAliveFalse : httpAgentKeepAliveFalse;
      }
      // If keepAlive is undefined, don't set any agent (more fetch-like behavior)
    }
    // Determine request module
    const requestModule = parsedUrl.protocol === 'https:' ? plugins.https : plugins.http;
    if (!requestModule) {
      throw new Error(`The request to ${this.url} is missing a viable protocol. Must be http or https`);
    }
    // Perform the request
    const request = requestModule.request(this.options, async (response) => {
      // Handle hard timeout
      if (this.options.hardDataCuttingTimeout) {
        setTimeout(() => {
          response.destroy();
          done.reject(new Error('Request timed out'));
        }, this.options.hardDataCuttingTimeout);
      }
      // Always return the raw stream
      done.resolve(response);
    });
    // Write request body
    if (this.options.requestBody) {
      if (this.options.requestBody instanceof plugins.formData) {
        this.options.requestBody.pipe(request).on('finish', () => {
          request.end();
        });
      } else {
        // Write body as-is - caller is responsible for serialization
        const bodyData = typeof this.options.requestBody === 'string' 
          ? this.options.requestBody 
          : this.options.requestBody instanceof Buffer 
            ? this.options.requestBody
            : JSON.stringify(this.options.requestBody); // Still stringify for backward compatibility
        request.write(bodyData);
        request.end();
      }
    } else if (this.requestDataFunc) {
      this.requestDataFunc(request);
    } else {
      request.end();
    }
    // Handle request errors
    request.on('error', (e) => {
      console.error(e);
      request.destroy();
      done.reject(e);
    });
    // Get response and handle response errors
    const response = await done.promise;
    response.on('error', (err) => {
      console.error(err);
      response.destroy();
    });
    return response;
  }
  /**
   * Static factory method to create and fire a request
   */
  static async create(
    url: string,
    options: types.ICoreRequestOptions = {}
  ): Promise<CoreResponse> {
    const request = new CoreRequest(url, options);
    return request.fire();
  }
 }
--- a/ts/core_node/response.ts
+++ b/ts/core_node/response.ts
@@ -1,13 +1,13 @@
 import * as plugins from './plugins.js';
 import * as types from './types.js';
 import { CoreResponse as AbstractCoreResponse } from '../core_base/response.js';
 /**
- * Modern Response class that provides a fetch-like API
+ * Node.js implementation of Core Response class that provides a fetch-like API
 */
-export class SmartResponse<T = any> implements types.ICoreResponse<T> {
+export class CoreResponse<T = any> extends AbstractCoreResponse<T> implements types.INodeResponse<T> {
  private incomingMessage: plugins.http.IncomingMessage;
  private bodyBufferPromise: Promise<Buffer> | null = null;
  private consumed = false;
  // Public properties
  public readonly ok: boolean;
@@ -17,6 +17,7 @@ export class SmartResponse<T = any> implements types.ICoreResponse<T> {
  public readonly url: string;
  constructor(incomingMessage: plugins.http.IncomingMessage, url: string) {
    super();
    this.incomingMessage = incomingMessage;
    this.url = url;
    this.status = incomingMessage.statusCode || 0;
@@ -25,16 +26,6 @@ export class SmartResponse<T = any> implements types.ICoreResponse<T> {
    this.headers = incomingMessage.headers;
  }
  /**
   * Ensures the body can only be consumed once
   */
  private ensureNotConsumed(): void {
    if (this.consumed) {
      throw new Error('Body has already been consumed');
    }
    this.consumed = true;
  }
  /**
   * Collects the body as a buffer
   */
@@ -93,9 +84,44 @@ export class SmartResponse<T = any> implements types.ICoreResponse<T> {
  }
  /**
-   * Get response as a readable stream
+   * Get response as a web-style ReadableStream
   */
-  stream(): NodeJS.ReadableStream {
+  stream(): ReadableStream<Uint8Array> | null {
    this.ensureNotConsumed();
    // Convert Node.js stream to web stream
    // In Node.js 16.5+ we can use Readable.toWeb()
    if (this.incomingMessage.readableEnded || this.incomingMessage.destroyed) {
      return null;
    }
    // Create a web ReadableStream from the Node.js stream
    const nodeStream = this.incomingMessage;
    return new ReadableStream<Uint8Array>({
      start(controller) {
        nodeStream.on('data', (chunk) => {
          controller.enqueue(new Uint8Array(chunk));
        });
        nodeStream.on('end', () => {
          controller.close();
        });
        nodeStream.on('error', (err) => {
          controller.error(err);
        });
      },
      cancel() {
        nodeStream.destroy();
      }
    });
  }
  /**
   * Get response as a Node.js readable stream
   */
  streamNode(): NodeJS.ReadableStream {
    this.ensureNotConsumed();
    return this.incomingMessage;
  }
--- a/ts/core_node/types.ts
+++ b/ts/core_node/types.ts
@@ -0,0 +1,23 @@
 import * as plugins from './plugins.js';
 import * as baseTypes from '../core_base/types.js';
 // Re-export base types
 export * from '../core_base/types.js';
 /**
 * Extended IncomingMessage with body property (legacy compatibility)
 */
 export interface IExtendedIncomingMessage<T = any> extends plugins.http.IncomingMessage {
  body: T;
 }
 /**
 * Node.js specific response extensions
 */
 export interface INodeResponse<T = any> extends baseTypes.ICoreResponse<T> {
  // Node.js specific methods
  streamNode(): NodeJS.ReadableStream; // Returns Node.js style stream
  // Legacy compatibility
  raw(): plugins.http.IncomingMessage;
 }
--- a/ts/index.ts
+++ b/ts/index.ts
@@ -1,12 +1,10 @@
-// Legacy API exports (for backward compatibility)
+// Client API exports
-export * from './legacy/index.js';
+export * from './client/index.js';
 // Modern API exports
 export * from './modern/index.js';
 // Core exports for advanced usage
-export { SmartResponse, type ICoreRequestOptions, type ICoreResponse } from './core/index.js';
+export { CoreResponse } from './core/index.js';
 export type { ICoreRequestOptions, ICoreResponse } from './core_base/types.js';
 // Default export for easier importing
-import { SmartRequestClient } from './modern/smartrequestclient.js';
+import { SmartRequest } from './client/smartrequest.js';
-export default SmartRequestClient;
+export default SmartRequest;
--- a/ts/legacy/adapter.ts
+++ b/ts/legacy/adapter.ts
@@ -1,242 +0,0 @@
 /**
 * Legacy adapter that provides backward compatibility
 * Maps legacy API to the new core module
 */
 import * as core from '../core/index.js';
 import * as plugins from '../core/plugins.js';
 const smartpromise = plugins.smartpromise;
 // Re-export types for backward compatibility
 export { type IExtendedIncomingMessage } from '../core/types.js';
 export interface ISmartRequestOptions extends core.ICoreRequestOptions {
  autoJsonParse?: boolean;
  responseType?: 'json' | 'text' | 'binary' | 'stream';
 }
 // Re-export interface for form fields
 export interface IFormField {
  name: string;
  type: 'string' | 'filePath' | 'Buffer';
  payload: string | Buffer;
  fileName?: string;
  contentType?: string;
 }
 /**
 * Helper function to convert stream to IExtendedIncomingMessage for legacy compatibility
 */
 async function streamToExtendedMessage(
  stream: plugins.http.IncomingMessage,
  autoJsonParse = true
 ): Promise<core.IExtendedIncomingMessage> {
  const done = smartpromise.defer<core.IExtendedIncomingMessage>();
  const chunks: Buffer[] = [];
  stream.on('data', (chunk: Buffer) => {
    chunks.push(chunk);
  });
  stream.on('end', () => {
    const buffer = Buffer.concat(chunks);
    const extendedMessage = stream as core.IExtendedIncomingMessage;
    if (autoJsonParse) {
      const text = buffer.toString('utf-8');
      try {
        extendedMessage.body = JSON.parse(text);
      } catch (err) {
        extendedMessage.body = text;
      }
    } else {
      extendedMessage.body = buffer;
    }
    done.resolve(extendedMessage);
  });
  stream.on('error', (err) => {
    done.reject(err);
  });
  return done.promise;
 }
 /**
 * Legacy request function that returns IExtendedIncomingMessage
 */
 export async function request(
  urlArg: string,
  optionsArg: ISmartRequestOptions = {},
  responseStreamArg = false,
  requestDataFunc?: (req: plugins.http.ClientRequest) => void
 ): Promise<core.IExtendedIncomingMessage> {
  const stream = await core.coreRequest(urlArg, optionsArg, requestDataFunc);
  if (responseStreamArg) {
    // For stream responses, just cast and return
    return stream as core.IExtendedIncomingMessage;
  }
  // Convert stream to IExtendedIncomingMessage
  const autoJsonParse = optionsArg.autoJsonParse !== false;
  return streamToExtendedMessage(stream, autoJsonParse);
 }
 /**
 * Safe GET request
 */
 export async function safeGet(urlArg: string): Promise<core.IExtendedIncomingMessage | null> {
  const agentToUse = urlArg.startsWith('http://') 
    ? new plugins.http.Agent() 
    : new plugins.https.Agent();
  try {
    const response = await request(urlArg, {
      method: 'GET',
      agent: agentToUse,
      timeout: 5000,
      hardDataCuttingTimeout: 5000,
      autoJsonParse: false,
    });
    return response;
  } catch (err) {
    console.error(err);
    return null;
  }
 }
 /**
 * GET JSON request
 */
 export async function getJson(urlArg: string, optionsArg: ISmartRequestOptions = {}) {
  optionsArg.method = 'GET';
  return request(urlArg, optionsArg);
 }
 /**
 * POST JSON request
 */
 export async function postJson(urlArg: string, optionsArg: ISmartRequestOptions = {}) {
  optionsArg.method = 'POST';
  if (
    typeof optionsArg.requestBody === 'object' &&
    (!optionsArg.headers || !optionsArg.headers['Content-Type'])
  ) {
    // make sure headers exist
    if (!optionsArg.headers) {
      optionsArg.headers = {};
    }
    // assign the right Content-Type, leaving all other headers in place
    optionsArg.headers = {
      ...optionsArg.headers,
      'Content-Type': 'application/json',
    };
  }
  return request(urlArg, optionsArg);
 }
 /**
 * PUT JSON request
 */
 export async function putJson(urlArg: string, optionsArg: ISmartRequestOptions = {}) {
  optionsArg.method = 'PUT';
  return request(urlArg, optionsArg);
 }
 /**
 * DELETE JSON request
 */
 export async function delJson(urlArg: string, optionsArg: ISmartRequestOptions = {}) {
  optionsArg.method = 'DELETE';
  return request(urlArg, optionsArg);
 }
 /**
 * GET binary data
 */
 export async function getBinary(urlArg: string, optionsArg: ISmartRequestOptions = {}) {
  optionsArg = {
    ...optionsArg,
    autoJsonParse: false,
    responseType: 'binary'
  };
  return request(urlArg, optionsArg);
 }
 /**
 * POST form data
 */
 export async function postFormData(urlArg: string, formFields: IFormField[], optionsArg: ISmartRequestOptions = {}) {
  const form = new plugins.formData();
  for (const formField of formFields) {
    if (formField.type === 'filePath') {
      const fileData = plugins.fs.readFileSync(
        plugins.path.isAbsolute(formField.payload as string)
          ? formField.payload as string
          : plugins.path.join(process.cwd(), formField.payload as string)
      );
      form.append(formField.name, fileData, {
        filename: formField.fileName || plugins.path.basename(formField.payload as string),
        contentType: formField.contentType
      });
    } else if (formField.type === 'Buffer') {
      form.append(formField.name, formField.payload, {
        filename: formField.fileName,
        contentType: formField.contentType
      });
    } else {
      form.append(formField.name, formField.payload);
    }
  }
  optionsArg.method = 'POST';
  optionsArg.requestBody = form;
  if (!optionsArg.headers) {
    optionsArg.headers = {};
  }
  optionsArg.headers = {
    ...optionsArg.headers,
    ...form.getHeaders()
  };
  return request(urlArg, optionsArg);
 }
 /**
 * POST URL encoded form data
 */
 export async function postFormDataUrlEncoded(
  urlArg: string,
  formFields: { key: string; content: string }[],
  optionsArg: ISmartRequestOptions = {}
 ) {
  optionsArg.method = 'POST';
  if (!optionsArg.headers) {
    optionsArg.headers = {};
  }
  optionsArg.headers['Content-Type'] = 'application/x-www-form-urlencoded';
  const urlEncodedBody = formFields
    .map(field => `${encodeURIComponent(field.key)}=${encodeURIComponent(field.content)}`)
    .join('&');
  optionsArg.requestBody = urlEncodedBody;
  return request(urlArg, optionsArg);
 }
 /**
 * GET stream
 */
 export async function getStream(
  urlArg: string,
  optionsArg: ISmartRequestOptions = {}
 ): Promise<plugins.http.IncomingMessage> {
  optionsArg.method = 'GET';
  const response = await request(urlArg, optionsArg, true);
  return response;
 }
--- a/ts/legacy/index.ts
+++ b/ts/legacy/index.ts
@@ -1,2 +0,0 @@
 // Export everything from the legacy adapter
 export * from './adapter.js';
Author	SHA1	Message	Date
Juergen Kunz	cf24bf94b9	4.0.1 Some checks failed Default (tags) / security (push) Failing after 25s Details Default (tags) / test (push) Failing after 15s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-07-29 00:19:30 +00:00
Juergen Kunz	3e24f1c5a8	fix:(exports)	2025-07-29 00:19:19 +00:00
Juergen Kunz	2dc82bd730	BREAKING CHANGE(core): major architectural refactoring with cross-platform support and SmartRequest rename Some checks failed Default (tags) / security (push) Failing after 24s Details Default (tags) / test (push) Failing after 12s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-07-28 23:20:52 +00:00
Juergen Kunz	8e75047d1f	update	2025-07-28 22:50:12 +00:00
Juergen Kunz	eb2ccd8d9f	update	2025-07-28 22:37:36 +00:00
Juergen Kunz	bc99aa3569	update	2025-07-28 17:23:48 +00:00
Juergen Kunz	94bf23ad55	update	2025-07-28 17:15:35 +00:00
Juergen Kunz	ea54a8aeda	update	2025-07-28 17:07:24 +00:00
Juergen Kunz	18d8ab0278	update	2025-07-28 17:01:34 +00:00
Juergen Kunz	b8d707b363	update	2025-07-28 16:51:30 +00:00
Juergen Kunz	7dcc5f3fe2	update	2025-07-28 15:12:11 +00:00
Juergen Kunz	8f5c88b47e	update	2025-07-28 15:12:04 +00:00
Juergen Kunz	28a56b87bc	update	2025-07-28 15:00:42 +00:00
Juergen Kunz	d627bc870e	update	2025-07-28 14:45:47 +00:00
Juergen Kunz	2cded974a8	update	2025-07-28 14:38:09 +00:00
Juergen Kunz	31c25c8333	update	2025-07-28 14:30:27 +00:00
Juergen Kunz	01bbfa4a06	fix tests	2025-07-28 14:21:42 +00:00
Juergen Kunz	0ebd47d1b2	update readme.md	2025-07-28 07:45:37 +00:00
		`@@ -1,2 +0,0 @@`
			`// Export everything from the legacy adapter`
			`export * from './adapter.js';`