Merge pull request 'v1.2.0-HTTP2' (#3 ) from v1.2.0-HTTP2 into v1.2.0

Reviewed-on: #3
update http2.o
2026-06-17 06:19:51 +00:00 · 2026-06-17 13:12:17 +07:00 · 2026-06-17 13:09:50 +07:00 · 2026-06-13 19:00:30 +07:00 · 2026-06-05 11:27:33 +07:00 · 2026-05-29 11:30:23 +07:00
6 changed files with 730 additions and 332 deletions
--- a/Manifest.toml
+++ b/Manifest.toml
@@ -2,7 +2,7 @@

 julia_version = "1.12.6"
 manifest_format = "2.0"
-project_hash = "ec31595f278190cb6cfb8b50156867ebf16234d0"
+project_hash = "866f6d0804412d52eacd6423616500484f0060f0"

 [[deps.AliasTables]]
 deps = ["PtrArrays", "Random"]
@@ -34,11 +34,6 @@ version = "1.11.0"
 uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
 version = "1.11.0"

-[[deps.BitFlags]]
-git-tree-sha1 = "0691e34b3bb8be9307330f88d1a3c3f25466c24d"
-uuid = "d1d4a3ce-64b1-5f1a-9ba4-7e7e69966f35"
-version = "0.1.9"
-
 [[deps.BitIntegers]]
 deps = ["Random"]
 git-tree-sha1 = "091d591a060e43df1dd35faab3ca284925c48e46"
@@ -50,6 +45,10 @@ git-tree-sha1 = "6863c5b7fc997eadcabdbaf6c5f201dc30032643"
 uuid = "e1450e63-4bb3-523b-b2a4-4ffa8c0fd77d"
 version = "1.2.2"

+[[deps.CRC32c]]
+uuid = "8bf52ea8-c179-5cab-976a-9e18b702a9bc"
+version = "1.11.0"
+
 [[deps.CSV]]
 deps = ["CodecZlib", "Dates", "FilePathsBase", "InlineStrings", "Mmap", "Parsers", "PooledArrays", "PrecompileTools", "SentinelArrays", "Tables", "Unicode", "WeakRefStrings", "WorkerUtilities"]
 git-tree-sha1 = "8d8e0b0f350b8e1c91420b5e64e5de774c2f0f4d"
@@ -130,9 +129,9 @@ version = "1.8.2"

 [[deps.DataStructures]]
 deps = ["OrderedCollections"]
-git-tree-sha1 = "e86f4a2805f7f19bec5129bc9150c38208e5dc23"
+git-tree-sha1 = "6fb53a69613a0b2b68a0d12671717d307ab8b24e"
 uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
-version = "0.19.4"
+version = "0.19.5"

 [[deps.DataValueInterfaces]]
 git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6"
@@ -146,9 +145,9 @@ version = "1.11.0"

 [[deps.Distributions]]
 deps = ["AliasTables", "FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SpecialFunctions", "Statistics", "StatsAPI", "StatsBase", "StatsFuns"]
-git-tree-sha1 = "e421c1938fafab0165b04dc1a9dbe2a26272952c"
+git-tree-sha1 = "96f76dcd6cc75cf8eb49109123868499d413f526"
 uuid = "31c24e10-a181-5473-b8eb-7969acd0382f"
-version = "0.25.125"
+version = "0.25.126"

    [deps.Distributions.extensions]
    DistributionsChainRulesCoreExt = "ChainRulesCore"
@@ -175,12 +174,6 @@ git-tree-sha1 = "c49898e8438c828577f04b92fc9368c388ac783c"
 uuid = "4e289a0a-7415-4d19-859d-a7e5c4648b56"
 version = "1.0.7"

-[[deps.ExceptionUnwrapping]]
-deps = ["Test"]
-git-tree-sha1 = "d36f682e590a83d63d1c7dbd287573764682d12a"
-uuid = "460bff9d-24e4-43bc-9d9f-a8973cb893f4"
-version = "0.1.11"
-
 [[deps.ExprTools]]
 git-tree-sha1 = "27415f162e6028e81c72b82ef756bf321213b6ec"
 uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04"
@@ -191,12 +184,15 @@ deps = ["Compat", "Dates"]
 git-tree-sha1 = "3bab2c5aa25e7840a4b065805c0cdfc01f3068d2"
 uuid = "48062228-2e41-5def-b9a4-89aafe57970f"
 version = "0.9.24"
-weakdeps = ["Mmap", "Test"]

    [deps.FilePathsBase.extensions]
    FilePathsBaseMmapExt = "Mmap"
    FilePathsBaseTestExt = "Test"

+    [deps.FilePathsBase.weakdeps]
+    Mmap = "a63ad114-7e13-5084-954f-fe012c677804"
+    Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+
 [[deps.FileWatching]]
 uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee"
 version = "1.11.0"
@@ -226,17 +222,17 @@ version = "1.11.0"

 [[deps.GeneralUtils]]
 deps = ["CSV", "DataFrames", "DataStructures", "Dates", "Distributions", "JSON", "NATS", "PrettyPrinting", "Random", "Revise", "SHA", "UUIDs"]
-git-tree-sha1 = "e28ca4df47d0c46d04716422bef6adb660f33dc3"
+git-tree-sha1 = "8720a31344bc85ad610ae12f7e1247de22070765"
 repo-rev = "main"
 repo-url = "https://git.yiem.cc/ton/GeneralUtils"
 uuid = "c6c72f09-b708-4ac8-ac7c-2084d70108fe"
-version = "0.3.1"
+version = "0.3.2"

 [[deps.HTTP]]
-deps = ["Base64", "CodecZlib", "ConcurrentUtilities", "Dates", "ExceptionUnwrapping", "Logging", "LoggingExtras", "MbedTLS", "NetworkOptions", "OpenSSL", "PrecompileTools", "Random", "SimpleBufferStream", "Sockets", "URIs", "UUIDs"]
-git-tree-sha1 = "51059d23c8bb67911a2e6fd5130229113735fc7e"
+deps = ["Base64", "CodecZlib", "Dates", "EnumX", "PrecompileTools", "Random", "Reseau", "SHA", "URIs", "UUIDs", "Zlib_jll"]
+git-tree-sha1 = "196e75bcb0a53cbf80eebe6326d69a86605c34d6"
 uuid = "cd3eb016-35fb-5094-929b-558a96fad6f3"
-version = "1.11.0"
+version = "2.3.0"

 [[deps.HashArrayMappedTries]]
 git-tree-sha1 = "2eaa69a7cab70a52b9687c8bf950a5a93ec895ae"
@@ -287,9 +283,9 @@ version = "1.8.0"

 [[deps.JSON]]
 deps = ["Dates", "Logging", "Parsers", "PrecompileTools", "StructUtils", "UUIDs", "Unicode"]
-git-tree-sha1 = "f76f7560267b840e492180f9899b472f30b88450"
+git-tree-sha1 = "c89d196f5ffb64bfbf80985b699ea913b0d2c211"
 uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
-version = "1.6.0"
+version = "1.6.1"
 weakdeps = ["ArrowTypes"]

    [deps.JSON.extensions]
@@ -357,9 +353,9 @@ version = "1.12.0"

 [[deps.LogExpFunctions]]
 deps = ["DocStringExtensions", "IrrationalConstants", "LinearAlgebra"]
-git-tree-sha1 = "13ca9e2586b89836fd20cccf56e57e2b9ae7f38f"
+git-tree-sha1 = "bba2d9aa057d8f126415de240573e86a8f39d2a1"
 uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688"
-version = "0.3.29"
+version = "1.0.1"

    [deps.LogExpFunctions.extensions]
    LogExpFunctionsChainRulesCoreExt = "ChainRulesCore"
@@ -375,17 +371,11 @@ version = "0.3.29"
 uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"
 version = "1.11.0"

-[[deps.LoggingExtras]]
-deps = ["Dates", "Logging"]
-git-tree-sha1 = "f00544d95982ea270145636c181ceda21c4e2575"
-uuid = "e6f89c97-d47a-5376-807f-9c37f3926c36"
-version = "1.2.0"
-
 [[deps.LoweredCodeUtils]]
 deps = ["CodeTracking", "Compiler", "JuliaInterpreter"]
-git-tree-sha1 = "5d4278f755440f70648d80cc6225f51e78e94094"
+git-tree-sha1 = "0aad96d7b987a5600e260eec50147b254d5ff7e6"
 uuid = "6f1432cf-f94c-5a45-995e-cdbf5db27b0b"
-version = "3.5.1"
+version = "3.6.0"

 [[deps.Lz4_jll]]
 deps = ["Artifacts", "JLLWrappers", "Libdl"]
@@ -456,12 +446,6 @@ deps = ["Artifacts", "Libdl"]
 uuid = "05823500-19ac-5b8b-9628-191a04bc5112"
 version = "0.8.7+0"

-[[deps.OpenSSL]]
-deps = ["BitFlags", "Dates", "MozillaCACerts_jll", "NetworkOptions", "OpenSSL_jll", "Sockets"]
-git-tree-sha1 = "1d1aaa7d449b58415f97d2839c318b70ffb525a0"
-uuid = "4d8831e6-92b7-49fb-bdf8-b643e874388c"
-version = "1.6.1"
-
 [[deps.OpenSSL_jll]]
 deps = ["Artifacts", "Libdl"]
 uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95"
@@ -474,9 +458,9 @@ uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e"
 version = "0.5.6+0"

 [[deps.OrderedCollections]]
-git-tree-sha1 = "05868e21324cede2207c6f0f466b4bfef6d5e7ee"
+git-tree-sha1 = "94ba93778373a53bfd5a0caaf7d809c445292ff4"
 uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
-version = "1.8.1"
+version = "1.8.2"

 [[deps.PDMats]]
 deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"]
@@ -490,9 +474,9 @@ weakdeps = ["StatsBase"]

 [[deps.Parsers]]
 deps = ["Dates", "PrecompileTools", "UUIDs"]
-git-tree-sha1 = "5d5e0a78e971354b1c7bff0655d11fdc1b0e12c8"
+git-tree-sha1 = "32a4e09c5f29402573d673901778a0e03b0807b9"
 uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0"
-version = "2.8.4"
+version = "2.8.6"

 [[deps.PooledArrays]]
 deps = ["DataAPI", "Future"]
@@ -566,11 +550,17 @@ git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b"
 uuid = "189a3867-3050-52da-a836-e630ba90ab69"
 version = "1.2.2"

+[[deps.Reseau]]
+deps = ["NetworkOptions", "OpenSSL_jll", "PrecompileTools", "Random", "SHA"]
+git-tree-sha1 = "0eab6d95ed40c2ef3992255c1c71e4f9748932b5"
+uuid = "802f3686-a58f-41ce-bb0c-3c43c75bba36"
+version = "1.3.1"
+
 [[deps.Revise]]
-deps = ["CodeTracking", "FileWatching", "InteractiveUtils", "JuliaInterpreter", "LibGit2", "LoweredCodeUtils", "OrderedCollections", "Preferences", "REPL", "UUIDs"]
-git-tree-sha1 = "d9383b639663d8220ac9c523927e38bc21cad16a"
+deps = ["CRC32c", "CodeTracking", "FileWatching", "InteractiveUtils", "JuliaInterpreter", "LibGit2", "LoweredCodeUtils", "OrderedCollections", "Preferences", "REPL", "UUIDs"]
+git-tree-sha1 = "27e3ee13fc8739a59b380d6163d6a82f52c03bd7"
 uuid = "295af30f-e4ad-537b-8983-00126c2a3abe"
-version = "3.14.3"
+version = "3.15.1"

    [deps.Revise.extensions]
    DistributedExt = "Distributed"
@@ -616,11 +606,6 @@ version = "1.4.10"
 uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
 version = "1.11.0"

-[[deps.SimpleBufferStream]]
-git-tree-sha1 = "f305871d2f381d21527c770d4788c06c097c9bc1"
-uuid = "777ac1f9-54b0-4bf8-805c-2214025038e7"
-version = "1.2.0"
-
 [[deps.Sockets]]
 uuid = "6462fe0b-24de-5631-8697-dd941f90decc"
 version = "1.11.0"
@@ -644,9 +629,9 @@ version = "1.12.0"

 [[deps.SpecialFunctions]]
 deps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"]
-git-tree-sha1 = "2700b235561b0335d5bef7097a111dc513b8655e"
+git-tree-sha1 = "6547cbdd8ce32efba0d21c5a40fa96d1a3548f9f"
 uuid = "276daf66-3868-5448-9aa4-cd146d93841b"
-version = "2.7.2"
+version = "2.8.0"

    [deps.SpecialFunctions.extensions]
    SpecialFunctionsChainRulesCoreExt = "ChainRulesCore"
@@ -672,15 +657,15 @@ version = "1.8.0"

 [[deps.StatsBase]]
 deps = ["AliasTables", "DataAPI", "DataStructures", "IrrationalConstants", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"]
-git-tree-sha1 = "aceda6f4e598d331548e04cc6b2124a6148138e3"
+git-tree-sha1 = "c6f18e5a52a176a383f6f6c635e0f81feed1d6d4"
 uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
-version = "0.34.10"
+version = "0.34.11"

 [[deps.StatsFuns]]
 deps = ["HypergeometricFunctions", "IrrationalConstants", "LogExpFunctions", "Reexport", "Rmath", "SpecialFunctions"]
-git-tree-sha1 = "91f091a8716a6bb38417a6e6f274602a19aaa685"
+git-tree-sha1 = "3f4e1d24289cd974e089c617b1472311a2b1feab"
 uuid = "4c63d2b9-4356-54db-8cca-17b64c39e42c"
-version = "1.5.2"
+version = "2.1.0"

    [deps.StatsFuns.extensions]
    StatsFunsChainRulesCoreExt = "ChainRulesCore"
@@ -759,11 +744,6 @@ git-tree-sha1 = "f2c1efbc8f3a609aadf318094f8fc5204bdaf344"
 uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
 version = "1.12.1"

-[[deps.Test]]
-deps = ["InteractiveUtils", "Logging", "Random", "Serialization"]
-uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
-version = "1.11.0"
-
 [[deps.TimeZones]]
 deps = ["Artifacts", "Dates", "Downloads", "InlineStrings", "Mocking", "Printf", "Scratch", "TZJData", "Unicode", "p7zip_jll"]
 git-tree-sha1 = "d422301b2a1e294e3e4214061e44f338cafe18a2"
--- a/Project.toml
+++ b/Project.toml
@@ -19,5 +19,5 @@ UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 [compat]
 Base64 = "1.11.0"
 Dates = "1.11.0"
-GeneralUtils = "0.3 - 0.3.1"
+GeneralUtils = "0.3.2"
 JSON = "1.4.0"
--- a/src/msghandler-csr.js
+++ b/src/msghandler-csr.js
@@ -526,36 +526,15 @@ async function smartunpack(msg, options = {}) {
        max_delay = 5000
    } = options;

-    // Handle both raw JSON strings and transport message objects
-    let payload;
-    if (typeof msg === 'string') {
-        payload = msg;
-    } else if (msg !== null && typeof msg === 'object') {
-        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');
-        }
+    let envJsonObj;
+
+    // NATS's Javascript lib already return JSON object
+    if (msg !== null && typeof msg === 'object') {
+        envJsonObj = msg;
    } else {
        throw new Error('Invalid message format: expected JSON string or message object');
    }
 
-    logTrace('smartunpack', `smartunpack: raw payload length=${payload.length}`);
-    
-    // Debug: Show first 200 chars of payload
-    const payloadPreview = payload.substring(0, 200);
-    logTrace('smartunpack', `smartunpack: payload preview: ${payloadPreview}`);
-    
-    let envJsonObj;
-    try {
-        envJsonObj = JSON.parse(payload);
-    } catch (e) {
-        logTrace('smartunpack', `smartunpack: JSON parse failed: ${e.message}`);
-        throw e;
-    }
-    
    logTrace(envJsonObj.correlation_id, 'Processing received message');
    logTrace(envJsonObj.correlation_id, `smartunpack: envelope has ${envJsonObj.payloads.length} payloads`);

--- a/src/msghandler.jl
+++ b/src/msghandler.jl
@@ -451,9 +451,9 @@ function smartpack(
  # Process each payload in the list
  payloads = msg_payload_v1[]
  for (dataname, payload_data, payload_type) in data
-    @show dataname typeof(payload_data)
+    # @show dataname typeof(payload_data)

-    # Serialize data based on type
+    # Serialize data based on type. use bytes as medium for every datatype
    payload_bytes = _serialize_data(payload_data, payload_type)
    
    payload_size = length(payload_bytes)  # Calculate payload size in bytes
@@ -811,7 +811,7 @@ function smartunpack(
  max_retries::Int = 5,
  base_delay::Int = 100,
  max_delay::Int = 5000
-)::JSON.Object{String, Any}
+  )::JSON.Object{String, Any}

  # Parse the JSON envelope
  env_json_obj = JSON.parse(msg_json_str)
@@ -834,25 +834,25 @@ function smartunpack(
      # Extract base64 payload from the payload
      payload_b64 = String(payload["data"])
      
-      # Decode Base64 payload
+      # Decode Base64 payload back into bytes (smartpack use bytes as medium for every datatype)
      payload_bytes = Base64.base64decode(payload_b64)  # Decode base64 payload to bytes
      
      # Deserialize based on type
      data_type = String(payload["payload_type"])
-        data = _deserialize_data(payload_bytes, data_type, env_json_obj["correlation_id"])
+      data = _deserialize_data(payload_bytes, data_type, env_json_obj["correlation_id"])
      
      push!(payloads_list, (dataname, data, data_type))
    elseif transport == "link"  # Link transport - payload is at URL
      # Extract download URL from the payload
      url = String(payload["data"])
-        log_trace(env_json_obj["correlation_id"], "Link transport - fetching '$dataname' from URL: $url")  # Log link transport handling
+      log_trace(env_json_obj["correlation_id"], "Link transport - fetching '$dataname' from URL: $url")  # Log link transport handling
      
      # Fetch with exponential backoff using the download handler
-        downloaded_data = fileserver_download_handler(url, max_retries, base_delay, max_delay, env_json_obj["correlation_id"])
+      downloaded_data = fileserver_download_handler(url, max_retries, base_delay, max_delay, env_json_obj["correlation_id"])

      # Deserialize based on type
      data_type = String(payload["payload_type"])
-        data = _deserialize_data(downloaded_data, data_type, env_json_obj["correlation_id"])
+      data = _deserialize_data(downloaded_data, data_type, env_json_obj["correlation_id"])
      
      push!(payloads_list, (dataname, data, data_type))
    else  # Unknown transport type
@@ -1048,7 +1048,7 @@ function plik_oneshot_upload(file_server_url::String, dataname::String, data::Ve
  url_getUploadID = "$file_server_url/upload" # URL to get upload ID
  headers = ["Content-Type" => "application/json"]
  body = """{ "OneShot" : true }"""
-  http_response = HTTP.request("POST", url_getUploadID, headers, body; body_is_form=false)
+  http_response = HTTP.request("POST", url_getUploadID, headers, body)
  response_json = JSON.parse(http_response.body)
  uploadid = response_json["id"]
  uploadtoken = response_json["uploadToken"]
@@ -1125,7 +1125,7 @@ function plik_oneshot_upload(file_server_url::String, filepath::String)
  url_getUploadID = "$file_server_url/upload" # URL to get upload ID
  headers = ["Content-Type" => "application/json"]
  body = """{ "OneShot" : true }"""
-  http_response = HTTP.request("POST", url_getUploadID, headers, body; body_is_form=false)
+  http_response = HTTP.request("POST", url_getUploadID, headers, body)
  response_json = JSON.parse(http_response.body)

  uploadid = response_json["id"]
--- a/test/runtest.jl
+++ b/test/runtest.jl
@@ -0,0 +1,66 @@
+
+function plik_oneshot_upload(file_server_url::String, dataname::String, data::Vector{UInt8})
+
+  # ----------------------------------------- get upload id ---------------------------------------- #
+  # Equivalent curl command:  curl -X POST -d '{ "OneShot" : true }' http://localhost:8080/upload
+  url_getUploadID = "$file_server_url/upload" # URL to get upload ID
+  headers = ["Content-Type" => "application/json"]
+  body = """{ "OneShot" : true }"""
+  http_response = HTTP.request("POST", url_getUploadID, headers, body)
+  response_json = JSON.parse(http_response.body)
+  uploadid = response_json["id"]
+  uploadtoken = response_json["uploadToken"]
+
+  # ------------------------------------------ upload file ----------------------------------------- #
+  # Equivalent curl command:  curl -X POST --header "X-UploadToken: UPLOAD_TOKEN" -F "file=@PATH_TO_FILE" http://localhost:8080/file/UPLOAD_ID
+  file_multipart = HTTP.Multipart(dataname, IOBuffer(data), "application/octet-stream") # Plik won't accept raw bytes upload
+  url_upload = "$file_server_url/file/$uploadid"
+  headers = ["X-UploadToken" => uploadtoken]
+
+  # Create the multipart form data
+  form = HTTP.Form(Dict(
+    "file" => file_multipart
+  ))
+
+  # Execute the POST request
+  http_response = nothing
+  try
+    http_response = HTTP.post(url_upload, headers, form)
+  catch e
+    @error "Request failed" exception=e
+  end
+  response_json = JSON.parse(http_response.body)
+  fileid = response_json["id"]
+
+  # url of the uploaded data e.g. "http://192.168.1.20:8080/file/3F62E/4AgGT/test.zip"
+  url = "$file_server_url/file/$uploadid/$fileid/$dataname"
+
+  return Dict("status" => http_response.status, "uploadid" => uploadid, "fileid" => fileid, "url" => url)
+end
+
+
+using HTTP, JSON
+
+file_server_url = "https://fileserver.yiem.cc"
+dataname = "test.txt"
+data = Vector{UInt8}("hello world")
+
+# Upload to local plik server
+result = plik_oneshot_upload(file_server_url, dataname, data)
+println(result)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- a/test/test_julia_mix_payloads_sender.jl
+++ b/test/test_julia_mix_payloads_sender.jl
@@ -1,259 +1,632 @@
-#!/usr/bin/env julia
-# Test script for mixed-content message testing
-# Tests sending a mix of text, dictionary, arrowtable, jsontable, image, audio, video, and binary data
-# from Julia serviceA to Julia serviceB using msghandler.jl smartpack
-# 
-# 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 msghandler.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
+/**
+ * msghandler - Cross-Platform Bi-Directional Data Bridge
+ * Browser-Compatible Implementation (Client-Side Rendering)
+ * 
+ * This module provides functionality for sending and receiving data across network boundaries
+ * 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
+ * 
+ * Browser-compatible version uses:
+ * - Web Crypto API for UUID generation
+ * - Uint8Array instead of Buffer
+ * - fetch API for file server communication
+ * 
+ * @module msghandlerCSR
+ */

-using NATS, JSON, UUIDs, Dates, PrettyPrinting, DataFrames, Arrow, HTTP, Base64
+// Use native fetch available in browsers

-# Include the bridge module
-include("/home/ton/docker-apps/sommpanion/msghandler/src/msghandler.jl")
-using .msghandler
+// ---------------------------------------------- Constants ---------------------------------------------- //

-# Configuration
-const SUBJECT = "/msghandler"
-const NATS_URL = "nats.yiem.cc"
-# const FILESERVER_URL = "http://192.168.88.104:8080"
-const FILESERVER_URL = "https://fileserver.yiem.cc"
+/**
+ * Default size threshold for switching from direct to link transport (0.5MB)
+ */
+const DEFAULT_SIZE_THRESHOLD = 500_000;

-# Create correlation ID for tracing
-correlation_id = string(uuid4())
+/**
+ * Default broker URL
+ */
+const DEFAULT_BROKER_URL = 'localhost:4222';

+/**
+ * Default HTTP file server URL for link transport
+ */
+const DEFAULT_FILESERVER_URL = 'http://localhost:8080';

-# ------------------------------------------------------------------------------------------------ #
-#                                      test mixed content transfer                                 #
-# ------------------------------------------------------------------------------------------------ #
+// ---------------------------------------------- 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);
+}

-# Helper: Log with correlation ID
-function log_trace(message)
-    timestamp = Dates.now()
-    println("[$timestamp] [Correlation: $correlation_id] $message")
-end
+/**
+ * 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;
+}

+/**
+ * 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('');
+}

-# 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"]
+/**
+ * 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}`);
+}

-    # Upload file
-    file_multipart = HTTP.Multipart(dataname, IOBuffer(data), "application/octet-stream")
-    url_upload = "$fileserver_url/file/$uploadid"
-    headers = ["X-UploadToken" => uploadtoken]
+// ---------------------------------------------- Serialization Functions ---------------------------------------------- //

-    form = HTTP.Form(Dict("file" => file_multipart))
-    httpResponse = HTTP.post(url_upload, headers, form)
-    responseJson = JSON.parse(String(httpResponse.body))
+/**
+ * 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}`);
+    }
+}

-    fileid = responseJson["id"]
-    url = "$fileserver_url/file/$uploadid/$fileid/$dataname"
+/**
+ * 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);
    
-    return Dict("status" => httpResponse.status, "uploadid" => uploadid, "fileid" => fileid, "url" => url)
-end
+    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(' ')}`);
+    }
    
-# Helper: Create sample data for each type
-function create_sample_data()
-    # Text data (small - direct transport)
-    text_data = "Hello! This is a test chat message. 🎉\nHow are you doing today? 😊"
+    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}`);
+    }
+}

-    # Dictionary/JSON data (medium - could be direct or link)
-    dict_data = Dict(
-        "type" => "chat",
-        "sender" => "serviceA",
-        "receiver" => "serviceB",
-        "metadata" => Dict(
-            "timestamp" => string(Dates.now()),
-            "priority" => "high",
-            "tags" => ["urgent", "chat", "test"]
-        ),
-        "content" => Dict(
-            "text" => "This is a JSON-formatted chat message with nested structure.",
-            "format" => "markdown",
-            "mentions" => ["user1", "user2"]
-        )
-    )
+// ---------------------------------------------- File Server Handlers ---------------------------------------------- //

-    # Arrow table data (DataFrame - small - direct transport)
-    # Uses Arrow IPC format for efficient binary serialization
-    # msghandler.jl handles serialization: DataFrame -> Arrow IPC
-    arrow_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)
-    )
+/**
+ * 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);
    
-    # Arrow table data (DataFrame - large - link transport)
-    # ~1.5MB of Arrow data (200,000 rows) - should trigger link transport
-    # msghandler.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]
-    )
+    // Get upload id
+    const urlGetUploadID = `${fileServerUrl}/upload`;
+    const headers = { 'Content-Type': 'application/json' };
+    const body = JSON.stringify({ OneShot: true });
    
-    # Json table data (DataFrame - small - direct transport)
-    # Uses JSON format for human-readable tabular data
-    # msghandler.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)
-    )
+    const httpResponse = await fetch(urlGetUploadID, {
+        method: 'POST',
+        headers,
+        body
+    });
    
-    # Json table data (DataFrame - large - link transport)
-    # ~1.5MB of JSON data (150,000 rows) - should trigger link transport
-    # msghandler.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)
-    )
+    const responseJson = await httpResponse.json();
+    const uploadid = responseJson.id;
+    const uploadtoken = responseJson.uploadToken;

-    # Audio data (small binary - direct transport)
-    audio_data = UInt8[rand(1:255) for _ in 1:100]
+    // 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);
    
-    # Audio data (large - link transport)
-    # ~1.5MB of audio-like data
-    large_audio_data = UInt8[rand(1:255) for _ in 1:1_500_000]
+    const uploadHeaders = {
+        'X-UploadToken': uploadtoken
+    };

-    # Video data (small binary - direct transport)
-    video_data = UInt8[rand(1:255) for _ in 1:150]
+    const uploadResponse = await fetch(urlUpload, {
+        method: 'POST',
+        headers: uploadHeaders,
+        body: form
+    });
    
-    # Video data (large - link transport)
-    # ~1.5MB of video-like data
-    large_video_data = UInt8[rand(1:255) for _ in 1:1_500_000]
+    const uploadJson = await uploadResponse.json();
+    const fileid = uploadJson.id;

-    # Binary data (small - direct transport)
-    binary_data = UInt8[rand(1:255) for _ in 1:200]
+    const url = `${fileServerUrl}/file/${uploadid}/${fileid}/${dataname}`;

-    # Binary data (large - link transport)
-    # ~1.5MB of binary data
-    large_binary_data = UInt8[rand(1:255) for _ in 1:1_500_000]
+    return {
+        status: uploadResponse.status,
+        uploadid,
+        fileid,
+        url
+    };
+}

-    return (
-        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
-    )
-end
+/**
+ * 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);
            
-# Sender: Send mixed content via smartpack
-function test_mix_send()
-    # 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()
+            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}`);
            
-    # 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)
+            if (attempt < maxRetries) {
+                await new Promise(resolve => setTimeout(resolve, delay));
+                delay = Math.min(delay * 2, maxDelay);
+            }
+        }
+    }
    
-    # 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)
+    throw new Error(`Failed to fetch data after ${maxRetries} attempts`);
+}

-    # 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"
-    # msghandler.jl handles the serialization internally
-    payloads = [
-        # Small data (direct transport) - text, dictionary, arrowtable, jsontable, small image
-        ("chat_text", text_data, "text"),
-        ("chat_json", dict_data, "dictionary"),
-        # ("arrow_table_small", arrow_table_small, "arrowtable"),
-        ("json_table_small", json_table_small, "jsontable"),
-        (filename_small_image, file_data_small_image, "binary"),
+// ---------------------------------------------- Core Functions ---------------------------------------------- //

-        # 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")
-    ]
+/**
+ * Build message envelope from payloads and metadata
+ * @param {string} subject - Subject/topic
+ * @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
+    };
+}

-    # Use smartpack with mixed content
-    env, env_json_str = msghandler.smartpack(
-        SUBJECT,
-        payloads;  # 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 = "mix_sender",
-        receiver_name = "",
-        receiver_id = "",
-        reply_to = "",
-        reply_to_msg_id = "",
-    )
+/**
+ * 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';
+    }
    
-    log_trace("Sent message with $(length(env.payloads)) payloads")
+    return {
+        id: uuidv4(),
+        dataname,
+        payload_type: payloadType,
+        transport,
+        encoding,
+        size: payloadBytes.byteLength,
+        data,
+        metadata: transport === 'direct' ? { payload_bytes: payloadBytes.byteLength } : {}
+    };
+}

-    # 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)")
+/**
+ * Send data 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
+ * into a "direct" payload. Otherwise, it uploads the data to a fileserver
+ * and creates a "link" payload with the URL.
+ * 
+ * Transport publishing is the caller's responsibility. This function returns the
+ * envelope and its JSON string representation.
+ * 
+ * @param {string} subject - Subject/topic to send 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] - Broker URL (for envelope metadata)
+ * @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="msghandler"] - 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 {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 msghandlerCSR.smartpack(
+ *     "/test",
+ *     [["dataname1", data1, "dictionary"]]
+ * );
+ * 
+ * // Send multiple payloads (use jsontable instead of arrowtable for browser)
+ * const [env, envJsonStr] = await msghandlerCSR.smartpack(
+ *     "/test",
+ *     [
+ *         ["dataname1", data1, "dictionary"],
+ *         ["dataname2", tableData, "jsontable"]
+ *     ]
+ * );
+ * 
+ * // Publish via your transport (NATS, MQTT, HTTP, etc.)
+ * // await myNatsClient.publish("/test", envJsonStr);
+ */
+async function smartpack(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 = 'msghandler',
+        receiver_name = '',
+        receiver_id = '',
+        reply_to = '',
+        reply_to_msg_id = '',
+        msg_id = uuidv4(),
+        sender_id = uuidv4()
+    } = options;

-        if payload.transport == "link"
-            log_trace("  URL: $(payload.data)")
-        end
-    end
+    logTrace(correlation_id, `Starting smartpack for subject: ${subject}`);
+    logTrace(correlation_id, `smartpack: data array length=${data.length}`);
    
-    # Summary
-    println("\n--- Transport Summary ---")
-    direct_count = count(p -> p.transport == "direct", env.payloads)
-    link_count = count(p -> p.transport == "link", env.payloads)
-    log_trace("Direct transport: $direct_count payloads")
-    log_trace("Link transport: $link_count payloads")
+    // Debug: Log input data structure
+    for (let i = 0; i < data.length; i++) {
+        const [dataname, payloadData, payloadType] = data[i];
+        logTrace(correlation_id, `smartpack: payload[${i}] dataname=${dataname}, type=${payloadType}, data type=${typeof payloadData}, constructor=${payloadData?.constructor?.name}`);
+    }

-    return env_json_str
-end
+    // Process payloads
+    const payloads = [];
+    for (const [dataname, payloadData, payloadType] of data) {
+        logTrace(correlation_id, `smartpack: Processing payload '${dataname}' type=${payloadType}`);
+        logTrace(correlation_id, `smartpack: payloadData type=${typeof payloadData}, constructor=${payloadData?.constructor?.name}`);
        
+        const payloadBytes = await serializeData(payloadData, payloadType);
+        const payloadSize = payloadBytes.byteLength;

-# Run the test
-println("Starting mixed-content transport test...")
-println("Correlation ID: $correlation_id")
+        logTrace(correlation_id, `Serialized payload '${dataname}' (type: ${payloadType}) size: ${payloadSize} bytes`);

-# Run sender
-println("start smartpack for mixed content")
-env_json_str = test_mix_send()
+        // 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(' ')}`);
+        }

-println("\nTest completed.")
-println("Note: Run test_julia_to_julia_mix_receiver.jl to receive the messages.")
+        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);
+
+    return [env, env_json_str];
+}
+
+/**
+ * Receive and process messages
+ * 
+ * This function processes incoming 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 {string|Object} msg - Message payload. Accepts either a JSON string directly,
+ *          or an object with a `data` or `payload` property containing the JSON string.
+ * @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 from JSON string directly
+ * const env = await msghandlerCSR.smartunpack(jsonString, {
+ *     fileserver_download_handler: msghandlerCSR.fetchWithBackoff,
+ *     max_retries: 5,
+ *     base_delay: 100,
+ *     max_delay: 5000
+ * });
+ * 
+ * // Receive from transport message object (e.g., NATS, MQTT)
+ * const env = await msghandlerCSR.smartunpack(natsMsg, {
+ *     fileserver_download_handler: msghandlerCSR.fetchWithBackoff
+ * });
+ * // 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 smartunpack(msg, options = {}) {
+    const {
+        fileserver_download_handler = fetchWithBackoff,
+        max_retries = 5,
+        base_delay = 100,
+        max_delay = 5000
+    } = options;
+
+    let envJsonObj;
+
+    // NATS's Javascript lib already return JSON object
+    if (msg !== null && typeof msg === 'object') {
+        envJsonObj = msg;
+    } else {
+        throw new Error('Invalid message format: expected JSON string or message object');
+    }
+ 
+    logTrace(envJsonObj.correlation_id, 'Processing received message');
+    logTrace(envJsonObj.correlation_id, `smartunpack: envelope has ${envJsonObj.payloads.length} payloads`);
+
+    // Process all payloads in the envelope
+    const payloadsList = [];
+    const numPayloads = envJsonObj.payloads.length;
+
+    logTrace(envJsonObj.correlation_id, `smartunpack: 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, `smartunpack: 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, `smartunpack: Successfully processed all ${payloadsList.length} payloads`);
+    envJsonObj.payloads = payloadsList;
+    return envJsonObj;
+}
+
+// ---------------------------------------------- Module Exports ---------------------------------------------- //
+
+const msghandlerCSR = {
+    /**
+     * Send data with automatic transport selection
+     */
+    smartpack,
+
+    /**
+     * Receive and process messages
+     */
+    smartunpack,
+
+    /**
+     * 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 msghandlerCSR;
Author	SHA1	Message	Date
ton	d257175cdb	Merge pull request 'v1.2.0-HTTP2' (#3 ) from v1.2.0-HTTP2 into v1.2.0 Reviewed-on: #3	2026-06-17 06:19:51 +00:00
narawat	8de8e8b2f0	update http2.o	2026-06-17 13:12:17 +07:00
narawat	eeb67cebd3	HTTP2.0	2026-06-17 13:09:50 +07:00
narawat	b6e1ca95ac	update comment	2026-06-13 19:00:30 +07:00
narawat	97821f83e5	update	2026-06-05 11:27:33 +07:00
narawat	0d1bf11b21	update	2026-05-29 11:30:23 +07:00