fastled 1.2.40__tar.gz → 1.2.42__tar.gz

{fastled-1.2.40 → fastled-1.2.42}/.github/workflows/build_multi_docker_image.yml

@@ -20,27 +20,13 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 2
-      - name: Check FastLED repo
-        uses: actions/checkout@v4
-        with:
-          repository: fastled/fastled
-          path: fastled
       - id: check
         run: |
           # Check if there are any changes in workflow repository
-          WORKFLOW_CHANGED=$(git diff --quiet HEAD^1 HEAD || echo "changed")
-          
-          # Check FastLED repo for changes in last 24 hours
-          cd fastled
-          FASTLED_CHANGED=$(git log --since="24 hours ago" --oneline | wc -l)
-          
-          if [[ -n "$WORKFLOW_CHANGED" ]] || [[ "$FASTLED_CHANGED" -gt 0 ]]; then
-            echo "Changes detected in workflow repository or FastLED in last 24h"
-            echo "should_run=true" >> $GITHUB_OUTPUT
-          else
-            echo "No recent changes detected"
-            echo "should_run=false" >> $GITHUB_OUTPUT
-          fi
+          # At this point always run, this used to trigger on changes to fastled repo (mostly for the compiler stuff)
+          # but that has been moved to this repo.
+          echo "should_run=true" >> $GITHUB_OUTPUT
+
 
   build-amd64:
     needs: check-if-changed
@@ -73,8 +59,8 @@ jobs:
         uses: docker/build-push-action@v6
         with:
           platforms: ${{ matrix.platform }}
-          context: https://github.com/fastled/fastled.git
-          file: src/platforms/wasm/compiler/Dockerfile
+          context: https://github.com/zackees/fastled-wasm.git
+          file: Dockerfile
           labels: ${{ steps.meta.outputs.labels }}
           outputs: type=image,name=${{ env.REGISTRY_IMAGE }},push-by-digest=true,name-canonical=true,push=true
           build-args: |
@@ -125,8 +111,8 @@ jobs:
         uses: docker/build-push-action@v6
         with:
           platforms: ${{ matrix.platform }}
-          context: https://github.com/fastled/fastled.git
-          file: src/platforms/wasm/compiler/Dockerfile
+          context: https://github.com/zackees/fastled-wasm.git
+          file: Dockerfile
           labels: ${{ steps.meta.outputs.labels }}
           outputs: type=image,name=${{ env.REGISTRY_IMAGE }},push-by-digest=true,name-canonical=true,push=true
           build-args: |

fastled-1.2.42/Dockerfile

@@ -0,0 +1,205 @@
+# Overview of this docker file
+# This is a emscripten docker file that is used to compile FastLED for the web assembly platform.
+# The goals of this docker are:
+#   * Compile the inputs as quickly as possible.
+#   * Be very fast to rebuild
+# Container size is important, but not the primary goal.
+#
+# The emscripten build is based on emscripten. We create a custom `wasm_compiler_flags.py``
+# that performs the necessary transformations to make this work.
+#
+# Maximizing compiler speed
+# First let's talk about why platformio is typically slow
+#   * Network checking to see if the repo's are up to date
+#   * Unnecessary recompilation of cpp files that haven't changed.
+#
+# We address these slow compiler speeds via a few tricks
+#   * The emscripten compiler is wrapped in ccache so that identical compilations are cached.
+#   * We prewarm the ccache with a pre-compile of an example
+#     * This will generate the initial cache and also install the necessary tools.
+#
+# Pre-warming the cache
+#   * We have two pre-warm cycles. We do this for speed reasons.
+#     * The first pre-warm is done with a copy of fastled downloaded from the github repo
+#       * Docker is very relaxed on invalidating a cache layer for statements cloning a github repo. We want this.
+#       * So we clone the repo early in the docker image build cycle. Then we run a pre-warm compile.
+#         * This is the slowest pre-warm, and once built, tends to always be cached. However, it tends to go out of date
+#           quickly, which will make the cache be less effective.
+#   * The second pre-warm is done with a fresh copy of the fastled repo from the host machine that is copied over the
+#     git hub repo. We copy directories piece by piece to maximize the cache hit rate. Core files then platform files.
+#     * During developement when many files are changed, this second pre-warm will almost always be invalidated, however
+#       it is very fast to rebuild because the initial tool download of platformio has already been done with the first pre-warm.
+#     * After this second pre-warm, the ccache will have the exact state of the repo in it's cache.
+#
+# Final state
+#  * The final state of the docker image is a pre-warmed cached with the entire instance ready to compile.
+#  * The calling code is expected to provide volume mapped directory that will be inserted into the docker image when it runs.
+#  * However, this is not true when using this in server mode (see server.py) where the code to be compiled is injected into the
+#    container instance via a FastAPI route, the compilation is performed. Typically the web compiler is much better at holding
+#    on the cached files. Server.py will also periodically git pull the fastled repo to keep in sync with the latest changes.
+
+
+# This will be set to arm64 to support MacOS M1+ devices (and Linux-based arm64 devices)
+ARG PLATFORM_TAG=""
+
+# Use only Emscripten base image
+FROM emscripten/emsdk:3.1.70${PLATFORM_TAG}
+
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Update the apt-get package list. This takes a long time, so we do it first to maximize cache hits.
+# Also install apt-fast first
+RUN apt-get update
+
+RUN apt-get install -y software-properties-common
+
+RUN add-apt-repository ppa:apt-fast/stable -y && \
+    apt-get update && \
+    apt-get -y install apt-fast
+
+# Update apt and install required packages
+RUN apt-fast install -y \
+    git \
+    gawk \
+    nano \
+    ca-certificates \
+    python3 \
+    python3-pip \
+    dos2unix \
+    tar \
+    wget \
+    unzip \
+    make \
+    cmake \
+    ninja-build \
+    ccache \
+    zlib1g \
+    zlib1g-dev \
+    gcc \
+    g++ \
+    rsync \
+    && rm -rf /var/lib/apt/lists/*
+
+
+# /container/bin contains symbolic links to python3 and pip3 as python and pip that we use for the compiler.
+RUN mkdir -p /container/bin && \
+    ln -s /usr/bin/python3 /container/bin/python && \
+    ln -s /usr/bin/pip3 /container/bin/pip
+
+
+# Add Python and Emscripten to PATH
+ENV PATH="/container/bin:/usr/local/bin:/usr/bin:/emsdk:/emsdk/upstream/emscripten:${PATH}"
+ENV CCACHE_DIR=/ccache
+ENV CCACHE_MAXSIZE=1G
+
+# Create a custom print script
+RUN echo '#!/bin/sh' > /usr/bin/print && \
+    echo 'echo "$@"' >> /usr/bin/print && \
+    chmod +x /usr/bin/print
+
+# Add print function (which seems to be missing, strangly) and PATH modifications to /etc/profile
+RUN echo 'print() { echo "$@"; }' >> /etc/profile && \
+    echo 'export -f print' >> /etc/profile && \
+    echo 'export PATH="/container/bin:/usr/bin:/emsdk:/emsdk/upstream/emscripten:$PATH"' >> /etc/profile && \
+    echo 'source /emsdk/emsdk_env.sh' >> /etc/profile
+
+# This was added to try and fix formatting issues. It didn't fix it but it's better to force everything to use
+# utf-8, as god intended it.
+ENV LANG=en_US.UTF-8
+ENV LC_CTYPE=UTF-8
+RUN echo 'export LANG=en_US.UTF-8' >> /etc/profile && \
+    echo 'export LC_CTYPE=UTF-8' >> /etc/profile
+
+# This is disabled code to try and use the arduino-cli to transform an *.ino file into a cpp file
+# to enable the auto-predeclaration of missing functions. However, Arduino-cli is absolutely gigantic
+# and requires that we compile it against one of the platforms. This doesn't work for us because
+# we don't want a compile failure because of something weird in the platform we are compiling against, which
+# isn't wasm.
+#COPY compiler/install-arduino-cli.sh /install-arduino-cli.sh
+#RUN chmod +x /install-arduino-cli.sh && /install-arduino-cli.sh || echo "Failed to install Arduino CLI"
+
+RUN pip install uv==0.5.6
+
+# Get the compiler requirements and install them.
+COPY compiler/requirements.txt /install/requirements.txt
+RUN uv pip install --system -r /install/requirements.txt
+
+RUN pio settings set check_platformio_interval 9999
+RUN pio settings set enable_telemetry 0
+
+# FIRST PRE-WARM CYCLE and initial setup: Download the fastled repo from the github and pre-warm the cache with a compilation.
+# This is by far the most expensive part of the build, because platformio needs to download initial tools. This
+# pre-warm cycle is "sticky" and tends to stay in the cache for a long time since docker is very relaxed about
+# invalidating cache layers that clone a github repo.
+
+ARG FASTLED_BUILD_DAY=echo $(date +'%Y-%m-%d')
+ENV FASTLED_BUILD_DAY=${FASTLED_BUILD_DAY}
+
+ARG FASTLED_VERSION=master
+ENV FASTLED_VERSION=${FASTLED_VERSION}
+RUN git clone -b ${FASTLED_VERSION} https://github.com/fastled/FastLED.git --depth 1 /git/fastled && \
+    mkdir -p /js/fastled && \
+    rsync -a /git/fastled/ /js/fastled/ --exclude='.git'
+
+# Create symlinks for wasm platform files.
+COPY compiler/init_runtime.py /js/init_runtime.py
+COPY compiler/prewarm.sh /js/prewarm.sh
+
+WORKDIR /js
+
+ARG NO_PREWARM=0
+ENV NO_PREWARM=${NO_PREWARM}
+
+RUN python /js/init_runtime.py || true
+
+
+# First pre-warm cycle - always do it as part of the build.
+RUN mkdir -p /logs
+
+# Force a build if the compiler flags change.
+COPY compiler/wasm_compiler_flags.py /trash/wasm_compiler_flags.py
+COPY compiler/CMakeLists.txt /trash/CMakeLists.txt
+RUN rm -rf /trash
+
+RUN chmod +x /js/prewarm.sh && \
+    cat /js/prewarm.sh >> /logs/prewarm.log.0
+RUN /js/prewarm.sh --force >> /logs/prewarm.log.1 || true
+
+
+# # Copy the fastled repo from the host machine and prepare for pre-warm
+# # Make sure and delete files that have been removed so that we don't get
+# # duplicate symbols from stale files.
+# COPY *.json /host/fastled/
+# COPY src/*.* /host/fastled/src/
+# COPY examples /host/fastled/examples
+# COPY src/fx /host/fastled/src/fx
+# COPY src/fl /host/fastled/src/fl
+# COPY src/lib8tion /host/fastled/src/lib8tion
+# COPY src/third_party /host/fastled/src/third_party
+# COPY src/sensors /host/fastled/src/sensors
+# COPY src/platforms /host/fastled/src/platforms
+
+COPY compiler /js/compiler
+
+COPY compiler/entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh && dos2unix /entrypoint.sh
+
+# RSYNC DISABLED FOR NOW
+# now sync local to the source directory.
+# RUN rsync -av /host/fastled/ /js/fastled/ && rm -rf /host/fastled
+
+RUN python /js/init_runtime.py || true
+
+
+# SECOND PRE-WARM CYCLE: Copy the fastled repo from the host machine and pre-warm the cache with that compilation. This will
+# be much quicker than the first pre-warm cycle.
+RUN /js/prewarm.sh --force > /logs/prewarm.log.2 || true
+
+# Now timestamp the image and store it at the end of the build.
+RUN date > /image_timestamp.txt
+
+ENTRYPOINT ["/entrypoint.sh"]
+CMD ["python", "/js/run.py", "server"]
+
+# CMD ["/bin/bash", "/entrypoint.sh"]

{fastled-1.2.40 → fastled-1.2.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fastled
-Version: 1.2.40
+Version: 1.2.42
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
@@ -294,6 +294,8 @@ A: `delay()` will block `loop()` which blocks the main thread of the browser. Th
 Q: How can I get the compiled size of my FastLED sketch smaller?
 A: A big chunk of space is being used by unnecessary javascript `emscripten` bundling. The wasm_compiler_settings.py file in the FastLED repo can tweak this.
 
+
+
 # Revisions
 
   * 1.2.31 - Bunch of fixes and ease of use while compiling code in the repo.

{fastled-1.2.40 → fastled-1.2.42}/README.md

@@ -268,6 +268,8 @@ A: `delay()` will block `loop()` which blocks the main thread of the browser. Th
 Q: How can I get the compiled size of my FastLED sketch smaller?
 A: A big chunk of space is being used by unnecessary javascript `emscripten` bundling. The wasm_compiler_settings.py file in the FastLED repo can tweak this.
 
+
+
 # Revisions
 
   * 1.2.31 - Bunch of fixes and ease of use while compiling code in the repo.

fastled-1.2.42/compiler/.dockerignore

@@ -0,0 +1,2 @@
+**/.mypy_cache/
+**/.ruff_cache/

fastled-1.2.42/compiler/CMakeLists.txt

@@ -0,0 +1,139 @@
+cmake_minimum_required(VERSION 3.10)
+project(FastLED_WASM)
+
+# Enable verbose makefile output for all compiled sources
+set(CMAKE_VERBOSE_MAKEFILE ON)
+
+# --- Set Emscripten as the Compiler ---
+set(CMAKE_C_COMPILER "emcc")
+set(CMAKE_CXX_COMPILER "em++")
+set(CMAKE_AR "emar")
+set(CMAKE_RANLIB "emranlib")
+
+# Use ccache as a compiler launcher (requires CMake 3.4 or newer)
+set(CMAKE_C_COMPILER_LAUNCHER "ccache")
+set(CMAKE_CXX_COMPILER_LAUNCHER "ccache")
+
+# --- Build Mode and Optimization Level ---
+if(NOT DEFINED ENV{BUILD_MODE})
+    set(BUILD_MODE "QUICK")
+else()
+    set(BUILD_MODE $ENV{BUILD_MODE})
+endif()
+
+if(BUILD_MODE STREQUAL "QUICK")
+    set(OPT_LEVEL "-O0")
+elseif(BUILD_MODE STREQUAL "DEBUG")
+    set(OPT_LEVEL "-Og")
+else() # RELEASE
+    set(OPT_LEVEL "-Oz")
+endif()
+
+# --- Common Compiler and Linker Flags ---
+set(COMMON_COMPILE_FLAGS
+    -DFASTLED_ENGINE_EVENTS_MAX_LISTENERS=50
+    -DFASTLED_FORCE_NAMESPACE=1
+    -DFASTLED_NO_FORCE_INLINE
+    -DFASTLED_USE_PROGMEM=0
+    -DDISABLE_EXCEPTION_CATCHING=1
+    -fno-exceptions
+    -fno-rtti
+    -DEMSCRIPTEN_HAS_UNBOUND_TYPE_NAMES=0
+    -std=gnu++17
+    -fpermissive
+    -fno-inline
+    -Wno-constant-logical-operand
+    -Wnon-c-typedef-for-linkage
+    -Werror=bad-function-cast
+    -Werror=cast-function-type
+    -sUSE_PTHREADS=0          # Disable threading support
+    ${OPT_LEVEL}
+)
+
+# (Optional: PROFILE flags can be added here if needed)
+
+set(COMMON_LINK_FLAGS
+    -sALLOW_MEMORY_GROWTH=0
+    -sDISABLE_EXCEPTION_CATCHING=1
+    -sDISABLE_EXCEPTION_THROWING=0
+    -sWASM_BIGINT
+    --bind
+    -DUSE_OFFSET_CONVERTER=0
+    -sINITIAL_MEMORY=134217728
+    -fuse-ld=lld
+    --no-entry
+    -sMODULARIZE=1
+)
+
+set(LIBRARY_LINK_FLAGS
+    ${COMMON_LINK_FLAGS}
+)
+
+set(SKETCH_LINK_FLAGS
+    ${COMMON_LINK_FLAGS}
+    -sEXPORTED_RUNTIME_METHODS=['ccall','cwrap','stringToUTF8','lengthBytesUTF8']
+    -sEXPORTED_FUNCTIONS=['_malloc','_free','_extern_setup','_extern_loop','_fastled_declare_files']
+    -sEXPORT_NAME=fastled
+    -o fastled.js
+)
+
+if(BUILD_MODE STREQUAL "DEBUG")
+    list(APPEND COMMON_COMPILE_FLAGS
+        -g3
+        -fsanitize=address
+        -fsanitize=undefined
+    )
+    set(DEBUG_LINK_FLAGS
+        -gsource-map
+        --emit-symbol-map
+        -sSTACK_OVERFLOW_CHECK=2
+        -ASSERTIONS=1
+    )
+    list(APPEND LIBRARY_LINK_FLAGS ${DEBUG_LINK_FLAGS})
+    list(APPEND SKETCH_LINK_FLAGS ${DEBUG_LINK_FLAGS})
+endif()
+
+# --- FASTLED LIBRARY SETUP ---
+set(LIBFASTLED_PATH /precompiled/libfastled.a)
+
+if(EXISTS ${LIBFASTLED_PATH})
+    message(STATUS "Found prebuilt libfastled.a at ${LIBFASTLED_PATH}, skipping build of FastLED library.")
+    add_library(fastled STATIC IMPORTED)
+    set_target_properties(fastled PROPERTIES IMPORTED_LOCATION ${LIBFASTLED_PATH})
+else()
+    message(FATAL_ERROR "Did not find precompiled libfastled.a at ${LIBFASTLED_PATH}. Please build the library first.")
+endif()
+
+if(TARGET fastled)
+    set_target_properties(fastled PROPERTIES
+        CXX_STANDARD 17
+        CXX_STANDARD_REQUIRED ON
+        POSITION_INDEPENDENT_CODE ON
+    )
+endif()
+
+# --- LIBRARY TARGET: sketch_lib ---
+file(GLOB_RECURSE ALL_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
+message(STATUS "All sources: ${ALL_SOURCES}")
+
+add_library(sketch_lib STATIC ${ALL_SOURCES})
+
+target_compile_options(sketch_lib PRIVATE ${COMMON_COMPILE_FLAGS})
+target_compile_definitions(sketch_lib PRIVATE SKETCH_COMPILE)
+target_include_directories(sketch_lib PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+    "/precompiled/include"
+)
+set_target_properties(sketch_lib PROPERTIES
+    CXX_STANDARD 17
+    CXX_STANDARD_REQUIRED ON
+)
+
+# ── FINAL LINKING STEP: Produce fastled.js ──
+# This custom target invokes em++ to link the static library (sketch_lib)
+# with the precompiled libfastled.a into the final binary fastled.js.
+add_custom_target(final_wasm ALL
+    COMMAND em++ ${SKETCH_LINK_FLAGS} -Wl,--whole-archive $<TARGET_FILE:sketch_lib> -Wl,--no-whole-archive /precompiled/libfastled.a
+    DEPENDS sketch_lib fastled
+    COMMENT "Linking final wasm binary to fastled.js"
+)

fastled-1.2.42/compiler/arduino-pre-process.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+arduino-cli compile --preprocess --fqbn arduino:avr:uno /pre-warm/Blink/Blink.ino

fastled-1.2.42/compiler/build.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+python compile.py --no-platformio

fastled-1.2.42/compiler/build_archive.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+set -e  # Exit immediately if a command exits with a non-zero status
+set -x
+
+# if /include does not exist
+if [ ! -d "/precompiled/include" ]; then
+   echo "include directory does not exist, copying header include tree"
+   # echo "include directory does not exist, copying header include tree"
+   # copy *.h,*.hpp files from fastled/src/** to /include
+   mkdir -p /precompiled/include
+   cd fastled/src
+   find . -name "*.h*" -exec cp --parents {} /precompiled/include \;
+   cd ../../
+fi
+
+# if /precompiled/libfastled.a does not exist
+if [ ! -f "/precompiled/libfastled.a" ]; then
+   # echo "libfastled.a does not exist, compiling static library"
+   echo "libfastled.a does not exist, compiling static library"
+   cd fastled/src/platforms/wasm/compiler/lib
+   mkdir -p build
+   cd build
+   emcmake cmake -DCMAKE_VERBOSE_MAKEFILE=ON ..
+   emmake cmake --build . -v -j
+   cp fastled/libfastled.a /precompiled/libfastled.a
+   cd ../../../../../
+fi
+

fastled-1.2.42/compiler/build_fast.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+set -e  # Exit immediately if a command exits with a non-zero status
+set -x
+
+#################################
+# Compile fastled lib
+#################################
+
+
+./build_archive.sh
+
+# first compile if build doesn't exist
+first_compile=false
+
+# if build directory doesn't exist
+if [ ! -d "build" ]; then
+    # Create the build directory if it doesn't exist and mark as first compile.
+    mkdir -p build
+    # if /js/src/CMakeCache.txt exists then delete it
+
+    first_compile=true
+fi
+
+cd build
+
+# Set build mode: QUICK, DEBUG, or RELEASE (default is QUICK)
+export BUILD_MODE=${1:-QUICK}
+
+# Check for an optional second parameter to activate PROFILE
+# PROFILE_FLAG="-DPROFILE=ON"
+
+# touch CMakeLists.txt to force reconfigure
+touch /js/CMakeLists.txt
+
+
+# always delete CMakeCache.txt
+if [ -f "/js/fastled/src/CMakeCache.txt" ]; then
+    rm -rf /js/fastled/src/CMakeCache.txt
+fi
+
+
+if [ "$first_compile" = true ]; then
+    # Configure with CMake
+    # If you want verbose build output, you can enable CMAKE_VERBOSE_MAKEFILE.
+    echo "Configuring build with CMake..."
+    emcmake cmake -DCMAKE_VERBOSE_MAKEFILE=ON  ..
+else
+    # If the build directory already exists, reconfigure with CMake.
+    echo "Skipping CMake configuration as build directory already exists."
+fi
+
+# Build the project using CMake
+emmake cmake --build . -v -j
+

fastled-1.2.42/compiler/code_sync.py

@@ -0,0 +1,76 @@
+
+import os
+from pathlib import Path
+from typing import Callable
+import subprocess
+import time
+
+from compile_lock import COMPILE_LOCK
+
+VOLUME_MAPPED_SRC = Path("/host/fastled/src")
+RSYNC_DEST = Path("/js/fastled/src")
+TIME_START = time.time()
+
+def sync_src_to_target(
+    src: Path, dst: Path, callback: Callable[[], None] | None = None
+) -> bool:
+    """Sync the volume mapped source directory to the FastLED source directory."""
+    suppress_print = (
+        TIME_START + 30 > time.time()
+    )  # Don't print during initial volume map.
+    if not src.exists():
+        # Volume is not mapped in so we don't rsync it.
+        print(f"Skipping rsync, as fastled src at {src} doesn't exist")
+        return False
+    try:
+        exclude_hidden = "--exclude=.*/"  # suppresses folders like .mypy_cache/
+        print("\nSyncing source directories...")
+        with COMPILE_LOCK:
+            # Use rsync to copy files, preserving timestamps and deleting removed files
+            cp: subprocess.CompletedProcess = subprocess.run(
+                ["rsync", "-av", "--info=NAME", "--delete", f"{src}/", f"{dst}/", exclude_hidden],
+                check=True,
+                text=True,
+                capture_output=True,
+            )
+            if cp.returncode == 0:
+                changed = False
+                changed_lines: list[str] = []
+                lines = cp.stdout.split("\n")
+                for line in lines:
+                    suffix = line.strip().split(".")[-1]
+                    if suffix in ["cpp", "h", "hpp", "ino", "py", "js", "html", "css"]:
+                        if not suppress_print:
+                            print(f"Changed file: {line}")
+                        changed = True
+                        changed_lines.append(line)
+                if changed:
+                    if not suppress_print:
+                        print(f"FastLED code had updates: {changed_lines}")
+                    if callback:
+                        callback()
+                    return True
+                print("Source directory synced successfully with no changes")
+                return False
+            else:
+                print(f"Error syncing directories: {cp.stdout}\n\n{cp.stderr}")
+                return False
+
+    except subprocess.CalledProcessError as e:
+        print(f"Error syncing directories: {e.stdout}\n\n{e.stderr}")
+    except Exception as e:
+        print(f"Error syncing directories: {e}")
+    return False
+
+
+
+def sync_source_directory_if_volume_is_mapped(
+    callback: Callable[[], None] | None = None
+) -> bool:
+    """Sync the volume mapped source directory to the FastLED source directory."""
+    if not VOLUME_MAPPED_SRC.exists():
+        # Volume is not mapped in so we don't rsync it.
+        print("Skipping rsync, as fastled src volume not mapped")
+        return False
+    print("Syncing source directories because host is mapped in")
+    return sync_src_to_target(VOLUME_MAPPED_SRC, RSYNC_DEST, callback=callback)