imxc 0.5.4 → 0.6.0

package/dist/templates/custom.js

@@ -0,0 +1,945 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { buildImxDts, TSCONFIG, GITIGNORE, cmakeTemplate } from './index.js';
+// ---------------------------------------------------------------------------
+// Shared helper content (async.h used by both async and networking)
+// ---------------------------------------------------------------------------
+const ASYNC_H = `#pragma once
+#include <thread>
+#include <functional>
+#include <imx/runtime.h>
+
+namespace imx {
+
+// Runs \`work\` on a background thread, then calls \`on_done\` with the result.
+// Calls request_frame() so the UI wakes up to display the result.
+// Replace with a thread pool if you need to limit concurrency.
+template<typename T>
+void run_async(Runtime& runtime, std::function<T()> work, std::function<void(T)> on_done) {
+    std::thread([&runtime, work = std::move(work), on_done = std::move(on_done)]() {
+        T result = work();
+        on_done(std::move(result));
+        runtime.request_frame();
+    }).detach();
+}
+
+} // namespace imx
+`;
+const PERSISTENCE_H = `#pragma once
+#include <fstream>
+#include <string>
+#include <imx/json.hpp>
+
+namespace imx {
+
+// Save state as formatted JSON. Returns true on success.
+// Saves next to the executable by default — change path for platform app data dirs.
+template<typename T>
+bool save_json(const std::string& path, const T& state) {
+    std::ofstream f(path);
+    if (!f) return false;
+    f << nlohmann::json(state).dump(2);
+    return true;
+}
+
+// Load state from JSON file. Returns true on success, leaves state unchanged on failure.
+template<typename T>
+bool load_json(const std::string& path, T& state) {
+    std::ifstream f(path);
+    if (!f) return false;
+    nlohmann::json j = nlohmann::json::parse(f, nullptr, false);
+    if (j.is_discarded()) return false;
+    nlohmann::from_json(j, state);
+    return true;
+}
+
+} // namespace imx
+`;
+const HOTRELOAD_H = `#pragma once
+#include <string>
+#include <filesystem>
+#include <iostream>
+#include <imx/runtime.h>
+#include <imgui.h>
+#include "AppState.h"
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#include <unistd.h>
+#endif
+
+struct HotModule {
+    using RenderFn = void(*)(imx::Runtime&, AppState&, ImGuiContext*);
+
+#ifdef _WIN32
+    HMODULE handle = nullptr;
+#else
+    void* handle = nullptr;
+#endif
+    RenderFn render = nullptr;
+    std::filesystem::file_time_type last_write{};
+    std::string path;
+
+    bool load(const std::string& lib_path) {
+        path = lib_path;
+        if (!std::filesystem::exists(path)) {
+            std::cerr << "hotreload: " << path << " not found\\n";
+            return false;
+        }
+        last_write = std::filesystem::last_write_time(path);
+
+#ifdef _WIN32
+        // Copy DLL to avoid locking the original (allows rebuild while loaded)
+        std::string copy_path = path + ".live";
+        std::filesystem::copy_file(path, copy_path, std::filesystem::copy_options::overwrite_existing);
+        handle = LoadLibraryA(copy_path.c_str());
+        if (!handle) {
+            std::cerr << "hotreload: LoadLibrary failed\\n";
+            return false;
+        }
+        render = reinterpret_cast<RenderFn>(GetProcAddress(handle, "imx_render"));
+#else
+        handle = dlopen(path.c_str(), RTLD_NOW);
+        if (!handle) {
+            std::cerr << "hotreload: dlopen failed: " << dlerror() << "\\n";
+            return false;
+        }
+        render = reinterpret_cast<RenderFn>(dlsym(handle, "imx_render"));
+#endif
+        if (!render) {
+            std::cerr << "hotreload: imx_render symbol not found\\n";
+            unload();
+            return false;
+        }
+        std::cout << "hotreload: loaded " << path << "\\n";
+        return true;
+    }
+
+    void unload() {
+        if (!handle) return;
+#ifdef _WIN32
+        FreeLibrary(handle);
+#else
+        dlclose(handle);
+#endif
+        handle = nullptr;
+        render = nullptr;
+    }
+
+    bool check_reload() {
+        if (path.empty() || !std::filesystem::exists(path)) return false;
+        auto current = std::filesystem::last_write_time(path);
+        if (current == last_write) return false;
+        std::cout << "hotreload: change detected, reloading...\\n";
+        unload();
+        // Small delay to ensure file write is complete
+#ifdef _WIN32
+        Sleep(100);
+#else
+        usleep(100000);
+#endif
+        if (load(path)) {
+            std::cout << "hotreload: reload successful\\n";
+            return true;
+        }
+        std::cerr << "hotreload: reload failed\\n";
+        return false;
+    }
+
+    ~HotModule() { unload(); }
+};
+`;
+const UI_ENTRY_CPP = `#include <imx/runtime.h>
+#include <imgui.h>
+#include "AppState.h"
+
+// Declared in app_root.gen.cpp (generated by imxc)
+namespace imx {
+template <> void render_root<AppState>(imx::Runtime& runtime, AppState& state);
+}
+
+#ifdef _WIN32
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT __attribute__((visibility("default")))
+#endif
+
+// ImGuiContext* must be passed from host — DLL has its own static ImGui globals
+extern "C" EXPORT void imx_render(imx::Runtime& runtime, AppState& state, ImGuiContext* ctx) {
+    ImGui::SetCurrentContext(ctx);
+    imx::render_root(runtime, state);
+}
+`;
+// ---------------------------------------------------------------------------
+// Feature definitions (prefixed names to avoid collisions when combined)
+// ---------------------------------------------------------------------------
+export const FEATURES = [
+    {
+        name: 'async',
+        description: 'Background tasks with std::thread',
+        includes: ['#include <thread>', '#include <chrono>'],
+        appStateCppHeaders: ['#include <string>'],
+        appStateCppFields: [
+            '    bool loading = false;',
+            '    std::string result = "";',
+            '    std::function<void()> onFetchAsync;',
+        ].join('\n'),
+        appStateTsFields: [
+            '    loading: boolean;',
+            '    result: string;',
+            '    onFetchAsync: () => void;',
+        ].join('\n'),
+        callbacks: `    app.state.onFetchAsync = [&]() {
+        app.state.loading = true;
+        app.state.result = "";
+        imx::run_async<std::string>(
+            app.runtime,
+            []() {
+                // Simulate work — replace with real computation
+                std::this_thread::sleep_for(std::chrono::seconds(2));
+                return std::string("Data loaded successfully!");
+            },
+            [&](std::string res) {
+                app.state.result = std::move(res);
+                app.state.loading = false;
+            }
+        );
+    };`,
+        tsxWindow: `      <Window title="Async Demo">
+        <Column gap={8}>
+          <Text>Background Task Example</Text>
+          <Separator />
+          <Button
+            title="Fetch Data"
+            onPress={props.onFetchAsync}
+            disabled={props.loading}
+          />
+          {props.loading && <Text color={[1, 0.8, 0, 1]}>Loading...</Text>}
+          {props.result !== "" && <Text color={[0, 1, 0, 1]}>Result: {props.result}</Text>}
+        </Column>
+      </Window>`,
+        extraFiles: { 'async.h': ASYNC_H },
+    },
+    {
+        name: 'persistence',
+        description: 'JSON save/load with nlohmann/json',
+        includes: [],
+        appStateCppHeaders: ['#include <string>', '#include <imx/json.hpp>'],
+        appStateCppFields: [
+            '    std::string name = "World";',
+            '    float volume = 50.0F;',
+            '    bool darkMode = true;',
+            '    std::function<void()> onSaveState;',
+            '    std::function<void()> onLoadState;',
+        ].join('\n'),
+        appStateTsFields: [
+            '    name: string;',
+            '    volume: number;',
+            '    darkMode: boolean;',
+            '    onSaveState: () => void;',
+            '    onLoadState: () => void;',
+        ].join('\n'),
+        callbacks: `    app.state.onSaveState = [&]() {
+        imx::save_json("state.json", app.state);
+    };
+    app.state.onLoadState = [&]() {
+        imx::load_json("state.json", app.state);
+        app.runtime.request_frame();
+    };
+
+    // Auto-load saved state (silently fails if no file exists)
+    imx::load_json("state.json", app.state);`,
+        tsxWindow: `      <Window title="Persistence Demo">
+        <Column gap={8}>
+          <Text>JSON Save/Load Example</Text>
+          <Separator />
+          <TextInput label="Name" value={props.name} />
+          <SliderFloat label="Volume" value={props.volume} min={0} max={100} />
+          <Checkbox label="Dark Mode" value={props.darkMode} />
+          <Separator />
+          <Row gap={8}>
+            <Button title="Save" onPress={props.onSaveState} />
+            <Button title="Load" onPress={props.onLoadState} />
+          </Row>
+        </Column>
+      </Window>`,
+        extraFiles: { 'persistence.h': PERSISTENCE_H },
+        dataFields: ['name', 'volume', 'darkMode'],
+    },
+    {
+        name: 'networking',
+        description: 'HTTP client with cpp-httplib',
+        requires: ['async'],
+        includes: ['#include <thread>', '#include <imx/httplib.h>'],
+        appStateCppHeaders: ['#include <string>'],
+        appStateCppFields: [
+            '    std::string url = "http://jsonplaceholder.typicode.com/todos/1";',
+            '    std::string response = "";',
+            '    bool loading = false;',
+            '    std::function<void()> onFetchNet;',
+        ].join('\n'),
+        appStateTsFields: [
+            '    url: string;',
+            '    response: string;',
+            '    loading: boolean;',
+            '    onFetchNet: () => void;',
+        ].join('\n'),
+        callbacks: `    // Wire up the HTTP fetch callback
+    app.state.onFetchNet = [&]() {
+        app.state.loading = true;
+        app.state.response = "";
+        std::string url = app.state.url;
+        imx::run_async<std::string>(
+            app.runtime,
+            [url]() -> std::string {
+                // Parse http://host/path
+                auto scheme_end = url.find("://");
+                if (scheme_end == std::string::npos)
+                    return "Error: invalid URL (must start with http://)";
+                auto host_start = scheme_end + 3;
+                auto path_start = url.find('/', host_start);
+                std::string host = (path_start != std::string::npos)
+                    ? url.substr(0, path_start) : url;
+                std::string path = (path_start != std::string::npos)
+                    ? url.substr(path_start) : "/";
+
+                // For HTTPS: #define CPPHTTPLIB_OPENSSL_SUPPORT and link OpenSSL
+                httplib::Client cli(host);
+                cli.set_connection_timeout(5);
+                cli.set_read_timeout(5);
+                auto res = cli.Get(path);
+                if (res) return res->body;
+                return "Error: request failed";
+            },
+            [&](std::string body) {
+                app.state.response = std::move(body);
+                app.state.loading = false;
+            }
+        );
+    };`,
+        tsxWindow: `      <Window title="Networking Demo">
+        <Column gap={8}>
+          <Text>HTTP Client Example</Text>
+          <Separator />
+          <TextInput label="URL" value={props.url} />
+          <Button title="Fetch" onPress={props.onFetchNet} disabled={props.loading} />
+          {props.loading && <Text color={[1, 0.8, 0, 1]}>Loading...</Text>}
+          {props.response !== "" && <Text wrapped={true}>{props.response}</Text>}
+        </Column>
+      </Window>`,
+        extraFiles: { 'async.h': ASYNC_H },
+    },
+    {
+        name: 'filedialog',
+        description: 'Native file dialogs + drag & drop',
+        includes: ['#include <imx/pfd.h>'],
+        appStateCppHeaders: ['#include <string>'],
+        appStateCppFields: [
+            '    std::string filePath = "";',
+            '    std::string message = "";',
+            '    std::function<void()> onOpenDialog;',
+            '    std::function<void()> onSaveDialog;',
+        ].join('\n'),
+        appStateTsFields: [
+            '    filePath: string;',
+            '    message: string;',
+            '    onOpenDialog: () => void;',
+            '    onSaveDialog: () => void;',
+        ].join('\n'),
+        callbacks: `    app.state.onOpenDialog = [&]() {
+        auto result = pfd::open_file("Open File").result();
+        if (!result.empty()) {
+            app.state.filePath = result[0];
+            app.state.message = "Opened: " + result[0];
+            app.runtime.request_frame();
+        }
+    };
+
+    app.state.onSaveDialog = [&]() {
+        auto result = pfd::save_file("Save File").result();
+        if (!result.empty()) {
+            app.state.filePath = result;
+            app.state.message = "Save to: " + result;
+            app.runtime.request_frame();
+        }
+    };
+
+    // GLFW file drop callback
+    glfwSetDropCallback(window, [](GLFWwindow* w, int count, const char** paths) {
+        auto* a = static_cast<App*>(glfwGetWindowUserPointer(w));
+        if (a && count > 0) {
+            a->state.filePath = paths[0];
+            a->state.message = "Dropped: " + std::string(paths[0]);
+            a->runtime.request_frame();
+        }
+    });`,
+        tsxWindow: `      <Window title="File Dialog Demo">
+        <Column gap={8}>
+          <Text>Native File Dialogs + Drag & Drop</Text>
+          <Separator />
+          <Row gap={8}>
+            <Button title="Open File" onPress={props.onOpenDialog} />
+            <Button title="Save File" onPress={props.onSaveDialog} />
+          </Row>
+          <Text>Drag & drop a file onto this window</Text>
+          {props.message !== "" && <Text color={[0, 1, 0, 1]}>{props.message}</Text>}
+          {props.filePath !== "" && <Text>Path: {props.filePath}</Text>}
+        </Column>
+      </Window>`,
+        extraFiles: {},
+    },
+    {
+        name: 'hotreload',
+        description: 'DLL hot reload for live UI iteration',
+        includes: [],
+        appStateCppHeaders: ['#include <string>'],
+        appStateCppFields: '    std::string watchCmd;\n    std::function<void()> onCopyCmd;',
+        appStateTsFields: '    watchCmd: string;\n    onCopyCmd: () => void;',
+        callbacks: `    app.state.watchCmd = "npx imxc watch src -o build/generated --build \\"cmake --build build --target imx_ui\\"";
+    app.state.onCopyCmd = [&]() { imx::clipboard_set(app.state.watchCmd.c_str()); };`,
+        tsxWindow: `      <Window title="Hot Reload">
+        <Column gap={8}>
+          <Text>Run this in a second terminal to enable live reload:</Text>
+          <Text wrapped={true}>{props.watchCmd}</Text>
+          <Button title="Copy" onPress={props.onCopyCmd} />
+        </Column>
+      </Window>`,
+        extraFiles: {},
+    },
+];
+// ---------------------------------------------------------------------------
+// CMake for hot reload (host exe + UI shared lib)
+// ---------------------------------------------------------------------------
+function cmakeHotreloadCombined(projectName) {
+    return `cmake_minimum_required(VERSION 3.25)
+project(${projectName} LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+include(FetchContent)
+set(FETCHCONTENT_QUIET OFF)
+
+FetchContent_Declare(
+    imx
+    GIT_REPOSITORY https://github.com/bgocumlu/imx.git
+    GIT_TAG v0.6.0
+    GIT_SHALLOW TRUE
+    GIT_PROGRESS TRUE
+)
+message(STATUS "Fetching IMX (includes ImGui + GLFW)...")
+FetchContent_MakeAvailable(imx)
+
+include(ImxCompile)
+
+imx_compile_tsx(GENERATED
+    SOURCES src/App.tsx
+    OUTPUT_DIR \${CMAKE_BINARY_DIR}/generated
+)
+
+# UI shared library (hot-reloadable)
+add_library(imx_ui SHARED
+    src/ui_entry.cpp
+    \${GENERATED}
+)
+target_link_libraries(imx_ui PRIVATE imx::renderer)
+target_include_directories(imx_ui PRIVATE \${CMAKE_BINARY_DIR}/generated \${CMAKE_CURRENT_SOURCE_DIR}/src)
+
+# Host executable (loads UI module dynamically)
+add_executable(${projectName}
+    src/main.cpp
+)
+set_target_properties(${projectName} PROPERTIES WIN32_EXECUTABLE $<CONFIG:Release>)
+target_link_libraries(${projectName} PRIVATE imx::renderer \${CMAKE_DL_LIBS})
+target_include_directories(${projectName} PRIVATE \${CMAKE_CURRENT_SOURCE_DIR}/src)
+
+# Copy DLL/SO next to host exe after build
+add_custom_command(TARGET imx_ui POST_BUILD
+    COMMAND \${CMAKE_COMMAND} -E copy $<TARGET_FILE:imx_ui> $<TARGET_FILE_DIR:${projectName}>
+    COMMENT "Copying UI module to host directory"
+)
+add_dependencies(${projectName} imx_ui)
+
+# Copy public/ assets to output directory
+add_custom_command(TARGET ${projectName} POST_BUILD
+    COMMAND \${CMAKE_COMMAND} -E copy_directory
+        \${CMAKE_CURRENT_SOURCE_DIR}/public
+        $<TARGET_FILE_DIR:${projectName}>
+    COMMENT "Copying public/ assets"
+)
+`;
+}
+// ---------------------------------------------------------------------------
+// Base main.cpp template with placeholders
+// ---------------------------------------------------------------------------
+function buildMainCpp(projectName, extraIncludes, callbacks, hasPersistence) {
+    const includeBlock = extraIncludes ? '\n' + extraIncludes : '';
+    const persistenceInclude = hasPersistence ? '\n#include "persistence.h"' : '';
+    return `#include <imx/runtime.h>
+#include <imx/renderer.h>
+
+#include <imgui.h>
+#include <imgui_impl_glfw.h>
+#include <imgui_impl_opengl3.h>
+#include <GLFW/glfw3.h>
+${includeBlock}${persistenceInclude}
+#include "AppState.h"
+
+struct App {
+    GLFWwindow*      window  = nullptr;
+    ImGuiIO*         io      = nullptr;
+    imx::Runtime runtime;
+    AppState state;
+};
+
+static void render_frame(App& app) {
+    glfwMakeContextCurrent(app.window);
+    if (glfwGetWindowAttrib(app.window, GLFW_ICONIFIED) != 0) return;
+
+    int fb_w = 0, fb_h = 0;
+    glfwGetFramebufferSize(app.window, &fb_w, &fb_h);
+    if (fb_w <= 0 || fb_h <= 0) return;
+
+    ImGui_ImplOpenGL3_NewFrame();
+    ImGui_ImplGlfw_NewFrame();
+    ImGui::NewFrame();
+
+    imx::render_root(app.runtime, app.state);
+
+    ImGui::Render();
+    glViewport(0, 0, fb_w, fb_h);
+    glClearColor(0.12F, 0.12F, 0.15F, 1.0F);
+    glClear(GL_COLOR_BUFFER_BIT);
+    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+
+    if ((app.io->ConfigFlags & ImGuiConfigFlags_ViewportsEnable) != 0) {
+        ImGui::UpdatePlatformWindows();
+        ImGui::RenderPlatformWindowsDefault();
+    }
+
+    glfwMakeContextCurrent(app.window);
+    glfwSwapBuffers(app.window);
+}
+
+static void window_size_callback(GLFWwindow* window, int, int) {
+    auto* app = static_cast<App*>(glfwGetWindowUserPointer(window));
+    if (app) render_frame(*app);
+}
+
+int main() {
+    if (glfwInit() == 0) return 1;
+
+    const char* glsl_version = "#version 150";
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+#ifdef __APPLE__
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+#endif
+
+    GLFWwindow* window = glfwCreateWindow(800, 600, "${projectName}", nullptr, nullptr);
+    if (!window) { glfwTerminate(); return 1; }
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    IMGUI_CHECKVERSION();
+    ImGui::CreateContext();
+    ImGuiIO& io = ImGui::GetIO();
+    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+    io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
+
+    ImGui::StyleColorsDark();
+    ImGuiStyle& style = ImGui::GetStyle();
+    if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) {
+        style.WindowRounding = 0.0F;
+        style.Colors[ImGuiCol_WindowBg].w = 1.0F;
+    }
+
+    ImGui_ImplGlfw_InitForOpenGL(window, true);
+    ImGui_ImplOpenGL3_Init(glsl_version);
+
+    App app;
+    app.window = window;
+    app.io = &io;
+    glfwSetWindowUserPointer(window, &app);
+    glfwSetWindowSizeCallback(window, window_size_callback);
+
+${callbacks}
+
+    while (glfwWindowShouldClose(window) == 0) {
+        if (app.runtime.needs_frame()) {
+            glfwPollEvents();
+        } else {
+            glfwWaitEventsTimeout(0.1);
+        }
+        render_frame(app);
+        app.runtime.frame_rendered(ImGui::IsAnyItemActive());
+    }
+
+    ImGui_ImplOpenGL3_Shutdown();
+    ImGui_ImplGlfw_Shutdown();
+    ImGui::DestroyContext();
+    glfwDestroyWindow(window);
+    glfwTerminate();
+    return 0;
+}
+
+#ifdef _WIN32
+#include <windows.h>
+int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) { return main(); }
+#endif
+`;
+}
+// ---------------------------------------------------------------------------
+// Hot reload main.cpp template (DLL-loading variant)
+// ---------------------------------------------------------------------------
+function buildMainCppHotreload(projectName, extraIncludes, callbacks, hasPersistence) {
+    const includeBlock = extraIncludes ? '\n' + extraIncludes : '';
+    const persistenceInclude = hasPersistence ? '\n#include "persistence.h"' : '';
+    return `#include <imx/runtime.h>
+#include <imx/renderer.h>
+
+#include <imgui.h>
+#include <imgui_impl_glfw.h>
+#include <imgui_impl_opengl3.h>
+#include <GLFW/glfw3.h>
+${includeBlock}${persistenceInclude}
+#include "hotreload.h"
+#include "AppState.h"
+
+struct App {
+    GLFWwindow*      window  = nullptr;
+    ImGuiIO*         io      = nullptr;
+    imx::Runtime runtime;
+    AppState state;
+    HotModule module;
+};
+
+static void render_frame(App& app) {
+    glfwMakeContextCurrent(app.window);
+    if (glfwGetWindowAttrib(app.window, GLFW_ICONIFIED) != 0) return;
+
+    int fb_w = 0, fb_h = 0;
+    glfwGetFramebufferSize(app.window, &fb_w, &fb_h);
+    if (fb_w <= 0 || fb_h <= 0) return;
+
+    ImGui_ImplOpenGL3_NewFrame();
+    ImGui_ImplGlfw_NewFrame();
+    ImGui::NewFrame();
+
+    app.module.check_reload();
+    if (app.module.render) {
+        app.module.render(app.runtime, app.state, ImGui::GetCurrentContext());
+    }
+
+    ImGui::Render();
+    glViewport(0, 0, fb_w, fb_h);
+    glClearColor(0.12F, 0.12F, 0.15F, 1.0F);
+    glClear(GL_COLOR_BUFFER_BIT);
+    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+
+    if ((app.io->ConfigFlags & ImGuiConfigFlags_ViewportsEnable) != 0) {
+        ImGui::UpdatePlatformWindows();
+        ImGui::RenderPlatformWindowsDefault();
+    }
+
+    glfwMakeContextCurrent(app.window);
+    glfwSwapBuffers(app.window);
+}
+
+static void window_size_callback(GLFWwindow* window, int, int) {
+    auto* app = static_cast<App*>(glfwGetWindowUserPointer(window));
+    if (app) render_frame(*app);
+}
+
+int main() {
+    if (glfwInit() == 0) return 1;
+
+    const char* glsl_version = "#version 150";
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+#ifdef __APPLE__
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+#endif
+
+    GLFWwindow* window = glfwCreateWindow(800, 600, "${projectName}", nullptr, nullptr);
+    if (!window) { glfwTerminate(); return 1; }
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    IMGUI_CHECKVERSION();
+    ImGui::CreateContext();
+    ImGuiIO& io = ImGui::GetIO();
+    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+    io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
+
+    ImGui::StyleColorsDark();
+    ImGuiStyle& style = ImGui::GetStyle();
+    if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) {
+        style.WindowRounding = 0.0F;
+        style.Colors[ImGuiCol_WindowBg].w = 1.0F;
+    }
+
+    ImGui_ImplGlfw_InitForOpenGL(window, true);
+    ImGui_ImplOpenGL3_Init(glsl_version);
+
+    App app;
+    app.window = window;
+    app.io = &io;
+    glfwSetWindowUserPointer(window, &app);
+    glfwSetWindowSizeCallback(window, window_size_callback);
+
+${callbacks}
+
+#ifdef _WIN32
+    app.module.load("imx_ui.dll");
+#elif defined(__APPLE__)
+    app.module.load("libimx_ui.dylib");
+#else
+    app.module.load("libimx_ui.so");
+#endif
+
+    while (glfwWindowShouldClose(window) == 0) {
+        if (app.runtime.needs_frame()) {
+            glfwPollEvents();
+        } else {
+            glfwWaitEventsTimeout(0.1);
+        }
+        render_frame(app);
+        app.runtime.frame_rendered(ImGui::IsAnyItemActive());
+    }
+
+    app.module.unload();
+
+    ImGui_ImplOpenGL3_Shutdown();
+    ImGui_ImplGlfw_Shutdown();
+    ImGui::DestroyContext();
+    glfwDestroyWindow(window);
+    glfwTerminate();
+    return 0;
+}
+
+#ifdef _WIN32
+#include <windows.h>
+int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) { return main(); }
+#endif
+`;
+}
+// ---------------------------------------------------------------------------
+// AppState.h builder
+// ---------------------------------------------------------------------------
+function buildAppStateH(headers, fields, nlohmannMacroFields) {
+    const dedupedHeaders = [...new Set(['#include <functional>', ...headers])];
+    const headerBlock = dedupedHeaders.join('\n');
+    const macroLine = nlohmannMacroFields
+        ? `\n// Only serialize data fields — callbacks are not persisted\nNLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(AppState, ${nlohmannMacroFields.join(', ')})\n`
+        : '';
+    return `#pragma once
+${headerBlock}
+
+struct AppState {
+${fields}
+};
+${macroLine}`;
+}
+// ---------------------------------------------------------------------------
+// App.tsx builder
+// ---------------------------------------------------------------------------
+function buildAppTsx(windows) {
+    return `export default function App(props: AppState) {
+  return (
+    <DockSpace>
+${windows}
+    </DockSpace>
+  );
+}
+`;
+}
+// ---------------------------------------------------------------------------
+// Deduplicate C++ struct fields by field name
+// ---------------------------------------------------------------------------
+function deduplicateFields(fieldsBlock) {
+    const seen = new Set();
+    const result = [];
+    for (const line of fieldsBlock.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed === '')
+            continue;
+        // Extract field name: match "type name = ..." or "std::function<...> name;"
+        const match = trimmed.match(/(\w+)\s*[=;]/);
+        if (match) {
+            const fieldName = match[1];
+            if (seen.has(fieldName))
+                continue;
+            seen.add(fieldName);
+        }
+        result.push(line);
+    }
+    return result.join('\n');
+}
+// ---------------------------------------------------------------------------
+// Deduplicate TS interface fields by field name
+// ---------------------------------------------------------------------------
+function deduplicateTsFields(fieldsBlock) {
+    const seen = new Set();
+    const result = [];
+    for (const line of fieldsBlock.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed === '')
+            continue;
+        // Extract field name: "name: type;"
+        const match = trimmed.match(/^(\w+)\s*[?]?\s*:/);
+        if (match) {
+            const fieldName = match[1];
+            if (seen.has(fieldName))
+                continue;
+            seen.add(fieldName);
+        }
+        result.push(line);
+    }
+    return result.join('\n');
+}
+// ---------------------------------------------------------------------------
+// Main entry: generateCombined()
+// ---------------------------------------------------------------------------
+export function generateCombined(featureNames, projectDir, projectName) {
+    // 1. Resolve feature objects
+    const featureMap = new Map();
+    for (const f of FEATURES)
+        featureMap.set(f.name, f);
+    // Validate all names exist
+    for (const name of featureNames) {
+        if (!featureMap.has(name)) {
+            console.error(`Error: unknown feature "${name}". Available: ${FEATURES.map(f => f.name).join(', ')}`);
+            process.exit(1);
+        }
+    }
+    // 2. Resolve dependencies (auto-add required features)
+    const selected = new Set(featureNames);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const name of [...selected]) {
+            const feat = featureMap.get(name);
+            if (feat.requires) {
+                for (const dep of feat.requires) {
+                    if (!selected.has(dep)) {
+                        selected.add(dep);
+                        changed = true;
+                    }
+                }
+            }
+        }
+    }
+    // Deterministic order: follow FEATURES array order
+    const ordered = FEATURES.filter(f => selected.has(f.name));
+    // 4. Collect everything
+    const allIncludes = [];
+    const allCppFields = [];
+    const allCppHeaders = [];
+    const allTsFields = [];
+    const allCallbacks = [];
+    const allWindows = [];
+    const allExtraFiles = {};
+    let nlohmannFields = null;
+    for (const feat of ordered) {
+        for (const inc of feat.includes) {
+            if (!allIncludes.includes(inc))
+                allIncludes.push(inc);
+        }
+        if (feat.appStateCppFields)
+            allCppFields.push(feat.appStateCppFields);
+        for (const h of feat.appStateCppHeaders) {
+            if (!allCppHeaders.includes(h))
+                allCppHeaders.push(h);
+        }
+        if (feat.appStateTsFields)
+            allTsFields.push(feat.appStateTsFields);
+        if (feat.callbacks)
+            allCallbacks.push(feat.callbacks);
+        if (feat.tsxWindow)
+            allWindows.push(feat.tsxWindow);
+        Object.assign(allExtraFiles, feat.extraFiles);
+        if (feat.dataFields) {
+            nlohmannFields = nlohmannFields || [];
+            nlohmannFields.push(...feat.dataFields);
+        }
+    }
+    // Deduplicate struct fields (e.g. `loading` from both async and networking)
+    const mergedCppFields = deduplicateFields(allCppFields.join('\n'));
+    const mergedTsFields = deduplicateTsFields(allTsFields.join('\n'));
+    // 5. Check for existing files
+    const srcDir = path.join(projectDir, 'src');
+    if (fs.existsSync(path.join(srcDir, 'App.tsx'))) {
+        console.error(`Error: ${srcDir}/App.tsx already exists. Aborting.`);
+        process.exit(1);
+    }
+    fs.mkdirSync(srcDir, { recursive: true });
+    const publicDir = path.join(projectDir, 'public');
+    fs.mkdirSync(publicDir, { recursive: true });
+    // 6. Build files
+    const hasHotreload = selected.has('hotreload');
+    const hasPersistence = selected.has('persistence');
+    const includeLines = allIncludes.length > 0 ? allIncludes.join('\n') : '';
+    // Add async.h include if async.h is in extra files
+    const hasAsyncH = 'async.h' in allExtraFiles;
+    const asyncInclude = hasAsyncH ? '#include "async.h"' : '';
+    const fullIncludes = [includeLines, asyncInclude].filter(Boolean).join('\n');
+    // Build main.cpp
+    const mainCpp = hasHotreload
+        ? buildMainCppHotreload(projectName, fullIncludes, allCallbacks.join('\n\n'), hasPersistence)
+        : buildMainCpp(projectName, fullIncludes, allCallbacks.join('\n\n'), hasPersistence);
+    const appStateH = buildAppStateH(allCppHeaders, mergedCppFields, nlohmannFields);
+    const appStateInterface = `interface AppState {\n${mergedTsFields}\n}`;
+    const appTsx = buildAppTsx(allWindows.join('\n'));
+    const imxDts = buildImxDts(appStateInterface);
+    // Build CMakeLists
+    const cmake = hasHotreload
+        ? cmakeHotreloadCombined(projectName)
+        : cmakeTemplate(projectName, 'https://github.com/bgocumlu/imx.git');
+    // 7. Write files
+    fs.writeFileSync(path.join(srcDir, 'main.cpp'), mainCpp);
+    fs.writeFileSync(path.join(srcDir, 'AppState.h'), appStateH);
+    fs.writeFileSync(path.join(srcDir, 'App.tsx'), appTsx);
+    fs.writeFileSync(path.join(srcDir, 'imx.d.ts'), imxDts);
+    fs.writeFileSync(path.join(projectDir, 'tsconfig.json'), TSCONFIG);
+    fs.writeFileSync(path.join(projectDir, 'CMakeLists.txt'), cmake);
+    fs.writeFileSync(path.join(projectDir, '.gitignore'), GITIGNORE);
+    const createdFiles = [
+        'src/main.cpp',
+        'src/AppState.h',
+        'src/App.tsx',
+        'src/imx.d.ts',
+    ];
+    for (const [filename, content] of Object.entries(allExtraFiles)) {
+        fs.writeFileSync(path.join(srcDir, filename), content);
+        createdFiles.push(`src/${filename}`);
+    }
+    // Write hotreload-specific files
+    if (hasHotreload) {
+        fs.writeFileSync(path.join(srcDir, 'hotreload.h'), HOTRELOAD_H);
+        fs.writeFileSync(path.join(srcDir, 'ui_entry.cpp'), UI_ENTRY_CPP);
+        createdFiles.push('src/hotreload.h', 'src/ui_entry.cpp');
+    }
+    createdFiles.push('tsconfig.json', 'CMakeLists.txt', '.gitignore', 'public/');
+    // 8. Print summary
+    const featureList = ordered.map(f => f.name).join(', ');
+    console.log(`imxc: initialized project "${projectName}" with features: ${featureList}`);
+    console.log('');
+    console.log('  Created:');
+    for (const file of createdFiles) {
+        const pad = file.length < 22 ? ' '.repeat(22 - file.length) : ' ';
+        console.log(`    ${file}${pad}`);
+    }
+    console.log('');
+    console.log('  Next steps:');
+    console.log(`    cd ${projectName}`);
+    console.log(`    cmake -B build`);
+    console.log(`    cmake --build build`);
+}