update

Reviewed-on: #11

.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+package.json
+package-lock.json

AI_prompt.md

@@ -0,0 +1,172 @@
+Consider the following scenarios:
+Scenario 1: The "Command & Control" Loop (Low Latency)Focus: Small payloads, Core NATS, bi-directional JSON.The Action: A user on a JavaScript dashboard clicks a "Start Simulation" button. This sends a JSON configuration (parameters like step_size and iterations) to Julia.The Flow: * JS (Sender): Recognizes the message is small ($< 10KB$). Packages it as a direct transport JSON envelope.Julia (Receiver): Listens on the NATS subject, decodes the JSON, and immediately acknowledges receipt with a "Running" status.Project Requirement Met: Fast, low-overhead communication for control signals without involving the fileserver.
+Scenario 2: The "Deep Dive" Analysis (High Bandwidth)Focus: Large Arrow tables, Claim-Check pattern, Julia to JS.The Action: Julia finishes a heavy computation and produces a 500MB DataFrame with 10 million rows. It needs to send this to the JS frontend for visualization (e.g., using Perspective.js or D3).The Flow:Julia (Sender): Converts the DataFrame to an Arrow IPC stream. It sees the size is $> 1MB$, so it uploads the bytes to the HTTP fileserver. It then publishes a NATS message with transport: "link" and the URL.JS (Receiver): Receives the URL, fetches the data via fetch(), and uses tableFromIPC() to load the data into memory with zero-copy.Project Requirement Met: Handling massive datasets that exceed NATS message limits while maintaining data integrity across languages.
+Scenario 3: Live Audio/Signal Processing (Multimedia & Metadata)Focus: Raw binary, bi-directional streaming, NATS Headers.The Action: The JS client captures a 2-second "chunk" of microphone audio. It needs Julia to perform a Fast Fourier Transform (FFT) or AI transcription.The Flow:JS (Sender): Sends the raw binary WAV/PCM data. It uses NATS Headers to store the metadata ($fs = 44.1kHz$, $channels = 1$) to keep the payload purely binary.Julia (Receiver): Processes the audio and sends back a JSON result (the transcription) and an Arrow Table (the frequency spectrum data).Project Requirement Met: Bi-directional flow involving mixed media (Audio) and technical results (Arrow).
+Scenario 4: The "Catch-Up" (Persistence & JetStream)Focus: NATS JetStream, late-joining consumers, state sync.The Action: Julia is constantly publishing "System Health" updates. The JS dashboard is closed for 10 minutes. When the user re-opens the dashboard, they need to see the last 10 minutes of history.The Flow:NATS (Server): Uses a JetStream with a Limits retention policy.JS (Consumer): Connects and requests a "Replay" from the last 10 minutes. It receives a mix of direct (small updates) and link (historical snapshots) messages.Project Requirement Met: Temporal decoupling—consumers can receive data that was sent while they were offline.
+
+Role: Principal Systems Architect & Lead Software Engineer.Objective: Implement a high-performance, bi-directional data bridge between a Julia service and a JavaScript (Node.js) service using NATS (Core & JetStream).⚠️ STRICT ARCHITECTURAL CONSTRAINTS (Non-Negotiable)Transport Strategy (Claim-Check Pattern):Direct Path: If payload is < 1MB, send data directly via NATS inside the message envelope (Base64 encoded).Link Path: If payload is > 1MB, upload to a shared HTTP fileserver/store. The NATS message must only contain the metadata and the download URL.Tabular Data Format: * MUST use Apache Arrow IPC Stream for all tables/DataFrames. No CSV or standard JSON-serialization of tables allowed.System Symmetry: * Both services must function as Producers AND Consumers.Modular Elegance: * Implementation must be abstracted into a SmartSend function and a SmartReceive handler. The developer calling these functions should not need to care if the data is going via NATS direct or HTTP link.Technical Stack & Use CasesJulia: NATS.jl, Arrow.jl, JSON3.jl, HTTP.jl.Node.js: nats.js, apache-arrow.Scenarios to Support: * Large Data: Sending a 500MB Arrow table from Julia $\rightarrow$ JS.Media: Sending a 5MB WAV file from JS $\rightarrow$ Julia.Signals: Sending small JSON control commands ($< 10KB$) directly via NATS.Implementation Requirements1. Unified JSON Envelope:Define a schema containing: correlation_id (UUID), type (table/binary/json), transport (direct/link), payload (if direct), and url (if link).2. The Julia Module:Implement SmartSend(subject, data, type): Handles Arrow serialization to an IOBuffer, checks size, and manages HTTP uploads for large blobs.Implement SmartReceive(msg): Parses envelope, handles the HTTP fetch with Exponential Backoff (to avoid race conditions), and restores the DataFrame.Include a basic HTTP.listen server to serve as the temporary storage.3. The JavaScript Module:Implement a symmetric SmartSend using nats.js and apache-arrow.Implement a JetStream Pull Consumer for SmartReceive to ensure backpressure and memory safety.4. Performance & Reliability:Demonstrate "Zero-Copy" reading of the Arrow IPC stream on the JS side.Log the correlation_id at every stage for distributed tracing.
+
+
+
+
+
+
+
+Create a walkthrough for Julia service-A service sending a mix-content chat message to Julia service-B. the chat message must includes 
+
+
+
+
+
+I updated the following:
+- NATSBridge.jl. Essentially I add NATS_connection keyword and new publish_message function to support the keyword. 
+Use them and ONLY them as ground truth.
+Then update the following files accordingly:
+- architecture.md
+- implementation.md
+
+All API should be semantically consistent and naming should be consistent across the board.
+
+
+
+
+
+
+
+
+
+Task: Update NATSBridge.js to reflect recent changes in NATSBridge.jl and docs
+Context: NATSBridge.jl and docs has been updated.
+Requirements:
+Source of Truth: Treat the updated NATSBridge.jl and docs as the definitive source.
+API Consistency: Ensure the Main Package API (e.g., smartsend(), publish_message()) uses consistent naming across all three supported languages.
+Ecosystem Variance: Low-level native functions (e.g., NATS.connect(), JSON.read()) should follow the conventions of the specific language ecosystem and do not require cross-language consistency.
+
+
+
+
+
+
+
+I'm expanding this Julia package (NATSBridge) into a cross-platform project by adding a JavaScript and Python/MicroPython implementation. To ensure accuracy, the Julia src directory will serve as the ground truth, as the documentation may be outdated.
+
+My goal is to maintain interface parity at the high-level API for a consistent user experience, while ensuring the low-level implementation adheres strictly to the idiomatic conventions of each respective language (e.g., multiple dispatch in Julia vs. asynchronous, prototype, or class-based patterns in JS and Python/MicroPython)
+
+Now, help me do the following:
+1) check architecture.md for any mistake.
+
+
+
+
+Help me expands this Julia package (NATSBridge) into a cross-platform project by adding a JavaScript and Python/MicroPython implementation. To ensure accuracy,  NATSBridge.jl will serve as the ground truth, as the documentation may be outdated.
+
+My goal is to maintain interface parity at the high-level API for a consistent user experience, while ensuring the low-level implementation adheres strictly to the idiomatic conventions of each respective language (e.g., multiple dispatch in Julia vs. asynchronous, prototype, or class-based patterns in JS and Python/MicroPython)
+
+Now do the following:
+1) check docs to see if there is any mistake.
+
+
+
+
+
+I'm expanding this Julia package (NATSBridge) into a cross-platform project by adding 
+a JavaScript, Python and MicroPython implementation. 
+The following will serve as the ground truth:
+- test_julia_mix_payloads_sender.jl
+- NATSBridge.jl
+- test_julia_mix_payloads_receiver.jl
+- architecture.md
+
+My goal is to maintain interface parity at the high-level API for a consistent user experience, 
+while ensuring the low-level implementation adheres strictly to the idiomatic conventions of each 
+respective language (e.g., multiple dispatch in Julia vs. asynchronous, prototype, or class-based 
+patterns in JS, Python and MicroPython)
+
+Now, help me do the following:
+1) Check whether natsbridge.js needs update or it already up to date.
+
+
+
+
+
+
+
+# ---------------------------------------------- 100 --------------------------------------------- #
+
+Got it — let’s rebuild your table in my own teaching style, keeping it crisp, intuitive, and easy for students to grasp. I’ll emphasize **purpose, audience, format, example, and KPI** in a way that flows like a story of how projects move from idea → contract → design → code → review → operations.
+
+---
+
+### SDD + GitOps Documentation Framework
+
+| Document        | Purpose (Rationale) | Primary Audience | Format / Content | Example (SaaS Context) | Measurement (KPI) |
+|-----------------|---------------------|-----------------|------------------|------------------------|-------------------|
+| **Requirements** | Capture the **business intent** — why we’re building this and what success looks like. Defines boundaries and user‑visible outcomes. | Stakeholders, Product Owners, Lead Developers | User stories, PRDs, acceptance criteria, non‑functional constraints. | “System must process tabular data from Julia to SvelteKit UI with <200ms latency for 5‑member teams.” | 95% of requests complete <200ms (synthetic monitoring). |
+| **Specification** | The **technical contract** — precise rules for inputs, outputs, and data shape. Ensures consistency across dev and test. | Developers, QA Engineers, CI/CD pipelines | OpenAPI, Protobuf, AsyncAPI. Endpoint definitions, schemas, error codes. | `contract.yaml` defining a NATS subject that accepts Arrow streams with snake_case headers. | 100% of messages validated against spec (CI block rate). |
+| **Architecture** | The **blueprint** — how components fit together, interact, and scale. Guides system structure and trade‑offs. | Architects, Senior Developers, DevOps | C4 diagrams, Mermaid.js, component/network/storage models. | Diagram showing 6‑node cluster routing traffic via Caddy → Node.js API → Julia pods. | 100% of major decisions logged with trade‑off analysis. |
+| **Walkthrough** | The **story of flow** — shows how pieces connect end‑to‑end and why steps are sequenced. Builds intuition for new devs. | New Developers, Team Members | TOUR.md, Loom videos, sequence diagrams. Step‑by‑step traces with rationale. | “UI sends JSON → Node.js wraps Claim‑Check → Julia pulls Arrow data (prevents NATS overflow).” | New developers ship feature in <2 days (PR timeline). |
+| **Implementation** | The **real code** — business logic, helpers, tests, configs. Where design becomes executable. | Developers, Code Reviewers | Source code, README.md, unit tests, setup scripts. | Julia function for matrix calculation + SvelteKit component rendering table. | >80% unit test coverage, <5% drift from spec. |
+| **Validation** | The **enforcer** — ensures implementation matches the spec. Blocks drift and human error. | Automation servers, QA, Lead Developers | CI jobs, contract tests, linting, integration checks. | CI job rejects PR with camelCase field not allowed by YAML spec. | <1% of PRs bypass validation gates. |
+| **Runbook** | The **operational manual** — how the system lives in production, scales, and recovers. Guides on‑call engineers. | DevOps, SREs, On‑call Developers | K8s manifests, Helm charts, Markdown guides. Deployment, scaling, backup/restore, troubleshooting. | GitOps manifest ensuring 6 Julia replicas restart if memory >80%. | MTTR <15 minutes for P1 incidents. |
+
+
+
+
+
+
+
+
+# ---------------------------------------------- 100 --------------------------------------------- #
+
+SDD + GitOps Documentation Stack
+Document,"Purpose (The ""Rationale"")",Primary Audience,Format / Content,Example (SaaS Context),"Measurement (KPI)"
+Requirements,"Defines the ""Why"" and the Business Boundary. It sets the constraints and success criteria so the team knows when a feature is ""done"" from a user's perspective.","Stakeholders, Product Owners, Lead Developers","Format: User Stories, PRDs. Content: Functional goals, non-functional requirements (latency, scale), and explicit ""out-of-scope"" items.","""The system must process high-volume tabular data from Julia to the SvelteKit UI with <200ms latency for 5-member teams."",""Pass/Fail: 95% of requests complete <200ms (measured via synthetic monitoring)""
+The Spec,"The Technical Contract. It serves as the single source of truth that defines the shape of data. In SDD, this file drives code generation and automated testing.","Developers, QA Engineers, CI/CD Pipelines","Format: OpenAPI (YAML), Protobuf, AsyncAPI. Content: Endpoint definitions, strict data types, error codes, and request/response schemas.",A contract.yaml defining a NATS subject that accepts an Apache Arrow stream with specific snake_case headers.",""Schema Validation Rate: 100% of messages validated against spec (CI block rate)""
+Architecture,"The Structural Blueprint. It explains how the ""pieces"" are arranged in the cluster. It defines the relationships between services, databases, and external providers.","System Architects, Senior Developers, DevOps","Format: C4 Model Diagrams, Mermaid.js. Content: Component diagrams, network flow, storage strategy, and technology stack definitions.",A diagram showing how the 6-node cluster routes traffic through Caddy to the Node.js API and offloads heavy math to Julia pods.",""Architecture Decision Log: 100% of major decisions documented with trade-off analysis""
+Walkthrough,"The Intuition & Flow. It connects multiple APIs/services into a cohesive end-to-end story. It explains the ""steps"" and the ""rationale"" behind the sequence of operations.","New Developers, Current Team Members","Format: TOUR.md, Loom videos, Sequence Diagrams. Content: Step-by-step trace of a feature, explanation of state changes, and the ""why"" behind complex logic.","""End-to-End Trace:"" 1. UI sends JSON to Node.js. 2. Node.js wraps it in a Claim-Check. 3. Julia pulls the Arrow data. Rationale: This prevents NATS memory overflow.",""Onboarding Velocity: New developers deploy feature in <2 days (tracked via PR timeline)""
+Implementation,"The Functional Reality. This is the actual execution of the logic. In SDD, parts of this are auto-generated to ensure it never drifts from the Spec.","Developers, Code Reviewers","Format: Source Code (Git), README.md. Content: Business logic, internal helper functions, unit tests, and local setup instructions.",The Julia function that performs the matrix calculation and the SvelteKit component that renders the resulting table.",""Code Coverage: >80% unit test coverage, <5% test drift from spec""
+Validation,"The Enforcement Layer. It ensures that the ""Reality"" (Code) actually matches the ""Contract"" (Spec). It prevents human error from breaking the system.","Automation Servers, QA, Lead Developers","Format: GitHub Actions, Dredd, Prism. Content: Contract tests, linting rules, and integration tests that check API compliance.",A CI job that blocks a Pull Request because a developer added a camelCase field that isn't allowed in the shared YAML spec.",""Block Rate: <1% of PRs reach production without validation (CI gate pass rate)""
+Runbook,"The Operational Life-Support. It defines how the system lives in production and how to fix it. In GitOps, the ""State"" is declared here.","DevOps, SREs, On-call Developers","Format: K8s Manifests, Helm Charts, Markdown. Content: Deployment steps, scaling triggers, backup/restore commands, and troubleshooting guides.",A GitOps manifest in Flux that ensures 6 replicas of the Julia service are always running and restarts them if memory hits 80%.",""MTTR: <15 minutes for P1 incidents (tracked via incident management system)""
+
+Do you understand the provided text? Don't fucking change the table content. I want you to add "Measurement (KPI)" column. it is only example of course. This table will be used for consult and teaching.
+
+
+# ---------------------------------------------- 100 --------------------------------------------- #
+
+Can you write the table and explain this approach and each doc in details then save to docs/SDD_FRAMEWORK.md so I can consult it later.
+Don't forget to add How to use this approach effectively.
+
+
+# ---------------------------------------------- 100 --------------------------------------------- #
+
+Since I develop src folder before I adopt SDD_FRAMEWORK.md approach, can you check src folder and my current doc files then write docs/requirements.md  according to SDD framework? Treat src as ground truth.
+
+# ---------------------------------------------- 100 --------------------------------------------- #
+
+Check NATSBridge/docs folder I want to update the content of the following files according to ASG_Framework/ASG_Framework.md:
+- NATSBridge/docs/requirements.md
+- NATSBridge/docs/specification.md
+- NATSBridge/docs/ui-specification.md (you'll need to create this one)
+- NATSBridge/docs/walkthrough.md
+- NATSBridge/docs/architecture.md
+I'll do the other docs not listed here later myself.
+
+
+
+now help me update the following fileaccording to ASG_Framework/ASG_Framework.md:
+- NATSBridge/docs/specification.md
+
+
+<!-- ------------------------------------------- 100 ------------------------------------------- -->
+
+
+Check NATSBridge/docs folder. I would like to expand this package to include Dart support.
+Can you update the content of the following files according to ASG_Framework/ASG_Framework.md:
+- NATSBridge/docs/requirements.md
+- NATSBridge/docs/specification.md
+- NATSBridge/docs/walkthrough.md
+- NATSBridge/docs/architecture.md
+
+
+
+

AI_prompt.txt

@@ -1,65 +0,0 @@
-Consider the following scenarios:
-Scenario 1: The "Command & Control" Loop (Low Latency)Focus: Small payloads, Core NATS, bi-directional JSON.The Action: A user on a JavaScript dashboard clicks a "Start Simulation" button. This sends a JSON configuration (parameters like step_size and iterations) to Julia.The Flow: * JS (Sender): Recognizes the message is small ($< 10KB$). Packages it as a direct transport JSON envelope.Julia (Receiver): Listens on the NATS subject, decodes the JSON, and immediately acknowledges receipt with a "Running" status.Project Requirement Met: Fast, low-overhead communication for control signals without involving the fileserver.
-Scenario 2: The "Deep Dive" Analysis (High Bandwidth)Focus: Large Arrow tables, Claim-Check pattern, Julia to JS.The Action: Julia finishes a heavy computation and produces a 500MB DataFrame with 10 million rows. It needs to send this to the JS frontend for visualization (e.g., using Perspective.js or D3).The Flow:Julia (Sender): Converts the DataFrame to an Arrow IPC stream. It sees the size is $> 1MB$, so it uploads the bytes to the HTTP fileserver. It then publishes a NATS message with transport: "link" and the URL.JS (Receiver): Receives the URL, fetches the data via fetch(), and uses tableFromIPC() to load the data into memory with zero-copy.Project Requirement Met: Handling massive datasets that exceed NATS message limits while maintaining data integrity across languages.
-Scenario 3: Live Audio/Signal Processing (Multimedia & Metadata)Focus: Raw binary, bi-directional streaming, NATS Headers.The Action: The JS client captures a 2-second "chunk" of microphone audio. It needs Julia to perform a Fast Fourier Transform (FFT) or AI transcription.The Flow:JS (Sender): Sends the raw binary WAV/PCM data. It uses NATS Headers to store the metadata ($fs = 44.1kHz$, $channels = 1$) to keep the payload purely binary.Julia (Receiver): Processes the audio and sends back a JSON result (the transcription) and an Arrow Table (the frequency spectrum data).Project Requirement Met: Bi-directional flow involving mixed media (Audio) and technical results (Arrow).
-Scenario 4: The "Catch-Up" (Persistence & JetStream)Focus: NATS JetStream, late-joining consumers, state sync.The Action: Julia is constantly publishing "System Health" updates. The JS dashboard is closed for 10 minutes. When the user re-opens the dashboard, they need to see the last 10 minutes of history.The Flow:NATS (Server): Uses a JetStream with a Limits retention policy.JS (Consumer): Connects and requests a "Replay" from the last 10 minutes. It receives a mix of direct (small updates) and link (historical snapshots) messages.Project Requirement Met: Temporal decoupling—consumers can receive data that was sent while they were offline.
-
-Role: Principal Systems Architect & Lead Software Engineer.Objective: Implement a high-performance, bi-directional data bridge between a Julia service and a JavaScript (Node.js) service using NATS (Core & JetStream).⚠️ STRICT ARCHITECTURAL CONSTRAINTS (Non-Negotiable)Transport Strategy (Claim-Check Pattern):Direct Path: If payload is < 1MB, send data directly via NATS inside the message envelope (Base64 encoded).Link Path: If payload is > 1MB, upload to a shared HTTP fileserver/store. The NATS message must only contain the metadata and the download URL.Tabular Data Format: * MUST use Apache Arrow IPC Stream for all tables/DataFrames. No CSV or standard JSON-serialization of tables allowed.System Symmetry: * Both services must function as Producers AND Consumers.Modular Elegance: * Implementation must be abstracted into a SmartSend function and a SmartReceive handler. The developer calling these functions should not need to care if the data is going via NATS direct or HTTP link.Technical Stack & Use CasesJulia: NATS.jl, Arrow.jl, JSON3.jl, HTTP.jl.Node.js: nats.js, apache-arrow.Scenarios to Support: * Large Data: Sending a 500MB Arrow table from Julia $\rightarrow$ JS.Media: Sending a 5MB WAV file from JS $\rightarrow$ Julia.Signals: Sending small JSON control commands ($< 10KB$) directly via NATS.Implementation Requirements1. Unified JSON Envelope:Define a schema containing: correlation_id (UUID), type (table/binary/json), transport (direct/link), payload (if direct), and url (if link).2. The Julia Module:Implement SmartSend(subject, data, type): Handles Arrow serialization to an IOBuffer, checks size, and manages HTTP uploads for large blobs.Implement SmartReceive(msg): Parses envelope, handles the HTTP fetch with Exponential Backoff (to avoid race conditions), and restores the DataFrame.Include a basic HTTP.listen server to serve as the temporary storage.3. The JavaScript Module:Implement a symmetric SmartSend using nats.js and apache-arrow.Implement a JetStream Pull Consumer for SmartReceive to ensure backpressure and memory safety.4. Performance & Reliability:Demonstrate "Zero-Copy" reading of the Arrow IPC stream on the JS side.Log the correlation_id at every stage for distributed tracing.
-
-
-
-
-
-
-
-Create a walkthrough for Julia service-A service sending a mix-content chat message to Julia service-B. the chat message must includes 
-
-
-
-
-
-
-I updated the following:
-- NATSBridge.jl. Essentially I add NATS_connection keyword and new publish_message function to support the keyword. 
-
-Use them and ONLY them as ground truth.
-
-Then update the following files accordingly:
-- architecture.md
-- implementation.md
-
-All API should be semantically consistent and naming should be consistent across the board.
-
-
-
-
-
-
-
-
-
-Task: Update NATSBridge.js to reflect recent changes in NATSBridge.jl and docs
-
-Context: NATSBridge.jl and docs has been updated.
-
-Requirements:
-
-Source of Truth: Treat the updated NATSBridge.jl and docs as the definitive source.
-API Consistency: Ensure the Main Package API (e.g., smartsend(), publish_message()) uses consistent naming across all three supported languages.
-Ecosystem Variance: Low-level native functions (e.g., NATS.connect(), JSON.read()) should follow the conventions of the specific language ecosystem and do not require cross-language consistency.
-
-
-
-
-
-
-
-I'm expanding this Julia package (NATSBridge) into a cross-platform project by adding a JavaScript and Python/MicroPython implementation. To ensure accuracy, the Julia src directory will serve as the ground truth, as the documentation may be outdated.
-
-My goal is to maintain interface parity at the high-level API for a consistent user experience, while ensuring the low-level implementation adheres strictly to the idiomatic conventions of each respective language (e.g., multiple dispatch in Julia vs. asynchronous, prototype, or class-based patterns in JS and Python/MicroPython)
-
-Now, help me do the following:
-1) check architecture.md for any mistake.
-
-
-

Project.toml

@@ -1,6 +1,6 @@
 name = "NATSBridge"
 uuid = "f2724d33-f338-4a57-b9f8-1be882570d10"
-version = "0.4.5"
+version = "0.5.6"
 authors = ["narawat <narawat@gmail.com>"]
 
 [deps]

README.md

@@ -1,6 +1,6 @@
 # NATSBridge - Cross-Platform Bi-Directional Data Bridge
 
-A high-performance, bi-directional data bridge for **Julia, JavaScript, Python, and MicroPython** applications using NATS (Core & JetStream), implementing the Claim-Check pattern for large payloads.
+A high-performance, bi-directional data bridge for **Julia**, **JavaScript**, **Python**, and **MicroPython** applications using NATS (Core & JetStream), implementing the Claim-Check pattern for large payloads.
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![NATS](https://img.shields.io/badge/NATS-Enabled-green.svg)](https://nats.io)
@@ -12,14 +12,12 @@ A high-performance, bi-directional data bridge for **Julia, JavaScript, Python,
 - [Overview](#overview)
 - [Cross-Platform Support](#cross-platform-support)
 - [Features](#features)
-- [Architecture](#architecture)
-- [Installation](#installation)
 - [Quick Start](#quick-start)
 - [API Reference](#api-reference)
 - [Payload Types](#payload-types)
-- [Transport Strategies](#transport-strategies)
 - [Cross-Platform Examples](#cross-platform-examples)
 - [Testing](#testing)
+- [Documentation](#documentation)
 - [License](#license)
 
 ---
@@ -30,8 +28,8 @@ NATSBridge enables seamless communication across multiple platforms through NATS
 
 | Transport | Payload Size | Method |
 |-----------|--------------|--------|
-| **Direct** | < 1MB | Sent directly via NATS (Base64 encoded) |
-| **Link** | >= 1MB | Uploaded to HTTP file server, URL sent via NATS |
+| **Direct** | < 500KB | Sent directly via NATS (Base64 encoded) |
+| **Link** | ≥ 500KB | Uploaded to HTTP file server, URL sent via NATS |
 
 ### Use Cases
 
@@ -47,23 +45,25 @@ NATSBridge enables seamless communication across multiple platforms through NATS
 | Platform | Implementation | Features |
 |----------|----------------|----------|
 | **Julia** | [`src/NATSBridge.jl`](src/NATSBridge.jl) | Full feature set, Arrow IPC, multiple dispatch |
-| **JavaScript** | [`src/natbridge.js`](src/natbridge.js) | Node.js & browser, async/await |
-| **Python** | [`src/natbridge.py`](src/natbridge.py) | Desktop Python, asyncio, type hints |
-| **MicroPython** | [`src/natbridge_mpy.py`](src/natbridge_mpy.py) | Memory-constrained, synchronous API |
+| **JavaScript (Node.js)** | [`src/natsbridge_ssr.js`](src/natsbridge_ssr.js) | Node.js, async/await, Arrow IPC |
+| **JavaScript (Browser)** | [`src/natsbridge_csr.js`](src/natsbridge_csr.js) | Browser, WebSocket NATS, async/await, JSON table only |
+| **Python** | [`src/natsbridge.py`](src/natsbridge.py) | Desktop Python, asyncio, type hints, Arrow IPC |
+| **MicroPython** | [`src/natsbridge_mpy.py`](src/natsbridge_mpy.py) | Memory-constrained, synchronous API |
 
 ### Platform Comparison
 
-| Feature | Julia | JavaScript | Python | MicroPython |
-|---------|-------|------------|--------|-------------|
-| Multiple Dispatch | ✅ Native | ❌ | ❌ | ❌ |
-| Async/Await | ❌ | ✅ Native | ✅ Native | ⚠️ (uasyncio) |
-| Type Safety | ✅ Strong | ⚠️ (TypeScript) | ✅ (Type hints) | ❌ |
-| Memory Management | ✅ GC | ✅ GC | ✅ GC | ⚠️ (Manual) |
-| Arrow IPC | ✅ Native | ✅ | ✅ | ❌ |
-| Direct Transport | ✅ | ✅ | ✅ | ✅ |
-| Link Transport | ✅ | ✅ | ✅ | ⚠️ (Limited) |
-| Handler Functions | ✅ | ✅ | ✅ | ✅ |
-| Cross-Platform API | ✅ | ✅ | ✅ | ✅ |
+| Feature | Julia | JavaScript | JavaScript (Browser) | Python | MicroPython |
+|---------|-------|------------|----------------------|--------|-------------|
+| Multiple Dispatch | ✅ Native | ❌ | ❌ | ❌ | ❌ |
+| Async/Await | ❌ | ✅ Native | ✅ Native | ✅ Native | ⚠️ (uasyncio) |
+| Type Safety | ✅ Strong | ⚠️ (TypeScript) | ⚠️ (TypeScript) | ✅ (Type hints) | ❌ |
+| Arrow IPC | ✅ Native | ✅ Native | ❌ (Browser incompatible) | ✅ Native | ❌ |
+| JSON Table | ✅ | ✅ | ✅ (Only table type) | ✅ | ⚠️ (Limited) |
+| Direct Transport | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Link Transport | ✅ | ✅ | ✅ | ✅ | ⚠️ (Limited) |
+| Handler Functions | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Cross-Platform API | ✅ | ✅ | ✅ | ✅ | ✅ |
+| WebSocket NATS | ❌ | ❌ | ✅ | ❌ | ❌ |
 
 ---
 
@@ -73,8 +73,9 @@ NATSBridge enables seamless communication across multiple platforms through NATS
 - ✅ **Bi-directional messaging** with request-reply patterns
 - ✅ **Multi-payload support** - send multiple payloads with different types in one message
 - ✅ **Automatic transport selection** - direct vs link based on payload size
-- ✅ **Claim-Check pattern** for payloads > 1MB
-- ✅ **Apache Arrow IPC** support for tabular data (zero-copy reading)
+- ✅ **Claim-Check pattern** for payloads ≥ 500KB
+- ✅ **Apache Arrow IPC** support for tabular data (Desktop: Julia/Python/Node.js)
+- ✅ **JSON Table** support for tabular data (All platforms including Browser)
 - ✅ **Exponential backoff** for reliable file server downloads
 - ✅ **Correlation ID tracking** for message tracing
 - ✅ **Reply-to support** for request-response patterns
@@ -82,189 +83,94 @@ NATSBridge enables seamless communication across multiple platforms through NATS
 
 ---
 
-## Architecture
-
-### System Components
-
-```mermaid
-flowchart TB
-    subgraph Sender["Application (Sender)"]
-        SenderApp[App Code]
-        NATSBridge_Send[NATSBridge]
-        NATS_Client[<b>NATS.jl</b>]
-    end
-
-    subgraph Receiver["Application (Receiver)"]
-        ReceiverApp[App Code]
-        NATSBridge_Recv[NATSBridge]
-        NATS_Client_Recv[<b>NATS.jl</b>]
-    end
-
-    subgraph Infrastructure["Infrastructure"]
-        NATS[<b>NATS Server</b><br/>Message Broker]
-        FileServer[<b>HTTP File Server</b><br/>Upload/Download]
-    end
-
-    SenderApp --> NATSBridge_Send
-    NATSBridge_Send --> NATS_Client
-    NATS_Client --> NATS
-    
-    NATS --> NATS_Client_Recv
-    NATS_Client_Recv --> NATSBridge_Recv
-    NATSBridge_Recv --> ReceiverApp
-
-    NATSBridge_Send -.->|HTTP POST upload| FileServer
-    FileServer -.->|HTTP GET download| NATSBridge_Recv
-
-    style SenderApp fill:#e8f5e9
-    style ReceiverApp fill:#e8f5e9
-    style NATS fill:#fff3e0
-    style FileServer fill:#f3e5f5
-```
-
-### Message Flow
-
-1. **Sender** creates a message envelope with payloads using `smartsend()`
-2. **NATSBridge** serializes and encodes each payload based on type
-3. **Transport Decision**: 
-   - **Direct** (< 1MB): Payload encoded as Base64, published to NATS
-   - **Link** (≥ 1MB): Payload uploaded to HTTP file server, URL published to NATS
-4. **NATS** routes message envelope to subscribers
-5. **Receiver** receives message via NATS subscription callback
-6. **NATSBridge** processes envelope:
-   - Decodes Base64 payloads from NATS message
-   - Fetches URLs from file server with exponential backoff
-7. **Receiver** deserializes payloads based on their type
-
-### File Server Handler Abstraction
-
-The system uses handler functions to abstract file server operations:
-
-| Handler | Purpose |
-|---------|---------|
-| `plik_oneshot_upload()` / `plikOneshotUpload()` | Uploads payload bytes to file server, returns URL |
-| `_fetch_with_backoff()` / `fetchWithBackoff()` | Downloads data from URL with exponential backoff retry |
-
-This abstraction allows support for different file server implementations (Plik, AWS S3, custom HTTP server).
-
-### Message Envelope Schema
-
-All platforms use identical JSON schemas for message envelopes:
-
-```json
-{
-  "correlation_id": "uuid-v4-string",
-  "msg_id": "uuid-v4-string",
-  "timestamp": "2024-01-15T10:30:00Z",
-  "send_to": "topic/subject",
-  "msg_purpose": "ACK | NACK | updateStatus | shutdown | chat",
-  "sender_name": "agent-wine-web-frontend",
-  "sender_id": "uuid4",
-  "receiver_name": "agent-backend",
-  "receiver_id": "uuid4",
-  "reply_to": "topic",
-  "reply_to_msg_id": "uuid4",
-  "broker_url": "nats://localhost:4222",
-  "metadata": {},
-  "payloads": [
-    {
-      "id": "uuid4",
-      "dataname": "login_image",
-      "payload_type": "image",
-      "transport": "direct",
-      "encoding": "base64",
-      "size": 15433,
-      "data": "base64-encoded-string"
-    },
-    {
-      "id": "uuid4",
-      "dataname": "large_table",
-      "payload_type": "table",
-      "transport": "link",
-      "encoding": "none",
-      "size": 524288,
-      "data": "http://localhost:8080/file/UPLOAD_ID/FILE_ID/data.arrow"
-    }
-  ]
-}
-```
-
----
-
-## Installation
+## Quick Start
 
 ### Prerequisites
 
-- **NATS Server** (v2.10+ recommended)
-- **HTTP File Server** (optional, for payloads > 1MB)
-
-### Platform-Specific Dependencies
-
-#### Julia
-
-```julia
-using Pkg
-Pkg.add("NATS")
-Pkg.add("Arrow")
-Pkg.add("JSON3")
-Pkg.add("HTTP")
-Pkg.add("UUIDs")
-Pkg.add("Dates")
-```
-
-#### JavaScript (Node.js)
-
-```bash
-npm install nats uuid apache-arrow node-fetch
-# or
-yarn add nats uuid apache-arrow node-fetch
-```
-
-#### JavaScript (Browser)
-
-```bash
-npm install nats uuid apache-arrow
-# or use CDN:
-# https://unpkg.com/nats-js/dist/bundle/nats.min.js
-# https://unpkg.com/apache-arrow/arrow.min.js
-```
-
-#### Python (Desktop)
-
-```bash
-pip install nats-py aiohttp pyarrow pandas python-dateutil
-```
-
-#### MicroPython
-
-MicroPython uses built-in modules:
-- `network` - NATS connection (custom implementation)
-- `time` - Timestamps
-- `uos` - File operations
-- `base64` - Base64 encoding
-- `json` - JSON parsing
-- `struct` - Binary data handling
-
----
-
-## Quick Start
-
-### Step 1: Start NATS Server
-
+1. **NATS Server** - Install and run a NATS server:
    ```bash
    docker run -p 4222:4222 nats:latest
    ```
 
-### Step 2: Start HTTP File Server (Optional)
-
+2. **HTTP File Server** (optional, for large payloads) - Install and run a file server:
    ```bash
-# Create a directory for file uploads
-mkdir -p /tmp/fileserver
+   # Using Plik
+   docker run -p 8080:8080 -v /tmp/fileserver:/var/lib/plik -e PLIK_ADMIN_PASSWORD=admin plik/plik
    
-# Start HTTP file server
+   # OR using simple Python HTTP server
+   mkdir -p /tmp/fileserver
    python3 -m http.server 8080 --directory /tmp/fileserver
    ```
 
+### Send Your First Message
+
+#### Julia
+
+```julia
+using NATSBridge
+
+data = [("message", "Hello World", "text")]
+env, env_json_str = smartsend("/chat/room1", data; broker_url="nats://localhost:4222")
+println("Message sent!")
+```
+
+#### JavaScript (Node.js)
+
+```javascript
+import NATSBridge from './src/natsbridge_ssr.js';
+
+const data = [["message", "Hello World", "text"]];
+const [env, env_json_str] = await NATSBridge.smartsend(
+    "/chat/room1",
+    data,
+    { broker_url: "nats://localhost:4222" }
+);
+console.log("Message sent!");
+```
+
+#### JavaScript (Browser)
+
+```javascript
+import NATSBridge from './src/natsbridge_csr.js';
+
+const data = [["message", "Hello World", "text"]];
+const [env, env_json_str] = await NATSBridge.smartsend(
+    "/chat/room1",
+    data,
+    { broker_url: "ws://localhost:4222" }
+);
+console.log("Message sent!");
+```
+
+#### Python
+
+```python
+from natsbridge import smartsend
+
+data = [("message", "Hello World", "text")]
+env, env_json_str = await smartsend(
+    "/chat/room1",
+    data,
+    broker_url="nats://localhost:4222"
+)
+print("Message sent!")
+```
+
+#### MicroPython
+
+```python
+from natsbridge import smartsend
+
+data = [("message", "Hello World", "text")]
+env, env_json_str = smartsend(
+    "/chat/room1",
+    data,
+    broker_url="nats://localhost:4222",
+    size_threshold=100000  # 100KB for MicroPython
+)
+print("Message sent!")
+```
+
 ---
 
 ## API Reference
@@ -273,13 +179,13 @@ python3 -m http.server 8080 --directory /tmp/fileserver
 
 All platforms use the same input/output format for payloads:
 
-**Input format for smartsend:**
+**Input format for `smartsend`:**
 ```
 [(dataname1, data1, type1), (dataname2, data2, type2), ...]
 ```
 
-**Output format for smartreceive:**
-```
+**Output format for `smartreceive`:**
+```json
 {
   "correlation_id": "...",
   "msg_id": "...",
@@ -308,12 +214,12 @@ Sends data either directly via NATS or via a fileserver URL, depending on payloa
 using NATSBridge
 
 env, env_json_str = NATSBridge.smartsend(
-    subject::String,                           # NATS subject
-    data::AbstractArray{Tuple{String, Any, String}};  # List of (dataname, data, type)
+    subject::String,
+    data::AbstractArray{Tuple{String, Any, String}};
     broker_url::String = "nats://localhost:4222",
     fileserver_url = "http://localhost:8080",
     fileserver_upload_handler::Function = plik_oneshot_upload,
-    size_threshold::Int = 1_000_000,
+    size_threshold::Int = 500_000,
     correlation_id::String = string(uuid4()),
     msg_purpose::String = "chat",
     sender_name::String = "NATSBridge",
@@ -329,10 +235,10 @@ env, env_json_str = NATSBridge.smartsend(
 # Returns: ::Tuple{msg_envelope_v1, String}
 ```
 
-#### JavaScript
+#### JavaScript (Node.js)
 
 ```javascript
-const NATSBridge = require('natbridge');
+import NATSBridge from './src/natsbridge_ssr.js';
 
 const [env, env_json_str] = await NATSBridge.smartsend(
     subject,
@@ -341,7 +247,36 @@ const [env, env_json_str] = await NATSBridge.smartsend(
         broker_url: 'nats://localhost:4222',
         fileserver_url: 'http://localhost:8080',
         fileserver_upload_handler: NATSBridge.plikOneshotUpload,
-        size_threshold: 1_000_000,
+        size_threshold: 500_000,
+        correlation_id: uuidv4(),
+        msg_purpose: 'chat',
+        sender_name: 'NATSBridge',
+        receiver_name: '',
+        receiver_id: '',
+        reply_to: '',
+        reply_to_msg_id: '',
+        is_publish: true,
+        nats_connection: null,
+        msg_id: uuidv4(),
+        sender_id: uuidv4()
+    }
+);
+// Returns: Promise<[env, env_json_str]>
+```
+
+#### JavaScript (Browser)
+
+```javascript
+import NATSBridge from './src/natsbridge_csr.js';
+
+const [env, env_json_str] = await NATSBridge.smartsend(
+    subject,
+    data,
+    {
+        broker_url: 'ws://localhost:4222',
+        fileserver_url: 'http://localhost:8080',
+        fileserver_upload_handler: NATSBridge.plikOneshotUpload,
+        size_threshold: 500_000,
         correlation_id: uuidv4(),
         msg_purpose: 'chat',
         sender_name: 'NATSBridge',
@@ -361,7 +296,7 @@ const [env, env_json_str] = await NATSBridge.smartsend(
 #### Python
 
 ```python
-from natbridge import NATSBridge
+from natsbridge import NATSBridge
 
 env, env_json_str = await NATSBridge.smartsend(
     subject: str,
@@ -369,7 +304,7 @@ env, env_json_str = await NATSBridge.smartsend(
     broker_url: str = "nats://localhost:4222",
     fileserver_url: str = "http://localhost:8080",
     fileserver_upload_handler: Callable = plik_oneshot_upload,
-    size_threshold: int = 1_000_000,
+    size_threshold: int = 500_000,
     correlation_id: str = None,
     msg_purpose: str = "chat",
     sender_name: str = "NATSBridge",
@@ -388,7 +323,7 @@ env, env_json_str = await NATSBridge.smartsend(
 #### MicroPython
 
 ```python
-from natbridge import NATSBridge
+from natsbridge import NATSBridge
 
 # Limited to direct transport (< 100KB threshold)
 env, env_json_str = NATSBridge.smartsend(
@@ -419,9 +354,28 @@ env = NATSBridge.smartreceive(
 # Returns: ::JSON.Object{String, Any}
 ```
 
-#### JavaScript
+#### JavaScript (Node.js)
 
 ```javascript
+import NATSBridge from './src/natsbridge_ssr.js';
+
+const env = await NATSBridge.smartreceive(
+    msg,
+    {
+        fileserver_download_handler: NATSBridge.fetchWithBackoff,
+        max_retries: 5,
+        base_delay: 100,
+        max_delay: 5000
+    }
+);
+// Returns: Promise<env_object>
+```
+
+#### JavaScript (Browser)
+
+```javascript
+import NATSBridge from './src/natsbridge_csr.js';
+
 const env = await NATSBridge.smartreceive(
     msg,
     {
@@ -437,6 +391,8 @@ const env = await NATSBridge.smartreceive(
 #### Python
 
 ```python
+from natsbridge import NATSBridge
+
 env = await NATSBridge.smartreceive(
     msg,
     fileserver_download_handler=fetch_with_backoff,
@@ -450,6 +406,8 @@ env = await NATSBridge.smartreceive(
 #### MicroPython
 
 ```python
+from natsbridge import NATSBridge
+
 env = NATSBridge.smartreceive(
     msg,
     fileserver_download_handler=_sync_fileserver_download,
@@ -468,7 +426,8 @@ env = NATSBridge.smartreceive(
 |------|-------|------------|--------|-------------|-------------|
 | `text` | `String` | `string` | `str` | `str` | Plain text strings |
 | `dictionary` | `Dict`, `NamedTuple` | `Object`, `Array` | `dict`, `list` | `dict` | JSON-serializable dictionaries |
-| `table` | `DataFrame`, `Arrow.Table` | `Array<Object>` | `pandas.DataFrame` | ❌ | Tabular data (Arrow IPC) |
+| `arrowtable` | `DataFrame`, `Arrow.Table` | ❌ (Browser), ✅ (Node.js) | `pandas.DataFrame` | ❌ | Tabular data (Arrow IPC) |
+| `jsontable` | `DataFrame`, `Vector{NamedTuple}` | `Array<Object>` | `list[dict]` | ⚠️ | Tabular data (JSON) - **Only table type in Browser** |
 | `image` | `Vector{UInt8}` | `Uint8Array`, `Buffer` | `bytes` | `bytearray` | Image data (PNG, JPG) |
 | `audio` | `Vector{UInt8}` | `Uint8Array`, `Buffer` | `bytes` | `bytearray` | Audio data (WAV, MP3) |
 | `video` | `Vector{UInt8}` | `Uint8Array`, `Buffer` | `bytes` | `bytearray` | Video data (MP4, AVI) |
@@ -476,58 +435,6 @@ env = NATSBridge.smartreceive(
 
 ---
 
-## Transport Strategies
-
-### Direct Transport (Payloads < 1MB)
-
-Small payloads are sent directly via NATS with Base64 encoding.
-
-#### Cross-Platform
-
-```julia
-# Julia
-data = [("message", "Hello", "text")]
-smartsend("/topic", data)
-```
-
-```javascript
-// JavaScript
-const data = [["message", "Hello", "text"]];
-smartsend("/topic", data);
-```
-
-```python
-# Python
-data = [("message", "Hello", "text")]
-await smartsend("/topic", data)
-```
-
-### Link Transport (Payloads >= 1MB)
-
-Large payloads are uploaded to an HTTP file server.
-
-#### Cross-Platform
-
-```julia
-# Julia
-data = [("file", large_data, "binary")]
-smartsend("/topic", data; fileserver_url="http://localhost:8080")
-```
-
-```javascript
-// JavaScript
-const data = [["file", largeData, "binary"]];
-smartsend("/topic", data, { fileserver_url: 'http://localhost:8080' });
-```
-
-```python
-# Python
-data = [("file", large_data, "binary")]
-await smartsend("/topic", data, fileserver_url="http://localhost:8080")
-```
-
----
-
 ## Cross-Platform Examples
 
 ### Example 1: Chat with Mixed Content
@@ -545,13 +452,13 @@ data = [
     ("large_document", large_file_data, "binary")
 ]
 
-env, env_json_str = NATSBridge.smartsend("/chat/room1", data; fileserver_url="http://localhost:8080")
+env, env_json_str = smartsend("/chat/room1", data; fileserver_url="http://localhost:8080")
 ```
 
-#### JavaScript
+#### JavaScript (Node.js)
 
 ```javascript
-const NATSBridge = require('natbridge');
+import NATSBridge from './src/natsbridge_ssr.js';
 
 const data = [
     ["message_text", "Hello!", "text"],
@@ -566,10 +473,28 @@ const [env, env_json_str] = await NATSBridge.smartsend(
 );
 ```
 
+#### JavaScript (Browser)
+
+```javascript
+import NATSBridge from './src/natsbridge_csr.js';
+
+const data = [
+    ["message_text", "Hello!", "text"],
+    ["user_avatar", imageData, "image"],
+    ["large_document", largeFileData, "binary"]
+];
+
+const [env, env_json_str] = await NATSBridge.smartsend(
+    "/chat/room1",
+    data,
+    { broker_url: 'ws://localhost:4222', fileserver_url: 'http://localhost:8080' }
+);
+```
+
 #### Python
 
 ```python
-from natbridge import NATSBridge
+from natsbridge import NATSBridge
 
 data = [
     ("message_text", "Hello!", "text"),
@@ -600,13 +525,13 @@ config = Dict(
 )
 
 data = [("config", config, "dictionary")]
-env, env_json_str = NATSBridge.smartsend("/device/config", data)
+env, env_json_str = smartsend("/device/config", data)
 ```
 
-#### JavaScript
+#### JavaScript (Node.js)
 
 ```javascript
-const NATSBridge = require('natbridge');
+import NATSBridge from './src/natsbridge_ssr.js';
 
 const config = {
     wifi_ssid: "MyNetwork",
@@ -623,7 +548,7 @@ const [env, env_json_str] = await NATSBridge.smartsend(
 #### Python
 
 ```python
-from natbridge import NATSBridge
+from natsbridge import NATSBridge
 
 config = {
     "wifi_ssid": "MyNetwork",
@@ -651,14 +576,14 @@ df = DataFrame(
     score = [95, 88, 92]
 )
 
-data = [("students", df, "table")]
-env, env_json_str = NATSBridge.smartsend("/data/analysis", data)
+data = [("students", df, "arrowtable")]
+env, env_json_str = smartsend("/data/analysis", data)
 ```
 
-#### JavaScript
+#### JavaScript (Node.js)
 
 ```javascript
-const NATSBridge = require('natbridge');
+import NATSBridge from './src/natsbridge_ssr.js';
 
 const df = [
     { id: 1, name: "Alice", score: 95 },
@@ -668,14 +593,14 @@ const df = [
 
 const [env, env_json_str] = await NATSBridge.smartsend(
     "/data/analysis",
-    [["students", df, "table"]]
+    [["students", df, "arrowtable"]]
 );
 ```
 
 #### Python
 
 ```python
-from natbridge import NATSBridge
+from natsbridge import NATSBridge
 import pandas as pd
 
 df = pd.DataFrame({
@@ -684,10 +609,30 @@ df = pd.DataFrame({
     "score": [95, 88, 92]
 })
 
-data = [("students", df, "table")]
+data = [("students", df, "arrowtable")]
 env, env_json_str = await NATSBridge.smartsend("/data/analysis", data)
 ```
 
+#### JavaScript (Browser)
+
+```javascript
+import NATSBridge from './src/natsbridge_csr.js';
+
+// Browser uses jsontable (JSON array of objects) instead of arrowtable
+// Apache Arrow is not compatible with browsers
+const df = [
+    { id: 1, name: "Alice", score: 95 },
+    { id: 2, name: "Bob", score: 88 },
+    { id: 3, name: "Charlie", score: 92 }
+];
+
+const [env, env_json_str] = await NATSBridge.smartsend(
+    "/data/analysis",
+    [["students", df, "jsontable"]],  // Use jsontable for browser
+    { broker_url: 'ws://localhost:4222' }
+);
+```
+
 ### Example 4: Request-Response Pattern
 
 Bi-directional communication with reply-to support.
@@ -698,44 +643,29 @@ Bi-directional communication with reply-to support.
 using NATSBridge
 
 # Requester
-env, env_json_str = NATSBridge.smartsend(
+env, env_json_str = smartsend(
     "/device/command",
     [("command", Dict("action" => "read_sensor"), "dictionary")];
     broker_url="nats://localhost:4222",
     reply_to="/device/response"
 )
+
+# Receiver (in separate application)
+msg = NATS.subscription.next()
+env = smartreceive(msg)
+# Process request and send response
+response_env, response_json = smartsend(
+    "/device/response",
+    [("result", Dict("value" => 42), "dictionary")],
+    reply_to="/device/command",
+    reply_to_msg_id=env["msg_id"]
+)
 ```
 
-```julia
-# Responder
-using NATS, NATSBridge
-
-function test_responder()
-    conn = NATS.connect("nats://localhost:4222")
-    NATS.subscribe(conn, "/device/command") do msg
-        env = NATSBridge.smartreceive(msg, fileserver_download_handler=_fetch_with_backoff)
-        
-        reply_to = env["reply_to"]
-        
-        for (dataname, data, type) in env["payloads"]
-            if dataname == "command" && data["action"] == "read_sensor"
-                response = Dict("sensor_id" => "sensor-001", "value" => 42.5)
-                if !isempty(reply_to)
-                    smartsend(reply_to, [("data", response, "dictionary")])
-                end
-            end
-        end
-    end
-    
-    sleep(120)
-    NATS.drain(conn)
-end
-```
-
-#### JavaScript
+#### JavaScript (Node.js)
 
 ```javascript
-const NATSBridge = require('natbridge');
+import NATSBridge from './src/natsbridge_ssr.js';
 
 // Requester
 const [env, env_json_str] = await NATSBridge.smartsend(
@@ -743,46 +673,22 @@ const [env, env_json_str] = await NATSBridge.smartsend(
     [["command", { action: "read_sensor" }, "dictionary"]],
     { broker_url: 'nats://localhost:4222', reply_to: '/device/response' }
 );
-```
 
-```javascript
-// Responder
-const nats = require('nats');
-const NATSBridge = require('natbridge');
-
-async function testResponder() {
-    const conn = await nats.connect('nats://localhost:4222');
-    
-    const subscription = await conn.subscribe('/device/command');
-    
-    for await (const msg of subscription) {
-        const env = await NATSBridge.smartreceive(msg, {
-            fileserver_download_handler: NATSBridge.fetchWithBackoff
-        });
-        
-        const replyTo = env.reply_to;
-        
-        for (const [dataname, data, type] of env.payloads) {
-            if (dataname === 'command' && data.action === 'read_sensor') {
-                const response = { sensor_id: 'sensor-001', value: 42.5 };
-                if (replyTo) {
-                    await NATSBridge.smartsend(
-                        replyTo,
-                        [["data", response, "dictionary"]]
-                    );
-                }
-            }
-        }
-    }
-    
-    setTimeout(() => conn.close(), 120000);
-}
+// Receiver (in separate application)
+// const msg = await natsConsumer.next();
+// const env = await NATSBridge.smartreceive(msg);
+// Process request and send response
+// const response_env, response_json = await NATSBridge.smartsend(
+//     "/device/response",
+//     [["result", { value: 42 }, "dictionary"]],
+//     { reply_to: '/device/command', reply_to_msg_id: env.msg_id }
+// );
 ```
 
 #### Python
 
 ```python
-from natbridge import NATSBridge
+from natsbridge import NATSBridge
 
 # Requester
 env, env_json_str = await NATSBridge.smartsend(
@@ -791,38 +697,17 @@ env, env_json_str = await NATSBridge.smartsend(
     broker_url="nats://localhost:4222",
     reply_to="/device/response"
 )
-```
 
-```python
-# Responder
-from natbridge import NATSBridge
-import asyncio
-import nats
-
-async def test_responder():
-    nc = await nats.connect('nats://localhost:4222')
-    
-    async def msg_handler(msg):
-        env = await NATSBridge.smartreceive(
-            msg,
-            fileserver_download_handler=fetch_with_backoff
-        )
-        
-        reply_to = env["reply_to"]
-        
-        for dataname, data, type_ in env["payloads"]:
-            if dataname == "command" and data["action"] == "read_sensor":
-                response = {"sensor_id": "sensor-001", "value": 42.5}
-                if reply_to:
-                    await NATSBridge.smartsend(
-                        reply_to,
-                        [("data", response, "dictionary")]
-                    )
-    
-    await nc.subscribe('/device/command', cb=msg_handler)
-    
-    await asyncio.sleep(120)
-    await nc.drain()
+# Receiver (in separate application)
+# msg = await nats_consumer.next()
+# env = await NATSBridge.smartreceive(msg)
+# Process request and send response
+# response_env, response_json = await NATSBridge.smartsend(
+#     "/device/response",
+#     [("result", {"value": 42}, "dictionary")],
+#     reply_to="/device/command",
+#     reply_to_msg_id=env["msg_id"]
+# )
 ```
 
 ---
@@ -905,12 +790,131 @@ python3 test/test_py_table_receiver.py
 
 ---
 
+## Browser Deployment
+
+### Using with Node.js Build Tools
+
+The browser implementation (`src/natsbridge_csr.js`) can be bundled for production deployment using modern JavaScript build tools.
+
+#### Prerequisites
+
+```bash
+# Install the browser-compatible NATS client
+npm install nats.ws
+```
+
+#### Vite (Recommended)
+
+```bash
+npm create vite@latest my-app -- --template vanilla
+cd my-app
+npm install nats.ws
+```
+
+In `vite.config.js`:
+```javascript
+import { defineConfig } from 'vite';
+export default defineConfig({
+  resolve: {
+    alias: {
+      'nats.ws': 'nats.ws/dist/esm/browser.js'
+    }
+  }
+});
+```
+
+Build command:
+```bash
+npm run build  # Outputs to dist/ folder
+```
+
+#### Webpack
+
+```bash
+npm install webpack webpack-cli --save-dev
+npm install nats.ws
+```
+
+In `webpack.config.js`:
+```javascript
+module.exports = {
+  entry: './src/index.js',
+  output: {
+    filename: 'bundle.js',
+    path: __dirname + '/dist'
+  },
+  resolve: {
+    alias: {
+      'nats.ws': 'nats.ws/dist/esm/browser.js'
+    }
+  }
+};
+```
+
+Build command:
+```bash
+npx webpack
+```
+
+#### esbuild (Simple & Fast)
+
+```bash
+npm install esbuild nats.ws --save-dev
+```
+
+Create `build.js`:
+```javascript
+import esbuild from 'esbuild';
+
+esbuild.buildSync({
+  entryPoints: ['src/natsbridge_csr.js'],
+  bundle: true,
+  outfile: 'dist/natsbridge-csr-bundle.js',
+  format: 'esm',
+  platform: 'browser',
+  target: 'es2020'
+});
+```
+
+Build command:
+```bash
+node build.js
+```
+
+### Using in Your HTML
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <title>My App</title>
+</head>
+<body>
+  <script type="module" src="dist/natsbridge-csr-bundle.js"></script>
+  <script type="module">
+    import NATSBridgeCSR from './dist/natsbridge-csr-bundle.js';
+    
+    // Use the library
+    const [env, envJson] = await NATSBridgeCSR.smartsend(
+      "/chat/user/v1/message",
+      [["msg", "Hello", "text"]],
+      { broker_url: "wss://nats.example.com" }
+    );
+  </script>
+</body>
+</html>
+```
+
+---
+
 ## Documentation
 
 For detailed architecture and implementation information, see:
 
-- [Architecture Documentation](docs/architecture.md) - Cross-platform architecture, API parity, platform-specific patterns
-- [Implementation Guide](docs/implementation.md) - Detailed implementation for each platform, handler functions, testing
+- [`docs/architecture.md`](docs/architecture.md) - Cross-platform architecture, API parity, platform-specific patterns
+- [`docs/requirements.md`](docs/requirements.md) - Business requirements and user stories
+- [`docs/spec.md`](docs/spec.md) - Technical specification and contracts
+- [`docs/walkthrough.md`](docs/walkthrough.md) - Real-world application building guides
 
 ---
 

docs/requirements.md

@@ -0,0 +1,419 @@
+# Requirements Document: NATSBridge
+
+**Version**: 1.0.0  
+**Date**: 2026-03-23  
+**Status**: Active  
+**Ground Truth**: [`src/NATSBridge.jl`](../src/NATSBridge.jl)
+
+---
+
+## 1. Business Context & Success Metrics
+
+### 1.1 Business Goal
+
+NATSBridge is a cross-platform, bi-directional data bridge that enables seamless communication between **Julia**, **JavaScript**, **Python**, **Dart**, and **MicroPython** applications using NATS as the message bus. The system implements the **Claim-Check pattern** for efficient handling of large payloads (>0.5MB) by uploading them to an HTTP file server instead of sending raw binary data over NATS.
+
+### 1.2 User Stories (with acceptance criteria)
+
+| Story | Priority | Acceptance Criteria |
+|-------|----------|---------------------|
+| **As a Julia developer**, I want to send text messages to JavaScript/Dart applications that lives on a server and also on a browser | P1 | Text messages are serialized, encoded, and received correctly across platforms |
+| **As a Python developer**, I want to send tabular data to Julia/Dart applications | P1 | DataFrame exchange works with both Arrow IPC and JSON formats |
+| **As a JavaScript developer**, I want to send large files (>0.5MB) from JavaScript applications that lives on a server and also on a browser to other applications | P1 | Large files are automatically uploaded to file server and URLs are sent via NATS |
+| **As a Dart developer**, I want to send text messages to other platforms | P1 | Text messages are serialized, encoded, and received correctly across platforms |
+| **As a Dart developer**, I want to send dictionary data to other platforms | P1 | JSON-serializable data is exchanged correctly |
+| **As a Dart developer**, I want to send tabular data (List<Map>) to other platforms | P1 | JSON table format exchange works with Arrow IPC on desktop |
+| **As a Dart developer**, I want to send large files (>0.5MB) | P1 | Large files are automatically uploaded to file server and URLs are sent via NATS |
+| **As a MicroPython developer**, I want to send sensor data with minimal memory usage | P1 | Direct transport works for payloads <100KB on memory-constrained devices |
+| **As a developer**, I want to send mixed-content messages (text + image + file) | P1 | NATSBridge accepts list of (dataname, data, type) tuples and handles each payload appropriately |
+| **As a developer**, I want to receive multi-payload messages | P1 | NATSBridge returns payloads as list of tuples with correct types preserved |
+| **As a developer**, I want to use Plik as the file server | P2 | Plik one-shot upload mode is supported with upload ID and token handling |
+| **As a developer**, I want to use custom HTTP file servers | P2 | Handler function abstraction allows plugging in AWS S3 or custom implementations |
+| **As a developer**, I want automatic retry on file server download failures | P1 | Exponential backoff with configurable retries (default: 5, base_delay: 100ms, max_delay: 5000ms) |
+| **As a developer**, I want message tracing across distributed systems | P1 | Correlation ID is propagated through all message processing steps |
+
+### 1.3 KPIs & Targets
+
+| Metric | Target | Measurement Method |
+|--------|--------|-------------------|
+| 95% of messages complete within 200ms | 95% | Synthetic monitoring |
+| <2 days from onboarding to first PR | 2 days | PR timeline tracking |
+| 100% of messages validate against spec | 100% | CI block rate |
+| >80% unit test coverage | 80% | Test coverage tools |
+| <1% of PRs bypass validation gates | 1% | CI gate analysis |
+| MTTR <15 minutes for P1 incidents | 15 minutes | Incident tracking |
+
+---
+
+## 2. Technical Boundaries
+
+### 2.1 In Scope
+
+| Feature | Description |
+|---------|-------------|
+| Cross-platform interoperability | Seamless data exchange between Julia, JavaScript, Python, Dart, and MicroPython |
+| Intelligent transport selection | Direct transport (<0.5MB) vs Link transport (≥0.5MB) based on payload size |
+| Unified API | Consistent `smartsend()` and `smartreceive()` functions across all platforms |
+| Multi-payload support | List of (dataname, data, type) tuples with appropriate handling |
+| File server integration | Plik one-shot upload and custom HTTP server support |
+| Reliability features | Exponential backoff retry and correlation ID propagation |
+| Message serialization | Converts data types to binary format (Base64, JSON, Arrow IPC) |
+| NATS communication | Publishing and subscription via NATS subjects |
+
+### 2.2 Out of Scope
+
+| Feature | Reason |
+|---------|--------|
+| NATS JetStream support | Core NATS sufficient for current use cases |
+| Message compression | Compression adds complexity without clear benefit |
+| Message encryption | Payload encryption is application-layer concern |
+| Persistent message queues | NATS request-reply pattern sufficient |
+| Advanced routing rules | Simple NATS subject matching sufficient |
+
+### 2.3 Dependencies
+
+| Platform | Package | Version |
+|----------|---------|---------|
+| Julia | NATS.jl | Latest stable |
+| Julia | JSON.jl | Latest stable |
+| Julia | Arrow.jl | Latest stable |
+| Julia | HTTP.jl | Latest stable |
+| Julia | UUIDs.jl | Latest stable |
+| Node.js | nats | Latest stable |
+| Node.js | node-fetch | Latest stable |
+| Python | nats-py | Latest stable |
+| Python | aiohttp | Latest stable |
+| Python | pyarrow | Latest stable |
+| Browser | nats.ws | Latest stable |
+| Dart | nats | Latest stable |
+| Dart | http | Latest stable |
+| Dart | uuid | Latest stable |
+
+### 2.4 Platform Compatibility
+
+| Platform | Minimum Version | Notes |
+|----------|-----------------|-------|
+| Julia | 1.7+ | Arrow.jl required for arrowtable support |
+| Node.js | 16+ | nats.js required, Arrow IPC supported |
+| Python | 3.8+ | pyarrow required for arrowtable support |
+| Browser | Latest | No Arrow IPC (uses jsontable only) |
+| Dart | 2.17+ | Supports Desktop (Dart SDK), Flutter (Dart SDK), and Web (Dart SDK) |
+| MicroPython | 1.19+ | Limited to direct transport |
+
+---
+
+## 3. Functional Requirements (FR)
+
+| ID | Requirement | Description |
+|----|-------------|-------------|
+| **FR-001** | Cross-platform text messaging | System shall allow users to send text messages between Julia, JavaScript, Python, and MicroPython applications |
+| **FR-002** | Cross-platform tabular data | System shall support DataFrame exchange between Julia and Python applications using Arrow IPC format |
+| **FR-003** | Large file handling | System shall automatically detect payloads ≥0.5MB and upload them to HTTP file server instead of sending via NATS |
+| **FR-004** | Direct transport for small payloads | System shall send payloads <0.5MB directly via NATS without file server upload |
+| **FR-005** | MicroPython support | System shall support payloads <100KB on MicroPython devices using direct transport |
+| **FR-006** | Multi-payload messages | System shall accept and process lists of (dataname, data, type) tuples |
+| **FR-007** | Payload type preservation | System shall preserve payload types when returning multi-payload messages |
+| **FR-008** | Plik file server integration | System shall support Plik one-shot upload mode with upload ID and token handling |
+| **FR-009** | Custom file server support | System shall provide handler function abstraction for custom HTTP file server implementations |
+| **FR-010** | Exponential backoff retry | System shall implement exponential backoff with configurable retries (default: 5, base_delay: 100ms, max_delay: 5000ms) for file server download failures |
+| **FR-011** | Correlation ID propagation | System shall propagate correlation IDs through all message processing steps |
+| **FR-012** | Message serialization | System shall serialize data types using Base64, JSON, or Arrow IPC encoding |
+| **FR-013** | NATS publishing | System shall publish messages to NATS subjects |
+| **FR-014** | NATS subscription | System shall receive and process NATS messages |
+
+---
+
+## 4. Non-Functional Requirements (NFRs)
+
+### 4.1 Performance & Scalability
+
+| ID | Requirement | Specification | Test Method |
+|----|-------------|---------------|-------------|
+| **NFR-101** | Message serialization overhead | <50ms for 10KB payload | Benchmark tests |
+| **NFR-102** | Message deserialization overhead | <50ms for 10KB payload | Benchmark tests |
+| **NFR-103** | NATS connection establishment | <100ms | Connection pool benchmarks |
+| **NFR-104** | File upload latency | <1s for 0.5MB file | Integration tests |
+| **NFR-105** | File download latency | <1s for 0.5MB file | Integration tests |
+| **NFR-106** | Concurrent connections | Support 100+ simultaneous NATS connections | Scale testing |
+| **NFR-107** | Message throughput | Handle 1000+ messages/second per instance | Load testing |
+| **NFR-108** | File server scalability | Support horizontal scaling of file server backend | Architecture review |
+
+### 4.2 Availability & Reliability
+
+| ID | Requirement | Specification |
+|----|-------------|---------------|
+| **NFR-201** | Message delivery | At-least-once delivery semantics via NATS |
+| **NFR-202** | File server availability | Graceful degradation when file server is unavailable |
+| **NFR-203** | Connection recovery | Auto-reconnect on NATS connection failure |
+
+### 4.3 Privacy & Security
+
+| ID | Requirement | Specification |
+|----|-------------|---------------|
+| **NFR-301** | Payload integrity | SHA-256 checksum support via metadata |
+| **NFR-302** | Transport security | TLS support for NATS connections |
+| **NFR-303** | File server security | Authentication token for file uploads |
+
+### 4.4 Observability & Telemetry
+
+| ID | Requirement | Specification |
+|----|-------------|---------------|
+| **NFR-401** | Required logs | `correlation_id`, `msg_id`, `timestamp`, `sender_name`, `receiver_name`, `payload_type`, `transport` |
+| **NFR-402** | Critical metrics | `messages_sent_total`, `messages_received_total`, `file_upload_duration_seconds`, `file_download_duration_seconds`, `retry_attempts_total` |
+| **NFR-403** | Tracing | Correlation ID propagation for request tracing |
+| **NFR-404** | Alerting | `download_retry_exceeded` triggers alert when max retries exceeded |
+| **NFR-405** | Retention | Logs: 30 days, Metrics: 1 year |
+
+---
+
+## 5. Acceptance Conditions
+
+| Condition | Description |
+|-----------|-------------|
+| **AC-001** | All functional requirements FR-001 through FR-014 are implemented and tested |
+| **AC-002** | All non-functional requirements NFR-101 through NFR-405 meet specified targets |
+| **AC-003** | Cross-platform text message test passes (Julia ↔ JavaScript ↔ Python) |
+| **AC-004** | Cross-platform tabular data test passes with Arrow IPC round-trip (Desktop) |
+| **AC-005** | Cross-platform tabular data test passes with JSON table round-trip (Browser) |
+| **AC-006** | Large file transfer test passes with file server upload/download |
+| **AC-007** | Multi-payload mixed content test passes with all payload types in one message |
+| **AC-008** | CI validation gates block PRs on specification violations |
+| **AC-009** | Unit test coverage exceeds 80% |
+| **AC-010** | Documentation is complete and includes walkthroughs, architecture, and runbook |
+
+---
+
+## 6. Payload Type Requirements
+
+### 6.1 Supported Payload Types
+
+| Type | Julia | JavaScript | Python | Dart | MicroPython | Description |
+|------|-------|------------|--------|------|-------------|-------------|
+| `text` | `String` | `string` | `str` | `String` | `str` | Plain text strings |
+| `dictionary` | `Dict`, `NamedTuple` | `Object`, `Array` | `dict`, `list` | `Map` | `dict` | JSON-serializable data |
+| `arrowtable` | `DataFrame`, `Arrow.Table` | ❌ (Browser), ✅ (Node.js) | `pandas.DataFrame` | `List<Map>` (Desktop), `List<dynamic>` (Flutter) | ❌ | Tabular data (Arrow IPC) |
+| `jsontable` | `Vector{NamedTuple}` | `Array<Object>` | `list[dict]` | `List<Map>` | ⚠️ | Tabular data (JSON) - **Only table type in Browser** |
+| `image` | `Vector{UInt8}` | `Uint8Array`, `Buffer` | `bytes` | `Uint8List` | `bytearray` | Image binary data |
+| `audio` | `Vector{UInt8}` | `Uint8Array`, `Buffer` | `bytes` | `Uint8List` | `bytearray` | Audio binary data |
+| `video` | `Vector{UInt8}` | `Uint8Array`, `Buffer` | `bytes` | `Uint8List` | `bytearray` | Video binary data |
+| `binary` | `Vector{UInt8}`, `IOBuffer` | `Uint8Array`, `Buffer` | `bytes`, `bytearray` | `Uint8List` | `bytearray` | Generic binary data |
+
+### 6.2 Encoding Requirements
+
+| Payload Type | Encoding Method | Notes |
+|--------------|-----------------|-------|
+| `text` | UTF-8 → Base64 | Text must be String type |
+| `dictionary` | JSON → Base64 | JSON.jl for Julia |
+| `arrowtable` | Arrow IPC → Base64 | Requires Arrow.jl/pyarrow (Desktop only) |
+| `jsontable` | JSON → Base64 | Human-readable format - **Browser uses this only** |
+| `image`/`audio`/`video`/`binary` | Direct → Base64 | Binary data preserved |
+
+---
+
+## 7. Size Threshold Requirements
+
+### 7.1 Direct Transport Threshold
+
+| Platform | Threshold | Notes |
+|----------|-----------|-------|
+| Desktop (Julia/JS/Python/Dart) | 0.5MB | Default size threshold |
+| Dart Desktop | 0.5MB | Default size threshold |
+| Dart Flutter | 0.5MB | Default size threshold |
+| Dart Web | 0.5MB | Default size threshold |
+| MicroPython | 100KB | Lower threshold for memory constraints |
+
+### 7.2 Maximum Payload Size
+
+| Platform | Maximum | Notes |
+|----------|---------|-------|
+| Desktop | Unlimited | Limited by NATS server configuration |
+| Dart Desktop | Unlimited | Limited by NATS server configuration |
+| Dart Flutter | Unlimited | Limited by NATS server configuration |
+| Dart Web | Unlimited | Limited by NATS server configuration |
+| MicroPython | 50KB | Hard limit due to 256KB-1MB memory |
+
+---
+
+## 8. Message Envelope Requirements
+
+### 8.1 Required Fields
+
+| Field | Type | Purpose |
+|-------|------|---------|
+| `correlation_id` | String (UUID) | Track message flow across systems |
+| `msg_id` | String (UUID) | Unique message identifier |
+| `timestamp` | String (ISO 8601) | Message publication timestamp |
+| `send_to` | String | NATS subject to publish to |
+| `msg_purpose` | String | ACK, NACK, updateStatus, shutdown, chat |
+| `sender_name` | String | Sender application name |
+| `sender_id` | String (UUID) | Sender unique identifier |
+| `receiver_name` | String | Receiver application name (empty = broadcast) |
+| `receiver_id` | String (UUID) | Receiver unique identifier (empty = broadcast) |
+| `reply_to` | String | Topic for reply messages |
+| `reply_to_msg_id` | String | Message ID being replied to |
+| `broker_url` | String | NATS server URL |
+| `metadata` | Dict | Message-level metadata |
+| `payloads` | Array | List of payload objects |
+
+### 8.2 Payload Fields
+
+| Field | Type | Purpose |
+|-------|------|---------|
+| `id` | String (UUID) | Unique payload identifier |
+| `dataname` | String | Name of the payload |
+| `payload_type` | String | Type: text, dictionary, arrowtable, etc. |
+| `transport` | String | direct or link |
+| `encoding` | String | none, json, base64, arrow-ipc |
+| `size` | Integer | Payload size in bytes |
+| `data` | Any | Base64 string or URL |
+| `metadata` | Dict | Payload-level metadata |
+
+---
+
+## 9. Error Handling Requirements
+
+### 9.1 Error Codes
+
+| Error | Condition | Response |
+|-------|-----------|----------|
+| `Unknown payload_type` | Unsupported type | Throw error |
+| `Failed to upload` | File server error | Throw error |
+| `Failed to fetch` | File server unavailable | Retry with exponential backoff |
+| `Unknown transport` | Invalid transport type | Throw error |
+| `NATS connection failed` | NATS unavailable | Throw error |
+
+### 9.2 Exception Handling
+
+| Scenario | Handler |
+|----------|---------|
+| File server unavailable | Retry up to 5 times with exponential backoff |
+| NATS publish failure | Connection auto-reconnect |
+| Deserialization error | Log correlation ID and throw error |
+| Memory overflow (MicroPython) | Reject payloads >50KB |
+
+---
+
+## 10. Testing Requirements
+
+### 10.1 Unit Tests
+
+| Test Category | Coverage | Files |
+|---------------|----------|-------|
+| Serialization | All payload types | `test/test_*_sender.*` |
+| Deserialization | All payload types | `test/test_*_receiver.*` |
+| Transport selection | Direct vs link | `test/test_*_mix_payloads.*` |
+| File server upload | Plik integration | Platform-specific |
+| File server download | Exponential backoff | Platform-specific |
+
+### 10.2 Integration Tests
+
+| Test Scenario | Success Criteria |
+|-------------|-----------------|
+| Cross-platform text message | Julia ↔ JavaScript ↔ Python |
+| Cross-platform tabular data (Desktop) | Arrow IPC round-trip |
+| Cross-platform tabular data (Browser) | JSON table round-trip |
+| Large file transfer | File server upload/download |
+| Multi-payload mixed content | All payload types in one message |
+
+---
+
+## 11. API Contract
+
+### 11.1 smartsend Signature
+
+```julia
+function smartsend(
+    subject::String,
+    data::AbstractArray{Tuple{String, Any, String}};
+    broker_url::String = "nats://localhost:4222",
+    fileserver_url::String = "http://localhost:8080",
+    fileserver_upload_handler::Function = plik_oneshot_upload,
+    size_threshold::Int = 1_000_000,
+    correlation_id::String = string(uuid4()),
+    msg_purpose::String = "chat",
+    sender_name::String = "NATSBridge",
+    receiver_name::String = "",
+    receiver_id::String = "",
+    reply_to::String = "",
+    reply_to_msg_id::String = "",
+    is_publish::Bool = true,
+    NATS_connection::Union{NATS.Connection, Nothing} = nothing,
+    msg_id::String = string(uuid4()),
+    sender_id::String = string(uuid4())
+)::Tuple{msg_envelope_v1, String}
+```
+
+### 11.2 smartreceive Signature
+
+```julia
+function smartreceive(
+    msg::NATS.Msg;
+    fileserver_download_handler::Function = _fetch_with_backoff,
+    max_retries::Int = 5,
+    base_delay::Int = 100,
+    max_delay::Int = 5000
+)::JSON.Object{String, Any}
+```
+
+---
+
+## 12. Deployment Requirements
+
+### 12.1 Minimum Infrastructure
+
+| Component | Minimum | Notes |
+|-----------|---------|-------|
+| NATS Server | 1 instance | Single node for development |
+| File Server | 1 instance | HTTP server for large payloads |
+| Client Memory | 50MB | Desktop platforms (Julia/JS/Python/Dart) |
+| Client Memory | 256KB | MicroPython devices |
+
+### 12.2 Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `NATS_URL` | `nats://localhost:4222` | NATS server URL |
+| `FILESERVER_URL` | `http://localhost:8080` | HTTP file server URL |
+| `SIZE_THRESHOLD` | `1000000` | Size threshold in bytes |
+
+---
+
+## 13. Versioning
+
+### 13.1 Current Version
+
+- **Major**: 1 (Breaking changes require major version bump)
+- **Minor**: 0 (Feature additions)
+- **Patch**: 0 (Bug fixes)
+
+### 13.2 Version Compatibility
+
+| Version | Supported Platforms |
+|---------|---------------------|
+| v1.0.x | Julia 1.7+, Node.js 16+, Python 3.8+, Dart 2.17+, Browser (latest), MicroPython 1.19+ |
+
+---
+
+## 14. Change Log
+
+| Date | Version | Changes |
+|------|---------|---------|
+| 2026-03-23 | 1.0.0 | Updated to ASG Framework requirements structure |
+
+---
+
+## 15. References
+
+- [`src/NATSBridge.jl`](../src/NATSBridge.jl) - Ground truth implementation (Julia)
+- [`src/natsbridge_ssr.js`](../src/natsbridge_ssr.js) - Server-side JavaScript implementation
+- [`src/natsbridge_csr.js`](../src/natsbridge_csr.js) - Client-side JavaScript implementation
+- [`src/natsbridge.py`](../src/natsbridge.py) - Python implementation
+- [`src/natsbridge.dart`](../src/natsbridge.dart) - Dart implementation
+- [`src/natsbridge_mpy.py`](../src/natsbridge_mpy.py) - MicroPython implementation
+- [`README.md`](../README.md) - Project overview
+- [`docs/specification.md`](./specification.md) - Technical specification
+- [`docs/ui-specification.md`](./ui-specification.md) - UI specification
+- [`docs/walkthrough.md`](./walkthrough.md) - End-to-end walkthrough
+- [`docs/architecture.md`](./architecture.md) - Architecture documentation
+- [`docs/validation.md`](./validation.md) - Validation and CI/CD
+- [`docs/runbook.md`](./runbook.md) - Operational runbook

docs/walkthrough.md

@@ -0,0 +1,799 @@
+# Walkthrough: NATSBridge
+
+**Version**: 1.0.0  
+**Date**: 2026-03-23  
+**Status**: Active  
+**Ground Truth**: [`src/NATSBridge.jl`](../src/NATSBridge.jl)
+
+---
+
+## 1. Executive Summary
+
+This document provides the **end-to-end trace** for NATSBridge - the cross-platform bi-directional data bridge that enables seamless communication between **Julia**, **JavaScript**, **Python**, **Dart**, and **MicroPython** applications using NATS as the message bus.
+
+This walkthrough serves as the primary onboarding guide for new developers and explains:
+- **User scenarios** - Real-world use cases from developer perspective
+- **Why steps are sequenced** - The rationale behind architectural decisions
+- **What could go wrong** - Common failure scenarios and recovery strategies
+
+### 1.1 Specification Traceability
+
+| Walkthrough Section | Specification Reference | Requirement ID(s) | Description |
+|---------------------|-------------------------|-------------------|-------------|
+| Section 2 (Big Picture) | specification.md:2, specification.md:15 | FR-001, FR-002, FR-003, FR-004, FR-005, FR-006, FR-007, FR-012, FR-013, FR-014 | End-to-end system flow diagrams |
+| Section 3 (Chat Scenario) | specification.md:2, specification.md:3, specification.md:5, specification.md:11 | FR-001, FR-006, FR-007, FR-012, FR-013, FR-014 | Chat webapp ↔ Julia backend with mixed payloads |
+| Section 4 (Large File) | specification.md:6, specification.md:7 | FR-003, FR-004, FR-008, FR-009, FR-010, NFR-104, NFR-105 | Large file transfer with link transport |
+| Section 5 (Tabular Data) | specification.md:5, specification.md:10 | FR-002, FR-012, NFR-101, NFR-102 | Arrow IPC tabular data exchange |
+| Section 6 (MicroPython) | specification.md:13, specification.md:17 | FR-005, FR-006, FR-012, NFR-106 | Memory-constrained device communication |
+| Section 7 (Cross-Platform) | specification.md:3, specification.md:4, specification.md:5, specification.md:11 | FR-001, FR-002, FR-003, FR-004, FR-005, FR-006, FR-007, FR-012, FR-013, FR-014 | Multi-platform chat application |
+| Section 8 (Error Handling) | specification.md:9 | FR-008, FR-009, FR-010, NFR-201, NFR-202, NFR-203 | Common error scenarios and recovery |
+| Section 9 (Debugging) | specification.md:4, specification.md:11 | FR-011, NFR-401, NFR-403 | Correlation ID tracking |
+| Section 10 (Performance) | specification.md:7, specification.md:13 | NFR-101, NFR-102, NFR-103, NFR-104, NFR-105, NFR-106, NFR-107 | Optimization strategies |
+| Section 11 (Deployment) | specification.md:12, specification.md:18 | FR-013, FR-014, NFR-201, NFR-203 | Infrastructure requirements |
+
+---
+
+## 2. Overview: The Big Picture
+
+## Overview: The Big Picture
+
+NATSBridge implements the **Claim-Check pattern** for efficient handling of large payloads (>0.5MB):
+
+```mermaid
+flowchart TB
+    subgraph NATSBridge["NATSBridge Module"]
+        direction TB
+        
+        subgraph Sender["Sender (smartsend)"]
+            direction LR
+            S1["Data Tuples<br/>[(dataname, data, type)]"]
+            S2["Serialize Data"]
+            S3["Size Check"]
+            S4["Transport Selection"]
+            S5["Build Envelope"]
+            S6["Publish to NATS"]
+            
+            S1 --> S2
+            S2 --> S3
+            S3 --> S4
+            S4 --> S5
+            S5 --> S6
+        end
+        
+        subgraph Receiver["Receiver (smartreceive)"]
+            direction LR
+            R1["Subscribe to NATS"]
+            R2["Parse Envelope"]
+            R3["Check Transport"]
+            R4["Deserialize Data"]
+            R5["Return Payloads"]
+            
+            R1 --> R2
+            R2 --> R3
+            R3 --> R4
+            R4 --> R5
+        end
+        
+        S6 -.->|Message| R1
+    end
+    
+    subgraph FileServer["HTTP File Server (Plik)"]
+        direction TB
+        FS1["Upload URL"]
+        FS2["Download URL"]
+        
+        S4 -.->|Large Payload| FS1
+        FS1 -.->|URL| S5
+        R3 -.->|Fetch URL| FS2
+    end
+    
+    style NATSBridge fill:#e1f5fe,stroke:#0288d1,stroke-width:2px
+    style Sender fill:#b3e5fc,stroke:#0288d1
+    style Receiver fill:#b3e5fc,stroke:#0288d1
+    style FileServer fill:#ffe0b2,stroke:#f57c00
+```
+
+### Key Design Principles
+
+### Key Design Principles
+
+| Principle | Description | Rationale |
+|-----------|-------------|-----------|
+| **Claim-Check Pattern** | Large payloads uploaded to HTTP server, URL sent via NATS | NATS has message size limits; avoids NATS overflow |
+| **Automatic Transport Selection** | Direct (< threshold) vs Link (≥ threshold) based on size | Optimizes memory vs network I/O trade-off |
+| **Cross-Platform API** | Consistent `smartsend()`/`smartreceive()` across all platforms | Simplifies developer experience |
+| **Exponential Backoff** | Retry downloads with increasing delays | Handles transient failures gracefully |
+
+---
+
+## User Scenario 1: Chat Webapp ↔ Julia Backend
+
+### Scenario Description
+
+A JavaScript chat webapp wants to send mixed payloads (text message + user avatar image) to a Julia backend, and receive mixed payloads (text response + AI-generated image) back.
+
+### Step-by-Step Flow
+
+#### Step 1: JavaScript Webapp Sends Mixed Payloads
+
+```javascript
+// JavaScript (Browser or Node.js)
+const [env, msgJson] = await NATSBridge.smartsend(
+    "/agent/wine/api/v1/prompt",
+    [
+        ["msg", "Hello! I'm Ton.", "text"],
+        ["avatar", avatarImageData, "image"]
+    ],
+    {
+        broker_url: "ws://localhost:4222",
+        receiver_name: "agent-backend",
+        msg_purpose: "chat"
+    }
+);
+```
+
+**Rationale**:
+- **Why mixed payloads?** Real chat apps often send both text and images together
+- **Why text first?** Text is smaller, sent via direct transport (fast, no file server needed)
+- **Why image second?** Images may trigger link transport if >0.5MB
+
+#### Step 2: Transport Selection
+
+For each payload, NATSBridge determines transport:
+
+| Payload | Size | Transport | Reason |
+|---------|------|-----------|--------|
+| `"msg"` (text) | ~20 bytes | direct | < 0.5MB threshold |
+| `"avatar"` (image) | ~150KB | direct | < 0.5MB threshold |
+
+**Rationale**:
+- Direct transport is faster for small payloads (no file server round-trip)
+- Link transport is used when payload ≥ 0.5MB (avoids NATS size limits)
+
+#### Step 3: Serialization and Encoding
+
+Each payload is serialized:
+
+| Payload | Type | Serialization | Encoding |
+|---------|------|---------------|----------|
+| `"msg"` | `text` | UTF-8 bytes | Base64 |
+| `"avatar"` | `image` | Raw bytes | Base64 |
+
+**Rationale**:
+- Text uses UTF-8 encoding for human-readable data
+- Images use raw bytes to preserve binary data integrity
+- All payloads encoded as Base64 for JSON compatibility
+
+#### Step 4: Envelope Building
+
+NATSBridge builds the message envelope:
+
+```json
+{
+  "correlation_id": "a1b2c3d4...",
+  "msg_id": "e5f6g7h8...",
+  "timestamp": "2026-03-13T16:30:00.000Z",
+  "send_to": "/agent/wine/api/v1/prompt",
+  "msg_purpose": "chat",
+  "sender_name": "chat-webapp",
+  "sender_id": "sender-uuid...",
+  "receiver_name": "agent-backend",
+  "receiver_id": "",
+  "reply_to": "/agent/wine/api/v1/response",
+  "reply_to_msg_id": "",
+  "broker_url": "ws://localhost:4222",
+  "metadata": {},
+  "payloads": [
+    {
+      "id": "payload-uuid...",
+      "dataname": "msg",
+      "payload_type": "text",
+      "transport": "direct",
+      "encoding": "base64",
+      "size": 20,
+      "data": "SGVsbG8hIEknIHRlbCB5b3UgSW4gZW5nbGlzaC4=",
+      "metadata": {"payload_bytes": 20}
+    },
+    {
+      "id": "payload-uuid...",
+      "dataname": "avatar",
+      "payload_type": "image",
+      "transport": "direct",
+      "encoding": "base64",
+      "size": 150000,
+      "data": "iVBORw0KGgoAAAANSUhEUgAA...",
+      "metadata": {"payload_bytes": 150000}
+    }
+  ]
+}
+```
+
+**Rationale**:
+- **correlation_id**: Tracks this chat session across all systems
+- **reply_to**: Tells backend where to send response
+- **payloads array**: Contains all data with metadata for proper handling
+
+#### Step 5: Publish to NATS
+
+```javascript
+await NATSBridge.NATSClient.connect("ws://localhost:4222");
+await NATSBridge.NATSClient.publish("/agent/wine/api/v1/prompt", msgJson);
+```
+
+**Rationale**:
+- NATS provides low-latency message delivery
+- JSON format ensures cross-platform compatibility
+
+#### Step 6: Julia Backend Receives Message
+
+```julia
+# Julia backend
+msg = NATS.subscription.next()  # Get message from NATS
+env = smartreceive(msg)
+
+# env["payloads"] is now:
+# [
+#     ("msg", "Hello! I'm Ton.", "text"),
+#     ("avatar", binary_data, "image")
+# ]
+```
+
+**Rationale**:
+- `smartreceive()` handles both transport types automatically
+- Deserialization is type-aware based on `payload_type`
+- Returns consistent tuple format regardless of transport
+
+#### Step 7: Julia Backend Sends Response
+
+```julia
+# Julia backend processes the message
+response_text = "Hello Ton! I'm the AI assistant."
+generated_image = generate_ai_image(response_text)
+
+env, msg_json = smartsend(
+    "/agent/wine/api/v1/response",
+    [
+        ("response", response_text, "text"),
+        ("generated_image", generated_image, "image")
+    ],
+    reply_to = "/chat/user/v1/message",
+    reply_to_msg_id = msg["msg_id"]
+)
+```
+
+**Rationale**:
+- **Mixed response**: Text explanation + AI-generated image
+- **reply_to**: Ensures response goes to correct topic
+- **reply_to_msg_id**: Links response to original message for tracing
+
+---
+
+## User Scenario 2: Large File Transfer
+
+### Scenario Description
+
+A JavaScript webapp wants to upload a large file (10MB) to a Julia backend for processing.
+
+### Step-by-Step Flow
+
+#### Step 1: JavaScript Webapp Sends Large File
+
+```javascript
+const [env, msgJson] = await NATSBridge.smartsend(
+    "/agent/wine/api/v1/process",
+    [
+        ["file", largeFileData, "binary"]
+    ],
+    {
+        broker_url: "ws://localhost:4222",
+        receiver_name: "agent-backend"
+    }
+);
+```
+
+#### Step 2: Transport Selection (Link)
+
+| Payload | Size | Transport | Reason |
+|---------|------|-----------|--------|
+| `"file"` | 10MB | link | ≥ 0.5MB threshold |
+
+**Rationale**:
+- Link transport used for large payloads
+- File server handles large file upload
+- NATS only sends URL (small message)
+
+#### Step 3: File Server Upload
+
+```javascript
+// NATSBridge internally calls:
+const response = await plikOneshotUpload(
+    "http://localhost:8080",
+    "file",
+    largeFileData
+);
+
+// Response:
+// {
+//   status: 200,
+//   uploadid: "UPLOAD_ID",
+//   fileid: "FILE_ID",
+//   url: "http://localhost:8080/file/UPLOAD_ID/FILE_ID/file"
+// }
+```
+
+**Rationale**:
+- Plik handles multipart upload
+- One-shot mode simplifies API
+- Returns URL for download
+
+#### Step 4: Envelope with Link Transport
+
+```json
+{
+  "correlation_id": "a1b2c3d4...",
+  "payloads": [
+    {
+      "id": "payload-uuid...",
+      "dataname": "file",
+      "payload_type": "binary",
+      "transport": "link",
+      "encoding": "none",
+      "size": 10000000,
+      "data": "http://localhost:8080/file/UPLOAD_ID/FILE_ID/file",
+      "metadata": {}
+    }
+  ]
+}
+```
+
+**Rationale**:
+- `data` field contains URL instead of Base64
+- `transport: "link"` signals URL-based download
+- `encoding: "none"` indicates no additional encoding
+
+#### Step 5: Julia Backend Receives and Downloads
+
+```julia
+# Julia backend
+msg = NATS.subscription.next()
+env = smartreceive(msg)
+
+# NATSBridge automatically:
+# 1. Extracts URL from payload
+# 2. Downloads with exponential backoff
+# 3. Deserializes to binary data
+```
+
+**Rationale**:
+- Exponential backoff handles transient failures
+- Automatic download simplifies receiver code
+- Binary data returned directly
+
+---
+
+## User Scenario 3: Tabular Data Exchange
+
+### Scenario Description
+
+A Python application sends tabular data (pandas DataFrame) to a Julia backend for analysis, and receives processed results back.
+
+### Step-by-Step Flow
+
+#### Step 1: Python Sends Tabular Data
+
+```python
+# Python
+import pandas as pd
+from natsbridge import smartsend
+
+df = pd.DataFrame({
+    "id": [1, 2, 3],
+    "name": ["Alice", "Bob", "Charlie"],
+    "score": [95, 88, 92]
+})
+
+env, msg_json = await smartsend(
+    "/agent/wine/api/v1/analyze",
+    [("data", df, "arrowtable")],
+    broker_url="nats://localhost:4222",
+    receiver_name="agent-backend"
+)
+```
+
+**Rationale**:
+- `arrowtable` type for efficient tabular data transfer
+- Arrow IPC format preserves data types
+- Much faster than JSON serialization
+
+#### Step 2: Serialization to Arrow IPC
+
+```python
+# NATSBridge internally:
+import pyarrow as pa
+import pyarrow.ipc as ipc
+
+table = pa.Table.from_pandas(df)
+buf = io.BytesIO()
+sink = ipc.new_file(buf, table.schema)
+ipc.write_table(table, sink)
+arrow_bytes = buf.getvalue()
+```
+
+**Rationale**:
+- Arrow IPC preserves column types
+- Binary format is compact
+- No schema information loss
+
+#### Step 3: Julia Receives and Deserializes
+
+```julia
+# Julia backend
+msg = NATS.subscription.next()
+env = smartreceive(msg)
+
+# env["payloads"][1] is now:
+# ("data", DataFrame with id, name, score columns, "arrowtable")
+```
+
+**Rationale**:
+- Arrow.jl reads IPC format directly
+- DataFrame returned with correct types
+- No manual parsing needed
+
+#### Step 4: Julia Sends Results
+
+```julia
+# Julia backend
+results = analyze_data(env["payloads"][1][2])
+
+# Send results back
+env, msg_json = smartsend(
+    "/agent/wine/api/v1/results",
+    [("results", results, "arrowtable")],
+    reply_to = "/python/worker/v1/results"
+)
+```
+
+**Rationale**:
+- Arrow IPC format for efficient round-trip
+- Results preserve DataFrame structure
+- Python can deserialize to pandas DataFrame
+
+---
+
+## User Scenario 4: MicroPython Device
+
+### Scenario Description
+
+A MicroPython sensor device sends sensor readings to a Python backend.
+
+### Step-by-Step Flow
+
+#### Step 1: MicroPython Sends Sensor Data
+
+```python
+# MicroPython
+from natsbridge import smartsend
+
+sensor_data = {
+    "temperature": 25.5,
+    "humidity": 60.0,
+    "pressure": 1013.25
+}
+
+env, msg_json = smartsend(
+    "/sensor/device/v1/readings",
+    [("data", sensor_data, "dictionary")],
+    broker_url="nats://localhost:4222",
+    size_threshold=100000  # 100KB for MicroPython
+)
+```
+
+**Rationale**:
+- `dictionary` type for JSON-serializable sensor data
+- Smaller threshold (100KB) for memory constraints
+- Direct transport only (no file server support)
+
+#### Step 2: Serialization
+
+```python
+# NATSBridge internally:
+json_str = json.dumps(sensor_data)
+json_bytes = json_str.encode('utf-8')
+payload_b64 = base64.b64encode(json_bytes).decode('ascii')
+```
+
+**Rationale**:
+- JSON format for human-readable data
+- Base64 for NATS compatibility
+- UTF-8 for text encoding
+
+#### Step 3: Python Backend Receives
+
+```python
+# Python backend
+msg = await nats_consumer.next()
+env = await smartreceive(msg)
+
+# env["payloads"][0] is now:
+# ("data", {"temperature": 25.5, "humidity": 60.0, ...}, "dictionary")
+```
+
+**Rationale**:
+- JSON deserialization
+- Dictionary returned directly
+- No Arrow support (memory constraints)
+
+---
+
+## User Scenario 5: Cross-Platform Chat with Mixed Payloads
+
+### Scenario Description
+
+Multiple platforms (JavaScript, Python, Julia) communicate in a chat application with mixed payload types.
+
+### Step-by-Step Flow
+
+#### Step 1: JavaScript Sends Chat Message
+
+```javascript
+// JavaScript (Frontend)
+const [env, msgJson] = await NATSBridge.smartsend(
+    "/chat/user/v1/message",
+    [
+        ["text", "Check this out!", "text"],
+        ["image", imageData, "image"]
+    ],
+    {
+        broker_url: "ws://localhost:4222",
+        receiver_name: "",
+        msg_purpose: "chat"
+    }
+);
+```
+
+**Rationale**:
+- Empty `receiver_name` = broadcast to all subscribers
+- Chat messages often include text + images
+- NATS wildcard subscriptions route to correct recipients
+
+#### Step 2: Python Backend Receives
+
+```python
+# Python (Backend)
+msg = await nats_consumer.next()
+env = await smartreceive(msg)
+
+# env["payloads"] is now:
+# [
+#     ("text", "Check this out!", "text"),
+#     ("image", binary_data, "image")
+# ]
+```
+
+**Rationale**:
+- Consistent API across platforms
+- Same payload structure regardless of sender
+- Type information preserved
+
+#### Step 3: Julia Backend Receives
+
+```julia
+# Julia (Backend)
+msg = NATS.subscription.next()
+env = smartreceive(msg)
+
+# env["payloads"] is now:
+# [
+#     ("text", "Check this out!", "text"),
+#     ("image", binary_data, "image")
+# ]
+```
+
+**Rationale**:
+- Cross-platform API parity
+- Same function signature across platforms
+- Type information enables proper deserialization
+
+#### Step 4: All Platforms Reply
+
+Each platform can reply using the same API:
+
+```python
+# Python reply
+await smartsend(
+    "/chat/user/v1/reply",
+    [("response", "Nice!", "text")],
+    reply_to="/chat/user/v1/message"
+)
+```
+
+```julia
+# Julia reply
+smartsend(
+    "/chat/user/v1/reply",
+    [("response", "Nice!", "text")],
+    reply_to="/chat/user/v1/message"
+)
+```
+
+```javascript
+// JavaScript reply
+await NATSBridge.smartsend(
+    "/chat/user/v1/reply",
+    [["response", "Nice!", "text"]],
+    { reply_to: "/chat/user/v1/message" }
+);
+```
+
+**Rationale**:
+- Same API across platforms
+- Consistent behavior
+- Easy to maintain parity
+
+---
+
+## Error Handling
+
+### Common Error Scenarios
+
+| Scenario | Error | Recovery |
+|----------|-------|----------|
+| File server unavailable | `UPLOAD_FAILED` | Fall back to direct transport or smaller payloads |
+| File server download fails | `DOWNLOAD_FAILED` | Retry with exponential backoff |
+| Payload type mismatch | `DESERIALIZATION_ERROR` | Validate payload_type matches data |
+| NATS connection lost | `NATS_CONNECTION_FAILED` | NATS client auto-reconnects |
+
+### Error Response Format
+
+```json
+{
+  "correlation_id": "abc123...",
+  "error": {
+    "code": "DOWNLOAD_FAILED",
+    "message": "Failed to fetch data after 5 attempts",
+    "details": {
+      "url": "http://localhost:8080/file/...",
+      "correlation_id": "abc123..."
+    }
+  }
+}
+```
+
+---
+
+## Debugging and Tracing
+
+### Correlation ID Tracking
+
+Every message includes a `correlation_id`:
+
+```julia
+# At start of request
+correlation_id = string(uuid4())
+
+# Use throughout the flow
+log_trace(correlation_id, "Starting smartsend")
+log_trace(correlation_id, "Serialized payload size: 100 bytes")
+log_trace(correlation_id, "Published to NATS")
+```
+
+**Log Format**:
+```
+[2026-03-13T16:30:00.000Z] [Correlation: abc123...] Starting smartsend
+[2026-03-13T16:30:00.001Z] [Correlation: abc123...] Serialized payload size: 100 bytes
+[2026-03-13T16:30:00.002Z] [Correlation: abc123...] Published to NATS
+```
+
+---
+
+## Performance Considerations
+
+### Optimization Strategies
+
+| Strategy | Description | When to Use |
+|----------|-------------|-------------|
+| Pre-create NATS connection | Reuse connection for multiple sends | High-throughput scenarios |
+| Adjust size threshold | Increase threshold if file server slow | File server bottleneck |
+| Use direct transport | Avoid file server for small payloads | Low latency requirements |
+
+### Size Threshold by Platform
+
+| Platform | Threshold | Notes |
+|----------|-----------|-------|
+| Desktop (Julia/JS/Python/Dart) | 500,000 bytes (0.5MB) | Default threshold |
+| Dart Desktop | 500,000 bytes (0.5MB) | Default threshold |
+| Dart Flutter | 500,000 bytes (0.5MB) | Default threshold |
+| Dart Web | 500,000 bytes (0.5MB) | Default threshold |
+| MicroPython | 100,000 bytes (100KB) | Lower threshold for memory constraints |
+
+---
+
+## Deployment Considerations
+
+### Minimum Infrastructure
+
+| Component | Minimum | Notes |
+|-----------|---------|-------|
+| NATS Server | 1 instance | Single node for development |
+| File Server | 1 instance | HTTP server for large payloads |
+| Client Memory | 50MB | Desktop platforms (Julia/JS/Python/Dart) |
+| Client Memory | 256KB | MicroPython devices |
+
+### Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `NATS_URL` | `nats://localhost:4222` | NATS server URL |
+| `FILESERVER_URL` | `http://localhost:8080` | HTTP file server URL |
+| `SIZE_THRESHOLD` | `1000000` | Size threshold in bytes |
+
+---
+
+## Change Log
+
+| Date | Version | Changes |
+|------|---------|---------|
+| 2026-03-13 | 1.0.0 | Initial walkthrough documentation |
+
+---
+
+## 12. References
+
+### 12.1 Documentation Artifacts
+
+| Document | Purpose | Specification Traceability |
+|----------|---------|---------------------------|
+| [`docs/requirements.md`](./requirements.md) | Business requirements and user stories | FR-001 through FR-014, NFR-101 through NFR-405 |
+| [`docs/specification.md`](./specification.md) | Technical contract for NATSBridge | specification.md:2-19 (all sections) |
+| [`docs/ui-specification.md`](./ui-specification.md) | UI specification for client applications | UI components for data entry and display |
+| [`docs/walkthrough.md`](./walkthrough.md) | End-to-end system flow | This document |
+| [`docs/architecture.md`](./architecture.md) | System architecture diagrams | Component interaction and data flow |
+| [`docs/validation.md`](./validation.md) | CI/CD validation rules | Contract testing and spec compliance |
+| [`docs/runbook.md`](./runbook.md) | Operational runbook | Deployment, scaling, and troubleshooting |
+
+### 12.2 Implementation Files
+
+| File | Platform | Features | Specification Traceability |
+|------|----------|----------|---------------------------|
+| [`src/NATSBridge.jl`](../src/NATSBridge.jl) | Julia | Full feature set, Arrow IPC, multiple dispatch | specification.md:2-19 (all sections) |
+| [`src/natsbridge_ssr.js`](../src/natsbridge_ssr.js) | Node.js | Arrow IPC, async/await | specification.md:2-19 (all sections) |
+| [`src/natsbridge_csr.js`](../src/natsbridge_csr.js) | Browser | JSON table only, WebSocket NATS | specification.md:2-19 (all sections) |
+| [`src/natsbridge.py`](../src/natsbridge.py) | Python | Arrow IPC, async/await | specification.md:2-19 (all sections) |
+| [`src/natsbridge.dart`](../src/natsbridge.dart) | Dart | Full feature set, Arrow IPC, async/await | specification.md:2-19 (all sections) |
+| [`src/natsbridge_mpy.py`](../src/natsbridge_mpy.py) | MicroPython | Limited to direct transport | specification.md:2-19 (all sections) |
+
+---
+
+## 13. Change Log
+
+| Date | Version | Changes | Specification Reference |
+|------|---------|---------|------------------------|
+| 2026-03-23 | 1.0.0 | Updated to ASG Framework walkthrough guidelines | All sections |
+| 2026-03-13 | 1.0.0 | Initial walkthrough documentation | specification.md:2-19 (all sections) |
+
+---
+
+## 14. Gap-Check Validation
+
+| Stage Transition | Gap-Check Question | Status |
+|------------------|-------------------|--------|
+| Requirements → Specification | Does the Specification define all edge cases and conflict scenarios from the Requirements? | ✅ Verified - All FR-XXX requirements have corresponding spec rules |
+| Specification → UI Specification | Does the UI Specification expose all the data and states defined in the Specification? | ⏳ Pending - UI spec not yet created |
+| UI Specification → Walkthrough | Does the Walkthrough reflect the complete flow including error states and timing? | ⏳ Pending - UI spec not yet created |
+| Walkthrough → Architecture | Does the Architecture support the performance and integration requirements defined in the Walkthrough? | ⏳ Pending - Architecture not yet created |
+
+---
+
+*This walkthrough document is versioned and maintained in git alongside the codebase. All implementations must adhere to this documentation.*
+
+---
+
+*This walkthrough document is versioned and maintained in git alongside the codebase. All implementations must adhere to this documentation.*
+
+<tool_call>
+<function=update_todo_list>
+<parameter=todos>
+[x] Analyze existing documentation (requirements.md, spec.md, architecture.md)
+[x] Read all source files in src/ folder
+[x] Write docs/walkthrough.md according to SDD framework with user scenarios

etc.jl

@@ -1,38 +0,0 @@
-Task: Update README.md to reflect recent changes in NATSbridge package.
-
-Context: the package has been updated with the NATS_connection keyword and the publish_message function.
-
-Requirements:
-
-Source of Truth: Treat the updated NATSbridge code as the definitive source. Update README.md to align exactly with these changes.
-API Consistency: Ensure the Main Package API (e.g., smartsend(), publish_message()) uses consistent naming across all three supported languages.
-Ecosystem Variance: Low-level native functions (e.g., NATS.connect(), JSON.read()) should follow the conventions of the specific language ecosystem and do not require cross-language consistency.
-
-
-
-
-
-
-
-
-
-
-
-
-
-Help me expands this Julia package (NATSBridge) into a cross-platform project by adding a JavaScript and Python/MicroPython implementation. To ensure accuracy,  NATSBridge.jl will serve as the ground truth, as the documentation may be outdated.
-
-My goal is to maintain interface parity at the high-level API for a consistent user experience, while ensuring the low-level implementation adheres strictly to the idiomatic conventions of each respective language (e.g., multiple dispatch in Julia vs. asynchronous, prototype, or class-based patterns in JS and Python/MicroPython)
-
-Now do the following:
-1) check docs to see if there is any mistake.
-
-
-
-
-
-
-
-
-
-

etc.txt

@@ -0,0 +1,310 @@
+#!/usr/bin/env julia
+# Test script for mixed-content message testing
+# Tests receiving a mix of text, json, table, image, audio, video, and binary data
+# from Julia serviceA to Julia serviceB using NATSBridge.jl smartreceive
+#
+# This test demonstrates that any combination and any number of mixed content
+# can be sent and received correctly.
+
+using NATS, JSON, UUIDs, Dates, PrettyPrinting, DataFrames, Arrow, HTTP, Base64
+
+# Include the bridge module
+include("./src/NATSBridge.jl")
+using .NATSBridge
+
+# Configuration
+const SUBJECT = "/test/mix"
+const NATS_URL = "nats.yiem.cc"
+const FILESERVER_URL = "http://192.168.88.104:8080"
+
+
+# ------------------------------------------------------------------------------------------------ #
+#                                      test mixed content transfer                                 #
+# ------------------------------------------------------------------------------------------------ #
+
+
+# Helper: Log with correlation ID
+function log_trace(message)
+    timestamp = Dates.now()
+    println("[$timestamp] $message")
+end
+
+
+# Receiver: Listen for messages and verify mixed content handling
+function test_mix_receive()
+    conn = NATS.connect(NATS_URL)
+    incoming_msg = nothing
+    NATS.subscribe(conn, SUBJECT) do msg
+        log_trace("Received message on $(msg.subject)")
+        incoming_msg = msg
+        
+        # # Use NATSBridge.smartreceive to handle the data
+        # # API: smartreceive(msg, download_handler; max_retries, base_delay, max_delay)
+        # result = NATSBridge.smartreceive(
+        #     msg;
+        #     max_retries = 5,
+        #     base_delay = 100,
+        #     max_delay = 5000
+        # )
+        
+        # log_trace("Received $(length(result["payloads"])) payloads")
+        
+        
+        # # Result is an envelope dictionary with payloads field containing list of (dataname, data, data_type) tuples
+        # for (dataname, data, data_type) in result["payloads"]
+        #     log_trace("\n=== Payload: $dataname (type: $data_type) ===")
+            
+        #     # Handle different data types
+        #     if data_type == "text"
+        #         # Text data - should be a String
+        #         if isa(data, String)
+        #             log_trace("  Type: String")
+        #             log_trace("  Length: $(length(data)) characters")
+                    
+        #             # Display first 200 characters
+        #             if length(data) > 200
+        #                 log_trace("  First 200 chars: $(data[1:200])...")
+        #             else
+        #                 log_trace("  Content: $data")
+        #             end
+                    
+        #             # Save to file
+        #             output_path = "./received_$dataname.txt"
+        #             write(output_path, data)
+        #             log_trace("  Saved to: $output_path")
+        #         else
+        #             log_trace("  ERROR: Expected String, got $(typeof(data))")
+        #         end
+                
+        #     elseif data_type == "dictionary"
+        #         # Dictionary data - should be JSON object
+        #         if isa(data, JSON.Object{String, Any})
+        #             log_trace("  Type: Dict")
+        #             log_trace("  Keys: $(keys(data))")
+                    
+        #             # Display nested content
+        #             for (key, value) in data
+        #                 log_trace("  $key => $value")
+        #             end
+                    
+        #             # Save to JSON file
+        #             output_path = "./received_$dataname.json"
+        #             json_str = JSON.json(data, 2)
+        #             write(output_path, json_str)
+        #             log_trace("  Saved to: $output_path")
+        #         else
+        #             log_trace("  ERROR: Expected Dict, got $(typeof(data))")
+        #         end
+                
+        #     elseif data_type == "table"
+        #         # Table data - should be a DataFrame
+        #         tabledata = deepcopy(data)
+        #         println("found table data")
+        #         break
+        #         # return data
+        #         # if isa(data, DataFrame)
+        #         #     log_trace("  Type: DataFrame")
+        #         #     log_trace("  Dimensions: $(size(data, 1)) rows x $(size(data, 2)) columns")
+        #         #     log_trace("  Columns: $(names(data))")
+                    
+        #         #     # Display first few rows
+        #         #     log_trace("  First 5 rows:")
+        #         #     display(data[1:min(5, size(data, 1)), :])
+                    
+        #         #     # Save to Arrow file
+        #         #     output_path = "./received_$dataname.arrow"
+        #         #     io = IOBuffer()
+        #         #     Arrow.write(io, data)
+        #         #     write(output_path, take!(io))
+        #         #     log_trace("  Saved to: $output_path")
+        #         # else
+        #         #     log_trace("  ERROR: Expected DataFrame, got $(typeof(data))")
+        #         # end
+                
+        #     elseif data_type == "image"
+        #         # Image data - should be Vector{UInt8}
+        #         if isa(data, Vector{UInt8})
+        #             log_trace("  Type: Vector{UInt8} (binary)")
+        #             log_trace("  Size: $(length(data)) bytes")
+                    
+        #             # Save to file
+        #             output_path = "./received_$dataname.bin"
+        #             write(output_path, data)
+        #             log_trace("  Saved to: $output_path")
+        #         else
+        #             log_trace("  ERROR: Expected Vector{UInt8}, got $(typeof(data))")
+        #         end
+                
+        #     elseif data_type == "audio"
+        #         # Audio data - should be Vector{UInt8}
+        #         if isa(data, Vector{UInt8})
+        #             log_trace("  Type: Vector{UInt8} (binary)")
+        #             log_trace("  Size: $(length(data)) bytes")
+                    
+        #             # Save to file
+        #             output_path = "./received_$dataname.bin"
+        #             write(output_path, data)
+        #             log_trace("  Saved to: $output_path")
+        #         else
+        #             log_trace("  ERROR: Expected Vector{UInt8}, got $(typeof(data))")
+        #         end
+                
+        #     elseif data_type == "video"
+        #         # Video data - should be Vector{UInt8}
+        #         if isa(data, Vector{UInt8})
+        #             log_trace("  Type: Vector{UInt8} (binary)")
+        #             log_trace("  Size: $(length(data)) bytes")
+                    
+        #             # Save to file
+        #             output_path = "./received_$dataname.bin"
+        #             write(output_path, data)
+        #             log_trace("  Saved to: $output_path")
+        #         else
+        #             log_trace("  ERROR: Expected Vector{UInt8}, got $(typeof(data))")
+        #         end
+                
+        #     elseif data_type == "binary"
+        #         # Binary data - should be Vector{UInt8}
+        #         if isa(data, Vector{UInt8})
+        #             log_trace("  Type: Vector{UInt8} (binary)")
+        #             log_trace("  Size: $(length(data)) bytes")
+                    
+        #             # Save to file
+        #             output_path = "./received_$dataname.bin"
+        #             write(output_path, data)
+        #             log_trace("  Saved to: $output_path")
+        #         else
+        #             log_trace("  ERROR: Expected Vector{UInt8}, got $(typeof(data))")
+        #         end
+                
+        #     else
+        #         log_trace("  ERROR: Unknown data type '$data_type'")
+        #     end
+        # end
+        
+        # Summary
+        # println("\n=== Verification Summary ===")
+        # text_count = count(x -> x[3] == "text", result["payloads"])
+        # dict_count = count(x -> x[3] == "dictionary", result["payloads"])
+        # table_count = count(x -> x[3] == "table", result["payloads"])
+        # image_count = count(x -> x[3] == "image", result["payloads"])
+        # audio_count = count(x -> x[3] == "audio", result["payloads"])
+        # video_count = count(x -> x[3] == "video", result["payloads"])
+        # binary_count = count(x -> x[3] == "binary", result["payloads"])
+        
+        # log_trace("Text payloads: $text_count")
+        # log_trace("Dictionary payloads: $dict_count")
+        # log_trace("Table payloads: $table_count")
+        # log_trace("Image payloads: $image_count")
+        # log_trace("Audio payloads: $audio_count")
+        # log_trace("Video payloads: $video_count")
+        # log_trace("Binary payloads: $binary_count")
+        
+        # # Print transport type info for each payload if available
+        # println("\n=== Payload Details ===")
+        # for (dataname, data, data_type) in result["payloads"]
+        #     if data_type in ["image", "audio", "video", "binary"]
+        #         log_trace("$dataname: $(length(data)) bytes (binary)")
+        #     elseif data_type == "table"
+        #       data = DataFrame(data)
+        #         log_trace("$dataname: $(size(data, 1)) rows x $(size(data, 2)) columns (DataFrame)")
+        #     elseif data_type == "dictionary"
+        #         log_trace("$dataname: $(length(JSON.json(data))) bytes (Dict)")
+        #     elseif data_type == "text"
+        #         log_trace("$dataname: $(length(data)) characters (String)")
+        #     end
+        # end
+    end
+    
+    # Keep listening for 2 minutes
+    sleep(20)  
+    NATS.drain(conn)
+    return incoming_msg
+end
+
+
+# Run the test
+println("Starting mixed-content transport test...")
+println("Note: This receiver will wait for messages from the sender.")
+println("Run test_julia_to_julia_mix_sender.jl first to send test data.")
+
+# Run receiver
+println("\ntesting smartreceive for mixed content")
+incoming_msg = test_mix_receive()
+
+println("\nTest completed.")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Check architecture.md. For sending table I want to add JSON in addition to Apache Arrow. 
+Currently I use "table" datatype when sending table data using Arrow. Now table that I want to send using JSON 
+I will use "jsontable" as datatype while sending table using Arrow I will use "arrowtable" as datatype. 
+This will select how smartsend and smartreceive serialize/deserialize the table.
+
+Can you help me do this? Save the updated architecture.md into updated_architecture.md file. I will deal with source code later.
+
+
+
+
+Now update implementation.md and save into updated_implementation.md
+Keep in mind that Julia DataFrame and Python Pandas rely on columnar-oriented dictionary to create as the following example:
+julia> dict = Dict("customer age" => [15, 20, 25],
+                   "first name" => ["Rohit", "Rahul", "Akshat"])
+julia> DataFrame(dict)
+
+python> data = {
+    "Name": ["Alice", "Bob", "Charlie"],
+    "Age": [25, 30, 35],
+    "Score": [88.5, 92.0, 79.5]
+}
+
+python> df = pd.DataFrame(data)
+
+
+But JS use Array of Objects while MicroPython use list of lists. Both are row-oriented structure.
+So use row-oriented JSON to send across these languages. For Julia and Python, only convert 
+row-oriented JSON to columnar-oriented dictionary for "going-into" and vise versa for "coming-out" 
+a dataframe while JS and MicroPython won't require such process. 
+You may add these info into architecture.md if you see fit.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

examples/tutorial.md

@@ -1,731 +0,0 @@
-# Cross-Platform NATSBridge Tutorial
-
-A step-by-step guide to get started with NATSBridge across **Julia**, **JavaScript**, and **Python/MicroPython**.
-
-## Table of Contents
-
-1. [Overview](#overview)
-2. [Prerequisites](#prerequisites)
-3. [Installation](#installation)
-4. [Quick Start](#quick-start)
-5. [Basic Examples](#basic-examples)
-6. [Advanced Usage](#advanced-usage)
-
----
-
-## Overview
-
-NATSBridge enables seamless communication across platforms through NATS, with automatic transport selection based on payload size:
-
-- **Direct Transport**: Payloads < 1MB are sent directly via NATS (Base64 encoded)
-- **Link Transport**: Payloads >= 1MB are uploaded to an HTTP file server and referenced via URL
-
-### Cross-Platform API Parity
-
-All three platforms use the same high-level API:
-
-```
-# Input format
-smartsend(subject, [(dataname, data, type), ...], options)
-
-# Output format
-(env, env_json_str) = smartsend(...)
-env = smartreceive(msg, options)
-```
-
-### Supported Payload Types
-
-| Type | Julia | JavaScript | Python | MicroPython |
-|------|-------|------------|--------|-------------|
-| `text` | `String` | `string` | `str` | `str` |
-| `dictionary` | `Dict` | `Object` | `dict` | `dict` |
-| `table` | `DataFrame` | `Array<Object>` | `DataFrame` | ❌ |
-| `image` | `Vector{UInt8}` | `Uint8Array` | `bytes` | `bytearray` |
-| `audio` | `Vector{UInt8}` | `Uint8Array` | `bytes` | `bytearray` |
-| `video` | `Vector{UInt8}` | `Uint8Array` | `bytes` | `bytearray` |
-| `binary` | `Vector{UInt8}` | `Uint8Array` | `bytes` | `bytearray` |
-
----
-
-## Prerequisites
-
-Before you begin, ensure you have:
-
-1. **NATS Server** running (or accessible)
-2. **HTTP File Server** (optional, for large payloads > 1MB)
-3. **Platform-specific packages** installed
-
----
-
-## Installation
-
-### Julia
-
-```julia
-using Pkg
-Pkg.add("NATS")
-Pkg.add("Arrow")
-Pkg.add("JSON3")
-Pkg.add("HTTP")
-Pkg.add("UUIDs")
-Pkg.add("Dates")
-```
-
-### JavaScript (Node.js)
-
-```bash
-npm install nats uuid apache-arrow node-fetch
-```
-
-### JavaScript (Browser)
-
-```html
-<script src="https://unpkg.com/nats-js/dist/bundle/nats.min.js"></script>
-<script src="https://unpkg.com/apache-arrow/arrow.min.js"></script>
-```
-
-### Python (Desktop)
-
-```bash
-pip install nats-py aiohttp pyarrow pandas
-```
-
-### MicroPython
-
-Uses built-in modules: `network`, `socket`, `time`, `json`, `base64`
-
----
-
-## Quick Start
-
-### Step 1: Start NATS Server
-
-```bash
-docker run -p 4222:4222 nats:latest
-```
-
-### Step 2: Start HTTP File Server (Optional)
-
-```bash
-mkdir -p /tmp/fileserver
-python3 -m http.server 8080 --directory /tmp/fileserver
-```
-
-### Step 3: Send Your First Message
-
-#### Julia
-
-```julia
-using NATSBridge
-
-# Send a text message
-data = [("message", "Hello World", "text")]
-env, env_json_str = smartsend("/chat/room1", data, broker_url="nats://localhost:4222")
-# env: msg_envelope_v1 struct with all metadata and payloads
-# env_json_str: JSON string representation of the envelope for publishing
-println("Message sent!")
-
-# Or use is_publish=false to get envelope and JSON without publishing
-env, env_json_str = smartsend("/chat/room1", data, broker_url="nats://localhost:4222", is_publish=false)
-# env: msg_envelope_v1 struct
-# env_json_str: JSON string for publishing to NATS
-```
-
-#### JavaScript
-
-```javascript
-const NATSBridge = require('./src/natbridge.js');
-
-// Send a text message
-const data = [["message", "Hello World", "text"]];
-const [env, env_json_str] = await NATSBridge.smartsend(
-    "/chat/room1",
-    data,
-    { broker_url: "nats://localhost:4222" }
-);
-// env: Object with all metadata and payloads
-// env_json_str: JSON string for publishing
-console.log("Message sent!");
-
-// Or use is_publish=false
-const [env, env_json_str] = await NATSBridge.smartsend(
-    "/chat/room1",
-    data,
-    { broker_url: "nats://localhost:4222", is_publish: false }
-);
-```
-
-#### Python
-
-```python
-from natbridge import smartsend
-
-# Send a text message
-data = [("message", "Hello World", "text")]
-env, env_json_str = await smartsend(
-    "/chat/room1",
-    data,
-    broker_url="nats://localhost:4222"
-)
-# env: Dict with all metadata and payloads
-# env_json_str: JSON string for publishing
-print("Message sent!")
-
-# Or use is_publish=False
-env, env_json_str = await smartsend(
-    "/chat/room1",
-    data,
-    broker_url="nats://localhost:4222",
-    is_publish=False
-)
-# env: Dict with all metadata and payloads
-# env_json_str: JSON string for publishing to NATS
-```
-
-#### MicroPython
-
-```python
-from natbridge_mpy import NATSBridge
-
-bridge = NATSBridge()
-
-# Send a text message (limited to small payloads)
-data = [("message", "Hello World", "text")]
-env, env_json_str = bridge.smartsend(
-    "/chat/room1",
-    data,
-    size_threshold=100000  # Lower threshold for MicroPython
-)
-print("Message sent!")
-```
-
-### Step 4: Receive Messages
-
-#### Julia
-
-```julia
-using NATSBridge
-
-# Receive and process message
-env = smartreceive(msg; fileserver_download_handler=_fetch_with_backoff)
-# Returns: ::JSON.Object{String, Any} with "payloads" field containing Vector{Tuple{String, Any, String}}
-# Access payloads: for (dataname, data, type) in env["payloads"]
-for (dataname, data, type) in env["payloads"]
-    println("Received $dataname: $data")
-end
-```
-
-#### JavaScript
-
-```javascript
-const NATSBridge = require('./src/natbridge.js');
-
-// Receive and process message
-const env = await NATSBridge.smartreceive(msg, {
-    fileserver_download_handler: NATSBridge.fetchWithBackoff
-});
-// env.payloads = [[dataname, data, type], ...]
-for (const [dataname, data, type] of env.payloads) {
-    console.log(`Received ${dataname}:`, data);
-}
-```
-
-#### Python
-
-```python
-from natbridge import smartreceive, fetch_with_backoff
-
-# Receive and process message
-env = await smartreceive(
-    msg,
-    fileserver_download_handler=fetch_with_backoff
-)
-# env["payloads"] = [(dataname, data, type), ...]
-for dataname, data, type_ in env["payloads"]:
-    print(f"Received {dataname}: {data}")
-```
-
----
-
-## Basic Examples
-
-### Example 1: Sending a Dictionary
-
-#### Julia
-
-```julia
-using NATSBridge
-
-config = Dict(
-    "wifi_ssid" => "MyNetwork",
-    "wifi_password" => "password123",
-    "update_interval" => 60
-)
-
-data = [("config", config, "dictionary")]
-env, env_json_str = smartsend("/device/config", data, broker_url="nats://localhost:4222")
-```
-
-#### JavaScript
-
-```javascript
-const NATSBridge = require('./src/natbridge.js');
-
-const config = {
-    wifi_ssid: "MyNetwork",
-    wifi_password: "password123",
-    update_interval: 60
-};
-
-const data = [["config", config, "dictionary"]];
-const [env, env_json_str] = await NATSBridge.smartsend(
-    "/device/config",
-    data,
-    { broker_url: "nats://localhost:4222" }
-);
-```
-
-#### Python
-
-```python
-from natbridge import smartsend
-
-config = {
-    "wifi_ssid": "MyNetwork",
-    "wifi_password": "password123",
-    "update_interval": 60
-}
-
-data = [("config", config, "dictionary")]
-env, env_json_str = await smartsend(
-    "/device/config",
-    data,
-    broker_url="nats://localhost:4222"
-)
-```
-
-#### MicroPython
-
-```python
-from natbridge_mpy import NATSBridge
-
-bridge = NATSBridge()
-
-config = {
-    "wifi_ssid": "MyNetwork",
-    "wifi_password": "password123",
-    "update_interval": 60
-}
-
-data = [("config", config, "dictionary")]
-env, env_json_str = bridge.smartsend(
-    "/device/config",
-    data,
-    size_threshold=100000
-)
-```
-
-### Example 2: Sending Binary Data (Image)
-
-#### Julia
-
-```julia
-using NATSBridge
-
-# Read image file
-image_data = read("image.png")
-
-data = [("user_image", image_data, "binary")]
-env, env_json_str = smartsend("/chat/image", data, broker_url="nats://localhost:4222")
-```
-
-#### JavaScript
-
-```javascript
-const NATSBridge = require('./src/natbridge.js');
-const fs = require('fs');
-
-// Read image file
-const image_data = fs.readFileSync('image.png');
-
-const data = [["user_image", image_data, "binary"]];
-const [env, env_json_str] = await NATSBridge.smartsend(
-    "/chat/image",
-    data,
-    { broker_url: "nats://localhost:4222" }
-);
-```
-
-#### Python
-
-```python
-from natbridge import smartsend
-
-# Read image file
-with open("image.png", "rb") as f:
-    image_data = f.read()
-
-data = [("user_image", image_data, "binary")]
-env, env_json_str = await smartsend(
-    "/chat/image",
-    data,
-    broker_url="nats://localhost:4222"
-)
-```
-
-#### MicroPython
-
-```python
-from natbridge_mpy import NATSBridge
-
-bridge = NATSBridge()
-
-# Read image file
-with open("image.png", "rb") as f:
-    image_data = f.read()
-
-data = [("user_image", image_data, "binary")]
-env, env_json_str = bridge.smartsend(
-    "/chat/image",
-    data,
-    size_threshold=100000
-)
-```
-
-### Example 3: Request-Response Pattern
-
-#### Julia (Requester)
-
-```julia
-using NATSBridge
-
-# Send command with reply-to
-data = [("command", Dict("action" => "read_sensor"), "dictionary")]
-env, env_json_str = smartsend(
-    "/device/command",
-    data,
-    broker_url="nats://localhost:4222",
-    reply_to="/device/response",
-    reply_to_msg_id="cmd-001"
-)
-```
-
-#### JavaScript (Requester)
-
-```javascript
-const NATSBridge = require('./src/natbridge.js');
-
-// Send command with reply-to
-const data = [["command", { action: "read_sensor" }, "dictionary"]];
-const [env, env_json_str] = await NATSBridge.smartsend(
-    "/device/command",
-    data,
-    {
-        broker_url: "nats://localhost:4222",
-        reply_to: "/device/response",
-        reply_to_msg_id: "cmd-001"
-    }
-);
-```
-
-#### Python (Requester)
-
-```python
-from natbridge import smartsend
-
-# Send command with reply-to
-data = [("command", {"action": "read_sensor"}, "dictionary")]
-env, env_json_str = await smartsend(
-    "/device/command",
-    data,
-    broker_url="nats://localhost:4222",
-    reply_to="/device/response",
-    reply_to_msg_id="cmd-001"
-)
-```
-
-#### Julia (Responder)
-
-```julia
-using NATSBridge, NATS
-
-const SUBJECT = "/device/command"
-const NATS_URL = "nats://localhost:4222"
-
-function test_responder()
-    conn = NATS.connect(NATS_URL)
-    NATS.subscribe(conn, SUBJECT) do msg
-        env = smartreceive(msg, fileserver_download_handler=_fetch_with_backoff)
-        
-        reply_to = env["reply_to"]
-        
-        for (dataname, data, type) in env["payloads"]
-            if dataname == "command" && data["action"] == "read_sensor"
-                response = Dict("sensor_id" => "sensor-001", "value" => 42.5)
-                if !isempty(reply_to)
-                    smartsend(reply_to, [("data", response, "dictionary")])
-                end
-            end
-        end
-    end
-    
-    sleep(120)
-    NATS.drain(conn)
-end
-
-test_responder()
-```
-
----
-
-## Advanced Usage
-
-### Example 4: Large Payloads (File Server)
-
-For payloads larger than 1MB, NATSBridge automatically uses the file server:
-
-#### Julia
-
-```julia
-using NATSBridge
-
-# Create large data (> 1MB)
-large_data = rand(UInt8, 2_000_000)
-
-env, env_json_str = smartsend(
-    "/data/large",
-    [("large_file", large_data, "binary")],
-    broker_url="nats://localhost:4222",
-    fileserver_url="http://localhost:8080"
-)
-
-println("File uploaded to: $(env.payloads[1].data)")
-# Note: For link transport, data field contains the URL string
-```
-
-#### JavaScript
-
-```javascript
-const NATSBridge = require('./src/natbridge.js');
-
-// Create large data (> 1MB)
-const large_data = Buffer.alloc(2_000_000);
-for (let i = 0; i < large_data.length; i++) {
-    large_data[i] = Math.floor(Math.random() * 256);
-}
-
-const [env, env_json_str] = await NATSBridge.smartsend(
-    "/data/large",
-    [["large_file", large_data, "binary"]],
-    {
-        broker_url: "nats://localhost:4222",
-        fileserver_url: "http://localhost:8080"
-    }
-);
-
-console.log("File uploaded to:", env.payloads[0].data);
-// Note: For link transport, data field contains the URL string
-```
-
-#### Python
-
-```python
-from natbridge import smartsend
-
-# Create large data (> 1MB)
-import os
-large_data = os.urandom(2_000_000)
-
-env, env_json_str = await smartsend(
-    "/data/large",
-    [("large_file", large_data, "binary")],
-    broker_url="nats://localhost:4222",
-    fileserver_url="http://localhost:8080"
-)
-
-print(f"File uploaded to: {env['payloads'][0]['data']}")
-# Note: For link transport, data field contains the URL string
-```
-
-#### MicroPython
-
-MicroPython enforces a hard limit of 50KB per payload:
-
-```python
-from natbridge_mpy import NATSBridge
-
-bridge = NATSBridge()
-
-# MicroPython has a hard limit of 50KB per payload
-# Use streaming or chunking for larger data
-small_data = bytes(1000)  # 1KB
-
-data = [("small_file", small_data, "binary")]
-env, env_json_str = bridge.smartsend(
-    "/data/small",
-    data,
-    size_threshold=100000  # Enforced max: 50000 bytes
-)
-```
-
-### Example 5: Mixed Content (Chat with Text + Image)
-
-NATSBridge supports sending multiple payloads with different types in a single message:
-
-#### Julia
-
-```julia
-using NATSBridge
-
-image_data = read("avatar.png")
-
-data = [
-    ("message_text", "Hello with image!", "text"),
-    ("user_avatar", image_data, "image")
-]
-
-env, env_json_str = smartsend("/chat/mixed", data, broker_url="nats://localhost:4222")
-```
-
-#### JavaScript
-
-```javascript
-const NATSBridge = require('./src/natbridge.js');
-const fs = require('fs');
-
-const image_data = fs.readFileSync('avatar.png');
-
-const data = [
-    ["message_text", "Hello with image!", "text"],
-    ["user_avatar", image_data, "image"]
-];
-
-const [env, env_json_str] = await NATSBridge.smartsend(
-    "/chat/mixed",
-    data,
-    { broker_url: "nats://localhost:4222" }
-);
-```
-
-#### Python
-
-```python
-from natbridge import smartsend
-
-with open("avatar.png", "rb") as f:
-    image_data = f.read()
-
-data = [
-    ("message_text", "Hello with image!", "text"),
-    ("user_avatar", image_data, "image")
-]
-
-env, env_json_str = await smartsend(
-    "/chat/mixed",
-    data,
-    broker_url="nats://localhost:4222"
-)
-# env: Dict with all metadata and payloads
-```
-
-### Example 6: Table Data (Arrow IPC)
-
-For tabular data, NATSBridge uses Apache Arrow IPC format:
-
-#### Julia
-
-```julia
-using NATSBridge
-using DataFrames
-
-# Create DataFrame
-df = DataFrame(
-    id = [1, 2, 3],
-    name = ["Alice", "Bob", "Charlie"],
-    score = [95, 88, 92]
-)
-
-data = [("students", df, "table")]
-env, env_json_str = smartsend("/data/students", data, broker_url="nats://localhost:4222")
-```
-
-#### JavaScript
-
-```javascript
-const NATSBridge = require('./src/natbridge.js');
-
-// Create table data (array of objects)
-const table_data = [
-    { id: 1, name: "Alice", score: 95 },
-    { id: 2, name: "Bob", score: 88 },
-    { id: 3, name: "Charlie", score: 92 }
-];
-
-const data = [["students", table_data, "table"]];
-const [env, env_json_str] = await NATSBridge.smartsend(
-    "/data/students",
-    data,
-    { broker_url: "nats://localhost:4222" }
-);
-```
-
-#### Python
-
-```python
-from natbridge import smartsend
-import pandas as pd
-
-# Create DataFrame
-df = pd.DataFrame({
-    'id': [1, 2, 3],
-    'name': ['Alice', 'Bob', 'Charlie'],
-    'score': [95, 88, 92]
-})
-
-data = [("students", df, "table")]
-env, env_json_str = await smartsend(
-    "/data/students",
-    data,
-    broker_url="nats://localhost:4222"
-)
-```
-
-#### MicroPython
-
-MicroPython does not support table type due to memory constraints. Use dictionary or binary instead.
-
----
-
-## Next Steps
-
-1. **Explore the test directory** for more examples
-2. **Check the documentation** for advanced configuration options
-3. **Read the walkthrough** for building real-world applications
-
----
-
-## Troubleshooting
-
-### Connection Issues
-
-- Ensure NATS server is running: `docker ps | grep nats`
-- Check firewall settings
-- Verify NATS URL configuration
-
-### File Server Issues
-
-- Ensure file server is running and accessible
-- Check upload permissions
-- Verify file server URL configuration
-
-### Serialization Errors
-
-- Verify data type matches the specified type
-- Check that binary data is in the correct format
-- MicroPython: Ensure payload size < 50KB
-
----
-
-## License
-
-MIT

src/NATSBridge.jl

@@ -31,15 +31,23 @@
 # [(dataname1, data1, type1), (dataname2, data2, type2), ...]
 # ```
 #
-# Supported types: "text", "dictionary", "table", "image", "audio", "video", "binary"
+# Supported types: "text", "dictionary", "arrowtable", "jsontable", "image", "audio", "video", "binary"
+# 
+# Table Datatypes:
+# - `arrowtable`: Apache Arrow IPC format for efficient binary serialization
+#   - Input: DataFrame, Arrow.Table
+#   - Encoding: arrow-ipc
+# - `jsontable`: JSON format for human-readable tabular data
+#   - Input: Vector{NamedTuple}, Vector{Dict}
+#   - Encoding: json
 
 module NATSBridge
 
-using NATS, JSON, Arrow, HTTP, UUIDs, Dates, Base64, PrettyPrinting
+using NATS, JSON, Arrow, HTTP, UUIDs, Dates, Base64, PrettyPrinting, DataFrames
 # ---------------------------------------------- 100 --------------------------------------------- #
 
 # Constants
-const DEFAULT_SIZE_THRESHOLD = 1_000_000  # 1MB - threshold for switching from direct to link transport
+const DEFAULT_SIZE_THRESHOLD = 500_000  # 0.5MB - threshold for switching from direct to link transport
 const DEFAULT_BROKER_URL = "nats://localhost:4222"  # Default NATS server URL
 const DEFAULT_FILESERVER_URL = "http://localhost:8080"  # Default HTTP file server URL for link transport
 
@@ -51,7 +59,7 @@ It supports both direct transport (base64-encoded data) and link transport (URL-
 # Arguments:
   - `id::String` - Unique identifier for this payload (e.g., "uuid4")
   - `dataname::String` - Name of the payload (e.g., "login_image")
-  - `payload_type::String` - Payload type: "text", "dictionary", "table", "image", "audio", "video", "binary"
+  - `payload_type::String` - Payload type: "text", "dictionary", "arrowtable", "jsontable", "image", "audio", "video", "binary"
   - `transport::String` - Transport method: "direct" or "link"
   - `encoding::String` - Encoding method: "none", "json", "base64", "arrow-ipc"
   - `size::Integer` - Size of the payload in bytes (e.g., 15433)
@@ -100,7 +108,7 @@ payload = msg_payload_v1(
 struct msg_payload_v1
   id::String                    # id of this payload e.g. "uuid4"
   dataname::String              # name of this payload e.g. "login_image"
-  payload_type::String                  # this payload type. Can be "text", "dictionary", "table", "image", "audio", "video", "binary"
+  payload_type::String                  # this payload type. Can be "text", "dictionary", "arrowtable", "jsontable", "image", "audio", "video", "binary"
   transport::String             # transport method: "direct" or "link"
   encoding::String              # encoding method: "none", "json", "base64", "arrow-ipc"
   size::Integer                 # data size in bytes e.g. 15433
@@ -292,19 +300,7 @@ function envelope_to_json(env::msg_envelope_v1)
       "encoding" => payload.encoding,
       "size" => payload.size,
     )
-    # Include data based on transport type
-      if payload.transport == "direct" && payload.data !== nothing
-        if payload.encoding == "base64" || payload.encoding == "json"
     payload_obj["data"] = payload.data
-        else
-          # For other encodings, use base64
-          payload_bytes = _get_payload_bytes(payload.data)
-          payload_obj["data"] = Base64.base64encode(payload_bytes)
-        end
-      elseif payload.transport == "link" && payload.data !== nothing
-        # For link transport, data is a URL string - include directly
-        payload_obj["data"] = payload.data
-      end
     if !isempty(payload.metadata)
       payload_obj["metadata"] = Dict(String(k) => v for (k, v) in payload.metadata)
     end
@@ -363,7 +359,7 @@ Each payload can have a different type, enabling mixed-content messages (e.g., c
   - `data::AbstractArray{Tuple{String, Any, String}}` - List of (dataname, data, type) tuples to send
     - `dataname::String` - Name of the payload
     - `data::Any` - The actual data to send
-    - `payload_type::String` - Payload type: "text", "dictionary", "table", "image", "audio", "video", "binary"
+    - `payload_type::String` - Payload type: "text", "dictionary", "arrowtable", "jsontable", "image", "audio", "video", "binary"
   - No standalone `type` parameter - type is specified per payload
 
 # Keyword Arguments:
@@ -399,11 +395,15 @@ env, msg_json = smartsend("my.subject", [("dataname1", data, "dictionary")])
 # Send multiple payloads in one message with different types
 data1 = Dict("key1" => "value1")
 data2 = rand(10_000)  # Small array
-env, msg_json = smartsend("my.subject", [("dataname1", data1, "dictionary"), ("dataname2", data2, "table")])
+env, msg_json = smartsend("my.subject", [("dataname1", data1, "dictionary"), ("dataname2", data2, "arrowtable")])
 
 # Send a large array using fileserver upload
 data = rand(10_000_000)  # ~80 MB
-env, msg_json = smartsend("large.data", [("large_table", data, "table")])
+env, msg_json = smartsend("large.data", [("large_arrow_table", data, "arrowtable")])
+
+# Send jsontable (JSON format)
+rows = [Dict("id" => 1, "name" => "Alice"), Dict("id" => 2, "name" => "Bob")]
+env, msg_json = smartsend("json.data", [("users", rows, "jsontable")])
 
 # Mixed content (e.g., chat with text and image)
 env, msg_json = smartsend("chat.subject", [
@@ -424,13 +424,12 @@ function smartsend(
   fileserver_upload_handler::Function = plik_oneshot_upload,  # a function to handle uploading data to specific HTTP fileserver
   size_threshold::Int = DEFAULT_SIZE_THRESHOLD,
 
-  #=
-    Generate a globally unique identifier (UUID) at the start of the request.
-    This ID must remain constant and immutable as it propagates through every
-    stage of the execution pipeline. It serves as the end-to-end ID for
-    distributed tracing, enabling the correlation of all logs, metrics, and
-    errors across the system back to this specific request instance.
-  =#
+  # Generate a globally unique identifier (UUID) at the start of the request.
+  # This ID must remain constant and immutable as it propagates through every
+  # stage of the execution pipeline. It serves as the end-to-end ID for
+  # distributed tracing, enabling the correlation of all logs, metrics, and
+  # errors across the system back to this specific request instance.
+
   correlation_id::String = string(uuid4()),
   
   msg_purpose::String = "chat",
@@ -451,6 +450,8 @@ function smartsend(
   # Process each payload in the list
   payloads = msg_payload_v1[]
   for (dataname, payload_data, payload_type) in data
+    @show dataname typeof(payload_data)
+
     # Serialize data based on type
     payload_bytes = _serialize_data(payload_data, payload_type)
     
@@ -463,6 +464,14 @@ function smartsend(
       payload_b64 = Base64.base64encode(payload_bytes)  # Encode bytes as base64 string
       log_trace(correlation_id, "Using direct transport for $payload_size bytes")  # Log transport choice
       
+      # Determine encoding based on payload_type
+      encoding = "base64"
+      if payload_type == "jsontable"
+        encoding = "json"
+      elseif payload_type == "arrowtable"
+        encoding = "arrow-ipc"
+      end
+      
       # Create msg_payload_v1 for direct transport
       payload = msg_payload_v1(
         payload_b64,
@@ -470,7 +479,7 @@ function smartsend(
         id = string(uuid4()),
         dataname = dataname,
         transport = "direct",
-        encoding = "base64",
+        encoding = encoding,
         size = payload_size,
         metadata = Dict{String, Any}("payload_bytes" => payload_size)
       )
@@ -489,6 +498,14 @@ function smartsend(
       url = response["url"]  # URL for the uploaded data
       log_trace(correlation_id, "Uploaded to URL: $url")  # Log successful upload
 
+      # Determine encoding based on payload_type
+      encoding = "none"
+      if payload_type == "jsontable"
+        encoding = "json"
+      elseif payload_type == "arrowtable"
+        encoding = "arrow-ipc"
+      end
+
       # Create msg_payload_v1 for link transport
       payload = msg_payload_v1(
         url,
@@ -496,7 +513,7 @@ function smartsend(
         id = string(uuid4()),
         dataname = dataname,
         transport = "link",
-        encoding = "none",
+        encoding = encoding,
         size = payload_size,
         metadata = Dict{String, Any}()
       )
@@ -543,12 +560,13 @@ It supports multiple serialization formats for different data types.
 2. Converts data to binary representation according to format rules
 3. For text: converts string to UTF-8 bytes
 4. For dictionary: serializes as JSON then converts to bytes
-5. For table: uses Arrow.jl to write as IPC stream
-6. For image/audio/video/binary: returns binary data directly
+5. For arrowtable: uses Arrow.jl to write as IPC stream
+6. For jsontable: converts to JSON then to bytes
+7. For image/audio/video/binary: returns binary data directly
 
 # Arguments:
-  - `data::Any` - Data to serialize (string for `"text"`, JSON-serializable for `"dictionary"`, table-like for `"table"`, binary for `"image"`, `"audio"`, `"video"`, `"binary"`)
-  - `payload_type::String` - Target format: "text", "dictionary", "table", "image", "audio", "video", "binary"
+  - `data::Any` - Data to serialize (string for `"text"`, JSON-serializable for `"dictionary"`, table-like for `"arrowtable"`, Vector{NamedTuple}/Vector{Dict} for `"jsontable"`, binary for `"image"`, `"audio"`, `"video"`, `"binary"`)
+  - `payload_type::String` - Target format: "text", "dictionary", "arrowtable", "jsontable", "image", "audio", "video", "binary"
 
 # Return:
   - `Vector{UInt8}` - Binary representation of the serialized data
@@ -569,9 +587,13 @@ text_bytes = _serialize_data(text_data, "text")
 json_data = Dict("name" => "Alice", "age" => 30)
 json_bytes = _serialize_data(json_data, "dictionary")
 
-# Table serialization with a DataFrame (recommended for tabular data)
+# Arrow table serialization with a DataFrame (recommended for tabular data)
 df = DataFrame(id = 1:3, name = ["Alice", "Bob", "Charlie"], score = [95, 88, 92])
-table_bytes = _serialize_data(df, "table")
+arrow_bytes = _serialize_data(df, "arrowtable")
+
+# JSON table serialization - Vector{NamedTuple} or Vector{Dict}
+rows = [Dict("id" => 1, "name" => "Alice"), Dict("id" => 2, "name" => "Bob")]
+json_bytes = _serialize_data(rows, "jsontable")
 
 # Image data (Vector{UInt8})
 image_bytes = UInt8[1, 2, 3]  # Image bytes
@@ -622,10 +644,30 @@ function _serialize_data(data::Any, payload_type::String)
     json_str = JSON.json(data)  # Convert Julia data to JSON string
     json_str_bytes = Vector{UInt8}(json_str) # Convert JSON string to bytes
     return json_str_bytes 
-  elseif payload_type == "table"  # Table data - convert to Arrow IPC stream
+  elseif payload_type == "arrowtable"  # Arrow table data - convert to Arrow IPC stream
     io = IOBuffer()  # Create in-memory buffer
     Arrow.write(io, data)  # Write data as Arrow IPC stream to buffer
     return take!(io)  # Return the buffer contents as bytes
+  elseif payload_type == "jsontable"  # JSON table data - convert to JSON
+    # data can be Vector{NamedTuple}, Vector{Dict}, or DataFrame
+    # If DataFrame, convert to Vector{Dict} first
+    if isa(data, DataFrame)
+      # Convert DataFrame to Vector{Dict} (row-oriented)
+      rows = []
+      for i in 1:nrow(data)
+        row_dict = Dict()
+        for col in names(data)
+          row_dict[String(col)] = data[i, col]
+        end
+        push!(rows, row_dict)
+      end
+      json_str = JSON.json(rows)
+      return Vector{UInt8}(json_str)
+    else
+      # Already Vector{NamedTuple} or Vector{Dict}
+      json_str = JSON.json(data)
+      return Vector{UInt8}(json_str)
+    end
   elseif payload_type == "image"  # Image data - treat as binary
     if isa(data, Vector{UInt8})
         return data  # Return binary data directly
@@ -881,24 +923,25 @@ end
 
 """ _deserialize_data - Deserialize bytes to data based on type
 This internal function converts serialized bytes back to Julia data based on type.
-It handles "text" (string), "dictionary" (JSON deserialization), "table" (Arrow IPC deserialization),
-"image" (binary data), "audio" (binary data), "video" (binary data), and "binary" (binary data).
+It handles "text" (string), "dictionary" (JSON deserialization), "arrowtable" (Arrow IPC deserialization),
+"jsontable" (JSON deserialization), "image" (binary data), "audio" (binary data), "video" (binary data), and "binary" (binary data).
 
 # Function Workflow:
 1. Validates the data type against supported formats
 2. Converts bytes to appropriate Julia data type based on format
 3. For text: converts bytes to string
 4. For dictionary: converts bytes to JSON string then parses to Julia object
-5. For table: reads Arrow IPC format and returns DataFrame
-6. For image/audio/video/binary: returns bytes directly
+5. For arrowtable: reads Arrow IPC format and returns a DataFrame
+6. For jsontable: converts bytes to JSON string then parses to Vector{Dict} and return a DataFrame
+7. For image/audio/video/binary: returns bytes directly
 
 # Arguments:
   - `data::Vector{UInt8}` - Serialized data as bytes
-  - `payload_type::String` - Data type ("text", "dictionary", "table", "image", "audio", "video", "binary")
+  - `payload_type::String` - Data type ("text", "dictionary", "arrowtable", "jsontable", "image", "audio", "video", "binary")
   - `correlation_id::String` - Correlation ID for logging
 
 # Return:
-  - Deserialized data (String for "text", DataFrame for "table", JSON data for "dictionary", bytes for "image", "audio", "video", "binary")
+  - Deserialized data (String for "text", Arrow.Table for "arrowtable", Vector{Dict} for "jsontable", JSON data for "dictionary", bytes for "image", "audio", "video", "binary")
 
 # Throws:
   - `Error` if `payload_type` is not one of the supported types
@@ -913,9 +956,13 @@ text_data = _deserialize_data(text_bytes, "text", "correlation123")
 json_bytes = UInt8[123, 34, 110, 97, 109, 101, 34, 58, 34, 65, 108, 105, 99, 101, 125]  # {"name":"Alice"}
 json_data = _deserialize_data(json_bytes, "dictionary", "correlation123")
 
-# Arrow IPC data (table)
+# Arrow IPC data (arrowtable)
 arrow_bytes = Vector{UInt8}([1, 2, 3])  # Arrow IPC bytes
-table_data = _deserialize_data(arrow_bytes, "table", "correlation123")
+df = _deserialize_data(arrow_bytes, "arrowtable", "correlation123")
+
+# JSON table data (jsontable)
+json_table_bytes = UInt8[91, 123, 34, 105, 100, 34, 58, 49, 44, 34, 110, 97, 109, 101, 34, 58, 34, 65, 108, 105, 99, 101, 34, 125]  # [{"id":1,"name":"Alice"}]
+df = _deserialize_data(json_table_bytes, "jsontable", "correlation123")
 ```
 """
 function _deserialize_data(
@@ -928,10 +975,16 @@ function _deserialize_data(
   elseif payload_type == "dictionary"  # JSON data - deserialize
     json_str = String(data)  # Convert bytes to string
     return JSON.parse(json_str)  # Parse JSON string to JSON object
-  elseif payload_type == "table"  # Table data - deserialize Arrow IPC stream
+  elseif payload_type == "arrowtable"  # Arrow table data - deserialize Arrow IPC stream
     io = IOBuffer(data)  # Create buffer from bytes
-    df = Arrow.Table(io)  # Read Arrow IPC format from buffer
-    return df  # Return DataFrame
+    arrowtable = Arrow.Table(io)  # Read Arrow IPC format from buffer
+    df = DataFrame(arrowtable)
+    return df
+  elseif payload_type == "jsontable"  # JSON table data - deserialize JSON
+    json_str = String(data)  # Convert bytes to string
+    jsontable = JSON.parse(json_str)  # Parse JSON string to jsontable i.e. Vector{Dict}
+    df = DataFrame(jsontable)
+    return df
   elseif payload_type == "image"  # Image data - return binary
     return data  # Return bytes directly
   elseif payload_type == "audio"  # Audio data - return binary
@@ -1106,18 +1159,4 @@ end
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 end # module

src/natsbridge.py

@@ -6,7 +6,7 @@ This module provides functionality for sending and receiving data across network
 using NATS as the message bus, with support for both direct payload transport and
 URL-based transport for larger payloads.
 
-@package natbridge
+@package natsbridge
 """
 
 import asyncio
@@ -34,9 +34,9 @@ except ImportError:
 # ---------------------------------------------- Constants ---------------------------------------------- #
 
 """
-Default size threshold for switching from direct to link transport (1MB)
+Default size threshold for switching from direct to link transport (0.5MB)
 """
-DEFAULT_SIZE_THRESHOLD = 1_000_000
+DEFAULT_SIZE_THRESHOLD = 500_000
 
 """
 Default NATS server URL
@@ -71,8 +71,9 @@ def _serialize_data(data: Any, payload_type: str) -> bytes:
     
     Args:
         data: Data to serialize (string for "text", JSON-serializable for "dictionary",
-              table-like for "table", binary for "image", "audio", "video", "binary")
-        payload_type: Target format: "text", "dictionary", "table", "image", "audio", "video", "binary"
+              table-like for "arrowtable"/"jsontable", binary for "image", "audio", "video", "binary")
+        payload_type: Target format: "text", "dictionary", "arrowtable", "jsontable",
+                      "image", "audio", "video", "binary"
     
     Returns:
         Binary representation of the serialized data
@@ -80,7 +81,8 @@ def _serialize_data(data: Any, payload_type: str) -> bytes:
     Raises:
         Error: If payload_type is not one of the supported types
         Error: If payload_type is "image", "audio", or "video" but data is not bytes
-        Error: If payload_type is "table" but data is not a pandas DataFrame or pyarrow Table
+        Error: If payload_type is "arrowtable" but data is not a pandas DataFrame or pyarrow Table
+        Error: If payload_type is "jsontable" but data is not a list of dicts
     """
     if payload_type == 'text':
         if isinstance(data, str):
@@ -90,9 +92,9 @@ def _serialize_data(data: Any, payload_type: str) -> bytes:
     elif payload_type == 'dictionary':
         json_str = json.dumps(data)
         return json_str.encode('utf-8')
-    elif payload_type == 'table':
+    elif payload_type == 'arrowtable':
         if not ARROW_AVAILABLE:
-            raise RuntimeError('pyarrow not available for table serialization')
+            raise RuntimeError('pyarrow not available for arrowtable serialization')
         
         import io
         buf = io.BytesIO()
@@ -110,7 +112,14 @@ def _serialize_data(data: Any, payload_type: str) -> bytes:
             sink.close()
             return buf.getvalue()
         else:
-            raise ValueError('Table data must be a pandas DataFrame or pyarrow Table')
+            raise ValueError('Arrow table data must be a pandas DataFrame or pyarrow Table')
+    elif payload_type == 'jsontable':
+        # Serialize list of dicts to JSON format
+        if isinstance(data, list) and all(isinstance(row, dict) for row in data):
+            json_str = json.dumps(data)
+            return json_str.encode('utf-8')
+        else:
+            raise ValueError('JSON table data must be a list of dicts')
     elif payload_type == 'image':
         if isinstance(data, (bytes, bytearray)):
             return bytes(data)
@@ -141,12 +150,13 @@ def _deserialize_data(data: bytes, payload_type: str, correlation_id: str) -> An
     
     Args:
         data: Serialized data as bytes
-        payload_type: Data type ("text", "dictionary", "table", "image", "audio", "video", "binary")
+        payload_type: Data type ("text", "dictionary", "arrowtable", "jsontable",
+                      "image", "audio", "video", "binary")
         correlation_id: Correlation ID for logging
     
     Returns:
-        Deserialized data (String for "text", DataFrame for "table", JSON data for "dictionary",
-        bytes for "image", "audio", "video", "binary")
+        Deserialized data (String for "text", DataFrame for "arrowtable",
+        Vector{Dict} for "jsontable"/"dictionary", bytes for "image", "audio", "video", "binary")
     
     Raises:
         Error: If payload_type is not one of the supported types
@@ -156,14 +166,18 @@ def _deserialize_data(data: bytes, payload_type: str, correlation_id: str) -> An
     elif payload_type == 'dictionary':
         json_str = data.decode('utf-8')
         return json.loads(json_str)
-    elif payload_type == 'table':
+    elif payload_type == 'arrowtable':
         if not ARROW_AVAILABLE:
-            raise RuntimeError('pyarrow not available for table deserialization')
+            raise RuntimeError('pyarrow not available for arrowtable deserialization')
         
         import io
         buf = io.BytesIO(data)
         reader = ipc.open_file(buf)
         return reader.read_all().to_pandas()
+    elif payload_type == 'jsontable':
+        # Deserialize JSON to list of dicts
+        json_str = data.decode('utf-8')
+        return json.loads(json_str)
     elif payload_type == 'image':
         return data
     elif payload_type == 'audio':
@@ -317,7 +331,7 @@ class NATSClient:
             self._client = nats.connect(self.url)
             await self._client
         else:
-            raise Error('nats-py not available')
+            raise RuntimeError('nats-py not available')
         return self._client
     
     async def publish(self, subject: str, message: str, correlation_id: str = "") -> None:
@@ -397,12 +411,19 @@ def _build_payload(
     Returns:
         Payload object
     """
+    # Determine encoding based on payload type (matching Julia/JS implementation)
+    encoding = 'base64'
+    if payload_type == 'jsontable':
+        encoding = 'json'
+    elif payload_type == 'arrowtable':
+        encoding = 'arrow-ipc'
+    
     return {
         'id': str(uuid.uuid4()),
         'dataname': dataname,
         'payload_type': payload_type,
         'transport': transport,
-        'encoding': 'base64' if transport == 'direct' else 'none',
+        'encoding': encoding,
         'size': len(payload_bytes),
         'data': data,
         'metadata': {'payload_bytes': len(payload_bytes)} if transport == 'direct' else {}
@@ -476,7 +497,7 @@ async def smartsend(
         data: List of (dataname, data, type) tuples to send
             - dataname: Name of the payload
             - data: The actual data to send
-            - type: Payload type: "text", "dictionary", "table", "image", "audio", "video", "binary"
+            - type: Payload type: "text", "dictionary", "arrowtable", "jsontable", "image", "audio", "video", "binary"
         broker_url: URL of the NATS server
         fileserver_url: URL of the HTTP file server for large payloads
         fileserver_upload_handler: Function to handle fileserver uploads (must return Dict with "status",
@@ -514,14 +535,21 @@ async def smartsend(
         >>> data2 = [1, 2, 3, 4, 5]
         >>> env, env_json_str = await smartsend(
         ...     "my.subject",
-        ...     [("dataname1", data1, "dictionary"), ("dataname2", data2, "table")]
+        ...     [("dataname1", data1, "dictionary"), ("dataname2", data2, "arrowtable")]
         ... )
         >>>
         >>> # Send a large array using fileserver upload
         >>> data = list(range(10_000_000))  # ~80 MB
         >>> env, env_json_str = await smartsend(
         ...     "large.data",
-        ...     [("large_table", data, "table")]
+        ...     [("large_table", data, "arrowtable")]
+        ... )
+        >>>
+        >>> # Send jsontable (JSON format for human-readable tabular data)
+        >>> users = [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]
+        >>> env, env_json_str = await smartsend(
+        ...     "json.data",
+        ...     [("users", users, "jsontable")]
         ... )
         >>>
         >>> # Mixed content (e.g., chat with text and image)

src/natsbridge_csr.js

@@ -0,0 +1,915 @@
+/**
+ * NATSBridge - Cross-Platform Bi-Directional Data Bridge
+ * Browser-Compatible Implementation (Client-Side Rendering)
+ * 
+ * This module provides functionality for sending and receiving data across network boundaries
+ * using NATS as the message bus, with support for both direct payload transport and
+ * URL-based transport for larger payloads.
+ * 
+ * Supported payload types: "text", "dictionary", "jsontable", "image", "audio", "video", "binary"
+ * Note: Browser version does NOT support Apache Arrow IPC (arrowtable) due to browser compatibility constraints.
+ * Use "jsontable" for tabular data in browser applications.
+ * 
+ * Browser requirements:
+ * - Modern browser with ES module support (or use module bundler)
+ * - Web Crypto API for UUID generation
+ * - Fetch API for HTTP requests
+ * - WebSocket support for NATS connections (use ws:// or wss:// URLs)
+ * 
+ * Browser-compatible version uses:
+ * - nats.ws for WebSocket-based NATS connections
+ * - Web Crypto API for UUID generation
+ * - Uint8Array instead of Buffer
+ * - fetch API for file server communication
+ * 
+ * @module NATSBridgeCSR
+ */
+
+// Import browser-compatible NATS client
+import * as nats from 'nats.ws';
+
+// Use native fetch available in browsers
+
+// ---------------------------------------------- Constants ---------------------------------------------- //
+
+/**
+ * Default size threshold for switching from direct to link transport (0.5MB)
+ */
+const DEFAULT_SIZE_THRESHOLD = 500_000;
+
+/**
+ * Default NATS server URL (WebSocket protocol)
+ */
+const DEFAULT_BROKER_URL = 'ws://localhost:4222';
+
+/**
+ * Default HTTP file server URL for link transport
+ */
+const DEFAULT_FILESERVER_URL = 'http://localhost:8080';
+
+// ---------------------------------------------- Utility Functions ---------------------------------------------- //
+
+/**
+ * Convert Uint8Array to Base64 string
+ * @param {Uint8Array} data - Data to encode
+ * @returns {string} Base64 encoded string
+ */
+function bufferToBase64(data) {
+    const bytes = new Uint8Array(data);
+    const binary = String.fromCharCode(...bytes);
+    return btoa(binary);
+}
+
+/**
+ * Convert Base64 string to Uint8Array
+ * @param {string} base64 - Base64 encoded string
+ * @returns {Uint8Array} Decoded binary data
+ */
+function base64ToBuffer(base64) {
+    const binary = atob(base64);
+    const len = binary.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+
+/**
+ * Convert Uint8Array to Base64 string (Unicode-safe version)
+ * Uses TextEncoder/TextDecoder for proper Unicode handling
+ * @param {Uint8Array} data - Data to encode
+ * @returns {string} Base64 encoded string
+ */
+function bufferToBase64UnicodeSafe(data) {
+    const bytes = new Uint8Array(data);
+    // Use TextDecoder to properly handle the bytes as text
+    const binary = String.fromCharCode(...bytes);
+    return btoa(binary);
+}
+
+/**
+ * Convert Base64 string to Uint8Array (Unicode-safe version)
+ * @param {string} base64 - Base64 encoded string
+ * @returns {Uint8Array} Decoded binary data
+ */
+function base64ToBufferUnicodeSafe(base64) {
+    const binary = atob(base64);
+    const len = binary.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+
+/**
+ * Generate UUID v4 using Web Crypto API
+ * @returns {string} UUID string
+ */
+function uuidv4() {
+    const array = new Uint8Array(16);
+    crypto.getRandomValues(array);
+    array[6] = (array[6] & 0x0f) | 0x40;
+    array[8] = (array[8] & 0x3f) | 0x80;
+    return Array.from(array, (val) => val.toString(16).padStart(2, '0').toUpperCase()).join('');
+}
+
+/**
+ * Log a trace message with correlation ID and timestamp
+ * @param {string} correlationId - Correlation ID for tracing
+ * @param {string} message - Message content to log
+ */
+function logTrace(correlationId, message) {
+    const timestamp = new Date().toISOString();
+    console.log(`[${timestamp}] [Correlation: ${correlationId}] ${message}`);
+}
+
+// ---------------------------------------------- Serialization Functions ---------------------------------------------- //
+
+/**
+ * Serialize data according to specified format
+ * @param {any} data - Data to serialize
+ * @param {string} payloadType - Target format: "text", "dictionary", "jsontable", "image", "audio", "video", "binary"
+ * @returns {Uint8Array} Binary representation of the serialized data
+ */
+async function serializeData(data, payloadType) {
+    if (payloadType === 'text') {
+        if (typeof data === 'string') {
+            return new Uint8Array(new TextEncoder().encode(data));
+        } else {
+            throw new Error('Text data must be a string');
+        }
+    } else if (payloadType === 'dictionary') {
+        const jsonStr = JSON.stringify(data);
+        return new Uint8Array(new TextEncoder().encode(jsonStr));
+    } else if (payloadType === 'jsontable') {
+        // Serialize array of objects to JSON format
+        if (!Array.isArray(data)) {
+            throw new Error('JSON table data must be an array');
+        }
+        const jsonStr = JSON.stringify(data);
+        return new Uint8Array(new TextEncoder().encode(jsonStr));
+    } else if (payloadType === 'image') {
+        if (data instanceof Uint8Array || data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+            return new Uint8Array(data);
+        } else {
+            throw new Error('Image data must be Uint8Array, ArrayBuffer, or ArrayBuffer view');
+        }
+    } else if (payloadType === 'audio') {
+        if (data instanceof Uint8Array || data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+            return new Uint8Array(data);
+        } else {
+            throw new Error('Audio data must be Uint8Array, ArrayBuffer, or ArrayBuffer view');
+        }
+    } else if (payloadType === 'video') {
+        if (data instanceof Uint8Array || data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+            return new Uint8Array(data);
+        } else {
+            throw new Error('Video data must be Uint8Array, ArrayBuffer, or ArrayBuffer view');
+        }
+    } else if (payloadType === 'binary') {
+        if (data instanceof Uint8Array || data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+            return new Uint8Array(data);
+        } else {
+            throw new Error('Binary data must be Uint8Array, ArrayBuffer, or ArrayBuffer view');
+        }
+    } else {
+        throw new Error(`Unknown payload_type: ${payloadType}`);
+    }
+}
+
+/**
+ * Deserialize bytes to data based on type
+ * @param {Uint8Array|ArrayBuffer} data - Serialized data as bytes
+ * @param {string} payloadType - Data type
+ * @param {string} correlationId - Correlation ID for logging
+ * @returns {any} Deserialized data
+ */
+async function deserializeData(data, payloadType, correlationId) {
+    const buffer = data instanceof Uint8Array ? data : new Uint8Array(data);
+    
+    logTrace(correlationId, `deserializeData: type=${payloadType}, bufferLength=${buffer.length}`);
+    
+    // Debug: Show first 20 bytes in hex for binary data
+    if (payloadType === 'jsontable' || payloadType === 'image' || payloadType === 'binary') {
+        const hexPreview = [];
+        for (let i = 0; i < Math.min(20, buffer.length); i++) {
+            hexPreview.push(buffer[i].toString(16).padStart(2, '0'));
+        }
+        logTrace(correlationId, `deserializeData: First 20 bytes (hex): ${hexPreview.join(' ')}`);
+    }
+    
+    if (payloadType === 'text') {
+        const result = new TextDecoder().decode(buffer);
+        logTrace(correlationId, `deserializeData: text result length=${result.length}`);
+        return result;
+    } else if (payloadType === 'dictionary') {
+        const jsonStr = new TextDecoder().decode(buffer);
+        const result = JSON.parse(jsonStr);
+        logTrace(correlationId, `deserializeData: dictionary keys=${Object.keys(result).join(', ')}`);
+        return result;
+    } else if (payloadType === 'jsontable') {
+        const jsonStr = new TextDecoder().decode(buffer);
+        const result = JSON.parse(jsonStr);
+        logTrace(correlationId, `deserializeData: jsontable result length=${Array.isArray(result) ? result.length : 'N/A'}`);
+        return result;
+    } else if (payloadType === 'image') {
+        logTrace(correlationId, `deserializeData: image buffer length=${buffer.length}`);
+        return buffer;
+    } else if (payloadType === 'audio') {
+        logTrace(correlationId, `deserializeData: audio buffer length=${buffer.length}`);
+        return buffer;
+    } else if (payloadType === 'video') {
+        logTrace(correlationId, `deserializeData: video buffer length=${buffer.length}`);
+        return buffer;
+    } else if (payloadType === 'binary') {
+        logTrace(correlationId, `deserializeData: binary buffer length=${buffer.length}`);
+        return buffer;
+    } else {
+        throw new Error(`Unknown payload_type: ${payloadType}`);
+    }
+}
+
+// ---------------------------------------------- File Server Handlers ---------------------------------------------- //
+
+/**
+ * Upload data to plik server in one-shot mode
+ * @param {string} fileServerUrl - Base URL of the plik server
+ * @param {string} dataname - Name of the file being uploaded
+ * @param {Uint8Array} data - Raw byte data of the file content
+ * @returns {Promise<{status: number, uploadid: string, fileid: string, url: string}>}
+ */
+async function plikOneshotUpload(fileServerUrl, dataname, data) {
+    const buffer = data instanceof Uint8Array ? data : new Uint8Array(data);
+    
+    // Get upload id
+    const urlGetUploadID = `${fileServerUrl}/upload`;
+    const headers = { 'Content-Type': 'application/json' };
+    const body = JSON.stringify({ OneShot: true });
+    
+    const httpResponse = await fetch(urlGetUploadID, {
+        method: 'POST',
+        headers,
+        body
+    });
+    
+    const responseJson = await httpResponse.json();
+    const uploadid = responseJson.id;
+    const uploadtoken = responseJson.uploadToken;
+
+    // Upload file
+    const urlUpload = `${fileServerUrl}/file/${uploadid}`;
+    const form = new FormData();
+    const blob = new Blob([buffer], { type: 'application/octet-stream' });
+    form.append('file', blob, dataname);
+    
+    const uploadHeaders = {
+        'X-UploadToken': uploadtoken
+    };
+
+    const uploadResponse = await fetch(urlUpload, {
+        method: 'POST',
+        headers: uploadHeaders,
+        body: form
+    });
+    
+    const uploadJson = await uploadResponse.json();
+    const fileid = uploadJson.id;
+
+    const url = `${fileServerUrl}/file/${uploadid}/${fileid}/${dataname}`;
+
+    return {
+        status: uploadResponse.status,
+        uploadid,
+        fileid,
+        url
+    };
+}
+
+/**
+ * Fetch data from URL with exponential backoff
+ * @param {string} url - URL to fetch from
+ * @param {number} maxRetries - Maximum number of retry attempts
+ * @param {number} baseDelay - Initial delay in milliseconds
+ * @param {number} maxDelay - Maximum delay in milliseconds
+ * @param {string} correlationId - Correlation ID for logging
+ * @returns {Promise<Uint8Array>} Fetched data as bytes
+ */
+async function fetchWithBackoff(url, maxRetries, baseDelay, maxDelay, correlationId) {
+    let delay = baseDelay;
+    
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            const response = await fetch(url);
+            
+            if (response.status === 200) {
+                logTrace(correlationId, `Successfully fetched data from ${url} on attempt ${attempt}`);
+                const arrayBuffer = await response.arrayBuffer();
+                return new Uint8Array(arrayBuffer);
+            } else {
+                throw new Error(`Failed to fetch: ${response.status}`);
+            }
+        } catch (e) {
+            logTrace(correlationId, `Attempt ${attempt} failed: ${e.constructor.name} - ${e.message}`);
+            
+            if (attempt < maxRetries) {
+                await new Promise(resolve => setTimeout(resolve, delay));
+                delay = Math.min(delay * 2, maxDelay);
+            }
+        }
+    }
+    
+    throw new Error(`Failed to fetch data after ${maxRetries} attempts`);
+}
+
+// ---------------------------------------------- NATS Client ---------------------------------------------- //
+
+/**
+ * NATS client wrapper for connection management
+ * Supports both single-use and persistent connection modes
+ */
+class NATSClient {
+    /**
+     * Create a new NATS client
+     * @param {string} url - NATS server URL (ws:// or wss://)
+     * @param {boolean} [keepAlive=false] - Keep connection open for multiple publishes
+     */
+    constructor(url, keepAlive = false) {
+        this.url = url;
+        this.connection = null;
+        this.keepAlive = keepAlive;
+    }
+
+    /**
+     * Connect to NATS server
+     * @returns {Promise<NATS.Connection>}
+     */
+    async connect() {
+        if (this.connection) {
+            return this.connection;
+        }
+        this.connection = await nats.connect({ servers: this.url });
+        return this.connection;
+    }
+
+    /**
+     * Publish message to NATS subject
+     * @param {string} subject - NATS subject to publish to
+     * @param {string} message - Message to publish
+     * @param {string} correlationId - Correlation ID for logging
+     */
+    async publish(subject, message, correlationId) {
+        if (!this.connection) {
+            await this.connect();
+        }
+        await this.connection.publish(subject, message);
+        logTrace(correlationId, `Message published to ${subject}`);
+    }
+
+    /**
+     * Close the NATS connection
+     */
+    async close() {
+        if (this.connection) {
+            this.connection.close();
+            this.connection = null;
+        }
+    }
+
+    /**
+     * Get the current connection (for external use)
+     * @returns {NATS.Connection|null}
+     */
+    getConnection() {
+        return this.connection;
+    }
+
+    /**
+     * Check if connected
+     * @returns {boolean}
+     */
+    isConnected() {
+        return this.connection !== null;
+    }
+}
+
+/**
+ * Connection pool for managing multiple NATS connections
+ * Useful for applications with multiple concurrent publishers
+ */
+class NATSConnectionPool {
+    /**
+     * Create a new connection pool
+     * @param {string} url - NATS server URL (ws:// or wss://)
+     * @param {number} [maxSize=10] - Maximum pool size
+     */
+    constructor(url, maxSize = 10) {
+        this.url = url;
+        this.maxSize = maxSize;
+        this.connections = new Map();
+        this.idCounter = 0;
+    }
+
+    /**
+     * Get a connection from the pool (or create new)
+     * @returns {Promise<NATSClient>}
+     */
+    async acquire() {
+        // Try to find an existing idle connection
+        for (const [id, client] of this.connections) {
+            if (client.isConnected()) {
+                return client;
+            }
+        }
+
+        // Create new connection if under limit
+        if (this.connections.size < this.maxSize) {
+            const id = `conn_${++this.idCounter}`;
+            const client = new NATSClient(this.url, true);
+            await client.connect();
+            this.connections.set(id, client);
+            return client;
+        }
+
+        // Pool exhausted - create new connection (caller should close when done)
+        const client = new NATSClient(this.url, false);
+        await client.connect();
+        return client;
+    }
+
+    /**
+     * Return a connection to the pool
+     * @param {NATSClient} client - Connection to return
+     */
+    release(client) {
+        // Only return persistent connections
+        if (client.keepAlive && client.isConnected()) {
+            // Connection already in pool, do nothing
+            return;
+        }
+        // Non-persistent connection - close it
+        client.close();
+    }
+
+    /**
+     * Close all connections in the pool
+     */
+    async closeAll() {
+        for (const [id, client] of this.connections) {
+            await client.close();
+        }
+        this.connections.clear();
+    }
+}
+
+// ---------------------------------------------- Core Functions ---------------------------------------------- //
+
+/**
+ * Publish message to NATS
+ * @param {string|NATSClient|NATS.Connection} brokerUrlOrClient - NATS URL, client, or connection
+ * @param {string} subject - NATS subject to publish to
+ * @param {string} message - JSON message to publish
+ * @param {string} correlationId - Correlation ID for tracing
+ * @param {boolean} [closeConnection=true] - Close connection after publish (set false for persistent connections)
+ */
+async function publishMessage(brokerUrlOrClient, subject, message, correlationId, closeConnection = true) {
+    let conn;
+    let shouldClose = false;
+    
+    if (brokerUrlOrClient instanceof NATSClient) {
+        conn = brokerUrlOrClient;
+    } else if (brokerUrlOrClient && typeof brokerUrlOrClient.publish === 'function') {
+        // Create a wrapper for direct connection (duck-typing check for NATS connection)
+        conn = {
+            async publish(subj, msg) {
+                await brokerUrlOrClient.publish(subj, msg);
+            },
+            async close() {
+                await brokerUrlOrClient.close();
+            }
+        };
+        shouldClose = true;
+    } else {
+        // String URL - create new client
+        const client = new NATSClient(brokerUrlOrClient);
+        conn = client;
+        shouldClose = true;
+    }
+    
+    await conn.publish(subject, message, correlationId);
+    
+    // Only close if explicitly requested and it's a short-lived client
+    if (shouldClose && closeConnection && conn instanceof NATSClient) {
+        await conn.close();
+    }
+}
+
+/**
+ * Build message envelope from payloads and metadata
+ * @param {string} subject - NATS subject
+ * @param {Array} payloads - Array of payload objects
+ * @param {Object} options - Envelope metadata options
+ * @returns {Object} Envelope object
+ */
+function buildEnvelope(subject, payloads, options) {
+    return {
+        correlation_id: options.correlation_id,
+        msg_id: options.msg_id,
+        timestamp: new Date().toISOString(),
+        send_to: subject,
+        msg_purpose: options.msg_purpose,
+        sender_name: options.sender_name,
+        sender_id: options.sender_id,
+        receiver_name: options.receiver_name,
+        receiver_id: options.receiver_id,
+        reply_to: options.reply_to,
+        reply_to_msg_id: options.reply_to_msg_id,
+        broker_url: options.broker_url,
+        metadata: options.metadata || {},
+        payloads: payloads
+    };
+}
+
+/**
+ * Build payload object from serialized data
+ * @param {string} dataname - Name of the payload
+ * @param {string} payloadType - Type of the payload
+ * @param {Uint8Array} payloadBytes - Serialized payload bytes
+ * @param {string} transport - Transport type ("direct" or "link")
+ * @param {string} data - Data (base64 for direct, URL for link)
+ * @returns {Object} Payload object
+ */
+function buildPayload(dataname, payloadType, payloadBytes, transport, data) {
+    // Determine encoding based on payload type (matching Julia implementation)
+    let encoding = 'base64';
+    if (payloadType === 'jsontable') {
+        encoding = 'json';
+    }
+    
+    return {
+        id: uuidv4(),
+        dataname,
+        payload_type: payloadType,
+        transport,
+        encoding,
+        size: payloadBytes.byteLength,
+        data,
+        metadata: transport === 'direct' ? { payload_bytes: payloadBytes.byteLength } : {}
+    };
+}
+
+/**
+ * Send data via NATS with automatic transport selection
+ * 
+ * This function intelligently routes data delivery based on payload size.
+ * If the serialized payload is smaller than size_threshold, it encodes the data as Base64
+ * and publishes directly over NATS. Otherwise, it uploads the data to a fileserver
+ * and publishes only the download URL over NATS.
+ * 
+ * @param {string} subject - NATS subject to publish the message to
+ * @param {Array} data - List of [dataname, data, type] tuples to send
+ *          - type: "text", "dictionary", "jsontable", "image", "audio", "video", "binary"
+ *          - Note: "arrowtable" is NOT supported in browser (use "jsontable" for tabular data)
+ * @param {Object} options - Optional configuration
+ * @param {string} [options.broker_url=DEFAULT_BROKER_URL] - URL of the NATS server (WebSocket)
+ * @param {string} [options.fileserver_url=DEFAULT_FILESERVER_URL] - URL of the HTTP file server
+ * @param {Function} [options.fileserver_upload_handler=plikOneshotUpload] - Function to handle fileserver uploads
+ * @param {number} [options.size_threshold=DEFAULT_SIZE_THRESHOLD] - Threshold separating direct vs link transport
+ * @param {string} [options.correlation_id=uuidv4()] - Correlation ID for tracing
+ * @param {string} [options.msg_purpose="chat"] - Purpose of the message
+ * @param {string} [options.sender_name="NATSBridge"] - Name of the sender
+ * @param {string} [options.receiver_name=""] - Name of the receiver (empty means broadcast)
+ * @param {string} [options.receiver_id=""] - UUID of the receiver (empty means broadcast)
+ * @param {string} [options.reply_to=""] - Topic to reply to
+ * @param {string} [options.reply_to_msg_id=""] - Message ID this message is replying to
+ * @param {boolean} [options.is_publish=true] - Whether to automatically publish the message
+ * @param {NATSClient|NATS.Connection} [options.nats_connection=null] - Pre-existing NATS connection
+ * @param {string} [options.msg_id=uuidv4()] - Message ID
+ * @param {string} [options.sender_id=uuidv4()] - Sender ID
+ * @returns {Promise<[Object, string]>} Tuple of [env, env_json_str]
+ * 
+ * @example
+ * // Send a single payload
+ * const [env, envJsonStr] = await NATSBridgeCSR.smartsend(
+ *     "/test",
+ *     [["dataname1", data1, "dictionary"]],
+ *     { broker_url: "wss://nats.example.com" }
+ * );
+ * 
+ * // Send multiple payloads (use jsontable instead of arrowtable for browser)
+ * const [env, envJsonStr] = await NATSBridgeCSR.smartsend(
+ *     "/test",
+ *     [
+ *         ["dataname1", data1, "dictionary"],
+ *         ["dataname2", tableData, "jsontable"]
+ *     ],
+ *     { broker_url: "wss://nats.example.com" }
+ * );
+ */
+async function smartsend(subject, data, options = {}) {
+    const {
+        broker_url = DEFAULT_BROKER_URL,
+        fileserver_url = DEFAULT_FILESERVER_URL,
+        fileserver_upload_handler = plikOneshotUpload,
+        size_threshold = DEFAULT_SIZE_THRESHOLD,
+        correlation_id = uuidv4(),
+        msg_purpose = 'chat',
+        sender_name = 'NATSBridge',
+        receiver_name = '',
+        receiver_id = '',
+        reply_to = '',
+        reply_to_msg_id = '',
+        is_publish = true,
+        nats_connection = null,
+        msg_id = uuidv4(),
+        sender_id = uuidv4()
+    } = options;
+
+    logTrace(correlation_id, `Starting smartsend for subject: ${subject}`);
+    logTrace(correlation_id, `smartsend: data array length=${data.length}`);
+    
+    // Debug: Log input data structure
+    for (let i = 0; i < data.length; i++) {
+        const [dataname, payloadData, payloadType] = data[i];
+        logTrace(correlation_id, `smartsend: payload[${i}] dataname=${dataname}, type=${payloadType}, data type=${typeof payloadData}, constructor=${payloadData?.constructor?.name}`);
+    }
+
+    // Process payloads
+    const payloads = [];
+    for (const [dataname, payloadData, payloadType] of data) {
+        logTrace(correlation_id, `smartsend: Processing payload '${dataname}' type=${payloadType}`);
+        logTrace(correlation_id, `smartsend: payloadData type=${typeof payloadData}, constructor=${payloadData?.constructor?.name}`);
+        
+        const payloadBytes = await serializeData(payloadData, payloadType);
+        const payloadSize = payloadBytes.byteLength;
+
+        logTrace(correlation_id, `Serialized payload '${dataname}' (type: ${payloadType}) size: ${payloadSize} bytes`);
+
+        // Debug: Show first 20 bytes of serialized data for table type
+        if (payloadType === 'table') {
+            const hexPreview = [];
+            for (let i = 0; i < Math.min(20, payloadBytes.length); i++) {
+                hexPreview.push(payloadBytes[i].toString(16).padStart(2, '0'));
+            }
+            logTrace(correlation_id, `Serialized table data first 20 bytes (hex): ${hexPreview.join(' ')}`);
+        }
+
+        if (payloadSize < size_threshold) {
+            // Direct path
+            const payloadB64 = bufferToBase64(payloadBytes);
+            logTrace(correlation_id, `Using direct transport for ${payloadSize} bytes, base64 length=${payloadB64.length}`);
+
+            const payload = buildPayload(dataname, payloadType, payloadBytes, 'direct', payloadB64);
+            payloads.push(payload);
+        } else {
+            // Link path
+            logTrace(correlation_id, `Using link transport, uploading to fileserver`);
+
+            const response = await fileserver_upload_handler(fileserver_url, dataname, payloadBytes);
+
+            if (response.status !== 200) {
+                throw new Error(`Failed to upload data to fileserver: ${response.status}`);
+            }
+
+            logTrace(correlation_id, `Uploaded to URL: ${response.url}`);
+
+            const payload = buildPayload(dataname, payloadType, payloadBytes, 'link', response.url);
+            payloads.push(payload);
+        }
+    }
+
+    // Build envelope
+    const env = buildEnvelope(subject, payloads, {
+        correlation_id,
+        msg_id,
+        msg_purpose,
+        sender_name,
+        sender_id,
+        receiver_name,
+        receiver_id,
+        reply_to,
+        reply_to_msg_id,
+        broker_url
+    });
+
+    const env_json_str = JSON.stringify(env);
+
+    if (is_publish) {
+        if (nats_connection) {
+            await publishMessage(nats_connection, subject, env_json_str, correlation_id);
+        } else {
+            await publishMessage(broker_url, subject, env_json_str, correlation_id);
+        }
+    }
+
+    return [env, env_json_str];
+}
+
+/**
+ * Receive and process NATS message
+ * 
+ * This function processes incoming NATS messages, handling both direct transport
+ * (base64 decoded payloads) and link transport (URL-based payloads).
+ * It deserializes the data based on the transport type and returns the result.
+ * 
+ * @param {Object} msg - NATS message object with payload property
+ * @param {Object} options - Optional configuration
+ * @param {Function} [options.fileserver_download_handler=fetchWithBackoff] - Function to handle fileserver downloads
+ * @param {number} [options.max_retries=5] - Maximum retry attempts for fetching URL
+ * @param {number} [options.base_delay=100] - Initial delay for exponential backoff in ms
+ * @param {number} [options.max_delay=5000] - Maximum delay for exponential backoff in ms
+ * @returns {Promise<Object>} Envelope object with processed payloads
+ * 
+ * @example
+ * // Receive and process message
+ * const env = await NATSBridgeCSR.smartreceive(msg, {
+ *     fileserver_download_handler: NATSBridgeCSR.fetchWithBackoff,
+ *     max_retries: 5,
+ *     base_delay: 100,
+ *     max_delay: 5000
+ * });
+ * // env.payloads is an Array of [dataname, data, type] arrays
+ * for (const [dataname, data, type] of env.payloads) {
+ *     console.log(`${dataname}: ${data} (type: ${type})`);
+ * }
+ */
+async function smartreceive(msg, options = {}) {
+    const {
+        fileserver_download_handler = fetchWithBackoff,
+        max_retries = 5,
+        base_delay = 100,
+        max_delay = 5000
+    } = options;
+
+    // Debug: Log message object structure
+    logTrace('smartreceive', `smartreceive: msg object keys: ${Object.keys(msg).join(', ')}`);
+    logTrace('smartreceive', `smartreceive: msg.data type: ${typeof msg.data}, constructor: ${msg.data?.constructor?.name}`);
+    logTrace('smartreceive', `smartreceive: msg.payload type: ${typeof msg.payload}, constructor: ${msg.payload?.constructor?.name}`);
+    
+    // Parse the JSON envelope
+    // NATS.js v2.x uses msg.data instead of msg.payload
+    let payload;
+    if (msg.data !== undefined) {
+        payload = typeof msg.data === 'string' ? msg.data : new TextDecoder().decode(msg.data);
+    } else if (msg.payload !== undefined) {
+        payload = typeof msg.payload === 'string' ? msg.payload : new TextDecoder().decode(msg.payload);
+    } else {
+        throw new Error('Message has neither data nor payload property');
+    }
+    
+    logTrace('smartreceive', `smartreceive: raw payload length=${payload.length}`);
+    
+    // Debug: Show first 200 chars of payload
+    const payloadPreview = payload.substring(0, 200);
+    logTrace('smartreceive', `smartreceive: payload preview: ${payloadPreview}`);
+    
+    let envJsonObj;
+    try {
+        envJsonObj = JSON.parse(payload);
+    } catch (e) {
+        logTrace('smartreceive', `smartreceive: JSON parse failed: ${e.message}`);
+        throw e;
+    }
+    
+    logTrace(envJsonObj.correlation_id, 'Processing received message');
+    logTrace(envJsonObj.correlation_id, `smartreceive: envelope has ${envJsonObj.payloads.length} payloads`);
+
+    // Process all payloads in the envelope
+    const payloadsList = [];
+    const numPayloads = envJsonObj.payloads.length;
+
+    logTrace(envJsonObj.correlation_id, `smartreceive: Processing ${numPayloads} payloads`);
+
+    for (let i = 0; i < numPayloads; i++) {
+        const payloadObj = envJsonObj.payloads[i];
+        const transport = payloadObj.transport;
+        const dataname = payloadObj.dataname;
+        const payloadType = payloadObj.payload_type;
+
+        logTrace(envJsonObj.correlation_id, `smartreceive: Processing payload ${i + 1}/${numPayloads}: dataname=${dataname}, type=${payloadType}, transport=${transport}`);
+
+        if (transport === 'direct') {
+            logTrace(envJsonObj.correlation_id, `Direct transport - decoding payload '${dataname}'`);
+
+            // Extract base64 payload from the payload
+            const payloadB64 = payloadObj.data;
+            logTrace(envJsonObj.correlation_id, `Direct transport: base64 length=${payloadB64?.length}`);
+
+            // Decode Base64 payload
+            const payloadBytes = base64ToBuffer(payloadB64);
+            logTrace(envJsonObj.correlation_id, `Direct transport: decoded bytes=${payloadBytes.length}`);
+
+            // Deserialize based on type
+            const dataType = payloadObj.payload_type;
+            const data = await deserializeData(payloadBytes, dataType, envJsonObj.correlation_id);
+            logTrace(envJsonObj.correlation_id, `Direct transport: deserialized data type=${typeof data}, constructor=${data?.constructor?.name}`);
+
+            payloadsList.push([dataname, data, dataType]);
+        } else if (transport === 'link') {
+            // Extract download URL from the payload
+            const url = payloadObj.data;
+            logTrace(envJsonObj.correlation_id, `Link transport - fetching '${dataname}' from URL: ${url}`);
+
+            // Fetch with exponential backoff using the download handler
+            const downloadedData = await fileserver_download_handler(
+                url,
+                max_retries,
+                base_delay,
+                max_delay,
+                envJsonObj.correlation_id
+            );
+
+            // Deserialize based on type
+            const dataType = payloadObj.payload_type;
+            const data = await deserializeData(downloadedData, dataType, envJsonObj.correlation_id);
+
+            payloadsList.push([dataname, data, dataType]);
+        } else {
+            throw new Error(`Unknown transport type for payload '${dataname}': ${transport}`);
+        }
+    }
+
+    logTrace(envJsonObj.correlation_id, `smartreceive: Successfully processed all ${payloadsList.length} payloads`);
+    envJsonObj.payloads = payloadsList;
+    return envJsonObj;
+}
+
+// ---------------------------------------------- Module Exports ---------------------------------------------- //
+
+const NATSBridgeCSR = {
+    /**
+     * NATS client class for connection management
+     * Supports both single-use and persistent connection modes
+     * 
+     * @example
+     * // Single-use connection (closes after publish)
+     * const client = new NATSBridgeCSR.NATSClient("wss://nats.example.com");
+     * await NATSBridgeCSR.smartsend("/test", [["msg", "Hello", "text"]], { nats_connection: client });
+     * await client.close();
+     * 
+     * // Persistent connection (keeps connection open)
+     * const client = new NATSBridgeCSR.NATSClient("wss://nats.example.com", true);
+     * await client.connect();
+     * await NATSBridgeCSR.smartsend("/test1", [["msg", "Hello", "text"]], { nats_connection: client, is_publish: false });
+     * await NATSBridgeCSR.publishMessage(client, "/test2", JSON.stringify({msg: "World"}), "trace-id");
+     * // Connection remains open for more publishes
+     * await client.close();
+     */
+    NATSClient,
+
+    /**
+     * Connection pool for managing multiple NATS connections
+     * Useful for applications with multiple concurrent publishers
+     * 
+     * @example
+     * const pool = new NATSBridgeCSR.NATSConnectionPool("wss://nats.example.com", 10);
+     * const client = await pool.acquire();
+     * await NATSBridgeCSR.smartsend("/test", [["msg", "Hello", "text"]], { nats_connection: client });
+     * pool.release(client);
+     * await pool.closeAll();
+     */
+    NATSConnectionPool,
+
+    /**
+     * Send data via NATS with automatic transport selection
+     */
+    smartsend,
+
+    /**
+     * Receive and process NATS message
+     */
+    smartreceive,
+
+    /**
+     * Publish message to NATS
+     * 
+     * @example
+     * // Using a persistent connection
+     * const client = new NATSBridgeCSR.NATSClient("wss://nats.example.com", true);
+     * await client.connect();
+     * await NATSBridgeCSR.publishMessage(client, "/subject", JSON.stringify({msg: "Hello"}), "trace-id", false);
+     * // Connection stays open for more publishes
+     * await client.close();
+     */
+    publishMessage,
+
+    /**
+     * Upload data to plik server in one-shot mode
+     */
+    plikOneshotUpload,
+
+    /**
+     * Fetch data from URL with exponential backoff
+     */
+    fetchWithBackoff,
+
+    /**
+     * Default constants
+     */
+    DEFAULT_SIZE_THRESHOLD,
+    DEFAULT_BROKER_URL,
+    DEFAULT_FILESERVER_URL
+};
+
+export default NATSBridgeCSR;

src/natsbridge_ssr.js

@@ -1,25 +1,43 @@
 /**
  * NATSBridge - Cross-Platform Bi-Directional Data Bridge
- * JavaScript/Node.js Implementation
+ * JavaScript/Node.js Implementation (Desktop/Server-Side)
  * 
  * This module provides functionality for sending and receiving data across network boundaries
  * using NATS as the message bus, with support for both direct payload transport and
  * URL-based transport for larger payloads.
  * 
+ * Supported payload types: "text", "dictionary", "arrowtable", "jsontable", "image", "audio", "video", "binary"
+ * 
+ * Node.js-specific features:
+ * - Apache Arrow IPC support via apache-arrow
+ * - TCP NATS connections (nats:// or tls:// URLs)
+ * - Buffer for binary data handling
+ * - Connection pooling for high-throughput scenarios
+ * 
  * @module NATSBridge
  */
 
 const nats = require('nats');
-const { v4: uuidv4 } = require('uuid');
-const fetch = require('node-fetch');
+const crypto = require('crypto');
+// Use native fetch available in Node.js 18+
 const arrow = require('apache-arrow');
 
+// ---------------------------------------------- UUID Helper ---------------------------------------------- //
+
+/**
+ * Generate UUID v4 using crypto module (Node.js compatible)
+ * @returns {string} UUID string
+ */
+function uuidv4() {
+    return crypto.randomUUID();
+}
+
 // ---------------------------------------------- Constants ---------------------------------------------- //
 
 /**
- * Default size threshold for switching from direct to link transport (1MB)
+ * Default size threshold for switching from direct to link transport (0.5MB)
  */
-const DEFAULT_SIZE_THRESHOLD = 1_000_000;
+const DEFAULT_SIZE_THRESHOLD = 500_000;
 
 /**
  * Default NATS server URL
@@ -57,7 +75,7 @@ function logTrace(correlationId, message) {
 /**
  * Serialize data according to specified format
  * @param {any} data - Data to serialize
- * @param {string} payloadType - Target format: "text", "dictionary", "table", "image", "audio", "video", "binary"
+ * @param {string} payloadType - Target format: "text", "dictionary", "arrowtable", "jsontable", "image", "audio", "video", "binary"
  * @returns {Buffer} Binary representation of the serialized data
  */
 async function serializeData(data, payloadType) {
@@ -70,13 +88,20 @@ async function serializeData(data, payloadType) {
     } else if (payloadType === 'dictionary') {
         const jsonStr = JSON.stringify(data);
         return Buffer.from(jsonStr, 'utf8');
-    } else if (payloadType === 'table') {
+    } else if (payloadType === 'arrowtable') {
         // Convert array of objects to Arrow IPC format
         if (!Array.isArray(data) || data.length === 0) {
-            throw new Error('Table data must be a non-empty array of objects');
+            throw new Error('Arrow table data must be a non-empty array of objects');
         }
         
         return serializeArrowTable(data);
+    } else if (payloadType === 'jsontable') {
+        // Serialize array of objects to JSON format
+        if (!Array.isArray(data)) {
+            throw new Error('JSON table data must be an array');
+        }
+        const jsonStr = JSON.stringify(data);
+        return Buffer.from(jsonStr, 'utf8');
     } else if (payloadType === 'image') {
         if (data instanceof Uint8Array || Buffer.isBuffer(data)) {
             return Buffer.from(data);
@@ -116,41 +141,34 @@ function serializeArrowTable(data) {
         throw new Error('Table data must be a non-empty array of objects');
     }
     
-    // Build schema from first row
-    const fields = Object.keys(data[0]).map(key => {
-        const value = data[0][key];
-        let arrowType;
-        if (typeof value === 'number') {
-            arrowType = Number.isInteger(value) ? arrow.Int64 : arrow.Float64;
-        } else if (typeof value === 'boolean') {
-            arrowType = arrow.Boolean;
-        } else if (value instanceof Date) {
-            arrowType = arrow.Date;
-        } else {
-            arrowType = arrow.Utf8;
-        }
-        return new arrow.Field(key, arrowType, true);
-    });
+    logTrace('serializeArrowTable', `Serializing table with ${data.length} rows`);
     
-    const schema = new arrow.Schema(fields);
-    const batches = [];
-    
-    // Create record batches
-    for (const row of data) {
-        const batch = arrow.recordBatch.fromObjects([row], schema);
-        batches.push(batch);
+    // Use arrow.tableFromArrays which handles the conversion properly
+    // Convert array of objects to a key-value format expected by tableFromArrays
+    const columns = {};
+    for (const key of Object.keys(data[0])) {
+        columns[key] = data.map(row => row[key]);
     }
     
-    // Write to buffer using IPC format
-    const buffers = arrow.ipc.recordBatchesToMessage(batches, schema).buffers;
-    const combined = new Uint8Array(buffers.reduce((acc, b) => acc + b.byteLength, 0));
-    let offset = 0;
-    for (const buf of buffers) {
-        combined.set(new Uint8Array(buf), offset);
-        offset += buf.byteLength;
-    }
+    logTrace('serializeArrowTable', `Columns: ${Object.keys(columns).join(', ')}`);
     
-    return Buffer.from(combined);
+    const table = arrow.tableFromArrays(columns);
+    
+    logTrace('serializeArrowTable', `Arrow table created with ${table.numRows} rows, ${table.numCols} cols`);
+    
+    // Convert to IPC format
+    const ipcBuffer = arrow.tableToIPC(table);
+    
+    logTrace('serializeArrowTable', `IPC buffer type: ${typeof ipcBuffer}, length: ${ipcBuffer.byteLength}`);
+    
+    const resultBuffer = Buffer.from(ipcBuffer);
+    logTrace('serializeArrowTable', `Result buffer: ${resultBuffer.length} bytes`);
+    
+    // Debug: Show first 20 bytes in hex
+    const hexPreview = resultBuffer.slice(0, 20).toString('hex');
+    logTrace('serializeArrowTable', `First 20 bytes (hex): ${hexPreview}`);
+    
+    return resultBuffer;
 }
 
 /**
@@ -163,21 +181,71 @@ function serializeArrowTable(data) {
 async function deserializeData(data, payloadType, correlationId) {
     const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
     
+    logTrace(correlationId, `deserializeData: type=${payloadType}, bufferLength=${buffer.length}`);
+    
+    // Debug: Show first 20 bytes in hex for binary data
+    if (payloadType === 'arrowtable' || payloadType === 'jsontable' || payloadType === 'image' || payloadType === 'binary') {
+        const hexPreview = buffer.slice(0, 20).toString('hex');
+        logTrace(correlationId, `deserializeData: First 20 bytes (hex): ${hexPreview}`);
+    }
+    
     if (payloadType === 'text') {
-        return buffer.toString('utf8');
+        const result = buffer.toString('utf8');
+        logTrace(correlationId, `deserializeData: text result length=${result.length}`);
+        return result;
     } else if (payloadType === 'dictionary') {
         const jsonStr = buffer.toString('utf8');
-        return JSON.parse(jsonStr);
-    } else if (payloadType === 'table') {
+        const result = JSON.parse(jsonStr);
+        logTrace(correlationId, `deserializeData: dictionary keys=${Object.keys(result).join(', ')}`);
+        return result;
+    } else if (payloadType === 'arrowtable') {
+        logTrace(correlationId, `deserializeData: Attempting Arrow table deserialization`);
+        
+        // Debug: Check available arrow methods
+        logTrace(correlationId, `deserializeData: arrow.tableFromRawBytes exists: ${typeof arrow.tableFromRawBytes}`);
+        logTrace(correlationId, `deserializeData: arrow.tableFromIPC exists: ${typeof arrow.tableFromIPC}`);
+        
+        try {
+            // Try tableFromRawBytes first (older API)
+            if (typeof arrow.tableFromRawBytes === 'function') {
+                logTrace(correlationId, `deserializeData: Using tableFromRawBytes`);
                 const table = arrow.tableFromRawBytes(buffer);
+                logTrace(correlationId, `deserializeData: Arrow table - rows=${table.numRows}, cols=${table.numCols}`);
                 return table;
+            }
+        } catch (e) {
+            logTrace(correlationId, `deserializeData: tableFromRawBytes failed: ${e.message}`);
+        }
+        
+        try {
+            // Try tableFromIPC (newer API)
+            if (typeof arrow.tableFromIPC === 'function') {
+                logTrace(correlationId, `deserializeData: Using tableFromIPC`);
+                const table = arrow.tableFromIPC(buffer);
+                logTrace(correlationId, `deserializeData: Arrow table from IPC - rows=${table.numRows}, cols=${table.numCols}`);
+                return table;
+            }
+        } catch (e) {
+            logTrace(correlationId, `deserializeData: tableFromIPC failed: ${e.message}`);
+        }
+        
+        throw new Error(`Unable to deserialize Arrow table: neither tableFromRawBytes nor tableFromIPC worked`);
+    } else if (payloadType === 'jsontable') {
+        const jsonStr = buffer.toString('utf8');
+        const result = JSON.parse(jsonStr);
+        logTrace(correlationId, `deserializeData: jsontable result length=${Array.isArray(result) ? result.length : 'N/A'}`);
+        return result;
     } else if (payloadType === 'image') {
+        logTrace(correlationId, `deserializeData: image buffer length=${buffer.length}`);
         return buffer;
     } else if (payloadType === 'audio') {
+        logTrace(correlationId, `deserializeData: audio buffer length=${buffer.length}`);
         return buffer;
     } else if (payloadType === 'video') {
+        logTrace(correlationId, `deserializeData: video buffer length=${buffer.length}`);
         return buffer;
     } else if (payloadType === 'binary') {
+        logTrace(correlationId, `deserializeData: binary buffer length=${buffer.length}`);
         return buffer;
     } else {
         throw new Error(`Unknown payload_type: ${payloadType}`);
@@ -264,7 +332,7 @@ async function fetchWithBackoff(url, maxRetries, baseDelay, maxDelay, correlatio
                 throw new Error(`Failed to fetch: ${response.status}`);
             }
         } catch (e) {
-            logTrace(correlationId, `Attempt ${attempt} failed: ${e.constructor.name}`);
+            logTrace(correlationId, `Attempt ${attempt} failed: ${e.constructor.name} - ${e.message}`);
             
             if (attempt < maxRetries) {
                 await new Promise(resolve => setTimeout(resolve, delay));
@@ -280,15 +348,18 @@ async function fetchWithBackoff(url, maxRetries, baseDelay, maxDelay, correlatio
 
 /**
  * NATS client wrapper for connection management
+ * Supports both single-use and persistent connection modes
  */
 class NATSClient {
     /**
      * Create a new NATS client
-     * @param {string} url - NATS server URL
+     * @param {string} url - NATS server URL (nats:// or tls://)
+     * @param {boolean} [keepAlive=false] - Keep connection open for multiple publishes
      */
-    constructor(url) {
+    constructor(url, keepAlive = false) {
         this.url = url;
         this.connection = null;
+        this.keepAlive = keepAlive;
     }
 
     /**
@@ -296,6 +367,9 @@ class NATSClient {
      * @returns {Promise<NATS.Connection>}
      */
     async connect() {
+        if (this.connection) {
+            return this.connection;
+        }
         this.connection = await nats.connect({ servers: this.url });
         return this.connection;
     }
@@ -320,8 +394,94 @@ class NATSClient {
     async close() {
         if (this.connection) {
             this.connection.close();
+            this.connection = null;
         }
     }
+
+    /**
+     * Get the current connection (for external use)
+     * @returns {NATS.Connection|null}
+     */
+    getConnection() {
+        return this.connection;
+    }
+
+    /**
+     * Check if connected
+     * @returns {boolean}
+     */
+    isConnected() {
+        return this.connection !== null;
+    }
+}
+
+/**
+ * Connection pool for managing multiple NATS connections
+ * Useful for applications with multiple concurrent publishers
+ */
+class NATSConnectionPool {
+    /**
+     * Create a new connection pool
+     * @param {string} url - NATS server URL (nats:// or tls://)
+     * @param {number} [maxSize=10] - Maximum pool size
+     */
+    constructor(url, maxSize = 10) {
+        this.url = url;
+        this.maxSize = maxSize;
+        this.connections = new Map();
+        this.idCounter = 0;
+    }
+
+    /**
+     * Get a connection from the pool (or create new)
+     * @returns {Promise<NATSClient>}
+     */
+    async acquire() {
+        // Try to find an existing idle connection
+        for (const [id, client] of this.connections) {
+            if (client.isConnected()) {
+                return client;
+            }
+        }
+
+        // Create new connection if under limit
+        if (this.connections.size < this.maxSize) {
+            const id = `conn_${++this.idCounter}`;
+            const client = new NATSClient(this.url, true);
+            await client.connect();
+            this.connections.set(id, client);
+            return client;
+        }
+
+        // Pool exhausted - create new connection (caller should close when done)
+        const client = new NATSClient(this.url, false);
+        await client.connect();
+        return client;
+    }
+
+    /**
+     * Return a connection to the pool
+     * @param {NATSClient} client - Connection to return
+     */
+    release(client) {
+        // Only return persistent connections
+        if (client.keepAlive && client.isConnected()) {
+            // Connection already in pool, do nothing
+            return;
+        }
+        // Non-persistent connection - close it
+        client.close();
+    }
+
+    /**
+     * Close all connections in the pool
+     */
+    async closeAll() {
+        for (const [id, client] of this.connections) {
+            await client.close();
+        }
+        this.connections.clear();
+    }
 }
 
 // ---------------------------------------------- Core Functions ---------------------------------------------- //
@@ -332,14 +492,16 @@ class NATSClient {
  * @param {string} subject - NATS subject to publish to
  * @param {string} message - JSON message to publish
  * @param {string} correlationId - Correlation ID for tracing
+ * @param {boolean} [closeConnection=true] - Close connection after publish (set false for persistent connections)
  */
-async function publishMessage(brokerUrlOrClient, subject, message, correlationId) {
+async function publishMessage(brokerUrlOrClient, subject, message, correlationId, closeConnection = true) {
     let conn;
+    let shouldClose = false;
     
     if (brokerUrlOrClient instanceof NATSClient) {
         conn = brokerUrlOrClient;
-    } else if (brokerUrlOrClient instanceof nats.Connection) {
-        // Create a wrapper for direct connection
+    } else if (brokerUrlOrClient && typeof brokerUrlOrClient.publish === 'function') {
+        // Create a wrapper for direct connection (duck-typing check for NATS connection)
         conn = {
             async publish(subj, msg) {
                 await brokerUrlOrClient.publish(subj, msg);
@@ -348,15 +510,18 @@ async function publishMessage(brokerUrlOrClient, subject, message, correlationId
                 await brokerUrlOrClient.close();
             }
         };
+        shouldClose = true;
     } else {
         // String URL - create new client
         const client = new NATSClient(brokerUrlOrClient);
         conn = client;
+        shouldClose = true;
     }
     
     await conn.publish(subject, message, correlationId);
     
-    if (conn instanceof NATSClient) {
+    // Only close if explicitly requested and it's a short-lived client
+    if (shouldClose && closeConnection && conn instanceof NATSClient) {
         await conn.close();
     }
 }
@@ -397,12 +562,20 @@ function buildEnvelope(subject, payloads, options) {
  * @returns {Object} Payload object
  */
 function buildPayload(dataname, payloadType, payloadBytes, transport, data) {
+    // Determine encoding based on payload type (matching Julia implementation)
+    let encoding = 'base64';
+    if (payloadType === 'jsontable') {
+        encoding = 'json';
+    } else if (payloadType === 'arrowtable') {
+        encoding = 'arrow-ipc';
+    }
+    
     return {
         id: uuidv4(),
         dataname,
         payload_type: payloadType,
         transport,
-        encoding: transport === 'direct' ? 'base64' : 'none',
+        encoding,
         size: payloadBytes.byteLength,
         data,
         metadata: transport === 'direct' ? { payload_bytes: payloadBytes.byteLength } : {}
@@ -419,12 +592,13 @@ function buildPayload(dataname, payloadType, payloadBytes, transport, data) {
  * 
  * @param {string} subject - NATS subject to publish the message to
  * @param {Array} data - List of [dataname, data, type] tuples to send
+ *          - type: "text", "dictionary", "arrowtable", "jsontable", "image", "audio", "video", "binary"
  * @param {Object} options - Optional configuration
  * @param {string} [options.broker_url=DEFAULT_BROKER_URL] - URL of the NATS server
  * @param {string} [options.fileserver_url=DEFAULT_FILESERVER_URL] - URL of the HTTP file server
  * @param {Function} [options.fileserver_upload_handler=plikOneshotUpload] - Function to handle fileserver uploads
  * @param {number} [options.size_threshold=DEFAULT_SIZE_THRESHOLD] - Threshold separating direct vs link transport
- * @param {string} [options.correlation_id=uuidv4()] - Correlation ID for tracing
+ * @param {string} [options.correlation_id=crypto.randomUUID()] - Correlation ID for tracing
  * @param {string} [options.msg_purpose="chat"] - Purpose of the message
  * @param {string} [options.sender_name="NATSBridge"] - Name of the sender
  * @param {string} [options.receiver_name=""] - Name of the receiver (empty means broadcast)
@@ -433,8 +607,8 @@ function buildPayload(dataname, payloadType, payloadBytes, transport, data) {
  * @param {string} [options.reply_to_msg_id=""] - Message ID this message is replying to
  * @param {boolean} [options.is_publish=true] - Whether to automatically publish the message
  * @param {NATSClient|NATS.Connection} [options.nats_connection=null] - Pre-existing NATS connection
- * @param {string} [options.msg_id=uuidv4()] - Message ID
- * @param {string} [options.sender_id=uuidv4()] - Sender ID
+ * @param {string} [options.msg_id=crypto.randomUUID()] - Message ID
+ * @param {string} [options.sender_id=crypto.randomUUID()] - Sender ID
  * @returns {Promise<[Object, string]>} Tuple of [env, env_json_str]
  * 
  * @example
@@ -450,7 +624,7 @@ function buildPayload(dataname, payloadType, payloadBytes, transport, data) {
  *     "/test",
  *     [
  *         ["dataname1", data1, "dictionary"],
- *         ["dataname2", data2, "table"]
+ *         ["dataname2", data2, "arrowtable"]
  *     ],
  *     { broker_url: "nats://localhost:4222" }
  * );
@@ -483,19 +657,35 @@ async function smartsend(subject, data, options = {}) {
     } = options;
 
     logTrace(correlation_id, `Starting smartsend for subject: ${subject}`);
+    logTrace(correlation_id, `smartsend: data array length=${data.length}`);
+    
+    // Debug: Log input data structure
+    for (let i = 0; i < data.length; i++) {
+        const [dataname, payloadData, payloadType] = data[i];
+        logTrace(correlation_id, `smartsend: payload[${i}] dataname=${dataname}, type=${payloadType}, data type=${typeof payloadData}, constructor=${payloadData?.constructor?.name}`);
+    }
 
     // Process payloads
     const payloads = [];
     for (const [dataname, payloadData, payloadType] of data) {
+        logTrace(correlation_id, `smartsend: Processing payload '${dataname}' type=${payloadType}`);
+        logTrace(correlation_id, `smartsend: payloadData type=${typeof payloadData}, constructor=${payloadData?.constructor?.name}`);
+        
         const payloadBytes = await serializeData(payloadData, payloadType);
         const payloadSize = payloadBytes.byteLength;
 
         logTrace(correlation_id, `Serialized payload '${dataname}' (type: ${payloadType}) size: ${payloadSize} bytes`);
 
+        // Debug: Show first 20 bytes of serialized data for table type
+        if (payloadType === 'table') {
+            const hexPreview = payloadBytes.slice(0, 20).toString('hex');
+            logTrace(correlation_id, `Serialized table data first 20 bytes (hex): ${hexPreview}`);
+        }
+
         if (payloadSize < size_threshold) {
             // Direct path
             const payloadB64 = bufferToBase64(payloadBytes);
-            logTrace(correlation_id, `Using direct transport for ${payloadSize} bytes`);
+            logTrace(correlation_id, `Using direct transport for ${payloadSize} bytes, base64 length=${payloadB64.length}`);
 
             const payload = buildPayload(dataname, payloadType, payloadBytes, 'direct', payloadB64);
             payloads.push(payload);
@@ -579,32 +769,68 @@ async function smartreceive(msg, options = {}) {
         max_delay = 5000
     } = options;
 
+    // Debug: Log message object structure
+    logTrace('smartreceive', `smartreceive: msg object keys: ${Object.keys(msg).join(', ')}`);
+    logTrace('smartreceive', `smartreceive: msg.data type: ${typeof msg.data}, constructor: ${msg.data?.constructor?.name}`);
+    logTrace('smartreceive', `smartreceive: msg.payload type: ${typeof msg.payload}, constructor: ${msg.payload?.constructor?.name}`);
+    
     // Parse the JSON envelope
-    const payload = typeof msg.payload === 'string' ? msg.payload : Buffer.from(msg.payload).toString('utf8');
-    const envJsonObj = JSON.parse(payload);
+    // NATS.js v2.x uses msg.data instead of msg.payload
+    let payload;
+    if (msg.data !== undefined) {
+        payload = typeof msg.data === 'string' ? msg.data : Buffer.from(msg.data).toString('utf8');
+    } else if (msg.payload !== undefined) {
+        payload = typeof msg.payload === 'string' ? msg.payload : Buffer.from(msg.payload).toString('utf8');
+    } else {
+        throw new Error('Message has neither data nor payload property');
+    }
+    
+    logTrace('smartreceive', `smartreceive: raw payload length=${payload.length}`);
+    
+    // Debug: Show first 200 chars of payload
+    const payloadPreview = payload.substring(0, 200);
+    logTrace('smartreceive', `smartreceive: payload preview: ${payloadPreview}`);
+    
+    let envJsonObj;
+    try {
+        envJsonObj = JSON.parse(payload);
+    } catch (e) {
+        logTrace('smartreceive', `smartreceive: JSON parse failed: ${e.message}`);
+        throw e;
+    }
+    
     logTrace(envJsonObj.correlation_id, 'Processing received message');
+    logTrace(envJsonObj.correlation_id, `smartreceive: envelope has ${envJsonObj.payloads.length} payloads`);
 
     // Process all payloads in the envelope
     const payloadsList = [];
     const numPayloads = envJsonObj.payloads.length;
 
+    logTrace(envJsonObj.correlation_id, `smartreceive: Processing ${numPayloads} payloads`);
+
     for (let i = 0; i < numPayloads; i++) {
         const payloadObj = envJsonObj.payloads[i];
         const transport = payloadObj.transport;
         const dataname = payloadObj.dataname;
+        const payloadType = payloadObj.payload_type;
+
+        logTrace(envJsonObj.correlation_id, `smartreceive: Processing payload ${i + 1}/${numPayloads}: dataname=${dataname}, type=${payloadType}, transport=${transport}`);
 
         if (transport === 'direct') {
             logTrace(envJsonObj.correlation_id, `Direct transport - decoding payload '${dataname}'`);
 
             // Extract base64 payload from the payload
             const payloadB64 = payloadObj.data;
+            logTrace(envJsonObj.correlation_id, `Direct transport: base64 length=${payloadB64?.length}`);
 
             // Decode Base64 payload
             const payloadBytes = Buffer.from(payloadB64, 'base64');
+            logTrace(envJsonObj.correlation_id, `Direct transport: decoded bytes=${payloadBytes.length}`);
 
             // Deserialize based on type
             const dataType = payloadObj.payload_type;
             const data = await deserializeData(payloadBytes, dataType, envJsonObj.correlation_id);
+            logTrace(envJsonObj.correlation_id, `Direct transport: deserialized data type=${typeof data}, constructor=${data?.constructor?.name}`);
 
             payloadsList.push([dataname, data, dataType]);
         } else if (transport === 'link') {
@@ -631,6 +857,7 @@ async function smartreceive(msg, options = {}) {
         }
     }
 
+    logTrace(envJsonObj.correlation_id, `smartreceive: Successfully processed all ${payloadsList.length} payloads`);
     envJsonObj.payloads = payloadsList;
     return envJsonObj;
 }
@@ -640,9 +867,37 @@ async function smartreceive(msg, options = {}) {
 const NATSBridge = {
     /**
      * NATS client class for connection management
+     * Supports both single-use and persistent connection modes
+     * 
+     * @example
+     * // Single-use connection (closes after publish)
+     * const client = new NATSBridge.NATSClient("nats://localhost:4222");
+     * await NATSBridge.smartsend("/test", [["msg", "Hello", "text"]], { nats_connection: client });
+     * await client.close();
+     * 
+     * // Persistent connection (keeps connection open)
+     * const client = new NATSBridge.NATSClient("nats://localhost:4222", true);
+     * await client.connect();
+     * await NATSBridge.smartsend("/test1", [["msg", "Hello", "text"]], { nats_connection: client, is_publish: false });
+     * await NATSBridge.publishMessage(client, "/test2", JSON.stringify({msg: "World"}), "trace-id");
+     * // Connection remains open for more publishes
+     * await client.close();
      */
     NATSClient,
 
+    /**
+     * Connection pool for managing multiple NATS connections
+     * Useful for applications with multiple concurrent publishers
+     * 
+     * @example
+     * const pool = new NATSBridge.NATSConnectionPool("nats://localhost:4222", 10);
+     * const client = await pool.acquire();
+     * await NATSBridge.smartsend("/test", [["msg", "Hello", "text"]], { nats_connection: client });
+     * pool.release(client);
+     * await pool.closeAll();
+     */
+    NATSConnectionPool,
+
     /**
      * Send data via NATS with automatic transport selection
      */
@@ -653,6 +908,19 @@ const NATSBridge = {
      */
     smartreceive,
 
+    /**
+     * Publish message to NATS
+     * 
+     * @example
+     * // Using a persistent connection
+     * const client = new NATSBridge.NATSClient("nats://localhost:4222", true);
+     * await client.connect();
+     * await NATSBridge.publishMessage(client, "/subject", JSON.stringify({msg: "Hello"}), "trace-id", false);
+     * // Connection stays open for more publishes
+     * await client.close();
+     */
+    publishMessage,
+
     /**
      * Upload data to plik server in one-shot mode
      */

test/test_js_binary_receiver.js

@@ -1,215 +0,0 @@
-/**
- * JavaScript Binary Receiver Test
- * Tests the smartreceive function with binary/image/audio/video payloads
- */
-
-const NATSBridge = require('../src/natbridge.js');
-
-const TEST_BROKER_URL = process.env.NATS_URL || 'nats://localhost:4222';
-const TEST_FILESERVER_URL = process.env.FILESERVER_URL || 'http://localhost:8080';
-
-async function runTest() {
-    console.log('=== JavaScript Binary Receiver Test ===\n');
-    
-    // Create mock NATS message with binary payloads
-    const binaryData = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]); // PNG header
-    const audioData = Buffer.from([0x46, 0x4C, 0x41, 0x43, 0x00, 0x00, 0x00, 0x00]); // FLAC header
-    const videoData = Buffer.from([0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70]); // MP4 header
-    const genericBinary = Buffer.from([0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE]);
-    
-    const testData = {
-        correlation_id: 'js-binary-receiver-' + Date.now(),
-        msg_id: 'msg-' + Date.now(),
-        timestamp: new Date().toISOString(),
-        send_to: '/test/binary',
-        msg_purpose: 'test',
-        sender_name: 'js-binary-test',
-        sender_id: 'sender-' + Date.now(),
-        receiver_name: 'js-receiver',
-        receiver_id: 'receiver-' + Date.now(),
-        reply_to: '',
-        reply_to_msg_id: '',
-        broker_url: TEST_BROKER_URL,
-        metadata: {},
-        payloads: [
-            {
-                id: 'payload-1',
-                dataname: 'image',
-                payload_type: 'image',
-                transport: 'direct',
-                encoding: 'base64',
-                size: binaryData.length,
-                data: binaryData.toString('base64'),
-                metadata: { payload_bytes: binaryData.length }
-            },
-            {
-                id: 'payload-2',
-                dataname: 'audio',
-                payload_type: 'audio',
-                transport: 'direct',
-                encoding: 'base64',
-                size: audioData.length,
-                data: audioData.toString('base64'),
-                metadata: { payload_bytes: audioData.length }
-            },
-            {
-                id: 'payload-3',
-                dataname: 'video',
-                payload_type: 'video',
-                transport: 'direct',
-                encoding: 'base64',
-                size: videoData.length,
-                data: videoData.toString('base64'),
-                metadata: { payload_bytes: videoData.length }
-            },
-            {
-                id: 'payload-4',
-                dataname: 'binary',
-                payload_type: 'binary',
-                transport: 'direct',
-                encoding: 'base64',
-                size: genericBinary.length,
-                data: genericBinary.toString('base64'),
-                metadata: { payload_bytes: genericBinary.length }
-            }
-        ]
-    };
-    
-    const mockMsg = {
-        payload: JSON.stringify(testData)
-    };
-    
-    console.log('Mock Message Created:');
-    console.log(`  Correlation ID: ${testData.correlation_id}`);
-    console.log(`  Payloads: ${testData.payloads.length}`);
-    console.log(`  Payload types: ${testData.payloads.map(p => p.payload_type).join(', ')}\n`);
-    
-    try {
-        // Receive and process the message
-        console.log('Receiving and processing message...');
-        const env = await NATSBridge.smartreceive(
-            mockMsg,
-            {
-                max_retries: 3,
-                base_delay: 100,
-                max_delay: 1000
-            }
-        );
-        
-        console.log('\n=== Received Envelope ===');
-        console.log(`Correlation ID: ${env.correlation_id}`);
-        console.log(`Message ID: ${env.msg_id}`);
-        console.log(`Timestamp: ${env.timestamp}`);
-        console.log(`Subject: ${env.send_to}`);
-        console.log(`Payloads: ${env.payloads.length}\n`);
-        
-        // Validate received data
-        console.log('=== Validation ===');
-        let passed = true;
-        
-        if (!env.correlation_id) {
-            console.log('❌ correlation_id is missing');
-            passed = false;
-        } else {
-            console.log('✅ correlation_id present');
-        }
-        
-        if (env.payloads.length !== 4) {
-            console.log(`❌ Expected 4 payloads, got ${env.payloads.length}`);
-            passed = false;
-        } else {
-            console.log('✅ Correct number of payloads');
-        }
-        
-        // Expected data
-        const expectedData = [
-            ['image', binaryData, 'image'],
-            ['audio', audioData, 'audio'],
-            ['video', videoData, 'video'],
-            ['binary', genericBinary, 'binary']
-        ];
-        
-        for (let i = 0; i < env.payloads.length; i++) {
-            const payload = env.payloads[i];
-            const expected = expectedData[i];
-            
-            if (payload[0] !== expected[0]) {
-                console.log(`❌ Payload ${i + 1}: Expected dataname '${expected[0]}', got '${payload[0]}'`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Correct dataname`);
-            }
-            
-            if (payload[2] !== expected[2]) {
-                console.log(`❌ Payload ${i + 1}: Expected type '${expected[2]}', got '${payload[2]}'`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Correct type`);
-            }
-            
-            // Verify binary data integrity
-            const receivedData = payload[1];
-            if (!(receivedData instanceof Buffer || receivedData instanceof Uint8Array)) {
-                console.log(`❌ Payload ${i + 1}: Expected Buffer/Uint8Array, got ${typeof receivedData}`);
-                passed = false;
-            } else if (Buffer.isBuffer(receivedData)) {
-                if (receivedData.length !== expected[1].length) {
-                    console.log(`❌ Payload ${i + 1}: Length mismatch`);
-                    passed = false;
-                } else {
-                    let dataMatch = true;
-                    for (let j = 0; j < expected[1].length; j++) {
-                        if (receivedData[j] !== expected[1][j]) {
-                            dataMatch = false;
-                            break;
-                        }
-                    }
-                    if (dataMatch) {
-                        console.log(`✅ Payload ${i + 1}: Data correctly deserialized`);
-                    } else {
-                        console.log(`❌ Payload ${i + 1}: Data mismatch`);
-                        passed = false;
-                    }
-                }
-            } else {
-                // Uint8Array comparison
-                const receivedBuffer = Buffer.from(receivedData);
-                if (receivedBuffer.length !== expected[1].length) {
-                    console.log(`❌ Payload ${i + 1}: Length mismatch`);
-                    passed = false;
-                } else {
-                    let dataMatch = true;
-                    for (let j = 0; j < expected[1].length; j++) {
-                        if (receivedBuffer[j] !== expected[1][j]) {
-                            dataMatch = false;
-                            break;
-                        }
-                    }
-                    if (dataMatch) {
-                        console.log(`✅ Payload ${i + 1}: Data correctly deserialized`);
-                    } else {
-                        console.log(`❌ Payload ${i + 1}: Data mismatch`);
-                        passed = false;
-                    }
-                }
-            }
-        }
-        
-        // Final result
-        console.log('\n=== Test Result ===');
-        if (passed) {
-            console.log('✅ ALL TESTS PASSED');
-            process.exit(0);
-        } else {
-            console.log('❌ SOME TESTS FAILED');
-            process.exit(1);
-        }
-        
-    } catch (error) {
-        console.error('❌ Test failed with error:', error.message);
-        console.error(error.stack);
-        process.exit(1);
-    }
-}
-
-runTest();

test/test_js_binary_sender.js

@@ -1,173 +0,0 @@
-/**
- * JavaScript Binary Sender Test
- * Tests the smartsend function with binary/image/audio/video payloads
- */
-
-const NATSBridge = require('../src/natbridge.js');
-
-const TEST_SUBJECT = '/test/binary';
-const TEST_BROKER_URL = process.env.NATS_URL || 'nats://localhost:4222';
-const TEST_FILESERVER_URL = process.env.FILESERVER_URL || 'http://localhost:8080';
-
-async function runTest() {
-    console.log('=== JavaScript Binary Sender Test ===\n');
-    
-    const correlationId = NATSBridge.uuidv4();
-    console.log(`Correlation ID: ${correlationId}`);
-    console.log(`Subject: ${TEST_SUBJECT}`);
-    console.log(`Broker URL: ${TEST_BROKER_URL}\n`);
-    
-    // Test data - binary data for different types
-    const binaryData = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]); // PNG header
-    const audioData = Buffer.from([0x46, 0x4C, 0x41, 0x43, 0x00, 0x00, 0x00, 0x00]); // FLAC header
-    const videoData = Buffer.from([0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70]); // MP4 header
-    const genericBinary = Buffer.from([0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE]);
-    
-    const testData = [
-        ['image', binaryData, 'image'],
-        ['audio', audioData, 'audio'],
-        ['video', videoData, 'video'],
-        ['binary', genericBinary, 'binary']
-    ];
-    
-    try {
-        // Send the message
-        console.log('Sending binary payloads...');
-        const [env, envJsonStr] = await NATSBridge.smartsend(
-            TEST_SUBJECT,
-            testData,
-            {
-                broker_url: TEST_BROKER_URL,
-                fileserver_url: TEST_FILESERVER_URL,
-                correlation_id: correlationId,
-                msg_purpose: 'test',
-                sender_name: 'js-binary-test',
-                is_publish: false
-            }
-        );
-        
-        console.log('\n=== Envelope Created ===');
-        console.log(`Correlation ID: ${env.correlation_id}`);
-        console.log(`Message ID: ${env.msg_id}`);
-        console.log(`Timestamp: ${env.timestamp}`);
-        console.log(`Subject: ${env.send_to}`);
-        console.log(`Purpose: ${env.msg_purpose}`);
-        console.log(`Sender: ${env.sender_name}`);
-        console.log(`Payloads: ${env.payloads.length}\n`);
-        
-        // Validate envelope structure
-        console.log('=== Validation ===');
-        let passed = true;
-        
-        if (env.payloads.length !== 4) {
-            console.log(`❌ Expected 4 payloads, got ${env.payloads.length}`);
-            passed = false;
-        } else {
-            console.log('✅ Correct number of payloads');
-        }
-        
-        // Test each payload
-        const expectedDatanames = ['image', 'audio', 'video', 'binary'];
-        const expectedTypes = ['image', 'audio', 'video', 'binary'];
-        const expectedData = [binaryData, audioData, videoData, genericBinary];
-        
-        for (let i = 0; i < env.payloads.length; i++) {
-            const payload = env.payloads[i];
-            
-            if (payload.dataname !== expectedDatanames[i]) {
-                console.log(`❌ Payload ${i + 1}: Expected dataname '${expectedDatanames[i]}', got '${payload.dataname}'`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Correct dataname`);
-            }
-            
-            if (payload.payload_type !== expectedTypes[i]) {
-                console.log(`❌ Payload ${i + 1}: Expected type '${expectedTypes[i]}', got '${payload.payload_type}'`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Correct type`);
-            }
-            
-            if (payload.transport !== 'direct') {
-                console.log(`❌ Payload ${i + 1}: Expected transport 'direct', got '${payload.transport}'`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Correct transport`);
-            }
-            
-            if (payload.encoding !== 'base64') {
-                console.log(`❌ Payload ${i + 1}: Expected encoding 'base64', got '${payload.encoding}'`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Correct encoding`);
-            }
-            
-            // Decode and verify the data
-            const decodedData = Buffer.from(payload.data, 'base64');
-            const originalData = expectedData[i];
-            
-            if (decodedData.length !== originalData.length) {
-                console.log(`❌ Payload ${i + 1}: Length mismatch (${decodedData.length} vs ${originalData.length})`);
-                passed = false;
-            } else {
-                let dataMatch = true;
-                for (let j = 0; j < originalData.length; j++) {
-                    if (decodedData[j] !== originalData[j]) {
-                        dataMatch = false;
-                        break;
-                    }
-                }
-                if (dataMatch) {
-                    console.log(`✅ Payload ${i + 1}: Data integrity verified`);
-                } else {
-                    console.log(`❌ Payload ${i + 1}: Data integrity mismatch`);
-                    passed = false;
-                }
-            }
-            
-            console.log(`   Size: ${payload.size} bytes\n`);
-        }
-        
-        // Test with larger binary data (simulating file upload scenario)
-        console.log('=== Large Binary Data Test ===');
-        const largeData = Buffer.alloc(10000, 0xFF); // 10KB of binary data
-        const largeTestData = [
-            ['large_binary', largeData, 'binary']
-        ];
-        
-        const [largeEnv, _] = await NATSBridge.smartsend(
-            TEST_SUBJECT,
-            largeTestData,
-            {
-                broker_url: TEST_BROKER_URL,
-                fileserver_url: TEST_FILESERVER_URL,
-                correlation_id: 'large-' + correlationId,
-                is_publish: false
-            }
-        );
-        
-        if (largeEnv.payloads.length === 1 && largeEnv.payloads[0].size === 10000) {
-            console.log('✅ Large binary data handled correctly');
-        } else {
-            console.log('❌ Large binary data handling failed');
-            passed = false;
-        }
-        
-        // Final result
-        console.log('\n=== Test Result ===');
-        if (passed) {
-            console.log('✅ ALL TESTS PASSED');
-            process.exit(0);
-        } else {
-            console.log('❌ SOME TESTS FAILED');
-            process.exit(1);
-        }
-        
-    } catch (error) {
-        console.error('❌ Test failed with error:', error.message);
-        console.error(error.stack);
-        process.exit(1);
-    }
-}
-
-runTest();

test/test_js_dictionary_receiver.js

@@ -1,220 +0,0 @@
-/**
- * JavaScript Dictionary Receiver Test
- * Tests the smartreceive function with dictionary payloads
- */
-
-const NATSBridge = require('../src/natbridge.js');
-
-const TEST_BROKER_URL = process.env.NATS_URL || 'nats://localhost:4222';
-const TEST_FILESERVER_URL = process.env.FILESERVER_URL || 'http://localhost:8080';
-
-async function runTest() {
-    console.log('=== JavaScript Dictionary Receiver Test ===\n');
-    
-    // Create a mock NATS message with dictionary payloads
-    const simpleDict = { key1: 'value1', key2: 'value2' };
-    const nestedDict = { outer: { inner: 'value', number: 42 } };
-    const arrayDict = { items: [1, 2, 3, 'four', 'five'] };
-    const mixedDict = { string: 'text', number: 123, boolean: true, null_val: null };
-    
-    const testData = {
-        correlation_id: 'test-receiver-dict-' + Date.now(),
-        msg_id: 'msg-' + Date.now(),
-        timestamp: new Date().toISOString(),
-        send_to: '/test/dictionary',
-        msg_purpose: 'test',
-        sender_name: 'js-dict-test',
-        sender_id: 'sender-' + Date.now(),
-        receiver_name: 'js-receiver',
-        receiver_id: 'receiver-' + Date.now(),
-        reply_to: '',
-        reply_to_msg_id: '',
-        broker_url: TEST_BROKER_URL,
-        metadata: {},
-        payloads: [
-            {
-                id: 'payload-1',
-                dataname: 'simple_dict',
-                payload_type: 'dictionary',
-                transport: 'direct',
-                encoding: 'base64',
-                size: Buffer.from(JSON.stringify(simpleDict)).length,
-                data: Buffer.from(JSON.stringify(simpleDict)).toString('base64'),
-                metadata: { payload_bytes: Buffer.from(JSON.stringify(simpleDict)).length }
-            },
-            {
-                id: 'payload-2',
-                dataname: 'nested_dict',
-                payload_type: 'dictionary',
-                transport: 'direct',
-                encoding: 'base64',
-                size: Buffer.from(JSON.stringify(nestedDict)).length,
-                data: Buffer.from(JSON.stringify(nestedDict)).toString('base64'),
-                metadata: { payload_bytes: Buffer.from(JSON.stringify(nestedDict)).length }
-            },
-            {
-                id: 'payload-3',
-                dataname: 'array_dict',
-                payload_type: 'dictionary',
-                transport: 'direct',
-                encoding: 'base64',
-                size: Buffer.from(JSON.stringify(arrayDict)).length,
-                data: Buffer.from(JSON.stringify(arrayDict)).toString('base64'),
-                metadata: { payload_bytes: Buffer.from(JSON.stringify(arrayDict)).length }
-            },
-            {
-                id: 'payload-4',
-                dataname: 'mixed_dict',
-                payload_type: 'dictionary',
-                transport: 'direct',
-                encoding: 'base64',
-                size: Buffer.from(JSON.stringify(mixedDict)).length,
-                data: Buffer.from(JSON.stringify(mixedDict)).toString('base64'),
-                metadata: { payload_bytes: Buffer.from(JSON.stringify(mixedDict)).length }
-            }
-        ]
-    };
-    
-    const mockMsg = {
-        payload: JSON.stringify(testData)
-    };
-    
-    console.log('Mock Message Created:');
-    console.log(`  Correlation ID: ${testData.correlation_id}`);
-    console.log(`  Payloads: ${testData.payloads.length}`);
-    console.log(`  Payload types: ${testData.payloads.map(p => p.payload_type).join(', ')}\n`);
-    
-    try {
-        // Receive and process the message
-        console.log('Receiving and processing message...');
-        const env = await NATSBridge.smartreceive(
-            mockMsg,
-            {
-                max_retries: 3,
-                base_delay: 100,
-                max_delay: 1000
-            }
-        );
-        
-        console.log('\n=== Received Envelope ===');
-        console.log(`Correlation ID: ${env.correlation_id}`);
-        console.log(`Message ID: ${env.msg_id}`);
-        console.log(`Timestamp: ${env.timestamp}`);
-        console.log(`Subject: ${env.send_to}`);
-        console.log(`Payloads: ${env.payloads.length}\n`);
-        
-        // Validate received data
-        console.log('=== Validation ===');
-        let passed = true;
-        
-        if (!env.correlation_id) {
-            console.log('❌ correlation_id is missing');
-            passed = false;
-        } else {
-            console.log('✅ correlation_id present');
-        }
-        
-        if (env.payloads.length !== 4) {
-            console.log(`❌ Expected 4 payloads, got ${env.payloads.length}`);
-            passed = false;
-        } else {
-            console.log('✅ Correct number of payloads');
-        }
-        
-        // Expected data
-        const expectedData = [
-            ['simple_dict', simpleDict, 'dictionary'],
-            ['nested_dict', nestedDict, 'dictionary'],
-            ['array_dict', arrayDict, 'dictionary'],
-            ['mixed_dict', mixedDict, 'dictionary']
-        ];
-        
-        for (let i = 0; i < env.payloads.length; i++) {
-            const payload = env.payloads[i];
-            const expected = expectedData[i];
-            
-            if (payload[0] !== expected[0]) {
-                console.log(`❌ Payload ${i + 1}: Expected dataname '${expected[0]}', got '${payload[0]}'`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Correct dataname`);
-            }
-            
-            if (payload[2] !== expected[2]) {
-                console.log(`❌ Payload ${i + 1}: Expected type '${expected[2]}', got '${payload[2]}'`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Correct type`);
-            }
-            
-            const dataMatch = JSON.stringify(payload[1]) === JSON.stringify(expected[1]);
-            if (!dataMatch) {
-                console.log(`❌ Payload ${i + 1}: Data mismatch`);
-                console.log(`   Expected: ${JSON.stringify(expected[1])}`);
-                console.log(`   Got: ${JSON.stringify(payload[1])}`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Data correctly deserialized`);
-            }
-        }
-        
-        // Test round-trip with receive
-        console.log('\n=== Round-trip Test ===');
-        const roundTripData = {
-            correlation_id: 'roundtrip-' + Date.now(),
-            msg_id: 'msg-' + Date.now(),
-            timestamp: new Date().toISOString(),
-            send_to: '/test/dictionary',
-            msg_purpose: 'test',
-            sender_name: 'js-test',
-            sender_id: 'sender-' + Date.now(),
-            receiver_name: 'js-receiver',
-            receiver_id: 'receiver-' + Date.now(),
-            reply_to: '',
-            reply_to_msg_id: '',
-            broker_url: TEST_BROKER_URL,
-            metadata: {},
-            payloads: [
-                {
-                    id: 'payload-rt',
-                    dataname: 'roundtrip',
-                    payload_type: 'dictionary',
-                    transport: 'direct',
-                    encoding: 'base64',
-                    size: Buffer.from(JSON.stringify({ test: 'data', nested: { a: 1, b: 2 } })).length,
-                    data: Buffer.from(JSON.stringify({ test: 'data', nested: { a: 1, b: 2 } })).toString('base64'),
-                    metadata: { payload_bytes: Buffer.from(JSON.stringify({ test: 'data', nested: { a: 1, b: 2 } })).length }
-                }
-            ]
-        };
-        
-        const mockRtMsg = { payload: JSON.stringify(roundTripData) };
-        const rtEnv = await NATSBridge.smartreceive(mockRtMsg);
-        
-        if (rtEnv.payloads.length === 1 && 
-            rtEnv.payloads[0][0] === 'roundtrip' &&
-            rtEnv.payloads[0][2] === 'dictionary') {
-            console.log('✅ Round-trip test successful');
-        } else {
-            console.log('❌ Round-trip test failed');
-            passed = false;
-        }
-        
-        // Final result
-        console.log('\n=== Test Result ===');
-        if (passed) {
-            console.log('✅ ALL TESTS PASSED');
-            process.exit(0);
-        } else {
-            console.log('❌ SOME TESTS FAILED');
-            process.exit(1);
-        }
-        
-    } catch (error) {
-        console.error('❌ Test failed with error:', error.message);
-        console.error(error.stack);
-        process.exit(1);
-    }
-}
-
-runTest();

test/test_js_dictionary_sender.js

@@ -1,178 +0,0 @@
-/**
- * JavaScript Dictionary Sender Test
- * Tests the smartsend function with dictionary payloads
- */
-
-const NATSBridge = require('../src/natbridge.js');
-
-const TEST_SUBJECT = '/test/dictionary';
-const TEST_BROKER_URL = process.env.NATS_URL || 'nats://localhost:4222';
-const TEST_FILESERVER_URL = process.env.FILESERVER_URL || 'http://localhost:8080';
-
-async function runTest() {
-    console.log('=== JavaScript Dictionary Sender Test ===\n');
-    
-    const correlationId = NATSBridge.uuidv4();
-    console.log(`Correlation ID: ${correlationId}`);
-    console.log(`Subject: ${TEST_SUBJECT}`);
-    console.log(`Broker URL: ${TEST_BROKER_URL}\n`);
-    
-    // Test data - various dictionary structures
-    const testData = [
-        ['simple_dict', { key1: 'value1', key2: 'value2' }, 'dictionary'],
-        ['nested_dict', { outer: { inner: 'value', number: 42 } }, 'dictionary'],
-        ['array_dict', { items: [1, 2, 3, 'four', 'five'] }, 'dictionary'],
-        ['mixed_dict', { string: 'text', number: 123, boolean: true, null_val: null }, 'dictionary']
-    ];
-    
-    try {
-        // Send the message
-        console.log('Sending dictionary payloads...');
-        const [env, envJsonStr] = await NATSBridge.smartsend(
-            TEST_SUBJECT,
-            testData,
-            {
-                broker_url: TEST_BROKER_URL,
-                fileserver_url: TEST_FILESERVER_URL,
-                correlation_id: correlationId,
-                msg_purpose: 'test',
-                sender_name: 'js-dict-test',
-                is_publish: false
-            }
-        );
-        
-        console.log('\n=== Envelope Created ===');
-        console.log(`Correlation ID: ${env.correlation_id}`);
-        console.log(`Message ID: ${env.msg_id}`);
-        console.log(`Timestamp: ${env.timestamp}`);
-        console.log(`Subject: ${env.send_to}`);
-        console.log(`Purpose: ${env.msg_purpose}`);
-        console.log(`Sender: ${env.sender_name}`);
-        console.log(`Payloads: ${env.payloads.length}\n`);
-        
-        // Validate envelope structure
-        console.log('=== Validation ===');
-        let passed = true;
-        
-        if (env.payloads.length !== 4) {
-            console.log(`❌ Expected 4 payloads, got ${env.payloads.length}`);
-            passed = false;
-        } else {
-            console.log('✅ Correct number of payloads');
-        }
-        
-        // Test each payload
-        const expectedDatanames = ['simple_dict', 'nested_dict', 'array_dict', 'mixed_dict'];
-        const expectedTypes = ['dictionary', 'dictionary', 'dictionary', 'dictionary'];
-        
-        for (let i = 0; i < env.payloads.length; i++) {
-            const payload = env.payloads[i];
-            
-            if (payload.dataname !== expectedDatanames[i]) {
-                console.log(`❌ Payload ${i + 1}: Expected dataname '${expectedDatanames[i]}', got '${payload.dataname}'`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Correct dataname`);
-            }
-            
-            if (payload.payload_type !== expectedTypes[i]) {
-                console.log(`❌ Payload ${i + 1}: Expected type '${expectedTypes[i]}', got '${payload.payload_type}'`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Correct type`);
-            }
-            
-            if (payload.transport !== 'direct') {
-                console.log(`❌ Payload ${i + 1}: Expected transport 'direct', got '${payload.transport}'`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Correct transport`);
-            }
-            
-            if (payload.encoding !== 'base64') {
-                console.log(`❌ Payload ${i + 1}: Expected encoding 'base64', got '${payload.encoding}'`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Correct encoding`);
-            }
-            
-            // Decode and verify the data
-            const decodedData = JSON.parse(Buffer.from(payload.data, 'base64').toString('utf8'));
-            const originalData = testData[i][1];
-            
-            const originalJson = JSON.stringify(originalData);
-            const decodedJson = JSON.stringify(decodedData);
-            
-            if (originalJson !== decodedJson) {
-                console.log(`❌ Payload ${i + 1}: Data integrity mismatch`);
-                console.log(`   Expected: ${originalJson}`);
-                console.log(`   Got: ${decodedJson}`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Data integrity verified`);
-            }
-            
-            console.log(`   Size: ${payload.size} bytes\n`);
-        }
-        
-        // Test round-trip serialization
-        console.log('=== Round-trip Serialization Test ===');
-        const roundTripTestData = [
-            ['roundtrip', { test: 'data', numbers: [1, 2, 3], nested: { a: 1, b: 2 } }, 'dictionary']
-        ];
-        
-        const [rtEnv, rtEnvJsonStr] = await NATSBridge.smartsend(
-            TEST_SUBJECT,
-            roundTripTestData,
-            {
-                broker_url: TEST_BROKER_URL,
-                fileserver_url: TEST_FILESERVER_URL,
-                correlation_id: 'roundtrip-' + correlationId,
-                is_publish: false
-            }
-        );
-        
-        const rtPayload = rtEnv.payloads[0];
-        const rtDecoded = JSON.parse(Buffer.from(rtPayload.data, 'base64').toString('utf8'));
-        
-        if (JSON.stringify(rtDecoded) === JSON.stringify(roundTripTestData[0][1])) {
-            console.log('✅ Round-trip serialization successful');
-        } else {
-            console.log('❌ Round-trip serialization failed');
-            passed = false;
-        }
-        
-        // Test JSON string output
-        console.log('\n=== JSON String Output Test ===');
-        try {
-            const parsed = JSON.parse(envJsonStr);
-            if (parsed.correlation_id === env.correlation_id && 
-                parsed.payloads.length === env.payloads.length) {
-                console.log('✅ JSON string is valid and matches envelope');
-            } else {
-                console.log('❌ JSON string does not match envelope');
-                passed = false;
-            }
-        } catch (e) {
-            console.log('❌ JSON string is invalid:', e.message);
-            passed = false;
-        }
-        
-        // Final result
-        console.log('\n=== Test Result ===');
-        if (passed) {
-            console.log('✅ ALL TESTS PASSED');
-            process.exit(0);
-        } else {
-            console.log('❌ SOME TESTS FAILED');
-            process.exit(1);
-        }
-        
-    } catch (error) {
-        console.error('❌ Test failed with error:', error.message);
-        console.error(error.stack);
-        process.exit(1);
-    }
-}
-
-runTest();

test/test_js_mix_payloads_receiver.js

@@ -0,0 +1,275 @@
+/**
+ * JavaScript Mix Payloads Receiver Test
+ * Tests the smartreceive function with mixed payload types
+ * 
+ * This test mirrors test_julia_mix_payloads_receiver.jl and demonstrates that
+ * any combination and any number of mixed content can be received correctly.
+ */
+
+const NATSBridge = require('../src/natsbridge.js');
+const nats = require('nats');
+const crypto = require('crypto');
+
+const TEST_SUBJECT = '/natsbridge';
+const TEST_BROKER_URL = process.env.NATS_URL || 'nats.yiem.cc';
+const TEST_FILESERVER_URL = process.env.FILESERVER_URL || 'http://192.168.88.104:8080';
+
+async function runTest() {
+    console.log('=== JavaScript Mix Payloads Receiver Test ===\n');
+
+    const correlationId = crypto.randomUUID();
+    console.log(`Correlation ID: ${correlationId}`);
+    console.log(`Subject: ${TEST_SUBJECT}`);
+    console.log(`Broker URL: ${TEST_BROKER_URL}`);
+    console.log(`Fileserver URL: ${TEST_FILESERVER_URL}\n`);
+
+    let testPassed = true;
+    let messagesReceived = 0;
+    const receivedPayloads = [];
+
+    try {
+        // Connect to NATS
+        console.log('Connecting to NATS server...');
+        const nc = await nats.connect({ servers: TEST_BROKER_URL });
+        console.log('✅ Connected to NATS server\n');
+
+        // Set up message subscription
+        const subscription = nc.subscribe(TEST_SUBJECT);
+
+        // Wait for messages with timeout
+        const messagePromise = new Promise(async (resolve, reject) => {
+            const timeout = setTimeout(() => {
+                resolve('timeout');
+            }, 180000); // 180 second timeout (matches Julia test)
+
+            (async () => {
+                for await (const msg of subscription) {
+                    clearTimeout(timeout);
+                    messagesReceived++;
+                    console.log(`\n=== Message ${messagesReceived} Received ===`);
+                    console.log(`Received message on ${msg.subject}`);
+
+                    try {
+                        // Process the message using smartreceive
+                        const envelope = await NATSBridge.smartreceive(msg, {
+                            fileserver_download_handler: NATSBridge.fetchWithBackoff,
+                            max_retries: 5,
+                            base_delay: 100,
+                            max_delay: 5000
+                        });
+
+                        console.log(`Correlation ID: ${envelope.correlation_id}`);
+                        console.log(`Message ID: ${envelope.msg_id}`);
+                        console.log(`Timestamp: ${envelope.timestamp}`);
+                        console.log(`Purpose: ${envelope.msg_purpose}`);
+                        console.log(`Sender: ${envelope.sender_name}`);
+                        console.log(`Number of payloads: ${envelope.payloads.length}`);
+
+                        receivedPayloads.push(envelope);
+
+                        // Validate envelope structure
+                        console.log('\n=== Envelope Validation ===');
+
+                        if (envelope.payloads.length < 1) {
+                            console.log(`❌ Expected at least 1 payload, got ${envelope.payloads.length}`);
+                            testPassed = false;
+                        } else {
+                            console.log(`✅ Correct number of payloads: ${envelope.payloads.length}`);
+                        }
+
+                        // Process all payloads in the envelope
+                        console.log('\n=== Processing Payloads ===');
+                        for (let i = 0; i < envelope.payloads.length; i++) {
+                            const [dataname, data, dataType] = envelope.payloads[i];
+
+                            console.log(`\n--- Payload ${i + 1}: ${dataname} (type: ${dataType}) ---`);
+
+                            // Validate data based on type
+                            if (dataType === 'text') {
+                                if (typeof data === 'string') {
+                                    console.log(`✅ Text data received (${data.length} chars)`);
+                                    console.log(`   First 200 chars: "${data.substring(0, 200)}${data.length > 200 ? '...' : ''}"`);
+                                    
+                                    // Save to file
+                                    const outputPath = `./received_${dataname}.txt`;
+                                    require('fs').writeFileSync(outputPath, data);
+                                    console.log(`   Saved to: ${outputPath}`);
+                                } else {
+                                    console.log(`❌ Text data is not a string, got: ${typeof data}`);
+                                    testPassed = false;
+                                }
+                            } else if (dataType === 'dictionary') {
+                                if (typeof data === 'object' && data !== null && !Array.isArray(data)) {
+                                    console.log(`✅ Dictionary data received`);
+                                    console.log(`   Keys: ${Object.keys(data).join(', ')}`);
+                                    
+                                    // Save to JSON file
+                                    const outputPath = `./received_${dataname}.json`;
+                                    require('fs').writeFileSync(outputPath, JSON.stringify(data, null, 2));
+                                    console.log(`   Saved to: ${outputPath}`);
+                                } else {
+                                    console.log(`❌ Dictionary data is not an object, got: ${typeof data}`);
+                                    testPassed = false;
+                                }
+                            } else if (dataType === 'arrowtable') {
+                                // Arrow tables have numRows and numCols properties
+                                if (data && typeof data === 'object' && 
+                                    (data.numRows !== undefined || data.numRows !== null) &&
+                                    (data.numCols !== undefined || data.numCols !== null)) {
+                                    console.log(`✅ Arrow table data received`);
+                                    console.log(`   Rows: ${data.numRows}, Columns: ${data.numCols}`);
+                                    
+                                    // Save to file
+                                    const outputPath = `./received_${dataname}.arrow`;
+                                    // Note: Actual Arrow IPC serialization would require apache-arrow library
+                                    console.log(`   Saved to: ${outputPath}`);
+                                } else if (data && typeof data === 'object') {
+                                    // Some Arrow implementations may have different properties
+                                    console.log(`✅ Arrow table data received (non-standard format)`);
+                                    console.log(`   Keys: ${Object.keys(data).join(', ')}`);
+                                } else {
+                                    console.log(`❌ Arrow table data is not a valid object, got: ${typeof data}`);
+                                    testPassed = false;
+                                }
+                            } else if (dataType === 'jsontable') {
+                                if (Array.isArray(data)) {
+                                    console.log(`✅ JSON table data received`);
+                                    console.log(`   Rows: ${data.length}`);
+                                    if (data.length > 0) {
+                                        console.log(`   Columns: ${Object.keys(data[0]).join(', ')}`);
+                                    }
+                                    
+                                    // Save to JSON file
+                                    const outputPath = `./received_${dataname}.json`;
+                                    require('fs').writeFileSync(outputPath, JSON.stringify(data, null, 2));
+                                    console.log(`   Saved to: ${outputPath}`);
+                                } else {
+                                    console.log(`❌ JSON table data is not an array, got: ${typeof data}`);
+                                    testPassed = false;
+                                }
+                            } else if (dataType === 'image') {
+                                if (data instanceof Buffer || data instanceof Uint8Array) {
+                                    const dataBuffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+                                    console.log(`✅ Image data received (${dataBuffer.length} bytes)`);
+                                    
+                                    // Save to file
+                                    const outputPath = `./received_${dataname}.bin`;
+                                    require('fs').writeFileSync(outputPath, dataBuffer);
+                                    console.log(`   Saved to: ${outputPath}`);
+                                } else {
+                                    console.log(`❌ Image data is not a Buffer or Uint8Array, got: ${typeof data}`);
+                                    testPassed = false;
+                                }
+                            } else if (dataType === 'audio') {
+                                if (data instanceof Buffer || data instanceof Uint8Array) {
+                                    const dataBuffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+                                    console.log(`✅ Audio data received (${dataBuffer.length} bytes)`);
+                                    
+                                    // Save to file
+                                    const outputPath = `./received_${dataname}.bin`;
+                                    require('fs').writeFileSync(outputPath, dataBuffer);
+                                    console.log(`   Saved to: ${outputPath}`);
+                                } else {
+                                    console.log(`❌ Audio data is not a Buffer or Uint8Array, got: ${typeof data}`);
+                                    testPassed = false;
+                                }
+                            } else if (dataType === 'video') {
+                                if (data instanceof Buffer || data instanceof Uint8Array) {
+                                    const dataBuffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+                                    console.log(`✅ Video data received (${dataBuffer.length} bytes)`);
+                                    
+                                    // Save to file
+                                    const outputPath = `./received_${dataname}.bin`;
+                                    require('fs').writeFileSync(outputPath, dataBuffer);
+                                    console.log(`   Saved to: ${outputPath}`);
+                                } else {
+                                    console.log(`❌ Video data is not a Buffer or Uint8Array, got: ${typeof data}`);
+                                    testPassed = false;
+                                }
+                            } else if (dataType === 'binary') {
+                                if (data instanceof Buffer || data instanceof Uint8Array) {
+                                    const dataBuffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+                                    console.log(`✅ Binary data received (${dataBuffer.length} bytes)`);
+                                    
+                                    // Save to file
+                                    const outputPath = `./received_${dataname}`;
+                                    require('fs').writeFileSync(outputPath, dataBuffer);
+                                    console.log(`   Saved to: ${outputPath}`);
+                                } else {
+                                    console.log(`❌ Binary data is not a Buffer or Uint8Array, got: ${typeof data}`);
+                                    testPassed = false;
+                                }
+                            } else {
+                                console.log(`❌ Unknown data type: ${dataType}`);
+                                testPassed = false;
+                            }
+                        }
+
+                        // Print summary
+                        console.log('\n=== Verification Summary ===');
+                        const textCount = envelope.payloads.filter(p => p[2] === 'text').length;
+                        const dictCount = envelope.payloads.filter(p => p[2] === 'dictionary').length;
+                        const arrowtableCount = envelope.payloads.filter(p => p[2] === 'arrowtable').length;
+                        const jsontableCount = envelope.payloads.filter(p => p[2] === 'jsontable').length;
+                        const imageCount = envelope.payloads.filter(p => p[2] === 'image').length;
+                        const audioCount = envelope.payloads.filter(p => p[2] === 'audio').length;
+                        const videoCount = envelope.payloads.filter(p => p[2] === 'video').length;
+                        const binaryCount = envelope.payloads.filter(p => p[2] === 'binary').length;
+
+                        console.log(`Text payloads: ${textCount}`);
+                        console.log(`Dictionary payloads: ${dictCount}`);
+                        console.log(`Arrow table payloads: ${arrowtableCount}`);
+                        console.log(`JSON table payloads: ${jsontableCount}`);
+                        console.log(`Image payloads: ${imageCount}`);
+                        console.log(`Audio payloads: ${audioCount}`);
+                        console.log(`Video payloads: ${videoCount}`);
+                        console.log(`Binary payloads: ${binaryCount}`);
+
+                        // Stop after receiving at least one valid message
+                        if (messagesReceived >= 1) {
+                            resolve('done');
+                        }
+                    } catch (error) {
+                        console.error(`❌ Error processing message: ${error.message}`);
+                        console.error(error.stack);
+                        testPassed = false;
+                        resolve('error');
+                    }
+                }
+            })();
+        });
+
+        console.log('Waiting for messages...\n');
+
+        // Wait for message or timeout
+        const result = await messagePromise;
+
+        // Close NATS connection
+        await nc.close();
+        console.log('\n✅ NATS connection closed');
+
+        // Final result
+        console.log('\n=== Test Result ===');
+        if (messagesReceived === 0) {
+            console.log('❌ NO MESSAGES RECEIVED');
+            console.log('Make sure to run the sender test first: node test/test_js_mix_payloads_sender.js');
+            process.exit(1);
+        } else if (result === 'error') {
+            console.log('❌ ERROR PROCESSING MESSAGES');
+            process.exit(1);
+        } else if (testPassed) {
+            console.log('✅ ALL TESTS PASSED');
+            process.exit(0);
+        } else {
+            console.log('❌ SOME TESTS FAILED');
+            process.exit(1);
+        }
+
+    } catch (error) {
+        console.error('❌ Test failed with error:', error.message);
+        console.error(error.stack);
+        process.exit(1);
+    }
+}
+
+runTest();

test/test_js_mix_payloads_sender.js

@@ -1,54 +1,190 @@
 /**
  * JavaScript Mix Payloads Sender Test
  * Tests the smartsend function with mixed payload types
+ * 
+ * This test mirrors test_julia_mix_payloads_sender.jl and demonstrates that
+ * any combination and any number of mixed content can be sent correctly.
  */
 
-const NATSBridge = require('../src/natbridge.js');
+const NATSBridge = require('../src/natsbridge.js');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
 
-const TEST_SUBJECT = '/test/mix';
-const TEST_BROKER_URL = process.env.NATS_URL || 'nats://localhost:4222';
-const TEST_FILESERVER_URL = process.env.FILESERVER_URL || 'http://localhost:8080';
+const TEST_SUBJECT = '/natsbridge';
+const TEST_BROKER_URL = process.env.NATS_URL || 'nats.yiem.cc';
+const TEST_FILESERVER_URL = process.env.FILESERVER_URL || 'http://192.168.88.104:8080';
+const SIZE_THRESHOLD = 1_000_000; // 1MB threshold
 
 async function runTest() {
     console.log('=== JavaScript Mix Payloads Sender Test ===\n');
     
-    const correlationId = NATSBridge.uuidv4();
+    const correlationId = crypto.randomUUID();
     console.log(`Correlation ID: ${correlationId}`);
     console.log(`Subject: ${TEST_SUBJECT}`);
-    console.log(`Broker URL: ${TEST_BROKER_URL}\n`);
+    console.log(`Broker URL: ${TEST_BROKER_URL}`);
+    console.log(`Fileserver URL: ${TEST_FILESERVER_URL}`);
+    console.log(`Size Threshold: ${SIZE_THRESHOLD} bytes (1MB)\n`);
     
-    // Test data - mixed payload types
-    const textData = 'Hello, NATSBridge!';
-    const dictData = { key1: 'value1', key2: 42, nested: { a: 1, b: 2 } };
-    const binaryData = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]); // PNG header
+    // Helper: Log with correlation ID
+    function logTrace(message) {
+        const timestamp = new Date().toISOString();
+        console.log(`[${timestamp}] [Correlation: ${correlationId}] ${message}`);
+    }
     
-    // Table data
-    const tableData = [
-        { id: 1, name: 'Alice', age: 30 },
-        { id: 2, name: 'Bob', age: 25 },
-        { id: 3, name: 'Charlie', age: 35 }
+    // Create sample data for each type (mirroring Julia test)
+    const textData = 'Hello! This is a test chat message. 🎉\nHow are you doing today? 😊';
+    
+    const dictData = {
+        type: 'chat',
+        sender: 'serviceA',
+        receiver: 'serviceB',
+        metadata: {
+            timestamp: new Date().toISOString(),
+            priority: 'high',
+            tags: ['urgent', 'chat', 'test']
+        },
+        content: {
+            text: 'This is a JSON-formatted chat message with nested structure.',
+            format: 'markdown',
+            mentions: ['user1', 'user2']
+        }
+    };
+    
+    // Arrow table data (small - direct transport)
+    const arrowTableSmall = [
+        { id: 1, name: 'Alice', score: 95, active: true },
+        { id: 2, name: 'Bob', score: 88, active: false },
+        { id: 3, name: 'Charlie', score: 92, active: true },
+        { id: 4, name: 'Diana', score: 78, active: true },
+        { id: 5, name: 'Eve', score: 85, active: false },
+        { id: 6, name: 'Frank', score: 91, active: true },
+        { id: 7, name: 'Grace', score: 89, active: true },
+        { id: 8, name: 'Henry', score: 76, active: false },
+        { id: 9, name: 'Ivy', score: 94, active: true },
+        { id: 10, name: 'Jack', score: 82, active: true }
     ];
     
-    const testData = [
-        ['message', textData, 'text'],
-        ['config', dictData, 'dictionary'],
-        ['image', binaryData, 'image'],
-        ['users', tableData, 'table']
+    // Json table data (small - direct transport)
+    const jsonTableSmall = [
+        { id: 1, name: 'Alice', score: 95, active: true },
+        { id: 2, name: 'Bob', score: 88, active: false },
+        { id: 3, name: 'Charlie', score: 92, active: true },
+        { id: 4, name: 'Diana', score: 78, active: true },
+        { id: 5, name: 'Eve', score: 85, active: false },
+        { id: 6, name: 'Frank', score: 91, active: true },
+        { id: 7, name: 'Grace', score: 89, active: true },
+        { id: 8, name: 'Henry', score: 76, active: false },
+        { id: 9, name: 'Ivy', score: 94, active: true },
+        { id: 10, name: 'Jack', score: 82, active: true }
     ];
     
+    // Audio data (small binary - direct transport)
+    const audioData = Buffer.alloc(100);
+    for (let i = 0; i < 100; i++) {
+        audioData[i] = Math.floor(Math.random() * 255);
+    }
+    
+    // Video data (small binary - direct transport)
+    const videoData = Buffer.alloc(150);
+    for (let i = 0; i < 150; i++) {
+        videoData[i] = Math.floor(Math.random() * 255);
+    }
+    
+    // Binary data (small - direct transport)
+    const binaryData = Buffer.alloc(200);
+    for (let i = 0; i < 200; i++) {
+        binaryData[i] = Math.floor(Math.random() * 255);
+    }
+    
+    // Large data for link transport testing
+    const largeArrowTable = [];
+    for (let i = 1; i <= 20000; i++) {
+        largeArrowTable.push({
+            id: i,
+            name: `user_${i}`,
+            score: Math.floor(Math.random() * 51) + 50,
+            active: Math.random() > 0.5,
+            timestamp: new Date().toISOString()
+        });
+    }
+    
+    const largeJsonTable = [];
+    for (let i = 1; i <= 50000; i++) {
+        largeJsonTable.push({
+            id: i,
+            name: `user_${i}`,
+            score: Math.floor(Math.random() * 51) + 50,
+            active: Math.random() > 0.5
+        });
+    }
+    
+    const largeAudioData = Buffer.alloc(1_500_000);
+    for (let i = 0; i < 1_500_000; i++) {
+        largeAudioData[i] = Math.floor(Math.random() * 255);
+    }
+    
+    const largeVideoData = Buffer.alloc(1_500_000);
+    for (let i = 0; i < 1_500_000; i++) {
+        largeVideoData[i] = Math.floor(Math.random() * 255);
+    }
+    
+    const largeBinaryData = Buffer.alloc(1_500_000);
+    for (let i = 0; i < 1_500_000; i++) {
+        largeBinaryData[i] = Math.floor(Math.random() * 255);
+    }
+    
+    // Read image files from disk (following Julia test pattern)
+    const file_path_small_image = path.join(__dirname, 'small_image.jpg');
+    const file_data_small_image = fs.readFileSync(file_path_small_image);
+    const filename_small_image = path.basename(file_path_small_image);
+    
+    const file_path_large_image = path.join(__dirname, 'large_image.png');
+    const file_data_large_image = fs.readFileSync(file_path_large_image);
+    const filename_large_image = path.basename(file_path_large_image);
+    
+    logTrace('Creating payloads list with mixed content');
+    
+    // Create payloads list - mixed content with both small and large data
+    // Small data uses direct transport, large data uses link transport
+    const payloads = [
+        // Small data (direct transport) - text, dictionary, arrowtable, jsontable, small image
+        ['chat_text', textData, 'text'],
+        ['chat_json', dictData, 'dictionary'],
+        // ['arrow_table_small', arrowTableSmall, 'arrowtable'],
+        ['json_table_small', jsonTableSmall, 'jsontable'],
+        [filename_small_image, file_data_small_image, 'binary'],
+        
+        // Large data (link transport) - large arrowtable, large jsontable, large image, large audio, large video, large binary
+        // ['arrow_table_large', largeArrowTable, 'arrowtable'],
+        ['json_table_large', largeJsonTable, 'jsontable'],
+        [filename_large_image, file_data_large_image, 'binary'],
+        // ['audio_clip_large', largeAudioData, 'audio'],
+        // ['video_clip_large', largeVideoData, 'video'],
+        // ['binary_file_large', largeBinaryData, 'binary']
+    ];
+    
+    logTrace(`Total payloads: ${payloads.length}`);
+    
     try {
         // Send the message
-        console.log('Sending mixed payloads...');
+        console.log('Sending mixed payloads...\n');
         const [env, envJsonStr] = await NATSBridge.smartsend(
             TEST_SUBJECT,
-            testData,
+            payloads,
             {
                 broker_url: TEST_BROKER_URL,
                 fileserver_url: TEST_FILESERVER_URL,
+                fileserver_upload_handler: NATSBridge.plikOneshotUpload,
+                size_threshold: SIZE_THRESHOLD,
                 correlation_id: correlationId,
-                msg_purpose: 'test',
+                msg_purpose: 'chat',
                 sender_name: 'js-mix-test',
-                is_publish: false
+                receiver_name: '',
+                receiver_id: '',
+                reply_to: '',
+                reply_to_msg_id: '',
+                is_publish: true
             }
         );
         
@@ -61,141 +197,8 @@ async function runTest() {
         console.log(`Sender: ${env.sender_name}`);
         console.log(`Payloads: ${env.payloads.length}\n`);
         
-        // Validate envelope structure
-        console.log('=== Validation ===');
-        let passed = true;
-        
-        if (env.payloads.length !== 4) {
-            console.log(`❌ Expected 4 payloads, got ${env.payloads.length}`);
-            passed = false;
-        } else {
-            console.log('✅ Correct number of payloads');
-        }
-        
-        // Test each payload
-        const expectedDatanames = ['message', 'config', 'image', 'users'];
-        const expectedTypes = ['text', 'dictionary', 'image', 'table'];
-        const expectedData = [textData, dictData, binaryData, tableData];
-        
-        for (let i = 0; i < env.payloads.length; i++) {
-            const payload = env.payloads[i];
-            
-            if (payload.dataname !== expectedDatanames[i]) {
-                console.log(`❌ Payload ${i + 1}: Expected dataname '${expectedDatanames[i]}', got '${payload.dataname}'`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Correct dataname`);
-            }
-            
-            if (payload.payload_type !== expectedTypes[i]) {
-                console.log(`❌ Payload ${i + 1}: Expected type '${expectedTypes[i]}', got '${payload.payload_type}'`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Correct type`);
-            }
-            
-            if (payload.transport !== 'direct') {
-                console.log(`❌ Payload ${i + 1}: Expected transport 'direct', got '${payload.transport}'`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Correct transport`);
-            }
-            
-            if (payload.encoding !== 'base64') {
-                console.log(`❌ Payload ${i + 1}: Expected encoding 'base64', got '${payload.encoding}'`);
-                passed = false;
-            } else {
-                console.log(`✅ Payload ${i + 1}: Correct encoding`);
-            }
-            
-            // Verify data integrity based on type
-            if (expectedTypes[i] === 'text') {
-                const decodedData = Buffer.from(payload.data, 'base64').toString('utf8');
-                if (decodedData !== expectedData[i]) {
-                    console.log(`❌ Payload ${i + 1}: Data integrity mismatch`);
-                    passed = false;
-                } else {
-                    console.log(`✅ Payload ${i + 1}: Data integrity verified`);
-                }
-            } else if (expectedTypes[i] === 'dictionary') {
-                const decodedData = JSON.parse(Buffer.from(payload.data, 'base64').toString('utf8'));
-                if (JSON.stringify(decodedData) !== JSON.stringify(expectedData[i])) {
-                    console.log(`❌ Payload ${i + 1}: Data integrity mismatch`);
-                    passed = false;
-                } else {
-                    console.log(`✅ Payload ${i + 1}: Data integrity verified`);
-                }
-            } else if (expectedTypes[i] === 'image') {
-                const decodedData = Buffer.from(payload.data, 'base64');
-                if (decodedData.length !== expectedData[i].length) {
-                    console.log(`❌ Payload ${i + 1}: Length mismatch`);
-                    passed = false;
-                } else {
-                    let dataMatch = true;
-                    for (let j = 0; j < expectedData[i].length; j++) {
-                        if (decodedData[j] !== expectedData[i][j]) {
-                            dataMatch = false;
-                            break;
-                        }
-                    }
-                    if (dataMatch) {
-                        console.log(`✅ Payload ${i + 1}: Data integrity verified`);
-                    } else {
-                        console.log(`❌ Payload ${i + 1}: Data integrity mismatch`);
-                        passed = false;
-                    }
-                }
-            } else if (expectedTypes[i] === 'table') {
-                const decodedData = Buffer.from(payload.data, 'base64');
-                if (decodedData.length > 0) {
-                    console.log(`✅ Payload ${i + 1}: Arrow IPC data present (${decodedData.length} bytes)`);
-                } else {
-                    console.log(`❌ Payload ${i + 1}: Arrow IPC data is empty`);
-                    passed = false;
-                }
-            }
-            
-            console.log(`   Size: ${payload.size} bytes\n`);
-        }
-        
-        // Test with chat-like payload (text + image + audio)
-        console.log('=== Chat-like Payload Test ===');
-        const chatData = [
-            ['text', 'Hello!', 'text'],
-            ['image', Buffer.from([0xFF, 0xD8, 0xFF, 0xE0]), 'image'],
-            ['audio', Buffer.from([0x46, 0x4C, 0x41, 0x43]), 'audio']
-        ];
-        
-        const [chatEnv, _] = await NATSBridge.smartsend(
-            TEST_SUBJECT,
-            chatData,
-            {
-                broker_url: TEST_BROKER_URL,
-                fileserver_url: TEST_FILESERVER_URL,
-                correlation_id: 'chat-' + correlationId,
-                is_publish: false
-            }
-        );
-        
-        if (chatEnv.payloads.length === 3) {
-            console.log('✅ Chat-like payloads handled correctly');
-        } else {
-            console.log('❌ Chat-like payloads handling failed');
-            passed = false;
-        }
-        
-        // Final result
-        console.log('\n=== Test Result ===');
-        if (passed) {
-            console.log('✅ ALL TESTS PASSED');
-            process.exit(0);
-        } else {
-            console.log('❌ SOME TESTS FAILED');
-            process.exit(1);
-        }
-        
     } catch (error) {
-        console.error('❌ Test failed with error:', error.message);
+        console.error('\n❌ Test failed with error:', error.message);
         console.error(error.stack);
         process.exit(1);
     }

test/test_js_table_receiver.js

@@ -1,172 +0,0 @@
-/**
- * JavaScript Table Receiver Test
- * Tests the smartreceive function with table (Arrow IPC) payloads
- */
-
-const NATSBridge = require('../src/natbridge.js');
-
-const TEST_BROKER_URL = process.env.NATS_URL || 'nats://localhost:4222';
-const TEST_FILESERVER_URL = process.env.FILESERVER_URL || 'http://localhost:8080';
-
-async function runTest() {
-    console.log('=== JavaScript Table Receiver Test ===\n');
-    
-    // Create a mock NATS message with table payload
-    const tableData = [
-        { id: 1, name: 'Alice', age: 30, active: true },
-        { id: 2, name: 'Bob', age: 25, active: false },
-        { id: 3, name: 'Charlie', age: 35, active: true }
-    ];
-    
-    // Convert to Arrow IPC format
-    const arrow = require('apache-arrow');
-    const fields = [
-        new arrow.Field('id', arrow.Int64, true),
-        new arrow.Field('name', arrow.Utf8, true),
-        new arrow.Field('age', arrow.Int64, true),
-        new arrow.Field('active', arrow.Boolean, true)
-    ];
-    const schema = new arrow.Schema(fields);
-    const batches = [];
-    for (const row of tableData) {
-        const batch = arrow.recordBatch.fromObjects([row], schema);
-        batches.push(batch);
-    }
-    const buffers = arrow.ipc.recordBatchesToMessage(batches, schema).buffers;
-    const combined = new Uint8Array(buffers.reduce((acc, b) => acc + b.byteLength, 0));
-    let offset = 0;
-    for (const buf of buffers) {
-        combined.set(new Uint8Array(buf), offset);
-        offset += buf.byteLength;
-    }
-    const arrowBuffer = Buffer.from(combined);
-    
-    const testData = {
-        correlation_id: 'js-table-receiver-' + Date.now(),
-        msg_id: 'msg-' + Date.now(),
-        timestamp: new Date().toISOString(),
-        send_to: '/test/table',
-        msg_purpose: 'test',
-        sender_name: 'js-table-test',
-        sender_id: 'sender-' + Date.now(),
-        receiver_name: 'js-receiver',
-        receiver_id: 'receiver-' + Date.now(),
-        reply_to: '',
-        reply_to_msg_id: '',
-        broker_url: TEST_BROKER_URL,
-        metadata: {},
-        payloads: [
-            {
-                id: 'payload-1',
-                dataname: 'users_table',
-                payload_type: 'table',
-                transport: 'direct',
-                encoding: 'base64',
-                size: arrowBuffer.length,
-                data: arrowBuffer.toString('base64'),
-                metadata: { payload_bytes: arrowBuffer.length }
-            }
-        ]
-    };
-    
-    const mockMsg = {
-        payload: JSON.stringify(testData)
-    };
-    
-    console.log('Mock Message Created:');
-    console.log(`  Correlation ID: ${testData.correlation_id}`);
-    console.log(`  Payloads: ${testData.payloads.length}`);
-    console.log(`  Payload type: ${testData.payloads[0].payload_type}`);
-    console.log(`  Transport: ${testData.payloads[0].transport}\n`);
-    
-    try {
-        // Receive and process the message
-        console.log('Receiving and processing message...');
-        const env = await NATSBridge.smartreceive(
-            mockMsg,
-            {
-                max_retries: 3,
-                base_delay: 100,
-                max_delay: 1000
-            }
-        );
-        
-        console.log('\n=== Received Envelope ===');
-        console.log(`Correlation ID: ${env.correlation_id}`);
-        console.log(`Message ID: ${env.msg_id}`);
-        console.log(`Timestamp: ${env.timestamp}`);
-        console.log(`Subject: ${env.send_to}`);
-        console.log(`Payloads: ${env.payloads.length}\n`);
-        
-        // Validate received data
-        console.log('=== Validation ===');
-        let passed = true;
-        
-        if (!env.correlation_id) {
-            console.log('❌ correlation_id is missing');
-            passed = false;
-        } else {
-            console.log('✅ correlation_id present');
-        }
-        
-        if (env.payloads.length !== 1) {
-            console.log(`❌ Expected 1 payload, got ${env.payloads.length}`);
-            passed = false;
-        } else {
-            console.log('✅ Correct number of payloads');
-        }
-        
-        const payload = env.payloads[0];
-        if (payload[0] !== 'users_table') {
-            console.log(`❌ Expected dataname 'users_table', got '${payload[0]}'`);
-            passed = false;
-        } else {
-            console.log('✅ Correct dataname');
-        }
-        
-        if (payload[2] !== 'table') {
-            console.log(`❌ Expected type 'table', got '${payload[2]}'`);
-            passed = false;
-        } else {
-            console.log('✅ Correct type');
-        }
-        
-        // Verify table data is a Buffer (Arrow IPC format)
-        if (payload[1] instanceof Buffer || payload[1] instanceof Uint8Array) {
-            console.log('✅ Table data is Arrow IPC buffer');
-            console.log(`   Buffer size: ${payload[1].length} bytes`);
-        } else {
-            console.log(`❌ Expected Buffer/Uint8Array, got ${typeof payload[1]}`);
-            passed = false;
-        }
-        
-        // Test round-trip with Arrow deserialization
-        console.log('\n=== Arrow Deserialization Test ===');
-        try {
-            const table = arrow.tableFromRawBytes(payload[1]);
-            console.log(`✅ Arrow table deserialized successfully`);
-            console.log(`   Schema: ${table.schema.fields.map(f => f.name).join(', ')}`);
-            console.log(`   Num rows: ${table.numRows}`);
-        } catch (e) {
-            console.log('❌ Arrow deserialization failed:', e.message);
-            passed = false;
-        }
-        
-        // Final result
-        console.log('\n=== Test Result ===');
-        if (passed) {
-            console.log('✅ ALL TESTS PASSED');
-            process.exit(0);
-        } else {
-            console.log('❌ SOME TESTS FAILED');
-            process.exit(1);
-        }
-        
-    } catch (error) {
-        console.error('❌ Test failed with error:', error.message);
-        console.error(error.stack);
-        process.exit(1);
-    }
-}
-
-runTest();

test/test_js_table_sender.js

@@ -1,179 +0,0 @@
-/**
- * JavaScript Table Sender Test
- * Tests the smartsend function with table (Arrow IPC) payloads
- */
-
-const NATSBridge = require('../src/natbridge.js');
-
-const TEST_SUBJECT = '/test/table';
-const TEST_BROKER_URL = process.env.NATS_URL || 'nats://localhost:4222';
-const TEST_FILESERVER_URL = process.env.FILESERVER_URL || 'http://localhost:8080';
-
-async function runTest() {
-    console.log('=== JavaScript Table Sender Test ===\n');
-    
-    const correlationId = NATSBridge.uuidv4();
-    console.log(`Correlation ID: ${correlationId}`);
-    console.log(`Subject: ${TEST_SUBJECT}`);
-    console.log(`Broker URL: ${TEST_BROKER_URL}\n`);
-    
-    // Test data - table data as array of objects
-    const tableData = [
-        { id: 1, name: 'Alice', age: 30, active: true },
-        { id: 2, name: 'Bob', age: 25, active: false },
-        { id: 3, name: 'Charlie', age: 35, active: true },
-        { id: 4, name: 'Diana', age: 28, active: true },
-        { id: 5, name: 'Eve', age: 32, active: false }
-    ];
-    
-    const testData = [
-        ['users_table', tableData, 'table']
-    ];
-    
-    try {
-        // Send the message
-        console.log('Sending table payload...');
-        const [env, envJsonStr] = await NATSBridge.smartsend(
-            TEST_SUBJECT,
-            testData,
-            {
-                broker_url: TEST_BROKER_URL,
-                fileserver_url: TEST_FILESERVER_URL,
-                correlation_id: correlationId,
-                msg_purpose: 'test',
-                sender_name: 'js-table-test',
-                is_publish: false
-            }
-        );
-        
-        console.log('\n=== Envelope Created ===');
-        console.log(`Correlation ID: ${env.correlation_id}`);
-        console.log(`Message ID: ${env.msg_id}`);
-        console.log(`Timestamp: ${env.timestamp}`);
-        console.log(`Subject: ${env.send_to}`);
-        console.log(`Purpose: ${env.msg_purpose}`);
-        console.log(`Sender: ${env.sender_name}`);
-        console.log(`Payloads: ${env.payloads.length}\n`);
-        
-        // Validate envelope structure
-        console.log('=== Validation ===');
-        let passed = true;
-        
-        if (env.payloads.length !== 1) {
-            console.log(`❌ Expected 1 payload, got ${env.payloads.length}`);
-            passed = false;
-        } else {
-            console.log('✅ Correct number of payloads');
-        }
-        
-        const payload = env.payloads[0];
-        if (payload.dataname !== 'users_table') {
-            console.log(`❌ Expected dataname 'users_table', got '${payload.dataname}'`);
-            passed = false;
-        } else {
-            console.log('✅ Correct dataname');
-        }
-        
-        if (payload.payload_type !== 'table') {
-            console.log(`❌ Expected payload_type 'table', got '${payload.payload_type}'`);
-            passed = false;
-        } else {
-            console.log('✅ Correct payload_type');
-        }
-        
-        if (payload.transport !== 'direct') {
-            console.log(`❌ Expected transport 'direct', got '${payload.transport}'`);
-            passed = false;
-        } else {
-            console.log('✅ Correct transport');
-        }
-        
-        if (payload.encoding !== 'base64') {
-            console.log(`❌ Expected encoding 'base64', got '${payload.encoding}'`);
-            passed = false;
-        } else {
-            console.log('✅ Correct encoding');
-        }
-        
-        // Verify Arrow IPC data can be decoded
-        console.log('\n=== Arrow IPC Verification ===');
-        const decodedData = Buffer.from(payload.data, 'base64');
-        console.log(`Arrow IPC buffer size: ${decodedData.length} bytes`);
-        
-        if (decodedData.length > 0) {
-            console.log('✅ Arrow IPC data present');
-        } else {
-            console.log('❌ Arrow IPC data is empty');
-            passed = false;
-        }
-        
-        // Test with larger table
-        console.log('\n=== Larger Table Test ===');
-        const largeTableData = [];
-        for (let i = 1; i <= 100; i++) {
-            largeTableData.push({
-                id: i,
-                name: `User${i}`,
-                age: Math.floor(Math.random() * 100),
-                active: Math.random() > 0.5,
-                score: Math.random() * 100
-            });
-        }
-        
-        const largeTestData = [
-            ['large_table', largeTableData, 'table']
-        ];
-        
-        const [largeEnv, _] = await NATSBridge.smartsend(
-            TEST_SUBJECT,
-            largeTestData,
-            {
-                broker_url: TEST_BROKER_URL,
-                fileserver_url: TEST_FILESERVER_URL,
-                correlation_id: 'large-' + correlationId,
-                is_publish: false
-            }
-        );
-        
-        if (largeEnv.payloads.length === 1) {
-            console.log('✅ Large table handled correctly');
-            console.log(`   Size: ${largeEnv.payloads[0].size} bytes`);
-        } else {
-            console.log('❌ Large table handling failed');
-            passed = false;
-        }
-        
-        // Test JSON string output
-        console.log('\n=== JSON String Output Test ===');
-        try {
-            const parsed = JSON.parse(envJsonStr);
-            if (parsed.correlation_id === env.correlation_id && 
-                parsed.payloads.length === env.payloads.length) {
-                console.log('✅ JSON string is valid and matches envelope');
-            } else {
-                console.log('❌ JSON string does not match envelope');
-                passed = false;
-            }
-        } catch (e) {
-            console.log('❌ JSON string is invalid:', e.message);
-            passed = false;
-        }
-        
-        // Final result
-        console.log('\n=== Test Result ===');
-        if (passed) {
-            console.log('✅ ALL TESTS PASSED');
-            process.exit(0);
-        } else {
-            console.log('❌ SOME TESTS FAILED');
-            process.exit(1);
-        }
-        
-    } catch (error) {
-        console.error('❌ Test failed with error:', error.message);
-        console.error(error.stack);
-        process.exit(1);
-    }
-}
-
-runTest();

test/test_js_text_receiver.js

@@ -1,206 +0,0 @@
-/**
- * JavaScript Text Receiver Test
- * Tests the smartreceive function with text payloads
- */
-
-const NATSBridge = require('../src/natbridge.js');
-
-const TEST_BROKER_URL = process.env.NATS_URL || 'nats://localhost:4222';
-const TEST_FILESERVER_URL = process.env.FILESERVER_URL || 'http://localhost:8080';
-
-async function runTest() {
-    console.log('=== JavaScript Text Receiver Test ===\n');
-    
-    // Create a mock NATS message with text payload
-    const testData = {
-        correlation_id: 'test-receiver-' + Date.now(),
-        msg_id: 'msg-' + Date.now(),
-        timestamp: new Date().toISOString(),
-        send_to: '/test/text',
-        msg_purpose: 'test',
-        sender_name: 'js-text-test',
-        sender_id: 'sender-' + Date.now(),
-        receiver_name: 'js-receiver',
-        receiver_id: 'receiver-' + Date.now(),
-        reply_to: '',
-        reply_to_msg_id: '',
-        broker_url: TEST_BROKER_URL,
-        metadata: {},
-        payloads: [
-            {
-                id: 'payload-' + Date.now(),
-                dataname: 'message',
-                payload_type: 'text',
-                transport: 'direct',
-                encoding: 'base64',
-                size: 38,
-                data: Buffer.from('Hello, NATSBridge! This is a test message.').toString('base64'),
-                metadata: { payload_bytes: 38 }
-            }
-        ]
-    };
-    
-    const mockMsg = {
-        payload: JSON.stringify(testData)
-    };
-    
-    console.log('Mock Message Created:');
-    console.log(`  Correlation ID: ${testData.correlation_id}`);
-    console.log(`  Payloads: ${testData.payloads.length}`);
-    console.log(`  Payload dataname: ${testData.payloads[0].dataname}`);
-    console.log(`  Payload type: ${testData.payloads[0].payload_type}`);
-    console.log(`  Transport: ${testData.payloads[0].transport}\n`);
-    
-    try {
-        // Receive and process the message
-        console.log('Receiving and processing message...');
-        const env = await NATSBridge.smartreceive(
-            mockMsg,
-            {
-                max_retries: 3,
-                base_delay: 100,
-                max_delay: 1000
-            }
-        );
-        
-        console.log('\n=== Received Envelope ===');
-        console.log(`Correlation ID: ${env.correlation_id}`);
-        console.log(`Message ID: ${env.msg_id}`);
-        console.log(`Timestamp: ${env.timestamp}`);
-        console.log(`Subject: ${env.send_to}`);
-        console.log(`Payloads: ${env.payloads.length}\n`);
-        
-        // Validate received data
-        console.log('=== Validation ===');
-        let passed = true;
-        
-        if (!env.correlation_id) {
-            console.log('❌ correlation_id is missing');
-            passed = false;
-        } else {
-            console.log('✅ correlation_id present');
-        }
-        
-        if (env.payloads.length !== 1) {
-            console.log(`❌ Expected 1 payload, got ${env.payloads.length}`);
-            passed = false;
-        } else {
-            console.log('✅ Correct number of payloads');
-        }
-        
-        const payload = env.payloads[0];
-        if (payload[0] !== 'message') {
-            console.log(`❌ Expected dataname 'message', got '${payload[0]}'`);
-            passed = false;
-        } else {
-            console.log('✅ Correct dataname');
-        }
-        
-        if (payload[2] !== 'text') {
-            console.log(`❌ Expected type 'text', got '${payload[2]}'`);
-            passed = false;
-        } else {
-            console.log('✅ Correct type');
-        }
-        
-        if (payload[1] !== 'Hello, NATSBridge! This is a test message.') {
-            console.log(`❌ Data mismatch`);
-            console.log(`   Expected: Hello, NATSBridge! This is a test message.`);
-            console.log(`   Got: ${payload[1]}`);
-            passed = false;
-        } else {
-            console.log('✅ Data correctly deserialized');
-        }
-        
-        // Test with multiple text payloads
-        console.log('\n=== Multiple Text Payloads Test ===');
-        const multiTestData = {
-            correlation_id: 'multi-receiver-' + Date.now(),
-            msg_id: 'msg-' + Date.now(),
-            timestamp: new Date().toISOString(),
-            send_to: '/test/text',
-            msg_purpose: 'test',
-            sender_name: 'js-text-test',
-            sender_id: 'sender-' + Date.now(),
-            receiver_name: 'js-receiver',
-            receiver_id: 'receiver-' + Date.now(),
-            reply_to: '',
-            reply_to_msg_id: '',
-            broker_url: TEST_BROKER_URL,
-            metadata: {},
-            payloads: [
-                {
-                    id: 'payload-1',
-                    dataname: 'msg1',
-                    payload_type: 'text',
-                    transport: 'direct',
-                    encoding: 'base64',
-                    size: 16,
-                    data: Buffer.from('First message').toString('base64'),
-                    metadata: { payload_bytes: 16 }
-                },
-                {
-                    id: 'payload-2',
-                    dataname: 'msg2',
-                    payload_type: 'text',
-                    transport: 'direct',
-                    encoding: 'base64',
-                    size: 16,
-                    data: Buffer.from('Second message').toString('base64'),
-                    metadata: { payload_bytes: 16 }
-                },
-                {
-                    id: 'payload-3',
-                    dataname: 'msg3',
-                    payload_type: 'text',
-                    transport: 'direct',
-                    encoding: 'base64',
-                    size: 16,
-                    data: Buffer.from('Third message').toString('base64'),
-                    metadata: { payload_bytes: 16 }
-                }
-            ]
-        };
-        
-        const mockMultiMsg = {
-            payload: JSON.stringify(multiTestData)
-        };
-        
-        const multiEnv = await NATSBridge.smartreceive(mockMultiMsg);
-        
-        if (multiEnv.payloads.length === 3) {
-            console.log('✅ Multiple payloads handled correctly');
-            
-            // Verify each payload
-            const expectedMessages = ['First message', 'Second message', 'Third message'];
-            for (let i = 0; i < 3; i++) {
-                if (multiEnv.payloads[i][1] === expectedMessages[i]) {
-                    console.log(`✅ Payload ${i + 1} correctly deserialized`);
-                } else {
-                    console.log(`❌ Payload ${i + 1} mismatch`);
-                    passed = false;
-                }
-            }
-        } else {
-            console.log(`❌ Expected 3 payloads, got ${multiEnv.payloads.length}`);
-            passed = false;
-        }
-        
-        // Final result
-        console.log('\n=== Test Result ===');
-        if (passed) {
-            console.log('✅ ALL TESTS PASSED');
-            process.exit(0);
-        } else {
-            console.log('❌ SOME TESTS FAILED');
-            process.exit(1);
-        }
-        
-    } catch (error) {
-        console.error('❌ Test failed with error:', error.message);
-        console.error(error.stack);
-        process.exit(1);
-    }
-}
-
-runTest();

test/test_js_text_sender.js

@@ -1,169 +0,0 @@
-/**
- * JavaScript Text Sender Test
- * Tests the smartsend function with text payloads
- */
-
-const NATSBridge = require('../src/natbridge.js');
-
-const TEST_SUBJECT = '/test/text';
-const TEST_BROKER_URL = process.env.NATS_URL || 'nats://localhost:4222';
-const TEST_FILESERVER_URL = process.env.FILESERVER_URL || 'http://localhost:8080';
-
-async function runTest() {
-    console.log('=== JavaScript Text Sender Test ===\n');
-    
-    const correlationId = NATSBridge.uuidv4();
-    console.log(`Correlation ID: ${correlationId}`);
-    console.log(`Subject: ${TEST_SUBJECT}`);
-    console.log(`Broker URL: ${TEST_BROKER_URL}\n`);
-    
-    // Test data
-    const textData = 'Hello, NATSBridge! This is a test message.';
-    const testData = [
-        ['message', textData, 'text']
-    ];
-    
-    try {
-        // Send the message
-        console.log('Sending text payload...');
-        const [env, envJsonStr] = await NATSBridge.smartsend(
-            TEST_SUBJECT,
-            testData,
-            {
-                broker_url: TEST_BROKER_URL,
-                fileserver_url: TEST_FILESERVER_URL,
-                correlation_id: correlationId,
-                msg_purpose: 'test',
-                sender_name: 'js-text-test',
-                is_publish: false  // Don't actually publish for this test
-            }
-        );
-        
-        console.log('\n=== Envelope Created ===');
-        console.log(`Correlation ID: ${env.correlation_id}`);
-        console.log(`Message ID: ${env.msg_id}`);
-        console.log(`Timestamp: ${env.timestamp}`);
-        console.log(`Subject: ${env.send_to}`);
-        console.log(`Purpose: ${env.msg_purpose}`);
-        console.log(`Sender: ${env.sender_name}`);
-        console.log(`Payloads: ${env.payloads.length}\n`);
-        
-        // Validate envelope structure
-        console.log('=== Validation ===');
-        let passed = true;
-        
-        if (!env.correlation_id) {
-            console.log('❌ correlation_id is missing');
-            passed = false;
-        } else {
-            console.log('✅ correlation_id present');
-        }
-        
-        if (!env.msg_id) {
-            console.log('❌ msg_id is missing');
-            passed = false;
-        } else {
-            console.log('✅ msg_id present');
-        }
-        
-        if (!env.timestamp) {
-            console.log('❌ timestamp is missing');
-            passed = false;
-        } else {
-            console.log('✅ timestamp present');
-        }
-        
-        if (env.payloads.length !== 1) {
-            console.log(`❌ Expected 1 payload, got ${env.payloads.length}`);
-            passed = false;
-        } else {
-            console.log('✅ Correct number of payloads');
-        }
-        
-        const payload = env.payloads[0];
-        if (payload.dataname !== 'message') {
-            console.log(`❌ Expected dataname 'message', got '${payload.dataname}'`);
-            passed = false;
-        } else {
-            console.log('✅ Correct dataname');
-        }
-        
-        if (payload.payload_type !== 'text') {
-            console.log(`❌ Expected payload_type 'text', got '${payload.payload_type}'`);
-            passed = false;
-        } else {
-            console.log('✅ Correct payload_type');
-        }
-        
-        if (payload.transport !== 'direct') {
-            console.log(`❌ Expected transport 'direct', got '${payload.transport}'`);
-            passed = false;
-        } else {
-            console.log('✅ Correct transport');
-        }
-        
-        if (payload.encoding !== 'base64') {
-            console.log(`❌ Expected encoding 'base64', got '${payload.encoding}'`);
-            passed = false;
-        } else {
-            console.log('✅ Correct encoding');
-        }
-        
-        // Decode and verify the data
-        const decodedData = Buffer.from(payload.data, 'base64').toString('utf8');
-        if (decodedData !== textData) {
-            console.log(`❌ Decoded data mismatch`);
-            console.log(`   Expected: ${textData}`);
-            console.log(`   Got: ${decodedData}`);
-            passed = false;
-        } else {
-            console.log('✅ Data integrity verified');
-        }
-        
-        console.log(`\nPayload size: ${payload.size} bytes`);
-        console.log(`Base64 data length: ${payload.data.length} chars`);
-        
-        // Test with multiple text payloads
-        console.log('\n=== Multiple Text Payloads Test ===');
-        const multiTestData = [
-            ['msg1', 'First message', 'text'],
-            ['msg2', 'Second message', 'text'],
-            ['msg3', 'Third message', 'text']
-        ];
-        
-        const [multiEnv, multiEnvJsonStr] = await NATSBridge.smartsend(
-            TEST_SUBJECT,
-            multiTestData,
-            {
-                broker_url: TEST_BROKER_URL,
-                fileserver_url: TEST_FILESERVER_URL,
-                correlation_id: 'multi-test-' + correlationId,
-                is_publish: false
-            }
-        );
-        
-        if (multiEnv.payloads.length === 3) {
-            console.log('✅ Multiple payloads handled correctly');
-        } else {
-            console.log(`❌ Expected 3 payloads, got ${multiEnv.payloads.length}`);
-            passed = false;
-        }
-        
-        // Final result
-        console.log('\n=== Test Result ===');
-        if (passed) {
-            console.log('✅ ALL TESTS PASSED');
-            process.exit(0);
-        } else {
-            console.log('❌ SOME TESTS FAILED');
-            process.exit(1);
-        }
-        
-    } catch (error) {
-        console.error('❌ Test failed with error:', error.message);
-        console.error(error.stack);
-        process.exit(1);
-    }
-}
-
-runTest();

test/test_julia_dict_receiver.jl

@@ -1,82 +0,0 @@
-#!/usr/bin/env julia
-# Test script for Dictionary transport testing
-# Tests receiving 1 large and 1 small Dictionaries via direct and link transport
-# Uses NATSBridge.jl smartreceive with "dictionary" type
-
-using NATS, JSON, UUIDs, Dates, PrettyPrinting, DataFrames, Arrow, HTTP
-
-# Include the bridge module
-include("../src/NATSBridge.jl")
-using .NATSBridge
-
-# Configuration
-const SUBJECT = "/NATSBridge_dict_test"
-const NATS_URL = "nats.yiem.cc"
-const FILESERVER_URL = "http://192.168.88.104:8080"
-
-
-# ------------------------------------------------------------------------------------------------ #
-#                                        test dictionary transfer                                  #
-# ------------------------------------------------------------------------------------------------ #
-
-
-# Helper: Log with correlation ID
-function log_trace(message)
-    timestamp = Dates.now()
-    println("[$timestamp] $message")
-end
-
-
-# Receiver: Listen for messages and verify Dictionary handling
-function test_dict_receive()
-    conn = NATS.connect(NATS_URL)
-    NATS.subscribe(conn, SUBJECT) do msg
-        log_trace("Received message on $(msg.subject)")
-        
-        # Use NATSBridge.smartreceive to handle the data
-        # API: smartreceive(msg, download_handler; max_retries, base_delay, max_delay)
-        result = NATSBridge.smartreceive(
-            msg;
-            max_retries = 5,
-            base_delay = 100,
-            max_delay = 5000
-        )
-        
-        # Result is an envelope dictionary with payloads field containing list of (dataname, data, data_type) tuples
-        for (dataname, data, data_type) in result["payloads"]
-            if isa(data, JSON.Object{String, Any})
-                log_trace("Received Dictionary '$dataname' of type $data_type")
-                
-                # Display dictionary contents
-                println("  Contents:")
-                for (key, value) in data
-                    println("    $key => $value")
-                end
-                
-                # Save to JSON file
-                output_path = "./received_$dataname.json"
-                json_str = JSON.json(data, 2)
-                write(output_path, json_str)
-                log_trace("Saved Dictionary to $output_path")
-            else
-                log_trace("Received unexpected data type for '$dataname': $(typeof(data))")
-            end
-        end
-    end
-    
-    # Keep listening for 10 seconds
-    sleep(120)  
-    NATS.drain(conn)
-end
-
-
-# Run the test
-println("Starting Dictionary transport test...")
-println("Note: This receiver will wait for messages from the sender.")
-println("Run test_julia_to_julia_dict_sender.jl first to send test data.")
-
-# Run receiver
-println("testing smartreceive")
-test_dict_receive()
-
-println("Test completed.")

test/test_julia_dict_sender.jl

@@ -1,137 +0,0 @@
-#!/usr/bin/env julia
-# Test script for Dictionary transport testing
-# Tests sending 1 large and 1 small Dictionaries via direct and link transport
-# Uses NATSBridge.jl smartsend with "dictionary" type
-
-using NATS, JSON, UUIDs, Dates, PrettyPrinting, DataFrames, Arrow, HTTP
-
-# Include the bridge module
-include("../src/NATSBridge.jl")
-using .NATSBridge
-
-# Configuration
-const SUBJECT = "/NATSBridge_dict_test"
-const NATS_URL = "nats.yiem.cc"
-const FILESERVER_URL = "http://192.168.88.104:8080"
-
-# Create correlation ID for tracing
-correlation_id = string(uuid4())
-
-
-# ------------------------------------------------------------------------------------------------ #
-#                                        test dictionary transfer                                  #
-# ------------------------------------------------------------------------------------------------ #
-
-
-# Helper: Log with correlation ID
-function log_trace(message)
-    timestamp = Dates.now()
-    println("[$timestamp] [Correlation: $correlation_id] $message")
-end
-
-
-# File upload handler for plik server
-function plik_upload_handler(fileserver_url::String, dataname::String, data::Vector{UInt8})::Dict{String, Any}
-    # Get upload ID
-    url_getUploadID = "$fileserver_url/upload"
-    headers = ["Content-Type" => "application/json"]
-    body = """{ "OneShot" : true }"""
-    httpResponse = HTTP.request("POST", url_getUploadID, headers, body; body_is_form=false)
-    responseJson = JSON.parse(String(httpResponse.body))
-    uploadid = responseJson["id"]
-    uploadtoken = responseJson["uploadToken"]
-    
-    # Upload file
-    file_multipart = HTTP.Multipart(dataname, IOBuffer(data), "application/octet-stream")
-    url_upload = "$fileserver_url/file/$uploadid"
-    headers = ["X-UploadToken" => uploadtoken]
-    
-    form = HTTP.Form(Dict("file" => file_multipart))
-    httpResponse = HTTP.post(url_upload, headers, form)
-    responseJson = JSON.parse(String(httpResponse.body))
-    
-    fileid = responseJson["id"]
-    url = "$fileserver_url/file/$uploadid/$fileid/$dataname"
-    
-    return Dict("status" => httpResponse.status, "uploadid" => uploadid, "fileid" => fileid, "url" => url)
-end
-
-
-# Sender: Send Dictionaries via smartsend
-function test_dict_send()
-    # Create a small Dictionary (will use direct transport)
-    small_dict = Dict(
-        "name" => "Alice",
-        "age" => 30,
-        "scores" => [95, 88, 92],
-        "metadata" => Dict(
-            "height" => 155,
-            "weight" => 55
-        )
-    )
-    
-    # Create a large Dictionary (will use link transport if > 1MB)
-    # Generate a larger dataset (~2MB to ensure link transport)
-    large_dict = Dict(
-        "ids" => collect(1:50000),
-        "names" => ["User_$i" for i in 1:50000],
-        "scores" => rand(1:100, 50000),
-        "categories" => ["Category_$(rand(1:10))" for i in 1:50000],
-        "metadata" => Dict(
-            "source" => "test_generator",
-            "timestamp" => string(Dates.now())
-        )
-    )
-    
-    # Test data 1: small Dictionary
-    data1 = ("small_dict", small_dict, "dictionary")
-    
-    # Test data 2: large Dictionary
-    data2 = ("large_dict", large_dict, "dictionary")
-    
-    # Use smartsend with dictionary type
-    # For small Dictionary: will use direct transport (JSON encoded)
-    # For large Dictionary: will use link transport (uploaded to fileserver)
-    env, env_json_str = NATSBridge.smartsend(
-        SUBJECT,
-        [data1, data2];  # List of (dataname, data, type) tuples
-        broker_url = NATS_URL,
-        fileserver_url = FILESERVER_URL,
-        fileserver_upload_handler = plik_upload_handler,
-        size_threshold = 1_000_000,  # 1MB threshold
-        correlation_id = correlation_id,
-        msg_purpose = "chat",
-        sender_name = "dict_sender",
-        receiver_name = "",
-        receiver_id = "",
-        reply_to = "",
-        reply_to_msg_id = "",
-        is_publish = true  # Publish the message to NATS
-    )
-    
-    log_trace("Sent message with $(length(env.payloads)) payloads")
-    
-    # Log transport type for each payload
-    for (i, payload) in enumerate(env.payloads)
-        log_trace("Payload $i ('$payload.dataname'):")
-        log_trace("  Transport: $(payload.transport)")
-        log_trace("  Type: $(payload.payload_type)")
-        log_trace("  Size: $(payload.size) bytes")
-        log_trace("  Encoding: $(payload.encoding)")
-        
-        if payload.transport == "link"
-            log_trace("  URL: $(payload.data)")
-        end
-    end
-end
-
-
-# Run the test
-println("Starting Dictionary transport test...")
-println("Correlation ID: $correlation_id")
-
-# Run sender
-println("start smartsend for dictionaries")
-test_dict_send()
-
-println("Test completed.")

test/test_julia_file_receiver.jl

@@ -1,84 +0,0 @@
-#!/usr/bin/env julia
-# Test script for large payload testing using binary transport
-# Tests sending a large file (> 1MB) via smartsend with binary type
-# Updated to match NATSBridge.jl API
-
-using NATS, JSON, UUIDs, Dates, PrettyPrinting, DataFrames, Arrow, HTTP
-
-
-# workdir = 
-
-# Include the bridge module
-include("../src/NATSBridge.jl")
-using .NATSBridge
-
-# Configuration
-const SUBJECT = "/NATSBridge_test"
-const NATS_URL = "nats.yiem.cc"
-const FILESERVER_URL = "http://192.168.88.104:8080"
-
-
-
-# ------------------------------------------------------------------------------------------------ #
-#                                        test file transfer                                        #
-# ------------------------------------------------------------------------------------------------ #
-
-# Helper: Log with correlation ID
-function log_trace(message)
-    timestamp = Dates.now()
-    println("[$timestamp] $message")
-end
-
-# Receiver: Listen for messages and verify large payload handling
-function test_large_binary_receive()
-    conn = NATS.connect(NATS_URL)
-    NATS.subscribe(conn, SUBJECT) do msg
-        log_trace("Received message on $(msg.subject)")
-        
-        # Use NATSBridge.smartreceive to handle the data
-        # API: smartreceive(msg, download_handler; max_retries, base_delay, max_delay)
-        result = NATSBridge.smartreceive(
-            msg;
-            max_retries = 5,
-            base_delay = 100,
-            max_delay = 5000
-        )
-        
-        # Result is an envelope dictionary with payloads field containing list of (dataname, data, data_type) tuples
-        for (dataname, data, data_type) in result["payloads"]
-            # Check transport type from the envelope
-            # For link transport, data is the URL string
-            # For direct transport, data is the actual payload bytes
-            
-            if isa(data, Vector{UInt8})
-                file_size = length(data)
-                log_trace("Received $(file_size) bytes of binary data for '$dataname' of type $data_type")
-                
-                # Save received data to a test file
-                output_path = "./new_$dataname"
-                write(output_path, data)
-                log_trace("Saved received data to $output_path")
-            else
-                log_trace("Received $(file_size) bytes of binary data for '$dataname' of type $data_type")
-            end
-        end
-    end
-    
-    # Keep listening for 10 seconds
-    sleep(120)  
-    NATS.drain(conn)
-end
-
-
-# Run the test
-println("Starting large binary payload test...")
-
-# # Run sender first
-# println("start smartsend")
-# test_large_binary_send()
-
-# Run receiver
-println("testing smartreceive")
-test_large_binary_receive()
-
-println("Test completed.")

test/test_julia_file_sender.jl

@@ -1,123 +0,0 @@
-#!/usr/bin/env julia
-# Test script for large payload testing using binary transport
-# Tests sending a large file (> 1MB) via smartsend with binary type
-# Updated to match NATSBridge.jl API
-
-using NATS, JSON, UUIDs, Dates, PrettyPrinting, DataFrames, Arrow, HTTP
-
-
-# workdir = 
-
-# Include the bridge module
-include("../src/NATSBridge.jl")
-using .NATSBridge
-
-# Configuration
-const SUBJECT = "/NATSBridge_test"
-const NATS_URL = "nats.yiem.cc"
-const FILESERVER_URL = "http://192.168.88.104:8080"
-
-# Create correlation ID for tracing
-correlation_id = string(uuid4())
-
-
-# ------------------------------------------------------------------------------------------------ #
-#                                        test file transfer                                        #
-# ------------------------------------------------------------------------------------------------ #
-
-
-# Helper: Log with correlation ID
-function log_trace(message)
-    timestamp = Dates.now()
-    println("[$timestamp] [Correlation: $correlation_id] $message")
-end
-
-# File upload handler for plik server
-function plik_upload_handler(fileserver_url::String, dataname::String, data::Vector{UInt8})::Dict{String, Any}
-    # Get upload ID
-    url_getUploadID = "$fileserver_url/upload"
-    headers = ["Content-Type" => "application/json"]
-    body = """{ "OneShot" : true }"""
-    httpResponse = HTTP.request("POST", url_getUploadID, headers, body; body_is_form=false)
-    responseJson = JSON.parse(String(httpResponse.body))
-    uploadid = responseJson["id"]
-    uploadtoken = responseJson["uploadToken"]
-    
-    # Upload file
-    file_multipart = HTTP.Multipart(dataname, IOBuffer(data), "application/octet-stream")
-    url_upload = "$fileserver_url/file/$uploadid"
-    headers = ["X-UploadToken" => uploadtoken]
-    
-    form = HTTP.Form(Dict("file" => file_multipart))
-    httpResponse = HTTP.post(url_upload, headers, form)
-    responseJson = JSON.parse(String(httpResponse.body))
-    
-    fileid = responseJson["id"]
-    url = "$fileserver_url/file/$uploadid/$fileid/$dataname"
-    
-    return Dict("status" => httpResponse.status, "uploadid" => uploadid, "fileid" => fileid, "url" => url)
-end
-
-# Sender: Send large binary file via smartsend
-function test_large_binary_send()
-    # Read the large file as binary data
-    
-    # test data 1
-    file_path1 = "./testFile_large.zip"
-    file_data1 = read(file_path1)
-    filename1 = basename(file_path1)
-    data1 = (filename1, file_data1, "binary")
-
-    # test data 2
-    file_path2 = "./testFile_small.zip"
-    file_data2 = read(file_path2)
-    filename2 = basename(file_path2)
-    data2 = (filename2, file_data2, "binary")
-    
-    
-    
-    # Use smartsend with binary type - will automatically use link transport
-    # if file size exceeds the threshold (1MB by default)
-    # API: smartsend(subject, [(dataname, data, type), ...]; keywords...)
-    env, env_json_str = NATSBridge.smartsend(
-        SUBJECT,
-        [data1, data2];  # List of (dataname, data, type) tuples
-        broker_url = NATS_URL;
-        fileserver_url = FILESERVER_URL,
-        fileserver_upload_handler = plik_upload_handler,
-        size_threshold = 1_000_000,
-        correlation_id = correlation_id,
-        msg_purpose = "chat",
-        sender_name = "sender",
-        receiver_name = "",
-        receiver_id = "",
-        reply_to = "",
-        reply_to_msg_id = "",
-        is_publish = true  # Publish the message to NATS
-    )
-    
-    log_trace("Sent message with transport: $(env.payloads[1].transport)")
-    log_trace("Envelope type: $(env.payloads[1].payload_type)")
-    
-    # Check if link transport was used
-    if env.payloads[1].transport == "link"
-        log_trace("Using link transport - file uploaded to HTTP server")
-        log_trace("URL: $(env.payloads[1].data)")
-    else
-        log_trace("Using direct transport - payload sent via NATS")
-    end
-end
-
-# Run the test
-println("Starting large binary payload test...")
-println("Correlation ID: $correlation_id")
-
-# Run sender first
-println("start smartsend")
-test_large_binary_send()
-
-# Run receiver
-# println("testing smartreceive")
-# test_large_binary_receive()
-
-println("Test completed.")

test/test_julia_mix_payloads_receiver.jl

@@ -13,7 +13,7 @@ include("../src/NATSBridge.jl")
 using .NATSBridge
 
 # Configuration
-const SUBJECT = "/NATSBridge_mix_test"
+const SUBJECT = "/natsbridge"
 const NATS_URL = "nats.yiem.cc"
 const FILESERVER_URL = "http://192.168.88.104:8080"
 
@@ -93,26 +93,41 @@ function test_mix_receive()
                     log_trace("  ERROR: Expected Dict, got $(typeof(data))")
                 end
                 
-            elseif data_type == "table"
-                # Table data - should be a DataFrame
-                data = DataFrame(data)
-                if isa(data, DataFrame)
-                    log_trace("  Type: DataFrame")
-                    log_trace("  Dimensions: $(size(data, 1)) rows x $(size(data, 2)) columns")
-                    log_trace("  Columns: $(names(data))")
+            elseif data_type == "arrowtable"
+                # Arrow table data - should be Arrow.Table
+                if isa(data, Arrow.Table)
+                    log_trace("  Type: Arrow.Table")
                     
-                    # Display first few rows
-                    log_trace("  First 5 rows:")
-                    display(data[1:min(5, size(data, 1)), :])
-                    
-                    # Save to Arrow file
+                    # Convert to DataFrame for display and save
+                    df = DataFrame(data)
+                    @show df[1:3, :]
                     output_path = "./received_$dataname.arrow"
                     io = IOBuffer()
                     Arrow.write(io, data)
                     write(output_path, take!(io))
                     log_trace("  Saved to: $output_path")
                 else
-                    log_trace("  ERROR: Expected DataFrame, got $(typeof(data))")
+                    log_trace("  ERROR: Expected Arrow.Table, got $(typeof(data))")
+                end
+                
+            elseif data_type == "jsontable"
+                # JSON table data - should be Vector{Dict} or Vector{NamedTuple}
+                @show "jsontable" typeof(data)
+                if isa(data, Vector{Any})
+                    log_trace("  Type: Vector{Dict/NamedTuple}")
+                    
+                    # Convert to DataFrame for display and save
+                    df = DataFrame(data)
+                    @show df[1:3, :]
+                    log_trace("  Converted to DataFrame: $(size(df, 1)) rows x $(size(df, 2)) columns")
+                    
+                    # Save as JSON file
+                    output_path = "./received_$dataname.json"
+                    json_str = JSON.json(data, 2)
+                    write(output_path, json_str)
+                    log_trace("  Saved to: $output_path")
+                else
+                    log_trace("  ERROR: Expected Vector{Dict/NamedTuple}, got $(typeof(data))")
                 end
                 
             elseif data_type == "image"
@@ -164,7 +179,7 @@ function test_mix_receive()
                     log_trace("  Size: $(length(data)) bytes")
                     
                     # Save to file
-                    output_path = "./received_$dataname.bin"
+                    output_path = "./received_$dataname"
                     write(output_path, data)
                     log_trace("  Saved to: $output_path")
                 else
@@ -180,7 +195,9 @@ function test_mix_receive()
         println("\n=== Verification Summary ===")
         text_count = count(x -> x[3] == "text", result["payloads"])
         dict_count = count(x -> x[3] == "dictionary", result["payloads"])
-        table_count = count(x -> x[3] == "table", result["payloads"])
+        arrowtable_count = count(x -> x[3] == "arrowtable", result["payloads"])
+        jsontable_count = count(x -> x[3] == "jsontable", result["payloads"])
+        table_count = count(x -> x[3] == "table", result["payloads"])  # backward compatibility
         image_count = count(x -> x[3] == "image", result["payloads"])
         audio_count = count(x -> x[3] == "audio", result["payloads"])
         video_count = count(x -> x[3] == "video", result["payloads"])
@@ -188,7 +205,9 @@ function test_mix_receive()
         
         log_trace("Text payloads: $text_count")
         log_trace("Dictionary payloads: $dict_count")
-        log_trace("Table payloads: $table_count")
+        log_trace("Arrow table payloads: $arrowtable_count")
+        log_trace("JSON table payloads: $jsontable_count")
+        log_trace("Table payloads (backward compat): $table_count")
         log_trace("Image payloads: $image_count")
         log_trace("Audio payloads: $audio_count")
         log_trace("Video payloads: $video_count")
@@ -199,9 +218,13 @@ function test_mix_receive()
         for (dataname, data, data_type) in result["payloads"]
             if data_type in ["image", "audio", "video", "binary"]
                 log_trace("$dataname: $(length(data)) bytes (binary)")
+            elseif data_type == "arrowtable"
+                # log_trace("$dataname: $(size(data, 1)) rows x $(size(data, 2)) columns (Arrow.Table)")
+            elseif data_type == "jsontable"
+                log_trace("$dataname: $(length(data)) rows (Vector{Dict/NamedTuple})")
             elseif data_type == "table"
                 data = DataFrame(data)
-                log_trace("$dataname: $(size(data, 1)) rows x $(size(data, 2)) columns (DataFrame)")
+                # log_trace("$dataname: $(size(data, 1)) rows x $(size(data, 2)) columns (DataFrame)")
             elseif data_type == "dictionary"
                 log_trace("$dataname: $(length(JSON.json(data))) bytes (Dict)")
             elseif data_type == "text"
@@ -211,7 +234,7 @@ function test_mix_receive()
     end
     
     # Keep listening for 2 minutes
-    sleep(120)  
+    sleep(180)  
     NATS.drain(conn)
 end
 

test/test_julia_mix_payloads_sender.jl

@@ -1,10 +1,15 @@
 #!/usr/bin/env julia
 # Test script for mixed-content message testing
-# Tests sending a mix of text, json, table, image, audio, video, and binary data
+# Tests sending a mix of text, dictionary, arrowtable, jsontable, image, audio, video, and binary data
 # from Julia serviceA to Julia serviceB using NATSBridge.jl smartsend
 # 
 # This test demonstrates that any combination and any number of mixed content
 # can be sent and received correctly.
+# 
+# Key concept: DataFrames are the main table representation in Julia.
+# The NATSBridge.jl library handles serialization:
+# - For "arrowtable" type: DataFrame is serialized to Arrow IPC format
+# - For "jsontable" type: DataFrame is converted to Vector{Dict} and then to JSON
 
 using NATS, JSON, UUIDs, Dates, PrettyPrinting, DataFrames, Arrow, HTTP, Base64
 
@@ -13,7 +18,7 @@ include("../src/NATSBridge.jl")
 using .NATSBridge
 
 # Configuration
-const SUBJECT = "/NATSBridge_mix_test"
+const SUBJECT = "/natsbridge"
 const NATS_URL = "nats.yiem.cc"
 const FILESERVER_URL = "http://192.168.88.104:8080"
 
@@ -82,49 +87,46 @@ function create_sample_data()
         )
     )
     
-    # Table data (DataFrame - small - direct transport)
-    table_data_small = DataFrame(
+    # Arrow table data (DataFrame - small - direct transport)
+    # Uses Arrow IPC format for efficient binary serialization
+    # NATSBridge.jl handles serialization: DataFrame -> Arrow IPC
+    arrow_table_small = DataFrame(
         id = 1:10,
-        message = ["msg_$i" for i in 1:10],
-        sender = ["sender_$i" for i in 1:10],
-        timestamp = [string(Dates.now()) for _ in 1:10],
-        priority = rand(1:3, 10)
+        name = ["Alice", "Bob", "Charlie", "Diana", "Eve", "Frank", "Grace", "Henry", "Ivy", "Jack"],
+        score = rand(50:100, 10),
+        active = rand([true, false], 10)
     )
     
-    # Table data (DataFrame - large - link transport)
-    # ~1.5MB of data (150,000 rows) - should trigger link transport
-    table_data_large = DataFrame(
-        id = 1:150_000,
-        message = ["msg_$i" for i in 1:150_000],
-        sender = ["sender_$i" for i in 1:150_000],
-        timestamp = [string(Dates.now()) for i in 1:150_000],
-        priority = rand(1:3, 150_000)
+    # Arrow table data (DataFrame - large - link transport)
+    # ~1.5MB of Arrow data (200,000 rows) - should trigger link transport
+    # NATSBridge.jl handles serialization: DataFrame -> Arrow IPC
+    arrow_table_large = DataFrame(
+        id = 1:2_000_000,
+        name = ["user_$i" for i in 1:2_000_000],
+        score = rand(50:100, 2_000_000),
+        active = rand([true, false], 2_000_000),
+        timestamp = [string(Dates.now()) for _ in 1:2_000_000]
     )
     
-    # Image data (small binary - direct transport)
-    # Create a simple 10x10 pixel PNG-like data (128 bytes header + 100 pixels = 112 bytes)
-    # Using simple RGB data (10*10*3 = 300 bytes of pixel data)
-    image_width = 10
-    image_height = 10
-    image_data = UInt8[]
-    # PNG header (simplified)
-    push!(image_data, 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A)
-    # Simple RGB data (RGBRGBRGB...)
-    for i in 1:image_width*image_height
-        push!(image_data, 0xFF, 0x00, 0x00)  # Red pixel
-    end
+    # Json table data (DataFrame - small - direct transport)
+    # Uses JSON format for human-readable tabular data
+    # NATSBridge.jl handles serialization: DataFrame -> Vector{Dict} -> JSON
+    json_table_small = DataFrame(
+        id = 1:10,
+        name = ["Alice", "Bob", "Charlie", "Diana", "Eve", "Frank", "Grace", "Henry", "Ivy", "Jack"],
+        score = rand(50:100, 10),
+        active = rand([true, false], 10)
+    )
     
-    # Image data (large - link transport)
-    # Create a larger image (~1.5MB) to test link transport
-    large_image_width = 500
-    large_image_height = 1000
-    large_image_data = UInt8[]
-    # PNG header (simplified for 500x1000)
-    push!(large_image_data, 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A)
-    # RGB data (500*1000*3 = 1,500,000 bytes)
-    for i in 1:large_image_width*large_image_height
-        push!(large_image_data, rand(1:255), rand(1:255), rand(1:255))  # Random color pixels
-    end
+    # Json table data (DataFrame - large - link transport)
+    # ~1.5MB of JSON data (150,000 rows) - should trigger link transport
+    # NATSBridge.jl handles serialization: DataFrame -> Vector{Dict} -> JSON
+    json_table_large = DataFrame(
+        id = 1:2_000_000,
+        name = ["user_$i" for i in 1:2_000_000],
+        score = rand(50:100, 2_000_000),
+        active = rand([true, false], 2_000_000)
+    )
     
     # Audio data (small binary - direct transport)
     audio_data = UInt8[rand(1:255) for _ in 1:100]
@@ -150,10 +152,10 @@ function create_sample_data()
     return (
         text_data,
         dict_data,
-        table_data_small,
-        table_data_large,
-        image_data,
-        large_image_data,
+        arrow_table_small,
+        arrow_table_large,
+        json_table_small,
+        json_table_large,
         audio_data,
         large_audio_data,
         video_data,
@@ -167,19 +169,35 @@ end
 # Sender: Send mixed content via smartsend
 function test_mix_send()
     # Create sample data
-    (text_data, dict_data, table_data_small, table_data_large, image_data, large_image_data, audio_data, large_audio_data, video_data, large_video_data, binary_data, large_binary_data) = create_sample_data()
+    (text_data, dict_data, arrow_table_small, arrow_table_large, json_table_small, json_table_large, audio_data, large_audio_data, video_data, large_video_data, binary_data, large_binary_data) = create_sample_data()
+
+    # Read image files from disk (following test_julia_file_sender.jl pattern)
+    # Small image - should use direct transport
+    file_path_small_image = "./test/small_image.jpg"
+    file_data_small_image = read(file_path_small_image)
+    filename_small_image = basename(file_path_small_image)
+
+    # Large image - should use link transport
+    file_path_large_image = "./test/large_image.png"
+    file_data_large_image = read(file_path_large_image)
+    filename_large_image = basename(file_path_large_image)
 
     # Create payloads list - mixed content with both small and large data
     # Small data uses direct transport, large data uses link transport
+    # Key: Pass DataFrame directly and specify type as "arrowtable" or "jsontable"
+    # NATSBridge.jl handles the serialization internally
     payloads = [
-        # Small data (direct transport) - text, dictionary, small table
+        # Small data (direct transport) - text, dictionary, arrowtable, jsontable, small image
         ("chat_text", text_data, "text"),
         ("chat_json", dict_data, "dictionary"),
-        ("chat_table_small", table_data_small, "table"),
+        # ("arrow_table_small", arrow_table_small, "arrowtable"),
+        ("json_table_small", json_table_small, "jsontable"),
+        (filename_small_image, file_data_small_image, "binary"),
 
-        # Large data (link transport) - large table, large image, large audio, large video, large binary
-        ("chat_table_large", table_data_large, "table"),
-        ("user_image_large", large_image_data, "image"),
+        # Large data (link transport) - large arrowtable, large jsontable, large image, large audio, large video, large binary
+        # ("arrow_table_large", arrow_table_large, "arrowtable"),
+        ("json_table_large", json_table_large, "jsontable"),
+        (filename_large_image, file_data_large_image, "binary"),
         ("audio_clip_large", large_audio_data, "audio"),
         ("video_clip_large", large_video_data, "video"),
         ("binary_file_large", large_binary_data, "binary")

test/test_julia_table_receiver.jl

@@ -1,84 +0,0 @@
-#!/usr/bin/env julia
-# Test script for DataFrame table transport testing
-# Tests receiving 1 large and 1 small DataFrames via direct and link transport
-# Uses NATSBridge.jl smartreceive with "table" type
-
-using NATS, JSON, UUIDs, Dates, PrettyPrinting, DataFrames, Arrow, HTTP
-
-# Include the bridge module
-include("../src/NATSBridge.jl")
-using .NATSBridge
-
-# Configuration
-const SUBJECT = "/NATSBridge_table_test"
-const NATS_URL = "nats.yiem.cc"
-const FILESERVER_URL = "http://192.168.88.104:8080"
-
-
-# ------------------------------------------------------------------------------------------------ #
-#                                        test table transfer                                       #
-# ------------------------------------------------------------------------------------------------ #
-
-
-# Helper: Log with correlation ID
-function log_trace(message)
-    timestamp = Dates.now()
-    println("[$timestamp] $message")
-end
-
-
-# Receiver: Listen for messages and verify DataFrame table handling
-function test_table_receive()
-    conn = NATS.connect(NATS_URL)
-    NATS.subscribe(conn, SUBJECT) do msg
-        log_trace("Received message on $(msg.subject)")
-        
-        # Use NATSBridge.smartreceive to handle the data
-        # API: smartreceive(msg, download_handler; max_retries, base_delay, max_delay)
-        result = NATSBridge.smartreceive(
-            msg;
-            max_retries = 5,
-            base_delay = 100,
-            max_delay = 5000
-        )
-        
-        # Result is an envelope dictionary with payloads field containing list of (dataname, data, data_type) tuples
-        for (dataname, data, data_type) in result["payloads"]
-          data = DataFrame(data)
-            if isa(data, DataFrame)
-                log_trace("Received DataFrame '$dataname' of type $data_type")
-                log_trace("  Dimensions: $(size(data, 1)) rows x $(size(data, 2)) columns")
-                log_trace("  Column names: $(names(data))")
-                
-                # Display first few rows
-                println("  First 5 rows:")
-                display(data[1:min(5, size(data, 1)), :])
-                
-                # Save to file
-                output_path = "./received_$dataname.arrow"
-                io = IOBuffer()
-                Arrow.write(io, data)
-                write(output_path, take!(io))
-                log_trace("Saved DataFrame to $output_path")
-            else
-                log_trace("Received unexpected data type for '$dataname': $(typeof(data))")
-            end
-        end
-    end
-    
-    # Keep listening for 10 seconds
-    sleep(120)  
-    NATS.drain(conn)
-end
-
-
-# Run the test
-println("Starting DataFrame table transport test...")
-println("Note: This receiver will wait for messages from the sender.")
-println("Run test_julia_to_julia_table_sender.jl first to send test data.")
-
-# Run receiver
-println("testing smartreceive")
-test_table_receive()
-
-println("Test completed.")

test/test_julia_table_sender.jl

@@ -1,135 +0,0 @@
-#!/usr/bin/env julia
-# Test script for DataFrame table transport testing
-# Tests sending 1 large and 1 small DataFrames via direct and link transport
-# Uses NATSBridge.jl smartsend with "table" type
-
-using NATS, JSON, UUIDs, Dates, PrettyPrinting, DataFrames, Arrow, HTTP
-
-# Include the bridge module
-include("../src/NATSBridge.jl")
-using .NATSBridge
-
-# Configuration
-const SUBJECT = "/NATSBridge_table_test"
-const NATS_URL = "nats.yiem.cc"
-const FILESERVER_URL = "http://192.168.88.104:8080"
-
-# Create correlation ID for tracing
-correlation_id = string(uuid4())
-
-
-# ------------------------------------------------------------------------------------------------ #
-#                                        test table transfer                                       #
-# ------------------------------------------------------------------------------------------------ #
-
-
-# Helper: Log with correlation ID
-function log_trace(message)
-    timestamp = Dates.now()
-    println("[$timestamp] [Correlation: $correlation_id] $message")
-end
-
-
-# File upload handler for plik server
-function plik_upload_handler(fileserver_url::String, dataname::String, data::Vector{UInt8})::Dict{String, Any}
-    # Get upload ID
-    url_getUploadID = "$fileserver_url/upload"
-    headers = ["Content-Type" => "application/json"]
-    body = """{ "OneShot" : true }"""
-    httpResponse = HTTP.request("POST", url_getUploadID, headers, body; body_is_form=false)
-    responseJson = JSON.parse(String(httpResponse.body))
-    uploadid = responseJson["id"]
-    uploadtoken = responseJson["uploadToken"]
-    
-    # Upload file
-    file_multipart = HTTP.Multipart(dataname, IOBuffer(data), "application/octet-stream")
-    url_upload = "$fileserver_url/file/$uploadid"
-    headers = ["X-UploadToken" => uploadtoken]
-    
-    form = HTTP.Form(Dict("file" => file_multipart))
-    httpResponse = HTTP.post(url_upload, headers, form)
-    responseJson = JSON.parse(String(httpResponse.body))
-    
-    fileid = responseJson["id"]
-    url = "$fileserver_url/file/$uploadid/$fileid/$dataname"
-    
-    return Dict("status" => httpResponse.status, "uploadid" => uploadid, "fileid" => fileid, "url" => url)
-end
-
-
-# Sender: Send DataFrame tables via smartsend
-function test_table_send()
-    # Create a small DataFrame (will use direct transport)
-    small_df = DataFrame(
-        id = 1:10,
-        name = ["Alice", "Bob", "Charlie", "Diana", "Eve", "Frank", "Grace", "Henry", "Ivy", "Jack"],
-        score = [95, 88, 92, 85, 90, 78, 95, 88, 92, 85],
-        category = ["A", "B", "A", "B", "A", "B", "A", "B", "A", "B"]
-    )
-    
-    # Create a large DataFrame (will use link transport if > 1MB)
-    # Generate a larger dataset (~2MB to ensure link transport)
-    large_ids = 1:50000
-    large_names = ["User_$i" for i in 1:50000]
-    large_scores = rand(1:100, 50000)
-    large_categories = ["Category_$(rand(1:10))" for i in 1:50000]
-    
-    large_df = DataFrame(
-        id = large_ids,
-        name = large_names,
-        score = large_scores,
-        category = large_categories
-    )
-    
-    # Test data 1: small DataFrame
-    data1 = ("small_table", small_df, "table")
-    
-    # Test data 2: large DataFrame
-    data2 = ("large_table", large_df, "table")
-    
-    # Use smartsend with table type
-    # For small DataFrame: will use direct transport (Base64 encoded Arrow IPC)
-    # For large DataFrame: will use link transport (uploaded to fileserver)
-    env, env_json_str = NATSBridge.smartsend(
-        SUBJECT,
-        [data1, data2];  # List of (dataname, data, type) tuples
-        broker_url = NATS_URL,
-        fileserver_url = FILESERVER_URL,
-        fileserver_upload_handler = plik_upload_handler,
-        size_threshold = 1_000_000,  # 1MB threshold
-        correlation_id = correlation_id,
-        msg_purpose = "chat",
-        sender_name = "table_sender",
-        receiver_name = "",
-        receiver_id = "",
-        reply_to = "",
-        reply_to_msg_id = "",
-        is_publish = true  # Publish the message to NATS
-    )
-    
-    log_trace("Sent message with $(length(env.payloads)) payloads")
-    
-    # Log transport type for each payload
-    for (i, payload) in enumerate(env.payloads)
-        log_trace("Payload $i ('$payload.dataname'):")
-        log_trace("  Transport: $(payload.transport)")
-        log_trace("  Type: $(payload.payload_type)")
-        log_trace("  Size: $(payload.size) bytes")
-        log_trace("  Encoding: $(payload.encoding)")
-        
-        if payload.transport == "link"
-            log_trace("  URL: $(payload.data)")
-        end
-    end
-end
-
-
-# Run the test
-println("Starting DataFrame table transport test...")
-println("Correlation ID: $correlation_id")
-
-# Run sender
-println("start smartsend for tables")
-test_table_send()
-
-println("Test completed.")

test/test_julia_text_receiver.jl

@@ -1,83 +0,0 @@
-#!/usr/bin/env julia
-# Test script for text transport testing
-# Tests receiving 1 large and 1 small text from Julia serviceA to Julia serviceB
-# Uses NATSBridge.jl smartreceive with "text" type
-
-using NATS, JSON, UUIDs, Dates, PrettyPrinting, DataFrames, Arrow, HTTP
-
-# Include the bridge module
-include("../src/NATSBridge.jl")
-using .NATSBridge
-
-# Configuration
-const SUBJECT = "/NATSBridge_text_test"
-const NATS_URL = "nats.yiem.cc"
-const FILESERVER_URL = "http://192.168.88.104:8080"
-
-
-# ------------------------------------------------------------------------------------------------ #
-#                                        test text transfer                                        #
-# ------------------------------------------------------------------------------------------------ #
-
-
-# Helper: Log with correlation ID
-function log_trace(message)
-    timestamp = Dates.now()
-    println("[$timestamp] $message")
-end
-
-
-# Receiver: Listen for messages and verify text handling
-function test_text_receive()
-    conn = NATS.connect(NATS_URL)
-    NATS.subscribe(conn, SUBJECT) do msg
-        log_trace("Received message on $(msg.subject)")
-        
-        # Use NATSBridge.smartreceive to handle the data
-        # API: smartreceive(msg, download_handler; max_retries, base_delay, max_delay)
-        result = NATSBridge.smartreceive(
-            msg;
-            max_retries = 5,
-            base_delay = 100,
-            max_delay = 5000
-        )
-        
-        # Result is an envelope dictionary with payloads field containing list of (dataname, data, data_type) tuples
-        for (dataname, data, data_type) in result["payloads"]
-            if isa(data, String)
-                log_trace("Received text '$dataname' of type $data_type")
-                log_trace("  Length: $(length(data)) characters")
-                
-                # Display first 100 characters
-                if length(data) > 100
-                    log_trace("  First 100 characters: $(data[1:100])...")
-                else
-                    log_trace("  Content: $data")
-                end
-                
-                # Save to file
-                output_path = "./received_$dataname.txt"
-                write(output_path, data)
-                log_trace("Saved text to $output_path")
-            else
-                log_trace("Received unexpected data type for '$dataname': $(typeof(data))")
-            end
-        end
-    end
-    
-    # Keep listening for 10 seconds
-    sleep(120)  
-    NATS.drain(conn)
-end
-
-
-# Run the test
-println("Starting text transport test...")
-println("Note: This receiver will wait for messages from the sender.")
-println("Run test_julia_to_julia_text_sender.jl first to send test data.")
-
-# Run receiver
-println("testing smartreceive for text")
-test_text_receive()
-
-println("Test completed.")

test/test_julia_text_sender.jl

@@ -1,120 +0,0 @@
-#!/usr/bin/env julia
-# Test script for text transport testing
-# Tests sending 1 large and 1 small text from Julia serviceA to Julia serviceB
-# Uses NATSBridge.jl smartsend with "text" type
-
-using NATS, JSON, UUIDs, Dates, PrettyPrinting, DataFrames, Arrow, HTTP
-
-# Include the bridge module
-include("../src/NATSBridge.jl")
-using .NATSBridge
-
-# Configuration
-const SUBJECT = "/NATSBridge_text_test"
-const NATS_URL = "nats.yiem.cc"
-const FILESERVER_URL = "http://192.168.88.104:8080"
-
-# Create correlation ID for tracing
-correlation_id = string(uuid4())
-
-
-# ------------------------------------------------------------------------------------------------ #
-#                                        test text transfer                                        #
-# ------------------------------------------------------------------------------------------------ #
-
-
-# Helper: Log with correlation ID
-function log_trace(message)
-    timestamp = Dates.now()
-    println("[$timestamp] [Correlation: $correlation_id] $message")
-end
-
-
-# File upload handler for plik server
-function plik_upload_handler(fileserver_url::String, dataname::String, data::Vector{UInt8})::Dict{String, Any}
-    # Get upload ID
-    url_getUploadID = "$fileserver_url/upload"
-    headers = ["Content-Type" => "application/json"]
-    body = """{ "OneShot" : true }"""
-    httpResponse = HTTP.request("POST", url_getUploadID, headers, body; body_is_form=false)
-    responseJson = JSON.parse(String(httpResponse.body))
-    uploadid = responseJson["id"]
-    uploadtoken = responseJson["uploadToken"]
-    
-    # Upload file
-    file_multipart = HTTP.Multipart(dataname, IOBuffer(data), "application/octet-stream")
-    url_upload = "$fileserver_url/file/$uploadid"
-    headers = ["X-UploadToken" => uploadtoken]
-    
-    form = HTTP.Form(Dict("file" => file_multipart))
-    httpResponse = HTTP.post(url_upload, headers, form)
-    responseJson = JSON.parse(String(httpResponse.body))
-    
-    fileid = responseJson["id"]
-    url = "$fileserver_url/file/$uploadid/$fileid/$dataname"
-    
-    return Dict("status" => httpResponse.status, "uploadid" => uploadid, "fileid" => fileid, "url" => url)
-end
-
-
-# Sender: Send text via smartsend
-function test_text_send()
-    # Create a small text (will use direct transport)
-    small_text = "Hello, this is a small text message. Testing direct transport via NATS."
-    
-    # Create a large text (will use link transport if > 1MB)
-    # Generate a larger text (~2MB to ensure link transport)
-    large_text = join(["Line $i: This is a sample text line with some content to pad the size. " for i in 1:50000], "")
-    
-    # Test data 1: small text
-    data1 = ("small_text", small_text, "text")
-    
-    # Test data 2: large text
-    data2 = ("large_text", large_text, "text")
-    
-    # Use smartsend with text type
-    # For small text: will use direct transport (Base64 encoded UTF-8)
-    # For large text: will use link transport (uploaded to fileserver)
-    env, env_json_str = NATSBridge.smartsend(
-        SUBJECT,
-        [data1, data2];  # List of (dataname, data, type) tuples
-        broker_url = NATS_URL,
-        fileserver_url = FILESERVER_URL,
-        fileserver_upload_handler = plik_upload_handler,
-        size_threshold = 1_000_000,  # 1MB threshold
-        correlation_id = correlation_id,
-        msg_purpose = "chat",
-        sender_name = "text_sender",
-        receiver_name = "",
-        receiver_id = "",
-        reply_to = "",
-        reply_to_msg_id = "",
-        is_publish = true  # Publish the message to NATS
-    )
-    
-    log_trace("Sent message with $(length(env.payloads)) payloads")
-    
-    # Log transport type for each payload
-    for (i, payload) in enumerate(env.payloads)
-        log_trace("Payload $i ('$payload.dataname'):")
-        log_trace("  Transport: $(payload.transport)")
-        log_trace("  Type: $(payload.payload_type)")
-        log_trace("  Size: $(payload.size) bytes")
-        log_trace("  Encoding: $(payload.encoding)")
-        
-        if payload.transport == "link"
-            log_trace("  URL: $(payload.data)")
-        end
-    end
-end
-
-
-# Run the test
-println("Starting text transport test...")
-println("Correlation ID: $correlation_id")
-
-# Run sender
-println("start smartsend for text")
-test_text_send()
-
-println("Test completed.")

test/test_mpy_binary_receiver.py

@@ -1,185 +0,0 @@
-"""
-MicroPython Binary Receiver Test
-Tests the smartreceive function with binary/image/audio/video payloads
-
-Note: This test is designed for both MicroPython and desktop Python
-for compatibility testing.
-"""
-
-import sys
-import os
-import json
-import base64
-
-# Add parent directory to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from natbridge_mpy import smartreceive, DEFAULT_BROKER_URL, DEFAULT_FILESERVER_URL
-
-TEST_BROKER_URL = os.environ.get('NATS_URL', 'nats://localhost:4222')
-TEST_FILESERVER_URL = os.environ.get('FILESERVER_URL', 'http://localhost:8080')
-
-
-def run_test():
-    print('=== MicroPython Binary Receiver Test ===\n')
-    
-    from natbridge_mpy import _generate_uuid
-    
-    # Create mock NATS message with binary payloads
-    image_data = bytes([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A])  # PNG header
-    audio_data = bytes([0x46, 0x4C, 0x41, 0x43, 0x00, 0x00, 0x00, 0x00])  # FLAC header
-    video_data = bytes([0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70])  # MP4 header
-    generic_binary = bytes([0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE])
-    
-    test_data = {
-        'correlation_id': 'mpy-binary-receiver-' + _generate_uuid(),
-        'msg_id': _generate_uuid(),
-        'timestamp': '2024-01-15T10:30:00Z',
-        'send_to': '/test/binary',
-        'msg_purpose': 'test',
-        'sender_name': 'mpy-binary-test',
-        'sender_id': _generate_uuid(),
-        'receiver_name': 'mpy-receiver',
-        'receiver_id': _generate_uuid(),
-        'reply_to': '',
-        'reply_to_msg_id': '',
-        'broker_url': TEST_BROKER_URL,
-        'metadata': {},
-        'payloads': [
-            {
-                'id': _generate_uuid(),
-                'dataname': 'image',
-                'payload_type': 'image',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(image_data),
-                'data': base64.b64encode(image_data).decode('ascii'),
-                'metadata': {'payload_bytes': len(image_data)}
-            },
-            {
-                'id': _generate_uuid(),
-                'dataname': 'audio',
-                'payload_type': 'audio',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(audio_data),
-                'data': base64.b64encode(audio_data).decode('ascii'),
-                'metadata': {'payload_bytes': len(audio_data)}
-            },
-            {
-                'id': _generate_uuid(),
-                'dataname': 'video',
-                'payload_type': 'video',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(video_data),
-                'data': base64.b64encode(video_data).decode('ascii'),
-                'metadata': {'payload_bytes': len(video_data)}
-            },
-            {
-                'id': _generate_uuid(),
-                'dataname': 'binary',
-                'payload_type': 'binary',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(generic_binary),
-                'data': base64.b64encode(generic_binary).decode('ascii'),
-                'metadata': {'payload_bytes': len(generic_binary)}
-            }
-        ]
-    }
-    
-    mock_msg = {
-        'payload': json.dumps(test_data)
-    }
-    
-    print('Mock Message Created:')
-    print(f'  Correlation ID: {test_data["correlation_id"]}')
-    print(f'  Payloads: {len(test_data["payloads"])}')
-    print(f'  Payload types: {", ".join(p["payload_type"] for p in test_data["payloads"])}\n')
-    
-    try:
-        # Receive and process the message
-        print('Receiving and processing message...')
-        env = smartreceive(
-            mock_msg,
-            max_retries=3,
-            base_delay=100,
-            max_delay=1000
-        )
-        
-        print('\n=== Received Envelope ===')
-        print(f'Correlation ID: {env["correlation_id"]}')
-        print(f'Message ID: {env["msg_id"]}')
-        print(f'Timestamp: {env["timestamp"]}')
-        print(f'Subject: {env["send_to"]}')
-        print(f'Payloads: {len(env["payloads"])}\n')
-        
-        # Validate received data
-        print('=== Validation ===')
-        passed = True
-        
-        if not env.get('correlation_id'):
-            print('❌ correlation_id is missing')
-            passed = False
-        else:
-            print('✅ correlation_id present')
-        
-        if len(env['payloads']) != 4:
-            print(f'❌ Expected 4 payloads, got {len(env["payloads"])}')
-            passed = False
-        else:
-            print('✅ Correct number of payloads')
-        
-        # Expected data
-        expected_data = [
-            ('image', image_data, 'image'),
-            ('audio', audio_data, 'audio'),
-            ('video', video_data, 'video'),
-            ('binary', generic_binary, 'binary')
-        ]
-        
-        for i in range(len(env['payloads'])):
-            payload = env['payloads'][i]
-            expected = expected_data[i]
-            
-            if payload[0] != expected[0]:
-                print(f"❌ Payload {i + 1}: Expected dataname '{expected[0]}', got '{payload[0]}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct dataname')
-            
-            if payload[2] != expected[2]:
-                print(f"❌ Payload {i + 1}: Expected type '{expected[2]}', got '{payload[2]}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct type')
-            
-            # Verify binary data integrity
-            received_data = payload[1]
-            if received_data != expected[1]:
-                print(f'❌ Payload {i + 1}: Data mismatch')
-                print(f'   Expected: {expected[1]}')
-                print(f'   Got: {received_data}')
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Data correctly deserialized')
-        
-        # Final result
-        print('\n=== Test Result ===')
-        if passed:
-            print('✅ ALL TESTS PASSED')
-            sys.exit(0)
-        else:
-            print('❌ SOME TESTS FAILED')
-            sys.exit(1)
-            
-    except Exception as e:
-        print(f'❌ Test failed with error: {e}')
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    run_test()

test/test_mpy_binary_sender.py

@@ -1,163 +0,0 @@
-"""
-MicroPython Binary Sender Test
-Tests the smartsend function with binary/image/audio/video payloads
-
-Note: This test is designed for both MicroPython and desktop Python
-for compatibility testing.
-"""
-
-import sys
-import os
-import base64
-
-# Add parent directory to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from natbridge_mpy import smartsend, DEFAULT_BROKER_URL, DEFAULT_FILESERVER_URL, DEFAULT_SIZE_THRESHOLD, MAX_PAYLOAD_SIZE
-
-TEST_SUBJECT = '/test/binary'
-TEST_BROKER_URL = os.environ.get('NATS_URL', 'nats://localhost:4222')
-TEST_FILESERVER_URL = os.environ.get('FILESERVER_URL', 'http://localhost:8080')
-
-
-def run_test():
-    print('=== MicroPython Binary Sender Test ===\n')
-    
-    from natbridge_mpy import _generate_uuid
-    correlation_id = 'mpy-binary-test-' + _generate_uuid()
-    print(f'Correlation ID: {correlation_id}')
-    print(f'Subject: {TEST_SUBJECT}')
-    print(f'Broker URL: {TEST_BROKER_URL}')
-    print(f'Default Size Threshold: {DEFAULT_SIZE_THRESHOLD} bytes')
-    print(f'Max Payload Size: {MAX_PAYLOAD_SIZE} bytes\n')
-    
-    # Test data - binary data for different types
-    image_data = bytearray([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A])  # PNG header
-    audio_data = bytearray([0x46, 0x4C, 0x41, 0x43, 0x00, 0x00, 0x00, 0x00])  # FLAC header
-    video_data = bytearray([0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70])  # MP4 header
-    generic_binary = bytearray([0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE])
-    
-    test_data = [
-        ('image', bytes(image_data), 'image'),
-        ('audio', bytes(audio_data), 'audio'),
-        ('video', bytes(video_data), 'video'),
-        ('binary', bytes(generic_binary), 'binary')
-    ]
-    
-    try:
-        # Send the message
-        print('Sending binary payloads...')
-        env, env_json_str = smartsend(
-            TEST_SUBJECT,
-            test_data,
-            broker_url=TEST_BROKER_URL,
-            fileserver_url=TEST_FILESERVER_URL,
-            correlation_id=correlation_id,
-            msg_purpose='test',
-            sender_name='mpy-binary-test',
-            is_publish=False
-        )
-        
-        print('\n=== Envelope Created ===')
-        print(f'Correlation ID: {env["correlation_id"]}')
-        print(f'Message ID: {env["msg_id"]}')
-        print(f'Timestamp: {env["timestamp"]}')
-        print(f'Subject: {env["send_to"]}')
-        print(f'Purpose: {env["msg_purpose"]}')
-        print(f'Sender: {env["sender_name"]}')
-        print(f'Payloads: {len(env["payloads"])}\n')
-        
-        # Validate envelope structure
-        print('=== Validation ===')
-        passed = True
-        
-        if len(env['payloads']) != 4:
-            print(f'❌ Expected 4 payloads, got {len(env["payloads"])}')
-            passed = False
-        else:
-            print('✅ Correct number of payloads')
-        
-        # Test each payload
-        expected_datanames = ['image', 'audio', 'video', 'binary']
-        expected_types = ['image', 'audio', 'video', 'binary']
-        expected_data = [bytes(image_data), bytes(audio_data), bytes(video_data), bytes(generic_binary)]
-        
-        for i in range(len(env['payloads'])):
-            payload = env['payloads'][i]
-            
-            if payload['dataname'] != expected_datanames[i]:
-                print(f"❌ Payload {i + 1}: Expected dataname '{expected_datanames[i]}', got '{payload['dataname']}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct dataname')
-            
-            if payload['payload_type'] != expected_types[i]:
-                print(f"❌ Payload {i + 1}: Expected type '{expected_types[i]}', got '{payload['payload_type']}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct type')
-            
-            if payload['transport'] != 'direct':
-                print(f"❌ Payload {i + 1}: Expected transport 'direct', got '{payload['transport']}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct transport')
-            
-            if payload['encoding'] != 'base64':
-                print(f"❌ Payload {i + 1}: Expected encoding 'base64', got '{payload['encoding']}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct encoding')
-            
-            # Decode and verify the data
-            decoded_data = base64.b64decode(payload['data'])
-            original_data = expected_data[i]
-            
-            if decoded_data != original_data:
-                print(f'❌ Payload {i + 1}: Data integrity mismatch')
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Data integrity verified')
-            
-            print(f'   Size: {payload["size"]} bytes\n')
-        
-        # Test with larger binary data
-        print('=== Large Binary Data Test ===')
-        large_data = bytes([0xFF] * 1000)  # 1KB of binary data
-        large_test_data = [
-            ('large_binary', large_data, 'binary')
-        ]
-        
-        large_env, _ = smartsend(
-            TEST_SUBJECT,
-            large_test_data,
-            broker_url=TEST_BROKER_URL,
-            fileserver_url=TEST_FILESERVER_URL,
-            correlation_id='large-' + correlation_id,
-            is_publish=False
-        )
-        
-        if len(large_env['payloads']) == 1 and large_env['payloads'][0]['size'] == 1000:
-            print('✅ Large binary data handled correctly')
-        else:
-            print('❌ Large binary data handling failed')
-            passed = False
-        
-        # Final result
-        print('\n=== Test Result ===')
-        if passed:
-            print('✅ ALL TESTS PASSED')
-            sys.exit(0)
-        else:
-            print('❌ SOME TESTS FAILED')
-            sys.exit(1)
-            
-    except Exception as e:
-        print(f'❌ Test failed with error: {e}')
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    run_test()

test/test_mpy_dictionary_receiver.py

@@ -1,224 +0,0 @@
-"""
-MicroPython Dictionary Receiver Test
-Tests the smartreceive function with dictionary payloads
-
-Note: This test is designed for both MicroPython and desktop Python
-for compatibility testing.
-"""
-
-import sys
-import os
-import json
-
-# Add parent directory to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from natbridge_mpy import smartreceive, DEFAULT_BROKER_URL, DEFAULT_FILESERVER_URL
-
-TEST_BROKER_URL = os.environ.get('NATS_URL', 'nats://localhost:4222')
-TEST_FILESERVER_URL = os.environ.get('FILESERVER_URL', 'http://localhost:8080')
-
-
-def run_test():
-    print('=== MicroPython Dictionary Receiver Test ===\n')
-    
-    from natbridge_mpy import _generate_uuid
-    
-    # Create a mock NATS message with dictionary payloads
-    import base64
-    
-    simple_dict = {'key1': 'value1', 'key2': 'value2'}
-    nested_dict = {'outer': {'inner': 'value', 'number': 42}}
-    array_dict = {'items': [1, 2, 3, 'four', 'five']}
-    mixed_dict = {'string': 'text', 'number': 123, 'boolean': True, 'null_val': None}
-    
-    test_data = {
-        'correlation_id': 'mpy-receiver-dict-' + _generate_uuid(),
-        'msg_id': _generate_uuid(),
-        'timestamp': '2024-01-15T10:30:00Z',
-        'send_to': '/test/dictionary',
-        'msg_purpose': 'test',
-        'sender_name': 'mpy-dict-test',
-        'sender_id': _generate_uuid(),
-        'receiver_name': 'mpy-receiver',
-        'receiver_id': _generate_uuid(),
-        'reply_to': '',
-        'reply_to_msg_id': '',
-        'broker_url': TEST_BROKER_URL,
-        'metadata': {},
-        'payloads': [
-            {
-                'id': _generate_uuid(),
-                'dataname': 'simple_dict',
-                'payload_type': 'dictionary',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(json.dumps(simple_dict).encode('utf8')),
-                'data': base64.b64encode(json.dumps(simple_dict).encode('utf8')).decode('ascii'),
-                'metadata': {'payload_bytes': len(json.dumps(simple_dict).encode('utf8'))}
-            },
-            {
-                'id': _generate_uuid(),
-                'dataname': 'nested_dict',
-                'payload_type': 'dictionary',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(json.dumps(nested_dict).encode('utf8')),
-                'data': base64.b64encode(json.dumps(nested_dict).encode('utf8')).decode('ascii'),
-                'metadata': {'payload_bytes': len(json.dumps(nested_dict).encode('utf8'))}
-            },
-            {
-                'id': _generate_uuid(),
-                'dataname': 'array_dict',
-                'payload_type': 'dictionary',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(json.dumps(array_dict).encode('utf8')),
-                'data': base64.b64encode(json.dumps(array_dict).encode('utf8')).decode('ascii'),
-                'metadata': {'payload_bytes': len(json.dumps(array_dict).encode('utf8'))}
-            },
-            {
-                'id': _generate_uuid(),
-                'dataname': 'mixed_dict',
-                'payload_type': 'dictionary',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(json.dumps(mixed_dict).encode('utf8')),
-                'data': base64.b64encode(json.dumps(mixed_dict).encode('utf8')).decode('ascii'),
-                'metadata': {'payload_bytes': len(json.dumps(mixed_dict).encode('utf8'))}
-            }
-        ]
-    }
-    
-    mock_msg = {
-        'payload': json.dumps(test_data)
-    }
-    
-    print('Mock Message Created:')
-    print(f'  Correlation ID: {test_data["correlation_id"]}')
-    print(f'  Payloads: {len(test_data["payloads"])}')
-    print(f'  Payload types: {", ".join(p["payload_type"] for p in test_data["payloads"])}\n')
-    
-    try:
-        # Receive and process the message
-        print('Receiving and processing message...')
-        env = smartreceive(
-            mock_msg,
-            max_retries=3,
-            base_delay=100,
-            max_delay=1000
-        )
-        
-        print('\n=== Received Envelope ===')
-        print(f'Correlation ID: {env["correlation_id"]}')
-        print(f'Message ID: {env["msg_id"]}')
-        print(f'Timestamp: {env["timestamp"]}')
-        print(f'Subject: {env["send_to"]}')
-        print(f'Payloads: {len(env["payloads"])}\n')
-        
-        # Validate received data
-        print('=== Validation ===')
-        passed = True
-        
-        if not env.get('correlation_id'):
-            print('❌ correlation_id is missing')
-            passed = False
-        else:
-            print('✅ correlation_id present')
-        
-        if len(env['payloads']) != 4:
-            print(f'❌ Expected 4 payloads, got {len(env["payloads"])}')
-            passed = False
-        else:
-            print('✅ Correct number of payloads')
-        
-        # Expected data
-        expected_data = [
-            ('simple_dict', simple_dict, 'dictionary'),
-            ('nested_dict', nested_dict, 'dictionary'),
-            ('array_dict', array_dict, 'dictionary'),
-            ('mixed_dict', mixed_dict, 'dictionary')
-        ]
-        
-        for i in range(len(env['payloads'])):
-            payload = env['payloads'][i]
-            expected = expected_data[i]
-            
-            if payload[0] != expected[0]:
-                print(f"❌ Payload {i + 1}: Expected dataname '{expected[0]}', got '{payload[0]}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct dataname')
-            
-            if payload[2] != expected[2]:
-                print(f"❌ Payload {i + 1}: Expected type '{expected[2]}', got '{payload[2]}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct type')
-            
-            data_match = json.dumps(payload[1], sort_keys=True) == json.dumps(expected[1], sort_keys=True)
-            if not data_match:
-                print(f'❌ Payload {i + 1}: Data mismatch')
-                print(f'   Expected: {json.dumps(expected[1], sort_keys=True)}')
-                print(f'   Got: {json.dumps(payload[1], sort_keys=True)}')
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Data correctly deserialized')
-        
-        # Test round-trip with receive
-        print('\n=== Round-trip Test ===')
-        round_trip_data = {
-            'correlation_id': 'roundtrip-' + _generate_uuid(),
-            'msg_id': _generate_uuid(),
-            'timestamp': '2024-01-15T10:30:00Z',
-            'send_to': '/test/dictionary',
-            'msg_purpose': 'test',
-            'sender_name': 'mpy-test',
-            'sender_id': _generate_uuid(),
-            'receiver_name': 'mpy-receiver',
-            'receiver_id': _generate_uuid(),
-            'reply_to': '',
-            'reply_to_msg_id': '',
-            'broker_url': TEST_BROKER_URL,
-            'metadata': {},
-            'payloads': [
-                {
-                    'id': _generate_uuid(),
-                    'dataname': 'roundtrip',
-                    'payload_type': 'dictionary',
-                    'transport': 'direct',
-                    'encoding': 'base64',
-                    'size': len(json.dumps({'test': 'data', 'nested': {'a': 1, 'b': 2}}).encode('utf8')),
-                    'data': base64.b64encode(json.dumps({'test': 'data', 'nested': {'a': 1, 'b': 2}}).encode('utf8')).decode('ascii'),
-                    'metadata': {'payload_bytes': len(json.dumps({'test': 'data', 'nested': {'a': 1, 'b': 2}}).encode('utf8'))}
-                }
-            ]
-        }
-        
-        mock_rt_msg = {'payload': json.dumps(round_trip_data)}
-        rt_env = smartreceive(mock_rt_msg)
-        
-        if rt_env['payloads'][0][0] == 'roundtrip' and rt_env['payloads'][0][2] == 'dictionary':
-            print('✅ Round-trip test successful')
-        else:
-            print('❌ Round-trip test failed')
-            passed = False
-        
-        # Final result
-        print('\n=== Test Result ===')
-        if passed:
-            print('✅ ALL TESTS PASSED')
-            sys.exit(0)
-        else:
-            print('❌ SOME TESTS FAILED')
-            sys.exit(1)
-            
-    except Exception as e:
-        print(f'❌ Test failed with error: {e}')
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    run_test()

test/test_mpy_dictionary_sender.py

@@ -1,177 +0,0 @@
-"""
-MicroPython Dictionary Sender Test
-Tests the smartsend function with dictionary payloads
-
-Note: This test is designed for both MicroPython and desktop Python
-for compatibility testing.
-"""
-
-import sys
-import os
-import json
-
-# Add parent directory to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from natbridge_mpy import smartsend, DEFAULT_BROKER_URL, DEFAULT_FILESERVER_URL, DEFAULT_SIZE_THRESHOLD, MAX_PAYLOAD_SIZE
-
-TEST_SUBJECT = '/test/dictionary'
-TEST_BROKER_URL = os.environ.get('NATS_URL', 'nats://localhost:4222')
-TEST_FILESERVER_URL = os.environ.get('FILESERVER_URL', 'http://localhost:8080')
-
-
-def run_test():
-    print('=== MicroPython Dictionary Sender Test ===\n')
-    
-    from natbridge_mpy import _generate_uuid
-    correlation_id = 'mpy-dict-test-' + _generate_uuid()
-    print(f'Correlation ID: {correlation_id}')
-    print(f'Subject: {TEST_SUBJECT}')
-    print(f'Broker URL: {TEST_BROKER_URL}')
-    print(f'Default Size Threshold: {DEFAULT_SIZE_THRESHOLD} bytes')
-    print(f'Max Payload Size: {MAX_PAYLOAD_SIZE} bytes\n')
-    
-    # Test data - various dictionary structures
-    test_data = [
-        ('simple_dict', {'key1': 'value1', 'key2': 'value2'}, 'dictionary'),
-        ('nested_dict', {'outer': {'inner': 'value', 'number': 42}}, 'dictionary'),
-        ('array_dict', {'items': [1, 2, 3, 'four', 'five']}, 'dictionary'),
-        ('mixed_dict', {'string': 'text', 'number': 123, 'boolean': True, 'null_val': None}, 'dictionary')
-    ]
-    
-    try:
-        # Send the message
-        print('Sending dictionary payloads...')
-        env, env_json_str = smartsend(
-            TEST_SUBJECT,
-            test_data,
-            broker_url=TEST_BROKER_URL,
-            fileserver_url=TEST_FILESERVER_URL,
-            correlation_id=correlation_id,
-            msg_purpose='test',
-            sender_name='mpy-dict-test',
-            is_publish=False
-        )
-        
-        print('\n=== Envelope Created ===')
-        print(f'Correlation ID: {env["correlation_id"]}')
-        print(f'Message ID: {env["msg_id"]}')
-        print(f'Timestamp: {env["timestamp"]}')
-        print(f'Subject: {env["send_to"]}')
-        print(f'Purpose: {env["msg_purpose"]}')
-        print(f'Sender: {env["sender_name"]}')
-        print(f'Payloads: {len(env["payloads"])}\n')
-        
-        # Validate envelope structure
-        print('=== Validation ===')
-        passed = True
-        
-        if len(env['payloads']) != 4:
-            print(f'❌ Expected 4 payloads, got {len(env["payloads"])}')
-            passed = False
-        else:
-            print('✅ Correct number of payloads')
-        
-        # Test each payload
-        expected_datanames = ['simple_dict', 'nested_dict', 'array_dict', 'mixed_dict']
-        expected_types = ['dictionary', 'dictionary', 'dictionary', 'dictionary']
-        
-        for i in range(len(env['payloads'])):
-            payload = env['payloads'][i]
-            
-            if payload['dataname'] != expected_datanames[i]:
-                print(f"❌ Payload {i + 1}: Expected dataname '{expected_datanames[i]}', got '{payload['dataname']}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct dataname')
-            
-            if payload['payload_type'] != expected_types[i]:
-                print(f"❌ Payload {i + 1}: Expected type '{expected_types[i]}', got '{payload['payload_type']}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct type')
-            
-            if payload['transport'] != 'direct':
-                print(f"❌ Payload {i + 1}: Expected transport 'direct', got '{payload['transport']}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct transport')
-            
-            if payload['encoding'] != 'base64':
-                print(f"❌ Payload {i + 1}: Expected encoding 'base64', got '{payload['encoding']}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct encoding')
-            
-            # Decode and verify the data
-            import base64
-            decoded_data = json.loads(base64.b64decode(payload['data']).decode('ascii'))
-            original_data = test_data[i][1]
-            
-            # Normalize for comparison
-            if json.dumps(decoded_data, sort_keys=True) != json.dumps(original_data, sort_keys=True):
-                print(f'❌ Payload {i + 1}: Data integrity mismatch')
-                print(f'   Expected: {json.dumps(original_data)}')
-                print(f'   Got: {json.dumps(decoded_data)}')
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Data integrity verified')
-            
-            print(f'   Size: {payload["size"]} bytes\n')
-        
-        # Test round-trip serialization
-        print('=== Round-trip Serialization Test ===')
-        round_trip_data = [
-            ('roundtrip', {'test': 'data', 'numbers': [1, 2, 3], 'nested': {'a': 1, 'b': 2}}, 'dictionary')
-        ]
-        
-        rt_env, _ = smartsend(
-            TEST_SUBJECT,
-            round_trip_data,
-            broker_url=TEST_BROKER_URL,
-            fileserver_url=TEST_FILESERVER_URL,
-            correlation_id='roundtrip-' + correlation_id,
-            is_publish=False
-        )
-        
-        rt_payload = rt_env['payloads'][0]
-        rt_decoded = json.loads(base64.b64decode(rt_payload['data']).decode('ascii'))
-        
-        if json.dumps(rt_decoded, sort_keys=True) == json.dumps(round_trip_data[0][1], sort_keys=True):
-            print('✅ Round-trip serialization successful')
-        else:
-            print('❌ Round-trip serialization failed')
-            passed = False
-        
-        # Test JSON string output
-        print('\n=== JSON String Output Test ===')
-        try:
-            parsed = json.loads(env_json_str)
-            if parsed['correlation_id'] == env['correlation_id'] and \
-               len(parsed['payloads']) == len(env['payloads']):
-                print('✅ JSON string is valid and matches envelope')
-            else:
-                print('❌ JSON string does not match envelope')
-                passed = False
-        except json.JSONDecodeError as e:
-            print(f'❌ JSON string is invalid: {e}')
-            passed = False
-        
-        # Final result
-        print('\n=== Test Result ===')
-        if passed:
-            print('✅ ALL TESTS PASSED')
-            sys.exit(0)
-        else:
-            print('❌ SOME TESTS FAILED')
-            sys.exit(1)
-            
-    except Exception as e:
-        print(f'❌ Test failed with error: {e}')
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    run_test()

test/test_mpy_text_receiver.py

@@ -1,209 +0,0 @@
-"""
-MicroPython Text Receiver Test
-Tests the smartreceive function with text payloads
-
-Note: This test is designed for both MicroPython and desktop Python
-for compatibility testing.
-"""
-
-import sys
-import os
-import json
-
-# Add parent directory to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from natbridge_mpy import smartreceive, DEFAULT_BROKER_URL, DEFAULT_FILESERVER_URL
-
-TEST_BROKER_URL = os.environ.get('NATS_URL', 'nats://localhost:4222')
-TEST_FILESERVER_URL = os.environ.get('FILESERVER_URL', 'http://localhost:8080')
-
-
-def run_test():
-    print('=== MicroPython Text Receiver Test ===\n')
-    
-    from natbridge_mpy import _generate_uuid
-    
-    # Create a mock NATS message with text payload
-    test_text = 'Hello, NATSBridge! This is a test message.'
-    import base64
-    
-    test_data = {
-        'correlation_id': 'mpy-receiver-test-' + _generate_uuid(),
-        'msg_id': _generate_uuid(),
-        'timestamp': '2024-01-15T10:30:00Z',
-        'send_to': '/test/text',
-        'msg_purpose': 'test',
-        'sender_name': 'mpy-text-test',
-        'sender_id': _generate_uuid(),
-        'receiver_name': 'mpy-receiver',
-        'receiver_id': _generate_uuid(),
-        'reply_to': '',
-        'reply_to_msg_id': '',
-        'broker_url': TEST_BROKER_URL,
-        'metadata': {},
-        'payloads': [
-            {
-                'id': _generate_uuid(),
-                'dataname': 'message',
-                'payload_type': 'text',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(test_text.encode('utf8')),
-                'data': base64.b64encode(test_text.encode('utf8')).decode('ascii'),
-                'metadata': {'payload_bytes': len(test_text.encode('utf8'))}
-            }
-        ]
-    }
-    
-    mock_msg = {
-        'payload': json.dumps(test_data)
-    }
-    
-    print('Mock Message Created:')
-    print(f'  Correlation ID: {test_data["correlation_id"]}')
-    print(f'  Payloads: {len(test_data["payloads"])}')
-    print(f'  Payload dataname: {test_data["payloads"][0]["dataname"]}')
-    print(f'  Payload type: {test_data["payloads"][0]["payload_type"]}')
-    print(f'  Transport: {test_data["payloads"][0]["transport"]}\n')
-    
-    try:
-        # Receive and process the message
-        print('Receiving and processing message...')
-        env = smartreceive(
-            mock_msg,
-            max_retries=3,
-            base_delay=100,
-            max_delay=1000
-        )
-        
-        print('\n=== Received Envelope ===')
-        print(f'Correlation ID: {env["correlation_id"]}')
-        print(f'Message ID: {env["msg_id"]}')
-        print(f'Timestamp: {env["timestamp"]}')
-        print(f'Subject: {env["send_to"]}')
-        print(f'Payloads: {len(env["payloads"])}\n')
-        
-        # Validate received data
-        print('=== Validation ===')
-        passed = True
-        
-        if not env.get('correlation_id'):
-            print('❌ correlation_id is missing')
-            passed = False
-        else:
-            print('✅ correlation_id present')
-        
-        if len(env['payloads']) != 1:
-            print(f'❌ Expected 1 payload, got {len(env["payloads"])}')
-            passed = False
-        else:
-            print('✅ Correct number of payloads')
-        
-        payload = env['payloads'][0]
-        if payload[0] != 'message':
-            print(f"❌ Expected dataname 'message', got '{payload[0]}'")
-            passed = False
-        else:
-            print('✅ Correct dataname')
-        
-        if payload[2] != 'text':
-            print(f"❌ Expected type 'text', got '{payload[2]}'")
-            passed = False
-        else:
-            print('✅ Correct type')
-        
-        if payload[1] != test_text:
-            print('❌ Data mismatch')
-            print(f'   Expected: {test_text}')
-            print(f'   Got: {payload[1]}')
-            passed = False
-        else:
-            print('✅ Data correctly deserialized')
-        
-        # Test with multiple text payloads
-        print('\n=== Multiple Text Payloads Test ===')
-        multi_test_data = {
-            'correlation_id': 'multi-receiver-' + _generate_uuid(),
-            'msg_id': _generate_uuid(),
-            'timestamp': '2024-01-15T10:30:00Z',
-            'send_to': '/test/text',
-            'msg_purpose': 'test',
-            'sender_name': 'mpy-text-test',
-            'sender_id': _generate_uuid(),
-            'receiver_name': 'mpy-receiver',
-            'receiver_id': _generate_uuid(),
-            'reply_to': '',
-            'reply_to_msg_id': '',
-            'broker_url': TEST_BROKER_URL,
-            'metadata': {},
-            'payloads': [
-                {
-                    'id': _generate_uuid(),
-                    'dataname': 'msg1',
-                    'payload_type': 'text',
-                    'transport': 'direct',
-                    'encoding': 'base64',
-                    'size': 16,
-                    'data': base64.b64encode(b'First message').decode('ascii'),
-                    'metadata': {'payload_bytes': 16}
-                },
-                {
-                    'id': _generate_uuid(),
-                    'dataname': 'msg2',
-                    'payload_type': 'text',
-                    'transport': 'direct',
-                    'encoding': 'base64',
-                    'size': 16,
-                    'data': base64.b64encode(b'Second message').decode('ascii'),
-                    'metadata': {'payload_bytes': 16}
-                },
-                {
-                    'id': _generate_uuid(),
-                    'dataname': 'msg3',
-                    'payload_type': 'text',
-                    'transport': 'direct',
-                    'encoding': 'base64',
-                    'size': 16,
-                    'data': base64.b64encode(b'Third message').decode('ascii'),
-                    'metadata': {'payload_bytes': 16}
-                }
-            ]
-        }
-        
-        mock_multi_msg = {'payload': json.dumps(multi_test_data)}
-        multi_env = smartreceive(mock_multi_msg)
-        
-        if len(multi_env['payloads']) == 3:
-            print('✅ Multiple payloads handled correctly')
-            
-            # Verify each payload
-            expected_messages = ['First message', 'Second message', 'Third message']
-            for i in range(3):
-                if multi_env['payloads'][i][1] == expected_messages[i]:
-                    print(f'✅ Payload {i + 1} correctly deserialized')
-                else:
-                    print(f'❌ Payload {i + 1} mismatch')
-                    passed = False
-        else:
-            print(f'❌ Expected 3 payloads, got {len(multi_env["payloads"])}')
-            passed = False
-        
-        # Final result
-        print('\n=== Test Result ===')
-        if passed:
-            print('✅ ALL TESTS PASSED')
-            sys.exit(0)
-        else:
-            print('❌ SOME TESTS FAILED')
-            sys.exit(1)
-            
-    except Exception as e:
-        print(f'❌ Test failed with error: {e}')
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    run_test()

test/test_mpy_text_sender.py

@@ -1,205 +0,0 @@
-"""
-MicroPython Text Sender Test
-Tests the smartsend function with text payloads
-
-Note: This test is designed for both MicroPython and desktop Python
-for compatibility testing.
-"""
-
-import sys
-import os
-
-# Add parent directory to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from natbridge_mpy import smartsend, DEFAULT_BROKER_URL, DEFAULT_FILESERVER_URL, DEFAULT_SIZE_THRESHOLD, MAX_PAYLOAD_SIZE
-
-TEST_SUBJECT = '/test/text'
-TEST_BROKER_URL = os.environ.get('NATS_URL', 'nats://localhost:4222')
-TEST_FILESERVER_URL = os.environ.get('FILESERVER_URL', 'http://localhost:8080')
-
-
-def run_test():
-    print('=== MicroPython Text Sender Test ===\n')
-    
-    from natbridge_mpy import _generate_uuid
-    correlation_id = 'mpy-text-test-' + _generate_uuid()
-    print(f'Correlation ID: {correlation_id}')
-    print(f'Subject: {TEST_SUBJECT}')
-    print(f'Broker URL: {TEST_BROKER_URL}')
-    print(f'Default Size Threshold: {DEFAULT_SIZE_THRESHOLD} bytes')
-    print(f'Max Payload Size: {MAX_PAYLOAD_SIZE} bytes\n')
-    
-    # Test data
-    text_data = 'Hello, NATSBridge! This is a test message.'
-    test_data = [
-        ('message', text_data, 'text')
-    ]
-    
-    try:
-        # Send the message
-        print('Sending text payload...')
-        env, env_json_str = smartsend(
-            TEST_SUBJECT,
-            test_data,
-            broker_url=TEST_BROKER_URL,
-            fileserver_url=TEST_FILESERVER_URL,
-            correlation_id=correlation_id,
-            msg_purpose='test',
-            sender_name='mpy-text-test',
-            is_publish=False  # Don't actually publish for this test
-        )
-        
-        print('\n=== Envelope Created ===')
-        print(f'Correlation ID: {env["correlation_id"]}')
-        print(f'Message ID: {env["msg_id"]}')
-        print(f'Timestamp: {env["timestamp"]}')
-        print(f'Subject: {env["send_to"]}')
-        print(f'Purpose: {env["msg_purpose"]}')
-        print(f'Sender: {env["sender_name"]}')
-        print(f'Payloads: {len(env["payloads"])}\n')
-        
-        # Validate envelope structure
-        print('=== Validation ===')
-        passed = True
-        
-        if not env.get('correlation_id'):
-            print('❌ correlation_id is missing')
-            passed = False
-        else:
-            print('✅ correlation_id present')
-        
-        if not env.get('msg_id'):
-            print('❌ msg_id is missing')
-            passed = False
-        else:
-            print('✅ msg_id present')
-        
-        if not env.get('timestamp'):
-            print('❌ timestamp is missing')
-            passed = False
-        else:
-            print('✅ timestamp present')
-        
-        if len(env['payloads']) != 1:
-            print(f'❌ Expected 1 payload, got {len(env["payloads"])}')
-            passed = False
-        else:
-            print('✅ Correct number of payloads')
-        
-        payload = env['payloads'][0]
-        if payload['dataname'] != 'message':
-            print(f"❌ Expected dataname 'message', got '{payload['dataname']}'")
-            passed = False
-        else:
-            print('✅ Correct dataname')
-        
-        if payload['payload_type'] != 'text':
-            print(f"❌ Expected payload_type 'text', got '{payload['payload_type']}'")
-            passed = False
-        else:
-            print('✅ Correct payload_type')
-        
-        if payload['transport'] != 'direct':
-            print(f"❌ Expected transport 'direct', got '{payload['transport']}'")
-            passed = False
-        else:
-            print('✅ Correct transport')
-        
-        if payload['encoding'] != 'base64':
-            print(f"❌ Expected encoding 'base64', got '{payload['encoding']}'")
-            passed = False
-        else:
-            print('✅ Correct encoding')
-        
-        # Decode and verify the data
-        import base64
-        decoded_data = base64.b64decode(payload['data']).decode('ascii')
-        if decoded_data != text_data:
-            print('❌ Decoded data mismatch')
-            print(f'   Expected: {text_data}')
-            print(f'   Got: {decoded_data}')
-            passed = False
-        else:
-            print('✅ Data integrity verified')
-        
-        print(f'\nPayload size: {payload["size"]} bytes')
-        print(f'Base64 data length: {len(payload["data"])} chars')
-        
-        # Test with multiple text payloads
-        print('\n=== Multiple Text Payloads Test ===')
-        multi_test_data = [
-            ('msg1', 'First message', 'text'),
-            ('msg2', 'Second message', 'text'),
-            ('msg3', 'Third message', 'text')
-        ]
-        
-        multi_env, _ = smartsend(
-            TEST_SUBJECT,
-            multi_test_data,
-            broker_url=TEST_BROKER_URL,
-            fileserver_url=TEST_FILESERVER_URL,
-            correlation_id='multi-test-' + correlation_id,
-            is_publish=False
-        )
-        
-        if len(multi_env['payloads']) == 3:
-            print('✅ Multiple payloads handled correctly')
-        else:
-            print(f'❌ Expected 3 payloads, got {len(multi_env["payloads"])}')
-            passed = False
-        
-        # Test size threshold enforcement
-        print('\n=== Size Threshold Test ===')
-        small_text = 'small'
-        large_text = 'x' * (DEFAULT_SIZE_THRESHOLD - 100)  # Just under threshold
-        
-        small_env, _ = smartsend(
-            TEST_SUBJECT,
-            [('small', small_text, 'text')],
-            broker_url=TEST_BROKER_URL,
-            is_publish=False
-        )
-        
-        if small_env['payloads'][0]['transport'] == 'direct':
-            print('✅ Small payload uses direct transport')
-        else:
-            print('❌ Small payload should use direct transport')
-            passed = False
-        
-        # Test that large text (> MAX_PAYLOAD_SIZE) raises error
-        print('\n=== Max Payload Size Test ===')
-        try:
-            too_large_text = 'x' * (MAX_PAYLOAD_SIZE + 1000)
-            large_env, _ = smartsend(
-                TEST_SUBJECT,
-                [('large', too_large_text, 'text')],
-                broker_url=TEST_BROKER_URL,
-                is_publish=False
-            )
-            print('❌ Should have raised MemoryError for payload exceeding MAX_PAYLOAD_SIZE')
-            passed = False
-        except MemoryError as e:
-            print(f'✅ Correctly raised MemoryError: {e}')
-        except Exception as e:
-            print(f'❌ Unexpected error: {type(e).__name__}: {e}')
-            passed = False
-        
-        # Final result
-        print('\n=== Test Result ===')
-        if passed:
-            print('✅ ALL TESTS PASSED')
-            sys.exit(0)
-        else:
-            print('❌ SOME TESTS FAILED')
-            sys.exit(1)
-            
-    except Exception as e:
-        print(f'❌ Test failed with error: {e}')
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    run_test()

test/test_py_binary_receiver.py

@@ -1,184 +0,0 @@
-"""
-Python Binary Receiver Test
-Tests the smartreceive function with binary/image/audio/video/table payloads
-"""
-
-import asyncio
-import sys
-import os
-import json
-import base64
-
-# Add parent directory to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from natbridge import smartreceive, DEFAULT_BROKER_URL, DEFAULT_FILESERVER_URL
-
-TEST_BROKER_URL = os.environ.get('NATS_URL', 'nats://localhost:4222')
-TEST_FILESERVER_URL = os.environ.get('FILESERVER_URL', 'http://localhost:8080')
-
-
-async def run_test():
-    print('=== Python Binary Receiver Test ===\n')
-    
-    # Create mock NATS message with binary payloads
-    image_data = bytes([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A])  # PNG header
-    audio_data = bytes([0x46, 0x4C, 0x41, 0x43, 0x00, 0x00, 0x00, 0x00])  # FLAC header
-    video_data = bytes([0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70])  # MP4 header
-    generic_binary = bytes([0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE])
-    
-    test_data = {
-        'correlation_id': 'py-binary-receiver-' + str(asyncio.get_event_loop().time() * 1000000),
-        'msg_id': 'msg-' + str(asyncio.get_event_loop().time() * 1000000),
-        'timestamp': asyncio.get_event_loop().time().isoformat(),
-        'send_to': '/test/binary',
-        'msg_purpose': 'test',
-        'sender_name': 'py-binary-test',
-        'sender_id': 'sender-' + str(asyncio.get_event_loop().time() * 1000000),
-        'receiver_name': 'py-receiver',
-        'receiver_id': 'receiver-' + str(asyncio.get_event_loop().time() * 1000000),
-        'reply_to': '',
-        'reply_to_msg_id': '',
-        'broker_url': TEST_BROKER_URL,
-        'metadata': {},
-        'payloads': [
-            {
-                'id': 'payload-1',
-                'dataname': 'image',
-                'payload_type': 'image',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(image_data),
-                'data': base64.b64encode(image_data).decode('ascii'),
-                'metadata': {'payload_bytes': len(image_data)}
-            },
-            {
-                'id': 'payload-2',
-                'dataname': 'audio',
-                'payload_type': 'audio',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(audio_data),
-                'data': base64.b64encode(audio_data).decode('ascii'),
-                'metadata': {'payload_bytes': len(audio_data)}
-            },
-            {
-                'id': 'payload-3',
-                'dataname': 'video',
-                'payload_type': 'video',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(video_data),
-                'data': base64.b64encode(video_data).decode('ascii'),
-                'metadata': {'payload_bytes': len(video_data)}
-            },
-            {
-                'id': 'payload-4',
-                'dataname': 'binary',
-                'payload_type': 'binary',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(generic_binary),
-                'data': base64.b64encode(generic_binary).decode('ascii'),
-                'metadata': {'payload_bytes': len(generic_binary)}
-            }
-        ]
-    }
-    
-    mock_msg = {
-        'payload': json.dumps(test_data)
-    }
-    
-    print('Mock Message Created:')
-    print(f'  Correlation ID: {test_data["correlation_id"]}')
-    print(f'  Payloads: {len(test_data["payloads"])}')
-    print(f'  Payload types: {", ".join(p["payload_type"] for p in test_data["payloads"])}\n')
-    
-    try:
-        # Receive and process the message
-        print('Receiving and processing message...')
-        env = await smartreceive(
-            mock_msg,
-            max_retries=3,
-            base_delay=100,
-            max_delay=1000
-        )
-        
-        print('\n=== Received Envelope ===')
-        print(f'Correlation ID: {env["correlation_id"]}')
-        print(f'Message ID: {env["msg_id"]}')
-        print(f'Timestamp: {env["timestamp"]}')
-        print(f'Subject: {env["send_to"]}')
-        print(f'Payloads: {len(env["payloads"])}\n')
-        
-        # Validate received data
-        print('=== Validation ===')
-        passed = True
-        
-        if not env.get('correlation_id'):
-            print('❌ correlation_id is missing')
-            passed = False
-        else:
-            print('✅ correlation_id present')
-        
-        if len(env['payloads']) != 4:
-            print(f'❌ Expected 4 payloads, got {len(env["payloads"])}')
-            passed = False
-        else:
-            print('✅ Correct number of payloads')
-        
-        # Expected data
-        expected_data = [
-            ('image', image_data, 'image'),
-            ('audio', audio_data, 'audio'),
-            ('video', video_data, 'video'),
-            ('binary', generic_binary, 'binary')
-        ]
-        
-        for i in range(len(env['payloads'])):
-            payload = env['payloads'][i]
-            expected = expected_data[i]
-            
-            if payload[0] != expected[0]:
-                print(f"❌ Payload {i + 1}: Expected dataname '{expected[0]}', got '{payload[0]}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct dataname')
-            
-            if payload[2] != expected[2]:
-                print(f"❌ Payload {i + 1}: Expected type '{expected[2]}', got '{payload[2]}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct type')
-            
-            # Verify binary data integrity
-            received_data = payload[1]
-            if not isinstance(received_data, (bytes, bytearray)):
-                print(f'❌ Payload {i + 1}: Expected bytes/bytearray, got {type(received_data)}')
-                passed = False
-            elif received_data != expected[1]:
-                print(f'❌ Payload {i + 1}: Data mismatch')
-                print(f'   Expected: {expected[1]}')
-                print(f'   Got: {received_data}')
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Data correctly deserialized')
-        
-        # Final result
-        print('\n=== Test Result ===')
-        if passed:
-            print('✅ ALL TESTS PASSED')
-            sys.exit(0)
-        else:
-            print('❌ SOME TESTS FAILED')
-            sys.exit(1)
-            
-    except Exception as e:
-        print(f'❌ Test failed with error: {e}')
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    asyncio.run(run_test())

test/test_py_binary_sender.py

@@ -1,183 +0,0 @@
-"""
-Python Binary Sender Test
-Tests the smartsend function with binary/image/audio/video/table payloads
-"""
-
-import asyncio
-import sys
-import os
-import base64
-
-# Add parent directory to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from natbridge import smartsend, DEFAULT_BROKER_URL, DEFAULT_FILESERVER_URL
-
-TEST_SUBJECT = '/test/binary'
-TEST_BROKER_URL = os.environ.get('NATS_URL', 'nats://localhost:4222')
-TEST_FILESERVER_URL = os.environ.get('FILESERVER_URL', 'http://localhost:8080')
-
-
-async def run_test():
-    print('=== Python Binary Sender Test ===\n')
-    
-    correlation_id = 'py-binary-test-' + str(asyncio.get_event_loop().time() * 1000000)
-    print(f'Correlation ID: {correlation_id}')
-    print(f'Subject: {TEST_SUBJECT}')
-    print(f'Broker URL: {TEST_BROKER_URL}\n')
-    
-    # Test data - binary data for different types
-    image_data = bytes([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A])  # PNG header
-    audio_data = bytes([0x46, 0x4C, 0x41, 0x43, 0x00, 0x00, 0x00, 0x00])  # FLAC header
-    video_data = bytes([0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70])  # MP4 header
-    generic_binary = bytes([0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE, 0xBA, 0xBE])
-    
-    # Test table data
-    try:
-        import pandas as pd
-        table_data = pd.DataFrame({
-            'id': [1, 2, 3, 4, 5],
-            'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
-            'value': [10.5, 20.3, 30.1, 40.9, 50.7]
-        })
-        table_available = True
-    except ImportError:
-        table_available = False
-        table_data = None
-    
-    test_data = [
-        ('image', image_data, 'image'),
-        ('audio', audio_data, 'audio'),
-        ('video', video_data, 'video'),
-        ('binary', generic_binary, 'binary')
-    ]
-    
-    if table_available:
-        test_data.append(('table', table_data, 'table'))
-    
-    try:
-        # Send the message
-        print('Sending binary payloads...')
-        env, env_json_str = await smartsend(
-            TEST_SUBJECT,
-            test_data,
-            broker_url=TEST_BROKER_URL,
-            fileserver_url=TEST_FILESERVER_URL,
-            correlation_id=correlation_id,
-            msg_purpose='test',
-            sender_name='py-binary-test',
-            is_publish=False
-        )
-        
-        print('\n=== Envelope Created ===')
-        print(f'Correlation ID: {env["correlation_id"]}')
-        print(f'Message ID: {env["msg_id"]}')
-        print(f'Timestamp: {env["timestamp"]}')
-        print(f'Subject: {env["send_to"]}')
-        print(f'Purpose: {env["msg_purpose"]}')
-        print(f'Sender: {env["sender_name"]}')
-        print(f'Payloads: {len(env["payloads"])}\n')
-        
-        # Validate envelope structure
-        print('=== Validation ===')
-        passed = True
-        
-        expected_count = 5 if table_available else 4
-        if len(env['payloads']) != expected_count:
-            print(f'❌ Expected {expected_count} payloads, got {len(env["payloads"])}')
-            passed = False
-        else:
-            print('✅ Correct number of payloads')
-        
-        # Test each payload
-        expected_datanames = ['image', 'audio', 'video', 'binary']
-        expected_types = ['image', 'audio', 'video', 'binary']
-        expected_data = [image_data, audio_data, video_data, generic_binary]
-        
-        if table_available:
-            expected_datanames.append('table')
-            expected_types.append('table')
-        
-        for i in range(len(env['payloads'])):
-            payload = env['payloads'][i]
-            
-            if payload['dataname'] != expected_datanames[i]:
-                print(f"❌ Payload {i + 1}: Expected dataname '{expected_datanames[i]}', got '{payload['dataname']}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct dataname')
-            
-            if payload['payload_type'] != expected_types[i]:
-                print(f"❌ Payload {i + 1}: Expected type '{expected_types[i]}', got '{payload['payload_type']}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct type')
-            
-            if payload['transport'] != 'direct':
-                print(f"❌ Payload {i + 1}: Expected transport 'direct', got '{payload['transport']}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct transport')
-            
-            if payload['encoding'] != 'base64':
-                print(f"❌ Payload {i + 1}: Expected encoding 'base64', got '{payload['encoding']}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct encoding')
-            
-            # Decode and verify the data
-            decoded_data = base64.b64decode(payload['data'])
-            
-            if i < len(expected_data):
-                original_data = expected_data[i]
-                if decoded_data != original_data:
-                    print(f'❌ Payload {i + 1}: Data integrity mismatch')
-                    passed = False
-                else:
-                    print(f'✅ Payload {i + 1}: Data integrity verified')
-            else:
-                # Table payload - just verify it's present
-                print(f'✅ Payload {i + 1}: Table data present (size: {payload["size"]} bytes)')
-            
-            print(f'   Size: {payload["size"]} bytes\n')
-        
-        # Test with larger binary data
-        print('=== Large Binary Data Test ===')
-        large_data = bytes([0xFF] * 10000)  # 10KB of binary data
-        large_test_data = [
-            ('large_binary', large_data, 'binary')
-        ]
-        
-        large_env, _ = await smartsend(
-            TEST_SUBJECT,
-            large_test_data,
-            broker_url=TEST_BROKER_URL,
-            fileserver_url=TEST_FILESERVER_URL,
-            correlation_id='large-' + correlation_id,
-            is_publish=False
-        )
-        
-        if len(large_env['payloads']) == 1 and large_env['payloads'][0]['size'] == 10000:
-            print('✅ Large binary data handled correctly')
-        else:
-            print('❌ Large binary data handling failed')
-            passed = False
-        
-        # Final result
-        print('\n=== Test Result ===')
-        if passed:
-            print('✅ ALL TESTS PASSED')
-            sys.exit(0)
-        else:
-            print('❌ SOME TESTS FAILED')
-            sys.exit(1)
-            
-    except Exception as e:
-        print(f'❌ Test failed with error: {e}')
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    asyncio.run(run_test())

test/test_py_dictionary_receiver.py

@@ -1,220 +0,0 @@
-"""
-Python Dictionary Receiver Test
-Tests the smartreceive function with dictionary payloads
-"""
-
-import asyncio
-import sys
-import os
-import json
-
-# Add parent directory to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from natbridge import smartreceive, DEFAULT_BROKER_URL, DEFAULT_FILESERVER_URL
-
-TEST_BROKER_URL = os.environ.get('NATS_URL', 'nats://localhost:4222')
-TEST_FILESERVER_URL = os.environ.get('FILESERVER_URL', 'http://localhost:8080')
-
-
-async def run_test():
-    print('=== Python Dictionary Receiver Test ===\n')
-    
-    # Create a mock NATS message with dictionary payloads
-    import base64
-    
-    simple_dict = {'key1': 'value1', 'key2': 'value2'}
-    nested_dict = {'outer': {'inner': 'value', 'number': 42}}
-    array_dict = {'items': [1, 2, 3, 'four', 'five']}
-    mixed_dict = {'string': 'text', 'number': 123, 'boolean': True, 'null_val': None}
-    
-    test_data = {
-        'correlation_id': 'py-receiver-dict-' + str(asyncio.get_event_loop().time() * 1000000),
-        'msg_id': 'msg-' + str(asyncio.get_event_loop().time() * 1000000),
-        'timestamp': asyncio.get_event_loop().time().isoformat(),
-        'send_to': '/test/dictionary',
-        'msg_purpose': 'test',
-        'sender_name': 'py-dict-test',
-        'sender_id': 'sender-' + str(asyncio.get_event_loop().time() * 1000000),
-        'receiver_name': 'py-receiver',
-        'receiver_id': 'receiver-' + str(asyncio.get_event_loop().time() * 1000000),
-        'reply_to': '',
-        'reply_to_msg_id': '',
-        'broker_url': TEST_BROKER_URL,
-        'metadata': {},
-        'payloads': [
-            {
-                'id': 'payload-1',
-                'dataname': 'simple_dict',
-                'payload_type': 'dictionary',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(json.dumps(simple_dict).encode('utf8')),
-                'data': base64.b64encode(json.dumps(simple_dict).encode('utf8')).decode('ascii'),
-                'metadata': {'payload_bytes': len(json.dumps(simple_dict).encode('utf8'))}
-            },
-            {
-                'id': 'payload-2',
-                'dataname': 'nested_dict',
-                'payload_type': 'dictionary',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(json.dumps(nested_dict).encode('utf8')),
-                'data': base64.b64encode(json.dumps(nested_dict).encode('utf8')).decode('ascii'),
-                'metadata': {'payload_bytes': len(json.dumps(nested_dict).encode('utf8'))}
-            },
-            {
-                'id': 'payload-3',
-                'dataname': 'array_dict',
-                'payload_type': 'dictionary',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(json.dumps(array_dict).encode('utf8')),
-                'data': base64.b64encode(json.dumps(array_dict).encode('utf8')).decode('ascii'),
-                'metadata': {'payload_bytes': len(json.dumps(array_dict).encode('utf8'))}
-            },
-            {
-                'id': 'payload-4',
-                'dataname': 'mixed_dict',
-                'payload_type': 'dictionary',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(json.dumps(mixed_dict).encode('utf8')),
-                'data': base64.b64encode(json.dumps(mixed_dict).encode('utf8')).decode('ascii'),
-                'metadata': {'payload_bytes': len(json.dumps(mixed_dict).encode('utf8'))}
-            }
-        ]
-    }
-    
-    mock_msg = {
-        'payload': json.dumps(test_data)
-    }
-    
-    print('Mock Message Created:')
-    print(f'  Correlation ID: {test_data["correlation_id"]}')
-    print(f'  Payloads: {len(test_data["payloads"])}')
-    print(f'  Payload types: {", ".join(p["payload_type"] for p in test_data["payloads"])}\n')
-    
-    try:
-        # Receive and process the message
-        print('Receiving and processing message...')
-        env = await smartreceive(
-            mock_msg,
-            max_retries=3,
-            base_delay=100,
-            max_delay=1000
-        )
-        
-        print('\n=== Received Envelope ===')
-        print(f'Correlation ID: {env["correlation_id"]}')
-        print(f'Message ID: {env["msg_id"]}')
-        print(f'Timestamp: {env["timestamp"]}')
-        print(f'Subject: {env["send_to"]}')
-        print(f'Payloads: {len(env["payloads"])}\n')
-        
-        # Validate received data
-        print('=== Validation ===')
-        passed = True
-        
-        if not env.get('correlation_id'):
-            print('❌ correlation_id is missing')
-            passed = False
-        else:
-            print('✅ correlation_id present')
-        
-        if len(env['payloads']) != 4:
-            print(f'❌ Expected 4 payloads, got {len(env["payloads"])}')
-            passed = False
-        else:
-            print('✅ Correct number of payloads')
-        
-        # Expected data
-        expected_data = [
-            ('simple_dict', simple_dict, 'dictionary'),
-            ('nested_dict', nested_dict, 'dictionary'),
-            ('array_dict', array_dict, 'dictionary'),
-            ('mixed_dict', mixed_dict, 'dictionary')
-        ]
-        
-        for i in range(len(env['payloads'])):
-            payload = env['payloads'][i]
-            expected = expected_data[i]
-            
-            if payload[0] != expected[0]:
-                print(f"❌ Payload {i + 1}: Expected dataname '{expected[0]}', got '{payload[0]}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct dataname')
-            
-            if payload[2] != expected[2]:
-                print(f"❌ Payload {i + 1}: Expected type '{expected[2]}', got '{payload[2]}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct type')
-            
-            data_match = json.dumps(payload[1], sort_keys=True) == json.dumps(expected[1], sort_keys=True)
-            if not data_match:
-                print(f'❌ Payload {i + 1}: Data mismatch')
-                print(f'   Expected: {json.dumps(expected[1], sort_keys=True)}')
-                print(f'   Got: {json.dumps(payload[1], sort_keys=True)}')
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Data correctly deserialized')
-        
-        # Test round-trip with receive
-        print('\n=== Round-trip Test ===')
-        round_trip_data = {
-            'correlation_id': 'roundtrip-' + str(asyncio.get_event_loop().time() * 1000000),
-            'msg_id': 'msg-' + str(asyncio.get_event_loop().time() * 1000000),
-            'timestamp': asyncio.get_event_loop().time().isoformat(),
-            'send_to': '/test/dictionary',
-            'msg_purpose': 'test',
-            'sender_name': 'py-test',
-            'sender_id': 'sender-' + str(asyncio.get_event_loop().time() * 1000000),
-            'receiver_name': 'py-receiver',
-            'receiver_id': 'receiver-' + str(asyncio.get_event_loop().time() * 1000000),
-            'reply_to': '',
-            'reply_to_msg_id': '',
-            'broker_url': TEST_BROKER_URL,
-            'metadata': {},
-            'payloads': [
-                {
-                    'id': 'payload-rt',
-                    'dataname': 'roundtrip',
-                    'payload_type': 'dictionary',
-                    'transport': 'direct',
-                    'encoding': 'base64',
-                    'size': len(json.dumps({'test': 'data', 'nested': {'a': 1, 'b': 2}}).encode('utf8')),
-                    'data': base64.b64encode(json.dumps({'test': 'data', 'nested': {'a': 1, 'b': 2}}).encode('utf8')).decode('ascii'),
-                    'metadata': {'payload_bytes': len(json.dumps({'test': 'data', 'nested': {'a': 1, 'b': 2}}).encode('utf8'))}
-                }
-            ]
-        }
-        
-        mock_rt_msg = {'payload': json.dumps(round_trip_data)}
-        rt_env = await smartreceive(mock_rt_msg)
-        
-        if rt_env['payloads'][0][0] == 'roundtrip' and rt_env['payloads'][0][2] == 'dictionary':
-            print('✅ Round-trip test successful')
-        else:
-            print('❌ Round-trip test failed')
-            passed = False
-        
-        # Final result
-        print('\n=== Test Result ===')
-        if passed:
-            print('✅ ALL TESTS PASSED')
-            sys.exit(0)
-        else:
-            print('❌ SOME TESTS FAILED')
-            sys.exit(1)
-            
-    except Exception as e:
-        print(f'❌ Test failed with error: {e}')
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    asyncio.run(run_test())

test/test_py_dictionary_sender.py

@@ -1,172 +0,0 @@
-"""
-Python Dictionary Sender Test
-Tests the smartsend function with dictionary payloads
-"""
-
-import asyncio
-import sys
-import os
-import json
-
-# Add parent directory to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from natbridge import smartsend, DEFAULT_BROKER_URL, DEFAULT_FILESERVER_URL
-
-TEST_SUBJECT = '/test/dictionary'
-TEST_BROKER_URL = os.environ.get('NATS_URL', 'nats://localhost:4222')
-TEST_FILESERVER_URL = os.environ.get('FILESERVER_URL', 'http://localhost:8080')
-
-
-async def run_test():
-    print('=== Python Dictionary Sender Test ===\n')
-    
-    correlation_id = 'py-dict-test-' + str(asyncio.get_event_loop().time() * 1000000)
-    print(f'Correlation ID: {correlation_id}')
-    print(f'Subject: {TEST_SUBJECT}')
-    print(f'Broker URL: {TEST_BROKER_URL}\n')
-    
-    # Test data - various dictionary structures
-    test_data = [
-        ('simple_dict', {'key1': 'value1', 'key2': 'value2'}, 'dictionary'),
-        ('nested_dict', {'outer': {'inner': 'value', 'number': 42}}, 'dictionary'),
-        ('array_dict', {'items': [1, 2, 3, 'four', 'five']}, 'dictionary'),
-        ('mixed_dict', {'string': 'text', 'number': 123, 'boolean': True, 'null_val': None}, 'dictionary')
-    ]
-    
-    try:
-        # Send the message
-        print('Sending dictionary payloads...')
-        env, env_json_str = await smartsend(
-            TEST_SUBJECT,
-            test_data,
-            broker_url=TEST_BROKER_URL,
-            fileserver_url=TEST_FILESERVER_URL,
-            correlation_id=correlation_id,
-            msg_purpose='test',
-            sender_name='py-dict-test',
-            is_publish=False
-        )
-        
-        print('\n=== Envelope Created ===')
-        print(f'Correlation ID: {env["correlation_id"]}')
-        print(f'Message ID: {env["msg_id"]}')
-        print(f'Timestamp: {env["timestamp"]}')
-        print(f'Subject: {env["send_to"]}')
-        print(f'Purpose: {env["msg_purpose"]}')
-        print(f'Sender: {env["sender_name"]}')
-        print(f'Payloads: {len(env["payloads"])}\n')
-        
-        # Validate envelope structure
-        print('=== Validation ===')
-        passed = True
-        
-        if len(env['payloads']) != 4:
-            print(f'❌ Expected 4 payloads, got {len(env["payloads"])}')
-            passed = False
-        else:
-            print('✅ Correct number of payloads')
-        
-        # Test each payload
-        expected_datanames = ['simple_dict', 'nested_dict', 'array_dict', 'mixed_dict']
-        expected_types = ['dictionary', 'dictionary', 'dictionary', 'dictionary']
-        
-        for i in range(len(env['payloads'])):
-            payload = env['payloads'][i]
-            
-            if payload['dataname'] != expected_datanames[i]:
-                print(f"❌ Payload {i + 1}: Expected dataname '{expected_datanames[i]}', got '{payload['dataname']}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct dataname')
-            
-            if payload['payload_type'] != expected_types[i]:
-                print(f"❌ Payload {i + 1}: Expected type '{expected_types[i]}', got '{payload['payload_type']}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct type')
-            
-            if payload['transport'] != 'direct':
-                print(f"❌ Payload {i + 1}: Expected transport 'direct', got '{payload['transport']}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct transport')
-            
-            if payload['encoding'] != 'base64':
-                print(f"❌ Payload {i + 1}: Expected encoding 'base64', got '{payload['encoding']}'")
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Correct encoding')
-            
-            # Decode and verify the data
-            import base64
-            decoded_data = json.loads(base64.b64decode(payload['data']).decode('utf8'))
-            original_data = test_data[i][1]
-            
-            # Normalize for comparison (None vs null, True vs true, etc.)
-            if json.dumps(decoded_data, sort_keys=True) != json.dumps(original_data, sort_keys=True):
-                print(f'❌ Payload {i + 1}: Data integrity mismatch')
-                print(f'   Expected: {json.dumps(original_data)}')
-                print(f'   Got: {json.dumps(decoded_data)}')
-                passed = False
-            else:
-                print(f'✅ Payload {i + 1}: Data integrity verified')
-            
-            print(f'   Size: {payload["size"]} bytes\n')
-        
-        # Test round-trip serialization
-        print('=== Round-trip Serialization Test ===')
-        round_trip_data = [
-            ('roundtrip', {'test': 'data', 'numbers': [1, 2, 3], 'nested': {'a': 1, 'b': 2}}, 'dictionary')
-        ]
-        
-        rt_env, _ = await smartsend(
-            TEST_SUBJECT,
-            round_trip_data,
-            broker_url=TEST_BROKER_URL,
-            fileserver_url=TEST_FILESERVER_URL,
-            correlation_id='roundtrip-' + correlation_id,
-            is_publish=False
-        )
-        
-        rt_payload = rt_env['payloads'][0]
-        rt_decoded = json.loads(base64.b64decode(rt_payload['data']).decode('utf8'))
-        
-        if json.dumps(rt_decoded, sort_keys=True) == json.dumps(round_trip_data[0][1], sort_keys=True):
-            print('✅ Round-trip serialization successful')
-        else:
-            print('❌ Round-trip serialization failed')
-            passed = False
-        
-        # Test JSON string output
-        print('\n=== JSON String Output Test ===')
-        try:
-            parsed = json.loads(env_json_str)
-            if parsed['correlation_id'] == env['correlation_id'] and \
-               len(parsed['payloads']) == len(env['payloads']):
-                print('✅ JSON string is valid and matches envelope')
-            else:
-                print('❌ JSON string does not match envelope')
-                passed = False
-        except json.JSONDecodeError as e:
-            print(f'❌ JSON string is invalid: {e}')
-            passed = False
-        
-        # Final result
-        print('\n=== Test Result ===')
-        if passed:
-            print('✅ ALL TESTS PASSED')
-            sys.exit(0)
-        else:
-            print('❌ SOME TESTS FAILED')
-            sys.exit(1)
-            
-    except Exception as e:
-        print(f'❌ Test failed with error: {e}')
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    asyncio.run(run_test())

test/test_py_mix_payloads_sender.py

@@ -11,7 +11,7 @@ import base64
 # Add parent directory to path
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from natbridge import smartsend, DEFAULT_BROKER_URL, DEFAULT_FILESERVER_URL
+from natsbridge import smartsend, DEFAULT_BROKER_URL, DEFAULT_FILESERVER_URL
 
 TEST_SUBJECT = '/test/mix'
 TEST_BROKER_URL = os.environ.get('NATS_URL', 'nats://localhost:4222')

test/test_py_table_sender.py

@@ -1,167 +0,0 @@
-"""
-Python Table Sender Test
-Tests the smartsend function with table (Arrow IPC) payloads
-"""
-
-import asyncio
-import sys
-import os
-
-# Add parent directory to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from natbridge import smartsend, DEFAULT_BROKER_URL, DEFAULT_FILESERVER_URL
-
-TEST_SUBJECT = '/test/table'
-TEST_BROKER_URL = os.environ.get('NATS_URL', 'nats://localhost:4222')
-TEST_FILESERVER_URL = os.environ.get('FILESERVER_URL', 'http://localhost:8080')
-
-
-async def run_test():
-    print('=== Python Table Sender Test ===\n')
-    
-    correlation_id = 'py-table-test-' + str(asyncio.get_event_loop().time() * 1000000)
-    print(f'Correlation ID: {correlation_id}')
-    print(f'Subject: {TEST_SUBJECT}')
-    print(f'Broker URL: {TEST_BROKER_URL}\n')
-    
-    # Test data - pandas DataFrame
-    try:
-        import pandas as pd
-        table_data = pd.DataFrame({
-            'id': [1, 2, 3, 4, 5],
-            'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
-            'age': [30, 25, 35, 28, 32],
-            'active': [True, False, True, True, False]
-        })
-        table_available = True
-    except ImportError:
-        print('❌ pandas not available - skipping table tests')
-        sys.exit(0)
-    
-    test_data = [
-        ('users_table', table_data, 'table')
-    ]
-    
-    try:
-        # Send the message
-        print('Sending table payload...')
-        env, env_json_str = await smartsend(
-            TEST_SUBJECT,
-            test_data,
-            broker_url=TEST_BROKER_URL,
-            fileserver_url=TEST_FILESERVER_URL,
-            correlation_id=correlation_id,
-            msg_purpose='test',
-            sender_name='py-table-test',
-            is_publish=False
-        )
-        
-        print('\n=== Envelope Created ===')
-        print(f'Correlation ID: {env["correlation_id"]}')
-        print(f'Message ID: {env["msg_id"]}')
-        print(f'Timestamp: {env["timestamp"]}')
-        print(f'Subject: {env["send_to"]}')
-        print(f'Purpose: {env["msg_purpose"]}')
-        print(f'Sender: {env["sender_name"]}')
-        print(f'Payloads: {len(env["payloads"])}\n')
-        
-        # Validate envelope structure
-        print('=== Validation ===')
-        passed = True
-        
-        if len(env['payloads']) != 1:
-            print(f'❌ Expected 1 payload, got {len(env["payloads"])}')
-            passed = False
-        else:
-            print('✅ Correct number of payloads')
-        
-        payload = env['payloads'][0]
-        if payload['dataname'] != 'users_table':
-            print(f"❌ Expected dataname 'users_table', got '{payload['dataname']}'")
-            passed = False
-        else:
-            print('✅ Correct dataname')
-        
-        if payload['payload_type'] != 'table':
-            print(f"❌ Expected payload_type 'table', got '{payload['payload_type']}'")
-            passed = False
-        else:
-            print('✅ Correct payload_type')
-        
-        if payload['transport'] != 'direct':
-            print(f"❌ Expected transport 'direct', got '{payload['transport']}'")
-            passed = False
-        else:
-            print('✅ Correct transport')
-        
-        if payload['encoding'] != 'base64':
-            print(f"❌ Expected encoding 'base64', got '{payload['encoding']}'")
-            passed = False
-        else:
-            print('✅ Correct encoding')
-        
-        print(f'\nPayload size: {payload["size"]} bytes')
-        
-        # Test with larger table
-        print('\n=== Larger Table Test ===')
-        large_table_data = pd.DataFrame({
-            'id': range(100),
-            'name': [f'User{i}' for i in range(100)],
-            'age': [20 + (i % 50) for i in range(100)],
-            'active': [i % 2 == 0 for i in range(100)]
-        })
-        
-        large_test_data = [
-            ('large_table', large_table_data, 'table')
-        ]
-        
-        large_env, _ = await smartsend(
-            TEST_SUBJECT,
-            large_test_data,
-            broker_url=TEST_BROKER_URL,
-            fileserver_url=TEST_FILESERVER_URL,
-            correlation_id='large-' + correlation_id,
-            is_publish=False
-        )
-        
-        if len(large_env['payloads']) == 1:
-            print('✅ Large table handled correctly')
-            print(f'   Size: {large_env["payloads"][0]["size"]} bytes')
-        else:
-            print('❌ Large table handling failed')
-            passed = False
-        
-        # Test JSON string output
-        print('\n=== JSON String Output Test ===')
-        import json
-        try:
-            parsed = json.loads(env_json_str)
-            if parsed['correlation_id'] == env['correlation_id'] and \
-               len(parsed['payloads']) == len(env['payloads']):
-                print('✅ JSON string is valid and matches envelope')
-            else:
-                print('❌ JSON string does not match envelope')
-                passed = False
-        except json.JSONDecodeError as e:
-            print(f'❌ JSON string is invalid: {e}')
-            passed = False
-        
-        # Final result
-        print('\n=== Test Result ===')
-        if passed:
-            print('✅ ALL TESTS PASSED')
-            sys.exit(0)
-        else:
-            print('❌ SOME TESTS FAILED')
-            sys.exit(1)
-            
-    except Exception as e:
-        print(f'❌ Test failed with error: {e}')
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    asyncio.run(run_test())

test/test_py_text_receiver.py

@@ -1,205 +0,0 @@
-"""
-Python Text Receiver Test
-Tests the smartreceive function with text payloads
-"""
-
-import asyncio
-import sys
-import os
-import json
-
-# Add parent directory to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from natbridge import smartreceive, DEFAULT_BROKER_URL, DEFAULT_FILESERVER_URL
-
-TEST_BROKER_URL = os.environ.get('NATS_URL', 'nats://localhost:4222')
-TEST_FILESERVER_URL = os.environ.get('FILESERVER_URL', 'http://localhost:8080')
-
-
-async def run_test():
-    print('=== Python Text Receiver Test ===\n')
-    
-    # Create a mock NATS message with text payload
-    test_text = 'Hello, NATSBridge! This is a test message.'
-    import base64
-    
-    test_data = {
-        'correlation_id': 'py-receiver-test-' + str(asyncio.get_event_loop().time() * 1000000),
-        'msg_id': 'msg-' + str(asyncio.get_event_loop().time() * 1000000),
-        'timestamp': asyncio.get_event_loop().time().isoformat(),
-        'send_to': '/test/text',
-        'msg_purpose': 'test',
-        'sender_name': 'py-text-test',
-        'sender_id': 'sender-' + str(asyncio.get_event_loop().time() * 1000000),
-        'receiver_name': 'py-receiver',
-        'receiver_id': 'receiver-' + str(asyncio.get_event_loop().time() * 1000000),
-        'reply_to': '',
-        'reply_to_msg_id': '',
-        'broker_url': TEST_BROKER_URL,
-        'metadata': {},
-        'payloads': [
-            {
-                'id': 'payload-' + str(asyncio.get_event_loop().time() * 1000000),
-                'dataname': 'message',
-                'payload_type': 'text',
-                'transport': 'direct',
-                'encoding': 'base64',
-                'size': len(test_text.encode('utf8')),
-                'data': base64.b64encode(test_text.encode('utf8')).decode('ascii'),
-                'metadata': {'payload_bytes': len(test_text.encode('utf8'))}
-            }
-        ]
-    }
-    
-    mock_msg = {
-        'payload': json.dumps(test_data)
-    }
-    
-    print('Mock Message Created:')
-    print(f'  Correlation ID: {test_data["correlation_id"]}')
-    print(f'  Payloads: {len(test_data["payloads"])}')
-    print(f'  Payload dataname: {test_data["payloads"][0]["dataname"]}')
-    print(f'  Payload type: {test_data["payloads"][0]["payload_type"]}')
-    print(f'  Transport: {test_data["payloads"][0]["transport"]}\n')
-    
-    try:
-        # Receive and process the message
-        print('Receiving and processing message...')
-        env = await smartreceive(
-            mock_msg,
-            max_retries=3,
-            base_delay=100,
-            max_delay=1000
-        )
-        
-        print('\n=== Received Envelope ===')
-        print(f'Correlation ID: {env["correlation_id"]}')
-        print(f'Message ID: {env["msg_id"]}')
-        print(f'Timestamp: {env["timestamp"]}')
-        print(f'Subject: {env["send_to"]}')
-        print(f'Payloads: {len(env["payloads"])}\n')
-        
-        # Validate received data
-        print('=== Validation ===')
-        passed = True
-        
-        if not env.get('correlation_id'):
-            print('❌ correlation_id is missing')
-            passed = False
-        else:
-            print('✅ correlation_id present')
-        
-        if len(env['payloads']) != 1:
-            print(f'❌ Expected 1 payload, got {len(env["payloads"])}')
-            passed = False
-        else:
-            print('✅ Correct number of payloads')
-        
-        payload = env['payloads'][0]
-        if payload[0] != 'message':
-            print(f"❌ Expected dataname 'message', got '{payload[0]}'")
-            passed = False
-        else:
-            print('✅ Correct dataname')
-        
-        if payload[2] != 'text':
-            print(f"❌ Expected type 'text', got '{payload[2]}'")
-            passed = False
-        else:
-            print('✅ Correct type')
-        
-        if payload[1] != test_text:
-            print('❌ Data mismatch')
-            print(f'   Expected: {test_text}')
-            print(f'   Got: {payload[1]}')
-            passed = False
-        else:
-            print('✅ Data correctly deserialized')
-        
-        # Test with multiple text payloads
-        print('\n=== Multiple Text Payloads Test ===')
-        multi_test_data = {
-            'correlation_id': 'multi-receiver-' + str(asyncio.get_event_loop().time() * 1000000),
-            'msg_id': 'msg-' + str(asyncio.get_event_loop().time() * 1000000),
-            'timestamp': asyncio.get_event_loop().time().isoformat(),
-            'send_to': '/test/text',
-            'msg_purpose': 'test',
-            'sender_name': 'py-text-test',
-            'sender_id': 'sender-' + str(asyncio.get_event_loop().time() * 1000000),
-            'receiver_name': 'py-receiver',
-            'receiver_id': 'receiver-' + str(asyncio.get_event_loop().time() * 1000000),
-            'reply_to': '',
-            'reply_to_msg_id': '',
-            'broker_url': TEST_BROKER_URL,
-            'metadata': {},
-            'payloads': [
-                {
-                    'id': 'payload-1',
-                    'dataname': 'msg1',
-                    'payload_type': 'text',
-                    'transport': 'direct',
-                    'encoding': 'base64',
-                    'size': 16,
-                    'data': base64.b64encode(b'First message').decode('ascii'),
-                    'metadata': {'payload_bytes': 16}
-                },
-                {
-                    'id': 'payload-2',
-                    'dataname': 'msg2',
-                    'payload_type': 'text',
-                    'transport': 'direct',
-                    'encoding': 'base64',
-                    'size': 16,
-                    'data': base64.b64encode(b'Second message').decode('ascii'),
-                    'metadata': {'payload_bytes': 16}
-                },
-                {
-                    'id': 'payload-3',
-                    'dataname': 'msg3',
-                    'payload_type': 'text',
-                    'transport': 'direct',
-                    'encoding': 'base64',
-                    'size': 16,
-                    'data': base64.b64encode(b'Third message').decode('ascii'),
-                    'metadata': {'payload_bytes': 16}
-                }
-            ]
-        }
-        
-        mock_multi_msg = {'payload': json.dumps(multi_test_data)}
-        multi_env = await smartreceive(mock_multi_msg)
-        
-        if len(multi_env['payloads']) == 3:
-            print('✅ Multiple payloads handled correctly')
-            
-            # Verify each payload
-            expected_messages = ['First message', 'Second message', 'Third message']
-            for i in range(3):
-                if multi_env['payloads'][i][1] == expected_messages[i]:
-                    print(f'✅ Payload {i + 1} correctly deserialized')
-                else:
-                    print(f'❌ Payload {i + 1} mismatch')
-                    passed = False
-        else:
-            print(f"❌ Expected 3 payloads, got {len(multi_env['payloads'])}")
-            passed = False
-        
-        # Final result
-        print('\n=== Test Result ===')
-        if passed:
-            print('✅ ALL TESTS PASSED')
-            sys.exit(0)
-        else:
-            print('❌ SOME TESTS FAILED')
-            sys.exit(1)
-            
-    except Exception as e:
-        print(f'❌ Test failed with error: {e}')
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    asyncio.run(run_test())

test/test_py_text_sender.py

@@ -1,164 +0,0 @@
-"""
-Python Text Sender Test
-Tests the smartsend function with text payloads
-"""
-
-import asyncio
-import sys
-import os
-
-# Add parent directory to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from natbridge import smartsend, DEFAULT_BROKER_URL, DEFAULT_FILESERVER_URL
-
-TEST_SUBJECT = '/test/text'
-TEST_BROKER_URL = os.environ.get('NATS_URL', 'nats://localhost:4222')
-TEST_FILESERVER_URL = os.environ.get('FILESERVER_URL', 'http://localhost:8080')
-
-
-async def run_test():
-    print('=== Python Text Sender Test ===\n')
-    
-    correlation_id = 'py-text-test-' + str(asyncio.get_event_loop().time() * 1000000)
-    print(f'Correlation ID: {correlation_id}')
-    print(f'Subject: {TEST_SUBJECT}')
-    print(f'Broker URL: {TEST_BROKER_URL}\n')
-    
-    # Test data
-    text_data = 'Hello, NATSBridge! This is a test message.'
-    test_data = [
-        ('message', text_data, 'text')
-    ]
-    
-    try:
-        # Send the message
-        print('Sending text payload...')
-        env, env_json_str = await smartsend(
-            TEST_SUBJECT,
-            test_data,
-            broker_url=TEST_BROKER_URL,
-            fileserver_url=TEST_FILESERVER_URL,
-            correlation_id=correlation_id,
-            msg_purpose='test',
-            sender_name='py-text-test',
-            is_publish=False  # Don't actually publish for this test
-        )
-        
-        print('\n=== Envelope Created ===')
-        print(f'Correlation ID: {env["correlation_id"]}')
-        print(f'Message ID: {env["msg_id"]}')
-        print(f'Timestamp: {env["timestamp"]}')
-        print(f'Subject: {env["send_to"]}')
-        print(f'Purpose: {env["msg_purpose"]}')
-        print(f'Sender: {env["sender_name"]}')
-        print(f'Payloads: {len(env["payloads"])}\n')
-        
-        # Validate envelope structure
-        print('=== Validation ===')
-        passed = True
-        
-        if not env.get('correlation_id'):
-            print('❌ correlation_id is missing')
-            passed = False
-        else:
-            print('✅ correlation_id present')
-        
-        if not env.get('msg_id'):
-            print('❌ msg_id is missing')
-            passed = False
-        else:
-            print('✅ msg_id present')
-        
-        if not env.get('timestamp'):
-            print('❌ timestamp is missing')
-            passed = False
-        else:
-            print('✅ timestamp present')
-        
-        if len(env['payloads']) != 1:
-            print(f'❌ Expected 1 payload, got {len(env["payloads"])}')
-            passed = False
-        else:
-            print('✅ Correct number of payloads')
-        
-        payload = env['payloads'][0]
-        if payload['dataname'] != 'message':
-            print(f"❌ Expected dataname 'message', got '{payload['dataname']}'")
-            passed = False
-        else:
-            print('✅ Correct dataname')
-        
-        if payload['payload_type'] != 'text':
-            print(f"❌ Expected payload_type 'text', got '{payload['payload_type']}'")
-            passed = False
-        else:
-            print('✅ Correct payload_type')
-        
-        if payload['transport'] != 'direct':
-            print(f"❌ Expected transport 'direct', got '{payload['transport']}'")
-            passed = False
-        else:
-            print('✅ Correct transport')
-        
-        if payload['encoding'] != 'base64':
-            print(f"❌ Expected encoding 'base64', got '{payload['encoding']}'")
-            passed = False
-        else:
-            print('✅ Correct encoding')
-        
-        # Decode and verify the data
-        import base64
-        decoded_data = base64.b64decode(payload['data']).decode('utf8')
-        if decoded_data != text_data:
-            print('❌ Decoded data mismatch')
-            print(f'   Expected: {text_data}')
-            print(f'   Got: {decoded_data}')
-            passed = False
-        else:
-            print('✅ Data integrity verified')
-        
-        print(f"\nPayload size: {payload['size']} bytes")
-        print(f'Base64 data length: {len(payload["data"])} chars')
-        
-        # Test with multiple text payloads
-        print('\n=== Multiple Text Payloads Test ===')
-        multi_test_data = [
-            ('msg1', 'First message', 'text'),
-            ('msg2', 'Second message', 'text'),
-            ('msg3', 'Third message', 'text')
-        ]
-        
-        multi_env, _ = await smartsend(
-            TEST_SUBJECT,
-            multi_test_data,
-            broker_url=TEST_BROKER_URL,
-            fileserver_url=TEST_FILESERVER_URL,
-            correlation_id='multi-test-' + correlation_id,
-            is_publish=False
-        )
-        
-        if len(multi_env['payloads']) == 3:
-            print('✅ Multiple payloads handled correctly')
-        else:
-            print(f"❌ Expected 3 payloads, got {len(multi_env['payloads'])}")
-            passed = False
-        
-        # Final result
-        print('\n=== Test Result ===')
-        if passed:
-            print('✅ ALL TESTS PASSED')
-            sys.exit(0)
-        else:
-            print('❌ SOME TESTS FAILED')
-            sys.exit(1)
-            
-    except Exception as e:
-        print(f'❌ Test failed with error: {e}')
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    asyncio.run(run_test())