AI_prompt.txt

@@ -1,103 +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.
-
-
-
-
-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.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

DO_NOT_READ_AI_prompt.txt

@@ -0,0 +1,154 @@
+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 --------------------------------------------- #
+
+
+
+
+
+
+
+
+
+

Project.toml

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

docs/SDD_FRAMEWORK.md

@@ -0,0 +1,402 @@
+# SDD + GitOps Documentation Framework
+
+This document defines the documentation framework for the NATSBridge project. It establishes a structured approach to creating, maintaining, and evolving technical documentation in alignment with GitOps principles—ensuring that documentation is versioned, auditable, and continuously validated alongside the codebase.
+
+---
+
+## The SDD Framework: Seven Pillars of Documentation
+
+| 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. |
+
+---
+
+## Detailed Document Descriptions
+
+### 1. Requirements
+
+**Purpose**: Capture the *business intent* — why we're building this and what success looks like. Defines boundaries and user-visible outcomes.
+
+**Why It Matters**:
+- Aligns engineering efforts with business goals
+- Provides a north star for feature development
+- Establishes acceptance criteria before implementation begins
+- Creates a contract between product and engineering
+
+**Content Guidelines**:
+- User stories with clear acceptance criteria (As a X, I want Y so that Z)
+- Product Requirements Documents (PRDs) with success metrics
+- Non-functional requirements (performance, security, scalability)
+- Boundary definitions (what's in scope vs. out of scope)
+
+**Best Practices**:
+- Link each requirement to a measurable KPI
+- Keep requirements testable and verifiable
+- Maintain backward compatibility with existing requirements
+- Review and update requirements as business context changes
+
+---
+
+### 2. Specification
+
+**Purpose**: The *technical contract* — precise rules for inputs, outputs, and data shape. Ensures consistency across dev and test.
+
+**Why It Matters**:
+- Prevents implementation drift between components
+- Enables contract testing in CI/CD pipelines
+- Provides a single source of truth for data structures
+- Facilitates integration between teams
+
+**Content Guidelines**:
+- API endpoint definitions (methods, paths, parameters)
+- Request/response schemas (JSON, XML, Protobuf, AsyncAPI)
+- Error codes and their meanings
+- Data validation rules and constraints
+- Rate limiting and quota definitions
+
+**Best Practices**:
+- Use formal specification languages (OpenAPI 3.0+, AsyncAPI)
+- Version specifications alongside code
+- Generate client SDKs from specifications
+- Block CI on specification violations
+- Document edge cases and error scenarios
+
+---
+
+### 3. Architecture
+
+**Purpose**: The *blueprint* — how components fit together, interact, and scale. Guides system structure and trade-offs.
+
+**Why It Matters**:
+- Provides a mental model for system design
+- Guides technical decision-making and trade-off analysis
+- Facilitates onboarding of new architects and senior developers
+- Documents scaling and performance considerations
+
+**Content Guidelines**:
+- C4 diagrams (Context, Container, Component levels)
+- Mermaid.js flowcharts for sequence diagrams
+- Component interaction diagrams
+- Network topology and data flow
+- Storage and caching strategies
+- Scaling and resilience patterns
+
+**Best Practices**:
+- Use diagrams that are easy to update (Mermaid.js over static images)
+- Document trade-off decisions with Rationale Documents
+- Include scaling considerations for each component
+- Document failure modes and recovery strategies
+- Keep architecture diagrams versioned with code
+
+---
+
+### 4. Walkthrough
+
+**Purpose**: The *story of flow* — shows how pieces connect end-to-end and why steps are sequenced. Builds intuition for new devs.
+
+**Why It Matters**:
+- Reduces onboarding time for new developers
+- Provides context that code comments alone cannot convey
+- Explains the "why" behind architectural decisions
+- Helps identify gaps in the system design
+
+**Content Guidelines**:
+- Step-by-step flow descriptions with rationale
+- Sequence diagrams showing request/response patterns
+- "Tour of the codebase" guides
+- Video walkthroughs (Loom, internal recordings)
+- Debugging and tracing examples
+
+**Best Practices**:
+- Walk through real user journeys, not just technical flows
+- Include "what could go wrong" scenarios
+- Link walkthroughs to relevant code locations
+- Keep walkthroughs updated with architecture changes
+- Make walkthroughs interactive where possible
+
+---
+
+### 5. Implementation
+
+**Purpose**: The *real code* — business logic, helpers, tests, configs. Where design becomes executable.
+
+**Why It Matters**:
+- This is the actual artifact that runs in production
+- Code is the ultimate source of truth (when it matches spec)
+- Tests validate correctness and prevent regressions
+- Configuration files define runtime behavior
+
+**Content Guidelines**:
+- Business logic implementation
+- Helper functions and utilities
+- Unit and integration tests
+- Configuration files (YAML, JSON, environment)
+- Setup and development scripts
+- Code organization and module structure
+
+**Best Practices**:
+- Follow consistent code style and conventions
+- Write tests before or alongside implementation (TDD/BDD)
+- Document complex logic with inline comments
+- Keep configuration externalized and versioned
+- Use type annotations where applicable
+
+---
+
+### 6. Validation
+
+**Purpose**: The *enforcer* — ensures implementation matches the spec. Blocks drift and human error.
+
+**Why It Matters**:
+- Prevents breaking changes from reaching production
+- Catches specification violations early in the CI pipeline
+- Maintains data integrity and API consistency
+- Reduces manual QA effort through automation
+
+**Content Guidelines**:
+- CI/CD pipeline configurations
+- Contract testing scripts
+- Linting rules and configurations
+- Integration test suites
+- Schema validation jobs
+- Security scanning and audit jobs
+
+**Best Practices**:
+- Fail CI on specification violations
+- Run validation jobs on every commit and PR
+- Use automated code review tools
+- Maintain validation job health dashboard
+- Document validation failure remediation steps
+
+---
+
+### 7. Runbook
+
+**Purpose**: The *operational manual* — how the system lives in production, scales, and recovers. Guides on-call engineers.
+
+**Why It Matters**:
+- Reduces Mean Time To Recovery (MTTR) for incidents
+- Provides step-by-step guidance for common issues
+- Documents scaling and deployment procedures
+- Ensures operational knowledge is not siloed
+
+**Content Guidelines**:
+- Deployment procedures (manual and automated)
+- Scaling instructions (horizontal/vertical)
+- Backup and restore procedures
+- Troubleshooting guides for common issues
+- Runbook entries for specific error codes
+- Contact information and escalation paths
+
+**Best Practices**:
+- Write runbooks for every P1/P2 incident
+- Include exact commands and configuration snippets
+- Test runbooks periodically (chaos engineering)
+- Link runbook entries to relevant documentation
+- Keep runbooks updated when system changes
+
+---
+
+## How to Use This Approach Effectively
+
+### 1. Start with Requirements
+
+Before writing any code or documentation, establish clear requirements. Ask:
+- What business problem are we solving?
+- How will we measure success?
+- What are the non-negotiable constraints?
+
+**Action**: Create a `docs/requirements/` directory and start with `PRD.md` and `KPIs.md`.
+
+### 2. Define the Specification First
+
+Once requirements are stable, define the technical specification. This becomes the contract for implementation.
+
+**Action**: Create `docs/specification/` with `contract.yaml` (or appropriate format) and `error-codes.md`.
+
+### 3. Design the Architecture
+
+With requirements and specification in place, design the architecture. Document trade-off decisions explicitly.
+
+**Action**: Create `docs/architecture/` with Mermaid diagrams and `trade-offs.md`.
+
+### 4. Create Walkthroughs Early
+
+As soon as the architecture is defined, create walkthroughs. This helps identify gaps and provides onboarding material.
+
+**Action**: Create `docs/walkthrough/` with `TOUR.md` and sequence diagrams.
+
+### 5. Implement with Validation in Mind
+
+Write implementation code that adheres to the specification. Build validation into the CI pipeline from day one.
+
+**Action**: Ensure test files are co-located with implementation and run on every commit.
+
+### 6. Automate Validation
+
+Build automated validation that runs in CI/CD. This ensures spec compliance and prevents drift.
+
+**Action**: Configure CI jobs to validate against specification and block PRs on violations.
+
+### 7. Document Operations from Day One
+
+Create runbook entries as soon as deployment procedures are established. Update them when incidents occur.
+
+**Action**: Create `docs/runbook/` with entries for deployment, scaling, and common issues.
+
+---
+
+## GitOps Integration
+
+This documentation framework aligns with GitOps principles:
+
+| GitOps Principle | Documentation Alignment |
+|-----------------|------------------------|
+| **Versioned** | All documentation lives in git, with history and audit trail |
+| ** declarative** | Specifications and architecture are declarative contracts |
+| **Automated** | Validation jobs automate spec compliance checks |
+| **Self-Service** | Walkthroughs and runbooks enable self-service onboarding and operations |
+| **Observability** | KPIs and metrics are defined for each documentation artifact |
+
+**Git Structure**:
+```
+docs/
+├── requirements/       # PRDs, user stories, KPIs
+├── specification/      # OpenAPI, Protobuf, AsyncAPI specs
+├── architecture/       # C4 diagrams, Mermaid, trade-off docs
+├── walkthrough/        # TOUR.md, sequence diagrams
+├── implementation/     # Source code (in src/)
+├── validation/         # CI configs, test suites
+└── runbook/            # Deployment, scaling, troubleshooting
+```
+
+---
+
+## Metrics and Continuous Improvement
+
+Each documentation artifact has associated KPIs. Track these to ensure quality:
+
+| Document | KPI | Target |
+|----------|-----|--------|
+| Requirements | Requirement coverage | 100% of features have associated requirements |
+| Specification | Spec compliance rate | 100% of messages validate against spec |
+| Architecture | Decision documentation | 100% of major decisions logged with trade-offs |
+| Walkthrough | New dev time-to-first-PR | <2 days from onboarding to first contribution |
+| Implementation | Test coverage | >80% unit test coverage |
+| Validation | Bypass rate | <1% of PRs bypass validation gates |
+| Runbook | MTTR | <15 minutes for P1 incidents |
+
+**Review Cadence**:
+- Weekly: Review KPI dashboards and documentation gaps
+- Monthly: Update documentation based on incident learnings
+- Quarterly: Full framework review and improvement
+
+---
+
+## Template Examples
+
+### Requirements Template
+```markdown
+# PRD: Feature Name
+
+## Business Goal
+[What problem are we solving?]
+
+## Success Metrics
+- [Metric 1]: Target [value]
+- [Metric 2]: Target [value]
+
+## User Stories
+- As a [role], I want [feature] so that [benefit]
+  - Acceptance Criteria: [details]
+
+## Non-Functional Requirements
+- Performance: [details]
+- Security: [details]
+- Scalability: [details]
+
+## Out of Scope
+- [What's explicitly excluded]
+```
+
+### Specification Template
+```yaml
+# contract.yaml
+openapi: 3.0.0
+info:
+  title: NATSBridge API
+  version: 1.0.0
+paths:
+  /api/v1/endpoint:
+    post:
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/Request'
+      responses:
+        '200':
+          description: Success
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Response'
+```
+
+### Architecture Template
+```mermaid
+%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#3b82f6'}}}%%
+flowchart TD
+    A[Client] --> B[Caddy]
+    B --> C[Node.js API]
+    C --> D[Julia Worker]
+    D --> E[NATS Cluster]
+    E --> F[Storage]
+    
+    style A fill:#f9f9f9,stroke:#333
+    style E fill:#e0e7ff,stroke:#3b82f6
+```
+
+### Runbook Template
+```markdown
+# Runbook: Service Restart
+
+**Severity**: P2
+**Estimated Time**: 5 minutes
+
+## Symptoms
+- Service is unresponsive
+- Health checks are failing
+
+## Steps
+1. SSH to the host
+2. Run: `kubectl rollout restart deployment/natsbridge`
+3. Monitor: `kubectl get pods -l app=natsbridge -w`
+
+## Rollback
+- Run: `kubectl rollout undo deployment/natsbridge`
+
+## Post-Incident
+- [ ] Review logs for root cause
+- [ ] Update runbook if needed
+```
+
+---
+
+## Conclusion
+
+This SDD + GitOps Documentation Framework ensures that documentation is:
+- **Structured**: Seven distinct artifacts with clear purposes
+- **Automated**: Validation and CI/CD integration
+- **Versioned**: All documentation in git with history
+- **Measurable**: KPIs for quality and effectiveness
+- **Actionable**: Practical templates and examples
+
+Use this framework as a living document—update it as your team's needs evolve.

docs/requirements.md

@@ -0,0 +1,420 @@
+# Requirements Document: NATSBridge
+
+**Version**: 1.0.0  
+**Date**: 2026-03-13  
+**Status**: Active  
+**Ground Truth**: [`src/NATSBridge.jl`](../src/NATSBridge.jl)
+
+---
+
+## Executive Summary
+
+NATSBridge is a cross-platform, bi-directional data bridge that enables seamless communication between **Julia**, **JavaScript**, **Python**, 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.
+
+---
+
+## Business Goals
+
+### Primary Objectives
+
+1. **Cross-Platform Interoperability**: Enable seamless data exchange between Julia, JavaScript (for both Server-Side rendering and Client-Side rendering webapp), Python, and MicroPython applications without platform-specific barriers.
+
+2. **Efficient Large Payload Handling**: Implement intelligent transport selection based on payload size:
+   - **Direct Transport**: Small payloads (<0.5MB) sent directly via NATS
+   - **Link Transport**: Large payloads (≥0.5MB) uploaded to HTTP file server, URL sent via NATS
+
+3. **Unified API Across Platforms**: Provide consistent `smartsend()` and `smartreceive()` functions across all supported platforms while maintaining idiomatic implementations.
+
+4. **Developer Productivity**: Reduce onboarding time and simplify integration through comprehensive documentation and test examples.
+
+### Success Metrics
+
+| 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 |
+
+---
+
+## User Stories
+
+### Core Functionality
+
+| Story | Priority | Acceptance Criteria |
+|-------|----------|---------------------|
+| **As a Julia developer**, I want to send text messages to JavaScript 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 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 MicroPython developer**, I want to send sensor data with minimal memory usage | P1 | Direct transport works for payloads <100KB on memory-constrained devices |
+
+### Multi-Payload Support
+
+| Story | Priority | Acceptance Criteria |
+|-------|----------|---------------------|
+| **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 |
+
+### File Server Integration
+
+| Story | Priority | Acceptance Criteria |
+|-------|----------|---------------------|
+| **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 |
+
+### Reliability Features
+
+| Story | Priority | Acceptance Criteria |
+|-------|----------|---------------------|
+| **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 |
+
+---
+
+## Non-Functional Requirements
+
+### Performance Requirements
+
+| Requirement | Specification | Test Method |
+|-------------|---------------|-------------|
+| Message serialization overhead | <50ms for 10KB payload | Benchmark tests |
+| Message deserialization overhead | <50ms for 10KB payload | Benchmark tests |
+| NATS connection establishment | <100ms | Connection pool benchmarks |
+| File upload latency | <1s for 0.5MB file | Integration tests |
+| File download latency | <1s for 0.5MB file | Integration tests |
+
+### Scalability Requirements
+
+| Requirement | Specification |
+|-------------|---------------|
+| Concurrent connections | Support 100+ simultaneous NATS connections |
+| Message throughput | Handle 1000+ messages/second per instance |
+| File server scalability | Support horizontal scaling of file server backend |
+
+### Reliability Requirements
+
+| Requirement | Specification |
+|-------------|---------------|
+| Message delivery | At-least-once delivery semantics via NATS |
+| File server availability | Graceful degradation when file server is unavailable |
+| Connection recovery | Auto-reconnect on NATS connection failure |
+
+### Security Requirements
+
+| Requirement | Specification |
+|-------------|---------------|
+| Payload integrity | SHA-256 checksum support via metadata |
+| Transport security | TLS support for NATS connections |
+| File server security | Authentication token for file uploads |
+
+### Compatibility Requirements
+
+| Platform | Minimum Version | Notes |
+|----------|-----------------|-------|
+| Julia | 1.7+ | Arrow.jl required for arrowtable support |
+| Node.js | 16+ | nats.js required |
+| Python | 3.8+ | pyarrow required for arrowtable support |
+| MicroPython | 1.19+ | Limited to direct transport |
+
+---
+
+## Out of Scope
+
+### Phase 1 (Current Implementation)
+
+| 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 |
+
+### Future Considerations
+
+| Feature | Future Phase |
+|---------|--------------|
+| JetStream streams and consumers | Phase 2 |
+| Message TTL and dead-letter queues | Phase 3 |
+| Message tracing with OpenTelemetry | Phase 3 |
+| Rate limiting and quota management | Phase 4 |
+
+---
+
+## Boundary Definitions
+
+### What NATSBridge Handles
+
+| Function | Description |
+|----------|-------------|
+| Message serialization | Converts data types to binary format |
+| Message encoding | Base64, JSON, Arrow IPC encoding |
+| Transport selection | Direct vs link based on size threshold |
+| NATS publishing | Publishes messages to NATS subjects |
+| NATS subscription | Receives and processes NATS messages |
+| File server upload | Uploads large payloads to HTTP server |
+| File server download | Downloads payloads from HTTP server with retry |
+| Correlation ID generation | Creates and propagates UUIDs |
+| Data deserialization | Converts binary format back to native types |
+
+### What NATSBridge Does NOT Handle
+
+| Function | Handled By |
+|----------|------------|
+| NATS server management | External NATS deployment |
+| File server management | External HTTP server deployment |
+| Application business logic | Application code using NATSBridge |
+| Message encryption | Application layer |
+| Message compression | Application layer |
+| Authentication/Authorization | NATS server configuration |
+
+---
+
+## Payload Type Requirements
+
+### Supported Payload Types
+
+| Type | Julia | JavaScript | Python | MicroPython | Description |
+|------|-------|------------|--------|-------------|-------------|
+| `text` | `String` | `string` | `str` | `str` | Plain text strings |
+| `dictionary` | `Dict`, `NamedTuple` | `Object`, `Array` | `dict`, `list` | `dict` | JSON-serializable data |
+| `arrowtable` | `DataFrame`, `Arrow.Table` | `Array<Object>` | `pandas.DataFrame` | ❌ | Tabular data (Arrow IPC) |
+| `jsontable` | `Vector{NamedTuple}` | `Array<Object>` | `list[dict]` | ⚠️ | Tabular data (JSON) |
+| `image` | `Vector{UInt8}` | `Uint8Array`, `Buffer` | `bytes` | `bytearray` | Image binary data |
+| `audio` | `Vector{UInt8}` | `Uint8Array`, `Buffer` | `bytes` | `bytearray` | Audio binary data |
+| `video` | `Vector{UInt8}` | `Uint8Array`, `Buffer` | `bytes` | `bytearray` | Video binary data |
+| `binary` | `Vector{UInt8}`, `IOBuffer` | `Uint8Array`, `Buffer` | `bytes`, `bytearray` | `bytearray` | Generic binary data |
+
+### 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 |
+| `jsontable` | JSON → Base64 | Human-readable format |
+| `image`/`audio`/`video`/`binary` | Direct → Base64 | Binary data preserved |
+
+---
+
+## Size Threshold Requirements
+
+### Direct Transport Threshold
+
+| Platform | Threshold | Notes |
+|----------|-----------|-------|
+| Desktop (Julia/JS/Python) | 0.5MB | Default size threshold |
+| MicroPython | 100KB | Lower threshold for memory constraints |
+
+### Maximum Payload Size
+
+| Platform | Maximum | Notes |
+|----------|---------|-------|
+| Desktop | Unlimited | Limited by NATS server configuration |
+| MicroPython | 50KB | Hard limit due to 256KB-1MB memory |
+
+---
+
+## Message Envelope Requirements
+
+### 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 |
+
+### 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 |
+
+---
+
+## Error Handling Requirements
+
+### 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 |
+
+### 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 |
+
+---
+
+## Testing Requirements
+
+### 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 |
+
+### Integration Tests
+
+| Test Scenario | Success Criteria |
+|-------------|-----------------|
+| Cross-platform text message | Julia ↔ JavaScript ↔ Python |
+| Cross-platform tabular data | Arrow IPC round-trip |
+| Large file transfer | File server upload/download |
+| Multi-payload mixed content | All payload types in one message |
+
+---
+
+## API Contract
+
+### 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}
+```
+
+### 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}
+```
+
+---
+
+## Dependencies
+
+### Required 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 |
+
+### Optional Dependencies
+
+| Platform | Package | Use Case |
+|----------|---------|----------|
+| Julia | DataFrames.jl | DataFrame support for arrowtable |
+| Python | pandas | DataFrame support for arrowtable |
+
+---
+
+## Deployment Requirements
+
+### 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 |
+| 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 |
+
+---
+
+## Versioning
+
+### Current Version
+
+- **Major**: 1 (Breaking changes require major version bump)
+- **Minor**: 0 (Feature additions)
+- **Patch**: 0 (Bug fixes)
+
+### Version Compatibility
+
+| Version | Supported Platforms |
+|---------|---------------------|
+| v1.0.x | Julia 1.7+, Node.js 16+, Python 3.8+, MicroPython 1.19+ |
+
+---
+
+## Change Log
+
+| Date | Version | Changes |
+|------|---------|---------|
+| 2026-03-13 | 1.0.0 | Initial requirements document |
+
+---
+
+## References
+
+- [`src/NATSBridge.jl`](../src/NATSBridge.jl) - Ground truth implementation
+- [`README.md`](../README.md) - Project overview
+- [`docs/architecture.md`](./architecture.md) - Architecture documentation
+- [`docs/implementation.md`](./implementation.md) - Implementation details
+- [`docs/walkthrough.md`](./walkthrough.md) - Usage examples