Upload 5 files

Dockerfile

@@ -0,0 +1,11 @@
+FROM julia:1.9
+
+WORKDIR /app
+
+COPY . .
+
+RUN julia --project=. -e 'using Pkg; Pkg.instantiate(); Pkg.precompile()'
+
+EXPOSE 7860
+
+CMD ["julia", "--project=.", "server.jl"]

Manifest.toml

@@ -0,0 +1,558 @@
+# This file is machine-generated - editing it directly is not advised
+
+julia_version = "1.9.3"
+manifest_format = "2.0"
+project_hash = "b83afd87647a69c61287d3f2945d7025e21be452"
+
+[[deps.Adapt]]
+deps = ["LinearAlgebra", "Requires"]
+git-tree-sha1 = "7e35fca2bdfba44d797c53dfe63a51fabf39bfc0"
+uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
+version = "4.4.0"
+weakdeps = ["SparseArrays", "StaticArrays"]
+
+    [deps.Adapt.extensions]
+    AdaptSparseArraysExt = "SparseArrays"
+    AdaptStaticArraysExt = "StaticArrays"
+
+[[deps.ArgTools]]
+uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f"
+version = "1.1.1"
+
+[[deps.Artifacts]]
+uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"
+
+[[deps.AxisAlgorithms]]
+deps = ["LinearAlgebra", "Random", "SparseArrays", "WoodburyMatrices"]
+git-tree-sha1 = "01b8ccb13d68535d73d2b0c23e39bd23155fb712"
+uuid = "13072b0f-2c55-5437-9ae7-d433b7a33950"
+version = "1.1.0"
+
+[[deps.Base64]]
+uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
+
+[[deps.BitFlags]]
+git-tree-sha1 = "0691e34b3bb8be9307330f88d1a3c3f25466c24d"
+uuid = "d1d4a3ce-64b1-5f1a-9ba4-7e7e69966f35"
+version = "0.1.9"
+
+[[deps.CSV]]
+deps = ["CodecZlib", "Dates", "FilePathsBase", "InlineStrings", "Mmap", "Parsers", "PooledArrays", "PrecompileTools", "SentinelArrays", "Tables", "Unicode", "WeakRefStrings", "WorkerUtilities"]
+git-tree-sha1 = "deddd8725e5e1cc49ee205a1964256043720a6c3"
+uuid = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b"
+version = "0.10.15"
+
+[[deps.ChainRulesCore]]
+deps = ["Compat", "LinearAlgebra"]
+git-tree-sha1 = "06ee8d1aa558d2833aa799f6f0b31b30cada405f"
+uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
+version = "1.25.2"
+weakdeps = ["SparseArrays"]
+
+    [deps.ChainRulesCore.extensions]
+    ChainRulesCoreSparseArraysExt = "SparseArrays"
+
+[[deps.CodecZlib]]
+deps = ["TranscodingStreams", "Zlib_jll"]
+git-tree-sha1 = "962834c22b66e32aa10f7611c08c8ca4e20749a9"
+uuid = "944b1d66-785c-5afd-91f1-9de20f533193"
+version = "0.7.8"
+
+[[deps.Compat]]
+deps = ["TOML", "UUIDs"]
+git-tree-sha1 = "9d8a54ce4b17aa5bdce0ea5c34bc5e7c340d16ad"
+uuid = "34da2185-b29b-5c13-b0c7-acf172513d20"
+version = "4.18.1"
+weakdeps = ["Dates", "LinearAlgebra"]
+
+    [deps.Compat.extensions]
+    CompatLinearAlgebraExt = "LinearAlgebra"
+
+[[deps.CompilerSupportLibraries_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae"
+version = "1.0.5+0"
+
+[[deps.ConcurrentUtilities]]
+deps = ["Serialization", "Sockets"]
+git-tree-sha1 = "d9d26935a0bcffc87d2613ce14c527c99fc543fd"
+uuid = "f0e56b4a-5159-44fe-b623-3e5288b988bb"
+version = "2.5.0"
+
+[[deps.Crayons]]
+git-tree-sha1 = "249fe38abf76d48563e2f4556bebd215aa317e15"
+uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f"
+version = "4.1.1"
+
+[[deps.DataAPI]]
+git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe"
+uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a"
+version = "1.16.0"
+
+[[deps.DataFrames]]
+deps = ["Compat", "DataAPI", "DataStructures", "Future", "InlineStrings", "InvertedIndices", "IteratorInterfaceExtensions", "LinearAlgebra", "Markdown", "Missings", "PooledArrays", "PrecompileTools", "PrettyTables", "Printf", "Random", "Reexport", "SentinelArrays", "SortingAlgorithms", "Statistics", "TableTraits", "Tables", "Unicode"]
+git-tree-sha1 = "a37ac0840a1196cd00317b57e39d6586bf0fd6f6"
+uuid = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
+version = "1.7.1"
+
+[[deps.DataStructures]]
+deps = ["Compat", "InteractiveUtils", "OrderedCollections"]
+git-tree-sha1 = "4e1fe97fdaed23e9dc21d4d664bea76b65fc50a0"
+uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
+version = "0.18.22"
+
+[[deps.DataValueInterfaces]]
+git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6"
+uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464"
+version = "1.0.0"
+
+[[deps.Dates]]
+deps = ["Printf"]
+uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"
+
+[[deps.Distributed]]
+deps = ["Random", "Serialization", "Sockets"]
+uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b"
+
+[[deps.Downloads]]
+deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"]
+uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6"
+version = "1.6.0"
+
+[[deps.ExceptionUnwrapping]]
+deps = ["Test"]
+git-tree-sha1 = "d36f682e590a83d63d1c7dbd287573764682d12a"
+uuid = "460bff9d-24e4-43bc-9d9f-a8973cb893f4"
+version = "0.1.11"
+
+[[deps.FilePathsBase]]
+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.FileWatching]]
+uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee"
+
+[[deps.Future]]
+deps = ["Random"]
+uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820"
+
+[[deps.HTTP]]
+deps = ["Base64", "CodecZlib", "ConcurrentUtilities", "Dates", "ExceptionUnwrapping", "Logging", "LoggingExtras", "MbedTLS", "NetworkOptions", "OpenSSL", "PrecompileTools", "Random", "SimpleBufferStream", "Sockets", "URIs", "UUIDs"]
+git-tree-sha1 = "5e6fe50ae7f23d171f44e311c2960294aaa0beb5"
+uuid = "cd3eb016-35fb-5094-929b-558a96fad6f3"
+version = "1.10.19"
+
+[[deps.InlineStrings]]
+git-tree-sha1 = "8f3d257792a522b4601c24a577954b0a8cd7334d"
+uuid = "842dd82b-1e85-43dc-bf29-5d0ee9dffc48"
+version = "1.4.5"
+
+    [deps.InlineStrings.extensions]
+    ArrowTypesExt = "ArrowTypes"
+    ParsersExt = "Parsers"
+
+    [deps.InlineStrings.weakdeps]
+    ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd"
+    Parsers = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0"
+
+[[deps.InteractiveUtils]]
+deps = ["Markdown"]
+uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
+
+[[deps.Interpolations]]
+deps = ["Adapt", "AxisAlgorithms", "ChainRulesCore", "LinearAlgebra", "OffsetArrays", "Random", "Ratios", "SharedArrays", "SparseArrays", "StaticArrays", "WoodburyMatrices"]
+git-tree-sha1 = "65d505fa4c0d7072990d659ef3fc086eb6da8208"
+uuid = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59"
+version = "0.16.2"
+
+    [deps.Interpolations.extensions]
+    InterpolationsForwardDiffExt = "ForwardDiff"
+    InterpolationsUnitfulExt = "Unitful"
+
+    [deps.Interpolations.weakdeps]
+    ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
+    Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"
+
+[[deps.InvertedIndices]]
+git-tree-sha1 = "6da3c4316095de0f5ee2ebd875df8721e7e0bdbe"
+uuid = "41ab1584-1d38-5bbf-9106-f11c6c58b48f"
+version = "1.3.1"
+
+[[deps.IteratorInterfaceExtensions]]
+git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856"
+uuid = "82899510-4779-5014-852e-03e436cf321d"
+version = "1.0.0"
+
+[[deps.JLLWrappers]]
+deps = ["Artifacts", "Preferences"]
+git-tree-sha1 = "0533e564aae234aff59ab625543145446d8b6ec2"
+uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210"
+version = "1.7.1"
+
+[[deps.JSON3]]
+deps = ["Dates", "Mmap", "Parsers", "PrecompileTools", "StructTypes", "UUIDs"]
+git-tree-sha1 = "411eccfe8aba0814ffa0fdf4860913ed09c34975"
+uuid = "0f8b85d8-7281-11e9-16c2-39a750bddbf1"
+version = "1.14.3"
+
+    [deps.JSON3.extensions]
+    JSON3ArrowExt = ["ArrowTypes"]
+
+    [deps.JSON3.weakdeps]
+    ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd"
+
+[[deps.LaTeXStrings]]
+git-tree-sha1 = "dda21b8cbd6a6c40d9d02a73230f9d70fed6918c"
+uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f"
+version = "1.4.0"
+
+[[deps.LibCURL]]
+deps = ["LibCURL_jll", "MozillaCACerts_jll"]
+uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21"
+version = "0.6.3"
+
+[[deps.LibCURL_jll]]
+deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"]
+uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0"
+version = "7.84.0+0"
+
+[[deps.LibGit2]]
+deps = ["Base64", "NetworkOptions", "Printf", "SHA"]
+uuid = "76f85450-5226-5b5a-8eaa-529ad045b433"
+
+[[deps.LibSSH2_jll]]
+deps = ["Artifacts", "Libdl", "MbedTLS_jll"]
+uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8"
+version = "1.10.2+0"
+
+[[deps.Libdl]]
+uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
+
+[[deps.LinearAlgebra]]
+deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"]
+uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+
+[[deps.Logging]]
+uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"
+
+[[deps.LoggingExtras]]
+deps = ["Dates", "Logging"]
+git-tree-sha1 = "f00544d95982ea270145636c181ceda21c4e2575"
+uuid = "e6f89c97-d47a-5376-807f-9c37f3926c36"
+version = "1.2.0"
+
+[[deps.MIMEs]]
+git-tree-sha1 = "c64d943587f7187e751162b3b84445bbbd79f691"
+uuid = "6c6e2e6c-3030-632d-7369-2d6c69616d65"
+version = "1.1.0"
+
+[[deps.Markdown]]
+deps = ["Base64"]
+uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"
+
+[[deps.MbedTLS]]
+deps = ["Dates", "MbedTLS_jll", "MozillaCACerts_jll", "NetworkOptions", "Random", "Sockets"]
+git-tree-sha1 = "c067a280ddc25f196b5e7df3877c6b226d390aaf"
+uuid = "739be429-bea8-5141-9913-cc70e7f3736d"
+version = "1.1.9"
+
+[[deps.MbedTLS_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1"
+version = "2.28.2+0"
+
+[[deps.Missings]]
+deps = ["DataAPI"]
+git-tree-sha1 = "ec4f7fbeab05d7747bdf98eb74d130a2a2ed298d"
+uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28"
+version = "1.2.0"
+
+[[deps.Mmap]]
+uuid = "a63ad114-7e13-5084-954f-fe012c677804"
+
+[[deps.MozillaCACerts_jll]]
+uuid = "14a3606d-f60d-562e-9121-12d972cd8159"
+version = "2022.10.11"
+
+[[deps.NetworkOptions]]
+uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908"
+version = "1.2.0"
+
+[[deps.OffsetArrays]]
+git-tree-sha1 = "117432e406b5c023f665fa73dc26e79ec3630151"
+uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
+version = "1.17.0"
+weakdeps = ["Adapt"]
+
+    [deps.OffsetArrays.extensions]
+    OffsetArraysAdaptExt = "Adapt"
+
+[[deps.OpenBLAS_jll]]
+deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"]
+uuid = "4536629a-c528-5b80-bd46-f80d51c5b363"
+version = "0.3.21+4"
+
+[[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", "JLLWrappers", "Libdl"]
+git-tree-sha1 = "f19301ae653233bc88b1810ae908194f07f8db9d"
+uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95"
+version = "3.5.4+0"
+
+[[deps.OrderedCollections]]
+git-tree-sha1 = "05868e21324cede2207c6f0f466b4bfef6d5e7ee"
+uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
+version = "1.8.1"
+
+[[deps.Oxygen]]
+deps = ["DataStructures", "Dates", "HTTP", "JSON3", "MIMEs", "Reexport", "RelocatableFolders", "Requires", "Sockets", "Statistics", "StructTypes"]
+git-tree-sha1 = "2ad010b0de6172faf1d09ed5e0837eb0b7355bd8"
+uuid = "df9a0d86-3283-4920-82dc-4555fc0d1d8b"
+version = "1.5.16"
+
+[[deps.Parsers]]
+deps = ["Dates", "PrecompileTools", "UUIDs"]
+git-tree-sha1 = "7d2f8f21da5db6a806faf7b9b292296da42b2810"
+uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0"
+version = "2.8.3"
+
+[[deps.Pkg]]
+deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"]
+uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
+version = "1.9.2"
+
+[[deps.PooledArrays]]
+deps = ["DataAPI", "Future"]
+git-tree-sha1 = "36d8b4b899628fb92c2749eb488d884a926614d3"
+uuid = "2dfb63ee-cc39-5dd5-95bd-886bf059d720"
+version = "1.4.3"
+
+[[deps.PrecompileTools]]
+deps = ["Preferences"]
+git-tree-sha1 = "5aa36f7049a63a1528fe8f7c3f2113413ffd4e1f"
+uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a"
+version = "1.2.1"
+
+[[deps.Preferences]]
+deps = ["TOML"]
+git-tree-sha1 = "522f093a29b31a93e34eaea17ba055d850edea28"
+uuid = "21216c6a-2e73-6563-6e65-726566657250"
+version = "1.5.1"
+
+[[deps.PrettyTables]]
+deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "Reexport", "StringManipulation", "Tables"]
+git-tree-sha1 = "66b20dd35966a748321d3b2537c4584cf40387c7"
+uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d"
+version = "2.3.2"
+
+[[deps.Printf]]
+deps = ["Unicode"]
+uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"
+
+[[deps.REPL]]
+deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"]
+uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
+
+[[deps.Random]]
+deps = ["SHA", "Serialization"]
+uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+
+[[deps.Ratios]]
+deps = ["Requires"]
+git-tree-sha1 = "1342a47bf3260ee108163042310d26f2be5ec90b"
+uuid = "c84ed2f1-dad5-54f0-aa8e-dbefe2724439"
+version = "0.4.5"
+
+    [deps.Ratios.extensions]
+    RatiosFixedPointNumbersExt = "FixedPointNumbers"
+
+    [deps.Ratios.weakdeps]
+    FixedPointNumbers = "53c48c17-4a7d-5ca2-90c5-79b7896eea93"
+
+[[deps.Reexport]]
+git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b"
+uuid = "189a3867-3050-52da-a836-e630ba90ab69"
+version = "1.2.2"
+
+[[deps.RelocatableFolders]]
+deps = ["SHA", "Scratch"]
+git-tree-sha1 = "ffdaf70d81cf6ff22c2b6e733c900c3321cab864"
+uuid = "05181044-ff0b-4ac5-8273-598c1e38db00"
+version = "1.0.1"
+
+[[deps.Requires]]
+deps = ["UUIDs"]
+git-tree-sha1 = "62389eeff14780bfe55195b7204c0d8738436d64"
+uuid = "ae029012-a4dd-5104-9daa-d747884805df"
+version = "1.3.1"
+
+[[deps.SHA]]
+uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce"
+version = "0.7.0"
+
+[[deps.Scratch]]
+deps = ["Dates"]
+git-tree-sha1 = "9b81b8393e50b7d4e6d0a9f14e192294d3b7c109"
+uuid = "6c6a2e73-6563-6170-7368-637461726353"
+version = "1.3.0"
+
+[[deps.SentinelArrays]]
+deps = ["Dates", "Random"]
+git-tree-sha1 = "ebe7e59b37c400f694f52b58c93d26201387da70"
+uuid = "91c51154-3ec4-41a3-a24f-3f23e20d615c"
+version = "1.4.9"
+
+[[deps.Serialization]]
+uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
+
+[[deps.SharedArrays]]
+deps = ["Distributed", "Mmap", "Random", "Serialization"]
+uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383"
+
+[[deps.SimpleBufferStream]]
+git-tree-sha1 = "f305871d2f381d21527c770d4788c06c097c9bc1"
+uuid = "777ac1f9-54b0-4bf8-805c-2214025038e7"
+version = "1.2.0"
+
+[[deps.Sockets]]
+uuid = "6462fe0b-24de-5631-8697-dd941f90decc"
+
+[[deps.SortingAlgorithms]]
+deps = ["DataStructures"]
+git-tree-sha1 = "64d974c2e6fdf07f8155b5b2ca2ffa9069b608d9"
+uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c"
+version = "1.2.2"
+
+[[deps.SparseArrays]]
+deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"]
+uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+
+[[deps.StaticArrays]]
+deps = ["LinearAlgebra", "PrecompileTools", "Random", "StaticArraysCore"]
+git-tree-sha1 = "b8693004b385c842357406e3af647701fe783f98"
+uuid = "90137ffa-7385-5640-81b9-e52037218182"
+version = "1.9.15"
+weakdeps = ["ChainRulesCore", "Statistics"]
+
+    [deps.StaticArrays.extensions]
+    StaticArraysChainRulesCoreExt = "ChainRulesCore"
+    StaticArraysStatisticsExt = "Statistics"
+
+[[deps.StaticArraysCore]]
+git-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a"
+uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c"
+version = "1.4.4"
+
+[[deps.Statistics]]
+deps = ["LinearAlgebra", "SparseArrays"]
+uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+version = "1.9.0"
+
+[[deps.StringManipulation]]
+deps = ["PrecompileTools"]
+git-tree-sha1 = "a04cabe79c5f01f4d723cc6704070ada0b9d46d5"
+uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e"
+version = "0.3.4"
+
+[[deps.StructTypes]]
+deps = ["Dates", "UUIDs"]
+git-tree-sha1 = "159331b30e94d7b11379037feeb9b690950cace8"
+uuid = "856f2bd8-1eba-4b0a-8007-ebc267875bd4"
+version = "1.11.0"
+
+[[deps.SuiteSparse_jll]]
+deps = ["Artifacts", "Libdl", "Pkg", "libblastrampoline_jll"]
+uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c"
+version = "5.10.1+6"
+
+[[deps.TOML]]
+deps = ["Dates"]
+uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76"
+version = "1.0.3"
+
+[[deps.TableTraits]]
+deps = ["IteratorInterfaceExtensions"]
+git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39"
+uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c"
+version = "1.0.1"
+
+[[deps.Tables]]
+deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "OrderedCollections", "TableTraits"]
+git-tree-sha1 = "f2c1efbc8f3a609aadf318094f8fc5204bdaf344"
+uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
+version = "1.12.1"
+
+[[deps.Tar]]
+deps = ["ArgTools", "SHA"]
+uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e"
+version = "1.10.0"
+
+[[deps.Test]]
+deps = ["InteractiveUtils", "Logging", "Random", "Serialization"]
+uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+
+[[deps.TranscodingStreams]]
+git-tree-sha1 = "0c45878dcfdcfa8480052b6ab162cdd138781742"
+uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa"
+version = "0.11.3"
+
+[[deps.URIs]]
+git-tree-sha1 = "bef26fb046d031353ef97a82e3fdb6afe7f21b1a"
+uuid = "5c2747f8-b7ea-4ff2-ba2e-563bfd36b1d4"
+version = "1.6.1"
+
+[[deps.UUIDs]]
+deps = ["Random", "SHA"]
+uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
+
+[[deps.Unicode]]
+uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
+
+[[deps.WeakRefStrings]]
+deps = ["DataAPI", "InlineStrings", "Parsers"]
+git-tree-sha1 = "b1be2855ed9ed8eac54e5caff2afcdb442d52c23"
+uuid = "ea10d353-3f73-51f8-a26c-33c1cb351aa5"
+version = "1.4.2"
+
+[[deps.WoodburyMatrices]]
+deps = ["LinearAlgebra", "SparseArrays"]
+git-tree-sha1 = "c1a7aa6219628fcd757dede0ca95e245c5cd9511"
+uuid = "efce3f68-66dc-5838-9240-27a6d6f5f9b6"
+version = "1.0.0"
+
+[[deps.WorkerUtilities]]
+git-tree-sha1 = "cd1659ba0d57b71a464a29e64dbc67cfe83d54e7"
+uuid = "76eceee3-57b5-4d4a-8e66-0e911cebbf60"
+version = "1.6.1"
+
+[[deps.Zlib_jll]]
+deps = ["Libdl"]
+uuid = "83775a58-1f1d-513f-b197-d71354ab007a"
+version = "1.2.13+0"
+
+[[deps.libblastrampoline_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "8e850b90-86db-534c-a0d3-1478176c7d93"
+version = "5.8.0+0"
+
+[[deps.nghttp2_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"
+version = "1.48.0+0"
+
+[[deps.p7zip_jll]]
+deps = ["Artifacts", "Libdl"]
+uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0"
+version = "17.4.0+0"

Project.toml

@@ -0,0 +1,10 @@
+[deps]
+CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b"
+DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
+Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
+HTTP = "cd3eb016-35fb-5094-929b-558a96fad6f3"
+Interpolations = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59"
+JSON3 = "0f8b85d8-7281-11e9-16c2-39a750bddbf1"
+Oxygen = "df9a0d86-3283-4920-82dc-4555fc0d1d8b"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"

index.html

@@ -0,0 +1,498 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>3D Mosquito Trajectory Visualizer</title>
+    <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
+
+    <style>
+        body { margin: 0; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; overflow: hidden; }
+        #controls.top-banner {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 60px; /* Fixed height for a slim look */
+            background: rgba(255, 255, 255, 0.95);
+            display: flex;
+            align-items: center;
+            justify-content: space-around; /* Distributes items evenly */
+            padding: 0 20px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+            z-index: 1000;
+            box-sizing: border-box;
+            font-family: sans-serif;
+            font-size: 13px;
+        }
+
+        .control-group {
+            display: flex;
+            flex-direction: column; /* Stack label over slider */
+            justify-content: center;
+            min-width: 150px;
+        }
+
+        .slider-header {
+            display: flex;
+            justify-content: space-between;
+            margin-bottom: 4px;
+            font-weight: bold;
+        }
+
+        .checkbox-label {
+            display: flex;
+            align-items: center; /* Centers the box with the text vertically */
+            gap: 8px;            /* Adds consistent space between box and text */
+            font-weight: bold;
+            cursor: pointer;
+            white-space: nowrap;
+            height: 100%;        /* Ensures it takes up full banner height if needed */
+        }
+
+        #reset-view {
+            padding: 6px 12px;
+            background: #f0f0f0;
+            border: 1px solid #ccc;
+            border-radius: 4px;
+            cursor: pointer;
+            transition: background 0.2s;
+        }
+
+        #reset-view:hover {
+            background: #e0e0e0;
+        }
+
+        .info-text {
+            font-size: 11px;
+            color: #888;
+            max-width: 240px;
+            line-height: 1.5;
+            text-align: center;
+        }
+
+        /* Adjust your Plotly container to make room for the banner */
+        #plot-container {
+            display: none; /* Hidden until data is loaded */
+            margin-top: 60px; 
+            height: calc(100vh - 60px);
+        }
+        .slider-label { display: flex; justify-content: space-between; margin-bottom: 8px; font-weight: bold; }
+        input[type=range] { width: 100%; }
+    </style>
+</head>
+<body>
+
+    <div id="controls" class="top-banner">
+        <div class="control-group" style="max-width: 300px; flex-direction: row; align-items: stretch;">
+            <input type="file" id="file-selector" style="display: none;" onchange="updateFilename(this)">
+            
+            <label for="file-selector" id="drop-zone" 
+                style="white-space: nowrap; overflow: hidden; text-overflow: ellipsis; padding: 8px; border: 1px solid #ccc; border-radius: 4px 4px 4px 4px; background: white; cursor: pointer; color: #666; display: flex; align-items: center; overflow: hidden;">
+                <span id="file-name-display">Click to select or Drop CSV...</span>
+            </label>
+
+            <button class="btn" id="process-btn" 
+                    style="background: #007bff; color: white; border: 1px solid #007bff; border-radius: 4px 4px 4px 4px; cursor: pointer; white-space: nowrap; margin-left:6px;" 
+                    onclick="uploadAndProcess()">
+                Process File
+            </button>
+        </div>
+
+        <div class="control-group">
+            <label class="checkbox-label">
+                <input type="checkbox" id="toggle-heatmap"> Density Heatmaps
+            </label>
+        </div>
+
+        <div class="control-group">
+            <div class="slider-header">
+                <span>Trajectories:</span>
+                <span id="percent-val">2%</span>
+            </div>
+            <input type="range" id="percent" min="1" max="100" value="2">
+        </div>
+
+        <div class="control-group">
+            <div class="slider-header">
+                <span>Opacity:</span>
+                <span id="opacity-val">0.99</span>
+            </div>
+            <input type="range" id="opacity" min="0" max="0.99" step="0.01" value="0.99">
+        </div>
+
+        <div class="control-group">
+            <button id="reset-view">Reset View</button>
+        </div>
+
+        <div class="info-text">
+            L: Rotate | Scroll: Zoom | R: Pan <br>
+            <i>Trajectories colored by starting times</i>
+        </div>
+    </div>
+    
+
+    <div id="plot-container"></div>
+
+    <script>
+
+        let allData = [];
+        let xMin, yMax, zMin;
+        let floorData, wallData, sideData; 
+        
+        function handleDrop(event) {
+            event.preventDefault();
+            const file = event.dataTransfer.files[0];
+            if (file) {
+                // Note: In local Chrome/Firefox, this usually grabs the filename.
+                // If the user drops from a local folder, it provides the name.
+                document.getElementById('path-input').value = file.name;
+            }
+            
+        }
+
+        function updateFilename(input) {
+            const nameDisplay = document.getElementById('file-name-display');
+            if (input.files.length > 0) {
+                nameDisplay.innerText = input.files[0].name;
+                nameDisplay.style.color = "#333";
+            }
+        }
+
+        async function uploadAndProcess() {
+            // 1. Get the file from a standard file input
+            // <input type="file" id="file-selector">
+            const fileElement = document.getElementById('file-selector');
+            const file = fileElement.files[0];
+            
+            if (!file) { alert("Please select a file first"); return; }
+
+            const btn = document.getElementById('process-btn');
+            btn.innerText = "Processing...";
+            btn.style.background = "#6c757d"; // Change to grey
+            btn.style.pointerEvents = "none"; // Prevent double-clicking
+
+            try {
+                // 2. Send the raw file to the backend
+                const response = await fetch('/process-file', {
+                    method: 'POST',
+                    body: file // Sending the blob directly
+                });
+
+                const data = await response.json();
+                
+                if (data.error) {
+                    alert("Error: " + data.error);
+                } else {
+                    allData = data.trajectories;
+                    
+                    // Re-flatten coordinate arrays for grid calculations
+                    const allX = allData.flatMap(t => t.x);
+                    const allY = allData.flatMap(t => t.y);
+                    const allZ = allData.flatMap(t => t.z);
+
+                    // Define the boundaries of your "box"
+                    xMin = allX.reduce((a, b) => Math.min(a, b), Infinity);
+                    yMax = allY.reduce((a, b) => Math.max(a, b), -Infinity);
+                    zMin = allZ.reduce((a, b) => Math.min(a, b), Infinity);
+
+                    floorData = computeDensityGrid(allX, allY);
+                    wallData = computeDensityGrid(allX, allZ);
+                    sideData = computeDensityGrid(allY, allZ);
+
+                    // 6. Trigger UI
+                    document.getElementById('plot-container').style.display = 'block';
+                    // updatePlot(document.getElementById('percent').value);
+                    //update slider to 2%
+                    document.getElementById('percent').value = 2;
+                    percentVal.innerText = "2%";
+                    updatePlot(2);
+                    console.log("Processed tracks:", allData.length);
+                }
+            } catch (err) {
+                console.error(err);
+                alert("Upload failed. Check file size.");
+            } finally {
+                btn.innerText = "Process File";
+                btn.style.background = "#3498db";
+                btn.style.pointerEvents = "auto"; // Re-enable button
+            }
+        }
+
+        // async function sendPathToJulia() {
+        //     const path = document.getElementById('path-input').value;
+        //     const btn = document.getElementById('process-btn');
+            
+        //     if (!path) {
+        //         alert("Please provide a file path.");
+        //         return;
+        //     }
+
+        //     btn.innerText = "Processing...";
+        //     btn.style.background = "#6c757d"; // Change to grey
+        //     btn.style.pointerEvents = "none"; // Prevent double-clicking
+
+        //     try {
+        //         const response = await fetch('http://localhost:8080/process-path', {
+        //             method: 'POST',
+        //             headers: { 'Content-Type': 'application/json' },
+        //             body: JSON.stringify({ path: path })
+        //         });
+
+        //         const data = await response.json();
+
+        //         if (data.error) {
+        //             alert("Julia Error: " + data.error);
+        //         } else {
+        //             console.log("Data received:", data);
+        //             allData = data.trajectories;
+                    
+        //             // Re-flatten coordinate arrays for grid calculations
+        //             const allX = allData.flatMap(t => t.x);
+        //             const allY = allData.flatMap(t => t.y);
+        //             const allZ = allData.flatMap(t => t.z);
+
+        //             // Define the boundaries of your "box"
+        //             xMin = allX.reduce((a, b) => Math.min(a, b), Infinity);
+        //             yMax = allY.reduce((a, b) => Math.max(a, b), -Infinity);
+        //             zMin = allZ.reduce((a, b) => Math.min(a, b), Infinity);
+
+        //             floorData = computeDensityGrid(allX, allY);
+        //             wallData = computeDensityGrid(allX, allZ);
+        //             sideData = computeDensityGrid(allY, allZ);
+
+        //             // 6. Trigger UI
+        //             document.getElementById('plot-container').style.display = 'block';
+        //             // updatePlot(document.getElementById('percent').value);
+        //             //update slider to 2%
+        //             document.getElementById('percent').value = 2;
+        //             percentVal.innerText = "2%";
+        //             updatePlot(2);
+        //             console.log("Processed tracks:", allData.length);
+                    
+        //         }
+        //     } catch (err) {
+        //         alert("Could not connect to Julia server. Is server.jl running?");
+        //         console.error(err);
+        //     } finally {
+        //         btn.innerText = "Process File";
+        //         btn.style.background = "#3498db";
+        //         btn.style.pointerEvents = "auto"; // Re-enable button
+        //     }
+        // }
+
+        // Use the variable name you defined in your Julia export
+        
+        const plotDiv = document.getElementById('plot-container');
+        const slider = document.getElementById('percent');
+        const percentVal = document.getElementById('percent-val');
+        const opacitySlider = document.getElementById('opacity');
+        const opacityVal = document.getElementById('opacity-val');
+
+        function computeDensityGrid(allX, allY, dX = 0.2) {
+            // 1. Define the grid boundaries
+            const xMin = allX.reduce((a, b) => Math.min(a, b), Infinity);
+            const xMax = allX.reduce((a, b) => Math.max(a, b), -Infinity);
+            const yMin = allY.reduce((a, b) => Math.min(a, b), Infinity);
+            const yMax = allY.reduce((a, b) => Math.max(a, b), -Infinity);
+
+            // 2. Calculate number of bins based on fixed dX
+            // We use Math.ceil to ensure we cover the entire range
+            const xBins = Math.ceil((xMax - xMin) / dX) + 1;
+            const yBins = Math.ceil((yMax - yMin) / dX) + 1;
+
+            // 3. Create 1D axis arrays for Plotly
+            // These represent the "ticks" on your floor/wall
+            const xRange = Array.from({length: xBins}, (_, i) => xMin + (i * dX));
+            const yRange = Array.from({length: yBins}, (_, i) => yMin + (i * dX));
+
+            // 4. Initialize 2D density grid with zeros [rows][columns]
+            // Plotly Surface expects z[yIndex][xIndex]
+            let density = Array.from({ length: yBins }, () => Array(xBins).fill(0));
+
+            // 5. Populate the grid (Binning)
+            for (let i = 0; i < allX.length; i++) {
+                // Calculate which bin the point falls into
+                const xIdx = Math.floor((allX[i] - xMin) / dX);
+                const yIdx = Math.floor((allY[i] - yMin) / dX);
+                
+                // Safety check to ensure indices stay within bounds
+                if (xIdx >= 0 && xIdx < xBins && yIdx >= 0 && yIdx < yBins) {
+                    density[yIdx][xIdx]++;
+                }
+            }
+
+            return { x: xRange, y: yRange, z: density };
+        }
+
+    
+        
+        let currentOpacity = 0.99;
+        let heatmapOpacity = 0.0;
+
+        function updatePlot(percent) {
+
+            if (!allData || allData.length === 0) return;
+
+            const plotDiv = document.getElementById('plot-container');
+            
+            // 1. Capture the CURRENT camera state
+            let currentCamera = null;
+            if (plotDiv && plotDiv.layout && plotDiv.layout.scene) {
+                currentCamera = plotDiv.layout.scene.camera;
+            }
+
+            // 1. Calculate how many trajectories to show
+            const totalToDisplay = Math.floor(allData.length * (percent / 100));
+            const subset = allData.slice(0, totalToDisplay);
+
+            // console.log("X range:", floorData.x[0], "to", floorData.x[floorData.x.length-1]);
+            // console.log("Y range:", floorData.y[0], "to", floorData.y[floorData.y.length-1]);
+            
+
+            // 2. Map data to Plotly traces
+            const traces = subset.map(t => ({
+                type: 'scatter3d',
+                mode: 'lines',
+                x: t.x,
+                y: t.y,
+                z: t.z,
+                line: {
+                    width: 2,
+                    // color: viridis(t.start_time / 3600) // Color by start time (assuming in seconds, converting to hours)
+                    // color:'#2c3e50'
+                    color: Array(t.x.length).fill(t.start_time),
+                    colorscale: 'YlGnBu',
+                    cmin: 0,
+                    cmax: 3600, // Assuming max start time is 60 minutes (3600 seconds)
+                },
+                opacity: currentOpacity, // Low opacity helps see the "void" density
+                hoverinfo: 'none' // Improves performance for 10k lines
+            }));
+
+            const floorSurface = {
+                type: 'surface',
+                x: floorData.x,
+                y: floorData.y,
+                z: floorData.y.map(() => floorData.x.map(() => zMin - 0.1)), // Constant Z
+                surfacecolor: floorData.z,
+                colorscale: 'Portland',
+                opacity: heatmapOpacity,
+                showscale: false,
+                hoverinfo: 'skip',
+                contours: {
+                    x: { show: false },
+                    y: { show: false },
+                    z: { show: false }
+                }
+
+            };
+
+            const wallSurface = {
+                type: 'surface',
+                // X-matrix: Create a row for every Z-bin
+                x: wallData.y.map(() => wallData.x), 
+                
+                // Y-matrix: Every single point in the grid is at the same 'yMax' (the wall)
+                y: wallData.z.map(row => row.map(() => yMax + 0.2)), 
+                
+                // Z-matrix: Create a column for every X-bin
+                z: wallData.y.map(zVal => Array(wallData.x.length).fill(zVal)), 
+                
+                surfacecolor: wallData.z,
+                colorscale: 'Portland',
+                opacity: heatmapOpacity,
+                showscale: false,
+                hoverinfo: 'skip',
+                contours: { x: {show: false}, y: {show: false}, z: {show: false} }
+            };
+
+            const sideSurface = {
+                type: 'surface',
+                // X-matrix: Every single point in the grid is at the same 'xMin' (the side wall)
+                x: sideData.z.map(row => row.map(() => xMin - 0.1)), 
+                
+                // Y-matrix: Create a row for every Z-bin
+                y: sideData.y.map(() => sideData.x), 
+                
+                // Z-matrix: Create a column for every Y-bin
+                z: sideData.y.map(zVal => Array(sideData.x.length).fill(zVal)), 
+                
+                surfacecolor: sideData.z,
+                colorscale: 'Portland',
+                opacity: heatmapOpacity,
+                showscale: false,
+                hoverinfo: 'skip',
+                contours: { x: {show: false}, y: {show: false}, z: {show: false} }
+            };
+
+            // 3. Define Layout (Crucial for seeing the exclusion zone)
+            const layout = {
+                scene: {
+                    camera: currentCamera || {
+                        eye: {x: 1.25, y: 1.25, z: 1.25}
+                    },
+                    xaxis: { title: 'X (m)', backgroundcolor: "#f8f9fa", showbackground: true, showspikes: false,  showgrid: true, zeroline: false, gridcolor: '#ffffff', gridwidth: 2 },
+                    yaxis: { title: 'Y (m)', backgroundcolor: "#f8f9fa", showbackground: true, showspikes: false, showgrid: true, zeroline: false, gridcolor: '#ffffff', gridwidth: 2 },
+                    zaxis: { title: 'Z (m)', backgroundcolor: "#f8f9fa", showbackground: true, showspikes: false, showgrid: true, zeroline: false, gridcolor: '#ffffff', gridwidth: 2 },
+                    aspectmode: 'data' // Ensures 1:1:1 spatial scale
+                    
+                },
+                margin: { l: 0, r: 0, b: 0, t: 0 },
+                showlegend: false,
+                uirevision: 'constant-state-key' // Preserve camera view on updates
+            };
+
+            const config = {
+                responsive: true,
+                displaylogo: false
+            };
+
+            const dataToPlot = [ floorSurface, wallSurface, sideSurface, ...traces ];
+
+            Plotly.react(plotDiv, dataToPlot, layout, config);
+        }
+
+
+        // Event Listeners
+        slider.oninput = function() {
+            percentVal.innerText = this.value + "%";
+        };
+
+        slider.onchange = function() {
+            updatePlot(this.value);
+        };
+
+        opacitySlider.oninput = function() {
+            currentOpacity = parseFloat(this.value);
+            opacityVal.innerText = currentOpacity;
+            // Trigger a re-render with the new opacity
+            updatePlot(document.getElementById('percent').value);
+        };
+
+        // 3. Reset View Listener
+        document.getElementById('reset-view').onclick = function() {
+            Plotly.relayout('plot-container', {
+                'scene.camera': {
+                    eye: {x: 1.25, y: 1.25, z: 1.25}, // Default Plotly camera position
+                    center: {x: 0, y: 0, z: 0},
+                    up: {x: 0, y: 0, z: 1}
+                }
+            });
+        };
+
+        document.getElementById('toggle-heatmap').onchange = function() {
+            showHeatmaps = this.checked;
+            // if checked set heatmapOpacity to 0.6 else 0.0
+            heatmapOpacity = showHeatmaps ? 0.6 : 0.0;
+            // Get the current trajectory percentage to maintain state
+            const currentPercent = document.getElementById('percent').value;
+            updatePlot(currentPercent);
+        };
+
+
+        // Initial render
+        window.onload = () => updatePlot(2);
+
+    </script>
+</body>
+</html>

server.jl

@@ -0,0 +1,161 @@
+using Oxygen, HTTP, JSON3, CSV, DataFrames, Dates, Random, Statistics, Interpolations
+
+parse_date(d::AbstractString) = DateTime(d, dateformat"yyyy-mm-dd HH:MM:SS.ssss")
+
+function export_clean_traces(file;
+        min_track_length = 1.0, min_start_time = 300.0, max_start_time=Inf,
+        wall_buffer_x = 0.0 , wall_buffer_y = 0.0, wall_buffer_z = 0.0
+)
+
+    data = CSV.read(file, DataFrame)
+    df = convert(DataFrame,data)
+    groups = groupby(df, 1)
+    
+    starting_times, clean_traces = save_data(groups, file; 
+        min_track_length=min_track_length, min_start_time=min_start_time, max_start_time=max_start_time,
+        wall_buffer_x=wall_buffer_x, wall_buffer_y=wall_buffer_y, wall_buffer_z=wall_buffer_z
+    )
+    
+    return starting_times, clean_traces
+    
+end
+
+
+function save_data(groups, file; 
+        min_track_length = 1.0, min_start_time = 300.0, max_start_time = Inf,
+        wall_buffer_x = 0.0 , wall_buffer_y = 0.0, wall_buffer_z = 0.0
+    )
+    # first, compute positions of wall
+    min_x = Vector{Float64}()
+    max_x = Vector{Float64}()
+    min_y = Vector{Float64}()
+    max_y = Vector{Float64}()
+    min_z = Vector{Float64}()
+    max_z = Vector{Float64}()
+    for g in groups
+        push!(min_x,minimum(g[:,3]))
+        push!(max_x,maximum(g[:,3]))
+        push!(min_y,minimum(g[:,4]))
+        push!(max_y,maximum(g[:,4]))
+        push!(min_z,minimum(g[:,5]))
+        push!(max_z,maximum(g[:,5]))
+    end
+
+    wall_robust = [(quantile(min_x,0.01),quantile(max_x,0.99)),(quantile(min_y,0.01),quantile(max_y,0.99)),(quantile(min_z,0.01),quantile(max_z,0.99))]
+    println("Wall x position: ", wall_robust[1])
+    println("Wall y position: ", wall_robust[2])
+    println("Wall z position: ", wall_robust[3])
+
+    # Filter tracks based on time requirements
+    experiment_start_time = parse_date(groups[1].datetime[1][1:end-3])
+    long_traces = []
+    for g in groups
+        track_end_time = parse_date(g.datetime[end][1:end-3])
+        track_start_time = parse_date(g.datetime[1][1:end-3])
+        if Dates.value(track_end_time - track_start_time)/1000 > min_track_length && Dates.value(track_start_time-experiment_start_time)/1000 > min_start_time && Dates.value(track_start_time-experiment_start_time)/1000 < max_start_time
+            push!(long_traces,g)
+        end
+    end
+
+    # Filter tracks based on position from wall
+    final_traces = []
+    times = []
+    starting_times = []
+    for g in long_traces
+        if all(g[:,3] .> wall_robust[1][1]+wall_buffer_x) && all(g[:,3] .< wall_robust[1][2]-wall_buffer_x) && all(g[:,4] .> wall_robust[2][1]+wall_buffer_y) && all(g[:,4] .< wall_robust[2][2]-wall_buffer_y) && all(g[:,5] .> wall_robust[3][1]+wall_buffer_z) && all(g[:,5] .< wall_robust[3][2]-wall_buffer_z)
+            push!(final_traces,g)
+            tmp = []
+            for i in 1:length(g.datetime)
+                push!(tmp,Dates.value(parse_date(g.datetime[i][1:end-3])-parse_date(g.datetime[1][1:end-3]))/1000)
+            end
+            push!(starting_times,Dates.value(parse_date(g.datetime[1][1:end-3])-experiment_start_time)/1000)
+            push!(times,tmp)
+        end
+    end
+
+
+    clean_traces = Vector{Matrix{Float64}}()
+    for g in 1:length(final_traces)
+        if sum(diff(times[g]) .<= 0.0) == 0
+            # ts = LinRange(0.0,times[g][end],Int(round(times[g][end]*100)+1))
+            ts = collect(0.0:0.01:times[g][end]) # fix dt to 0.01 seconds
+            interp_linear_xs = linear_interpolation(times[g], final_traces[g][:,3])
+            interp_linear_ys = linear_interpolation(times[g], final_traces[g][:,4])
+            interp_linear_zs = linear_interpolation(times[g], final_traces[g][:,5])
+
+            temp = zeros(length(ts),5)
+            temp[:,1] = interp_linear_xs.(ts) / 100 # convert cm to m
+            temp[:,2] = interp_linear_ys.(ts) / 100
+            temp[:,3] = interp_linear_zs.(ts) / 100
+            temp[:,4] = ts
+
+            for j in 1:length(ts)
+                if round(ts[j],digits=2) in times[g]
+                    temp[j,5] = 1.0
+                else
+                    temp[j,5] = 0.0
+                end
+            end
+            push!(clean_traces,temp)
+        else
+            println("Skipping track ",g)
+            deleteat!(starting_times, g)
+        end
+    end
+
+    return starting_times, clean_traces
+
+end
+
+function unzip(collection)
+    firsts = [x[1] for x in collection]
+    seconds = [x[2] for x in collection]
+    return firsts, seconds
+end
+
+# Re-use your existing processing logic here
+function process_big_csv(filepath)
+    start_times, traces = export_clean_traces(filepath;
+        min_track_length = 1.0, min_start_time = 0.0, max_start_time=Inf,
+    )
+    combined = collect(zip(start_times, traces))
+    shuffle!(combined)
+    # Separate the shuffled arrays
+    start_times, traces = unzip(combined);
+    payload = Dict("trajectories"=> [Dict("start_time" => start_times[i],
+                     "x" => Float32.(traces[i][:,1]),
+                     "y" => Float32.(traces[i][:,3]),
+                     "z" => Float32.(traces[i][:,2]),
+                    ) for i in 1:length(traces)]
+                )
+    return payload  # A dictionary/struct
+end
+
+@get "/" function()
+    return file("index.html")
+end
+
+@post "/process-path" function(req)
+    # Julia receives the file path or raw bytes
+    # Processes it at 100% precision
+    data = JSON3.read(String(req.body))
+    filepath = data.path
+    data = process_big_csv(filepath)
+    return data # Automatically converted to JSON
+end
+
+@post "/process-file" function(req)
+    try
+        # req.body contains the raw bytes of the uploaded 600MB file
+        # We wrap it in an IOBuffer so CSV.read can process it in RAM
+        data = process_big_csv(IOBuffer(req.body))
+                
+        # Return results (Oxygen handles JSON conversion)
+        return data
+    catch e
+        return HTTP.Response(500, JSON3.write(Dict("error" => string(e))))
+    end
+end
+
+staticfiles(".")
+serve(host="0.0.0.0", port=7860)