@directivegames/genesys.sdk 3.2.2

package/dist/src/templates/src/templates/vehicle/src/primitive-vehicle.js

@@ -0,0 +1,259 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var PrimitiveVehicle_1;
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import { BaseVehicle } from './base-vehicle.js';
+/**
+ * A simple vehicle with a box geometry
+ *
+ * Key points:
+ * - Movement parameters configured in createVehicleMovementComponent
+ * - No component is persisted (root is transient) in order to support recreating all the components in code (which is desired)
+ * - Rely on the builtin feature to create the wheel mesh (createWheelMeshes = true), no need to create them manually
+ * - All decorative meshes have physics disabled won't mess with the handling
+ * - Find the tail light meshes after the constructor so it works with deserialized actor
+ * - Rely on the base vehicle class to handle the camera and player interaction
+ */
+let PrimitiveVehicle = PrimitiveVehicle_1 = class PrimitiveVehicle extends BaseVehicle {
+    tailLightComponents = [];
+    constructor(options) {
+        // Create chassis mesh
+        const rootComponent = new ENGINE.MeshComponent({
+            geometry: new THREE.BoxGeometry(2, 1, 4),
+            material: new THREE.MeshStandardMaterial({
+                color: 0x4444FF,
+                roughness: 0.7,
+                metalness: 0.3,
+            }),
+            physicsOptions: {
+                enabled: true,
+                motionType: ENGINE.PhysicsMotionType.Dynamic,
+                generateCollisionEvents: true,
+            },
+        });
+        rootComponent.castShadow = true;
+        rootComponent.name = 'chassis';
+        // mark the component as transient, this prevents all the components from being saved since we're recreating them in code
+        rootComponent.setTransient(true);
+        options.rootComponent = rootComponent;
+        // create decorative meshes
+        PrimitiveVehicle_1.createDecorativeMeshes(rootComponent);
+        options.movementComponent = PrimitiveVehicle_1.createVehicleMovementComponent();
+        super(options);
+        this.tailLightComponents = this.getComponents(ENGINE.MeshComponent)
+            .filter((component) => component.name.includes('_taillight'));
+    }
+    tickPrePhysics(deltaTime) {
+        super.tickPrePhysics(deltaTime);
+        this.updateBrakeLights();
+    }
+    updateBrakeLights() {
+        if (!this.movementComponent || this.tailLightComponents.length === 0)
+            return;
+        const inputState = this.movementComponent.getInputState();
+        const isBraking = inputState.brakeInput > 0;
+        for (const tailLightComponent of this.tailLightComponents) {
+            const mesh = tailLightComponent.getMesh();
+            if (mesh && mesh.material) {
+                const material = mesh.material;
+                if (isBraking) {
+                    material.color.setHex(0xFF0000);
+                }
+                else {
+                    material.color.setHex(0xFFFFFF);
+                }
+            }
+        }
+    }
+    static createDecorativeMeshes(rootComponent) {
+        // Add windshield
+        const windshieldComponent = new ENGINE.MeshComponent({
+            geometry: new THREE.BoxGeometry(1.8, 1.8, 0.1),
+            material: new THREE.MeshStandardMaterial({
+                color: 0x87CEEB,
+                transparent: true,
+                opacity: 0.5,
+                roughness: 0.1,
+                metalness: 0.1,
+            }),
+            physicsOptions: {
+                enabled: false,
+            }
+        });
+        windshieldComponent.position.set(0, 0.4, -1.5);
+        windshieldComponent.rotation.x = Math.PI / 8; // Slight tilt
+        windshieldComponent.name = 'windshield';
+        rootComponent.add(windshieldComponent);
+        // Add left headlight
+        const leftHeadlightComponent = new ENGINE.MeshComponent({
+            geometry: new THREE.CylinderGeometry(0.15, 0.15, 0.1, 8),
+            material: new THREE.MeshStandardMaterial({
+                color: 0xFFFFFF,
+                emissive: 0xFFFFAA,
+                emissiveIntensity: 0.3,
+            }),
+            physicsOptions: {
+                enabled: false,
+            }
+        });
+        leftHeadlightComponent.position.set(-0.7, 0.1, -2.05);
+        leftHeadlightComponent.rotation.z = Math.PI / 2;
+        leftHeadlightComponent.name = 'left_headlight';
+        rootComponent.add(leftHeadlightComponent);
+        // Add right headlight
+        const rightHeadlightComponent = new ENGINE.MeshComponent({
+            geometry: new THREE.CylinderGeometry(0.15, 0.15, 0.1, 8),
+            material: new THREE.MeshStandardMaterial({
+                color: 0xFFFFFF,
+                emissive: 0xFFFFAA,
+                emissiveIntensity: 0.3,
+            }),
+            physicsOptions: {
+                enabled: false,
+            }
+        });
+        rightHeadlightComponent.position.set(0.7, 0.1, -2.05);
+        rightHeadlightComponent.rotation.z = Math.PI / 2;
+        rightHeadlightComponent.name = 'right_headlight';
+        rootComponent.add(rightHeadlightComponent);
+        // Add left tail light
+        const leftTaillightMaterial = new THREE.MeshStandardMaterial({
+            color: 0xFF0000,
+            emissive: 0x440000,
+            emissiveIntensity: 0.2,
+        });
+        const leftTaillightComponent = new ENGINE.MeshComponent({
+            geometry: new THREE.CylinderGeometry(0.1, 0.1, 0.1, 8),
+            material: leftTaillightMaterial,
+            physicsOptions: {
+                enabled: false,
+            }
+        });
+        leftTaillightComponent.position.set(-0.7, 0.1, 2.05);
+        leftTaillightComponent.rotation.z = Math.PI / 2;
+        leftTaillightComponent.name = 'left_taillight';
+        rootComponent.add(leftTaillightComponent);
+        // Add right tail light
+        const rightTaillightMaterial = new THREE.MeshStandardMaterial({
+            color: 0xFF0000,
+            emissive: 0x440000,
+            emissiveIntensity: 0.2,
+        });
+        const rightTaillightComponent = new ENGINE.MeshComponent({
+            geometry: new THREE.CylinderGeometry(0.1, 0.1, 0.1, 8),
+            material: rightTaillightMaterial,
+            physicsOptions: {
+                enabled: false,
+            }
+        });
+        rightTaillightComponent.position.set(0.7, 0.1, 2.05);
+        rightTaillightComponent.rotation.z = Math.PI / 2;
+        rightTaillightComponent.name = 'right_taillight';
+        rootComponent.add(rightTaillightComponent);
+    }
+    static createVehicleMovementComponent() {
+        const wheelBaseWidth = 2.6;
+        const wheelBaseLength = 3.0;
+        const wheelBaseHeight = 0;
+        const suspensionRestLength = 0.6;
+        const wheelRadius = 0.5;
+        const wheelWidth = 0.4;
+        const suspensionStiffness = 20;
+        const suspensionCompression = 0.83;
+        const suspensionRelaxation = 0.88;
+        const maxSuspensionForce = 6000.0;
+        const maxSuspensionTravel = 5.0;
+        const sideFrictionStiffness = 2;
+        const frictionSlip = 8;
+        const options = {
+            ...ENGINE.BasePawnMovementComponent.DEFAULT_OPTIONS,
+            maxEnginePower: 35,
+            maxSteeringAngle: Math.PI / 6, // 30 degrees
+            maxBrakeForce: 1,
+            engineResponseRate: 8.0,
+            steeringResponseRate: 12.0,
+            brakeResponseRate: 15.0,
+            createWheelMeshes: true,
+            wheelMaterialColor: 0x333333,
+            autoBreakWhenNotPossessed: 1,
+            autoStopBreak: 0.5,
+            wheels: [
+                // Default 4-wheel configuration
+                {
+                    position: new THREE.Vector3(-wheelBaseWidth / 2, wheelBaseHeight, -wheelBaseLength / 2), // Front left
+                    radius: wheelRadius,
+                    width: wheelWidth,
+                    canSteer: true,
+                    isPowered: false,
+                    canBrake: true,
+                    suspensionRestLength,
+                    suspensionStiffness,
+                    suspensionCompression,
+                    suspensionRelaxation,
+                    maxSuspensionForce,
+                    maxSuspensionTravel,
+                    sideFrictionStiffness,
+                    frictionSlip,
+                },
+                {
+                    position: new THREE.Vector3(wheelBaseWidth / 2, wheelBaseHeight, -wheelBaseLength / 2), // Front right
+                    radius: wheelRadius,
+                    width: wheelWidth,
+                    canSteer: true,
+                    isPowered: false,
+                    canBrake: true,
+                    suspensionRestLength,
+                    suspensionStiffness,
+                    suspensionCompression,
+                    suspensionRelaxation,
+                    maxSuspensionForce,
+                    maxSuspensionTravel,
+                    sideFrictionStiffness,
+                    frictionSlip,
+                },
+                {
+                    position: new THREE.Vector3(-wheelBaseWidth / 2, wheelBaseHeight, wheelBaseLength / 2), // Rear left
+                    radius: wheelRadius,
+                    width: wheelWidth,
+                    canSteer: false,
+                    isPowered: true,
+                    canBrake: true,
+                    suspensionRestLength,
+                    suspensionStiffness,
+                    suspensionCompression,
+                    suspensionRelaxation,
+                    maxSuspensionForce,
+                    maxSuspensionTravel,
+                    sideFrictionStiffness,
+                    frictionSlip,
+                },
+                {
+                    position: new THREE.Vector3(wheelBaseWidth / 2, wheelBaseHeight, wheelBaseLength / 2), // Rear right
+                    radius: wheelRadius,
+                    width: wheelWidth,
+                    canSteer: false,
+                    isPowered: true,
+                    canBrake: true,
+                    suspensionRestLength,
+                    suspensionStiffness,
+                    suspensionCompression,
+                    suspensionRelaxation,
+                    maxSuspensionForce,
+                    maxSuspensionTravel,
+                    sideFrictionStiffness,
+                    frictionSlip,
+                },
+            ],
+        };
+        return new ENGINE.VehicleMovementComponent(options);
+    }
+};
+PrimitiveVehicle = PrimitiveVehicle_1 = __decorate([
+    ENGINE.GameClass()
+], PrimitiveVehicle);
+export { PrimitiveVehicle };

package/dist/src/templates/src/templates/vehicle/src/ui-hints.js

@@ -0,0 +1,100 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import * as ENGINE from 'genesys.js';
+/**
+ * Dismissable UI component that displays control hints when the game starts
+ */
+let UIHints = class UIHints extends ENGINE.Actor {
+    uiElement = null;
+    constructor(options = {}) {
+        super(options);
+        this.setTransient(true); // Don't save this UI element to the level
+    }
+    async doBeginPlay() {
+        await super.doBeginPlay();
+        this.createHUD();
+    }
+    doEndPlay() {
+        this.removeHUD();
+        super.doEndPlay();
+    }
+    createHUD() {
+        const uiManager = this.world.uiManager;
+        // Create the UI element using the engine's UI system
+        this.uiElement = uiManager.createElement('game-hints', {
+            style: {
+                position: 'absolute',
+                top: '50px',
+                right: '50px',
+                background: 'rgba(0, 0, 0, 0.9)',
+                color: 'white',
+                padding: '25px',
+                borderRadius: '12px',
+                fontFamily: 'Arial, sans-serif',
+                fontSize: '16px',
+                lineHeight: '1.5',
+                maxWidth: '400px',
+                border: '2px solid rgba(76, 175, 80, 0.6)',
+                boxShadow: '0 8px 32px rgba(0, 0, 0, 0.8)',
+                zIndex: '1001'
+            }
+        });
+        // Set the HTML content
+        this.uiElement.setHTML(`
+      <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 15px;">
+        <div style="font-weight: bold; color: #4CAF50; font-size: 18px;">
+          🎮 Vehicle Game Controls
+        </div>
+        <button id="closeHints" style="
+          background: #f44336;
+          color: white;
+          border: none;
+          border-radius: 50%;
+          width: 30px;
+          height: 30px;
+          cursor: pointer;
+          font-size: 16px;
+          font-weight: bold;
+        ">×</button>
+      </div>
+      <div style="margin-bottom: 12px;">
+        <span style="color: #FFA726; font-weight: bold;">Movement:</span>
+        <br>• WASD or Arrow Keys - Move/Drive
+        <br>• Mouse - Camera control
+      </div>
+      <div style="margin-bottom: 12px;">
+        <span style="color: #FFA726; font-weight: bold;">Vehicle Interaction:</span>
+        <br>• E - Enter/Exit vehicle (when nearby)
+        <br>• F - Flip vehicle (when inside)
+      </div>
+      <div style="font-size: 14px; color: #CCCCCC; margin-top: 15px; text-align: center; font-style: italic;">
+        💡 Walk near a vehicle and press E to enter
+      </div>
+    `);
+        // Add close button functionality
+        const closeButton = this.uiElement.querySelector('#closeHints');
+        if (closeButton) {
+            closeButton.addEventListener('click', () => {
+                this.removeHUD();
+            });
+        }
+        // Auto-close after 10 seconds
+        setTimeout(() => {
+            this.removeHUD();
+        }, 10000);
+    }
+    removeHUD() {
+        if (this.uiElement) {
+            this.uiElement.remove();
+            this.uiElement = null;
+        }
+    }
+};
+UIHints = __decorate([
+    ENGINE.GameClass()
+], UIHints);
+export { UIHints };

package/dist/src/templates/src/templates/vr-game/src/auto-imports.js

@@ -0,0 +1 @@
+import './sample-vr-actor.ts';

package/dist/src/templates/src/templates/vr-game/src/game.js

@@ -0,0 +1,55 @@
+import * as ENGINE from 'genesys.js';
+import * as THREE from 'three';
+import './auto-imports.js';
+class MyGame extends ENGINE.BaseGameLoop {
+    pawn = null;
+    controller = null;
+    createLoadingScreen() {
+        // enable the default loading screen
+        return new ENGINE.DefaultLoadingScreen();
+    }
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...ENGINE.BaseGameLoop.DEFAULT_OPTIONS,
+            xrEnabled: true,
+            vrSessionOptions: {
+                optionalFeatures: ['hand-tracking', 'local-floor'],
+                requiredFeatures: []
+            }
+        };
+    }
+    async preStart() {
+        // Disable tone mapping for VR because it breaks VR
+        this.world.postProcessManager.disablePasses(ENGINE.PostProcessPass.ToneMapping);
+        // create the vr pawn
+        this.pawn = new ENGINE.VRPawn({
+            position: new THREE.Vector3(0, 0, 0),
+            movementComponent: null,
+            camera: new THREE.PerspectiveCamera(ENGINE.CAMERA_FOV, 1, ENGINE.CAMERA_NEAR, ENGINE.CAMERA_FAR),
+            controllerOptions: {
+                rayVisualizationEnabled: true,
+                maxRayDistance: 10
+            },
+            enableTeleportation: true,
+            enableSnapTurn: true,
+            snapTurnAngle: 30,
+            maxTeleportDistance: 15
+        });
+        // create the controller and possess the pawn
+        this.controller = new ENGINE.PlayerController();
+        this.controller.possess(this.pawn);
+        this.pawn.addComponent(new ENGINE.VRGrabComponent({}));
+        this.pawn.addComponent(new ENGINE.VRSnapTurnComponent({ angleDeg: this.pawn.getSnapTurnAngleDegrees() }));
+        this.pawn.addComponent(new ENGINE.VRInteractComponent({ button: ENGINE.XRButton.Trigger }));
+        this.pawn.addComponent(new ENGINE.VRTeleportComponent({ maxDistance: 15 }));
+        // add both to the world
+        this.world.addActors(this.pawn, this.controller);
+    }
+}
+export function main(container, gameId) {
+    const game = new MyGame(container, {
+        ...MyGame.DEFAULT_OPTIONS,
+        gameId
+    });
+    return game;
+}

package/dist/src/templates/src/templates/vr-game/src/sample-vr-actor.js

@@ -0,0 +1,29 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import * as ENGINE from 'genesys.js';
+/**
+ * Sample VR Actor - A simple actor that can be picked up and manipulated in VR
+ */
+let SampleVRActor = class SampleVRActor extends ENGINE.Actor {
+    meshComponent = null;
+    grabbable = null;
+    doBeginPlay() {
+        super.doBeginPlay();
+        this.meshComponent = this.getComponent(ENGINE.MeshComponent);
+        this.grabbable = this.getComponent(ENGINE.VRGrabbableComponent);
+        this.grabbable?.onGrabStart.add((_hand) => {
+            this.meshComponent?.setPhysicsEnabled(false);
+        });
+        this.grabbable?.onGrabEnd.add((_hand, _dropVelocity) => {
+            this.meshComponent?.setPhysicsEnabled(true);
+        });
+    }
+};
+SampleVRActor = __decorate([
+    ENGINE.GameClass()
+], SampleVRActor);
+export { SampleVRActor };

package/dist/src/templates/vite.config.js

@@ -0,0 +1,46 @@
+import { defineConfig } from 'vite';
+import mkcert from 'vite-plugin-mkcert';
+import { nodePolyfills } from 'vite-plugin-node-polyfills';
+export default defineConfig({
+    // Enable TypeScript support
+    esbuild: {
+        target: 'es2021',
+    },
+    plugins: [
+        nodePolyfills({
+            include: ['path'],
+        }),
+        mkcert(),
+    ],
+    // Configure module resolution
+    resolve: {
+        extensions: ['.ts', '.tsx', '.js', '.jsx', '.json'],
+    },
+    // Configure the dev server
+    server: {
+        port: 3000,
+        host: '0.0.0.0',
+        open: true,
+        // Enable CORS for asset loading
+        cors: true,
+        // Serve source maps for debugging
+        fs: {
+            allow: ['..', '.']
+        }
+    },
+    // Configure build options
+    build: {
+        target: 'es2021',
+        outDir: 'dist',
+        sourcemap: true,
+        rollupOptions: {
+            input: {
+                main: 'index.html',
+            },
+        },
+    },
+    // Enable source maps for debugging in development
+    css: {
+        devSourcemap: true,
+    },
+});

package/package.json

@@ -0,0 +1,176 @@
+{
+  "name": "@directivegames/genesys.sdk",
+  "version": "3.2.2",
+  "description": "Genesys SDK - A development toolkit for game development",
+  "author": "Directive Games",
+  "main": "index.js",
+  "type": "module",
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "electron"
+    ]
+  },
+  "files": [
+    "dist/src",
+    "src/templates",
+    "src/asset-pack",
+    "scripts"
+  ],
+  "bin": {
+    "genesys-sdk": "./dist/src/core/cli.js"
+  },
+  "scripts": {
+    "postinstall": "pnpm exec tsx scripts/post-install.ts",
+    "dev:main": "tsc --watch -p tsconfig.json",
+    "dev:preload": "tsc --watch -p tsconfig.preload.json",
+    "dev:electron": "electron dist/src/electron/backend/main.js",
+    "dev:watch": "pnpm compile && concurrently -k -n MAIN,PRELOAD \"pnpm dev:main\" \"pnpm dev:preload\" nodemon",
+    "dev": "pnpm compile && concurrently -k -n MAIN,PRELOAD \"pnpm dev:main\" \"pnpm dev:preload\" \"pnpm dev:electron\"",
+    "dev:hosted": "pnpm compile && concurrently -k -n MAIN,PRELOAD \"pnpm dev:main\" \"pnpm dev:preload\" \"dotenv -v DEV_HOSTED=true pnpm dev:electron\"",
+    "dev:vite-old": "vite",
+    "dev-old": "pnpm compile && concurrently -k -n MAIN,PRELOAD,VITE \"pnpm dev:main\" \"pnpm dev:preload\" \"pnpm dev:vite-old\" \"pnpm dev:electron-old\"",
+    "compile": "tsc -p tsconfig.json && tsc -p tsconfig.preload.json",
+    "build": "vite build && pnpm compile",
+    "dist": "pnpm build && electron-builder",
+    "lint": "eslint . --fix --ext .ts,.tsx",
+    "pack": "pnpm build && pnpm pack",
+    "cli": "pnpm exec tsx src/core/cli.ts",
+    "cli:new": "pnpm exec tsx src/core/cli.ts new",
+    "cli:build": "pnpm exec tsx src/core/cli.ts build",
+    "cli:new-asset-pack": "pnpm exec tsx src/core/cli.ts new-asset-pack"
+  },
+  "build": {
+    "artifactName": "Genesys-Setup-${version}.${ext}",
+    "publish": [
+      {
+        "provider": "github",
+        "releaseType": "release",
+        "owner": "directivegames",
+        "repo": "genesys.sdk-release",
+        "private": true
+      }
+    ],
+    "asar": true,
+    "asarUnpack": [
+      "node_modules/@esbuild/**/*",
+      "node_modules/esbuild/**/*"
+    ],
+    "appId": "com.directivegames.genesys.sdk",
+    "productName": "Genesys",
+    "files": [
+      "dist/**/*",
+      {
+        "from": "node_modules/.pnpm/three@0.177.0/node_modules/three/examples",
+        "to": "node_modules/three/examples"
+      }
+    ],
+    "extraResources": [
+      {
+        "from": "src/templates",
+        "to": "vendor/src/templates"
+      },
+      {
+        "from": "src/asset-pack",
+        "to": "vendor/src/asset-pack"
+      }
+    ],
+    "directories": {
+      "buildResources": "build"
+    },
+    "extraMetadata": {
+      "main": "dist/src/electron/backend/main.js"
+    },
+    "protocols": [
+      {
+        "name": "genesys",
+        "schemes": [
+          "genesys"
+        ]
+      },
+      {
+        "name": "genesys-dev",
+        "schemes": [
+          "genesys-dev"
+        ]
+      }
+    ],
+    "win": {
+      "target": "nsis"
+    },
+    "mac": {
+      "target": "dmg",
+      "hardenedRuntime": true,
+      "gatekeeperAssess": false,
+      "entitlements": "build/entitlements.mac.plist",
+      "entitlementsInherit": "build/entitlements.mac.plist"
+    }
+  },
+  "dependencies": {
+    "@electron/rebuild": "^4.0.1",
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.0",
+    "@mui/icons-material": "^7.1.0",
+    "@mui/lab": "^7.0.0-beta.12",
+    "@mui/material": "^7.1.0",
+    "chokidar": "^4.0.3",
+    "commander": "^14.0.2",
+    "core-util-is": "^1.0.3",
+    "cors": "^2.8.5",
+    "electron-devtools-installer": "^4.0.0",
+    "electron-is-dev": "^3.0.1",
+    "electron-log": "^5.4.3",
+    "electron-store": "^11.0.2",
+    "electron-updater": "^6.6.2",
+    "esbuild": "^0.25.11",
+    "express": "^5.1.0",
+    "fix-path": "^4.0.0",
+    "genesys.js": "^3.1.24",
+    "jsdom": "^27.0.0",
+    "minimatch": "^10.0.1",
+    "multer": "^2.0.2",
+    "node-abi": "^4.14.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "three": "^0.177.0",
+    "upath": "^2.0.1",
+    "ws": "^8.18.2",
+    "zod": "^3.24.4"
+  },
+  "devDependencies": {
+    "@electron/notarize": "^3.1.0",
+    "@modelcontextprotocol/sdk": "^1.22.0",
+    "@types/cors": "^2.8.18",
+    "@types/electron-store": "^1.3.1",
+    "@types/express": "^5.0.2",
+    "@types/jsdom": "^27.0.0",
+    "@types/minimatch": "^5.1.2",
+    "@types/multer": "^1.4.12",
+    "@types/react": "^19.2.0",
+    "@types/react-dom": "^19.2.0",
+    "@types/three": "^0.177.0",
+    "@types/ws": "^8.18.1",
+    "@typescript-eslint/eslint-plugin": "^8.29.1",
+    "@typescript-eslint/parser": "^8.29.1",
+    "@vitejs/plugin-react": "^4.4.1",
+    "ajv": "^8.17.1",
+    "concurrently": "^9.1.2",
+    "dotenv-cli": "^8.0.0",
+    "electron": "^39.2.3",
+    "electron-builder": "^26.0.12",
+    "eslint": "^9.24.0",
+    "eslint-plugin-import": "^2.31.0",
+    "get-port": "^7.1.0",
+    "nanoid": "^5.1.6",
+    "nodemon": "^3.1.10",
+    "ts-morph": "^27.0.2",
+    "tsc-watch": "^7.1.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.8.3",
+    "vite": "^6.3.5",
+    "vite-plugin-mkcert": "^1.17.9",
+    "vite-plugin-node-polyfills": "^0.24.0",
+    "wait-on": "^8.0.4",
+    "yaml": "^2.6.1",
+    "zod-to-json-schema": "^3.25.0"
+  }
+}