@vib3code/sdk 2.0.1 → 2.0.3-canary.3349130

package/README.md

@@ -2,12 +2,18 @@
 
 **General-purpose 4D rotation visualization SDK** for plugins, extensions, wearables, and agentic AI integration.
 
-[![Tests](https://img.shields.io/badge/tests-693%2B%20passing-brightgreen)](#testing)
-[![Version](https://img.shields.io/badge/version-2.0.0-blue)](#)
+[![Tests](https://img.shields.io/badge/tests-CI%20tracked-brightgreen)](DOCS/STATUS.md#test-status)
+[![Version](https://img.shields.io/badge/version-2.0.3-blue)](DOCS/STATUS.md#vib3-sdk-status)
 [![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 
 ---
 
+## Documentation
+
+The main documentation entrypoint is [`DOCS/README.md`](./DOCS/README.md), which includes canonical docs, persona-based reading paths, taxonomy, and source-of-truth ownership.
+
+---
+
 ## Quick Reference
 
 | Metric | Value |
@@ -29,7 +35,7 @@
 - **Agentic Integration:** MCP server with 14 tools for AI agent control
 - **Cross-Platform:** Web, WASM, Flutter support
 
-### New in v2.0.0
+### New in current release (v2.0.x)
 
 - **Universal Spatial Input:** 8 input sources (tilt, gyroscope, gamepad, mouse, MIDI, audio, programmatic, perspective) with 6 built-in profiles (card tilt, wearable, game, VJ, UI, XR)
 - **Creative Tooling:** 22 color presets, 14 easing transitions, 14 post-processing effects, keyframe timeline with BPM sync
@@ -176,7 +182,7 @@ engine.randomizeAll();
 engine.resetAll();
 ```
 
-### Spatial Input API (v2.0.0)
+### Spatial Input API (v2.0.x)
 
 ```javascript
 // Enable spatial input with a profile
@@ -194,7 +200,7 @@ engine.setSpatialDramaticMode(true); // 8x amplification
 //                     vjAudioSpatial, uiElement, immersiveXR
 ```
 
-### Framework Integration (v2.0.0)
+### Framework Integration (v2.0.x)
 
 ```javascript
 // React
@@ -348,17 +354,17 @@ echo 'geometry 10' | node src/cli/index.js
 │   │   ├── cli/              # CLI interface
 │   │   └── telemetry/        # Instrumentation
 │   ├── export/               # Export generators
-│   ├── reactivity/           # Reactivity + SpatialInputSystem (v2.0.0)
-│   ├── creative/             # Color presets, transitions, post-FX, timeline (v2.0.0)
-│   ├── integrations/         # React, Vue, Svelte, Figma, Three.js, TD, OBS (v2.0.0)
-│   └── advanced/             # WebXR, WebGPU compute, MIDI, AI, Worker (v2.0.0)
+│   ├── reactivity/           # Reactivity + SpatialInputSystem (current release series)
+│   ├── creative/             # Color presets, transitions, post-FX, timeline (current release series)
+│   ├── integrations/         # React, Vue, Svelte, Figma, Three.js, TD, OBS (current release series)
+│   └── advanced/             # WebXR, WebGPU compute, MIDI, AI, Worker (current release series)
 ├── tools/                    # Tooling (+ shader-sync-verify.js)
 ├── cpp/                      # C++ math core (WASM)
 ├── js/                       # Client-side integration
-├── tests/                    # Test suite (693+ tests)
+├── tests/                    # Test suite (CI-tracked status)
 ├── DOCS/                     # Documentation
 │   ├── SYSTEM_INVENTORY.md   # Complete system reference
-│   ├── SYSTEM_AUDIT_2026-01-30.md  # Full system audit
+│   ├── archive/SYSTEM_AUDIT_2026-01-30.md  # Full system audit (archived)
 │   ├── CLI_ONBOARDING.md     # Agent CLI setup
 │   └── CONTROL_REFERENCE.md  # UI parameters
 └── types/                    # TypeScript definitions
@@ -379,7 +385,7 @@ npm test -- --coverage
 npm test -- tests/agent/AgentCLI.test.js
 ```
 
-**Current Status:** 693+ tests passing
+**Current Status:** See [`DOCS/STATUS.md`](DOCS/STATUS.md) for release and CI-linked test status.
 
 ---
 
@@ -387,13 +393,20 @@ npm test -- tests/agent/AgentCLI.test.js
 
 | Document | Description |
 |----------|-------------|
+| [`DOCS/STATUS.md`](DOCS/STATUS.md) | Canonical release status (version, date, platforms, CI test status) |
+| [`DOCS/SYSTEM_INVENTORY.md`](DOCS/SYSTEM_INVENTORY.md) | Complete technical reference |
+| [`DOCS/SYSTEM_AUDIT_2026-01-30.md`](DOCS/SYSTEM_AUDIT_2026-01-30.md) | Full system audit |
 | [`DOCS/SYSTEM_INVENTORY.md`](DOCS/SYSTEM_INVENTORY.md) | Complete technical reference (v2.0.0) |
+| [`DOCS/PRODUCT_STRATEGY.md`](DOCS/PRODUCT_STRATEGY.md) | Product strategy: personas, use-cases, differentiation, and metrics |
+| [`DOCS/ROADMAP.md`](DOCS/ROADMAP.md) | Strategy goals mapped to technical epics and module ownership |
+| [`DOCS/README.md`](DOCS/README.md) | Documentation index and navigation hub |
 | [`DOCS/SYSTEM_AUDIT_2026-01-30.md`](DOCS/SYSTEM_AUDIT_2026-01-30.md) | Full system audit (v2.0.0) |
+| [`DOCS/archive/SYSTEM_AUDIT_2026-01-30.md`](DOCS/archive/SYSTEM_AUDIT_2026-01-30.md) | Full system audit (v2.0.0, archived) |
 | [`DOCS/CLI_ONBOARDING.md`](DOCS/CLI_ONBOARDING.md) | Agent CLI setup guide |
 | [`DOCS/CONTROL_REFERENCE.md`](DOCS/CONTROL_REFERENCE.md) | UI parameter reference |
 | [`24-GEOMETRY-6D-ROTATION-SUMMARY.md`](24-GEOMETRY-6D-ROTATION-SUMMARY.md) | Geometry encoding details |
 | [`DOCS/GPU_DISPOSAL_GUIDE.md`](DOCS/GPU_DISPOSAL_GUIDE.md) | Resource management |
-| [`CLAUDE.md`](CLAUDE.md) | AI/Developer technical reference (v2.0.0) |
+| [`CLAUDE.md`](CLAUDE.md) | AI/Developer technical reference |
 
 ---
 

package/cpp/CMakeLists.txt

@@ -0,0 +1,236 @@
+cmake_minimum_required(VERSION 3.20)
+project(vib3_core VERSION 1.0.0 LANGUAGES CXX)
+
+# C++20 required for concepts, ranges, and std::numbers
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# Build options
+option(VIB3_BUILD_WASM "Build WebAssembly module" ON)
+option(VIB3_BUILD_TESTS "Build unit tests" ON)
+option(VIB3_ENABLE_SIMD "Enable SIMD optimizations" ON)
+option(VIB3_ENABLE_THREADS "Enable threading support" OFF)
+
+# Output directories
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+
+# Compiler warnings
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
+    add_compile_options(
+        -Wall
+        -Wextra
+        -Wpedantic
+        -Wconversion
+        -Wsign-conversion
+        -Wno-unused-parameter
+    )
+endif()
+
+# SIMD support
+if(VIB3_ENABLE_SIMD)
+    if(EMSCRIPTEN)
+        add_compile_options(-msimd128)
+        add_link_options(-msimd128)
+    elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
+        # Detect CPU architecture
+        include(CheckCXXCompilerFlag)
+        check_cxx_compiler_flag("-mavx2" COMPILER_SUPPORTS_AVX2)
+        check_cxx_compiler_flag("-msse4.1" COMPILER_SUPPORTS_SSE41)
+
+        if(COMPILER_SUPPORTS_AVX2)
+            add_compile_options(-mavx2 -mfma)
+            add_definitions(-DVIB3_HAS_AVX2)
+        elseif(COMPILER_SUPPORTS_SSE41)
+            add_compile_options(-msse4.1)
+            add_definitions(-DVIB3_HAS_SSE41)
+        endif()
+    endif()
+endif()
+
+# Math library (required)
+if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/math/Vec4.cpp")
+    add_library(vib3_math STATIC
+        math/Vec4.cpp
+        math/Rotor4D.cpp
+        math/Mat4x4.cpp
+        math/Projection.cpp
+    )
+
+    target_include_directories(vib3_math PUBLIC
+        ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+else()
+    message(WARNING "VIB3: math/ directory not found, skipping vib3_math library")
+endif()
+
+# Geometry library (optional — may not exist in Flutter/submodule checkouts)
+if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/geometry/GeometryGenerator.cpp")
+    add_library(vib3_geometry STATIC
+        geometry/GeometryGenerator.cpp
+        geometry/Tesseract.cpp
+        geometry/Tetrahedron.cpp
+        geometry/Sphere.cpp
+        geometry/Torus.cpp
+        geometry/KleinBottle.cpp
+        geometry/Fractal.cpp
+        geometry/Wave.cpp
+        geometry/Crystal.cpp
+        geometry/WarpFunctions.cpp
+    )
+
+    target_link_libraries(vib3_geometry PUBLIC vib3_math)
+
+    target_include_directories(vib3_geometry PUBLIC
+        ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+else()
+    message(WARNING "VIB3: geometry/ directory not found, skipping vib3_geometry library")
+endif()
+
+# WebAssembly build
+if(EMSCRIPTEN AND VIB3_BUILD_WASM AND TARGET vib3_math AND TARGET vib3_geometry)
+    # Combined WASM module
+    add_executable(vib3_wasm
+        bindings/embind.cpp
+    )
+
+    target_link_libraries(vib3_wasm PRIVATE
+        vib3_math
+        vib3_geometry
+    )
+
+    # Emscripten settings
+    set_target_properties(vib3_wasm PROPERTIES
+        OUTPUT_NAME "vib3"
+        SUFFIX ".js"
+    )
+
+    # Emscripten link options
+    target_link_options(vib3_wasm PRIVATE
+        # Output formats
+        -sWASM=1
+        -sMODULARIZE=1
+        -sEXPORT_NAME=createVIB3Module
+        -sEXPORT_ES6=1
+
+        # Memory settings
+        -sALLOW_MEMORY_GROWTH=1
+        -sINITIAL_MEMORY=16777216  # 16MB initial
+        -sMAXIMUM_MEMORY=268435456 # 256MB max
+        -sSTACK_SIZE=1048576       # 1MB stack
+
+        # Bindings
+        --bind
+        -sNO_DISABLE_EXCEPTION_CATCHING
+
+        # Optimizations
+        -sASSERTIONS=0
+        -sMALLOC=emmalloc
+
+        # Environment
+        -sENVIRONMENT=web,worker
+        -sFILESYSTEM=0
+        -sNO_EXIT_RUNTIME=1
+
+        # TypeScript definitions
+        --emit-tsd vib3.d.ts
+    )
+
+    # SIMD for WASM
+    if(VIB3_ENABLE_SIMD)
+        target_link_options(vib3_wasm PRIVATE -msimd128)
+    endif()
+
+    # Threading for WASM (optional)
+    if(VIB3_ENABLE_THREADS)
+        target_link_options(vib3_wasm PRIVATE
+            -pthread
+            -sPTHREAD_POOL_SIZE=4
+        )
+    endif()
+
+    # Debug vs Release
+    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+        target_link_options(vib3_wasm PRIVATE
+            -sASSERTIONS=2
+            -sSAFE_HEAP=1
+            -sSTACK_OVERFLOW_CHECK=2
+            -g
+        )
+    else()
+        target_link_options(vib3_wasm PRIVATE
+            -O3
+            -flto
+            --closure 1
+        )
+    endif()
+
+    # Install WASM files
+    install(
+        FILES
+            ${CMAKE_BINARY_DIR}/bin/vib3.js
+            ${CMAKE_BINARY_DIR}/bin/vib3.wasm
+            ${CMAKE_BINARY_DIR}/bin/vib3.d.ts
+        DESTINATION ${CMAKE_SOURCE_DIR}/../dist/wasm
+    )
+endif()
+
+# Native tests (not for WASM, only if sources exist)
+if(VIB3_BUILD_TESTS AND NOT EMSCRIPTEN AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/tests/Vec4_test.cpp")
+    enable_testing()
+
+    # Find or fetch GoogleTest
+    include(FetchContent)
+    FetchContent_Declare(
+        googletest
+        URL https://github.com/google/googletest/archive/refs/tags/v1.14.0.zip
+    )
+    FetchContent_MakeAvailable(googletest)
+
+    # Math tests
+    if(TARGET vib3_math)
+        add_executable(math_tests
+            tests/Vec4_test.cpp
+            tests/Rotor4D_test.cpp
+            tests/Mat4x4_test.cpp
+            tests/Projection_test.cpp
+        )
+
+        target_link_libraries(math_tests PRIVATE
+            vib3_math
+            GTest::gtest_main
+        )
+
+        include(GoogleTest)
+        gtest_discover_tests(math_tests)
+    endif()
+
+    # Geometry tests
+    if(TARGET vib3_geometry AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/tests/Geometry_test.cpp")
+        add_executable(geometry_tests
+            tests/Geometry_test.cpp
+        )
+
+        target_link_libraries(geometry_tests PRIVATE
+            vib3_geometry
+            GTest::gtest_main
+        )
+
+        gtest_discover_tests(geometry_tests)
+    endif()
+endif()
+
+# Print configuration summary
+message(STATUS "")
+message(STATUS "VIB3 Core Configuration:")
+message(STATUS "  Version:       ${PROJECT_VERSION}")
+message(STATUS "  C++ Standard:  ${CMAKE_CXX_STANDARD}")
+message(STATUS "  Build WASM:    ${VIB3_BUILD_WASM}")
+message(STATUS "  Build Tests:   ${VIB3_BUILD_TESTS}")
+message(STATUS "  Enable SIMD:   ${VIB3_ENABLE_SIMD}")
+message(STATUS "  Enable Threads:${VIB3_ENABLE_THREADS}")
+message(STATUS "  Build Type:    ${CMAKE_BUILD_TYPE}")
+message(STATUS "")

package/cpp/bindings/embind.cpp

@@ -0,0 +1,269 @@
+/**
+ * embind.cpp - Emscripten JavaScript Bindings
+ *
+ * Exposes VIB3+ C++ classes to JavaScript via WebAssembly.
+ */
+
+#include <emscripten/bind.h>
+#include "../math/Vec4.hpp"
+#include "../math/Rotor4D.hpp"
+#include "../math/Mat4x4.hpp"
+#include "../math/Projection.hpp"
+
+using namespace emscripten;
+using namespace vib3;
+
+// Helper to convert std::array to JS array
+template<typename T, size_t N>
+val arrayToVal(const std::array<T, N>& arr) {
+    val jsArray = val::array();
+    for (size_t i = 0; i < N; ++i) {
+        jsArray.call<void>("push", arr[i]);
+    }
+    return jsArray;
+}
+
+// Helper to convert JS array to std::array
+template<typename T, size_t N>
+std::array<T, N> valToArray(const val& jsArray) {
+    std::array<T, N> arr;
+    for (size_t i = 0; i < N; ++i) {
+        arr[i] = jsArray[i].as<T>();
+    }
+    return arr;
+}
+
+EMSCRIPTEN_BINDINGS(vib3_math) {
+    // ====== Vec4 ======
+
+    class_<Vec4>("Vec4")
+        .constructor<>()
+        .constructor<float, float, float, float>()
+        .constructor<float>()
+
+        // Properties
+        .property("x", &Vec4::x)
+        .property("y", &Vec4::y)
+        .property("z", &Vec4::z)
+        .property("w", &Vec4::w)
+
+        // Static factories
+        .class_function("zero", &Vec4::zero)
+        .class_function("one", &Vec4::one)
+        .class_function("unitX", &Vec4::unitX)
+        .class_function("unitY", &Vec4::unitY)
+        .class_function("unitZ", &Vec4::unitZ)
+        .class_function("unitW", &Vec4::unitW)
+        .class_function("randomUnit", &Vec4::randomUnit)
+
+        // Arithmetic
+        .function("add", select_overload<Vec4(const Vec4&) const>(&Vec4::operator+))
+        .function("sub", select_overload<Vec4(const Vec4&) const>(&Vec4::operator-))
+        .function("mul", select_overload<Vec4(float) const>(&Vec4::operator*))
+        .function("div", select_overload<Vec4(float) const>(&Vec4::operator/))
+        .function("neg", select_overload<Vec4() const>(&Vec4::operator-))
+
+        // Operations
+        .function("dot", &Vec4::dot)
+        .function("length", &Vec4::length)
+        .function("lengthSquared", &Vec4::lengthSquared)
+        .function("normalized", &Vec4::normalized)
+        .function("normalize", &Vec4::normalize)
+        .function("distanceTo", &Vec4::distanceTo)
+        .function("distanceSquaredTo", &Vec4::distanceSquaredTo)
+        .function("lerp", &Vec4::lerp)
+        .function("min", &Vec4::min)
+        .function("max", &Vec4::max)
+        .function("clamp", &Vec4::clamp)
+        .function("abs", &Vec4::abs)
+        .function("projectOnto", &Vec4::projectOnto)
+        .function("reflect", &Vec4::reflect)
+        .function("isZero", &Vec4::isZero)
+        .function("isNormalized", &Vec4::isNormalized)
+
+        // Projections
+        .function("projectPerspective", &Vec4::projectPerspective)
+        .function("projectStereographic", &Vec4::projectStereographic)
+        .function("projectOrthographic", &Vec4::projectOrthographic)
+
+        // Conversion
+        .function("toArray", optional_override([](const Vec4& self) {
+            return arrayToVal<float, 4>(self.data);
+        }))
+        ;
+
+    // Free function for Vec4 construction from array
+    function("vec4FromArray", optional_override([](const val& arr) {
+        return Vec4(arr[0].as<float>(), arr[1].as<float>(),
+                    arr[2].as<float>(), arr[3].as<float>());
+    }));
+
+    // ====== Rotor4D ======
+
+    enum_<RotationPlane>("RotationPlane")
+        .value("XY", RotationPlane::XY)
+        .value("XZ", RotationPlane::XZ)
+        .value("YZ", RotationPlane::YZ)
+        .value("XW", RotationPlane::XW)
+        .value("YW", RotationPlane::YW)
+        .value("ZW", RotationPlane::ZW)
+        ;
+
+    class_<Rotor4D>("Rotor4D")
+        .constructor<>()
+        .constructor<float, float, float, float, float, float, float, float>()
+
+        // Components
+        .property("s", &Rotor4D::s)
+        .property("xy", &Rotor4D::xy)
+        .property("xz", &Rotor4D::xz)
+        .property("yz", &Rotor4D::yz)
+        .property("xw", &Rotor4D::xw)
+        .property("yw", &Rotor4D::yw)
+        .property("zw", &Rotor4D::zw)
+        .property("xyzw", &Rotor4D::xyzw)
+
+        // Static factories
+        .class_function("identity", &Rotor4D::identity)
+        .class_function("fromPlaneAngle", &Rotor4D::fromPlaneAngle)
+        .class_function("fromEuler6", select_overload<Rotor4D(float, float, float, float, float, float)>(&Rotor4D::fromEuler6))
+
+        // Operations
+        .function("mul", select_overload<Rotor4D(const Rotor4D&) const>(&Rotor4D::operator*))
+        .function("reverse", &Rotor4D::reverse)
+        .function("magnitude", &Rotor4D::magnitude)
+        .function("magnitudeSquared", &Rotor4D::magnitudeSquared)
+        .function("normalized", &Rotor4D::normalized)
+        .function("normalize", &Rotor4D::normalize)
+        .function("inverse", &Rotor4D::inverse)
+        .function("isNormalized", &Rotor4D::isNormalized)
+
+        // Vector rotation
+        .function("rotate", &Rotor4D::rotate)
+
+        // Interpolation
+        .function("slerp", &Rotor4D::slerp)
+        .function("nlerp", &Rotor4D::nlerp)
+        .function("dot", &Rotor4D::dot)
+
+        // Matrix conversion
+        .function("toMatrix", &Rotor4D::toMatrix)
+
+        // Conversion
+        .function("toArray", optional_override([](const Rotor4D& self) {
+            return arrayToVal<float, 8>(self.toArray());
+        }))
+        ;
+
+    // Free function for rotor creation from angle array
+    function("rotorFromEuler6Array", optional_override([](const val& arr) {
+        return Rotor4D::fromEuler6(
+            arr[0].as<float>(), arr[1].as<float>(), arr[2].as<float>(),
+            arr[3].as<float>(), arr[4].as<float>(), arr[5].as<float>()
+        );
+    }));
+
+    // ====== Mat4x4 ======
+
+    class_<Mat4x4>("Mat4x4")
+        .constructor<>()
+        .constructor<float>()
+
+        // Static factories
+        .class_function("identity", &Mat4x4::identity)
+        .class_function("zero", &Mat4x4::zero)
+        .class_function("rotationXY", &Mat4x4::rotationXY)
+        .class_function("rotationXZ", &Mat4x4::rotationXZ)
+        .class_function("rotationYZ", &Mat4x4::rotationYZ)
+        .class_function("rotationXW", &Mat4x4::rotationXW)
+        .class_function("rotationYW", &Mat4x4::rotationYW)
+        .class_function("rotationZW", &Mat4x4::rotationZW)
+        .class_function("rotationFromAngles", select_overload<Mat4x4(float, float, float, float, float, float)>(&Mat4x4::rotationFromAngles))
+        .class_function("scale", select_overload<Mat4x4(float)>(&Mat4x4::scale))
+
+        // Element access
+        .function("at", select_overload<float&(size_t, size_t)>(&Mat4x4::at))
+        .function("column", &Mat4x4::column)
+        .function("row", &Mat4x4::row)
+
+        // Operations
+        .function("mulMat", select_overload<Mat4x4(const Mat4x4&) const>(&Mat4x4::operator*))
+        .function("mulVec", select_overload<Vec4(const Vec4&) const>(&Mat4x4::operator*))
+        .function("mulScalar", select_overload<Mat4x4(float) const>(&Mat4x4::operator*))
+        .function("add", select_overload<Mat4x4(const Mat4x4&) const>(&Mat4x4::operator+))
+        .function("sub", select_overload<Mat4x4(const Mat4x4&) const>(&Mat4x4::operator-))
+        .function("transposed", &Mat4x4::transposed)
+        .function("transpose", &Mat4x4::transpose)
+        .function("determinant", &Mat4x4::determinant)
+        .function("inverse", &Mat4x4::inverse)
+        .function("isOrthogonal", &Mat4x4::isOrthogonal)
+        .function("isIdentity", &Mat4x4::isIdentity)
+
+        // Conversion
+        .function("toArray", optional_override([](const Mat4x4& self) {
+            return arrayToVal<float, 16>(self.data);
+        }))
+        ;
+
+    // Free function for matrix from angles array
+    function("matrixFromAnglesArray", optional_override([](const val& arr) {
+        return Mat4x4::rotationFromAngles(
+            arr[0].as<float>(), arr[1].as<float>(), arr[2].as<float>(),
+            arr[3].as<float>(), arr[4].as<float>(), arr[5].as<float>()
+        );
+    }));
+
+    // ====== Projection ======
+
+    value_object<Projection3D>("Projection3D")
+        .field("x", &Projection3D::x)
+        .field("y", &Projection3D::y)
+        .field("z", &Projection3D::z)
+        ;
+
+    value_object<SliceResult>("SliceResult")
+        .field("point", &SliceResult::point)
+        .field("alpha", &SliceResult::alpha)
+        .field("valid", &SliceResult::valid)
+        ;
+
+    // Projection functions
+    function("projectPerspective", &projectPerspective);
+    function("projectStereographic", &projectStereographic);
+    function("projectOrthographic", &projectOrthographic);
+    function("projectOblique", &projectOblique);
+    function("projectSlice", &projectSlice);
+
+    // Batch projections (returns typed array for efficiency)
+    function("projectToFloatArray", optional_override([](const val& jsPoints, float distance) {
+        std::vector<Vec4> points;
+        size_t len = jsPoints["length"].as<size_t>();
+        points.reserve(len);
+
+        for (size_t i = 0; i < len; ++i) {
+            points.push_back(jsPoints[i].as<Vec4>());
+        }
+
+        auto result = projectToFloatArray(points, distance);
+
+        // Return as Float32Array for efficient GPU upload
+        return val::global("Float32Array").new_(typed_memory_view(result.size(), result.data()));
+    }));
+}
+
+// Module initialization
+EMSCRIPTEN_BINDINGS(vib3_module) {
+    // Version info
+    function("getVersion", optional_override([]() {
+        return std::string("1.0.0");
+    }));
+
+    // Feature detection
+    function("hasSimd", optional_override([]() {
+#if defined(VIB3_HAS_SSE41) || defined(__wasm_simd128__)
+        return true;
+#else
+        return false;
+#endif
+    }));
+}