v5.0.1

fix(test): Enable --logfile in test script and bump @git.zone/tstest to ^2.8.2
v5.0.0
2025-11-17 14:37:09 +00:00 · 2025-11-17 14:37:08 +00:00 · 2025-11-17 14:18:58 +00:00 · 2025-11-17 14:18:58 +00:00 · 2025-11-16 23:41:24 +00:00 · 2025-11-16 23:41:24 +00:00
51 changed files with 12612 additions and 3506 deletions
--- a/.gitea/workflows/default_nottags.yaml
+++ b/.gitea/workflows/default_nottags.yaml
@@ -6,8 +6,8 @@ on:
      - '**'
 env:
-  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  IMAGE: code.foss.global/host.today/ht-docker-node:npmci
-  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
@@ -23,24 +23,16 @@ jobs:
    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
+          npm config set registry https://registry.npmjs.org
-          npmci command pnpm audit --audit-level=high --prod
+          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
+          npm config set registry https://registry.npmjs.org
-          npmci command pnpm audit --audit-level=high --dev
+          pnpm audit --audit-level=high --dev
        continue-on-error: true
  test:
@@ -55,12 +47,10 @@ jobs:
      - name: Test stable
        run: |
-          npmci node install stable
+          pnpm install
-          npmci npm install
+          pnpm test
          npmci npm test
      - name: Test build
        run: |
-          npmci node install stable
+          pnpm install
-          npmci npm install
+          pnpm build
          npmci npm build
--- a/.gitea/workflows/default_tags.yaml
+++ b/.gitea/workflows/default_tags.yaml
@@ -6,8 +6,8 @@ on:
      - '*'
 env:
-  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  IMAGE: code.foss.global/host.today/ht-docker-node:npmci
-  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
@@ -23,22 +23,16 @@ jobs:
    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
+          npm config set registry https://registry.npmjs.org
-          npmci command pnpm audit --audit-level=high --prod
+          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
+          npm config set registry https://registry.npmjs.org
-          npmci command pnpm audit --audit-level=high --dev
+          pnpm audit --audit-level=high --dev
        continue-on-error: true
  test:
@@ -51,23 +45,15 @@ jobs:
    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
+          pnpm install
-          npmci npm install
+          pnpm test
          npmci npm test
      - name: Test build
        run: |
-          npmci node install stable
+          pnpm install
-          npmci npm install
+          pnpm build
          npmci npm build
  release:
    needs: test
@@ -79,16 +65,27 @@ jobs:
    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
+          pnpm install
-          npmci npm publish
+          # Extract server host from GITHUB_SERVER_URL (remove https://)
          GITEA_HOST="${GITHUB_SERVER_URL#https://}"
          GITEA_REGISTRY="$GITHUB_SERVER_URL/api/packages/$GITHUB_REPOSITORY_OWNER/npm/"
          # Create .npmrc for Gitea authentication
          echo "@${GITHUB_REPOSITORY_OWNER}:registry=${GITEA_REGISTRY}" > .npmrc
          echo "//${GITEA_HOST}/api/packages/${GITHUB_REPOSITORY_OWNER}/npm/:_authToken=${GITEA_TOKEN}" >> .npmrc
          # Publish to Gitea
          pnpm publish --no-git-checks
          # Conditionally publish to npmjs.org if token exists
          if [ -n "$NPMCI_TOKEN_NPM" ]; then
            # Update .npmrc for npmjs.org
            echo "registry=https://registry.npmjs.org/" > .npmrc
            echo "//registry.npmjs.org/:_authToken=${NPMCI_TOKEN_NPM}" >> .npmrc
            pnpm publish --no-git-checks
          fi
  metadata:
    needs: test
@@ -101,24 +98,14 @@ jobs:
    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
+          npm install -g typescript
-          npmci npm install
+          pnpm install
      - name: Trigger
        run: npmci trigger
      - name: Build docs and upload artifacts
        run: |
-          npmci node install stable
+          pnpm install
          npmci npm install
          pnpm install -g @git.zone/tsdoc
-          npmci command tsdoc
+          tsdoc
        continue-on-error: true
--- a/.gitignore
+++ b/.gitignore
@@ -3,7 +3,6 @@
 # artifacts
 coverage/
 public/
 pages/
 # installs
 node_modules/
@@ -17,4 +16,8 @@ node_modules/
 dist/
 dist_*/
-# custom
+# AI
 .claude/
 .serena/
 #------# custom
--- a/changelog.md
+++ b/changelog.md
@@ -1,25 +1,160 @@
 # Changelog
 ## 2025-11-17 - 5.0.1 - fix(test)
 Enable --logfile in test script and bump @git.zone/tstest to ^2.8.2
 - Update npm script: add --logfile flag to the test command to produce test logs
 - Bump devDependency @git.zone/tstest from ^2.8.1 to ^2.8.2
 ## 2025-11-17 - 5.0.0 - BREAKING CHANGE(client/streaming)
 Unify streaming APIs: remove raw()/streamNode() and standardize on web ReadableStream across runtimes
 - Removed SmartRequest.raw() and RawStreamFunction type. The raw streaming function API is gone — use .stream() with a web ReadableStream for request body streaming.
 - Removed response.streamNode() from all runtimes. Responses now expose only response.stream() (ReadableStream<Uint8Array>). Node.js consumers must convert using Readable.fromWeb() if a Node.js stream is required.
 - Node implementation now uses Readable.toWeb() to convert native Node streams into web ReadableStream for a single cross-platform streaming API.
 - Client request.stream() still accepts Node.js streams but they are converted internally to web streams; temporary internal properties for raw streaming were removed.
 - Updated tests and documentation (readme) with migration guidance and examples for converting between web and Node.js streams.
 - Bumped devDependencies (@git.zone/tsbuild, tsrun, tstest) and upgraded form-data to a newer patch release.
 ## 2025-11-16 - 4.4.2 - fix(core_base/request)
 Strip 'unix:' prefix when parsing unix socket URLs so socketPath is a clean filesystem path
 - CoreRequest.parseUnixSocketUrl now removes a leading 'unix:' prefix and returns socketPath as a filesystem path (e.g., /var/run/docker.sock)
 - Updated tests for Bun, Deno and Node to expect socketPath without the 'unix:' prefix
 - Adjusted comments/documentation in core_base/request.ts to clarify returned socketPath format
 ## 2025-11-16 - 4.4.1 - fix(core_node)
 Fix unix socket URL parsing and handling in CoreRequest
 - CoreRequest.parseUnixSocketUrl now strips http:// and https:// prefixes so it correctly parses both full URLs (e.g. http://unix:/path/to/socket:/route) and already-stripped unix: paths.
 - Node.js CoreRequest now passes the original request URL to parseUnixSocketUrl instead of options.path, preventing incorrect socketPath/path extraction.
 - Fixes connection failures when using unix socket URLs (for example when targeting Docker via http://unix:/var/run/docker.sock:/v1.24/...).
 ## 2025-11-16 - 4.4.0 - feat(core)
 Add Bun and Deno runtime support, unify core loader, unix-socket support and cross-runtime streaming/tests
 - package.json: expose ./core_bun and ./core_deno in exports and add runtime-related keywords
 - Core dynamic loader (ts/core/index.ts): detect Bun and Deno at runtime and load corresponding implementations
 - New runtime modules: added ts/core_bun/* and ts/core_deno/* (response, types, index) to provide Bun and Deno CoreResponse/CoreRequest wrappers
 - Client streaming: SmartRequest no longer immediately deletes temporary __nodeStream and __rawStreamFunc props — CoreRequest implementations handle them; temporary properties are cleaned up after CoreRequest is created
 - Node.js request: core_node/request.ts converts web ReadableStream to Node.js Readable via stream.Readable.fromWeb and pipes it; also supports passing requestDataFunc for raw streaming
 - core_node/plugins: export stream helper and rework third-party exports (agentkeepalive, form-data) for Node implementation
 - CoreResponse for Bun/Deno: new implementations wrap native fetch Response and expose raw(), stream(), and streamNode() behavior (streamNode() throws in Bun/Deno with guidance to use web streams)
 - Tests: added unified cross-runtime streaming tests and separate unix-socket tests for Node/Bun/Deno with Docker-socket availability checks; removed old node-only streaming test
 - Docs/readme: updated to describe Node, Bun, Deno, and browser support, unix socket behavior per runtime, and new test conventions
 ## 2025-11-16 - 4.3.8 - fix(core)
 Ensure correct ArrayBuffer return, fix fetch body typing, reorganize node-only tests, and bump tsbuild devDependency
 - core_node: Fix arrayBuffer() to ensure an ArrayBuffer is returned (avoid returning SharedArrayBuffer) to improve interoperability when consuming binary responses.
 - core_fetch: Cast request body to BodyInit when assigning to fetch options and preserve duplex = 'half' for ReadableStream bodies to satisfy typings and streaming behavior.
 - tests: Reorganize tests into Node-only variants (rename/remove multi-platform test files to test.*.node.ts) to separate platform-specific test coverage.
 - chore: Bump devDependency @git.zone/tsbuild from ^2.6.8 to ^2.7.1.
 ## 2025-11-01 - 4.3.7 - fix(ci)
 Update dependencies, add deno.lock, and reorganize tests for browser and Node environments
 - Add deno.lock with resolved npm package versions for deterministic Deno/npm usage
 - Bump @push.rocks/smartenv dependency to ^6.0.0
 - Bump devDependencies: @git.zone/tsbuild -> ^2.6.8, @git.zone/tsrun -> ^1.6.2, @git.zone/tstest -> ^2.7.0
 - Reorganize tests: move browser tests to chromium variants and add environment-specific test files for node, bun, deno (streaming, timeout, streamNode, etc.)
 - Update package.json dependency ranges to match upgraded lockfile and test tooling
 ## 2025-10-26 - 4.3.6 - fix(ci)
 Use .npmrc for registry authentication in Gitea workflow and add conditional npmjs publish
 - Replace npm config set commands with creating a .npmrc file for Gitea registry authentication in .gitea/workflows/default_tags.yaml
 - Add conditional update of .npmrc and publishing to npmjs.org when NPMCI_TOKEN_NPM is provided
 - Keep pnpm publish --no-git-checks; improve CI credential handling to be file-based
 ## 2025-10-26 - 4.3.5 - fix(workflows)
 Remove npmci wrappers from CI workflows and use pnpm/npm CLI directly
 - Removed global npmci installation and npmci npm prepare steps from Gitea workflow files
 - Use pnpm install/test/build instead of npmci-wrapped commands in test jobs
 - Replace npmci command npm config set ... with direct npm config set calls for registry/auth configuration
 - Use pnpm publish --no-git-checks for Gitea publishing and use pnpm publish for conditional npmjs publish when token present
 - Simplified dependency auditing to run pnpm audit and set registry via npm config set
 - Install tsdoc globally and run tsdoc during docs build step (replacing npmci command usage)
 ## 2025-10-25 - 4.3.4 - fix(ci)
 Fix Gitea workflow publish invocation to run npm publish via npmci command
 - Update .gitea/workflows/default_tags.yaml to use 'npmci command npm publish' for the publish step
 - Ensures the workflow runs npm publish through the npmci command wrapper to avoid incorrect task invocation
 ## 2025-10-25 - 4.3.3 - fix(ci)
 Improve Gitea release workflow: install deps, configure Gitea npm registry, and optionally publish to npmjs.org
 - Run npm install in the release job to ensure dependencies are available before publishing.
 - Configure Gitea/npm registry using GITHUB_SERVER_URL and set auth token for the @<owner> scope.
 - Publish to the Gitea npm registry during release.
 - If NPMCI_TOKEN_NPM is provided, also publish to the public npmjs.org registry (conditional publish).
 - Extract host from GITHUB_SERVER_URL to correctly set the registry auth URL.
 ## 2025-10-17 - 4.3.2 - fix(core)
 Remove stray console.log from core module
 - Removed a stray debug console.log(modulePath) from ts/core/index.ts that printed the module path during Node environment initialization
 ## 2025-08-19 - 4.3.1 - fix(core)
 Improve streaming support and timeout handling; add browser streaming & timeout tests and README clarifications
 - core_fetch: accept Uint8Array and Buffer-like bodies; set fetch duplex for ReadableStream bodies so streaming requests work in environments that require duplex
 - core_fetch: implement AbortController-based timeouts and ensure timeouts are cleared on success/error to avoid hanging timers
 - core_node: add explicit request timeout handling (request.setTimeout) and hard-data-cutting timeout tracking with proper timeoutId clear on success/error
 - client: document that raw(streamFunc) is Node-only (not supported in browsers)
 - tests: add browser streaming tests (test/test.streaming.browser.ts) that exercise buffer() and web ReadableStream via stream()
 - tests: add timeout tests (test/test.timeout.ts) to validate clearing timers, enforcing timeouts, and preventing timer leaks across multiple requests
 - docs: update README streaming section to clarify cross-platform behavior of buffer(), stream(), and raw() methods
 ## 2025-08-18 - 4.3.0 - feat(client/smartrequest)
 Add streaming and raw buffer support to SmartRequest (buffer, stream, raw); update docs and tests
 - Add SmartRequest.buffer(data, contentType?) to send Buffer or Uint8Array bodies with Content-Type header.
 - Add SmartRequest.stream(stream, contentType?) to accept Node.js Readable streams or web ReadableStream and set Content-Type when provided.
 - Add SmartRequest.raw(streamFunc) to allow custom raw streaming functions (Node.js only) and a RawStreamFunction type.
 - Wire Node.js stream handling into CoreRequest by passing a requestDataFunc when creating CoreRequest instances.
 - Add comprehensive streaming examples and documentation to README describing buffer/stream/raw usage and streaming methods.
 - Add tests for streaming behavior (test/test.streaming.ts) covering buffer, stream, raw, and Uint8Array usage.
 - Update client exports and plugins to support streaming features and FormData usage where needed.
 ## 2025-08-18 - 4.2.2 - fix(client)
 Fix CI configuration, prevent socket hangs with auto-drain, and apply various client/core TypeScript fixes and test updates
 - CI/workflow updates: switch container IMAGE to code.foss.global/host.today/ht-docker-node:npmci, adjust NPMCI_COMPUTED_REPOURL, and install @ship.zone/npmci instead of @shipzone/npmci
 - Prevent socket hanging by adding automatic draining of unconsumed Node.js response bodies (configurable via options.autoDrain / SmartRequest.autoDrain); added logging when auto-drain runs and updated tests to consume bodies
 - Client improvements: fixes and cleanups in SmartRequest (accept header mapping, formData header handling, options(), pagination helpers, handle429Backoff backoff/Retry-After parsing and callbacks, retry logic and small API ergonomics)
 - Core fixes: fetch and node implementations corrected (buildUrl, fetch options, request/response constructors, stream conversions to web ReadableStream, proper error messages) and consistent exports
 - TypeScript and formatting fixes across many files (consistent trailing commas, object layout, newline fixes, typed function signatures, cleaned up exports and module imports)
 - Package metadata and tooling updates: package.json bug/homepage URLs adjusted to code.foss.global, bumped @git.zone/tstest devDependency, added pnpm overrides field; small .gitignore additions
 ## 2025-07-29 - 4.2.1 - fix(client)
 Fix socket hanging issues and add auto-drain feature
 **Fixes:**
 - Fixed socket hanging issues caused by unconsumed response bodies
 - Resolved test timeout problems where sockets remained open after tests completed
 **Features:**
 - Added automatic response body draining to prevent socket pool exhaustion
 - Made auto-drain configurable via `autoDrain()` method (enabled by default)
 - Added logging when auto-drain activates for debugging purposes
 **Improvements:**
 - Updated all tests to properly consume response bodies
 - Enhanced documentation about the importance of consuming response bodies
 ## 2025-07-29 - 4.2.0 - feat(client)
 Add handle429Backoff method for intelligent rate limit handling
 **Features:**
 - Added `handle429Backoff()` method to SmartRequest class for automatic HTTP 429 handling
 - Respects `Retry-After` headers with support for both seconds and HTTP date formats
 - Configurable exponential backoff when no Retry-After header is present
@@ -28,30 +163,37 @@ Add handle429Backoff method for intelligent rate limit handling
 - Maximum wait time capping to prevent excessive delays
 **Improvements:**
 - Updated test endpoints to use more reliable services (jsonplaceholder, echo.zuplo.io)
 - Added timeout parameter to test script for better CI/CD compatibility
 **Documentation:**
 - Added comprehensive rate limiting section to README with examples
 - Documented all configuration options for handle429Backoff
 ## 2025-07-29 - 4.1.0 - feat(client)
 Add missing options() method to SmartRequest client
 **Features:**
 - Added `options()` method to SmartRequest class for setting arbitrary request options
 - Enables setting keepAlive and other platform-specific options via fluent API
 - Added test coverage for keepAlive functionality
 **Documentation:**
 - Updated README with examples of using the `options()` method
 - Added specific examples for enabling keepAlive connections
 - Corrected all documentation to use `options()` instead of `option()`
 ## 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:
@@ -65,6 +207,7 @@ Complete architectural overhaul with cross-platform support
 - 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
@@ -72,15 +215,18 @@ Complete architectural overhaul with cross-platform support
 - 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
@@ -94,17 +240,20 @@ Major architectural refactoring with fetch-like API
  - 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
@@ -114,6 +263,7 @@ Enhance documentation and tests with modern API usage examples and migration gui
 - 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.
@@ -121,31 +271,37 @@ Enhance type safety for response in binary requests
 - 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
@@ -155,11 +311,13 @@ Improvements and fixes across various components
 - 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
@@ -167,9 +325,9 @@ Ensured binary handling compliance
 - 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/deno.lock
+++ b/deno.lock
--- a/npmextra.json
+++ b/npmextra.json
@@ -34,4 +34,4 @@
  "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.json
+++ b/package.json
@@ -1,16 +1,18 @@
 {
  "name": "@push.rocks/smartrequest",
-  "version": "4.2.1",
+  "version": "5.0.1",
  "private": false,
  "description": "A module for modern HTTP/HTTPS requests with support for form data, file uploads, JSON, binary data, streams, and more.",
  "exports": {
    ".": "./dist_ts/index.js",
    "./core_node": "./dist_ts/core_node/index.js",
-    "./core_fetch": "./dist_ts/core_fetch/index.js"
+    "./core_fetch": "./dist_ts/core_fetch/index.js",
    "./core_bun": "./dist_ts/core_bun/index.js",
    "./core_deno": "./dist_ts/core_deno/index.js"
  },
  "type": "module",
  "scripts": {
-    "test": "(tstest test/ --verbose --timeout 120)",
+    "test": "(tstest test/ --verbose --timeout 120 --logfile)",
    "build": "(tsbuild --web)",
    "buildDocs": "tsdoc"
  },
@@ -30,26 +32,30 @@
    "keepAlive",
    "TypeScript",
    "modern web requests",
-    "drop-in replacement"
+    "drop-in replacement",
    "Bun",
    "Deno",
    "Node.js",
    "unix sockets"
  ],
  "author": "Task Venture Capital GmbH",
  "license": "MIT",
  "bugs": {
-    "url": "https://gitlab.com/push.rocks/smartrequest/issues"
+    "url": "https://code.foss.global/push.rocks/smartrequest/issues"
  },
-  "homepage": "https://code.foss.global/push.rocks/smartrequest",
+  "homepage": "https://code.foss.global/push.rocks/smartrequest#readme",
  "dependencies": {
-    "@push.rocks/smartenv": "^5.0.13",
+    "@push.rocks/smartenv": "^6.0.0",
    "@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"
+    "form-data": "^4.0.5"
  },
  "devDependencies": {
-    "@git.zone/tsbuild": "^2.6.4",
+    "@git.zone/tsbuild": "^3.1.0",
-    "@git.zone/tsrun": "^1.3.3",
+    "@git.zone/tsrun": "^2.0.0",
-    "@git.zone/tstest": "^2.3.2",
+    "@git.zone/tstest": "^2.8.2",
    "@types/node": "^22.9.0"
  },
  "files": [
@@ -67,5 +73,8 @@
  "browserslist": [
    "last 1 chrome versions"
  ],
-  "packageManager": "pnpm@10.7.0+sha512.6b865ad4b62a1d9842b61d674a393903b871d9244954f652b8842c2b553c72176b278f64c463e52d40fff8aba385c235c8c9ecf5cc7de4fd78b8bb6d49633ab6"
+  "packageManager": "pnpm@10.7.0+sha512.6b865ad4b62a1d9842b61d674a393903b871d9244954f652b8842c2b553c72176b278f64c463e52d40fff8aba385c235c8c9ecf5cc7de4fd78b8bb6d49633ab6",
  "pnpm": {
    "overrides": {}
  }
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/readme.hints.md
+++ b/readme.hints.md
@@ -1,31 +1,36 @@
 # SmartRequest Architecture Hints
 ## Core Features
 - supports http
- supports https  
+- supports https
- supports unix socks
+- supports unix sockets on Node.js, Bun, and Deno
 - 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 Node.js, Bun, Deno, and browser environments with automatic runtime detection
- supports both Node.js and browser environments
+- runtime-specific implementations using native APIs (Node http/https, Bun fetch, Deno fetch with HttpClient, browser fetch)
 - used in modules like @push.rocks/smartproxy and @api.global/typedrequest
-## Architecture Overview (as of v3.0.0 major refactoring)
+## Architecture Overview (as of v4.x with Bun and Deno support)
- The project now has a multi-layer architecture with platform abstraction
+
 - The project has a multi-layer architecture with runtime abstraction
 - Base layer (ts/core_base/) contains abstract classes and unified types
- Node.js implementation (ts/core_node/) uses native http/https modules
+- Node.js implementation (ts/core_node/) uses native http/https modules with unix socket support
- Fetch implementation (ts/core_fetch/) uses Fetch API for browser compatibility
+- Bun implementation (ts/core_bun/) uses Bun's native fetch with unix socket support via `unix` option
- Core module (ts/core/) dynamically selects the appropriate implementation based on environment
+- Deno implementation (ts/core_deno/) uses Deno's fetch with unix socket support via HttpClient proxy
- Client API (ts/client/) provides a fluent, chainable interface  
+- Browser implementation (ts/core_fetch/) uses standard Fetch API for browser compatibility
- Legacy API has been completely removed in v3.0.0
+- Core module (ts/core/) uses @push.rocks/smartenv to detect runtime and dynamically load appropriate implementation
 - Client API (ts/client/) provides a fluent, chainable interface that works across all runtimes
 - Runtime detection order: Deno → Bun → Node.js → Browser (following smartenv detection best practices)
 ## 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
@@ -35,6 +40,7 @@
  - 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
@@ -44,6 +50,7 @@
  - 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
@@ -51,29 +58,70 @@
  - `stream()` returns native web ReadableStream from response.body
  - `streamNode()` throws error explaining it's not available in browser
 ### Core Bun Module (ts/core_bun/)
 - `request.ts`: Bun implementation using native fetch with unix socket support
  - Uses Bun's `unix` fetch option for unix socket connections
  - Supports both `unix` and `socketPath` options (converts socketPath to unix)
  - Handles URL parsing for `http://unix:/path/to/socket:/http/path` format
  - Throws errors for Node.js specific options (agent)
 - `response.ts`: Bun-based CoreResponse implementation
  - `stream()` returns native web ReadableStream from response.body
  - `streamNode()` throws error (Bun uses web streams; users should use stream() instead)
 - `types.ts`: Extends base types with IBunRequestOptions including `unix` option
 ### Core Deno Module (ts/core_deno/)
 - `request.ts`: Deno implementation using fetch with HttpClient proxy for unix sockets
  - Creates and caches Deno.HttpClient instances per socket path
  - Supports both explicit `client` option and automatic client creation from `socketPath`
  - HttpClient cache prevents creating multiple clients for same socket
  - Provides `clearClientCache()` static method for cleanup
  - Throws errors for Node.js specific options (agent)
 - `response.ts`: Deno-based CoreResponse implementation
  - `stream()` returns native web ReadableStream from response.body
  - `streamNode()` throws error (Deno uses web streams, not Node.js streams)
 - `types.ts`: Extends base types with IDenoRequestOptions including `client` option
 ### 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>
+
 - `stream()` method always returns web-style ReadableStream<Uint8Array> across all platforms
 - In Node.js, converts native streams to web streams
- `streamNode()` available only in Node.js environment for native streams
+- `streamNode()` availability by runtime:
- Consistent API across platforms while preserving platform-specific capabilities
+  - **Node.js**: Returns native Node.js ReadableStream (only runtime that supports this)
  - **Bun**: Throws error (use web streams via stream() instead)
  - **Deno**: Throws error (Deno uses web streams only)
  - **Browser**: Throws error (browsers use web streams only)
 - Consistent API across platforms with web streams as the common denominator
 - Only Node.js provides native Node.js streams via streamNode()
 ### 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)
+- Test file naming conventions:
  - `test.node.ts` - Node.js only tests
  - `test.bun.ts` - Bun only tests
  - `test.deno.ts` - Deno only tests
  - `test.node+bun+deno.ts` - Server-side runtime tests (all three)
  - `test.browser.ts` or `test.chrome.ts` - Browser tests
 - Unix socket tests check for Docker socket availability and skip if not present
 - Browser tests run in headless Chromium via puppeteer
--- a/readme.md
+++ b/readme.md
@@ -1,12 +1,14 @@
 # @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.
+
 A modern, cross-platform HTTP/HTTPS request library for Node.js, Bun, Deno, 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  
+# Using pnpm
 pnpm add @push.rocks/smartrequest
 # Using yarn
@@ -16,26 +18,30 @@ 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
+- 🌐 **Cross-Platform** - Works in Node.js, Bun, Deno, and browsers with a unified API
- 🔌 **Unix Socket Support** - Connect to local services like Docker (Node.js only)
+- 🔌 **Unix Socket Support** - Connect to local services like Docker (Node.js, Bun, and Deno)
 - 📦 **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
+- 📡 **Streaming Support** - Stream buffers, files, and custom data without loading into memory
- 🔧 **Highly Configurable** - Timeouts, retries, headers, and more
+- 🔧 **Highly Configurable** - Timeouts, retries, headers, rate limiting, and more
 ## Architecture
-SmartRequest v3.0 features a multi-layer architecture that provides consistent behavior across platforms:
+SmartRequest 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 Node** - Node.js implementation using native http/https modules with unix socket support
 - **Core Bun** - Bun implementation using native fetch with unix socket support via `unix` option
 - **Core Deno** - Deno implementation using fetch with unix socket support via HttpClient proxy
 - **Core Fetch** - Browser implementation using the Fetch API
- **Core** - Dynamic implementation selection based on environment
+- **Core** - Dynamic runtime detection and implementation selection using @push.rocks/smartenv
 - **Client** - High-level fluent API for everyday use
 The library automatically detects the runtime environment (Deno, Bun, Node.js, or browser) and loads the appropriate implementation, ensuring optimal performance and native feature support for each platform.
 ## Usage
 `@push.rocks/smartrequest` provides a clean, type-safe API inspired by the native fetch API but with additional features needed for modern applications.
@@ -79,10 +85,10 @@ async function directCoreRequest() {
  const request = new CoreRequest('https://api.example.com/data', {
    method: 'GET',
    headers: {
-      'Accept': 'application/json'
+      Accept: 'application/json',
-    }
+    },
  });
-  
+
  const response = await request.fire();
  const data = await response.json();
  return data;
@@ -100,7 +106,7 @@ async function searchRepositories(query: string, perPage: number = 10) {
    .header('Accept', 'application/vnd.github.v3+json')
    .query({
      q: query,
-      per_page: perPage.toString()
+      per_page: perPage.toString(),
    })
    .get();
@@ -136,8 +142,8 @@ import { SmartRequest } from '@push.rocks/smartrequest';
 const response = await SmartRequest.create()
  .url('https://api.example.com/data')
  .options({
-    keepAlive: true,           // Enable connection reuse (Node.js)
+    keepAlive: true, // Enable connection reuse (Node.js)
-    timeout: 10000,            // 10 second timeout
+    timeout: 10000, // 10 second timeout
    hardDataCuttingTimeout: 15000, // 15 second hard timeout
    // Platform-specific options are also supported
  })
@@ -153,19 +159,15 @@ import { SmartRequest } from '@push.rocks/smartrequest';
 // JSON response (default)
 async function fetchJson(url: string) {
-  const response = await SmartRequest.create()
+  const response = await SmartRequest.create().url(url).get();
-    .url(url)
+
    .get();
  return await response.json(); // Parses JSON automatically
 }
 // Text response
 async function fetchText(url: string) {
-  const response = await SmartRequest.create()
+  const response = await SmartRequest.create().url(url).get();
-    .url(url)
+
    .get();
  return await response.text(); // Returns response as string
 }
@@ -180,18 +182,16 @@ async function downloadImage(url: string) {
  return Buffer.from(buffer); // Convert ArrayBuffer to Buffer if needed
 }
-// Streaming response (Web Streams API)
+// Streaming response (Web Streams API - cross-platform)
 async function streamLargeFile(url: string) {
-  const response = await SmartRequest.create()
+  const response = await SmartRequest.create().url(url).get();
    .url(url)
    .get();
-  // Get a web-style ReadableStream (works in both Node.js and browsers)
+  // Get a web-style ReadableStream (works everywhere)
  const stream = response.stream();
-  
+
  if (stream) {
    const reader = stream.getReader();
-    
+
    try {
      while (true) {
        const { done, value } = await reader.read();
@@ -204,15 +204,15 @@ async function streamLargeFile(url: string) {
  }
 }
-// Node.js specific stream (only in Node.js environment)
+// Convert to Node.js stream if needed (Node.js only)
 async function streamWithNodeApi(url: string) {
-  const response = await SmartRequest.create()
+  const response = await SmartRequest.create().url(url).get();
-    .url(url)
+
-    .get();
+  // Convert web stream to Node.js stream
  import { Readable } from 'stream';
  const webStream = response.stream();
  const nodeStream = Readable.fromWeb(webStream);
  // 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`);
  });
@@ -232,14 +232,14 @@ The response object provides these methods:
 - `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 object
 - `raw(): Response | http.IncomingMessage` - Get the underlying platform response
 Each body method can only be called once per response, similar to the fetch API.
 ### Important: Always Consume Response Bodies
 **You should always consume response bodies, even if you don't need the data.** Unconsumed response bodies can cause:
 - Memory leaks as data accumulates in buffers
 - Socket hanging with keep-alive connections
 - Connection pool exhaustion
@@ -249,7 +249,7 @@ Each body method can only be called once per response, similar to the fetch API.
 const response = await SmartRequest.create()
  .url('https://api.example.com/status')
  .get();
-  
+
 if (response.ok) {
  console.log('Success!');
 }
@@ -259,7 +259,7 @@ if (response.ok) {
 const response = await SmartRequest.create()
  .url('https://api.example.com/status')
  .get();
-  
+
 if (response.ok) {
  console.log('Success!');
 }
@@ -269,13 +269,14 @@ await response.text(); // Consume the body even if not needed
 In Node.js, SmartRequest automatically drains unconsumed responses to prevent socket hanging, but it's still best practice to explicitly consume response bodies. When auto-drain occurs, you'll see a console log: `Auto-draining unconsumed response body for [URL] (status: [STATUS])`.
 You can disable auto-drain if needed:
 ```typescript
 // Disable auto-drain (not recommended unless you have specific requirements)
 const response = await SmartRequest.create()
  .url('https://api.example.com/data')
-  .autoDrain(false)  // Disable auto-drain
+  .autoDrain(false) // Disable auto-drain
  .get();
-  
+
 // Now you MUST consume the body or the socket will hang
 await response.text();
 ```
@@ -288,36 +289,184 @@ await response.text();
 import { SmartRequest } from '@push.rocks/smartrequest';
 import * as fs from 'fs';
-async function uploadMultipleFiles(files: Array<{name: string, path: string}>) {
+async function uploadMultipleFiles(
-  const formFields = files.map(file => ({
+  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'
+    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)
+### Streaming Request Bodies
 SmartRequest provides multiple ways to stream data in requests, making it easy to upload large files or send real-time data without loading everything into memory:
 ```typescript
 import { SmartRequest } from '@push.rocks/smartrequest';
 import * as fs from 'fs';
 import { Readable } from 'stream';
 // Stream a Buffer directly (works everywhere)
 async function uploadBuffer() {
  const buffer = Buffer.from('Hello, World!');
  const response = await SmartRequest.create()
    .url('https://api.example.com/upload')
    .buffer(buffer, 'text/plain')
    .post();
  return await response.json();
 }
 // Stream using web ReadableStream (cross-platform!)
 async function uploadWebStream() {
  const stream = new ReadableStream({
    start(controller) {
      const data = new TextEncoder().encode('Stream data');
      controller.enqueue(data);
      controller.close();
    },
  });
  const response = await SmartRequest.create()
    .url('https://api.example.com/upload')
    .stream(stream, 'text/plain')
    .post();
  return await response.json();
 }
 // Stream a file using Node.js streams (Node.js only)
 async function uploadLargeFile(filePath: string) {
  const fileStream = fs.createReadStream(filePath);
  const response = await SmartRequest.create()
    .url('https://api.example.com/upload')
    .stream(fileStream, 'application/octet-stream')
    .post();
  return await response.json();
 }
 // Stream data from any readable source (Node.js only)
 async function streamData(dataSource: Readable) {
  const response = await SmartRequest.create()
    .url('https://api.example.com/stream')
    .stream(dataSource)
    .post();
  return await response.json();
 }
 // Send Uint8Array (works everywhere)
 async function uploadBinaryData() {
  const data = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
  const response = await SmartRequest.create()
    .url('https://api.example.com/binary')
    .buffer(data, 'application/octet-stream')
    .post();
  return await response.json();
 }
 ```
 #### Streaming Methods
 - **`.buffer(data, contentType?)`** - Stream a Buffer or Uint8Array directly
  - `data`: Buffer (Node.js) or Uint8Array (cross-platform) to send
  - `contentType`: Optional content type (defaults to 'application/octet-stream')
  - ✅ Works everywhere (Node.js, Bun, Deno, browsers)
 - **`.stream(stream, contentType?)`** - Stream from ReadableStream or Node.js stream
  - `stream`: Web ReadableStream (cross-platform) or Node.js stream (Node.js only)
  - `contentType`: Optional content type
  - ✅ Web ReadableStream works everywhere (Node.js, Bun, Deno, browsers)
  - ⚠️ Node.js streams only work in Node.js (automatically converted to web streams in Bun/Deno)
 These methods are particularly useful for:
 - Uploading large files without loading them into memory
 - Streaming real-time data to servers
 - Proxying data between services
 - Implementing chunked transfer encoding
 ### Unix Socket Support (Node.js, Bun, and Deno)
 SmartRequest supports unix sockets across all server-side runtimes with a unified API:
 ```typescript
 import { SmartRequest } from '@push.rocks/smartrequest';
-// Connect to a service via Unix socket
+// Connect to a service via Unix socket (works on Node.js, Bun, and Deno)
 async function queryViaUnixSocket() {
  const response = await SmartRequest.create()
    .url('http://unix:/var/run/docker.sock:/v1.24/containers/json')
    .get();
-  
+
  return await response.json();
 }
 // Alternative: Use socketPath option (works on all server runtimes)
 async function queryWithSocketPath() {
  const response = await SmartRequest.create()
    .url('http://localhost/version')
    .options({ socketPath: '/var/run/docker.sock' })
    .get();
  return await response.json();
 }
 ```
 #### Runtime-Specific Unix Socket APIs
 Each runtime implements unix sockets using its native capabilities:
 **Bun:**
 ```typescript
 import { CoreRequest } from '@push.rocks/smartrequest/core_bun';
 // Bun uses the native `unix` fetch option
 const response = await CoreRequest.create('http://localhost/version', {
  unix: '/var/run/docker.sock'
 });
 ```
 **Deno:**
 ```typescript
 import { CoreRequest } from '@push.rocks/smartrequest/core_deno';
 // Deno uses HttpClient with unix socket proxy
 const client = Deno.createHttpClient({
  proxy: { url: 'unix:///var/run/docker.sock' }
 });
 const response = await CoreRequest.create('http://localhost/version', {
  client
 });
 // Clean up when done
 client.close();
 ```
 **Node.js:**
 ```typescript
 import { CoreRequest } from '@push.rocks/smartrequest/core_node';
 // Node.js uses native socketPath option
 const response = await CoreRequest.create('http://localhost/version', {
  socketPath: '/var/run/docker.sock'
 });
 ```
 ### Pagination Support
@@ -336,7 +485,7 @@ async function fetchAllUsers() {
      limitParam: 'limit',
      startPage: 1,
      pageSize: 20,
-      totalPath: 'meta.total'
+      totalPath: 'meta.total',
    });
  // Get first page with pagination info
@@ -362,7 +511,7 @@ async function fetchAllPosts() {
    .withCursorPagination({
      cursorParam: 'cursor',
      cursorPath: 'meta.nextCursor',
-      hasMorePath: 'meta.hasMore'
+      hasMorePath: 'meta.hasMore',
    })
    .getAllPages();
@@ -415,7 +564,7 @@ import { SmartRequest } from '@push.rocks/smartrequest';
 async function fetchWithRateLimitHandling() {
  const response = await SmartRequest.create()
    .url('https://api.example.com/data')
-    .handle429Backoff()  // Automatically retry on 429
+    .handle429Backoff() // Automatically retry on 429
    .get();
  return await response.json();
@@ -426,14 +575,14 @@ async function fetchWithCustomRateLimiting() {
  const response = await SmartRequest.create()
    .url('https://api.example.com/data')
    .handle429Backoff({
-      maxRetries: 5,              // Try up to 5 times (default: 3)
+      maxRetries: 5, // Try up to 5 times (default: 3)
-      respectRetryAfter: true,    // Honor Retry-After header (default: true)
+      respectRetryAfter: true, // Honor Retry-After header (default: true)
-      maxWaitTime: 30000,         // Max 30 seconds wait (default: 60000)
+      maxWaitTime: 30000, // Max 30 seconds wait (default: 60000)
-      fallbackDelay: 2000,        // 2s initial delay if no Retry-After (default: 1000)
+      fallbackDelay: 2000, // 2s initial delay if no Retry-After (default: 1000)
-      backoffFactor: 2,           // Exponential backoff multiplier (default: 2)
+      backoffFactor: 2, // Exponential backoff multiplier (default: 2)
      onRateLimit: (attempt, waitTime) => {
        console.log(`Rate limited. Attempt ${attempt}, waiting ${waitTime}ms`);
-      }
+      },
    })
    .get();
@@ -448,8 +597,10 @@ class RateLimitedApiClient {
      .handle429Backoff({
        maxRetries: 3,
        onRateLimit: (attempt, waitTime) => {
-          console.log(`API rate limit hit. Waiting ${waitTime}ms before retry ${attempt}`);
+          console.log(
-        }
+            `API rate limit hit. Waiting ${waitTime}ms before retry ${attempt}`,
          );
        },
      });
  }
@@ -461,6 +612,7 @@ class RateLimitedApiClient {
 ```
 The rate limiting feature:
 - Automatically detects 429 responses and retries with backoff
 - Respects the `Retry-After` header when present (supports both seconds and HTTP date formats)
 - Uses exponential backoff when no `Retry-After` header is provided
@@ -478,9 +630,9 @@ const response = await SmartRequest.create()
  .url('https://api.example.com/data')
  .options({
    credentials: 'include', // Include cookies
-    mode: 'cors',          // CORS mode
+    mode: 'cors', // CORS mode
-    cache: 'no-cache',     // Cache mode
+    cache: 'no-cache', // Cache mode
-    referrerPolicy: 'no-referrer'
+    referrerPolicy: 'no-referrer',
  })
  .get();
 ```
@@ -496,17 +648,66 @@ const response = await SmartRequest.create()
  .url('https://api.example.com/data')
  .options({
    agent: new Agent({ keepAlive: true }), // Custom agent
-    socketPath: '/var/run/api.sock',       // Unix socket
+    socketPath: '/var/run/api.sock', // Unix socket
  })
  .get();
 ```
 ### Bun-Specific Options
 When running in Bun, you can use Bun-specific options:
 ```typescript
 const response = await SmartRequest.create()
  .url('https://api.example.com/data')
  .options({
    unix: '/var/run/api.sock', // Unix socket (Bun's native option)
    keepAlive: true, // Keep-alive support
  })
  .get();
 // Bun uses web streams natively
 const streamResponse = await SmartRequest.create()
  .url('https://api.example.com/data')
  .get();
 const webStream = streamResponse.stream(); // ✅ Use web streams in Bun
 ```
 ### Deno-Specific Options
 When running in Deno, you can use Deno-specific options:
 ```typescript
 // Custom HttpClient for advanced configuration
 const client = Deno.createHttpClient({
  proxy: { url: 'unix:///var/run/api.sock' }
 });
 const response = await SmartRequest.create()
  .url('https://api.example.com/data')
  .options({
    client, // Custom Deno HttpClient
  })
  .get();
 // Remember to clean up clients when done
 client.close();
 // Deno uses web streams natively
 const streamResponse = await SmartRequest.create()
  .url('https://api.example.com/data')
  .get();
 const webStream = streamResponse.stream(); // ✅ Use web streams in Deno
 ```
 ## 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';
+import { SmartRequest, type ICoreResponse } from '@push.rocks/smartrequest';
 interface User {
  id: number;
@@ -523,40 +724,41 @@ interface Post {
 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')
+    const response = await this.request('/posts').json(post).post();
      .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}`);
    }
    // Consume the body
    await response.text();
  }
-  
+
  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[]>();
  }
@@ -580,15 +782,15 @@ async function fetchWithErrorHandling(url: string) {
      .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/')) {
@@ -611,9 +813,158 @@ async function fetchWithErrorHandling(url: string) {
 }
 ```
-## Migrating from v2.x to v3.x
+## Migrating from Earlier Versions
-Version 3.0 brings significant architectural improvements and a more consistent API:
+### From v4.x to v5.x
 Version 5.0 completes the transition to modern web standards by removing Node.js-specific streaming APIs:
 #### **Breaking Changes**
 1. **`.streamNode()` Method Removed**
   - The `.streamNode()` method has been removed from all response objects
   - Use the cross-platform `.stream()` method instead, which returns a web `ReadableStream<Uint8Array>`
   - For Node.js users who need Node.js streams, convert using `Readable.fromWeb()`
   ```typescript
   // ❌ Before (v4.x) - Node.js only
   const response = await SmartRequest.create().url(url).get();
   const nodeStream = response.streamNode();
   // ✅ After (v5.x) - Cross-platform
   import { Readable } from 'stream';
   const response = await SmartRequest.create().url(url).get();
   const webStream = response.stream();
   const nodeStream = Readable.fromWeb(webStream); // Convert to Node.js stream
   ```
 2. **Request `.raw()` Method Removed**
   - The `.raw(streamFunc)` method has been removed from the SmartRequest client
   - Use `.stream()` with a web `ReadableStream` instead for request body streaming
   - Node.js users can create web streams from Node.js streams using `Readable.toWeb()`
   ```typescript
   // ❌ Before (v4.x) - Node.js only
   const response = await SmartRequest.create()
     .url(url)
     .raw((request) => {
       request.write('chunk1');
       request.write('chunk2');
       request.end();
     })
     .post();
   // ✅ After (v5.x) - Cross-platform
   const stream = new ReadableStream({
     start(controller) {
       controller.enqueue(new TextEncoder().encode('chunk1'));
       controller.enqueue(new TextEncoder().encode('chunk2'));
       controller.close();
     }
   });
   const response = await SmartRequest.create()
     .url(url)
     .stream(stream)
     .post();
   // Or convert from Node.js stream (Node.js only)
   import { Readable } from 'stream';
   import * as fs from 'fs';
   const nodeStream = fs.createReadStream('file.txt');
   const webStream = Readable.toWeb(nodeStream);
   const response = await SmartRequest.create()
     .url(url)
     .stream(webStream)
     .post();
   ```
 3. **Response `.raw()` Method Preserved**
   - The `response.raw()` method is still available for accessing platform-specific response objects
   - Returns `http.IncomingMessage` in Node.js or `Response` in other runtimes
   - Use for advanced scenarios requiring access to raw platform objects
   ```typescript
   // ✅ Still works in v5.x
   const response = await SmartRequest.create().url(url).get();
   const rawResponse = response.raw(); // http.IncomingMessage or Response
   ```
 #### **Migration Guide**
 **For Response Streaming:**
 ```typescript
 // Before (v4.x)
 const response = await SmartRequest.create().url(url).get();
 const nodeStream = response.streamNode();
 nodeStream.on('data', (chunk) => {
  console.log(`Received ${chunk.length} bytes`);
 });
 // After (v5.x) - Option 1: Use web streams directly
 const response = await SmartRequest.create().url(url).get();
 const webStream = response.stream();
 if (webStream) {
  const reader = webStream.getReader();
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    console.log(`Received ${value.length} bytes`);
  }
  reader.releaseLock();
 }
 // After (v5.x) - Option 2: Convert to Node.js stream (Node.js only)
 import { Readable } from 'stream';
 const response = await SmartRequest.create().url(url).get();
 const webStream = response.stream();
 const nodeStream = Readable.fromWeb(webStream);
 nodeStream.on('data', (chunk) => {
  console.log(`Received ${chunk.length} bytes`);
 });
 ```
 **For Request Streaming:**
 Node.js streams are still accepted by the `.stream()` method and automatically converted internally. No changes required for most use cases:
 ```typescript
 // ✅ Still works in v5.x
 import * as fs from 'fs';
 const fileStream = fs.createReadStream('large-file.bin');
 const response = await SmartRequest.create()
  .url('https://api.example.com/upload')
  .stream(fileStream, 'application/octet-stream')
  .post();
 ```
 **Benefits:**
 - ✅ True cross-platform compatibility
 - ✅ Modern web standards
 - ✅ Cleaner API surface
 - ✅ Single streaming approach works everywhere
 ### From v3.x to v4.x
 Version 4.0 adds comprehensive cross-platform support:
 1. **Multi-Runtime Support**: Now works natively in Node.js, Bun, Deno, and browsers
 2. **Unix Sockets Everywhere**: Unix socket support added for Bun and Deno
 3. **Web Streams**: Full support for web ReadableStream across all platforms
 4. **Automatic Runtime Detection**: No configuration needed - works everywhere automatically
 ### From v2.x to v3.x
 Version 3.0 brought significant architectural improvements:
 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.
@@ -622,7 +973,7 @@ Version 3.0 brings significant architectural improvements and a more consistent
 ## 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. 
+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.
@@ -637,4 +988,4 @@ 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.
+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.chromium.ts
+++ b/test/test.chromium.ts
@@ -6,13 +6,15 @@ 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 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);
@@ -22,16 +24,19 @@ tap.test('browser: should request a JSON document over https', async () => {
 tap.test('browser: should handle CORS requests', async () => {
  const options: ICoreRequestOptions = {
    headers: {
-      'Accept': 'application/vnd.github.v3+json'
+      Accept: 'application/vnd.github.v3+json',
-    }
+    },
  };
-  
+
-  const request = new CoreRequest('https://api.github.com/users/github', options);
+  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');
@@ -39,21 +44,24 @@ tap.test('browser: should handle CORS requests', async () => {
 tap.test('browser: should handle request timeouts', async () => {
  let timedOut = false;
-  
+
  const options: ICoreRequestOptions = {
-    timeout: 1 // Extremely short timeout to guarantee failure
+    timeout: 1, // Extremely short timeout to guarantee failure
  };
-  
+
  try {
    // Use a URL that will definitely take longer than 1ms
-    const request = new CoreRequest('https://jsonplaceholder.typicode.com/posts/1', options);
+    const request = new CoreRequest(
      'https://jsonplaceholder.typicode.com/posts/1',
      options,
    );
    await request.fire();
  } catch (error) {
    timedOut = true;
    // Accept any error since different browsers handle timeouts differently
    expect(error).toBeDefined();
  }
-  
+
  expect(timedOut).toEqual(true);
 });
@@ -61,19 +69,22 @@ tap.test('browser: should handle POST requests with JSON', async () => {
  const testData = {
    title: 'foo',
    body: 'bar',
-    userId: 1
+    userId: 1,
  };
-  
+
  const options: ICoreRequestOptions = {
    method: 'POST',
-    requestBody: testData
+    requestBody: testData,
  };
-  
+
-  const request = new CoreRequest('https://jsonplaceholder.typicode.com/posts', options);
+  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);
@@ -84,15 +95,18 @@ tap.test('browser: should handle POST requests with JSON', async () => {
 tap.test('browser: should handle query parameters', async () => {
  const options: ICoreRequestOptions = {
    queryParams: {
-      userId: '2'
+      userId: '2',
-    }
+    },
  };
-  
+
-  const request = new CoreRequest('https://jsonplaceholder.typicode.com/posts', options);
+  const request = new CoreRequest(
    'https://jsonplaceholder.typicode.com/posts',
    options,
  );
  const response = await request.fire();
-    
+
  expect(response.status).toEqual(200);
-  
+
  const data = await response.json();
  expect(Array.isArray(data)).toBeTrue();
  // Verify we got posts filtered by userId 2
@@ -102,4 +116,4 @@ tap.test('browser: should handle query parameters', async () => {
  }
 });
-export default tap.start();
+export default tap.start();
--- a/test/test.node+bun+deno.ts
+++ b/test/test.node+bun+deno.ts
@@ -51,7 +51,10 @@ tap.test('client: should set headers correctly', async () => {
  // Check if the header exists (headers might be lowercase)
  const headers = body.headers;
-  const headerFound = headers[customHeader] || headers[customHeader.toLowerCase()] || headers['x-custom-header'];
+  const headerFound =
    headers[customHeader] ||
    headers[customHeader.toLowerCase()] ||
    headers['x-custom-header'];
  expect(headerFound).toEqual(headerValue);
 });
@@ -81,7 +84,7 @@ tap.test('client: should handle timeout configuration', async () => {
  const response = await client.get();
  expect(response).toHaveProperty('ok');
  expect(response.ok).toBeTrue();
-  
+
  // Consume the body to prevent socket hanging
  await response.text();
 });
@@ -95,34 +98,40 @@ tap.test('client: should handle retry configuration', async () => {
  const response = await client.get();
  expect(response).toHaveProperty('ok');
  expect(response.ok).toBeTrue();
-  
+
  // Consume the body to prevent socket hanging
  await response.text();
 });
-tap.test('client: should support keepAlive option for connection reuse', async () => {
+tap.test(
-  // Simple test
+  'client: should support keepAlive option for connection reuse',
-  const response = await SmartRequest.create()
+  async () => {
-    .url('https://jsonplaceholder.typicode.com/posts/1')
+    // Simple test
-    .options({ keepAlive: true })
+    const response = await SmartRequest.create()
-    .get();
+      .url('https://jsonplaceholder.typicode.com/posts/1')
-  
+      .options({ keepAlive: true })
-  expect(response.ok).toBeTrue();
+      .get();
  await response.text();
 });
-tap.test('client: should handle 429 rate limiting with default config', async () => {
+    expect(response.ok).toBeTrue();
-  // Test that handle429Backoff can be configured without errors
+    await response.text();
-  const client = SmartRequest.create()
+  },
-    .url('https://jsonplaceholder.typicode.com/posts/1')
+);
    .handle429Backoff();
-  const response = await client.get();
+tap.test(
-  expect(response.status).toEqual(200);
+  'client: should handle 429 rate limiting with default config',
-  
+  async () => {
-  // Consume the body to prevent socket hanging
+    // Test that handle429Backoff can be configured without errors
-  await response.text();
+    const client = SmartRequest.create()
-});
+      .url('https://jsonplaceholder.typicode.com/posts/1')
      .handle429Backoff();
    const response = await client.get();
    expect(response.status).toEqual(200);
    // Consume the body to prevent socket hanging
    await response.text();
  },
 );
 tap.test('client: should handle 429 with custom config', async () => {
  let rateLimitCallbackCalled = false;
@@ -139,65 +148,74 @@ tap.test('client: should handle 429 with custom config', async () => {
        rateLimitCallbackCalled = true;
        attemptCount = attempt;
        waitTimeReceived = waitTime;
-      }
+      },
    });
  const response = await client.get();
  expect(response.status).toEqual(200);
-  
+
  // The callback should not have been called for a 200 response
  expect(rateLimitCallbackCalled).toBeFalse();
-  
+
  // Consume the body to prevent socket hanging
  await response.text();
 });
-tap.test('client: should respect Retry-After header format (seconds)', async () => {
+tap.test(
-  // Test the configuration works - actual 429 testing would require a mock server
+  'client: should respect Retry-After header format (seconds)',
-  const client = SmartRequest.create()
+  async () => {
-    .url('https://jsonplaceholder.typicode.com/posts/1')
+    // Test the configuration works - actual 429 testing would require a mock server
-    .handle429Backoff({
+    const client = SmartRequest.create()
-      maxRetries: 1,
+      .url('https://jsonplaceholder.typicode.com/posts/1')
-      respectRetryAfter: true
+      .handle429Backoff({
-    });
+        maxRetries: 1,
        respectRetryAfter: true,
      });
-  const response = await client.get();
+    const response = await client.get();
-  expect(response.ok).toBeTrue();
+    expect(response.ok).toBeTrue();
  // Consume the body to prevent socket hanging
  await response.text();
 });
-tap.test('client: should handle rate limiting with exponential backoff', async () => {
+    // Consume the body to prevent socket hanging
-  // Test exponential backoff configuration
+    await response.text();
-  const client = SmartRequest.create()
+  },
-    .url('https://jsonplaceholder.typicode.com/posts/1')
+);
    .handle429Backoff({
      maxRetries: 3,
      fallbackDelay: 100,
      backoffFactor: 2,
      maxWaitTime: 1000
    });
-  const response = await client.get();
+tap.test(
-  expect(response.status).toEqual(200);
+  'client: should handle rate limiting with exponential backoff',
-  
+  async () => {
-  // Consume the body to prevent socket hanging
+    // Test exponential backoff configuration
-  await response.text();
+    const client = SmartRequest.create()
-});
+      .url('https://jsonplaceholder.typicode.com/posts/1')
      .handle429Backoff({
        maxRetries: 3,
        fallbackDelay: 100,
        backoffFactor: 2,
        maxWaitTime: 1000,
      });
-tap.test('client: should not retry non-429 errors with rate limit handler', async () => {
+    const response = await client.get();
-  // Test that 404 errors are not retried by rate limit handler
+    expect(response.status).toEqual(200);
  const client = SmartRequest.create()
    .url('https://jsonplaceholder.typicode.com/posts/999999')
    .handle429Backoff();
-  const response = await client.get();
+    // Consume the body to prevent socket hanging
-  expect(response.status).toEqual(404);
+    await response.text();
-  expect(response.ok).toBeFalse();
+  },
-  
+);
-  // Consume the body to prevent socket hanging
+
-  await response.text();
+tap.test(
-});
+  'client: should not retry non-429 errors with rate limit handler',
  async () => {
    // Test that 404 errors are not retried by rate limit handler
    const client = SmartRequest.create()
      .url('https://jsonplaceholder.typicode.com/posts/999999')
      .handle429Backoff();
    const response = await client.get();
    expect(response.status).toEqual(404);
    expect(response.ok).toBeFalse();
    // Consume the body to prevent socket hanging
    await response.text();
  },
 );
 tap.start();
--- a/test/test.streaming.chrome.ts
+++ b/test/test.streaming.chrome.ts
@@ -0,0 +1,41 @@
 import { tap, expect } from '@git.zone/tstest/tapbundle';
 import { SmartRequest } from '../ts/index.js';
 tap.test('browser: should send Uint8Array using buffer() method', async () => {
  const testData = new Uint8Array([72, 101, 108, 108, 111]); // "Hello" in ASCII
  const smartRequest = SmartRequest.create()
    .url('https://httpbin.org/post')
    .buffer(testData, 'application/octet-stream')
    .method('POST');
  const response = await smartRequest.post();
  const data = await response.json();
  expect(data).toHaveProperty('data');
  expect(data.headers['Content-Type']).toEqual('application/octet-stream');
 });
 tap.test('browser: should send web ReadableStream using stream() method', async () => {
  // Create a web ReadableStream
  const encoder = new TextEncoder();
  const stream = new ReadableStream({
    start(controller) {
      controller.enqueue(encoder.encode('Test stream data'));
      controller.close();
    }
  });
  const smartRequest = SmartRequest.create()
    .url('https://httpbin.org/post')
    .stream(stream, 'text/plain')
    .method('POST');
  const response = await smartRequest.post();
  const data = await response.json();
  expect(data).toHaveProperty('data');
  // httpbin should receive the streamed data
 });
 export default tap.start();
--- a/test/test.streaming.node+bun+deno.ts
+++ b/test/test.streaming.node+bun+deno.ts
@@ -0,0 +1,61 @@
 import { tap, expect } from '@git.zone/tstest/tapbundle';
 import { SmartRequest } from '../ts/index.js';
 // Cross-platform tests using web-standard APIs only
 tap.test('should send a buffer using buffer() method', async () => {
  const testBuffer = Buffer.from('Hello, World!');
  const smartRequest = SmartRequest.create()
    .url('https://httpbin.org/post')
    .buffer(testBuffer, 'text/plain')
    .method('POST');
  const response = await smartRequest.post();
  const data = await response.json();
  expect(data).toHaveProperty('data');
  expect(data.data).toEqual('Hello, World!');
  expect(data.headers['Content-Type']).toEqual('text/plain');
 });
 tap.test('should send a web ReadableStream using stream() method', async () => {
  const testData = 'Stream data test';
  // Use web-standard ReadableStream (works on all platforms)
  const stream = new ReadableStream({
    start(controller) {
      controller.enqueue(new TextEncoder().encode(testData));
      controller.close();
    },
  });
  const smartRequest = SmartRequest.create()
    .url('https://httpbin.org/post')
    .stream(stream, 'text/plain')
    .method('POST');
  const response = await smartRequest.post();
  const data = await response.json();
  expect(data).toHaveProperty('data');
  expect(data.data).toEqual(testData);
 });
 tap.test('should send Uint8Array using buffer() method', async () => {
  const testData = new Uint8Array([72, 101, 108, 108, 111]); // "Hello" in ASCII
  const smartRequest = SmartRequest.create()
    .url('https://httpbin.org/post')
    .buffer(testData, 'application/octet-stream')
    .method('POST');
  const response = await smartRequest.post();
  const data = await response.json();
  // Just verify that data was sent
  expect(data).toHaveProperty('data');
  expect(data.headers['Content-Type']).toEqual('application/octet-stream');
 });
 export default tap.start();
--- a/test/test.streamnode.node.ts
+++ b/test/test.streamnode.node.ts
@@ -0,0 +1,68 @@
 import { tap, expect } from '@git.zone/tstest/tapbundle';
 import { SmartRequest } from '../ts/index.js';
 import { Readable } from 'stream';
 tap.test('should have stream() method that returns web ReadableStream', async () => {
  const response = await SmartRequest.create()
    .url('https://httpbin.org/get')
    .get();
  // Verify stream() method exists
  expect(response.stream).toBeDefined();
  expect(typeof response.stream).toEqual('function');
  // Get web stream
  const webStream = response.stream();
  expect(webStream).toBeDefined();
  // Verify it's a web ReadableStream
  expect(typeof webStream.getReader).toEqual('function');
  expect(typeof webStream.cancel).toEqual('function');
  // Convert to Node.js stream using Readable.fromWeb()
  // Known TypeScript limitation: @types/node ReadableStream differs from web ReadableStream
  const nodeStream = Readable.fromWeb(webStream as any);
  expect(nodeStream).toBeDefined();
  // Verify it's a Node.js readable stream
  expect(typeof nodeStream.pipe).toEqual('function');
  expect(typeof nodeStream.on).toEqual('function');
  // Consume the stream to avoid hanging
  nodeStream.resume();
 });
 tap.test('should convert web stream to Node.js stream correctly', async () => {
  const response = await SmartRequest.create()
    .url('https://httpbin.org/get')
    .get();
  const webStream = response.stream();
  const nodeStream = Readable.fromWeb(webStream as any);
  // Collect data from stream
  const chunks: Buffer[] = [];
  await new Promise<void>((resolve, reject) => {
    nodeStream.on('data', (chunk) => {
      chunks.push(chunk);
    });
    nodeStream.on('end', () => {
      resolve();
    });
    nodeStream.on('error', reject);
  });
  // Verify we received data
  const data = Buffer.concat(chunks);
  expect(data.length).toBeGreaterThan(0);
  // Verify it's valid JSON
  const json = JSON.parse(data.toString('utf-8'));
  expect(json).toBeDefined();
  expect(json.url).toEqual('https://httpbin.org/get');
 });
 export default tap.start();
--- a/test/test.timeout.node+bun+deno.ts
+++ b/test/test.timeout.node+bun+deno.ts
@@ -0,0 +1,60 @@
 import { tap, expect } from '@git.zone/tstest/tapbundle';
 import { SmartRequest } from '../ts/index.js';
 tap.test('should clear timeout when request completes before timeout', async () => {
  // Set a long timeout that would keep the process alive if not cleared
  const response = await SmartRequest.create()
    .url('https://httpbin.org/delay/1') // 1 second delay
    .timeout(10000) // 10 second timeout (much longer than needed)
    .get();
  const data = await response.json();
  expect(data).toBeDefined();
  // The test should complete quickly, not wait for the 10 second timeout
  // If the timeout isn't cleared, the process would hang for 10 seconds
 });
 tap.test('should timeout when request takes longer than timeout', async () => {
  let errorThrown = false;
  try {
    // Try to fetch with a very short timeout
    await SmartRequest.create()
      .url('https://httpbin.org/delay/3') // 3 second delay
      .timeout(100) // 100ms timeout (will fail)
      .get();
  } catch (error) {
    errorThrown = true;
    expect(error.message).toContain('Request timed out');
  }
  expect(errorThrown).toBeTrue();
 });
 tap.test('should not leak timers with multiple successful requests', async () => {
  // Make multiple requests with timeouts to ensure no timer leaks
  const promises = [];
  for (let i = 0; i < 5; i++) {
    promises.push(
      SmartRequest.create()
        .url('https://httpbin.org/get')
        .timeout(5000) // 5 second timeout
        .get()
        .then(response => response.json())
    );
  }
  const results = await Promise.all(promises);
  // All requests should complete successfully
  expect(results).toHaveLength(5);
  results.forEach(result => {
    expect(result).toBeDefined();
  });
  // Process should exit cleanly after this test without hanging
 });
 export default tap.start();
--- a/test/test.unixsocket.bun.ts
+++ b/test/test.unixsocket.bun.ts
@@ -0,0 +1,101 @@
 import { tap, expect } from '@git.zone/tstest/tapbundle';
 import { SmartRequest } from '../ts/client/index.js';
 import { CoreRequest } from '../ts/core_bun/index.js';
 // Check if Docker socket exists (common unix socket for testing)
 const dockerSocketPath = '/var/run/docker.sock';
 let dockerAvailable = false;
 try {
  const file = Bun.file(dockerSocketPath);
  dockerAvailable = await file.exists();
 } catch (error) {
  console.log(
    'Docker socket not available - skipping unix socket tests. To enable, ensure Docker is running.',
  );
 }
 tap.test('bun: should detect unix socket URLs correctly', async () => {
  expect(CoreRequest.isUnixSocket('unix:/var/run/docker.sock:/version')).toBeTrue();
  expect(CoreRequest.isUnixSocket('http://unix:/var/run/docker.sock:/version')).toBeTrue();
  expect(CoreRequest.isUnixSocket('https://unix:/var/run/docker.sock:/version')).toBeTrue();
  expect(CoreRequest.isUnixSocket('http://example.com')).toBeFalse();
  expect(CoreRequest.isUnixSocket('https://example.com')).toBeFalse();
 });
 tap.test('bun: should parse unix socket URLs correctly', async () => {
  const result = CoreRequest.parseUnixSocketUrl('unix:/var/run/docker.sock:/v1.24/version');
  expect(result.socketPath).toEqual('/var/run/docker.sock');
  expect(result.path).toEqual('/v1.24/version');
 });
 if (dockerAvailable) {
  tap.test('bun: should connect to Docker via unix socket (unix: protocol)', async () => {
    const response = await SmartRequest.create()
      .url('http://unix:/var/run/docker.sock:/version')
      .get();
    expect(response.ok).toBeTrue();
    expect(response.status).toEqual(200);
    const body = await response.json();
    expect(body).toHaveProperty('Version');
    console.log(`Docker version: ${body.Version}`);
  });
  tap.test('bun: should connect to Docker via socketPath option', async () => {
    const response = await CoreRequest.create('http://localhost/version', {
      socketPath: '/var/run/docker.sock',
    });
    expect(response.ok).toBeTrue();
    expect(response.status).toEqual(200);
    const body = await response.json();
    expect(body).toHaveProperty('Version');
  });
  tap.test('bun: should connect to Docker via unix option', async () => {
    const response = await CoreRequest.create('http://localhost/version', {
      unix: '/var/run/docker.sock',
    });
    expect(response.ok).toBeTrue();
    expect(response.status).toEqual(200);
    const body = await response.json();
    expect(body).toHaveProperty('Version');
  });
  tap.test('bun: should handle unix socket with query parameters', async () => {
    const response = await SmartRequest.create()
      .url('http://unix:/var/run/docker.sock:/containers/json')
      .query({ all: 'true' })
      .get();
    expect(response.ok).toBeTrue();
    expect(response.status).toEqual(200);
    const body = await response.json();
    expect(Array.isArray(body)).toBeTrue();
  });
  tap.test('bun: should handle unix socket with POST requests', async () => {
    // Test POST to Docker API (this specific endpoint may require permissions)
    const response = await SmartRequest.create()
      .url('http://unix:/var/run/docker.sock:/containers/json')
      .query({ all: 'true', limit: '1' })
      .get();
    expect(response.status).toBeGreaterThanOrEqual(200);
    expect(response.status).toBeLessThan(500);
    await response.text(); // Consume body
  });
 } else {
  tap.skip.test(
    'bun: unix socket tests skipped - Docker socket not available',
  );
 }
 export default tap.start();
--- a/test/test.unixsocket.deno.ts
+++ b/test/test.unixsocket.deno.ts
@@ -0,0 +1,154 @@
 import { tap, expect } from '@git.zone/tstest/tapbundle';
 import { SmartRequest } from '../ts/client/index.js';
 import { CoreRequest } from '../ts/core_deno/index.js';
 // Check if Docker socket exists (common unix socket for testing)
 const dockerSocketPath = '/var/run/docker.sock';
 let dockerAvailable = false;
 try {
  const fileInfo = await Deno.stat(dockerSocketPath);
  dockerAvailable = fileInfo.isFile || fileInfo.isSymlink;
 } catch (error) {
  console.log(
    'Docker socket not available - skipping unix socket tests. To enable, ensure Docker is running.',
  );
 }
 tap.test('deno: should detect unix socket URLs correctly', async () => {
  expect(CoreRequest.isUnixSocket('unix:/var/run/docker.sock:/version')).toBeTrue();
  expect(CoreRequest.isUnixSocket('http://unix:/var/run/docker.sock:/version')).toBeTrue();
  expect(CoreRequest.isUnixSocket('https://unix:/var/run/docker.sock:/version')).toBeTrue();
  expect(CoreRequest.isUnixSocket('http://example.com')).toBeFalse();
  expect(CoreRequest.isUnixSocket('https://example.com')).toBeFalse();
 });
 tap.test('deno: should parse unix socket URLs correctly', async () => {
  const result = CoreRequest.parseUnixSocketUrl('unix:/var/run/docker.sock:/v1.24/version');
  expect(result.socketPath).toEqual('/var/run/docker.sock');
  expect(result.path).toEqual('/v1.24/version');
 });
 if (dockerAvailable) {
  tap.test('deno: should connect to Docker via unix socket (unix: protocol)', async () => {
    const response = await SmartRequest.create()
      .url('http://unix:/var/run/docker.sock:/version')
      .get();
    expect(response.ok).toBeTrue();
    expect(response.status).toEqual(200);
    const body = await response.json();
    expect(body).toHaveProperty('Version');
    console.log(`Docker version: ${body.Version}`);
  });
  tap.test('deno: should connect to Docker via socketPath option', async () => {
    const response = await CoreRequest.create('http://localhost/version', {
      socketPath: '/var/run/docker.sock',
    });
    expect(response.ok).toBeTrue();
    expect(response.status).toEqual(200);
    const body = await response.json();
    expect(body).toHaveProperty('Version');
  });
  tap.test('deno: should connect to Docker via HttpClient', async () => {
    const client = Deno.createHttpClient({
      proxy: {
        url: 'unix:///var/run/docker.sock',
      },
    });
    const response = await CoreRequest.create('http://localhost/version', {
      client,
    });
    expect(response.ok).toBeTrue();
    expect(response.status).toEqual(200);
    const body = await response.json();
    expect(body).toHaveProperty('Version');
    // Clean up client
    client.close();
  });
  tap.test('deno: should handle unix socket with query parameters', async () => {
    const response = await SmartRequest.create()
      .url('http://unix:/var/run/docker.sock:/containers/json')
      .query({ all: 'true' })
      .get();
    expect(response.ok).toBeTrue();
    expect(response.status).toEqual(200);
    const body = await response.json();
    expect(Array.isArray(body)).toBeTrue();
  });
  tap.test('deno: should handle unix socket with POST requests', async () => {
    // Test POST to Docker API (this specific endpoint may require permissions)
    const response = await SmartRequest.create()
      .url('http://unix:/var/run/docker.sock:/containers/json')
      .query({ all: 'true', limit: '1' })
      .get();
    expect(response.status).toBeGreaterThanOrEqual(200);
    expect(response.status).toBeLessThan(500);
    await response.text(); // Consume body
  });
  tap.test('deno: should cache HttpClient for reuse', async () => {
    // First request creates a client
    const response1 = await SmartRequest.create()
      .url('http://unix:/var/run/docker.sock:/version')
      .get();
    expect(response1.ok).toBeTrue();
    await response1.text();
    // Second request should reuse the cached client
    const response2 = await SmartRequest.create()
      .url('http://unix:/var/run/docker.sock:/version')
      .get();
    expect(response2.ok).toBeTrue();
    await response2.text();
    // Clean up cache
    CoreRequest.clearClientCache();
  });
  tap.test('deno: should clear HttpClient cache', async () => {
    const response = await SmartRequest.create()
      .url('http://unix:/var/run/docker.sock:/version')
      .get();
    expect(response.ok).toBeTrue();
    await response.text();
    // Clear cache - should not throw
    CoreRequest.clearClientCache();
    // Subsequent request should create new client
    const response2 = await SmartRequest.create()
      .url('http://unix:/var/run/docker.sock:/version')
      .get();
    expect(response2.ok).toBeTrue();
    await response2.text();
    // Clean up
    CoreRequest.clearClientCache();
  });
 } else {
  tap.skip.test(
    'deno: unix socket tests skipped - Docker socket not available',
  );
 }
 export default tap.start();
--- a/test/test.unixsocket.node.ts
+++ b/test/test.unixsocket.node.ts
@@ -0,0 +1,90 @@
 import { tap, expect } from '@git.zone/tstest/tapbundle';
 import * as plugins from '../ts/core_node/plugins.js';
 import { SmartRequest } from '../ts/client/index.js';
 import { CoreRequest } from '../ts/core_node/index.js';
 // Check if Docker socket exists (common unix socket for testing)
 const dockerSocketPath = '/var/run/docker.sock';
 let dockerAvailable = false;
 try {
  await plugins.fs.promises.access(dockerSocketPath, plugins.fs.constants.R_OK);
  dockerAvailable = true;
 } catch (error) {
  console.log(
    'Docker socket not available - skipping unix socket tests. To enable, ensure Docker is running.',
  );
 }
 tap.test('node: should detect unix socket URLs correctly', async () => {
  expect(CoreRequest.isUnixSocket('unix:/var/run/docker.sock:/version')).toBeTrue();
  expect(CoreRequest.isUnixSocket('http://unix:/var/run/docker.sock:/version')).toBeTrue();
  expect(CoreRequest.isUnixSocket('https://unix:/var/run/docker.sock:/version')).toBeTrue();
  expect(CoreRequest.isUnixSocket('http://example.com')).toBeFalse();
  expect(CoreRequest.isUnixSocket('https://example.com')).toBeFalse();
 });
 tap.test('node: should parse unix socket URLs correctly', async () => {
  const result = CoreRequest.parseUnixSocketUrl('unix:/var/run/docker.sock:/v1.24/version');
  expect(result.socketPath).toEqual('/var/run/docker.sock');
  expect(result.path).toEqual('/v1.24/version');
 });
 if (dockerAvailable) {
  tap.test('node: should connect to Docker via unix socket (unix: protocol)', async () => {
    const response = await SmartRequest.create()
      .url('http://unix:/var/run/docker.sock:/version')
      .get();
    expect(response.ok).toBeTrue();
    expect(response.status).toEqual(200);
    const body = await response.json();
    expect(body).toHaveProperty('Version');
    console.log(`Docker version: ${body.Version}`);
  });
  tap.test('node: should connect to Docker via socketPath option', async () => {
    const response = await CoreRequest.create('http://localhost/version', {
      socketPath: '/var/run/docker.sock',
    });
    expect(response.ok).toBeTrue();
    expect(response.status).toEqual(200);
    const body = await response.json();
    expect(body).toHaveProperty('Version');
  });
  tap.test('node: should handle unix socket with query parameters', async () => {
    const response = await SmartRequest.create()
      .url('http://unix:/var/run/docker.sock:/containers/json')
      .query({ all: 'true' })
      .get();
    expect(response.ok).toBeTrue();
    expect(response.status).toEqual(200);
    const body = await response.json();
    expect(Array.isArray(body)).toBeTrue();
  });
  tap.test('node: should handle unix socket with POST requests', async () => {
    // Test POST to Docker API (this specific endpoint may require permissions)
    const response = await SmartRequest.create()
      .url('http://unix:/var/run/docker.sock:/containers/json')
      .query({ all: 'true', limit: '1' })
      .get();
    expect(response.status).toBeGreaterThanOrEqual(200);
    expect(response.status).toBeLessThan(500);
    await response.text(); // Consume body
  });
 } else {
  tap.skip.test(
    'node: unix socket tests skipped - Docker socket not available',
  );
 }
 export default tap.start();
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@@ -3,6 +3,6 @@
 */
 export const commitinfo = {
  name: '@push.rocks/smartrequest',
-  version: '2.1.0',
+  version: '5.0.1',
  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
@@ -1,6 +1,10 @@
 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';
+import {
  type TPaginationConfig,
  PaginationStrategy,
  type TPaginatedResponse,
 } from '../types/pagination.js';
 /**
 * Creates a paginated response from a regular response
@@ -9,15 +13,17 @@ export async function createPaginatedResponse<T>(
  response: ICoreResponse<any>,
  paginationConfig: TPaginationConfig,
  queryParams: Record<string, string>,
-  fetchNextPage: (params: Record<string, string>) => Promise<TPaginatedResponse<T>>
+  fetchNextPage: (
    params: Record<string, string>,
  ) => Promise<TPaginatedResponse<T>>,
 ): Promise<TPaginatedResponse<T>> {
  // Parse response body first
-  const body = await response.json() as any;
+  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 || []);
+    : body?.items || body?.data || body?.results || [];
  let hasNextPage = false;
  let nextPageParams: Record<string, string> = {};
@@ -26,8 +32,14 @@ export async function createPaginatedResponse<T>(
  switch (paginationConfig.strategy) {
    case PaginationStrategy.OFFSET: {
      const config = paginationConfig;
-      const currentPage = parseInt(queryParams[config.pageParam || 'page'] || String(config.startPage || 1));
+      const currentPage = parseInt(
-      const limit = parseInt(queryParams[config.limitParam || 'limit'] || String(config.pageSize || 20));
+        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;
@@ -35,7 +47,7 @@ export async function createPaginatedResponse<T>(
      if (hasNextPage) {
        nextPageParams = {
          ...queryParams,
-          [config.pageParam || 'page']: String(currentPage + 1)
+          [config.pageParam || 'page']: String(currentPage + 1),
        };
      }
      break;
@@ -43,7 +55,10 @@ export async function createPaginatedResponse<T>(
    case PaginationStrategy.CURSOR: {
      const config = paginationConfig;
-      const nextCursor = getValueByPath(body, config.cursorPath || 'nextCursor');
+      const nextCursor = getValueByPath(
        body,
        config.cursorPath || 'nextCursor',
      );
      const hasMore = getValueByPath(body, config.hasMorePath || 'hasMore');
      hasNextPage = !!nextCursor || !!hasMore;
@@ -51,7 +66,7 @@ export async function createPaginatedResponse<T>(
      if (hasNextPage && nextCursor) {
        nextPageParams = {
          ...queryParams,
-          [config.cursorParam || 'cursor']: nextCursor
+          [config.cursorParam || 'cursor']: nextCursor,
        };
      }
      break;
@@ -60,7 +75,9 @@ export async function createPaginatedResponse<T>(
    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 headerValue = Array.isArray(linkHeader)
        ? linkHeader[0]
        : linkHeader;
      const links = parseLinkHeader(headerValue);
      hasNextPage = !!links.next;
@@ -100,7 +117,13 @@ export async function createPaginatedResponse<T>(
  // 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 };
+    let currentPage: TPaginatedResponse<T> = {
      items,
      hasNextPage,
      getNextPage,
      getAllPages,
      response,
    };
    while (currentPage.hasNextPage) {
      try {
@@ -119,7 +142,7 @@ export async function createPaginatedResponse<T>(
    hasNextPage,
    getNextPage,
    getAllPages,
-    response
+    response,
  };
 }
@@ -166,11 +189,15 @@ export function getValueByPath(obj: any, path?: string): any {
  let current = obj;
  for (const key of keys) {
-    if (current === null || current === undefined || typeof current !== 'object') {
+    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
@@ -5,15 +5,22 @@ export { SmartRequest } from './smartrequest.js';
 export { CoreResponse } from '../core/index.js';
 // Export types
-export type { HttpMethod, ResponseType, FormField, RetryConfig, TimeoutConfig, RateLimitConfig } from './types/common.js';
+export type {
-export { 
+  HttpMethod,
  ResponseType,
  FormField,
  RetryConfig,
  TimeoutConfig,
  RateLimitConfig,
 } from './types/common.js';
 export {
  PaginationStrategy,
  type TPaginationConfig as PaginationConfig,
  type OffsetPaginationConfig,
  type CursorPaginationConfig,
  type LinkPaginationConfig,
  type CustomPaginationConfig,
-  type TPaginatedResponse as PaginatedResponse
+  type TPaginatedResponse as PaginatedResponse,
 } from './types/pagination.js';
 // Convenience factory functions
@@ -45,4 +52,4 @@ export function createBinaryClient<T = any>() {
 */
 export function createStreamClient() {
  return SmartRequest.create().accept('stream');
-}
+}
--- a/ts/client/plugins.ts
+++ b/ts/client/plugins.ts
@@ -1,6 +1,4 @@
 // plugins for client module
 import FormData from 'form-data';
-export {
+export { FormData as formData };
  FormData as formData
 };
--- a/ts/client/smartrequest.ts
+++ b/ts/client/smartrequest.ts
@@ -3,14 +3,19 @@ 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, RateLimitConfig } from './types/common.js';
+import type {
  HttpMethod,
  ResponseType,
  FormField,
  RateLimitConfig,
 } from './types/common.js';
 import {
  type TPaginationConfig,
  PaginationStrategy,
  type OffsetPaginationConfig,
  type CursorPaginationConfig,
  type CustomPaginationConfig,
-  type TPaginatedResponse
+  type TPaginatedResponse,
 } from './types/pagination.js';
 import { createPaginatedResponse } from './features/pagination.js';
@@ -22,21 +27,21 @@ import { createPaginatedResponse } from './features/pagination.js';
 function parseRetryAfter(retryAfter: string | string[]): number {
  // Handle array of values (take first)
  const value = Array.isArray(retryAfter) ? retryAfter[0] : retryAfter;
-  
+
  if (!value) return 0;
-  
+
  // Try to parse as seconds (number)
  const seconds = parseInt(value, 10);
  if (!isNaN(seconds)) {
    return seconds * 1000;
  }
-  
+
  // Try to parse as HTTP date
  const retryDate = new Date(value);
  if (!isNaN(retryDate.getTime())) {
    return Math.max(0, retryDate.getTime() - Date.now());
  }
-  
+
  return 0;
 }
@@ -96,7 +101,7 @@ export class SmartRequest<T = any> {
      if (Buffer.isBuffer(item.value)) {
        form.append(item.name, item.value, {
          filename: item.filename || 'file',
-          contentType: item.contentType || 'application/octet-stream'
+          contentType: item.contentType || 'application/octet-stream',
        });
      } else {
        form.append(item.name, item.value);
@@ -109,13 +114,52 @@ export class SmartRequest<T = any> {
    this._options.headers = {
      ...this._options.headers,
-      ...form.getHeaders()
+      ...form.getHeaders(),
    };
    this._options.requestBody = form;
    return this;
  }
  /**
   * Set raw buffer data for the request
   */
  buffer(data: Buffer | Uint8Array, contentType?: string): this {
    if (!this._options.headers) {
      this._options.headers = {};
    }
    this._options.headers['Content-Type'] = contentType || 'application/octet-stream';
    this._options.requestBody = data;
    return this;
  }
  /**
   * Stream data for the request
   * Accepts Node.js Readable streams or web ReadableStream
   */
  stream(stream: NodeJS.ReadableStream | ReadableStream<Uint8Array>, contentType?: string): this {
    if (!this._options.headers) {
      this._options.headers = {};
    }
    // Set content type if provided
    if (contentType) {
      this._options.headers['Content-Type'] = contentType;
    }
    // Check if it's a Node.js stream (has pipe method)
    if ('pipe' in stream && typeof (stream as any).pipe === 'function') {
      // For Node.js streams, we need to use a custom approach
      // Store the stream to be used later
      (this._options as any).__nodeStream = stream;
    } else {
      // For web ReadableStream, pass directly
      this._options.requestBody = stream;
    }
    return this;
  }
  /**
   * Set request timeout in milliseconds
   */
@@ -143,7 +187,7 @@ export class SmartRequest<T = any> {
      maxWaitTime: config?.maxWaitTime ?? 60000,
      fallbackDelay: config?.fallbackDelay ?? 1000,
      backoffFactor: config?.backoffFactor ?? 2,
-      onRateLimit: config?.onRateLimit
+      onRateLimit: config?.onRateLimit,
    };
    return this;
  }
@@ -157,7 +201,7 @@ export class SmartRequest<T = any> {
    }
    this._options.headers = {
      ...this._options.headers,
-      ...headers
+      ...headers,
    };
    return this;
  }
@@ -179,7 +223,7 @@ export class SmartRequest<T = any> {
  query(params: Record<string, string>): this {
    this._queryParams = {
      ...this._queryParams,
-      ...params
+      ...params,
    };
    return this;
  }
@@ -190,7 +234,7 @@ export class SmartRequest<T = any> {
  options(options: Partial<ICoreRequestOptions>): this {
    this._options = {
      ...this._options,
-      ...options
+      ...options,
    };
    return this;
  }
@@ -210,12 +254,12 @@ export class SmartRequest<T = any> {
  accept(type: ResponseType): this {
    // Map response types to Accept header values
    const acceptHeaders: Record<ResponseType, string> = {
-      'json': 'application/json',
+      json: 'application/json',
-      'text': 'text/plain',
+      text: 'text/plain',
-      'binary': 'application/octet-stream',
+      binary: 'application/octet-stream',
-      'stream': '*/*'
+      stream: '*/*',
    };
-    
+
    return this.header('Accept', acceptHeaders[type]);
  }
@@ -230,20 +274,26 @@ export class SmartRequest<T = any> {
  /**
   * Configure offset-based pagination (page & limit)
   */
-  withOffsetPagination(config: Omit<OffsetPaginationConfig, 'strategy'> = {}): this {
+  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'
+      totalPath: config.totalPath || 'total',
    };
    // Add initial pagination parameters
    this.query({
-      [this._paginationConfig.pageParam]: String(this._paginationConfig.startPage),
+      [this._paginationConfig.pageParam]: String(
-      [this._paginationConfig.limitParam]: String(this._paginationConfig.pageSize)
+        this._paginationConfig.startPage,
      ),
      [this._paginationConfig.limitParam]: String(
        this._paginationConfig.pageSize,
      ),
    });
    return this;
@@ -252,12 +302,14 @@ export class SmartRequest<T = any> {
  /**
   * Configure cursor-based pagination
   */
-  withCursorPagination(config: Omit<CursorPaginationConfig, 'strategy'> = {}): this {
+  withCursorPagination(
    config: Omit<CursorPaginationConfig, 'strategy'> = {},
  ): this {
    this._paginationConfig = {
      strategy: PaginationStrategy.CURSOR,
      cursorParam: config.cursorParam || 'cursor',
      cursorPath: config.cursorPath || 'nextCursor',
-      hasMorePath: config.hasMorePath || 'hasMore'
+      hasMorePath: config.hasMorePath || 'hasMore',
    };
    return this;
  }
@@ -267,7 +319,7 @@ export class SmartRequest<T = any> {
   */
  withLinkPagination(): this {
    this._paginationConfig = {
-      strategy: PaginationStrategy.LINK_HEADER
+      strategy: PaginationStrategy.LINK_HEADER,
    };
    return this;
  }
@@ -279,7 +331,7 @@ export class SmartRequest<T = any> {
    this._paginationConfig = {
      strategy: PaginationStrategy.CUSTOM,
      hasNextPage: config.hasNextPage,
-      getNextPageParams: config.getNextPageParams
+      getNextPageParams: config.getNextPageParams,
    };
    return this;
  }
@@ -324,7 +376,9 @@ export class SmartRequest<T = any> {
   */
  async getPaginated<ItemType = T>(): Promise<TPaginatedResponse<ItemType>> {
    if (!this._paginationConfig) {
-      throw new Error('Pagination not configured. Call one of the pagination methods first.');
+      throw new Error(
        'Pagination not configured. Call one of the pagination methods first.',
      );
    }
    // Default to GET if no method specified
@@ -345,7 +399,7 @@ export class SmartRequest<T = any> {
        nextClient._queryParams = nextPageParams;
        return nextClient.getPaginated<ItemType>();
-      }
+      },
    );
  }
@@ -374,9 +428,23 @@ export class SmartRequest<T = any> {
    // Main retry loop
    for (let attempt = 0; attempt <= this._retries; attempt++) {
      try {
-        const request = new CoreRequest(this._url, this._options as any);
+        // Check if we have a Node.js stream that needs special handling
-        const response = await request.fire() as ICoreResponse<R>;
+        let requestDataFunc = null;
-        
+        if ((this._options as any).__nodeStream) {
          const nodeStream = (this._options as any).__nodeStream;
          requestDataFunc = (req: any) => {
            nodeStream.pipe(req);
          };
          // Don't delete __nodeStream yet - let CoreRequest implementations handle it
          // Node.js will use requestDataFunc, Bun/Deno will convert the stream
        }
        const request = new CoreRequest(this._url, this._options as any, requestDataFunc);
        // Clean up temporary properties after CoreRequest has been created
        delete (this._options as any).__nodeStream;
        const response = (await request.fire()) as ICoreResponse<R>;
        // Check for 429 status if rate limit handling is enabled
        if (this._rateLimitConfig && response.status === 429) {
          if (rateLimitAttempt >= this._rateLimitConfig.maxRetries) {
@@ -385,18 +453,22 @@ export class SmartRequest<T = any> {
          }
          let waitTime: number;
-          
+
-          if (this._rateLimitConfig.respectRetryAfter && response.headers['retry-after']) {
+          if (
            this._rateLimitConfig.respectRetryAfter &&
            response.headers['retry-after']
          ) {
            // Parse Retry-After header
            waitTime = parseRetryAfter(response.headers['retry-after']);
-            
+
            // Cap wait time to maxWaitTime
            waitTime = Math.min(waitTime, this._rateLimitConfig.maxWaitTime);
          } else {
            // Use exponential backoff
            waitTime = Math.min(
-              this._rateLimitConfig.fallbackDelay * Math.pow(this._rateLimitConfig.backoffFactor, rateLimitAttempt),
+              this._rateLimitConfig.fallbackDelay *
-              this._rateLimitConfig.maxWaitTime
+                Math.pow(this._rateLimitConfig.backoffFactor, rateLimitAttempt),
              this._rateLimitConfig.maxWaitTime,
            );
          }
@@ -406,14 +478,14 @@ export class SmartRequest<T = any> {
          }
          // Wait before retrying
-          await new Promise(resolve => setTimeout(resolve, waitTime));
+          await new Promise((resolve) => setTimeout(resolve, waitTime));
-          
+
          rateLimitAttempt++;
          // Decrement attempt to retry this attempt
          attempt--;
          continue;
        }
-        
+
        // Success or non-429 error response
        return response;
      } catch (error) {
@@ -425,11 +497,11 @@ export class SmartRequest<T = any> {
        }
        // Otherwise, wait before retrying
-        await new Promise(resolve => setTimeout(resolve, 1000));
+        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
@@ -1,7 +1,14 @@
 /**
 * HTTP Methods supported by the client
 */
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+export type HttpMethod =
  | 'GET'
  | 'POST'
  | 'PUT'
  | 'DELETE'
  | 'PATCH'
  | 'HEAD'
  | 'OPTIONS';
 /**
 * Response types supported by the client
@@ -30,11 +37,11 @@ export interface UrlEncodedField {
 * Retry configuration
 */
 export interface RetryConfig {
-  attempts: number;         // Number of retry attempts
+  attempts: number; // Number of retry attempts
-  initialDelay?: number;    // Initial delay in ms
+  initialDelay?: number; // Initial delay in ms
-  maxDelay?: number;        // Maximum delay in ms
+  maxDelay?: number; // Maximum delay in ms
-  factor?: number;          // Backoff factor
+  factor?: number; // Backoff factor
-  statusCodes?: number[];   // Status codes to retry on
+  statusCodes?: number[]; // Status codes to retry on
  shouldRetry?: (error: Error, attemptCount: number) => boolean;
 }
@@ -42,20 +49,20 @@ export interface RetryConfig {
 * Timeout configuration
 */
 export interface TimeoutConfig {
-  request?: number;         // Overall request timeout in ms
+  request?: number; // Overall request timeout in ms
-  connection?: number;      // Connection timeout in ms
+  connection?: number; // Connection timeout in ms
-  socket?: number;          // Socket idle timeout in ms
+  socket?: number; // Socket idle timeout in ms
-  response?: number;        // Response timeout in ms
+  response?: number; // Response timeout in ms
 }
 /**
 * Rate limit configuration for handling 429 responses
 */
 export interface RateLimitConfig {
-  maxRetries?: number;           // Maximum number of retries (default: 3)
+  maxRetries?: number; // Maximum number of retries (default: 3)
-  respectRetryAfter?: boolean;   // Respect Retry-After header (default: true)
+  respectRetryAfter?: boolean; // Respect Retry-After header (default: true)
-  maxWaitTime?: number;          // Max wait time in ms (default: 60000)
+  maxWaitTime?: number; // Max wait time in ms (default: 60000)
-  fallbackDelay?: number;        // Delay when no Retry-After header (default: 1000)
+  fallbackDelay?: number; // Delay when no Retry-After header (default: 1000)
-  backoffFactor?: number;        // Exponential backoff factor (default: 2)
+  backoffFactor?: number; // Exponential backoff factor (default: 2)
  onRateLimit?: (attempt: number, waitTime: number) => void; // Callback for rate limit events
-}
+}
--- a/ts/client/types/pagination.ts
+++ b/ts/client/types/pagination.ts
@@ -5,10 +5,10 @@ import type { ICoreResponse } from '../../core_base/types.js';
 * Pagination strategy options
 */
 export enum PaginationStrategy {
-  OFFSET = 'offset',        // Uses page & limit parameters
+  OFFSET = 'offset', // Uses page & limit parameters
-  CURSOR = 'cursor',        // Uses a cursor/token for next page
+  CURSOR = 'cursor', // Uses a cursor/token for next page
-  LINK_HEADER = 'link',     // Uses Link headers
+  LINK_HEADER = 'link', // Uses Link headers
-  CUSTOM = 'custom'         // Uses a custom pagination handler
+  CUSTOM = 'custom', // Uses a custom pagination handler
 }
 /**
@@ -16,11 +16,11 @@ export enum PaginationStrategy {
 */
 export interface OffsetPaginationConfig {
  strategy: PaginationStrategy.OFFSET;
-  pageParam?: string;       // Parameter name for page number (default: "page")
+  pageParam?: string; // Parameter name for page number (default: "page")
-  limitParam?: string;      // Parameter name for page size (default: "limit")
+  limitParam?: string; // Parameter name for page size (default: "limit")
-  startPage?: number;       // Starting page number (default: 1)
+  startPage?: number; // Starting page number (default: 1)
-  pageSize?: number;        // Number of items per page (default: 20)
+  pageSize?: number; // Number of items per page (default: 20)
-  totalPath?: string;       // JSON path to total item count (default: "total")
+  totalPath?: string; // JSON path to total item count (default: "total")
 }
 /**
@@ -28,9 +28,9 @@ export interface OffsetPaginationConfig {
 */
 export interface CursorPaginationConfig {
  strategy: PaginationStrategy.CURSOR;
-  cursorParam?: string;     // Parameter name for cursor (default: "cursor")
+  cursorParam?: string; // Parameter name for cursor (default: "cursor")
-  cursorPath?: string;      // JSON path to next cursor (default: "nextCursor")
+  cursorPath?: string; // JSON path to next cursor (default: "nextCursor")
-  hasMorePath?: string;     // JSON path to check if more items exist (default: "hasMore")
+  hasMorePath?: string; // JSON path to check if more items exist (default: "hasMore")
 }
 /**
@@ -47,21 +47,28 @@ export interface LinkPaginationConfig {
 export interface CustomPaginationConfig {
  strategy: PaginationStrategy.CUSTOM;
  hasNextPage: (response: ICoreResponse<any>) => boolean;
-  getNextPageParams: (response: ICoreResponse<any>, currentParams: Record<string, string>) => Record<string, string>;
+  getNextPageParams: (
    response: ICoreResponse<any>,
    currentParams: Record<string, string>,
  ) => Record<string, string>;
 }
 /**
 * Union type of all pagination configurations
 */
-export type TPaginationConfig = OffsetPaginationConfig | CursorPaginationConfig | LinkPaginationConfig | CustomPaginationConfig;
+export type TPaginationConfig =
  | OffsetPaginationConfig
  | CursorPaginationConfig
  | LinkPaginationConfig
  | CustomPaginationConfig;
 /**
 * Interface for a paginated response
 */
 export interface TPaginatedResponse<T> {
-  items: T[];                   // Current page items
+  items: T[]; // Current page items
-  hasNextPage: boolean;         // Whether there are more pages
+  hasNextPage: boolean; // Whether there are more pages
-  getNextPage: () => Promise<TPaginatedResponse<T>>;  // Function to get the next page
+  getNextPage: () => Promise<TPaginatedResponse<T>>; // Function to get the next page
-  getAllPages: () => Promise<T[]>;  // Function to get all remaining pages and combine
+  getAllPages: () => Promise<T[]>; // Function to get all remaining pages and combine
-  response: ICoreResponse<any>;  // Original response
+  response: ICoreResponse<any>; // Original response
-}
+}
--- a/ts/core/index.ts
+++ b/ts/core/index.ts
@@ -5,22 +5,31 @@ export * from '../core_base/types.js';
 const smartenvInstance = new plugins.smartenv.Smartenv();
-// Dynamically load the appropriate implementation
+// Dynamically load the appropriate implementation based on runtime
 let CoreRequest: any;
 let CoreResponse: any;
-if (smartenvInstance.isNode) {
+if (smartenvInstance.isDeno) {
-  // In Node.js, load the node implementation
+  // In Deno, load the Deno implementation with HttpClient-based unix socket support
  const impl = await import('../core_deno/index.js');
  CoreRequest = impl.CoreRequest;
  CoreResponse = impl.CoreResponse;
 } else if (smartenvInstance.isBun) {
  // In Bun, load the Bun implementation with native fetch unix socket support
  const impl = await import('../core_bun/index.js');
  CoreRequest = impl.CoreRequest;
  CoreResponse = impl.CoreResponse;
 } else if (smartenvInstance.isNode) {
  // In Node.js, load the Node.js implementation with native http/https unix socket support
  const modulePath = plugins.smartpath.join(
    plugins.smartpath.dirname(import.meta.url),
-    '../core_node/index.js'
+    '../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
+  // In browser, load the fetch implementation (no unix socket support)
  const impl = await import('../core_fetch/index.js');
  CoreRequest = impl.CoreRequest;
  CoreResponse = impl.CoreResponse;
--- a/ts/core_base/index.ts
+++ b/ts/core_base/index.ts
@@ -1,4 +1,4 @@
 // Core base exports - abstract classes and platform-agnostic types
 export * from './types.js';
 export * from './request.js';
-export * from './response.js';
+export * from './response.js';
--- a/ts/core_base/request.ts
+++ b/ts/core_base/request.ts
@@ -3,7 +3,10 @@ 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> {
+export abstract class CoreRequest<
  TOptions extends types.ICoreRequestOptions = types.ICoreRequestOptions,
  TResponse = any,
 > {
  /**
   * Tests if a URL is a unix socket
   */
@@ -14,10 +17,28 @@ export abstract class CoreRequest<TOptions extends types.ICoreRequestOptions = t
  /**
   * Parses socket path and route from unix socket URL
   * Handles both full URLs (http://unix:/path/to/socket:/route) and pre-stripped paths (unix:/path/to/socket:/route)
   * Returns clean file system path for socketPath (e.g., /var/run/docker.sock)
   */
  static parseUnixSocketUrl(url: string): { socketPath: string; path: string } {
    // Strip http:// or https:// prefix if present
    // This makes the method work with both full URLs and pre-stripped paths
    let cleanUrl = url;
    if (cleanUrl.startsWith('http://')) {
      cleanUrl = cleanUrl.substring('http://'.length);
    } else if (cleanUrl.startsWith('https://')) {
      cleanUrl = cleanUrl.substring('https://'.length);
    }
    // Strip unix: prefix if present to get clean file system path
    if (cleanUrl.startsWith('unix:')) {
      cleanUrl = cleanUrl.substring('unix:'.length);
    }
    // Parse the socket path and HTTP path
    // Format: /path/to/socket:/route/path
    const parseRegex = /(.*):(.*)/;
-    const result = parseRegex.exec(url);
+    const result = parseRegex.exec(cleanUrl);
    return {
      socketPath: result[1],
      path: result[2],
@@ -41,5 +62,4 @@ export abstract class CoreRequest<TOptions extends types.ICoreRequestOptions = t
   * 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
@@ -37,9 +37,9 @@ export abstract class CoreResponse<T = any> implements types.ICoreResponse<T> {
   * 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
@@ -1,7 +1,14 @@
 /**
 * HTTP Methods supported
 */
-export type THttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+export type THttpMethod =
  | 'GET'
  | 'POST'
  | 'PUT'
  | 'DELETE'
  | 'PATCH'
  | 'HEAD'
  | 'OPTIONS';
 /**
 * Response types supported
@@ -39,14 +46,14 @@ export interface ICoreRequestOptions {
  timeout?: number;
  hardDataCuttingTimeout?: number;
  autoDrain?: boolean; // Auto-drain unconsumed responses (Node.js only, default: true)
-  
+
  // 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;
@@ -73,10 +80,10 @@ export interface ICoreResponse<T = any> {
  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_bun/index.ts
+++ b/ts/core_bun/index.ts
@@ -0,0 +1,3 @@
 // Core Bun exports - Bun's native fetch implementation with unix socket support
 export * from './response.js';
 export { CoreRequest } from './request.js';
--- a/ts/core_bun/request.ts
+++ b/ts/core_bun/request.ts
@@ -0,0 +1,249 @@
 import * as types from './types.js';
 import { CoreResponse } from './response.js';
 import { CoreRequest as AbstractCoreRequest } from '../core_base/request.js';
 /**
 * Bun implementation of Core Request class using native fetch with unix socket support
 */
 export class CoreRequest extends AbstractCoreRequest<
  types.IBunRequestOptions,
  CoreResponse
 > {
  private timeoutId: ReturnType<typeof setTimeout> | null = null;
  private abortController: AbortController | null = null;
  private requestDataFunc: ((req: any) => void) | null;
  constructor(
    url: string,
    options: types.IBunRequestOptions = {},
    requestDataFunc: ((req: any) => void) | null = null,
  ) {
    super(url, options);
    this.requestDataFunc = requestDataFunc;
    // Check for unsupported Node.js-specific options
    if (options.agent) {
      throw new Error(
        'Node.js specific option (agent) is not supported in Bun implementation',
      );
    }
    // Handle Node.js stream conversion if requestDataFunc is provided
    if (requestDataFunc && (options as any).__nodeStream) {
      // Convert Node.js stream to web ReadableStream for Bun
      const nodeStream = (options as any).__nodeStream;
      // Bun can handle Node.js streams via Readable.toWeb if available
      // Or we can create a web stream that reads from the Node stream
      if (typeof (nodeStream as any).toWeb === 'function') {
        this.options.requestBody = (nodeStream as any).toWeb();
      } else {
        // Create web ReadableStream from Node.js stream
        this.options.requestBody = new ReadableStream({
          async start(controller) {
            nodeStream.on('data', (chunk: any) => {
              controller.enqueue(new Uint8Array(chunk));
            });
            nodeStream.on('end', () => {
              controller.close();
            });
            nodeStream.on('error', (err: any) => {
              controller.error(err);
            });
          },
        });
      }
    }
    // Warn if raw streaming function is provided (not supported in Bun)
    if (requestDataFunc && (options as any).__rawStreamFunc) {
      throw new Error(
        'Raw streaming with .raw() is not supported in Bun. Use .stream() with web ReadableStream instead.',
      );
    }
  }
  /**
   * Build the full URL with query parameters
   */
  private buildUrl(): string {
    // For unix sockets, we need to extract the HTTP path part
    if (CoreRequest.isUnixSocket(this.url)) {
      const { path } = CoreRequest.parseUnixSocketUrl(this.url);
      // Build URL for the HTTP request (the hostname doesn't matter for unix sockets)
      if (
        !this.options.queryParams ||
        Object.keys(this.options.queryParams).length === 0
      ) {
        return `http://localhost${path}`;
      }
      const url = new URL(`http://localhost${path}`);
      Object.entries(this.options.queryParams).forEach(([key, value]) => {
        url.searchParams.append(key, value);
      });
      return url.toString();
    }
    // Regular HTTP/HTTPS URL
    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 with Bun-specific extensions
   */
  private buildFetchOptions(): RequestInit & { unix?: string } {
    const fetchOptions: RequestInit & { unix?: string } = {
      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 unix socket
    if (CoreRequest.isUnixSocket(this.url)) {
      const { socketPath } = CoreRequest.parseUnixSocketUrl(this.url);
      fetchOptions.unix = socketPath;
    } else if (this.options.unix) {
      // Direct unix option was provided
      fetchOptions.unix = this.options.unix;
    } else if (this.options.socketPath) {
      // Legacy Node.js socketPath option - convert to Bun's unix option
      fetchOptions.unix = this.options.socketPath;
    }
    // Handle request body
    if (this.options.requestBody !== undefined) {
      if (
        typeof this.options.requestBody === 'string' ||
        this.options.requestBody instanceof ArrayBuffer ||
        this.options.requestBody instanceof Uint8Array ||
        this.options.requestBody instanceof FormData ||
        this.options.requestBody instanceof URLSearchParams ||
        this.options.requestBody instanceof ReadableStream ||
        // Check for Buffer (Bun supports Node.js Buffer)
        (typeof Buffer !== 'undefined' && this.options.requestBody instanceof Buffer)
      ) {
        fetchOptions.body = this.options.requestBody as BodyInit;
        // If streaming, we need to set duplex mode
        if (this.options.requestBody instanceof ReadableStream) {
          (fetchOptions as any).duplex = 'half';
        }
      } 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;
      this.abortController = new AbortController();
      this.timeoutId = setTimeout(() => {
        if (this.abortController) {
          this.abortController.abort();
        }
      }, timeout);
      fetchOptions.signal = this.abortController.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);
      // Clear timeout on successful response
      this.clearTimeout();
      return response;
    } catch (error) {
      // Clear timeout on error
      this.clearTimeout();
      if (error.name === 'AbortError') {
        throw new Error('Request timed out');
      }
      throw error;
    }
  }
  /**
   * Clear the timeout and abort controller
   */
  private clearTimeout(): void {
    if (this.timeoutId) {
      clearTimeout(this.timeoutId);
      this.timeoutId = null;
    }
    if (this.abortController) {
      this.abortController = null;
    }
  }
  /**
   * Static factory method to create and fire a request
   */
  static async create(
    url: string,
    options: types.IBunRequestOptions = {},
  ): 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_bun/response.ts
+++ b/ts/core_bun/response.ts
@@ -0,0 +1,81 @@
 import * as types from './types.js';
 import { CoreResponse as AbstractCoreResponse } from '../core_base/response.js';
 /**
 * Bun implementation of Core Response class that wraps native fetch Response
 */
 export class CoreResponse<T = any>
  extends AbstractCoreResponse<T>
  implements types.IBunResponse<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;
  }
  /**
   * Get the raw Response object
   */
  raw(): Response {
    return this.responseClone;
  }
 }
--- a/ts/core_bun/types.ts
+++ b/ts/core_bun/types.ts
@@ -0,0 +1,23 @@
 import * as baseTypes from '../core_base/types.js';
 // Re-export base types
 export * from '../core_base/types.js';
 /**
 * Bun-specific request options
 */
 export interface IBunRequestOptions extends baseTypes.ICoreRequestOptions {
  /**
   * Unix domain socket path for Bun's fetch
   * When provided, the request will be sent over the unix socket instead of TCP
   */
  unix?: string;
 }
 /**
 * Bun-specific response extensions
 */
 export interface IBunResponse<T = any> extends baseTypes.ICoreResponse<T> {
  // Access to raw Response object
  raw(): Response;
 }
--- a/ts/core_deno/deno.types.ts
+++ b/ts/core_deno/deno.types.ts
@@ -0,0 +1,23 @@
 /**
 * Minimal Deno type definitions for compilation in Node.js environment
 * These types are only used during build-time type checking
 * At runtime, actual Deno APIs will be available in Deno environment
 */
 declare global {
  namespace Deno {
    interface HttpClient {
      close(): void;
    }
    interface CreateHttpClientOptions {
      proxy?: {
        url: string;
      };
    }
    function createHttpClient(options: CreateHttpClientOptions): HttpClient;
  }
 }
 export {};
--- a/ts/core_deno/index.ts
+++ b/ts/core_deno/index.ts
@@ -0,0 +1,3 @@
 // Core Deno exports - Deno's native fetch implementation with unix socket support via HttpClient
 export * from './response.js';
 export { CoreRequest } from './request.js';
--- a/ts/core_deno/request.ts
+++ b/ts/core_deno/request.ts
@@ -0,0 +1,295 @@
 /// <reference path="./deno.types.ts" />
 import * as types from './types.js';
 import { CoreResponse } from './response.js';
 import { CoreRequest as AbstractCoreRequest } from '../core_base/request.js';
 /**
 * Cache for HttpClient instances keyed by socket path
 * This prevents creating multiple clients for the same socket
 */
 const httpClientCache = new Map<string, Deno.HttpClient>();
 /**
 * Deno implementation of Core Request class using native fetch with unix socket support via HttpClient
 */
 export class CoreRequest extends AbstractCoreRequest<
  types.IDenoRequestOptions,
  CoreResponse
 > {
  private timeoutId: ReturnType<typeof setTimeout> | null = null;
  private abortController: AbortController | null = null;
  private createdClient: Deno.HttpClient | null = null;
  private requestDataFunc: ((req: any) => void) | null;
  constructor(
    url: string,
    options: types.IDenoRequestOptions = {},
    requestDataFunc: ((req: any) => void) | null = null,
  ) {
    super(url, options);
    this.requestDataFunc = requestDataFunc;
    // Check for unsupported Node.js-specific options
    if (options.agent) {
      throw new Error(
        'Node.js specific option (agent) is not supported in Deno implementation',
      );
    }
    // Handle Node.js stream conversion if requestDataFunc is provided
    if (requestDataFunc && (options as any).__nodeStream) {
      // Convert Node.js stream to web ReadableStream for Deno
      const nodeStream = (options as any).__nodeStream;
      // Create web ReadableStream from Node.js stream
      this.options.requestBody = new ReadableStream({
        async start(controller) {
          nodeStream.on('data', (chunk: any) => {
            controller.enqueue(new Uint8Array(chunk));
          });
          nodeStream.on('end', () => {
            controller.close();
          });
          nodeStream.on('error', (err: any) => {
            controller.error(err);
          });
        },
      });
    }
    // Throw error if raw streaming function is provided (not supported in Deno)
    if (requestDataFunc && (options as any).__rawStreamFunc) {
      throw new Error(
        'Raw streaming with .raw() is not supported in Deno. Use .stream() with web ReadableStream instead.',
      );
    }
  }
  /**
   * Get or create an HttpClient for unix socket communication
   */
  private getHttpClient(): Deno.HttpClient | undefined {
    // If client was explicitly provided, use it
    if (this.options.client) {
      return this.options.client;
    }
    // Check if we need a unix socket client
    const socketPath = this.options.socketPath ||
      (CoreRequest.isUnixSocket(this.url)
        ? CoreRequest.parseUnixSocketUrl(this.url).socketPath
        : null);
    if (!socketPath) {
      return undefined; // Use default client
    }
    // Check cache first
    if (httpClientCache.has(socketPath)) {
      return httpClientCache.get(socketPath);
    }
    // Create new HttpClient for this socket
    const client = Deno.createHttpClient({
      proxy: {
        url: `unix://${socketPath}`,
      },
    });
    // Cache it
    httpClientCache.set(socketPath, client);
    this.createdClient = client;
    return client;
  }
  /**
   * Build the full URL with query parameters
   */
  private buildUrl(): string {
    // For unix sockets, we need to extract the HTTP path part
    if (CoreRequest.isUnixSocket(this.url)) {
      const { path } = CoreRequest.parseUnixSocketUrl(this.url);
      // Build URL for the HTTP request (the hostname doesn't matter for unix sockets)
      if (
        !this.options.queryParams ||
        Object.keys(this.options.queryParams).length === 0
      ) {
        return `http://localhost${path}`;
      }
      const url = new URL(`http://localhost${path}`);
      Object.entries(this.options.queryParams).forEach(([key, value]) => {
        url.searchParams.append(key, value);
      });
      return url.toString();
    }
    // Regular HTTP/HTTPS URL
    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 & { client?: Deno.HttpClient } {
    const fetchOptions: RequestInit & { client?: Deno.HttpClient } = {
      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,
    };
    // Set the HttpClient (for unix sockets or custom configurations)
    const client = this.getHttpClient();
    if (client) {
      fetchOptions.client = client;
    }
    // Handle request body
    if (this.options.requestBody !== undefined) {
      if (
        typeof this.options.requestBody === 'string' ||
        this.options.requestBody instanceof ArrayBuffer ||
        this.options.requestBody instanceof Uint8Array ||
        this.options.requestBody instanceof FormData ||
        this.options.requestBody instanceof URLSearchParams ||
        this.options.requestBody instanceof ReadableStream ||
        // Check for Buffer (Deno provides Buffer via Node.js compatibility)
        (typeof Buffer !== 'undefined' && this.options.requestBody instanceof Buffer)
      ) {
        fetchOptions.body = this.options.requestBody as BodyInit;
        // If streaming, we need to set duplex mode
        if (this.options.requestBody instanceof ReadableStream) {
          (fetchOptions as any).duplex = 'half';
        }
      } 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;
      this.abortController = new AbortController();
      this.timeoutId = setTimeout(() => {
        if (this.abortController) {
          this.abortController.abort();
        }
      }, timeout);
      fetchOptions.signal = this.abortController.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);
      // Clear timeout on successful response
      this.clearTimeout();
      return response;
    } catch (error) {
      // Clear timeout on error
      this.clearTimeout();
      if (error.name === 'AbortError') {
        throw new Error('Request timed out');
      }
      throw error;
    }
  }
  /**
   * Clear the timeout and abort controller
   * Note: We don't close the HttpClient here as it's cached for reuse
   */
  private clearTimeout(): void {
    if (this.timeoutId) {
      clearTimeout(this.timeoutId);
      this.timeoutId = null;
    }
    if (this.abortController) {
      this.abortController = null;
    }
  }
  /**
   * Static factory method to create and fire a request
   */
  static async create(
    url: string,
    options: types.IDenoRequestOptions = {},
  ): Promise<CoreResponse> {
    const request = new CoreRequest(url, options);
    return request.fire();
  }
  /**
   * Static method to clear the HttpClient cache
   * Call this when you want to force new clients to be created
   */
  static clearClientCache(): void {
    httpClientCache.forEach((client) => {
      client.close();
    });
    httpClientCache.clear();
  }
 }
 /**
 * Convenience exports for backward compatibility
 */
 export const isUnixSocket = CoreRequest.isUnixSocket;
 export const parseUnixSocketUrl = CoreRequest.parseUnixSocketUrl;
--- a/ts/core_deno/response.ts
+++ b/ts/core_deno/response.ts
@@ -0,0 +1,81 @@
 import * as types from './types.js';
 import { CoreResponse as AbstractCoreResponse } from '../core_base/response.js';
 /**
 * Deno implementation of Core Response class that wraps native fetch Response
 */
 export class CoreResponse<T = any>
  extends AbstractCoreResponse<T>
  implements types.IDenoResponse<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;
  }
  /**
   * Get the raw Response object
   */
  raw(): Response {
    return this.responseClone;
  }
 }
--- a/ts/core_deno/types.ts
+++ b/ts/core_deno/types.ts
@@ -0,0 +1,24 @@
 /// <reference path="./deno.types.ts" />
 import * as baseTypes from '../core_base/types.js';
 // Re-export base types
 export * from '../core_base/types.js';
 /**
 * Deno-specific request options
 */
 export interface IDenoRequestOptions extends baseTypes.ICoreRequestOptions {
  /**
   * Deno HttpClient instance for custom configurations including unix sockets
   * If not provided and socketPath is specified, a client will be created automatically
   */
  client?: Deno.HttpClient;
 }
 /**
 * Deno-specific response extensions
 */
 export interface IDenoResponse<T = any> extends baseTypes.ICoreResponse<T> {
  // Access to raw Response object
  raw(): Response;
 }
--- a/ts/core_fetch/index.ts
+++ b/ts/core_fetch/index.ts
@@ -1,3 +1,3 @@
 // Core fetch exports - native fetch implementation
 export * from './response.js';
-export { CoreRequest } from './request.js';
+export { CoreRequest } from './request.js';
--- a/ts/core_fetch/request.ts
+++ b/ts/core_fetch/request.ts
@@ -5,13 +5,21 @@ import { CoreRequest as AbstractCoreRequest } from '../core_base/request.js';
 /**
 * Fetch-based implementation of Core Request class
 */
-export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions, CoreResponse> {
+export class CoreRequest extends AbstractCoreRequest<
  types.ICoreRequestOptions,
  CoreResponse
 > {
  private timeoutId: ReturnType<typeof setTimeout> | null = null;
  private abortController: AbortController | null = null;
  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');
+      throw new Error(
        'Node.js specific options (agent, socketPath) are not supported in browser/fetch implementation',
      );
    }
  }
@@ -19,7 +27,10 @@ export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions,
   * Build the full URL with query parameters
   */
  private buildUrl(): string {
-    if (!this.options.queryParams || Object.keys(this.options.queryParams).length === 0) {
+    if (
      !this.options.queryParams ||
      Object.keys(this.options.queryParams).length === 0
    ) {
      return this.url;
    }
@@ -50,12 +61,22 @@ export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions,
    // Handle request body
    if (this.options.requestBody !== undefined) {
-      if (typeof this.options.requestBody === 'string' || 
+      if (
-          this.options.requestBody instanceof ArrayBuffer ||
+        typeof this.options.requestBody === 'string' ||
-          this.options.requestBody instanceof FormData ||
+        this.options.requestBody instanceof ArrayBuffer ||
-          this.options.requestBody instanceof URLSearchParams ||
+        this.options.requestBody instanceof Uint8Array ||
-          this.options.requestBody instanceof ReadableStream) {
+        this.options.requestBody instanceof FormData ||
-        fetchOptions.body = this.options.requestBody;
+        this.options.requestBody instanceof URLSearchParams ||
        this.options.requestBody instanceof ReadableStream ||
        // Check for Buffer (Node.js polyfills in browser may provide this)
        (typeof Buffer !== 'undefined' && this.options.requestBody instanceof Buffer)
      ) {
        fetchOptions.body = this.options.requestBody as BodyInit;
        // If streaming, we need to set duplex mode
        if (this.options.requestBody instanceof ReadableStream) {
          (fetchOptions as any).duplex = 'half';
        }
      } else {
        // Convert objects to JSON
        fetchOptions.body = JSON.stringify(this.options.requestBody);
@@ -66,7 +87,10 @@ export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions,
          if (!fetchOptions.headers.has('Content-Type')) {
            fetchOptions.headers.set('Content-Type', 'application/json');
          }
-        } else if (typeof fetchOptions.headers === 'object' && !Array.isArray(fetchOptions.headers)) {
+        } 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';
@@ -77,10 +101,15 @@ export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions,
    // Handle timeout
    if (this.options.timeout || this.options.hardDataCuttingTimeout) {
-      const timeout = this.options.hardDataCuttingTimeout || this.options.timeout;
+      const timeout =
-      const controller = new AbortController();
+        this.options.hardDataCuttingTimeout || this.options.timeout;
-      setTimeout(() => controller.abort(), timeout);
+      this.abortController = new AbortController();
-      fetchOptions.signal = controller.signal;
+      this.timeoutId = setTimeout(() => {
        if (this.abortController) {
          this.abortController.abort();
        }
      }, timeout);
      fetchOptions.signal = this.abortController.signal;
    }
    return fetchOptions;
@@ -100,11 +129,15 @@ export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions,
  async fireCore(): Promise<Response> {
    const url = this.buildUrl();
    const options = this.buildFetchOptions();
-    
+
    try {
      const response = await fetch(url, options);
      // Clear timeout on successful response
      this.clearTimeout();
      return response;
    } catch (error) {
      // Clear timeout on error
      this.clearTimeout();
      if (error.name === 'AbortError') {
        throw new Error('Request timed out');
      }
@@ -112,12 +145,25 @@ export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions,
    }
  }
  /**
   * Clear the timeout and abort controller
   */
  private clearTimeout(): void {
    if (this.timeoutId) {
      clearTimeout(this.timeoutId);
      this.timeoutId = null;
    }
    if (this.abortController) {
      this.abortController = null;
    }
  }
  /**
   * Static factory method to create and fire a request
   */
  static async create(
    url: string,
-    options: types.ICoreRequestOptions = {}
+    options: types.ICoreRequestOptions = {},
  ): Promise<CoreResponse> {
    const request = new CoreRequest(url, options);
    return request.fire();
@@ -128,4 +174,4 @@ export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions,
 * Convenience exports for backward compatibility
 */
 export const isUnixSocket = CoreRequest.isUnixSocket;
-export const parseUnixSocketUrl = CoreRequest.parseUnixSocketUrl;
+export const parseUnixSocketUrl = CoreRequest.parseUnixSocketUrl;
--- a/ts/core_fetch/response.ts
+++ b/ts/core_fetch/response.ts
@@ -4,7 +4,10 @@ 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> {
+export class CoreResponse<T = any>
  extends AbstractCoreResponse<T>
  implements types.IFetchResponse<T>
 {
  private response: Response;
  private responseClone: Response;
@@ -20,12 +23,12 @@ export class CoreResponse<T = any> extends AbstractCoreResponse<T> implements ty
    // 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) => {
@@ -69,17 +72,10 @@ export class CoreResponse<T = any> extends AbstractCoreResponse<T> implements ty
    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
@@ -7,9 +7,6 @@ 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
@@ -1,3 +1,3 @@
 // Core exports
 export * from './response.js';
-export { CoreRequest } from './request.js';
+export { CoreRequest } from './request.js';
--- a/ts/core_node/plugins.ts
+++ b/ts/core_node/plugins.ts
@@ -3,8 +3,9 @@ import * as fs from 'fs';
 import * as http from 'http';
 import * as https from 'https';
 import * as path from 'path';
 import * as stream from 'stream';
-export { http, https, fs, path };
+export { http, https, fs, path, stream };
 // pushrocks scope
 import * as smartpromise from '@push.rocks/smartpromise';
@@ -17,4 +18,4 @@ import { HttpAgent, HttpsAgent } from 'agentkeepalive';
 const agentkeepalive = { HttpAgent, HttpsAgent };
 import formData from 'form-data';
-export { agentkeepalive, formData };
+export { agentkeepalive, formData };
--- a/ts/core_node/request.ts
+++ b/ts/core_node/request.ts
@@ -29,21 +29,33 @@ const httpsAgentKeepAliveFalse = new plugins.agentkeepalive.HttpsAgent({
 /**
 * Node.js implementation of Core Request class that handles all HTTP/HTTPS requests
 */
-export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions, CoreResponse> {
+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
+    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 || 
+    if (
-        options.referrer || options.referrerPolicy || options.integrity) {
+      options.credentials ||
-      throw new Error('Fetch API specific options (credentials, mode, cache, redirect, referrer, referrerPolicy, integrity) are not supported in Node.js implementation');
+      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',
      );
    }
  }
@@ -65,7 +77,7 @@ export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions,
    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);
@@ -74,7 +86,7 @@ export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions,
    // Handle unix socket URLs
    if (CoreRequest.isUnixSocket(this.url)) {
-      const { socketPath, path } = CoreRequest.parseUnixSocketUrl(this.options.path);
+      const { socketPath, path } = CoreRequest.parseUnixSocketUrl(this.url);
      this.options.socketPath = socketPath;
      this.options.path = path;
    }
@@ -83,25 +95,33 @@ export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions,
    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;
+        this.options.agent =
          parsedUrl.protocol === 'https:' ? httpsAgent : httpAgent;
      } else if (this.options.keepAlive === false) {
-        this.options.agent = parsedUrl.protocol === 'https:' ? httpsAgentKeepAliveFalse : httpAgentKeepAliveFalse;
+        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;
+    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`);
+      throw new Error(
        `The request to ${this.url} is missing a viable protocol. Must be http or https`,
      );
    }
    // Perform the request
    let timeoutId: NodeJS.Timeout | null = null;
    const request = requestModule.request(this.options, async (response) => {
      // Handle hard timeout
      if (this.options.hardDataCuttingTimeout) {
-        setTimeout(() => {
+        timeoutId = setTimeout(() => {
          response.destroy();
          done.reject(new Error('Request timed out'));
        }, this.options.hardDataCuttingTimeout);
@@ -111,19 +131,34 @@ export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions,
      done.resolve(response);
    });
    // Set request timeout (Node.js built-in timeout)
    if (this.options.timeout) {
      request.setTimeout(this.options.timeout, () => {
        request.destroy();
        done.reject(new Error('Request timed out'));
      });
    }
    // Write request body
    if (this.options.requestBody) {
      if (this.options.requestBody instanceof plugins.formData) {
        this.options.requestBody.pipe(request).on('finish', () => {
          request.end();
        });
      } else if (this.options.requestBody instanceof ReadableStream) {
        // Convert web ReadableStream to Node.js Readable stream
        const nodeStream = plugins.stream.Readable.fromWeb(this.options.requestBody as any);
        nodeStream.pipe(request).on('finish', () => {
          request.end();
        });
      } else {
        // Write body as-is - caller is responsible for serialization
-        const bodyData = typeof this.options.requestBody === 'string' 
+        const bodyData =
-          ? this.options.requestBody 
+          typeof this.options.requestBody === 'string'
          : this.options.requestBody instanceof Buffer 
            ? this.options.requestBody
-            : JSON.stringify(this.options.requestBody); // Still stringify for backward compatibility
+            : this.options.requestBody instanceof Buffer
              ? this.options.requestBody
              : JSON.stringify(this.options.requestBody); // Still stringify for backward compatibility
        request.write(bodyData);
        request.end();
      }
@@ -137,11 +172,23 @@ export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions,
    request.on('error', (e) => {
      console.error(e);
      request.destroy();
      // Clear timeout on error
      if (timeoutId) {
        clearTimeout(timeoutId);
        timeoutId = null;
      }
      done.reject(e);
    });
    // Get response and handle response errors
    const response = await done.promise;
    // Clear timeout on successful response
    if (timeoutId) {
      clearTimeout(timeoutId);
      timeoutId = null;
    }
    response.on('error', (err) => {
      console.error(err);
      response.destroy();
@@ -155,7 +202,7 @@ export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions,
   */
  static async create(
    url: string,
-    options: types.ICoreRequestOptions = {}
+    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
@@ -5,7 +5,10 @@ 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> {
+export class CoreResponse<T = any>
  extends AbstractCoreResponse<T>
  implements types.INodeResponse<T>
 {
  private incomingMessage: plugins.http.IncomingMessage;
  private bodyBufferPromise: Promise<Buffer> | null = null;
  private _autoDrainTimeout: NodeJS.Immediate | null = null;
@@ -17,7 +20,11 @@ export class CoreResponse<T = any> extends AbstractCoreResponse<T> implements ty
  public readonly headers: plugins.http.IncomingHttpHeaders;
  public readonly url: string;
-  constructor(incomingMessage: plugins.http.IncomingMessage, url: string, options: types.ICoreRequestOptions = {}) {
+  constructor(
    incomingMessage: plugins.http.IncomingMessage,
    url: string,
    options: types.ICoreRequestOptions = {},
  ) {
    super();
    this.incomingMessage = incomingMessage;
    this.url = url;
@@ -25,14 +32,16 @@ export class CoreResponse<T = any> extends AbstractCoreResponse<T> implements ty
    this.statusText = incomingMessage.statusMessage || '';
    this.ok = this.status >= 200 && this.status < 300;
    this.headers = incomingMessage.headers;
-    
+
    // Auto-drain unconsumed streams to prevent socket hanging
    // This prevents keep-alive sockets from timing out when response bodies aren't consumed
    // Default to true if not specified
    if (options.autoDrain !== false) {
      this._autoDrainTimeout = setImmediate(() => {
        if (!this.consumed && !this.incomingMessage.readableEnded) {
-          console.log(`Auto-draining unconsumed response body for ${this.url} (status: ${this.status})`);
+          console.log(
            `Auto-draining unconsumed response body for ${this.url} (status: ${this.status})`,
          );
          this.incomingMessage.resume(); // Drain without processing
        }
      });
@@ -48,7 +57,7 @@ export class CoreResponse<T = any> extends AbstractCoreResponse<T> implements ty
      clearImmediate(this._autoDrainTimeout);
      this._autoDrainTimeout = null;
    }
-    
+
    super.ensureNotConsumed();
  }
@@ -57,22 +66,22 @@ export class CoreResponse<T = any> extends AbstractCoreResponse<T> implements ty
   */
  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);
    });
@@ -85,7 +94,7 @@ export class CoreResponse<T = any> extends AbstractCoreResponse<T> implements ty
  async json(): Promise<T> {
    const buffer = await this.collectBody();
    const text = buffer.toString('utf-8');
-    
+
    try {
      return JSON.parse(text);
    } catch (error) {
@@ -106,7 +115,12 @@ export class CoreResponse<T = any> extends AbstractCoreResponse<T> implements ty
   */
  async arrayBuffer(): Promise<ArrayBuffer> {
    const buffer = await this.collectBody();
-    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    const sliced = buffer.buffer.slice(
      buffer.byteOffset,
      buffer.byteOffset + buffer.byteLength,
    );
    // Ensure we return ArrayBuffer, not SharedArrayBuffer
    return sliced instanceof ArrayBuffer ? sliced : new ArrayBuffer(0);
  }
  /**
@@ -114,42 +128,16 @@ export class CoreResponse<T = any> extends AbstractCoreResponse<T> implements ty
   */
  stream(): ReadableStream<Uint8Array> | null {
    this.ensureNotConsumed();
-    
+
-    // Convert Node.js stream to web stream
+    // Convert Node.js stream to web stream using Readable.toWeb()
-    // In Node.js 16.5+ we can use Readable.toWeb()
+    // This creates a proper Node.js-compatible web stream that works with Readable.fromWeb()
    if (this.incomingMessage.readableEnded || this.incomingMessage.destroyed) {
      return null;
    }
-    
+
-    // Create a web ReadableStream from the Node.js stream
+    // Use Readable.toWeb() to convert Node.js stream to web stream (Node.js 16.5+)
-    const nodeStream = this.incomingMessage;
+    // The returned type is automatically Node.js ReadableStream which is compatible with Readable.fromWeb()
-    return new ReadableStream<Uint8Array>({
+    return plugins.stream.Readable.toWeb(this.incomingMessage) as any;
      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;
  }
  /**
@@ -158,5 +146,4 @@ export class CoreResponse<T = any> extends AbstractCoreResponse<T> implements ty
  raw(): plugins.http.IncomingMessage {
    return this.incomingMessage;
  }
-
+}
 }
--- a/ts/core_node/types.ts
+++ b/ts/core_node/types.ts
@@ -7,7 +7,8 @@ export * from '../core_base/types.js';
 /**
 * Extended IncomingMessage with body property (legacy compatibility)
 */
-export interface IExtendedIncomingMessage<T = any> extends plugins.http.IncomingMessage {
+export interface IExtendedIncomingMessage<T = any>
  extends plugins.http.IncomingMessage {
  body: T;
 }
@@ -15,9 +16,6 @@ export interface IExtendedIncomingMessage<T = any> extends plugins.http.Incoming
 * 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
@@ -7,4 +7,4 @@ export type { ICoreRequestOptions, ICoreResponse } from './core_base/types.js';
 // Default export for easier importing
 import { SmartRequest } from './client/smartrequest.js';
-export default SmartRequest;
+export default SmartRequest;
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -6,9 +6,9 @@
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "esModuleInterop": true,
-    "verbatimModuleSyntax": true
+    "verbatimModuleSyntax": true,
    "baseUrl": ".",
    "paths": {}
  },
-  "exclude": [
+  "exclude": ["dist_*/**/*.d.ts"]
    "dist_*/**/*.d.ts"
  ]
 }
Author	SHA1	Message	Date
Juergen Kunz	980675ea05	v5.0.1 Some checks failed Default (tags) / security (push) Successful in 4s Details Default (tags) / test (push) Failing after 48s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-17 14:37:09 +00:00
Juergen Kunz	15819d8a23	fix(test): Enable --logfile in test script and bump @git.zone/tstest to ^2.8.2	2025-11-17 14:37:08 +00:00
Juergen Kunz	bc71d2e5a8	v5.0.0 Some checks failed Default (tags) / security (push) Successful in 14s Details Default (tags) / test (push) Failing after 1m12s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-17 14:18:58 +00:00
Juergen Kunz	0cf48b3688	BREAKING CHANGE(client/streaming): Unify streaming APIs: remove raw()/streamNode() and standardize on web ReadableStream across runtimes	2025-11-17 14:18:58 +00:00
Juergen Kunz	1305b92ebe	v4.4.2 Some checks failed Default (tags) / security (push) Successful in 5s Details Default (tags) / test (push) Failing after 1m41s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-16 23:41:24 +00:00
Juergen Kunz	8b52ca1021	fix(core_base/request): Strip unix: prefix when parsing unix socket URLs so socketPath is a clean filesystem path	2025-11-16 23:41:24 +00:00
Juergen Kunz	e14800f077	v4.4.1 Some checks failed Default (tags) / security (push) Successful in 13s Details Default (tags) / test (push) Failing after 35s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-16 23:22:58 +00:00
Juergen Kunz	9f3503704b	fix(core_node): Fix unix socket URL parsing and handling in CoreRequest	2025-11-16 23:22:58 +00:00
Juergen Kunz	f3ba77050a	v4.4.0 Some checks failed Default (tags) / security (push) Successful in 13s Details Default (tags) / test (push) Failing after 36s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-16 22:50:19 +00:00
Juergen Kunz	6211acd60b	feat(core): Add Bun and Deno runtime support, unify core loader, unix-socket support and cross-runtime streaming/tests	2025-11-16 22:50:19 +00:00
Juergen Kunz	32332309dc	v4.3.8 Some checks failed Default (tags) / security (push) Successful in 13s Details Default (tags) / test (push) Failing after 37s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-16 21:55:40 +00:00
Juergen Kunz	9d29bd92da	fix(core): Ensure correct ArrayBuffer return, fix fetch body typing, reorganize node-only tests, and bump tsbuild devDependency	2025-11-16 21:55:40 +00:00
Juergen Kunz	6d148bb59e	4.3.7 Some checks failed Default (tags) / security (push) Successful in 10s Details Default (tags) / test (push) Failing after 36s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-11-01 15:53:47 +00:00
Juergen Kunz	e0f586693c	fix(ci): Update dependencies, add deno.lock, and reorganize tests for browser and Node environments	2025-11-01 15:53:47 +00:00
Juergen Kunz	df28cd4778	4.3.6 Some checks failed Default (tags) / security (push) Successful in 4s Details Default (tags) / test (push) Successful in 43s Details Default (tags) / release (push) Failing after 29s Details Default (tags) / metadata (push) Successful in 54s Details	2025-10-26 14:12:38 +00:00
Juergen Kunz	f49cbd2b6a	fix(ci): Use .npmrc for registry authentication in Gitea workflow and add conditional npmjs publish	2025-10-26 14:12:37 +00:00
Juergen Kunz	984b53cba2	4.3.5 Some checks failed Default (tags) / security (push) Successful in 11s Details Default (tags) / test (push) Successful in 47s Details Default (tags) / release (push) Failing after 29s Details Default (tags) / metadata (push) Successful in 57s Details	2025-10-26 14:07:55 +00:00
Juergen Kunz	4c55243646	fix(workflows): Remove npmci wrappers from CI workflows and use pnpm/npm CLI directly	2025-10-26 14:07:55 +00:00
Juergen Kunz	49cfcaedd1	4.3.4 Some checks failed Default (tags) / security (push) Successful in 34s Details Default (tags) / test (push) Successful in 1m1s Details Default (tags) / release (push) Failing after 46s Details Default (tags) / metadata (push) Successful in 56s Details	2025-10-25 17:16:01 +00:00
Juergen Kunz	3996a69f91	fix(ci): Fix Gitea workflow publish invocation to run npm publish via npmci command	2025-10-25 17:16:01 +00:00
Juergen Kunz	629f6dd425	4.3.3 Some checks failed Default (tags) / security (push) Successful in 43s Details Default (tags) / test (push) Successful in 1m5s Details Default (tags) / release (push) Failing after 48s Details Default (tags) / metadata (push) Successful in 57s Details	2025-10-25 17:09:33 +00:00
Juergen Kunz	d141ceeaf7	fix(ci): Improve Gitea release workflow: install deps, configure Gitea npm registry, and optionally publish to npmjs.org	2025-10-25 17:09:33 +00:00
Juergen Kunz	7d3c94cae6	4.3.2 Some checks failed Default (tags) / security (push) Successful in 58s Details Default (tags) / test (push) Successful in 1m45s Details Default (tags) / release (push) Failing after 59s Details Default (tags) / metadata (push) Successful in 1m0s Details	2025-10-17 09:09:12 +00:00
Juergen Kunz	5bae452365	fix(core): Remove stray console.log from core module	2025-10-17 09:09:12 +00:00
Juergen Kunz	ffabcf7bdb	4.3.1 Some checks failed Default (tags) / security (push) Successful in 42s Details Default (tags) / test (push) Successful in 1m2s Details Default (tags) / release (push) Failing after 43s Details Default (tags) / metadata (push) Successful in 53s Details	2025-08-19 01:36:44 +00:00
Juergen Kunz	361d97f440	fix(core): Improve streaming support and timeout handling; add browser streaming & timeout tests and README clarifications	2025-08-19 01:36:44 +00:00
Juergen Kunz	35867d9148	feat(response): Add streamNode() method for Node.js stream support; update tests	2025-08-19 01:20:19 +00:00
Juergen Kunz	d455a34632	4.3.0 Some checks failed Default (tags) / security (push) Successful in 41s Details Default (tags) / test (push) Successful in 59s Details Default (tags) / release (push) Failing after 44s Details Default (tags) / metadata (push) Successful in 54s Details	2025-08-18 22:29:24 +00:00
Juergen Kunz	9c5a939499	feat(client/smartrequest): Add streaming and raw buffer support to SmartRequest (buffer, stream, raw); update docs and tests	2025-08-18 22:29:24 +00:00
Juergen Kunz	7b2081dc4d	4.2.2 Some checks failed Default (tags) / security (push) Successful in 43s Details Default (tags) / test (push) Successful in 57s Details Default (tags) / release (push) Failing after 43s Details Default (tags) / metadata (push) Successful in 56s Details	2025-08-18 00:21:15 +00:00
Juergen Kunz	ee750dea58	fix(client): Fix CI configuration, prevent socket hangs with auto-drain, and apply various client/core TypeScript fixes and test updates	2025-08-18 00:21:14 +00:00