BREAKING CHANGE(core): major architectural refactoring with cross-platform support and SmartRequest rename

update
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 · 2025-07-28 17:15:35 +00:00 · 2025-07-28 17:07:24 +00:00
48 changed files with 12030 additions and 2351 deletions
--- a/.gitea/workflows/default_nottags.yaml
+++ b/.gitea/workflows/default_nottags.yaml
@@ -0,0 +1,66 @@
+name: Default (not tags)
+
+on:
+  push:
+    tags-ignore:
+      - '**'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install pnpm and npmci
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+
+      - name: Run npm prepare
+        run: npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
--- a/.gitea/workflows/default_tags.yaml
+++ b/.gitea/workflows/default_tags.yaml
@@ -0,0 +1,124 @@
+name: Default (tags)
+
+on:
+  push:
+    tags:
+      - '*'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
+
+  release:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Release
+        run: |
+          npmci node install stable
+          npmci npm publish
+
+  metadata:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Code quality
+        run: |
+          npmci command npm install -g typescript
+          npmci npm install
+
+      - name: Trigger
+        run: npmci trigger
+
+      - name: Build docs and upload artifacts
+        run: |
+          npmci node install stable
+          npmci npm install
+          pnpm install -g @git.zone/tsdoc
+          npmci command tsdoc
+        continue-on-error: true
--- a/.gitignore
+++ b/.gitignore
@@ -15,8 +15,6 @@ node_modules/

 # builds
 dist/
-dist_web/
-dist_serve/
-dist_ts_web/
+dist_*/

 # custom
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,119 +0,0 @@
-# gitzone ci_default
-image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-
-cache:
-  paths:
-  - .npmci_cache/
-  key: "$CI_BUILD_STAGE"
-
-stages:
- security
- test
- release
- metadata
-
-# ====================
-# security stage
-# ====================
-mirror:
-  stage: security
-  script:
-  - npmci git mirror
-  tags:
-  - docker
-  - notpriv
-
-snyk:
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install -g snyk
-    - npmci command npm install --ignore-scripts
-    - npmci command snyk test
-  tags:
-  - docker
-  - notpriv
-
-# ====================
-# test stage
-# ====================
-
-testStable:
-  stage: test
-  script:
-  - npmci npm prepare
-  - npmci node install stable
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - priv
-
-testBuild:
-  stage: test
-  script:
-  - npmci npm prepare
-  - npmci node install lts
-  - npmci npm install
-  - npmci command npm run build
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-
-release:
-  stage: release
-  script:
-  - npmci node install lts
-  - npmci npm publish
-  only:
-  - tags
-  tags:
-  - docker
-  - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  allow_failure: true
-  script:
-    - npmci command npm install -g tslint typescript
-    - npmci npm install
-    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
-  tags:
-  - docker
-  - priv
-
-trigger:
-  stage: metadata
-  script:
-  - npmci trigger
-  only:
-  - tags
-  tags:
-  - docker
-  - notpriv
-
-pages:
-  image: hosttoday/ht-docker-dbase:npmci
-  services:
-   - docker:stable-dind
-  stage: metadata
-  script:
-    - npmci command npm install -g @gitzone/tsdoc
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command tsdoc
-  tags:
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-    - public
-  allow_failure: true
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -0,0 +1,11 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "command": "npm test",
+      "name": "Run npm test",
+      "request": "launch",
+      "type": "node-terminal"
+    }
+  ]
+}
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -0,0 +1,26 @@
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["/npmextra.json"],
+      "schema": {
+        "type": "object",
+        "properties": {
+          "npmci": {
+            "type": "object",
+            "description": "settings for npmci"
+          },
+          "gitzone": {
+            "type": "object",
+            "description": "settings for gitzone",
+            "properties": {
+              "projectType": {
+                "type": "string",
+                "enum": ["website", "element", "service", "npm", "wcc"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}
--- a/README.md
+++ b/README.md
@@ -1,69 +0,0 @@
-# @pushrocks/smartrequest
-dropin replacement for request
-
-## Availabililty and Links
-* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartrequest)
-* [gitlab.com (source)](https://gitlab.com/pushrocks/smartrequest)
-* [github.com (source mirror)](https://github.com/pushrocks/smartrequest)
-* [docs (typedoc)](https://pushrocks.gitlab.io/smartrequest/)
-
-## Status for master
-[![build status](https://gitlab.com/pushrocks/smartrequest/badges/master/build.svg)](https://gitlab.com/pushrocks/smartrequest/commits/master)
-[![coverage report](https://gitlab.com/pushrocks/smartrequest/badges/master/coverage.svg)](https://gitlab.com/pushrocks/smartrequest/commits/master)
-[![npm downloads per month](https://img.shields.io/npm/dm/@pushrocks/smartrequest.svg)](https://www.npmjs.com/package/@pushrocks/smartrequest)
-[![Known Vulnerabilities](https://snyk.io/test/npm/@pushrocks/smartrequest/badge.svg)](https://snyk.io/test/npm/@pushrocks/smartrequest)
-[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
-
-## Usage
-
-Use TypeScript for best in class instellisense.
-
-> note: smartrequest uses the **native** node request module under the hood (not the one from npm)
-
-```javascript
-import * as smartrequest from 'smartrequest'
-
-// simple post
-let options: smartrequest.ISmartRequestOptions = { // typed options
-    headers: {
-        "Content-Type": "application/json"
-        "Authorization": "Bearer token"
-    },
-    requestBody: {
-        key1: 'value1',
-        key2: 3
-    }
-}
-
-smartrequest.post('https://example.com', options).then(res => {
-    console.log(res.status)
-    console.log(res.body) // if json, body will be parsed automatically
-}).catch(err => {
-    console.log(err)
-})
-
-// also available
-smartrequest.get(...)
-smartrequest.put(...)
-smartrequest.del(...)
-
-// streaming
-smartrequest.get('https://example.com/bigfile.mp4', optionsArg, true).then(res => { // third arg = true signals streaming
-    console.log(res.status)
-    res.on('data', data => {
-        // do something with the data chunk here
-    }
-    res.on('end', () => {
-        // do something when things have ended
-    })
-})
-```
-
-For further information read the linked docs at the top of this readme.
-
-> MIT licensed | **&copy;** [Lossless GmbH](https://lossless.gmbh)
-| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
-
-[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)
--- a/changelog.md
+++ b/changelog.md
@@ -0,0 +1,127 @@
+# 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
+
+**Breaking Changes:**
+- Legacy API functions are now imported from `@push.rocks/smartrequest/legacy` instead of the main export
+- Modern API response objects now use fetch-like methods (`.json()`, `.text()`, `.arrayBuffer()`, `.stream()`) instead of direct `.body` access
+- Renamed `responseType()` method to `accept()` in modern API
+- Removed automatic defaults:
+  - No default keepAlive (must be explicitly set)
+  - No default timeouts
+  - No automatic JSON parsing in core
+- Complete internal architecture refactoring:
+  - Core module now always returns raw streams
+  - Response parsing happens in SmartResponse methods
+  - Legacy API is now just an adapter over the core module
+
+**Features:**
+- New fetch-like response API with single-use body consumption
+- Better TypeScript support and type safety
+- Cleaner separation of concerns between request and response
+- More predictable behavior aligned with fetch API standards
+
+**Documentation:**
+- Updated all examples to show correct import paths
+- Added comprehensive examples for the new response API
+- Enhanced migration guide
+
+## 2025-04-03 - 2.1.0 - feat(docs)
+Enhance documentation and tests with modern API usage examples and migration guide
+
+- Updated README to include detailed examples for the modern fluent API, covering GET, POST, headers, query, timeout, retries, and pagination
+- Added a migration guide comparing the legacy API and modern API usage
+- Improved installation instructions with npm, pnpm, and yarn examples
+- Added and updated test files for both legacy and modern API functionalities
+- Minor formatting improvements in the code and documentation examples
+
+## 2024-11-06 - 2.0.23 - fix(core)
+Enhance type safety for response in binary requests
+
+- Updated the dependency versions in package.json to their latest versions.
+- Improved type inference for the response body in getBinary method of smartrequest.binaryrest.ts.
+- Introduced generic typing to IExtendedIncomingMessage interface for better type safety.
+
+## 2024-05-29 - 2.0.22 - Documentation
+update description
+
+## 2024-04-01 - 2.0.21 - Configuration
+Updated configuration files
+
+- Updated `tsconfig`
+- Updated `npmextra.json`: githost
+
+## 2023-07-10 - 2.0.15 - Structure
+Refactored the organization structure
+
+- Switched to a new organization scheme
+
+## 2022-07-29 - 1.1.57 to 2.0.0 - Major Update
+Significant changes and improvements leading to a major version update
+
+- **BREAKING CHANGE**: Switched the core to use ECMAScript modules (ESM)
+
+## 2018-08-14 - 1.1.12 to 1.1.13 - Functional Enhancements
+Enhanced request capabilities and removed unnecessary dependencies
+
+- Fixed request module to allow sending strings
+- Removed CI dependencies
+
+## 2018-07-19 - 1.1.1 to 1.1.11 - Various Fixes and Improvements
+Improvements and fixes across various components
+
+- Added formData capability
+- Corrected path resolution to use current working directory (CWD)
+- Improved formData handling
+- Included correct headers
+- Updated request ending method
+
+## 2018-06-19 - 1.0.14 - Structural Fix
+Resolved conflicts with file extensions
+
+- Changed `.json.ts` to `.jsonrest.ts` to avoid conflicts
+
+## 2018-06-13 - 1.0.8 to 1.0.10 - Core Updates
+Ensured binary handling compliance
+
+- Enhanced core to uphold latest standards
+- Correct binary file handling response
+- Fix for handling and returning binary responses
+
+## 2017-06-09 - 1.0.4 to 1.0.6 - Infrastructure and Type Improvements
+Types and infrastructure updates
+
+- Improved types
+- Removed need for content type on post requests
+- Updated for new infrastructure
+
--- a/npmextra.json
+++ b/npmextra.json
@@ -7,13 +7,31 @@
    "npmAccessLevel": "public"
  },
  "gitzone": {
+    "projectType": "npm",
    "module": {
-      "githost": "gitlab.com",
-      "gitscope": "pushrocks",
+      "githost": "code.foss.global",
+      "gitscope": "push.rocks",
      "gitrepo": "smartrequest",
-      "shortDescription": "dropin replacement for request",
-      "npmPackagename": "@pushrocks/smartrequest",
-      "license": "MIT"
+      "description": "A module for modern HTTP/HTTPS requests with support for form data, file uploads, JSON, binary data, streams, and more.",
+      "npmPackagename": "@push.rocks/smartrequest",
+      "license": "MIT",
+      "keywords": [
+        "HTTP",
+        "HTTPS",
+        "request library",
+        "form data",
+        "file uploads",
+        "JSON",
+        "binary data",
+        "streams",
+        "keepAlive",
+        "TypeScript",
+        "modern web requests",
+        "drop-in replacement"
+      ]
    }
+  },
+  "tsdoc": {
+    "legal": "\n## License and Legal Information\n\nThis 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. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
  }
 }
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,51 +1,71 @@
 {
-  "name": "@pushrocks/smartrequest",
-  "version": "1.1.35",
+  "name": "@push.rocks/smartrequest",
+  "version": "4.0.0",
  "private": false,
-  "description": "dropin replacement for request",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "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",
+    "./core_node": "./dist_ts/core_node/index.js",
+    "./core_fetch": "./dist_ts/core_fetch/index.js"
+  },
+  "type": "module",
  "scripts": {
-    "test": "(tstest test/)",
-    "build": "(tsbuild)"
+    "test": "(tstest test/ --verbose)",
+    "build": "(tsbuild --web)",
+    "buildDocs": "tsdoc"
  },
  "repository": {
    "type": "git",
-    "url": "git+ssh://git@gitlab.com/pushrocks/smartrequest.git"
+    "url": "https://code.foss.global/push.rocks/smartrequest.git"
  },
  "keywords": [
-    "request"
+    "HTTP",
+    "HTTPS",
+    "request library",
+    "form data",
+    "file uploads",
+    "JSON",
+    "binary data",
+    "streams",
+    "keepAlive",
+    "TypeScript",
+    "modern web requests",
+    "drop-in replacement"
  ],
-  "author": "Lossless GmbH",
+  "author": "Task Venture Capital GmbH",
  "license": "MIT",
  "bugs": {
-    "url": "https://gitlab.com/pushrocks/smartrequest/issues"
+    "url": "https://gitlab.com/push.rocks/smartrequest/issues"
  },
-  "homepage": "https://gitlab.com/pushrocks/smartrequest#README",
+  "homepage": "https://code.foss.global/push.rocks/smartrequest",
  "dependencies": {
-    "@pushrocks/smartpromise": "^3.0.5",
-    "@types/form-data": "^2.5.0",
-    "agentkeepalive": "^4.0.2",
-    "form-data": "^2.5.1"
+    "@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.4"
  },
  "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.17",
-    "@gitzone/tsrun": "^1.2.8",
-    "@gitzone/tstest": "^1.0.24",
-    "@pushrocks/tapbundle": "^3.0.13",
-    "@types/node": "^12.7.8",
-    "tslint": "^5.20.0",
-    "tslint-config-prettier": "^1.18.0"
+    "@git.zone/tsbuild": "^2.6.4",
+    "@git.zone/tsrun": "^1.3.3",
+    "@git.zone/tstest": "^2.3.2",
+    "@types/node": "^22.9.0"
  },
  "files": [
-    "ts/*",
-    "ts_web/*",
-    "dist/*",
-    "dist_web/*",
-    "dist_ts_web/*",
-    "assets/*",
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
    "cli.js",
    "npmextra.json",
    "readme.md"
-  ]
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ],
+  "packageManager": "pnpm@10.7.0+sha512.6b865ad4b62a1d9842b61d674a393903b871d9244954f652b8842c2b553c72176b278f64c463e52d40fff8aba385c235c8c9ecf5cc7de4fd78b8bb6d49633ab6"
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/readme.hints.md
+++ b/readme.hints.md
@@ -0,0 +1,79 @@
+# SmartRequest Architecture Hints
+
+## Core Features
+- supports http
+- supports https  
+- supports unix socks
+- supports formData
+- supports file uploads
+- supports best practice keepAlive
+- dedicated functions for working with JSON request/response cycles
+- 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 v3.0.0 major refactoring)
+- The project now has a multi-layer architecture with platform abstraction
+- Base layer (ts/core_base/) contains abstract classes and unified types
+- Node.js implementation (ts/core_node/) uses native http/https modules
+- Fetch implementation (ts/core_fetch/) uses Fetch API for browser 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 Base Module (ts/core_base/)
+- `request.ts`: Abstract CoreRequest class defining the request interface
+- `response.ts`: Abstract CoreResponse class with fetch-like API
+  - Defines `stream()` method that always returns web-style ReadableStream
+  - Body can only be consumed once (throws error on second attempt)
+- `types.ts`: Unified TypeScript interfaces and types
+  - Single `ICoreRequestOptions` interface for all implementations
+  - Implementations handle unsupported options by throwing errors
+
+### Core Node Module (ts/core_node/)
+- `request.ts`: Node.js implementation using http/https modules
+  - 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
+
+### Stream Handling
+- `stream()` method always returns web-style ReadableStream<Uint8Array>
+- In Node.js, converts native streams to web streams
+- `streamNode()` available only in Node.js environment for native streams
+- Consistent API across platforms while preserving platform-specific capabilities
+
+### Binary Request Handling
+- Binary requests handled through ArrayBuffer API
+- Response body kept as Buffer/ArrayBuffer without string conversion
+- No automatic transformations applied to binary data
+
+## Testing
+- Use `pnpm test` to run all tests
+- Tests use @git.zone/tstest/tapbundle for assertions
+- 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
@@ -0,0 +1,513 @@
+# @push.rocks/smartrequest
+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
+```bash
+# Using npm
+npm install @push.rocks/smartrequest --save
+
+# Using pnpm  
+pnpm add @push.rocks/smartrequest
+
+# Using yarn
+yarn add @push.rocks/smartrequest
+```
+
+## Key Features
+
+- 🚀 **Modern Fetch-like API** - Familiar response methods (`.json()`, `.text()`, `.arrayBuffer()`, `.stream()`)
+- 🌐 **Cross-Platform** - Works in both Node.js and browsers with a unified API
+- 🔌 **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 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
+- 🔧 **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` provides a clean, type-safe API inspired by the native fetch API but with additional features needed for modern applications.
+
+### Basic Usage
+
+```typescript
+import { SmartRequest } from '@push.rocks/smartrequest';
+
+// Simple GET request
+async function fetchUserData(userId: number) {
+  const response = await SmartRequest.create()
+    .url(`https://jsonplaceholder.typicode.com/users/${userId}`)
+    .get();
+
+  // Use the fetch-like response API
+  const userData = await response.json();
+  console.log(userData); // The parsed JSON response
+}
+
+// POST request with JSON body
+async function createPost(title: string, body: string, userId: number) {
+  const response = await SmartRequest.create()
+    .url('https://jsonplaceholder.typicode.com/posts')
+    .json({ title, body, userId })
+    .post();
+
+  const createdPost = await response.json();
+  console.log(createdPost); // The created post
+}
+```
+
+### 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 { SmartRequest } from '@push.rocks/smartrequest';
+
+async function searchRepositories(query: string, perPage: number = 10) {
+  const response = await SmartRequest.create()
+    .url('https://api.github.com/search/repositories')
+    .header('Accept', 'application/vnd.github.v3+json')
+    .query({
+      q: query,
+      per_page: perPage.toString()
+    })
+    .get();
+
+  const data = await response.json();
+  return data.items;
+}
+```
+
+### Handling Timeouts and Retries
+
+```typescript
+import { SmartRequest } from '@push.rocks/smartrequest';
+
+async function fetchWithRetry(url: string) {
+  const response = await SmartRequest.create()
+    .url(url)
+    .timeout(5000) // 5 seconds timeout
+    .retry(3) // Retry up to 3 times on failure
+    .get();
+
+  return await response.json();
+}
+```
+
+### Working with Different Response Types
+
+The API provides a fetch-like interface for handling different response types:
+
+```typescript
+import { SmartRequest } from '@push.rocks/smartrequest';
+
+// JSON response (default)
+async function fetchJson(url: string) {
+  const response = await SmartRequest.create()
+    .url(url)
+    .get();
+  
+  return await response.json(); // Parses JSON automatically
+}
+
+// Text response
+async function fetchText(url: string) {
+  const response = await SmartRequest.create()
+    .url(url)
+    .get();
+  
+  return await response.text(); // Returns response as string
+}
+
+// Binary data
+async function downloadImage(url: string) {
+  const response = await SmartRequest.create()
+    .url(url)
+    .accept('binary') // Optional: hints to server we want binary
+    .get();
+
+  const buffer = await response.arrayBuffer();
+  return Buffer.from(buffer); // Convert ArrayBuffer to Buffer if needed
+}
+
+// Streaming response (Web Streams API)
+async function streamLargeFile(url: string) {
+  const response = await SmartRequest.create()
+    .url(url)
+    .get();
+
+  // Get a web-style ReadableStream (works in both Node.js and browsers)
+  const stream = response.stream();
+  
+  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) => {
+    nodeStream.on('end', resolve);
+    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 library includes built-in support for various pagination strategies:
+
+```typescript
+import { SmartRequest } from '@push.rocks/smartrequest';
+
+// Offset-based pagination (page & limit)
+async function fetchAllUsers() {
+  const client = SmartRequest.create()
+    .url('https://api.example.com/users')
+    .withOffsetPagination({
+      pageParam: 'page',
+      limitParam: 'limit',
+      startPage: 1,
+      pageSize: 20,
+      totalPath: 'meta.total'
+    });
+
+  // Get first page with pagination info
+  const firstPage = await client.getPaginated();
+  console.log(`Found ${firstPage.items.length} users on first page`);
+  console.log(`Has more pages: ${firstPage.hasNextPage}`);
+
+  if (firstPage.hasNextPage) {
+    // Get next page
+    const secondPage = await firstPage.getNextPage();
+    console.log(`Found ${secondPage.items.length} more users`);
+  }
+
+  // Or get all pages at once (use with caution for large datasets)
+  const allUsers = await client.getAllPages();
+  console.log(`Retrieved ${allUsers.length} users in total`);
+}
+
+// Cursor-based pagination
+async function fetchAllPosts() {
+  const allPosts = await SmartRequest.create()
+    .url('https://api.example.com/posts')
+    .withCursorPagination({
+      cursorParam: 'cursor',
+      cursorPath: 'meta.nextCursor',
+      hasMorePath: 'meta.hasMore'
+    })
+    .getAllPages();
+
+  console.log(`Retrieved ${allPosts.length} posts in total`);
+}
+
+// Link header-based pagination (GitHub API style)
+async function fetchAllIssues(repo: string) {
+  const paginatedResponse = await SmartRequest.create()
+    .url(`https://api.github.com/repos/${repo}/issues`)
+    .header('Accept', 'application/vnd.github.v3+json')
+    .withLinkPagination()
+    .getPaginated();
+
+  return paginatedResponse.getAllPages();
+}
+```
+
+### Keep-Alive Connections (Node.js)
+
+```typescript
+import { SmartRequest } from '@push.rocks/smartrequest';
+
+// Enable keep-alive for better performance with multiple requests
+async function performMultipleRequests() {
+  const client = SmartRequest.create()
+    .header('Connection', 'keep-alive');
+
+  // 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(),
+    client.url('https://api.example.com/endpoint3').get()
+  ]);
+
+  return Promise.all(results.map(r => r.json()));
+}
+```
+
+## Platform-Specific Features
+
+### Browser-Specific Options
+
+When running in a browser, you can use browser-specific fetch options:
+
+```typescript
+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;
+  name: string;
+  email: string;
+}
+
+interface Post {
+  id: number;
+  title: string;
+  body: string;
+  userId: number;
+}
+
+class BlogApiClient {
+  private baseUrl = 'https://jsonplaceholder.typicode.com';
+  
+  private async request(path: string) {
+    return SmartRequest.create()
+      .url(`${this.baseUrl}${path}`)
+      .header('Accept', 'application/json');
+  }
+  
+  async getUser(id: number): Promise<User> {
+    const response = await this.request(`/users/${id}`).get();
+    return response.json<User>();
+  }
+  
+  async createPost(post: Omit<Post, 'id'>): Promise<Post> {
+    const response = await this.request('/posts')
+      .json(post)
+      .post();
+    return response.json<Post>();
+  }
+  
+  async deletePost(id: number): Promise<void> {
+    const response = await this.request(`/posts/${id}`).delete();
+    
+    if (!response.ok) {
+      throw new Error(`Failed to delete post: ${response.statusText}`);
+    }
+  }
+  
+  async getAllPosts(userId?: number): Promise<Post[]> {
+    const client = this.request('/posts');
+    
+    if (userId) {
+      client.query({ userId: userId.toString() });
+    }
+    
+    const response = await client.get();
+    return response.json<Post[]>();
+  }
+}
+
+// Usage
+const api = new BlogApiClient();
+const user = await api.getUser(1);
+const posts = await api.getAllPosts(user.id);
+```
+
+## Error Handling
+
+```typescript
+import { SmartRequest } from '@push.rocks/smartrequest';
+
+async function fetchWithErrorHandling(url: string) {
+  try {
+    const response = await SmartRequest.create()
+      .url(url)
+      .timeout(5000)
+      .retry(2)
+      .get();
+    
+    // Check if request was successful
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    
+    // Handle different content types
+    const contentType = response.headers['content-type'];
+    
+    if (contentType?.includes('application/json')) {
+      return await response.json();
+    } else if (contentType?.includes('text/')) {
+      return await response.text();
+    } else {
+      return await response.arrayBuffer();
+    }
+  } catch (error) {
+    if (error.code === 'ECONNREFUSED') {
+      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);
+    }
+    throw error;
+  }
+}
+```
+
+## 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. 
+
+**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
+
+### Trademarks
+
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.
+
+### Company Information
+
+Task Venture Capital GmbH  
+Registered at District court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
+
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
--- 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.node.ts
+++ b/test/test.node.ts
@@ -0,0 +1,95 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+
+import { SmartRequest } from '../ts/client/index.js';
+
+tap.test('client: should request a html document over https', async () => {
+  const response = await SmartRequest.create()
+    .url('https://encrypted.google.com/')
+    .get();
+
+  expect(response).not.toBeNull();
+  expect(response).toHaveProperty('status');
+  expect(response.status).toBeGreaterThan(0);
+  const text = await response.text();
+  expect(text.length).toBeGreaterThan(0);
+});
+
+tap.test('client: should request a JSON document over https', async () => {
+  const response = await SmartRequest.create()
+    .url('https://jsonplaceholder.typicode.com/posts/1')
+    .get();
+
+  const body = await response.json();
+  expect(body).toHaveProperty('id');
+  expect(body.id).toEqual(1);
+});
+
+tap.test('client: should post a JSON document over http', async () => {
+  const testData = { text: 'example_text' };
+  const response = await SmartRequest.create()
+    .url('https://httpbin.org/post')
+    .json(testData)
+    .post();
+
+  const body = await response.json();
+  expect(body).toHaveProperty('json');
+  expect(body.json).toHaveProperty('text');
+  expect(body.json.text).toEqual('example_text');
+});
+
+tap.test('client: should set headers correctly', async () => {
+  const customHeader = 'X-Custom-Header';
+  const headerValue = 'test-value';
+
+  const response = await SmartRequest.create()
+    .url('https://httpbin.org/headers')
+    .header(customHeader, headerValue)
+    .get();
+
+  const body = await response.json();
+  expect(body).toHaveProperty('headers');
+
+  // Check if the header exists (case-sensitive)
+  expect(body.headers).toHaveProperty(customHeader);
+  expect(body.headers[customHeader]).toEqual(headerValue);
+});
+
+tap.test('client: should handle query parameters', async () => {
+  const params = { param1: 'value1', param2: 'value2' };
+
+  const response = await SmartRequest.create()
+    .url('https://httpbin.org/get')
+    .query(params)
+    .get();
+
+  const body = await response.json();
+  expect(body).toHaveProperty('args');
+  expect(body.args).toHaveProperty('param1');
+  expect(body.args.param1).toEqual('value1');
+  expect(body.args).toHaveProperty('param2');
+  expect(body.args.param2).toEqual('value2');
+});
+
+tap.test('client: should handle timeout configuration', async () => {
+  // This test just verifies that the timeout method doesn't throw
+  const client = SmartRequest.create()
+    .url('https://httpbin.org/get')
+    .timeout(5000);
+
+  const response = await client.get();
+  expect(response).toHaveProperty('ok');
+  expect(response.ok).toBeTrue();
+});
+
+tap.test('client: should handle retry configuration', async () => {
+  // This test just verifies that the retry method doesn't throw
+  const client = SmartRequest.create()
+    .url('https://httpbin.org/get')
+    .retry(1);
+
+  const response = await client.get();
+  expect(response).toHaveProperty('ok');
+  expect(response.ok).toBeTrue();
+});
+
+tap.start();
--- a/test/test.ts
+++ b/test/test.ts
@@ -1,46 +0,0 @@
-import { tap, expect } from '@pushrocks/tapbundle';
-
-import * as smartrequest from '../ts/index';
-
-tap.test('should request a html document over https', async () => {
-  await expect(smartrequest.getJson('https://encrypted.google.com/'))
-    .to.eventually.property('body')
-    .be.a('string');
-  await expect(smartrequest.getJson('https://encrypted.google.com/'))
-    .to.eventually.property('body')
-    .be.a('string');
-  await expect(smartrequest.getJson('https://encrypted.google.com/'))
-    .to.eventually.property('body')
-    .be.a('string');
-});
-
-tap.test('should request a JSON document over https', async () => {
-  await expect(smartrequest.getJson('https://jsonplaceholder.typicode.com/posts/1'))
-    .to.eventually.property('body')
-    .property('id')
-    .equal(1);
-});
-
-tap.skip.test('should post a JSON document over http', async () => {
-  await expect(smartrequest.postJson('http://md5.jsontest.com/?text=example_text'))
-    .to.eventually.property('body')
-    .property('md5')
-    .equal('fa4c6baa0812e5b5c80ed8885e55a8a6');
-});
-
-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/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartrequest',
+  version: '2.1.0',
+  description: 'A module for modern HTTP/HTTPS requests with support for form data, file uploads, JSON, binary data, streams, and more.'
+}
--- a/ts/client/features/pagination.ts
+++ b/ts/client/features/pagination.ts
@@ -0,0 +1,176 @@
+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: 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() as any;
+  
+  // Default to response.body for items if response is JSON
+  let items: T[] = Array.isArray(body)
+    ? body
+    : (body?.items || body?.data || body?.results || []);
+
+  let hasNextPage = false;
+  let nextPageParams: Record<string, string> = {};
+
+  // Determine if there's a next page based on pagination strategy
+  switch (paginationConfig.strategy) {
+    case PaginationStrategy.OFFSET: {
+      const config = paginationConfig;
+      const currentPage = parseInt(queryParams[config.pageParam || 'page'] || String(config.startPage || 1));
+      const limit = parseInt(queryParams[config.limitParam || 'limit'] || String(config.pageSize || 20));
+      const total = getValueByPath(body, config.totalPath || 'total') || 0;
+
+      hasNextPage = currentPage * limit < total;
+
+      if (hasNextPage) {
+        nextPageParams = {
+          ...queryParams,
+          [config.pageParam || 'page']: String(currentPage + 1)
+        };
+      }
+      break;
+    }
+
+    case PaginationStrategy.CURSOR: {
+      const config = paginationConfig;
+      const nextCursor = getValueByPath(body, config.cursorPath || 'nextCursor');
+      const hasMore = getValueByPath(body, config.hasMorePath || 'hasMore');
+
+      hasNextPage = !!nextCursor || !!hasMore;
+
+      if (hasNextPage && nextCursor) {
+        nextPageParams = {
+          ...queryParams,
+          [config.cursorParam || 'cursor']: nextCursor
+        };
+      }
+      break;
+    }
+
+    case PaginationStrategy.LINK_HEADER: {
+      const linkHeader = response.headers['link'] || '';
+      // Handle both string and string[] types for the link header
+      const headerValue = Array.isArray(linkHeader) ? linkHeader[0] : linkHeader;
+      const links = parseLinkHeader(headerValue);
+
+      hasNextPage = !!links.next;
+
+      if (hasNextPage && links.next) {
+        // Extract query parameters from next link URL
+        const url = new URL(links.next);
+        nextPageParams = {};
+
+        url.searchParams.forEach((value, key) => {
+          nextPageParams[key] = value;
+        });
+      }
+      break;
+    }
+
+    case PaginationStrategy.CUSTOM: {
+      const config = paginationConfig;
+      hasNextPage = config.hasNextPage(response);
+
+      if (hasNextPage) {
+        nextPageParams = config.getNextPageParams(response, queryParams);
+      }
+      break;
+    }
+  }
+
+  // Create a function to fetch the next page
+  const getNextPage = async (): Promise<TPaginatedResponse<T>> => {
+    if (!hasNextPage) {
+      throw new Error('No more pages available');
+    }
+
+    return fetchNextPage(nextPageParams);
+  };
+
+  // Create a function to fetch all remaining pages
+  const getAllPages = async (): Promise<T[]> => {
+    const allItems = [...items];
+    let currentPage: TPaginatedResponse<T> = { items, hasNextPage, getNextPage, getAllPages, response };
+
+    while (currentPage.hasNextPage) {
+      try {
+        currentPage = await currentPage.getNextPage();
+        allItems.push(...currentPage.items);
+      } catch (error) {
+        break;
+      }
+    }
+
+    return allItems;
+  };
+
+  return {
+    items,
+    hasNextPage,
+    getNextPage,
+    getAllPages,
+    response
+  };
+}
+
+/**
+ * Parse Link header for pagination
+ * Link: <https://api.example.com/users?page=2>; rel="next", <https://api.example.com/users?page=5>; rel="last"
+ */
+export function parseLinkHeader(header: string): Record<string, string> {
+  const links: Record<string, string> = {};
+
+  if (!header) {
+    return links;
+  }
+
+  // Split parts by comma
+  const parts = header.split(',');
+
+  // Parse each part into a name:value pair
+  for (const part of parts) {
+    const section = part.split(';');
+    if (section.length < 2) {
+      continue;
+    }
+
+    const url = section[0].replace(/<(.*)>/, '$1').trim();
+    const name = section[1].replace(/rel="(.*)"/, '$1').trim();
+
+    links[name] = url;
+  }
+
+  return links;
+}
+
+/**
+ * Get a nested value from an object using dot notation path
+ * e.g., getValueByPath(obj, "data.pagination.nextCursor")
+ */
+export function getValueByPath(obj: any, path?: string): any {
+  if (!path || !obj) {
+    return undefined;
+  }
+
+  const keys = path.split('.');
+  let current = obj;
+
+  for (const key of keys) {
+    if (current === null || current === undefined || typeof current !== 'object') {
+      return undefined;
+    }
+    current = current[key];
+  }
+
+  return current;
+}
--- a/ts/client/index.ts
+++ b/ts/client/index.ts
@@ -0,0 +1,48 @@
+// Export the main client
+export { SmartRequest } from './smartrequest.js';
+
+// Export response type from core
+export { CoreResponse } from '../core/index.js';
+
+// Export types
+export type { HttpMethod, ResponseType, FormField, RetryConfig, TimeoutConfig } from './types/common.js';
+export { 
+  PaginationStrategy,
+  type TPaginationConfig as PaginationConfig,
+  type OffsetPaginationConfig,
+  type CursorPaginationConfig,
+  type LinkPaginationConfig,
+  type CustomPaginationConfig,
+  type TPaginatedResponse as PaginatedResponse
+} from './types/pagination.js';
+
+// Convenience factory functions
+import { SmartRequest } from './smartrequest.js';
+
+/**
+ * Create a client pre-configured for JSON requests
+ */
+export function createJsonClient<T = any>() {
+  return SmartRequest.create<T>();
+}
+
+/**
+ * Create a client pre-configured for form data requests
+ */
+export function createFormClient<T = any>() {
+  return SmartRequest.create<T>();
+}
+
+/**
+ * Create a client pre-configured for binary data
+ */
+export function createBinaryClient<T = any>() {
+  return SmartRequest.create<T>().accept('binary');
+}
+
+/**
+ * Create a client pre-configured for streaming
+ */
+export function createStreamClient() {
+  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/client/smartrequest.ts
+++ b/ts/client/smartrequest.ts
@@ -0,0 +1,332 @@
+import { CoreRequest, CoreResponse } from '../core/index.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 {
+  type TPaginationConfig,
+  PaginationStrategy,
+  type OffsetPaginationConfig,
+  type CursorPaginationConfig,
+  type CustomPaginationConfig,
+  type TPaginatedResponse
+} from './types/pagination.js';
+import { createPaginatedResponse } from './features/pagination.js';
+
+/**
+ * Modern fluent client for making HTTP requests
+ */
+export class SmartRequest<T = any> {
+  private _url: string;
+  private _options: ICoreRequestOptions = {};
+  private _retries: number = 0;
+  private _queryParams: Record<string, string> = {};
+  private _paginationConfig?: TPaginationConfig;
+
+  /**
+   * Create a new SmartRequest instance
+   */
+  static create<T = any>(): SmartRequest<T> {
+    return new SmartRequest<T>();
+  }
+
+  /**
+   * Set the URL for the request
+   */
+  url(url: string): this {
+    this._url = url;
+    return this;
+  }
+
+  /**
+   * Set the HTTP method
+   */
+  method(method: HttpMethod): this {
+    this._options.method = method;
+    return this;
+  }
+
+  /**
+   * Set JSON body for the request
+   */
+  json(data: any): this {
+    if (!this._options.headers) {
+      this._options.headers = {};
+    }
+    this._options.headers['Content-Type'] = 'application/json';
+    this._options.requestBody = data;
+    return this;
+  }
+
+  /**
+   * Set form data for the request
+   */
+  formData(data: FormField[]): this {
+    const form = new plugins.formData();
+
+    for (const item of data) {
+      if (Buffer.isBuffer(item.value)) {
+        form.append(item.name, item.value, {
+          filename: item.filename || 'file',
+          contentType: item.contentType || 'application/octet-stream'
+        });
+      } else {
+        form.append(item.name, item.value);
+      }
+    }
+
+    if (!this._options.headers) {
+      this._options.headers = {};
+    }
+
+    this._options.headers = {
+      ...this._options.headers,
+      ...form.getHeaders()
+    };
+
+    this._options.requestBody = form;
+    return this;
+  }
+
+  /**
+   * Set request timeout in milliseconds
+   */
+  timeout(ms: number): this {
+    this._options.timeout = ms;
+    this._options.hardDataCuttingTimeout = ms;
+    return this;
+  }
+
+  /**
+   * Set number of retry attempts
+   */
+  retry(count: number): this {
+    this._retries = count;
+    return this;
+  }
+
+  /**
+   * Set HTTP headers
+   */
+  headers(headers: Record<string, string>): this {
+    if (!this._options.headers) {
+      this._options.headers = {};
+    }
+    this._options.headers = {
+      ...this._options.headers,
+      ...headers
+    };
+    return this;
+  }
+
+  /**
+   * Set a single HTTP header
+   */
+  header(name: string, value: string): this {
+    if (!this._options.headers) {
+      this._options.headers = {};
+    }
+    this._options.headers[name] = value;
+    return this;
+  }
+
+  /**
+   * Set query parameters
+   */
+  query(params: Record<string, string>): this {
+    this._queryParams = {
+      ...this._queryParams,
+      ...params
+    };
+    return this;
+  }
+
+  /**
+   * Set the Accept header to indicate what content type is expected
+   */
+  accept(type: ResponseType): this {
+    // Map response types to Accept header values
+    const acceptHeaders: Record<ResponseType, string> = {
+      'json': 'application/json',
+      'text': 'text/plain',
+      'binary': 'application/octet-stream',
+      'stream': '*/*'
+    };
+    
+    return this.header('Accept', acceptHeaders[type]);
+  }
+
+  /**
+   * Configure pagination for requests
+   */
+  pagination(config: TPaginationConfig): this {
+    this._paginationConfig = config;
+    return this;
+  }
+
+  /**
+   * Configure offset-based pagination (page & limit)
+   */
+  withOffsetPagination(config: Omit<OffsetPaginationConfig, 'strategy'> = {}): this {
+    this._paginationConfig = {
+      strategy: PaginationStrategy.OFFSET,
+      pageParam: config.pageParam || 'page',
+      limitParam: config.limitParam || 'limit',
+      startPage: config.startPage || 1,
+      pageSize: config.pageSize || 20,
+      totalPath: config.totalPath || 'total'
+    };
+
+    // Add initial pagination parameters
+    this.query({
+      [this._paginationConfig.pageParam]: String(this._paginationConfig.startPage),
+      [this._paginationConfig.limitParam]: String(this._paginationConfig.pageSize)
+    });
+
+    return this;
+  }
+
+  /**
+   * Configure cursor-based pagination
+   */
+  withCursorPagination(config: Omit<CursorPaginationConfig, 'strategy'> = {}): this {
+    this._paginationConfig = {
+      strategy: PaginationStrategy.CURSOR,
+      cursorParam: config.cursorParam || 'cursor',
+      cursorPath: config.cursorPath || 'nextCursor',
+      hasMorePath: config.hasMorePath || 'hasMore'
+    };
+    return this;
+  }
+
+  /**
+   * Configure Link header-based pagination
+   */
+  withLinkPagination(): this {
+    this._paginationConfig = {
+      strategy: PaginationStrategy.LINK_HEADER
+    };
+    return this;
+  }
+
+  /**
+   * Configure custom pagination
+   */
+  withCustomPagination(config: Omit<CustomPaginationConfig, 'strategy'>): this {
+    this._paginationConfig = {
+      strategy: PaginationStrategy.CUSTOM,
+      hasNextPage: config.hasNextPage,
+      getNextPageParams: config.getNextPageParams
+    };
+    return this;
+  }
+
+  /**
+   * Make a GET request
+   */
+  async get<R = T>(): Promise<ICoreResponse<R>> {
+    return this.execute<R>('GET');
+  }
+
+  /**
+   * Make a POST request
+   */
+  async post<R = T>(): Promise<ICoreResponse<R>> {
+    return this.execute<R>('POST');
+  }
+
+  /**
+   * Make a PUT request
+   */
+  async put<R = T>(): Promise<ICoreResponse<R>> {
+    return this.execute<R>('PUT');
+  }
+
+  /**
+   * Make a DELETE request
+   */
+  async delete<R = T>(): Promise<ICoreResponse<R>> {
+    return this.execute<R>('DELETE');
+  }
+
+  /**
+   * Make a PATCH request
+   */
+  async patch<R = T>(): Promise<ICoreResponse<R>> {
+    return this.execute<R>('PATCH');
+  }
+
+  /**
+   * Get paginated response
+   */
+  async getPaginated<ItemType = T>(): Promise<TPaginatedResponse<ItemType>> {
+    if (!this._paginationConfig) {
+      throw new Error('Pagination not configured. Call one of the pagination methods first.');
+    }
+
+    // Default to GET if no method specified
+    if (!this._options.method) {
+      this._options.method = 'GET';
+    }
+
+    const response = await this.execute();
+
+    return await createPaginatedResponse<ItemType>(
+      response,
+      this._paginationConfig,
+      this._queryParams,
+      (nextPageParams) => {
+        // Create a new client with the same configuration but updated query params
+        const nextClient = new SmartRequest<ItemType>();
+        Object.assign(nextClient, this);
+        nextClient._queryParams = nextPageParams;
+
+        return nextClient.getPaginated<ItemType>();
+      }
+    );
+  }
+
+  /**
+   * Get all pages at once (use with caution for large datasets)
+   */
+  async getAllPages<ItemType = T>(): Promise<ItemType[]> {
+    const firstPage = await this.getPaginated<ItemType>();
+    return firstPage.getAllPages();
+  }
+
+  /**
+   * Execute the HTTP request
+   */
+  private async execute<R = T>(method?: HttpMethod): Promise<ICoreResponse<R>> {
+    if (method) {
+      this._options.method = method;
+    }
+
+    this._options.queryParams = this._queryParams;
+
+    // Handle retry logic
+    let lastError: Error;
+
+    for (let attempt = 0; attempt <= this._retries; attempt++) {
+      try {
+        const request = new CoreRequest(this._url, this._options as any);
+        const response = await request.fire();
+        return response as ICoreResponse<R>;
+      } catch (error) {
+        lastError = error as Error;
+
+        // If this is the last attempt, throw the error
+        if (attempt === this._retries) {
+          throw lastError;
+        }
+
+        // Otherwise, wait before retrying
+        await new Promise(resolve => setTimeout(resolve, 1000));
+      }
+    }
+
+    // This should never be reached due to the throw in the loop above
+    throw lastError;
+  }
+}
--- a/ts/client/types/common.ts
+++ b/ts/client/types/common.ts
@@ -0,0 +1,49 @@
+/**
+ * HTTP Methods supported by the client
+ */
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+
+/**
+ * Response types supported by the client
+ */
+export type ResponseType = 'json' | 'text' | 'binary' | 'stream';
+
+/**
+ * Form field data for multipart/form-data requests
+ */
+export interface FormField {
+  name: string;
+  value: string | Buffer;
+  filename?: string;
+  contentType?: string;
+}
+
+/**
+ * URL encoded form field
+ */
+export interface UrlEncodedField {
+  key: string;
+  value: string;
+}
+
+/**
+ * Retry configuration
+ */
+export interface RetryConfig {
+  attempts: number;         // Number of retry attempts
+  initialDelay?: number;    // Initial delay in ms
+  maxDelay?: number;        // Maximum delay in ms
+  factor?: number;          // Backoff factor
+  statusCodes?: number[];   // Status codes to retry on
+  shouldRetry?: (error: Error, attemptCount: number) => boolean;
+}
+
+/**
+ * Timeout configuration
+ */
+export interface TimeoutConfig {
+  request?: number;         // Overall request timeout in ms
+  connection?: number;      // Connection timeout in ms
+  socket?: number;          // Socket idle timeout in ms
+  response?: number;        // Response timeout in ms
+}
--- a/ts/client/types/pagination.ts
+++ b/ts/client/types/pagination.ts
@@ -0,0 +1,67 @@
+import { type CoreResponse } from '../../core/index.js';
+import type { ICoreResponse } from '../../core_base/types.js';
+
+/**
+ * Pagination strategy options
+ */
+export enum PaginationStrategy {
+  OFFSET = 'offset',        // Uses page & limit parameters
+  CURSOR = 'cursor',        // Uses a cursor/token for next page
+  LINK_HEADER = 'link',     // Uses Link headers
+  CUSTOM = 'custom'         // Uses a custom pagination handler
+}
+
+/**
+ * Configuration for offset-based pagination
+ */
+export interface OffsetPaginationConfig {
+  strategy: PaginationStrategy.OFFSET;
+  pageParam?: string;       // Parameter name for page number (default: "page")
+  limitParam?: string;      // Parameter name for page size (default: "limit")
+  startPage?: number;       // Starting page number (default: 1)
+  pageSize?: number;        // Number of items per page (default: 20)
+  totalPath?: string;       // JSON path to total item count (default: "total")
+}
+
+/**
+ * Configuration for cursor-based pagination
+ */
+export interface CursorPaginationConfig {
+  strategy: PaginationStrategy.CURSOR;
+  cursorParam?: string;     // Parameter name for cursor (default: "cursor")
+  cursorPath?: string;      // JSON path to next cursor (default: "nextCursor")
+  hasMorePath?: string;     // JSON path to check if more items exist (default: "hasMore")
+}
+
+/**
+ * Configuration for Link header-based pagination
+ */
+export interface LinkPaginationConfig {
+  strategy: PaginationStrategy.LINK_HEADER;
+  // No additional config needed, uses standard Link header format
+}
+
+/**
+ * Configuration for custom pagination
+ */
+export interface CustomPaginationConfig {
+  strategy: PaginationStrategy.CUSTOM;
+  hasNextPage: (response: ICoreResponse<any>) => boolean;
+  getNextPageParams: (response: ICoreResponse<any>, currentParams: Record<string, string>) => Record<string, string>;
+}
+
+/**
+ * Union type of all pagination configurations
+ */
+export type TPaginationConfig = OffsetPaginationConfig | CursorPaginationConfig | LinkPaginationConfig | CustomPaginationConfig;
+
+/**
+ * Interface for a paginated response
+ */
+export interface TPaginatedResponse<T> {
+  items: T[];                   // Current page items
+  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: ICoreResponse<any>;  // Original response
+}
--- a/ts/core/index.ts
+++ b/ts/core/index.ts
@@ -0,0 +1,30 @@
+import * as plugins from './plugins.js';
+
+// Export all base types - these are the public API
+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
@@ -0,0 +1,4 @@
+import * as smartenv from '@push.rocks/smartenv';
+import * as smartpath from '@push.rocks/smartpath/iso';
+
+export { smartenv, smartpath };
--- 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
@@ -0,0 +1,136 @@
+import * as plugins from './plugins.js';
+import * as types from './types.js';
+import { CoreResponse as AbstractCoreResponse } from '../core_base/response.js';
+
+/**
+ * Node.js implementation of Core Response class that provides a fetch-like API
+ */
+export class CoreResponse<T = any> extends AbstractCoreResponse<T> implements types.INodeResponse<T> {
+  private incomingMessage: plugins.http.IncomingMessage;
+  private bodyBufferPromise: Promise<Buffer> | null = null;
+
+  // Public properties
+  public readonly ok: boolean;
+  public readonly status: number;
+  public readonly statusText: string;
+  public readonly headers: plugins.http.IncomingHttpHeaders;
+  public readonly url: string;
+
+  constructor(incomingMessage: plugins.http.IncomingMessage, url: string) {
+    super();
+    this.incomingMessage = incomingMessage;
+    this.url = url;
+    this.status = incomingMessage.statusCode || 0;
+    this.statusText = incomingMessage.statusMessage || '';
+    this.ok = this.status >= 200 && this.status < 300;
+    this.headers = incomingMessage.headers;
+  }
+
+  /**
+   * Collects the body as a buffer
+   */
+  private async collectBody(): Promise<Buffer> {
+    this.ensureNotConsumed();
+    
+    if (this.bodyBufferPromise) {
+      return this.bodyBufferPromise;
+    }
+
+    this.bodyBufferPromise = new Promise<Buffer>((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      
+      this.incomingMessage.on('data', (chunk: Buffer) => {
+        chunks.push(chunk);
+      });
+      
+      this.incomingMessage.on('end', () => {
+        resolve(Buffer.concat(chunks));
+      });
+      
+      this.incomingMessage.on('error', reject);
+    });
+
+    return this.bodyBufferPromise;
+  }
+
+  /**
+   * Parse response as JSON
+   */
+  async json(): Promise<T> {
+    const buffer = await this.collectBody();
+    const text = buffer.toString('utf-8');
+    
+    try {
+      return JSON.parse(text);
+    } catch (error) {
+      throw new Error(`Failed to parse JSON: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get response as text
+   */
+  async text(): Promise<string> {
+    const buffer = await this.collectBody();
+    return buffer.toString('utf-8');
+  }
+
+  /**
+   * Get response as ArrayBuffer
+   */
+  async arrayBuffer(): Promise<ArrayBuffer> {
+    const buffer = await this.collectBody();
+    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  }
+
+  /**
+   * Get response as a web-style 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;
+  }
+
+  /**
+   * Get the raw IncomingMessage (for legacy compatibility)
+   */
+  raw(): plugins.http.IncomingMessage {
+    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,6 +1,10 @@
-export { request, IExtendedIncomingMessage } from './smartrequest.request';
-export { ISmartRequestOptions } from './smartrequest.interfaces';
+// Client API exports
+export * from './client/index.js';

-export * from './smartrequest.jsonrest';
-export * from './smartrequest.binaryrest';
-export * from './smartrequest.formdata';
+// Core exports for advanced usage
+export { CoreResponse } from './core/index.js';
+export type { ICoreRequestOptions, ICoreResponse } from './core_base/types.js';
+
+// Default export for easier importing
+import { SmartRequest } from './client/smartrequest.js';
+export default SmartRequest;
--- a/ts/smartrequest.binaryrest.ts
+++ b/ts/smartrequest.binaryrest.ts
@@ -1,29 +0,0 @@
-// this file implements methods to get and post binary data.
-import * as interfaces from './smartrequest.interfaces';
-import { request } from './smartrequest.request';
-
-import * as plugins from './smartrequest.plugins';
-
-export const getBinary = async (
-  domainArg: string,
-  optionsArg: interfaces.ISmartRequestOptions = {}
-) => {
-  const done = plugins.smartpromise.defer();
-  const response = await request(domainArg, optionsArg, true);
-  const data = [];
-
-  response
-    .on('data', function(chunk) {
-      data.push(chunk);
-    })
-    .on('end', function() {
-      //at this point data is an array of Buffers
-      //so Buffer.concat() can make us a new Buffer
-      //of all of them together
-      const buffer = Buffer.concat(data);
-      response.body = buffer.toString('binary');
-      done.resolve();
-    });
-  await done.promise;
-  return response;
-};
--- a/ts/smartrequest.formdata.ts
+++ b/ts/smartrequest.formdata.ts
@@ -1,44 +0,0 @@
-import * as plugins from './smartrequest.plugins';
-import * as interfaces from './smartrequest.interfaces';
-import { request } from './smartrequest.request';
-
-/**
- * the interfae for FormFieldData
- */
-export interface IFormField {
-  name: string;
-  type: 'string' | 'filePath' | 'Buffer';
-  payload: string;
-}
-
-const appendFormField = async (formDataArg: plugins.formData, formDataField: IFormField) => {
-  if (formDataField.type === 'filePath') {
-    const fileData = plugins.fs.readFileSync(plugins.path.join(process.cwd(), formDataField.payload));
-    formDataArg.append('file', fileData, {
-      filename: 'upload.pdf',
-      contentType: 'application/pdf'
-    });
-  }
-};
-
-export const postFormData = async (
-  urlArg: string,
-  optionsArg: interfaces.ISmartRequestOptions = {},
-  payloadArg: IFormField[]
-) => {
-  const form = new plugins.formData();
-  for (const formField of payloadArg) {
-    await appendFormField(form, formField);
-  }
-  const requestOptions = {...optionsArg, 
-    method: 'POST',
-    headers: {
-      ...optionsArg.headers,
-      ...form.getHeaders()
-    },
-    requestBody: form};
-
-  // lets fire the actual request for sending the formdata
-  const response = await request(urlArg, requestOptions);
-  return response;
-};
--- a/ts/smartrequest.interfaces.ts
+++ b/ts/smartrequest.interfaces.ts
@@ -1,8 +0,0 @@
-import * as plugins from './smartrequest.plugins';
-import * as https from 'https';
-
-export interface ISmartRequestOptions extends https.RequestOptions {
-  keepAlive?: boolean;
-  requestBody?: any;
-  autoJsonParse?: boolean;
-}
--- a/ts/smartrequest.jsonrest.ts
+++ b/ts/smartrequest.jsonrest.ts
@@ -1,63 +0,0 @@
-// This file implements methods to get and post JSON in a simple manner.
-
-import * as interfaces from './smartrequest.interfaces';
-import { request } from './smartrequest.request';
-
-/**
- * gets Json and puts the right headers + handles response aggregation
- * @param domainArg
- * @param optionsArg
- */
-export const getJson = async (
-  domainArg: string,
-  optionsArg: interfaces.ISmartRequestOptions = {}
-) => {
-  optionsArg.method = 'GET';
-  optionsArg.headers = {
-    ...optionsArg.headers
-  };
-  let response = await request(domainArg, optionsArg);
-  return response;
-};
-
-export const postJson = async (
-  domainArg: string,
-  optionsArg: interfaces.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'
-    };
-  }
-  let response = await request(domainArg, optionsArg);
-  return response;
-};
-
-export const putJson = async (
-  domainArg: string,
-  optionsArg: interfaces.ISmartRequestOptions = {}
-) => {
-  optionsArg.method = 'PUT';
-  let response = await request(domainArg, optionsArg);
-  return response;
-};
-
-export const delJson = async (
-  domainArg: string,
-  optionsArg: interfaces.ISmartRequestOptions = {}
-) => {
-  optionsArg.method = 'DELETE';
-  let response = await request(domainArg, optionsArg);
-  return response;
-};
--- a/ts/smartrequest.plugins.ts
+++ b/ts/smartrequest.plugins.ts
@@ -1,17 +0,0 @@
-import formData from 'form-data';
-import * as fs from 'fs';
-import * as http from 'http';
-import * as https from 'https';
-import * as path from 'path';
-import * as url from 'url';
-
-import * as smartpromise from '@pushrocks/smartpromise';
-
-export { formData, http, https, fs, path, url, smartpromise };
-
-// third party scope
-import * as agentkeepalive from 'agentkeepalive';
-
-export {
-  agentkeepalive
-};
--- a/ts/smartrequest.request.ts
+++ b/ts/smartrequest.request.ts
@@ -1,176 +0,0 @@
-import * as plugins from './smartrequest.plugins';
-import * as interfaces from './smartrequest.interfaces';
-
-import { IncomingMessage } from 'http';
-
-export interface IExtendedIncomingMessage extends IncomingMessage {
-  body: any;
-}
-
-const buildUtf8Response = (
-  incomingMessageArg: IncomingMessage,
-  autoJsonParse = true
-): Promise<IExtendedIncomingMessage> => {
-  const done = plugins.smartpromise.defer<IExtendedIncomingMessage>();
-  // Continuously update stream with data
-  let body = '';
-  incomingMessageArg.on('data', chunkArg => {
-    body += chunkArg;
-  });
-
-  incomingMessageArg.on('end', () => {
-    if (autoJsonParse) {
-      try {
-        (incomingMessageArg as IExtendedIncomingMessage).body = JSON.parse(body);
-      } catch (err) {
-        (incomingMessageArg as IExtendedIncomingMessage).body = body;
-      }
-    } else {
-      (incomingMessageArg as IExtendedIncomingMessage).body = body;
-    }
-    done.resolve(incomingMessageArg as IExtendedIncomingMessage);
-  });
-  return done.promise;
-};
-
-/**
- * determine wether a url is a unix sock
- * @param urlArg
- */
-const testForUnixSock = (urlArg: string): boolean => {
-  const unixRegex = /^(http:\/\/|https:\/\/|)unix:/;
-  return unixRegex.test(urlArg);
-};
-
-/**
- * determine socketPath and path for unixsock
- */
-const parseSocketPathAndRoute = (stringToParseArg: string) => {
-  const parseRegex = /(.*):(.*)/;
-  const result = parseRegex.exec(stringToParseArg);
-  return {
-    socketPath: result[1],
-    path: result[2]
-  };
-};
-
-/**
- * a custom http agent to make sure we can set custom keepAlive options for speedy subsequent calls
- */
-const httpAgent = new plugins.agentkeepalive.default();
-
-/**
- * a custom http agent to make sure we can set custom keepAlive options for speedy subsequent calls
- */
-const httpAgentKeepAliveFalse = new plugins.http.Agent({
-  maxFreeSockets: 0,
-  keepAlive: false,
-  keepAliveMsecs: 0
-});
-
-/**
- * a custom https agent to make sure we can set custom keepAlive options for speedy subsequent calls
- */
-const httpsAgent = new plugins.agentkeepalive.HttpsAgent();
-
-/**
- * a custom https agent to make sure we can set custom keepAlive options for speedy subsequent calls
- */
-const httpsAgentKeepAliveFalse = new plugins.https.Agent({
-  maxFreeSockets: 0,
-  keepAlive: false,
-  keepAliveMsecs: 0
-});
-
-export let request = async (
-  domainArg: string,
-  optionsArg: interfaces.ISmartRequestOptions = {},
-  responseStreamArg: boolean = false,
-  requestDataFunc: (req: plugins.http.ClientRequest) => void = null
-): Promise<IExtendedIncomingMessage> => {
-  const done = plugins.smartpromise.defer<any>();
-
-  // merge options
-  const defaultOptions: interfaces.ISmartRequestOptions = {
-    // agent: agent,
-    autoJsonParse: true,
-    keepAlive: true
-  };
-
-  optionsArg = {
-    ...defaultOptions,
-    ...optionsArg
-  };
-
-  // parse url
-  const parsedUrl = plugins.url.parse(domainArg);
-  optionsArg.hostname = parsedUrl.hostname;
-  if (parsedUrl.port) {
-    optionsArg.port = parseInt(parsedUrl.port, 10);
-  }
-  optionsArg.path = parsedUrl.path;
-
-  // determine if unixsock
-  if (testForUnixSock(domainArg)) {
-    const detailedUnixPath = parseSocketPathAndRoute(optionsArg.path);
-    optionsArg.socketPath = detailedUnixPath.socketPath;
-    optionsArg.path = detailedUnixPath.path;
-  }
-
-  // TODO: support tcp sockets
-
-  // lets determine the request module to use
-  const requestModule = (() => {
-    switch (true) {
-      case parsedUrl.protocol === 'https:' && optionsArg.keepAlive:
-        optionsArg.agent = httpsAgent;
-        return plugins.https;
-      case parsedUrl.protocol === 'https:' && (!optionsArg.keepAlive):
-        optionsArg.agent = httpsAgentKeepAliveFalse;
-        return plugins.https;
-      case parsedUrl.protocol === 'http:' && optionsArg.keepAlive:
-        optionsArg.agent = httpAgent;
-        return plugins.http;
-      case parsedUrl.protocol === 'http:' && (!optionsArg.keepAlive):
-        optionsArg.agent = httpAgentKeepAliveFalse;
-        return plugins.http;
-    }
-  })() as typeof plugins.https;
-
-  // lets perform the actual request
-  const requestToFire = requestModule.request(optionsArg, async response => {
-    if (responseStreamArg) {
-      done.resolve(response);
-    } else {
-      const builtResponse = await buildUtf8Response(response, optionsArg.autoJsonParse);
-      done.resolve(builtResponse);
-    }
-  });
-
-  // lets write the requestBody
-  if (optionsArg.requestBody) {
-    if (optionsArg.requestBody instanceof plugins.formData) {
-      optionsArg.requestBody.pipe(requestToFire).on('finish', event => {
-        requestToFire.end();
-      });
-    } else {
-      if (typeof optionsArg.requestBody !== 'string') {
-        optionsArg.requestBody = JSON.stringify(optionsArg.requestBody);
-      }
-      requestToFire.write(optionsArg.requestBody);
-      requestToFire.end();
-    }
-  } else if (requestDataFunc) {
-    requestDataFunc(requestToFire);
-  } else {
-    requestToFire.end();
-  }
-
-  // lets handle an error
-  requestToFire.on('error', e => {
-    console.error(e);
-  });
-
-  const result = await done.promise;
-  return result;
-};
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
+}
--- a/tslint.json
+++ b/tslint.json
@@ -1,17 +0,0 @@
-{
-  "extends": ["tslint:latest", "tslint-config-prettier"],
-  "rules": {
-    "semicolon": [true, "always"],
-    "no-console": false,
-    "ordered-imports": false,
-    "object-literal-sort-keys": false,
-    "member-ordering": {
-      "options":{
-        "order": [
-          "static-method"
-        ]
-      }
-    }
-  },
-  "defaultSeverity": "warning"
-}
Author	SHA1	Message	Date
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
Juergen Kunz	bbb57004d9	BREAKING CHANGE(core): major architectural refactoring with fetch-like API Some checks failed Default (tags) / security (push) Failing after 24s Details Default (tags) / test (push) Failing after 13s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-07-27 21:23:20 +00:00
Philipp Kunz	f7d2c6de4f	2.1.0 Some checks failed Default (tags) / security (push) Failing after 23s Details Default (tags) / test (push) Failing after 9s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-04-03 06:52:58 +00:00
Philipp Kunz	b8f545cdd5	feat(docs): Enhance documentation and tests with modern API usage examples and migration guide	2025-04-03 06:52:58 +00:00
Philipp Kunz	96820090d4	add modern version of request construction	2025-04-03 06:36:48 +00:00
Philipp Kunz	6e2c63fe1b	2.0.23	2024-11-06 20:58:17 +01:00
Philipp Kunz	39d3bb4d24	fix(core): Enhance type safety for response in binary requests	2024-11-06 20:58:17 +01:00
Philipp Kunz	62db3a9bc5	update description	2024-05-29 14:15:43 +02:00
Philipp Kunz	a82d9eafe2	2.0.22	2024-04-14 03:54:40 +02:00
Philipp Kunz	f55ab55365	fix(core): update	2024-04-14 03:54:39 +02:00
Philipp Kunz	9cf8c0b0f3	update tsconfig	2024-04-01 21:40:24 +02:00
Philipp Kunz	49796f89dd	update npmextra.json: githost	2024-04-01 19:59:25 +02:00
Philipp Kunz	aaeaa23b79	update npmextra.json: githost	2024-03-30 21:48:25 +01:00
Philipp Kunz	85199b8839	2.0.21	2023-11-09 21:22:58 +01:00
Philipp Kunz	33f7df28e2	fix(core): update	2023-11-09 21:22:57 +01:00
Philipp Kunz	29ee46b3a2	2.0.20	2023-11-03 01:37:11 +01:00
Philipp Kunz	18dd110d4e	fix(core): update	2023-11-03 01:37:10 +01:00
Philipp Kunz	fa93f13306	2.0.19	2023-11-03 00:47:43 +01:00
Philipp Kunz	81694cf58c	fix(core): update	2023-11-03 00:47:42 +01:00
Philipp Kunz	fdd1c7cdb3	2.0.18	2023-07-12 00:53:10 +02:00
Philipp Kunz	40f330791f	fix(core): update	2023-07-12 00:53:09 +02:00
Philipp Kunz	16b4d168db	2.0.17	2023-07-12 00:24:37 +02:00
Philipp Kunz	cc017a9bbf	fix(core): update	2023-07-12 00:24:36 +02:00
Philipp Kunz	2adf7e9ee2	2.0.16	2023-07-12 00:23:26 +02:00
Philipp Kunz	2303b6da7e	fix(core): update	2023-07-12 00:23:25 +02:00
Philipp Kunz	4487579bfd	switch to new org scheme	2023-07-10 10:17:43 +02:00
Philipp Kunz	8d2bbcae2a	2.0.15	2023-04-19 14:38:28 +02:00
Philipp Kunz	deb25a3068	fix(core): update	2023-04-19 14:38:28 +02:00
Philipp Kunz	0a83d8b476	2.0.14	2023-04-19 14:24:43 +02:00
Philipp Kunz	8e7c730d86	fix(core): update	2023-04-19 14:24:43 +02:00
Philipp Kunz	fe50adb1ff	2.0.13	2023-04-19 14:13:35 +02:00
Philipp Kunz	cd75f7acd8	fix(core): update	2023-04-19 14:13:34 +02:00
Philipp Kunz	bb0dd6426a	2.0.12	2023-04-19 04:07:44 +02:00
Philipp Kunz	d471376681	fix(core): update	2023-04-19 04:07:44 +02:00
Philipp Kunz	b882922f2b	2.0.11	2022-08-21 14:03:18 +02:00
Philipp Kunz	9a0d35c325	fix(core): update	2022-08-21 14:03:18 +02:00
Philipp Kunz	7b49bba0d2	2.0.10	2022-08-06 22:29:12 +02:00
Philipp Kunz	6600a23a00	fix(core): update	2022-08-06 22:29:12 +02:00
Philipp Kunz	e2845c9992	2.0.9	2022-08-01 17:15:53 +02:00
Philipp Kunz	5e6f2c6fbf	fix(core): update	2022-08-01 17:15:52 +02:00
Philipp Kunz	d3d0649b73	2.0.8	2022-08-01 17:10:22 +02:00
Philipp Kunz	fba43df3c4	fix(core): update	2022-08-01 17:10:22 +02:00
Philipp Kunz	c6fa540543	2.0.7	2022-08-01 17:10:11 +02:00
Philipp Kunz	1891b54389	fix(core): update	2022-08-01 17:10:11 +02:00
Philipp Kunz	fee8443af1	2.0.6	2022-07-30 18:43:11 +02:00
Philipp Kunz	c48f956ae3	fix(core): update	2022-07-30 18:43:10 +02:00
Philipp Kunz	4a4b64a2c4	2.0.5	2022-07-30 02:01:20 +02:00
Philipp Kunz	43d4b47782	fix(core): update	2022-07-30 02:01:20 +02:00
Philipp Kunz	6d970cb925	2.0.4	2022-07-30 01:52:04 +02:00
Philipp Kunz	43710c930e	fix(core): update	2022-07-30 01:52:04 +02:00
Philipp Kunz	306dd7c366	2.0.3	2022-07-29 15:45:04 +02:00
Philipp Kunz	3d69d97891	fix(core): update	2022-07-29 15:45:04 +02:00
Philipp Kunz	a6d52702fd	2.0.2	2022-07-29 15:43:56 +02:00
Philipp Kunz	de31ee6093	fix(core): update	2022-07-29 15:43:55 +02:00
Philipp Kunz	cd2d7b2525	2.0.1	2022-07-29 15:41:33 +02:00
Philipp Kunz	2d4a75c9cd	fix(core): update	2022-07-29 15:41:32 +02:00
Philipp Kunz	557fec0386	2.0.0	2022-07-29 01:20:25 +02:00
Philipp Kunz	e803f9e48d	BREAKING CHANGE(core): switch to esm	2022-07-29 01:20:24 +02:00
Philipp Kunz	76c714a931	1.1.57	2022-07-29 01:19:50 +02:00
Philipp Kunz	e8669f0420	fix(core): update	2022-07-29 01:19:50 +02:00
Philipp Kunz	d9e6214a7e	1.1.56	2022-02-15 23:09:15 +01:00
Philipp Kunz	7c4227bfc6	fix(core): update	2022-02-15 23:09:15 +01:00
Philipp Kunz	e55a521395	1.1.55	2022-02-15 19:02:44 +01:00
Philipp Kunz	06fc279caf	fix(core): update	2022-02-15 19:02:43 +01:00
Philipp Kunz	e89e317bbc	1.1.54	2022-02-15 18:57:42 +01:00
Philipp Kunz	d182832e47	fix(core): update	2022-02-15 18:57:42 +01:00
Philipp Kunz	92059a50de	1.1.53	2022-02-15 18:53:02 +01:00
Philipp Kunz	db80f2df7e	fix(core): update	2022-02-15 18:53:02 +01:00
Phil Kunz	145505b891	1.1.52	2021-05-16 23:39:26 +00:00
Phil Kunz	f4f50c6a94	fix(core): update	2021-05-16 23:39:25 +00:00
Phil Kunz	d204059313	1.1.51	2020-09-29 15:22:25 +00:00
Phil Kunz	00210566d5	fix(core): update	2020-09-29 15:22:25 +00:00
Phil Kunz	14245b2521	1.1.50	2020-09-29 15:20:41 +00:00
Phil Kunz	f0fa91e2db	fix(core): update	2020-09-29 15:20:40 +00:00
Phil Kunz	19a1fe1524	1.1.49	2020-08-24 12:04:11 +00:00
Phil Kunz	27770a8ad1	fix(core): update	2020-08-24 12:04:10 +00:00
Phil Kunz	ab48f11e83	1.1.48	2020-08-24 12:01:39 +00:00
Phil Kunz	a0a9e3f824	fix(core): update	2020-08-24 12:01:38 +00:00
Phil Kunz	c829b06169	1.1.47	2020-01-13 08:00:40 +00:00
Phil Kunz	80fa40baf4	fix(core): update	2020-01-13 08:00:39 +00:00
Phil Kunz	3659b80e1e	1.1.46	2020-01-13 07:58:54 +00:00
Phil Kunz	770e7d46ea	fix(core): update	2020-01-13 07:58:54 +00:00
Phil Kunz	2a46f2a306	1.1.45	2020-01-12 19:36:58 +00:00
Phil Kunz	eae4d09664	fix(core): update	2020-01-12 19:36:58 +00:00
Phil Kunz	23a2f597fc	1.1.44	2020-01-12 19:32:20 +00:00
Phil Kunz	c278249c32	fix(core): update	2020-01-12 19:32:20 +00:00
Phil Kunz	a32c372374	1.1.43	2019-11-21 17:32:31 +00:00
Phil Kunz	f98972d9fe	fix(core): update	2019-11-21 17:32:30 +00:00
Phil Kunz	acebe6a381	1.1.42	2019-10-28 16:18:15 +01:00
Phil Kunz	7031504852	1.1.41	2019-10-27 14:41:49 +01:00
Phil Kunz	3010a1da9a	fix(core): update	2019-10-27 14:41:48 +01:00
Phil Kunz	cdead33be4	1.1.40	2019-10-27 14:39:07 +01:00
Phil Kunz	5e23649702	fix(core): update	2019-10-27 14:39:06 +01:00
Phil Kunz	cc6bd5726a	1.1.39	2019-10-27 14:38:13 +01:00
Phil Kunz	f487584e80	fix(core): update	2019-10-27 14:38:12 +01:00
Phil Kunz	443bccd4c9	1.1.38	2019-10-27 14:36:18 +01:00
Phil Kunz	f359856b1d	fix(core): update	2019-10-27 14:36:17 +01:00
Phil Kunz	bda04f124b	1.1.37	2019-10-27 14:32:27 +01:00
Phil Kunz	466187fd52	fix(core): update	2019-10-27 14:32:27 +01:00
Phil Kunz	d22504317e	1.1.36	2019-09-29 16:42:56 +02:00
Phil Kunz	6e31d84798	fix(core): update	2019-09-29 16:42:56 +02:00