pcbjam/scripts/kicad/build-kicad-target.sh

#!/bin/bash
# Build a KiCad app (pcbnew, eeschema, calculator, pl_editor) for WebAssembly.
#
# Usage:
#   ./scripts/kicad/build-kicad-target.sh <app> [options]
#
# Args:
#   <app>         pcbnew | eeschema | calculator | pl_editor (required)
#
# Options:
#   --full        Full clean rebuild (dependencies + KiCad)
#   --clean-kicad Clean only KiCad build directory (not deps)
#   --build-deps  Build dependencies (default: skip)
#   --debug       Build with debug symbols (default)
#   --release     Build optimized without debug symbols
#   --diag=...    Diagnostic preprocessor flags (gal, coroutine, ctor, all)
#   -j N          Parallel compilation jobs (default: 1)
#
# Each app builds into its own tree: build-wasm/kicad-<app>/.
# Per-app extras live alongside generic stubs:
#   - wasm/bindings/<app>_embind.cpp        (optional)
#   - wasm/stubs/<app>_frame_stub.cpp       (optional, app-specific stubs)
#   - wasm/stubs/<app>_scripting_stub.cpp   (optional, app-specific scripting stubs)
#
# Most apps use the same name for the user-facing app, the CMake target, and
# the source subdirectory. Calculator is the exception: app=calculator but the
# upstream target and source subdir are both pcb_calculator (the OUTPUT_NAME
# property in pcb_calculator/CMakeLists.txt emits calculator.{js,wasm}).
# pl_editor is the standard case but its source subdir is pagelayout_editor.

set -e

if [ -z "$1" ]; then
    echo "Error: missing <app> argument (kicad_editor | pcbnew | eeschema | calculator | pl_editor | gerbview)" >&2
    exit 1
fi
APP_NAME="$1"
shift

# KICAD_TARGET: the CMake/make target name.
# KICAD_SUBDIR: the source/build subdirectory the target's artifacts land in.
# Most apps share all three names; the exceptions:
#   - calculator:    target+subdir are both pcb_calculator (OUTPUT_NAME=calculator)
#   - pl_editor:     subdir is pagelayout_editor (upstream source dir name)
# The footprint/symbol editors have no target of their own — the pcbnew/eeschema
# bundle opens them at runtime via single_top.cpp's --frame flag.
case "$APP_NAME" in
    kicad_editor)
        # Merged pcbnew+eeschema image (editor-unification Part 2): one executable
        # linking BOTH kifaces, frame chosen at runtime by --frame (pcb/fpedit/sch/
        # symedit). Target lives in wasm/editor/ (added by the fork's top-level
        # CMakeLists under -DKICAD_WASM_MERGED_EDITOR=ON); its binary dir doubles as
        # the artifact subdir.
        KICAD_TARGET="kicad_editor"
        KICAD_SUBDIR="kicad_editor"
        ;;
    pcbnew|eeschema|gerbview)
        KICAD_TARGET="$APP_NAME"
        KICAD_SUBDIR="$APP_NAME"
        ;;
    pl_editor)
        KICAD_TARGET="pl_editor"
        KICAD_SUBDIR="pagelayout_editor"
        ;;
    calculator)
        KICAD_TARGET="pcb_calculator"
        KICAD_SUBDIR="pcb_calculator"
        ;;
    kicad_tools)
        # Merged headless CLI (pcbjam-mcp 0001 tier 3a): both dieted kifaces —
        # .lib conversion (--convert-lib), --lint, --erc, --netlist, --bom,
        # --plot, --drc in one node image. (Supersedes the retired standalone
        # sym_convert / pcb_convert apps.) Its add_executable lives in
        # wasm/tools/ (added by the fork's top-level CMakeLists under
        # -DKICAD_TOOLS_WASM=ON); the binary dir doubles as the artifact
        # subdir of its own kicad-kicad_tools tree. A headless CLI has no 3D
        # viewer: skip the wasm/gl1 FFP shim compile (it needs glm, which the
        # libs sysroot doesn't guarantee) unless the caller forces it.
        KICAD_TARGET="kicad_tools"
        KICAD_SUBDIR="kicad_tools"
        BUILD_3D_VIEWER="${BUILD_3D_VIEWER:-OFF}"
        ;;
    occ_service)
        # Standalone OpenCASCADE 3D service (worker embind module). Target lives
        # in wasm/occ-service/ (added by the fork's top-level CMakeLists under
        # -DKICAD_OCC_SERVICE_WASM=ON); like kicad_editor, its binary dir
        # doubles as the artifact subdir of its own kicad-occ_service tree.
        KICAD_TARGET="occ_service"
        KICAD_SUBDIR="occ_service"
        ;;
    *)
        echo "Error: unknown app '$APP_NAME' (expected: kicad_editor | pcbnew | eeschema | calculator | pl_editor | gerbview | kicad_tools | occ_service)" >&2
        exit 1
        ;;
esac

# Which app's embind bindings to compile + link. Most apps use their own.
# NOTE kicad_tools deliberately does NOT reuse the editors' embind objects even
# though it links both kifaces: each kiface references exactly one embind
# symbol (kicadCollabOnSave), and linking a real bindings TU for it roots the
# whole editor surface from .init_array (~4x binary size — ysync 0009 size
# research). Its own wasm/bindings/kicad_tools_embind.cpp provides a no-op hook.
case "$APP_NAME" in
    # occ_service links the pcbnew kiface objects → pcbnew's embind object (its
    # own embind entry points live in occ_service_main.cpp, compiled inside the
    # CMake target).
    occ_service)      EMBIND_APP="pcbnew" ;;
    *)                EMBIND_APP="$APP_NAME" ;;
esac

# Embind linker support (--bind). kicad_tools has no bindings at all (see
# above) — dropping --bind keeps the embind JS/native runtime out entirely.
case "$APP_NAME" in
    kicad_tools)      EMBIND_LINK_FLAG="" ;;
    *)                EMBIND_LINK_FLAG="--bind" ;;
esac

# Which app's WASM stub libraries (scripting/frame placeholders) to link.
# kicad_editor links pcbnew's kiface objects, which reference the action-plugin
# scripting placeholders (pcbnewGet*); eeschema's frame stub arrives via CMake
# (target_sources on eeschema_kiface_objects), not this path.
case "$APP_NAME" in
    # kicad_tools links both kifaces: eeschema's frame stub comes through this
    # path, pcbnew's via CMake PCBNEW_WASM_STUBS.
    kicad_tools)      STUB_APP="eeschema" ;;
    kicad_editor)     STUB_APP="pcbnew" ;;
    # occ_service links the pcbnew kiface objects → pcbnew's stubs (frame +
    # action-plugin scripting placeholders), like the editors.
    occ_service)      STUB_APP="pcbnew" ;;
    *)                STUB_APP="$APP_NAME" ;;
esac

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
source "${SCRIPT_DIR}/../common/env.sh"
source "${SCRIPT_DIR}/../common/versions.sh"
source "${SCRIPT_DIR}/../common/functions.sh"
source "${SCRIPT_DIR}/../common/stages.sh"

KICAD_DIR="${PROJECT_ROOT}/kicad"
WASM_LAYER="${PROJECT_ROOT}/wasm"

KICAD_BUILD="${BUILD_ROOT}/kicad-${APP_NAME}"
KICAD_STAMP="${BUILD_ROOT}/stamps/kicad-${APP_NAME}.stamp"
WX_BUILD="${BUILD_ROOT}/wxwidgets"

# Parse arguments - incremental build by default (optimized for development)
NO_CLEAN=1
FULL_CLEAN=0
SKIP_DEPS=1
DEBUG=0
DIAG_LIST=""
while [[ $# -gt 0 ]]; do
    case $1 in
        --full)
            FULL_CLEAN=1
            NO_CLEAN=0
            SKIP_DEPS=0
            shift
            ;;
        --clean-kicad)
            NO_CLEAN=0
            shift
            ;;
        --build-deps)
            SKIP_DEPS=0
            shift
            ;;
        --debug)
            DEBUG=1
            shift
            ;;
        --release)
            DEBUG_BUILD=0
            export DEBUG_BUILD
            shift
            ;;
        --diag=*)
            DIAG_LIST="${1#--diag=}"
            shift
            ;;
        --diag)
            DIAG_LIST="$2"
            shift 2
            ;;
        -j)
            export JOBS="$2"
            shift 2
            ;;
        -j*)
            export JOBS="${1#-j}"
            shift
            ;;
        *)
            shift
            ;;
    esac
done

# Diagnostic preprocessor defines from --diag=<csv> (gal, coroutine, ctor, all).
# These gate the KI_DIAG_* macros in kicad/include/kicad_wasm_diag.h. Output goes
# to stdout ([KICAD_OUT] logs), never errors. Off by default.
DIAG_DEFINES=""
if [ -n "${DIAG_LIST}" ]; then
    IFS=',' read -ra _diag_cats <<< "${DIAG_LIST}"
    for _cat in "${_diag_cats[@]}"; do
        case "${_cat}" in
            gal)       DIAG_DEFINES="${DIAG_DEFINES} -DKICAD_DIAG_GAL=1" ;;
            coroutine) DIAG_DEFINES="${DIAG_DEFINES} -DKICAD_DIAG_COROUTINE=1" ;;
            ctor)      DIAG_DEFINES="${DIAG_DEFINES} -DKICAD_DIAG_CTOR=1" ;;
            all)       DIAG_DEFINES="${DIAG_DEFINES} -DKICAD_DIAG_GAL=1 -DKICAD_DIAG_COROUTINE=1 -DKICAD_DIAG_CTOR=1" ;;
            "")        ;;
            *)         log_warn "Unknown --diag category: '${_cat}' (valid: gal, coroutine, ctor, all)" ;;
        esac
    done
    log_info "Diagnostic logging enabled:${DIAG_DEFINES}"
fi

log_info "Building app: ${APP_NAME}"
log_info "Using ${JOBS} parallel jobs"

# Step 1: Clean build directories
if [ $FULL_CLEAN -eq 1 ]; then
    log_info "Full clean: removing all stamps and build directories..."
    rm -rf "${STAMPS_DIR}"/*
    rm -rf "${BUILD_ROOT}/deps"/*
    rm -rf "${BUILD_ROOT}/wxwidgets"
    rm -rf "${BUILD_ROOT}/stubs"
    rm -rf "${KICAD_BUILD}"
    rm -rf "${SYSROOT}"/*
elif [ $NO_CLEAN -eq 0 ]; then
    log_info "Cleaning KiCad ${APP_NAME} build directory..."
    rm -rf "${KICAD_BUILD}" "${KICAD_STAMP}"
else
    log_info "Incremental build (use --clean-kicad or --full to clean)"
fi

# Step 2: Build dependencies
# Note: --with-occ for OpenCASCADE. The ngspice dep is NOT needed here — the
# editor links only the sharedspice client stub; the engine is the separate
# ngspice_service app (scripts/kicad/build-ngspice_service.sh builds its dep).
if [ $SKIP_DEPS -eq 0 ]; then
    kw_stage deps
    log_info "Building dependencies..."
    "${SCRIPT_DIR}/../deps/build-all-deps.sh" --with-occ
else
    log_info "Skipping dependencies (use --build-deps or --full to build)"
fi

# Note: We don't check the KiCad stamp here for incremental builds.
# CMake handles dependency tracking - it will detect changed source files
# and only recompile what's needed. The stamp is created at the end for
# scripts that want to know if KiCad was ever built successfully.

# Step 4: Build wxWidgets (incremental - only recompiles changed files)
kw_stage wxwidgets
log_info "Building wxWidgets..."
"${SCRIPT_DIR}/../build-wx-wasm.sh" --no-clean

log_info "Building KiCad ${APP_NAME} ${KICAD_VERSION} for WASM..."

# Step 5: Set build type
# Exception model: native WebAssembly exceptions (legacy binary encoding) + wasm setjmp/longjmp,
# single-sourced from scripts/common/env.sh (KiCad and wxWidgets must agree — mixing EH models
# link-fails / traps; both build with exceptions enabled). -matomics -mbulk-memory are required for
# shared memory (pthreads).
KICAD_EH_FLAGS="$DEPS_EH_FLAGS"
log_info "KiCad EH model flags: ${KICAD_EH_FLAGS}"

# Use environment DEBUG_BUILD if set, otherwise check local --debug flag
# NOTE: We use -O1 for debug builds because -O0 produces WASM with too many
# locals for V8/Chrome to compile (error: "local count too large").
# -O1 keeps debug info but optimizes enough to stay under V8's limits.
if [ "${DEBUG_BUILD:-0}" = "1" ] || [ $DEBUG -eq 1 ]; then
    BUILD_TYPE="Debug"
    EXTRA_FLAGS="-g -O1 ${KICAD_EH_FLAGS} -matomics -mbulk-memory"
    # CMake defines DEBUG for Config=Debug (kicad/CMakeLists.txt:351). The embind TU (Step 7) is
    # compiled OUTSIDE CMake, so it must define DEBUG too — otherwise a DEBUG-gated virtual
    # (EDA_ITEM::Show, eda_item.h:471) occupies a vtable slot in the core's emitted vtable that the
    # embind TU doesn't account for, shifting every later slot by one. Then every virtual call made
    # from the embind TU past that slot (SetWidth/GetPosition/...) reads the wrong vtable offset and
    # mis-dispatches at runtime (call_indirect signature-mismatch trap; under native-EH the trap is
    # swallowed by the apply coroutine's catch_all → silent hang). See task #54 root-cause analysis.
    EMBIND_CONFIG_DEFINES="-DDEBUG"
    # -gseparate-dwarf puts debug info in a separate .debug.wasm file
    # This keeps the main WASM small (~200MB) while preserving full debug info
    # DevTools loads the debug file on-demand when debugging
    LINKER_DEBUG_FLAGS="-O1 -g -gseparate-dwarf ${KICAD_EH_FLAGS}"
    log_info "Building KiCad in DEBUG mode (separate DWARF for smaller main binary)"
else
    BUILD_TYPE="Release"
    EXTRA_FLAGS="-O2 ${KICAD_EH_FLAGS} -matomics -mbulk-memory"
    EMBIND_CONFIG_DEFINES=""   # Release defines no DEBUG in either TU → vtable layouts already match
    # -O0 at link time skips wasm-opt (which can OOM on large WASM files)
    # Compilation is still -O2 for optimized code, but we skip post-link wasm-opt
    LINKER_DEBUG_FLAGS="-O0 ${KICAD_EH_FLAGS}"
    log_info "Building KiCad in RELEASE mode (skipping wasm-opt due to memory limits)"
fi

# Async suspension backend (JSPI migration). Default asyncify; PCBJAM_ASYNC_BACKEND=jspi
# links the browser apps with -sJSPI (native stack switching) instead of
# -sASYNCIFY/-sDYNCALLS, defines PCBJAM_JSPI=1 for every TU (selects the JSPI
# libcontext coroutine backend + the wx port's JSPI dispatch paths), and skips
# the whole post-link asyncify pipeline (stub dance + host wasm-opt). The wx
# build this app links against must be built with the SAME knob
# (build-wx-wasm.sh reads it too). The headless CLIs (kicad_tools, occ_service)
# stay asyncify-shaped regardless: their targets pin -sASYNCIFY=0 and run in
# node/worker where no suspension backend is wanted.
PCBJAM_ASYNC_BACKEND="${PCBJAM_ASYNC_BACKEND:-asyncify}"
case "${APP_NAME}" in
    kicad_tools|occ_service) PCBJAM_ASYNC_BACKEND="asyncify" ;;
esac
if [ "${PCBJAM_ASYNC_BACKEND}" = "jspi" ]; then
    EXTRA_FLAGS="${EXTRA_FLAGS} -DPCBJAM_JSPI=1"
    # PCBJAM_JSPI is ABI-affecting (coroutine.h's callerStub grows a finish
    # hook — a template, so every instantiating TU must agree): route it into
    # KICAD_TU_ABI_FLAGS via EMBIND_CONFIG_DEFINES like the Debug -DDEBUG.
    EMBIND_CONFIG_DEFINES="${EMBIND_CONFIG_DEFINES} -DPCBJAM_JSPI=1"
    log_info "Async backend: JSPI (-sJSPI, -DPCBJAM_JSPI=1)"
else
    log_info "Async backend: asyncify"
fi

# Step 6: Create build directory
mkdir -p "${KICAD_BUILD}"
cd "${KICAD_BUILD}"

# Step 6.1: Build stub libraries for missing symbols
# Generic stubs (libgit2, curl, nng) are shared across apps and built in BUILD_ROOT/stubs.
# App-specific stubs (e.g. pcbnew_scripting_stub) build into the same directory but
# are only linked in when the corresponding source exists.
STUBS_DIR="${PROJECT_ROOT}/wasm/stubs"
STUBS_BUILD="${BUILD_ROOT}/stubs"
mkdir -p "${STUBS_BUILD}"

# ABI-affecting flags shared by EVERY C++ TU compiled OUTSIDE CMake (the embind + the app stubs below).
# The core CMake TUs get all of these (DEBUG via Config=Debug -> kicad/CMakeLists.txt:351;
# KICAD_USE_PLATFORM_WASM; the char16_t char_traits force-include). A TU that misses any of them can
# diverge in vtable layout / ABI from the core — task #54: the embind missing -DDEBUG shifted its vtable
# slot offsets by one and hung the collab apply (call_indirect signature-mismatch). Keep them in ONE
# place so no out-of-CMake C++ TU can skew again. (EMBIND_CONFIG_DEFINES holds the build-config -DDEBUG,
# set in the BUILD_TYPE block above; empty in Release where neither side defines DEBUG.)
KICAD_TU_ABI_FLAGS="${EMBIND_CONFIG_DEFINES} -DKICAD_USE_PLATFORM_WASM=1 -include ${STUBS_DIR}/char_traits_uint16_workaround.h"

kw_stage kicad-stubs
log_info "Building stub libraries..."
# Compile libgit2 stub
emcc -c "${STUBS_DIR}/libgit2_stub.c" -o "${STUBS_BUILD}/libgit2_stub.o"
emar rcs "${STUBS_BUILD}/libgit2_stub.a" "${STUBS_BUILD}/libgit2_stub.o"

# Compile curl stub
emcc -c "${STUBS_DIR}/curl_stub.c" -o "${STUBS_BUILD}/curl_stub.o"
emar rcs "${STUBS_BUILD}/libcurl_stub.a" "${STUBS_BUILD}/curl_stub.o"

# Note: the GLU tesselator is provided by kicad/libs/kimath/glu_tess/glu_tess_impl.cpp,
# compiled as part of the GAL library (requires KiCad headers).

# Compile NNG stub (IPC API requires NNG but sockets don't work in WASM)
emcc -c -I"${STUBS_DIR}" "${STUBS_DIR}/nng_stub.c" -o "${STUBS_BUILD}/nng_stub.o"
emar rcs "${STUBS_BUILD}/libnng_stub.a" "${STUBS_BUILD}/nng_stub.o"

# wx flags for any C++ stubs that include wx headers
WX_CXXFLAGS=$("${WX_BUILD}/wx-config" --cxxflags 2>/dev/null || echo "-I${WX_BUILD}/lib/wx/include/emscripten-unicode-static-3.2 -I${PROJECT_ROOT}/wxwidgets/include")

# App-specific stubs:
# - pcbnew: pcbnew_scripting_stub.cpp (action-plugin scripting placeholders)
# - eeschema: eeschema_frame_stub.cpp (placeholder; grows as linker dictates)
APP_STUB_LINK=""
APP_SCRIPTING_STUB_SRC="${STUBS_DIR}/${STUB_APP}_scripting_stub.cpp"
if [ -f "${APP_SCRIPTING_STUB_SRC}" ]; then
    log_info "Building app scripting stub: ${STUB_APP}_scripting_stub.cpp"
    em++ -c ${KICAD_TU_ABI_FLAGS} ${WX_CXXFLAGS} "${APP_SCRIPTING_STUB_SRC}" -o "${STUBS_BUILD}/${STUB_APP}_scripting_stub.o"
    emar rcs "${STUBS_BUILD}/lib${STUB_APP}_scripting_stub.a" "${STUBS_BUILD}/${STUB_APP}_scripting_stub.o"
    APP_STUB_LINK="${APP_STUB_LINK} ${STUBS_BUILD}/lib${STUB_APP}_scripting_stub.a"
fi

APP_FRAME_STUB_SRC="${STUBS_DIR}/${STUB_APP}_frame_stub.cpp"
if [ -f "${APP_FRAME_STUB_SRC}" ] && [ -s "${APP_FRAME_STUB_SRC}" ]; then
    log_info "Building app frame stub: ${STUB_APP}_frame_stub.cpp"
    em++ -c ${KICAD_TU_ABI_FLAGS} ${WX_CXXFLAGS} "${APP_FRAME_STUB_SRC}" -o "${STUBS_BUILD}/${STUB_APP}_frame_stub.o"
    emar rcs "${STUBS_BUILD}/lib${STUB_APP}_frame_stub.a" "${STUBS_BUILD}/${STUB_APP}_frame_stub.o"
    APP_STUB_LINK="${APP_STUB_LINK} ${STUBS_BUILD}/lib${STUB_APP}_frame_stub.a"
fi

log_info "Stub libraries built"

# Step 6.2/6.3: wasm-opt + wasm-emscripten-finalize handling.
# For the editor apps these tools OOM on the huge debug wasm, so we stub them in
# the container and run them on the host (docker/build.sh phase 2). The small,
# debug-stripped (-g0) CLI finalizes fine in-container, so for kicad_tools
# we restore/keep the real tools and skip host post-processing entirely.
if [ -z "${EMSDK}" ]; then
    log_error "EMSDK environment variable is not set."
    exit 1
fi
EMSDK_WASM_OPT="${EMSDK}/upstream/bin/wasm-opt"
EMSDK_FINALIZE="${EMSDK}/upstream/bin/wasm-emscripten-finalize"

if [ "${APP_NAME}" = "kicad_tools" ] || [ "${APP_NAME}" = "occ_service" ] || [ "${PCBJAM_ASYNC_BACKEND}" = "jspi" ]; then
    # Use the real tools so the module is fully finalized inside the container
    # (no host post-processing / asyncify for these targets). JSPI mode has no
    # asyncify pass at all, so every app finalizes in-container.
    [ -f "${EMSDK_WASM_OPT}.real" ] && cp "${EMSDK_WASM_OPT}.real" "${EMSDK_WASM_OPT}"
    [ -f "${EMSDK_FINALIZE}.real" ] && cp "${EMSDK_FINALIZE}.real" "${EMSDK_FINALIZE}"
    log_info "Using real wasm-opt/finalize for ${APP_NAME} (finalize in-container)"
else
    if [ -f "${EMSDK_WASM_OPT}" ] && [ ! -f "${EMSDK_WASM_OPT}.real" ]; then
        log_info "Backing up real wasm-opt..."
        mv "${EMSDK_WASM_OPT}" "${EMSDK_WASM_OPT}.real"
    fi
    # Always copy the latest stub (in case it was updated)
    cp "${STUBS_DIR}/wasm-opt-stub.sh" "${EMSDK_WASM_OPT}"
    chmod +x "${EMSDK_WASM_OPT}"
    log_info "wasm-opt stub installed (asyncify will run on host)"

    if [ -f "${EMSDK_FINALIZE}" ] && [ ! -f "${EMSDK_FINALIZE}.real" ]; then
        log_info "Backing up real wasm-emscripten-finalize..."
        mv "${EMSDK_FINALIZE}" "${EMSDK_FINALIZE}.real"
    fi
    # Always copy the latest stub (in case it was updated)
    cp "${STUBS_DIR}/wasm-emscripten-finalize-stub.sh" "${EMSDK_FINALIZE}"
    chmod +x "${EMSDK_FINALIZE}"
    log_info "wasm-emscripten-finalize stub installed (finalize will run on host)"
fi

# Step 6.5: Verify WASM support is in KiCad fork
# The kicad submodule should already have WASM port detection and kiplatform support
KICAD_CMAKE="${KICAD_DIR}/CMakeLists.txt"
if ! grep -q "msw|qt|gtk|osx|wasm" "${KICAD_CMAKE}"; then
    log_error "KiCad fork is missing WASM port detection support."
    log_error "Please ensure the kicad submodule has WASM modifications."
    exit 1
fi
KIPLATFORM_CMAKE="${KICAD_DIR}/libs/kiplatform/CMakeLists.txt"
if ! grep -q "KICAD_WX_PORT STREQUAL wasm" "${KIPLATFORM_CMAKE}"; then
    log_error "KiCad fork is missing kiplatform WASM support."
    log_error "Please ensure the kicad submodule has WASM modifications."
    exit 1
fi
log_info "KiCad WASM support verified"

# Embind object — built after CMake configure runs (so config.h exists). The
# linker line below references "${STUBS_BUILD}/${APP_NAME}_embind.o" so we
# create an empty placeholder when the source is missing, to keep the link
# line stable across apps.
# kicad_editor (merged image) links THREE embind objects: both per-editor TUs
# (compiled with -DKICAD_MERGED_EMBIND, which compiles out their duplicate
# definitions and shared-name registrations) plus the dispatcher TU that registers
# the shared JS names once — see wasm/bindings/kicad_editor_embind.cpp.
if [ "${APP_NAME}" = "kicad_editor" ]; then
    EMBIND_OBJ="${STUBS_BUILD}/pcbnew_embind.o ${STUBS_BUILD}/eeschema_embind.o ${STUBS_BUILD}/kicad_editor_embind.o"
else
    EMBIND_OBJ="${STUBS_BUILD}/${EMBIND_APP}_embind.o"
fi
EMBIND_SRC="${PROJECT_ROOT}/wasm/bindings/${EMBIND_APP}_embind.cpp"

# Step 7: Configure KiCad with CMake
# We use CMAKE_MODULE_PATH to inject our compatibility layer
kw_stage kicad-configure
log_info "Configuring KiCad with CMake..."
# emcc 6: -sUSE_ZLIB is gone; prebuild the zlib port (regular + PIC) so the
# explicit ZLIB_LIBRARY below always exists (PIC needed by the .so links).
"${EMSDK}/upstream/emscripten/embuilder" build zlib >/dev/null 2>&1 || true
"${EMSDK}/upstream/emscripten/embuilder" build zlib --pic >/dev/null 2>&1 || true

# CMAKE_SHARED/MODULE_LINKER_FLAGS below: set EXPLICITLY (a stale CMakeCache
# once resurrected experimental -L hacks), and carry the SAME ODR policy as
# the exe links (wasm/editor/CMakeLists.txt): KiCad deliberately ships
# wx-compat copies (wxGetContentRect in grid_checkbox.cpp vs wx grid.cpp)
# that emcc 6 kiface/.so links reject without --allow-multiple-definition.

# Use ccache if available (CMAKE_*_COMPILER_LAUNCHER is the proper CMake way)
CCACHE_OPTS=""
if command -v ccache &> /dev/null; then
    CCACHE_OPTS="-DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache"
    log_info "Using ccache for compilation"
fi

# The merged headless CLI configures with BOTH diet options (each trims its
# own kiface for this tree; the eeschema one also trims the SCH_IO factory to
# the two KiCad plugins) plus the wasm/tools/ subdir gate.
KICAD_TOOLS_CMAKE_FLAG=""
if [ "${APP_NAME}" = "kicad_tools" ]; then
    KICAD_TOOLS_CMAKE_FLAG="-DKICAD_TOOLS_WASM=ON -DKICAD_SYM_CONVERTER_WASM=ON -DKICAD_PCB_CONVERTER_WASM=ON"
fi

# Merged pcbnew+eeschema editor: gates the wasm/editor/ subdir, the per-engine
# Kiface()/KIFACE_GETTER renames, and the PCB-side ODR symbol renames in the fork's
# CMake (see KICAD_WASM_MERGED_EDITOR in kicad/CMakeLists.txt). Only this tree
# (build-wasm/kicad-kicad_editor) configures with it ON.
MERGED_EDITOR_CMAKE_FLAG=""
if [ "${APP_NAME}" = "kicad_editor" ]; then
    MERGED_EDITOR_CMAKE_FLAG="-DKICAD_WASM_MERGED_EDITOR=ON"
fi

# The standalone OCC 3D service (worker embind module) — gates the
# wasm/occ-service/ subdir in the fork's top-level CMakeLists.
OCC_SERVICE_CMAKE_FLAG=""
if [ "${APP_NAME}" = "occ_service" ]; then
    OCC_SERVICE_CMAKE_FLAG="-DKICAD_OCC_SERVICE_WASM=ON"
fi

# 3D viewer: built by DEFAULT (BUILD_3D_VIEWER=ON). Opt out with BUILD_3D_VIEWER=OFF, which links the
# 3D stubs instead. The default renderer is still the GL-free CPU raytracer
# (RENDER_3D_RAYTRACE_RAM) blitted through a WebGL2 textured quad, but KiCad's fixed-function
# OpenGL renderer (RENDER_3D_OPENGL) now links against the REAL GL1->WebGL2 emulation layer
# (wasm/gl1, no -sLEGACY_GL_EMULATION): the shim implements the FFP-only entry points and
# --wrap-intercepts the Emscripten-owned names it must observe (wasm/gl1/wrapped_symbols.txt).
# Regression gate: tests/3d-regression (47 golden scenarios). The KiCad CMake option
# KICAD_BUILD_3D_VIEWER_WASM stays OFF upstream; our build passes it explicitly.
# See wasm/gl1/README.md and docs/features/fork-cleanup/10-3d-viewer.md.
BUILD_3D_VIEWER="${BUILD_3D_VIEWER:-ON}"
GL3D_LINK_FLAGS=""
if [ "${BUILD_3D_VIEWER}" = "ON" ]; then
    log_info "3D viewer ENABLED for WASM (BUILD_3D_VIEWER=ON) — compiling wasm/gl1 FFP shim"
    GL1_DIR="${PROJECT_ROOT}/wasm/gl1"
    while IFS= read -r gl1_src; do
        [ -n "${gl1_src}" ] || continue
        em++ -c ${EXTRA_FLAGS} -pthread -std=c++20 \
             -I"${GL1_DIR}/include" -I"${STUBS_DIR}" -I"${SYSROOT}/include" \
             "${GL1_DIR}/src/${gl1_src}" -o "${STUBS_BUILD}/${gl1_src%.cpp}.o"
        GL3D_LINK_FLAGS="${GL3D_LINK_FLAGS} ${STUBS_BUILD}/${gl1_src%.cpp}.o"
    done < "${GL1_DIR}/sources.txt"
    while IFS= read -r gl1_sym; do
        [ -n "${gl1_sym}" ] || continue
        GL3D_LINK_FLAGS="${GL3D_LINK_FLAGS} -Wl,--wrap=${gl1_sym}"
    done < "${GL1_DIR}/wrapped_symbols.txt"
fi

# Multi-threaded CPU raytracer (mainline threading restored): link the main-thread
# nanosleep->Asyncify-yield shim so the raw-thread raytracer joins (sleep_for busy-wait)
# yield to the JS event loop instead of deadlocking on-demand pthread-Worker creation.
# Mirrors the wasm/gl1 pattern (compile to .o, add to the link). Shim:
# wasm/shims/nanosleep_yield.c; its EM_ASYNC_JS yield is covered by env.__asyncjs__* in
# scripts/common/asyncify-imports.txt.
# The synchronous node CLIs (ASYNCIFY=0) must NOT link it: their Asyncify JS
# runtime doesn't exist, so the shim's yield throws "Asyncify is not defined"
# on the first main-thread sleep (e.g. DRC copper-clearance's worker-poll).
# A blocking CLI wants libc's real blocking nanosleep anyway — node permits
# Atomics.wait on its main thread.
if [ "${APP_NAME}" = "kicad_tools" ] || [ "${APP_NAME}" = "occ_service" ]; then
    NANOSLEEP_YIELD_LINK=""
else
    emcc -c -pthread "${PROJECT_ROOT}/wasm/shims/nanosleep_yield.c" -o "${STUBS_BUILD}/nanosleep_yield.o"
    if [ "${PCBJAM_ASYNC_BACKEND}" = "jspi" ]; then
        # JSPI: no scheduler-context lane exists — the weak
        # pcbjam_context_sleep_ms stays null and every main-thread sleep
        # suspends in place (legal on a promising activation; EM_ASYNC_JS
        # auto-wraps as WebAssembly.Suspending under -sJSPI).
        # context_sleep.cpp is fiber-only machinery and must not link.
        NANOSLEEP_YIELD_LINK="${STUBS_BUILD}/nanosleep_yield.o"
    else
        # Its scheduler-aware half (docs/features/async/22 Phase B): a main-thread
        # sleep on a scheduler context parks THAT CONTEXT instead of suspending the
        # stack in place. C++ because the registry is a header-only C++ layer in
        # wx's port, hence WX_CXXFLAGS for the include path (the same reason
        # thirdparty/libcontext needed it at Phase A).
        em++ -c -std=c++17 -pthread ${WX_CXXFLAGS} \
            "${PROJECT_ROOT}/wasm/shims/context_sleep.cpp" -o "${STUBS_BUILD}/context_sleep.o"
        NANOSLEEP_YIELD_LINK="${STUBS_BUILD}/nanosleep_yield.o ${STUBS_BUILD}/context_sleep.o"
    fi
fi

# mallinfo() stub for the mimalloc build: -sMALLOC=mimalloc doesn't export the
# glibc mallinfo() that OpenCASCADE's OSD_MemInfo.cxx (libTKernel, pcbnew's 3D)
# references — without this the pcbnew link fails `undefined symbol: mallinfo`.
# Zeroed no-op (memory reporting only); harmless for apps that don't reference it.
emcc -c "${PROJECT_ROOT}/wasm/shims/mallinfo_stub.c" -o "${STUBS_BUILD}/mallinfo_stub.o"
MALLINFO_STUB_LINK="${STUBS_BUILD}/mallinfo_stub.o"

# Pre-warmed Web Worker pool size (emscripten pthreads). The 3D-viewer CPU raytracer runs
# KiCad's shared thread pool (hardware_concurrency long-lived threads, created at startup)
# AND, for camera-move preview + post-process passes, spawns its OWN set of raw std::thread
# workers — so a 3D-viewer session needs ~2x hardware_concurrency Workers *simultaneously*.
# With only one set pre-warmed, the raytracer's threads fall back to on-demand `new Worker()`,
# whose loaded→run handshake needs the main thread back in the JS event loop — which it can't
# reach while blocked in the render's busy-wait join (no PROXY_TO_PTHREAD; the join runs on the
# browser main thread). That circular wait is the 3D-viewer deadlock: moving the model, dragging
# or resizing the viewer all freeze the tab. Pre-warm enough Workers that on-demand creation
# never happens. Only 3D-viewer builds pay the extra startup Workers; other apps keep one set.
if [ "${BUILD_3D_VIEWER:-OFF}" = "ON" ]; then
    PTHREAD_POOL_EXPR='navigator.hardwareConcurrency*2+8'
else
    PTHREAD_POOL_EXPR='navigator.hardwareConcurrency'
fi

# Suspension-backend link surface. Asyncify: binaryen instrumentation +
# DYNCALLS (+ the dynCall runtime export used by the post-link dyncall shims).
# JSPI: native suspension — -sJSPI + the promising-export census
# (scripts/common/jspi-exports.txt: the wx KEEPALIVE entries that can park +
# pcbjam_libctx_entry; regenerate by grep, not memory), the jspi-scheduler
# pre-js (successor of the post-link-injected asyncify-scheduler.js), and the
# runtime methods its green-copy stack discipline needs (stackSave/
# stackRestore/HEAPU8). -sDYNCALLS is a fatal link error under JSPI.
if [ "${PCBJAM_ASYNC_BACKEND}" = "jspi" ]; then
    ASYNC_LINK_FLAGS="-sJSPI -sJSPI_EXPORTS=@${PROJECT_ROOT}/scripts/common/jspi-exports.txt --pre-js ${PROJECT_ROOT}/scripts/common/shims/jspi-scheduler.js"
    ASYNC_RUNTIME_METHODS="-sEXPORTED_RUNTIME_METHODS=['ccall','cwrap','UTF8ToString','stringToUTF8','lengthBytesUTF8','stackSave','stackRestore','HEAPU8','HEAP8','HEAP32']"
else
    ASYNC_LINK_FLAGS="-sASYNCIFY=1 -sDYNCALLS=1 -sASYNCIFY_STACK_SIZE=65536"
    ASYNC_RUNTIME_METHODS="-sEXPORTED_RUNTIME_METHODS=['ccall','cwrap','UTF8ToString','stringToUTF8','lengthBytesUTF8','dynCall'] -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE=['\$dynCall']"
fi

emcmake cmake "${KICAD_DIR}" \
    ${CCACHE_OPTS} \
    ${KICAD_TOOLS_CMAKE_FLAG} \
    ${MERGED_EDITOR_CMAKE_FLAG} \
    ${OCC_SERVICE_CMAKE_FLAG} \
    -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
    -DCMAKE_INSTALL_PREFIX="${SYSROOT}" \
    -DCMAKE_MODULE_PATH="${WASM_LAYER}/cmake" \
    -DSYSROOT="${SYSROOT}" \
    -DCMAKE_POLICY_VERSION_MINIMUM=3.5 \
    -DCMAKE_CXX_FLAGS="${EXTRA_FLAGS} -Xclang -fno-pch-timestamp -pthread --use-port=zlib -DKICAD_USE_PLATFORM_WASM=1${DIAG_DEFINES} -I${SYSROOT}/include -I${STUBS_DIR} -include ${STUBS_DIR}/char_traits_uint16_workaround.h" \
    -DCMAKE_C_FLAGS="${EXTRA_FLAGS} -pthread --use-port=zlib -I${SYSROOT}/include -I${STUBS_DIR}" \
    -DCMAKE_EXE_LINKER_FLAGS="${LINKER_DEBUG_FLAGS} -pthread ${ASYNC_LINK_FLAGS} -sUSE_PTHREADS=1 -sMALLOC=mimalloc -sPTHREAD_POOL_SIZE='${PTHREAD_POOL_EXPR}' -sPTHREAD_POOL_SIZE_STRICT=0 -sALLOW_MEMORY_GROWTH=1 -sINITIAL_MEMORY=256MB -sMAXIMUM_MEMORY=4GB -sMAX_WEBGL_VERSION=2 ${GL3D_LINK_FLAGS} ${NANOSLEEP_YIELD_LINK} ${MALLINFO_STUB_LINK} ${ASYNC_RUNTIME_METHODS} ${EMBIND_LINK_FLAG} -L${SYSROOT}/lib -L${KICAD_BUILD}/common -L${KICAD_BUILD}/common/gal ${STUBS_BUILD}/libgit2_stub.a ${STUBS_BUILD}/libcurl_stub.a${APP_STUB_LINK} ${STUBS_BUILD}/libnng_stub.a ${EMBIND_OBJ}" \
    -DCMAKE_SHARED_LINKER_FLAGS="-Wl,--allow-multiple-definition" \
    -DCMAKE_MODULE_LINKER_FLAGS="-Wl,--allow-multiple-definition" \
    -DZLIB_LIBRARY="${EMSDK}/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten/pic/libz.a" \
    -DZLIB_INCLUDE_DIR="${EMSDK}/upstream/emscripten/cache/sysroot/include" \
    -DCMAKE_PREFIX_PATH="${SYSROOT};${WX_BUILD}" \
    -DwxWidgets_CONFIG_EXECUTABLE="${WX_BUILD}/wx-config" \
    \
    -DKICAD_BUILD_QA_TESTS=OFF \
    -DKICAD_USE_EGL=OFF \
    -DKICAD_USE_BUNDLED_GLEW=ON \
    -DKICAD_BUILD_3D_VIEWER_WASM=${BUILD_3D_VIEWER} \
    -DKICAD_IPC_API=ON \
    -DKICAD_USE_PCH=ON \
    \
    -DZSTD_ROOT="${SYSROOT}" \
    -DZSTD_INCLUDE_DIR="${SYSROOT}/include" \
    -DZSTD_LIBRARY="${SYSROOT}/lib/libzstd.a" \
    -DGLM_INCLUDE_DIR="${SYSROOT}/include" \
    -DGLM_VERSION="0.9.9.8" \
    -DBOOST_ROOT="${SYSROOT}" \
    -DBoost_INCLUDE_DIR="${SYSROOT}/include" \
    -DBoost_LIBRARY_DIR="${SYSROOT}/lib" \
    -DBoost_NO_SYSTEM_PATHS=ON \
    -DBoost_NO_BOOST_CMAKE=ON \
    -DFREETYPE_INCLUDE_DIR_ft2build="${SYSROOT}/include/freetype2" \
    -DFREETYPE_INCLUDE_DIR_freetype2="${SYSROOT}/include/freetype2" \
    -DFREETYPE_LIBRARY="${SYSROOT}/lib/libfreetype.a" \
    -DHarfBuzz_INCLUDE_DIR="${SYSROOT}/include/harfbuzz" \
    -DHarfBuzz_LIBRARY="${SYSROOT}/lib/libharfbuzz.a" \
    -DOCC_INCLUDE_DIR="${SYSROOT}/include/opencascade" \
    -DOCC_LIBRARY_DIR="${SYSROOT}/lib" \
    -DProtobuf_INCLUDE_DIR="${SYSROOT}/include" \
    -DProtobuf_LIBRARY="${SYSROOT}/lib/libprotobuf.a" \
    -DProtobuf_LITE_LIBRARY="${SYSROOT}/lib/libprotobuf-lite.a" \
    -DProtobuf_PROTOC_EXECUTABLE="${SYSROOT}/bin/protoc" \
    -DODBC_CONFIG:STRING="stub-for-wasm" \
    -DODBCLIB:STRING="" \
    -DODBC_CFLAGS:STRING="" \
    -DODBC_LINK_FLAGS:STRING="" \
    -DODBC_LIBRARIES:STRING="" \
    \
    -DHAVE_STRCASECMP=1 \
    -DHAVE_STRNCASECMP=1

# Step 7.1: Compile Embind bindings (after CMake so config.h exists)
# Exposes KiCad objects to JavaScript for future Pyodide integration.
# When no app-specific source exists, build an empty object so the linker line
# referencing ${APP_NAME}_embind.o doesn't break.

# Compile one embind TU with the same includes and ABI-critical flags KiCad uses
# (KICAD_TU_ABI_FLAGS must match the core's -DDEBUG state or vtable dispatch skews —
# task #54). Args: <src> <obj> <app-include-subdir> [extra-defines]
compile_embind_tu() {
    local _src="$1" _obj="$2" _subdir="$3" _defines="${4:-}"

    local _includes="-I${KICAD_BUILD} -I${KICAD_DIR}/include -I${KICAD_DIR}/${_subdir} -I${KICAD_DIR}/common"
    # Generated DSN-lexer headers (e.g. pcb_lexer.h, used transitively via kicad_clipboard.h →
    # pcb_io_kicad_sexpr_parser.h) are emitted into the common build subdir by make_lexer.
    _includes+=" -I${KICAD_BUILD}/common"
    _includes+=" -I${KICAD_DIR}/libs/core/include -I${KICAD_DIR}/libs/kimath/include -I${KICAD_DIR}/libs/kiplatform/include"
    _includes+=" -I${KICAD_DIR}/thirdparty/clipper2/Clipper2Lib/include"
    _includes+=" -I${KICAD_DIR}/thirdparty/nlohmann_json"
    _includes+=" -I${KICAD_DIR}/thirdparty/expected/include"
    _includes+=" -I${KICAD_DIR}/thirdparty/rtree"
    _includes+=" -I${KICAD_DIR}/thirdparty/fmt"
    _includes+=" -I${KICAD_DIR}/thirdparty/dynamic_bitset"
    _includes+=" -I${KICAD_DIR}/thirdparty/nanodbc"
    _includes+=" -I${KICAD_DIR}/thirdparty/picosha2"
    _includes+=" -I${KICAD_DIR}/thirdparty"
    # libcontext.h lives one level deeper; tool/coroutine.h does #include <libcontext.h>
    _includes+=" -I${KICAD_DIR}/thirdparty/libcontext"
    _includes+=" -I${SYSROOT}/include"

    # KiCad requires C++20 for concepts
    em++ -std=c++20 -c ${EXTRA_FLAGS} ${KICAD_TU_ABI_FLAGS} ${WX_CXXFLAGS} ${_defines} ${_includes} "${_src}" -o "${_obj}"
}

if [ "${APP_NAME}" = "kicad_editor" ]; then
    # Merged image: both per-editor TUs (with -DKICAD_MERGED_EMBIND compiling out
    # their duplicate definitions / shared-name registrations) + the dispatcher TU
    # registering the shared JS names once (wasm/bindings/kicad_editor_embind.cpp).
    # pcbnew's TU needs the generated lexer headers — pre-build pcbcommon (no wasted
    # work: kicad_editor depends on pcbcommon anyway; incremental no-op).
    log_info "Pre-building pcbcommon so generated lexer headers exist for the embind compile..."
    emmake make -j${JOBS} pcbcommon
    log_info "Compiling merged Embind bindings (pcbnew + eeschema + dispatcher)..."
    compile_embind_tu "${PROJECT_ROOT}/wasm/bindings/pcbnew_embind.cpp" \
                      "${STUBS_BUILD}/pcbnew_embind.o" pcbnew "-DKICAD_MERGED_EMBIND"
    compile_embind_tu "${PROJECT_ROOT}/wasm/bindings/eeschema_embind.cpp" \
                      "${STUBS_BUILD}/eeschema_embind.o" eeschema "-DKICAD_MERGED_EMBIND"
    compile_embind_tu "${PROJECT_ROOT}/wasm/bindings/kicad_editor_embind.cpp" \
                      "${STUBS_BUILD}/kicad_editor_embind.o" common
elif [ -f "${EMBIND_SRC}" ]; then
    # pcbnew's embind TU transitively includes generated lexer headers
    # (kicad_clipboard.h → pcb_io_kicad_sexpr_parser.h → pcb_lexer.h, emitted into
    # ${KICAD_BUILD}/common by make_lexer custom commands on the pcbcommon target).
    # On a fresh build dir they don't exist until make runs — build pcbcommon first.
    # No wasted work: the app target depends on pcbcommon anyway; incremental no-op.
    # Guard on EMBIND_APP (not APP_NAME) so any app whose embind IS pcbnew's also
    # pre-builds pcbcommon.
    if [ "${EMBIND_APP}" = "pcbnew" ]; then
        log_info "Pre-building pcbcommon so generated lexer headers exist for the embind compile..."
        emmake make -j${JOBS} pcbcommon
    fi
    log_info "Compiling Embind bindings (${APP_NAME})..."
    # The include home is the app the BINDINGS belong to, not the artifact
    # subdir — for occ_service the two differ (bindings = pcbnew's; artifacts
    # land in the wasm/occ-service target's own occ_service/ binary dir, which
    # has no KiCad sources).
    case "${EMBIND_APP}" in
        pcbnew)   EMBIND_INC_SUBDIR="pcbnew" ;;
        eeschema) EMBIND_INC_SUBDIR="eeschema" ;;
        *)        EMBIND_INC_SUBDIR="${KICAD_SUBDIR}" ;;
    esac
    compile_embind_tu "${EMBIND_SRC}" "${EMBIND_OBJ}" "${EMBIND_INC_SUBDIR}"
else
    log_info "No embind source for ${APP_NAME} (expected at ${EMBIND_SRC}); using empty placeholder"
    EMPTY_C="${STUBS_BUILD}/${APP_NAME}_embind_empty.c"
    : > "${EMPTY_C}"
    emcc -c "${EMPTY_C}" -o "${EMBIND_OBJ}"
fi

# Step 8: Build the app target
kw_stage kicad-compile
log_info "Building ${APP_NAME} (CMake target: ${KICAD_TARGET})..."

# The embind object (step 7.1) is injected via linker flags, NOT tracked as a CMake/
# make dependency — so when ONLY <app>_embind.cpp changes, make sees no changed source,
# skips the link, and the new bindings silently vanish from the binary. Force a relink
# whenever the freshly-compiled embind object is newer than the linked output.
LINK_OUT_JS="${KICAD_BUILD}/${KICAD_SUBDIR}/${APP_NAME}.js"
LINK_OUT_WASM="${KICAD_BUILD}/${KICAD_SUBDIR}/${APP_NAME}.wasm"
# EMBIND_OBJ may hold several objects (kicad_editor) — check each.
for _embind_obj in ${EMBIND_OBJ}; do
    if [ -f "${_embind_obj}" ] && [ -f "${LINK_OUT_JS}" ] && [ "${_embind_obj}" -nt "${LINK_OUT_JS}" ]; then
        log_info "Embind object newer than ${APP_NAME}.js — forcing relink to pick up new bindings"
        rm -f "${LINK_OUT_JS}" "${LINK_OUT_WASM}"
        break
    fi
done

emmake make -j${JOBS} "${KICAD_TARGET}"

# Step 8.1: Build bitmap resources (images.tar.gz)
# This creates the icon archive that KiCad loads at runtime. The headless
# converter/service targets have no GUI/icons, so skip it.
if [ "${APP_NAME}" != "kicad_tools" ] && [ "${APP_NAME}" != "occ_service" ]; then
    kw_stage kicad-bitmaps
    log_info "Building bitmap resources..."
    emmake make bitmap_archive_build
fi

# Step 9: Create stamp file
create_stamp "${KICAD_STAMP}"
log_info "KiCad ${APP_NAME} build complete!"
log_info "Output: ${KICAD_BUILD}/${KICAD_SUBDIR}/${APP_NAME}.js"