diff --git a/Cargo.lock b/Cargo.lock
index 43157abf..9d36d317 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -648,7 +648,7 @@ dependencies = [
 [[package]]
 name = "bevy_mod_js_scripting"
 version = "0.1.0"
-source = "git+https://github.com/zicklag/bevy_mod_js_scripting.git?branch=punchy#7fe242ce4876e2a6f7e67e861d2fda15c7720e2b"
+source = "git+https://github.com/zicklag/bevy_mod_js_scripting.git?branch=punchy#279a9a1ab6506f5a0311a06ae9db1df80b8487eb"
 dependencies = [
  "anyhow",
  "bevy",
diff --git a/assets/items/health/health.ts b/assets/items/health/health.ts
index 684a057b..1b830a53 100644
--- a/assets/items/health/health.ts
+++ b/assets/items/health/health.ts
@@ -12,10 +12,11 @@ export default {
   postUpdate() {
     const grabEvents = punchy.getItemGrabEvents();
 
+    const fighterQuery = world.query(Health, Stats);
     for (const event of grabEvents) {
       const fighter = event.fighter;
 
-      const [health, stats] = world.get(fighter, Health, Stats);
+      const [health, stats] = fighterQuery.get(fighter);
 
       health[0] = stats.max_health;
     }
diff --git a/lib.bevy.d.ts b/lib.bevy.d.ts
index 8fac6f90..5987fdad 100644
--- a/lib.bevy.d.ts
+++ b/lib.bevy.d.ts
@@ -23,10 +23,6 @@ declare interface BevyScript {
 declare class ComponentId {
   index: number;
 }
-declare class Entity {
-  id: number;
-  generation: number;
-}
 
 type ComponentInfo = {
   id: ComponentId;
@@ -47,18 +43,23 @@ type BevyType<T> = {
   typeName: string;
 };
 
-
-type ExtractBevyType<T> = T extends BevyType<infer U> ? U
-  : T extends ComponentId ? Value
+type ExtractBevyType<T> = T extends BevyType<infer U>
+  ? U
+  : T extends ComponentId
+  ? Value
   : never;
 type MapQueryArgs<Q> = { [C in keyof Q]: ExtractBevyType<Q[C]> };
 
 type QueryParameter = BevyType<unknown> | ComponentId;
 type QueryItem<Q> = {
   entity: Entity;
-  components: MapQueryArgs<Q>,
+  components: MapQueryArgs<Q>;
 };
 
+declare class QueryItems<Q> extends Array<QueryItem<Q>> {
+  get(entity: Entity): MapQueryArgs<Q> | undefined;
+}
+
 declare class World {
   get components(): ComponentInfo[];
   get resources(): ComponentInfo[];
@@ -67,8 +68,11 @@ declare class World {
   resource(componentId: ComponentId): Value | null;
   resource<T>(type: BevyType<T>): T | null;
 
-  query<Q extends QueryParameter[]>(...query: Q): QueryItem<Q>[];
-  get<Q extends QueryParameter[]>(entity: Entity, ...components: Q): MapQueryArgs<Q>;
+  query<Q extends QueryParameter[]>(...query: Q): QueryItems<Q>;
+  get<Q extends QueryParameter[]>(
+    entity: Entity,
+    ...components: Q
+  ): MapQueryArgs<Q>;
 }
 
 declare let world: World;
diff --git a/lib.bevy.types.ts b/lib.bevy.types.ts
index d720706d..3989b3c2 100644
--- a/lib.bevy.types.ts
+++ b/lib.bevy.types.ts
@@ -1,4 +1,5 @@
 // generated with https://github.com/jakobhellermann/bevy_reflect_ts_type_export
+// bevy_core
 type bool = boolean;
 type f32 = number;
 type f64 = number;
@@ -13,572 +14,600 @@ type u32 = number;
 type u64 = number;
 type usize = number;
 type Cowstr = String;
-type Vec3A = Vec3;
-type AnimationPlayer = {
-    paused: bool,
-    repeat: bool,
-    speed: f32,
-    elapsed: f32,
-    animation_clip: HandleAnimationClip,
+
+type Name = {
+  hash: number,
+  name: string,
 };
-const AnimationPlayer: BevyType<AnimationPlayer> = { typeName: "bevy_animation::AnimationPlayer" };
 
-type HandleAnimationClip = {
-    id: HandleId,
+const Name: BevyType<Name> = { typeName: "bevy_core::name::Name" };
+// core
+type Rangef32 = unknown;
+type Duration = unknown;
+
+const Rangef32: BevyType<Rangef32> = { typeName: "core::ops::range::Range<f32>" };
+const Duration: BevyType<Duration> = { typeName: "core::time::Duration" };
+// hashbrown
+type HashSetString = unknown;
+
+const HashSetString: BevyType<HashSetString> = { typeName: "hashbrown::set::HashSet<alloc::string::String>" };
+// bevy_math
+type Rect = {
+  min: Vec2,
+  max: Vec2,
 };
-const HandleAnimationClip: BevyType<HandleAnimationClip> = { typeName: "bevy_asset::handle::Handle<bevy_animation::AnimationClip>" };
 
-type HandleAudioSink = {
-    id: HandleId,
+const Rect: BevyType<Rect> = { typeName: "bevy_math::rect::Rect" };
+// std
+type Instant = unknown;
+
+const Instant: BevyType<Instant> = { typeName: "std::time::Instant" };
+// bevy_ecs
+type Entity = unknown;
+
+const Entity: BevyType<Entity> = { typeName: "bevy_ecs::entity::Entity" };
+// bevy_time
+type Stopwatch = {
+  elapsed: Duration,
+  paused: boolean,
+};
+type Time = {
+  delta: Duration,
+  last_update: Instant | null,
+  delta_seconds_f64: number,
+  delta_seconds: number,
+  seconds_since_startup: number,
+  time_since_startup: Duration,
+  startup: Instant,
+};
+type Timer = {
+  stopwatch: Stopwatch,
+  duration: Duration,
+  repeating: boolean,
+  finished: boolean,
+  times_finished_this_tick: number,
 };
-const HandleAudioSink: BevyType<HandleAudioSink> = { typeName: "bevy_asset::handle::Handle<bevy_audio::audio_output::AudioSink>" };
 
+const Stopwatch: BevyType<Stopwatch> = { typeName: "bevy_time::stopwatch::Stopwatch" };
+const Time: BevyType<Time> = { typeName: "bevy_time::time::Time" };
+const Timer: BevyType<Timer> = { typeName: "bevy_time::timer::Timer" };
+// bevy_asset
+type HandleAnimationClip = {
+  id: HandleId,
+};
+type HandleAudioSink = {
+  id: HandleId,
+};
 type HandleAudioSource = {
-    id: HandleId,
+  id: HandleId,
 };
-const HandleAudioSource: BevyType<HandleAudioSource> = { typeName: "bevy_asset::handle::Handle<bevy_audio::audio_source::AudioSource>" };
-
 type HandleGltf = {
-    id: HandleId,
+  id: HandleId,
 };
-const HandleGltf: BevyType<HandleGltf> = { typeName: "bevy_asset::handle::Handle<bevy_gltf::Gltf>" };
-
 type HandleGltfMesh = {
-    id: HandleId,
+  id: HandleId,
 };
-const HandleGltfMesh: BevyType<HandleGltfMesh> = { typeName: "bevy_asset::handle::Handle<bevy_gltf::GltfMesh>" };
-
 type HandleGltfNode = {
-    id: HandleId,
+  id: HandleId,
 };
-const HandleGltfNode: BevyType<HandleGltfNode> = { typeName: "bevy_asset::handle::Handle<bevy_gltf::GltfNode>" };
-
 type HandleGltfPrimitive = {
-    id: HandleId,
+  id: HandleId,
 };
-const HandleGltfPrimitive: BevyType<HandleGltfPrimitive> = { typeName: "bevy_asset::handle::Handle<bevy_gltf::GltfPrimitive>" };
-
 type HandleStandardMaterial = {
-    id: HandleId,
+  id: HandleId,
 };
-const HandleStandardMaterial: BevyType<HandleStandardMaterial> = { typeName: "bevy_asset::handle::Handle<bevy_pbr::pbr_material::StandardMaterial>" };
-
 type HandleMesh = {
-    id: HandleId,
+  id: HandleId,
 };
-const HandleMesh: BevyType<HandleMesh> = { typeName: "bevy_asset::handle::Handle<bevy_render::mesh::mesh::Mesh>" };
-
 type HandleSkinnedMeshInverseBindposes = {
-    id: HandleId,
+  id: HandleId,
 };
-const HandleSkinnedMeshInverseBindposes: BevyType<HandleSkinnedMeshInverseBindposes> = { typeName: "bevy_asset::handle::Handle<bevy_render::mesh::mesh::skinning::SkinnedMeshInverseBindposes>" };
-
 type HandleShader = {
-    id: HandleId,
+  id: HandleId,
 };
-const HandleShader: BevyType<HandleShader> = { typeName: "bevy_asset::handle::Handle<bevy_render::render_resource::shader::Shader>" };
-
 type HandleImage = {
-    id: HandleId,
+  id: HandleId,
 };
-const HandleImage: BevyType<HandleImage> = { typeName: "bevy_asset::handle::Handle<bevy_render::texture::image::Image>" };
-
 type HandleDynamicScene = {
-    id: HandleId,
+  id: HandleId,
 };
-const HandleDynamicScene: BevyType<HandleDynamicScene> = { typeName: "bevy_asset::handle::Handle<bevy_scene::dynamic_scene::DynamicScene>" };
-
 type HandleScene = {
-    id: HandleId,
+  id: HandleId,
 };
-const HandleScene: BevyType<HandleScene> = { typeName: "bevy_asset::handle::Handle<bevy_scene::scene::Scene>" };
-
 type HandleColorMaterial = {
-    id: HandleId,
+  id: HandleId,
 };
-const HandleColorMaterial: BevyType<HandleColorMaterial> = { typeName: "bevy_asset::handle::Handle<bevy_sprite::mesh2d::color_material::ColorMaterial>" };
-
 type HandleTextureAtlas = {
-    id: HandleId,
+  id: HandleId,
 };
-const HandleTextureAtlas: BevyType<HandleTextureAtlas> = { typeName: "bevy_asset::handle::Handle<bevy_sprite::texture_atlas::TextureAtlas>" };
-
 type HandleFont = {
-    id: HandleId,
+  id: HandleId,
 };
-const HandleFont: BevyType<HandleFont> = { typeName: "bevy_asset::handle::Handle<bevy_text::font::Font>" };
-
 type HandleFontAtlasSet = {
-    id: HandleId,
+  id: HandleId,
 };
-const HandleFontAtlasSet: BevyType<HandleFontAtlasSet> = { typeName: "bevy_asset::handle::Handle<bevy_text::font_atlas_set::FontAtlasSet>" };
-
 type HandleId = unknown;
-const HandleId: BevyType<HandleId> = { typeName: "bevy_asset::handle::HandleId" };
 
-type Name = {
-    hash: u64,
-    name: Cowstr,
+const HandleAnimationClip: BevyType<HandleAnimationClip> = { typeName: "bevy_asset::handle::Handle<bevy_animation::AnimationClip>" };
+const HandleAudioSink: BevyType<HandleAudioSink> = { typeName: "bevy_asset::handle::Handle<bevy_audio::audio_output::AudioSink>" };
+const HandleAudioSource: BevyType<HandleAudioSource> = { typeName: "bevy_asset::handle::Handle<bevy_audio::audio_source::AudioSource>" };
+const HandleGltf: BevyType<HandleGltf> = { typeName: "bevy_asset::handle::Handle<bevy_gltf::Gltf>" };
+const HandleGltfMesh: BevyType<HandleGltfMesh> = { typeName: "bevy_asset::handle::Handle<bevy_gltf::GltfMesh>" };
+const HandleGltfNode: BevyType<HandleGltfNode> = { typeName: "bevy_asset::handle::Handle<bevy_gltf::GltfNode>" };
+const HandleGltfPrimitive: BevyType<HandleGltfPrimitive> = { typeName: "bevy_asset::handle::Handle<bevy_gltf::GltfPrimitive>" };
+const HandleStandardMaterial: BevyType<HandleStandardMaterial> = { typeName: "bevy_asset::handle::Handle<bevy_pbr::pbr_material::StandardMaterial>" };
+const HandleMesh: BevyType<HandleMesh> = { typeName: "bevy_asset::handle::Handle<bevy_render::mesh::mesh::Mesh>" };
+const HandleSkinnedMeshInverseBindposes: BevyType<HandleSkinnedMeshInverseBindposes> = { typeName: "bevy_asset::handle::Handle<bevy_render::mesh::mesh::skinning::SkinnedMeshInverseBindposes>" };
+const HandleShader: BevyType<HandleShader> = { typeName: "bevy_asset::handle::Handle<bevy_render::render_resource::shader::Shader>" };
+const HandleImage: BevyType<HandleImage> = { typeName: "bevy_asset::handle::Handle<bevy_render::texture::image::Image>" };
+const HandleDynamicScene: BevyType<HandleDynamicScene> = { typeName: "bevy_asset::handle::Handle<bevy_scene::dynamic_scene::DynamicScene>" };
+const HandleScene: BevyType<HandleScene> = { typeName: "bevy_asset::handle::Handle<bevy_scene::scene::Scene>" };
+const HandleColorMaterial: BevyType<HandleColorMaterial> = { typeName: "bevy_asset::handle::Handle<bevy_sprite::mesh2d::color_material::ColorMaterial>" };
+const HandleTextureAtlas: BevyType<HandleTextureAtlas> = { typeName: "bevy_asset::handle::Handle<bevy_sprite::texture_atlas::TextureAtlas>" };
+const HandleFont: BevyType<HandleFont> = { typeName: "bevy_asset::handle::Handle<bevy_text::font::Font>" };
+const HandleFontAtlasSet: BevyType<HandleFontAtlasSet> = { typeName: "bevy_asset::handle::Handle<bevy_text::font_atlas_set::FontAtlasSet>" };
+const HandleId: BevyType<HandleId> = { typeName: "bevy_asset::handle::HandleId" };
+// bevy_gltf
+type GltfExtras = {
+  value: string,
 };
-const Name: BevyType<Name> = { typeName: "bevy_core::name::Name" };
 
+const GltfExtras: BevyType<GltfExtras> = { typeName: "bevy_gltf::GltfExtras" };
+// bevy_core_pipeline
 type ClearColor = unknown;
-const ClearColor: BevyType<ClearColor> = { typeName: "bevy_core_pipeline::clear_color::ClearColor" };
-
 type ClearColorConfig = unknown;
-const ClearColorConfig: BevyType<ClearColorConfig> = { typeName: "bevy_core_pipeline::clear_color::ClearColorConfig" };
-
 type Camera2d = {
-    clear_color: ClearColorConfig,
+  clear_color: ClearColorConfig,
 };
-const Camera2d: BevyType<Camera2d> = { typeName: "bevy_core_pipeline::core_2d::camera_2d::Camera2d" };
-
 type Camera3d = {
-    clear_color: ClearColorConfig,
-    depth_load_op: Camera3dDepthLoadOp,
+  clear_color: ClearColorConfig,
+  depth_load_op: Camera3dDepthLoadOp,
 };
-const Camera3d: BevyType<Camera3d> = { typeName: "bevy_core_pipeline::core_3d::camera_3d::Camera3d" };
-
 type Camera3dDepthLoadOp = unknown;
-const Camera3dDepthLoadOp: BevyType<Camera3dDepthLoadOp> = { typeName: "bevy_core_pipeline::core_3d::camera_3d::Camera3dDepthLoadOp" };
-
-type GltfExtras = {
-    value: string,
-};
-const GltfExtras: BevyType<GltfExtras> = { typeName: "bevy_gltf::GltfExtras" };
-
-type Children = unknown;
-const Children: BevyType<Children> = { typeName: "bevy_hierarchy::components::children::Children" };
-
-type Parent = unknown;
-const Parent: BevyType<Parent> = { typeName: "bevy_hierarchy::components::parent::Parent" };
 
+const ClearColor: BevyType<ClearColor> = { typeName: "bevy_core_pipeline::clear_color::ClearColor" };
+const ClearColorConfig: BevyType<ClearColorConfig> = { typeName: "bevy_core_pipeline::clear_color::ClearColorConfig" };
+const Camera2d: BevyType<Camera2d> = { typeName: "bevy_core_pipeline::core_2d::camera_2d::Camera2d" };
+const Camera3d: BevyType<Camera3d> = { typeName: "bevy_core_pipeline::core_3d::camera_3d::Camera3d" };
+const Camera3dDepthLoadOp: BevyType<Camera3dDepthLoadOp> = { typeName: "bevy_core_pipeline::core_3d::camera_3d::Camera3dDepthLoadOp" };
+// bevy_pbr
 type CubemapVisibleEntities = {
 };
-const CubemapVisibleEntities: BevyType<CubemapVisibleEntities> = { typeName: "bevy_pbr::bundle::CubemapVisibleEntities" };
-
 type AmbientLight = {
-    color: Color,
-    brightness: f32,
+  color: Color,
+  brightness: number,
 };
-const AmbientLight: BevyType<AmbientLight> = { typeName: "bevy_pbr::light::AmbientLight" };
-
 type DirectionalLight = {
-    color: Color,
-    illuminance: f32,
-    shadows_enabled: bool,
-    shadow_projection: OrthographicProjection,
-    shadow_depth_bias: f32,
-    shadow_normal_bias: f32,
+  color: Color,
+  illuminance: number,
+  shadows_enabled: boolean,
+  shadow_projection: OrthographicProjection,
+  shadow_depth_bias: number,
+  shadow_normal_bias: number,
 };
-const DirectionalLight: BevyType<DirectionalLight> = { typeName: "bevy_pbr::light::DirectionalLight" };
-
 type DirectionalLightShadowMap = {
-    size: usize,
+  size: number,
 };
-const DirectionalLightShadowMap: BevyType<DirectionalLightShadowMap> = { typeName: "bevy_pbr::light::DirectionalLightShadowMap" };
-
 type PointLight = {
-    color: Color,
-    intensity: f32,
-    range: f32,
-    radius: f32,
-    shadows_enabled: bool,
-    shadow_depth_bias: f32,
-    shadow_normal_bias: f32,
+  color: Color,
+  intensity: number,
+  range: number,
+  radius: number,
+  shadows_enabled: boolean,
+  shadow_depth_bias: number,
+  shadow_normal_bias: number,
 };
-const PointLight: BevyType<PointLight> = { typeName: "bevy_pbr::light::PointLight" };
-
 type PointLightShadowMap = {
-    size: usize,
+  size: number,
 };
-const PointLightShadowMap: BevyType<PointLightShadowMap> = { typeName: "bevy_pbr::light::PointLightShadowMap" };
-
 type SpotLight = {
-    color: Color,
-    intensity: f32,
-    range: f32,
-    radius: f32,
-    shadows_enabled: bool,
-    shadow_depth_bias: f32,
-    shadow_normal_bias: f32,
-    outer_angle: f32,
-    inner_angle: f32,
+  color: Color,
+  intensity: number,
+  range: number,
+  radius: number,
+  shadows_enabled: boolean,
+  shadow_depth_bias: number,
+  shadow_normal_bias: number,
+  outer_angle: number,
+  inner_angle: number,
 };
-const SpotLight: BevyType<SpotLight> = { typeName: "bevy_pbr::light::SpotLight" };
 
+const CubemapVisibleEntities: BevyType<CubemapVisibleEntities> = { typeName: "bevy_pbr::bundle::CubemapVisibleEntities" };
+const AmbientLight: BevyType<AmbientLight> = { typeName: "bevy_pbr::light::AmbientLight" };
+const DirectionalLight: BevyType<DirectionalLight> = { typeName: "bevy_pbr::light::DirectionalLight" };
+const DirectionalLightShadowMap: BevyType<DirectionalLightShadowMap> = { typeName: "bevy_pbr::light::DirectionalLightShadowMap" };
+const PointLight: BevyType<PointLight> = { typeName: "bevy_pbr::light::PointLight" };
+const PointLightShadowMap: BevyType<PointLightShadowMap> = { typeName: "bevy_pbr::light::PointLightShadowMap" };
+const SpotLight: BevyType<SpotLight> = { typeName: "bevy_pbr::light::SpotLight" };
+// bevy_render
 type Camera = {
-    viewport: Viewport | null,
-    priority: isize,
-    is_active: bool,
-    depth_calculation: DepthCalculation,
+  viewport: Viewport | null,
+  priority: number,
+  is_active: boolean,
 };
-const Camera: BevyType<Camera> = { typeName: "bevy_render::camera::camera::Camera" };
-
 type CameraRenderGraph = unknown;
-const CameraRenderGraph: BevyType<CameraRenderGraph> = { typeName: "bevy_render::camera::camera::CameraRenderGraph" };
-
-type DepthCalculation = unknown;
-const DepthCalculation: BevyType<DepthCalculation> = { typeName: "bevy_render::camera::camera::DepthCalculation" };
-
-type Viewport = unknown;
-const Viewport: BevyType<Viewport> = { typeName: "bevy_render::camera::camera::Viewport" };
-
+type Viewport = {
+  physical_position: UVec2,
+  physical_size: UVec2,
+  depth: Rangef32,
+};
 type OrthographicProjection = {
-    left: f32,
-    right: f32,
-    bottom: f32,
-    top: f32,
-    near: f32,
-    far: f32,
-    window_origin: WindowOrigin,
-    scaling_mode: ScalingMode,
-    scale: f32,
-    depth_calculation: DepthCalculation,
+  left: number,
+  right: number,
+  bottom: number,
+  top: number,
+  near: number,
+  far: number,
+  window_origin: WindowOrigin,
+  scaling_mode: ScalingMode,
+  scale: number,
 };
-const OrthographicProjection: BevyType<OrthographicProjection> = { typeName: "bevy_render::camera::projection::OrthographicProjection" };
-
 type PerspectiveProjection = {
-    fov: f32,
-    aspect_ratio: f32,
-    near: f32,
-    far: f32,
+  fov: number,
+  aspect_ratio: number,
+  near: number,
+  far: number,
 };
-const PerspectiveProjection: BevyType<PerspectiveProjection> = { typeName: "bevy_render::camera::projection::PerspectiveProjection" };
-
 type Projection = unknown;
-const Projection: BevyType<Projection> = { typeName: "bevy_render::camera::projection::Projection" };
-
 type ScalingMode = unknown;
-const ScalingMode: BevyType<ScalingMode> = { typeName: "bevy_render::camera::projection::ScalingMode" };
-
 type WindowOrigin = unknown;
-const WindowOrigin: BevyType<WindowOrigin> = { typeName: "bevy_render::camera::projection::WindowOrigin" };
-
 type Color = unknown;
-const Color: BevyType<Color> = { typeName: "bevy_render::color::Color" };
-
 type SkinnedMesh = {
-    inverse_bindposes: HandleSkinnedMeshInverseBindposes,
-    joints: Entity[],
+  inverse_bindposes: HandleSkinnedMeshInverseBindposes,
+  joints: Entity[],
 };
-const SkinnedMesh: BevyType<SkinnedMesh> = { typeName: "bevy_render::mesh::mesh::skinning::SkinnedMesh" };
-
 type Aabb = {
-    center: Vec3A,
-    half_extents: Vec3A,
+  center: Vec3A,
+  half_extents: Vec3A,
 };
-const Aabb: BevyType<Aabb> = { typeName: "bevy_render::primitives::Aabb" };
-
 type CubemapFrusta = {
 };
-const CubemapFrusta: BevyType<CubemapFrusta> = { typeName: "bevy_render::primitives::CubemapFrusta" };
-
 type Frustum = {
 };
-const Frustum: BevyType<Frustum> = { typeName: "bevy_render::primitives::Frustum" };
-
 type Msaa = {
-    samples: u32,
+  samples: number,
 };
-const Msaa: BevyType<Msaa> = { typeName: "bevy_render::view::Msaa" };
-
 type ComputedVisibility = {
-    is_visible_in_hierarchy: bool,
-    is_visible_in_view: bool,
+  is_visible_in_hierarchy: boolean,
+  is_visible_in_view: boolean,
 };
-const ComputedVisibility: BevyType<ComputedVisibility> = { typeName: "bevy_render::view::visibility::ComputedVisibility" };
-
 type Visibility = {
-    is_visible: bool,
+  is_visible: boolean,
 };
-const Visibility: BevyType<Visibility> = { typeName: "bevy_render::view::visibility::Visibility" };
-
 type VisibleEntities = {
 };
-const VisibleEntities: BevyType<VisibleEntities> = { typeName: "bevy_render::view::visibility::VisibleEntities" };
 
+const Camera: BevyType<Camera> = { typeName: "bevy_render::camera::camera::Camera" };
+const CameraRenderGraph: BevyType<CameraRenderGraph> = { typeName: "bevy_render::camera::camera::CameraRenderGraph" };
+const Viewport: BevyType<Viewport> = { typeName: "bevy_render::camera::camera::Viewport" };
+const OrthographicProjection: BevyType<OrthographicProjection> = { typeName: "bevy_render::camera::projection::OrthographicProjection" };
+const PerspectiveProjection: BevyType<PerspectiveProjection> = { typeName: "bevy_render::camera::projection::PerspectiveProjection" };
+const Projection: BevyType<Projection> = { typeName: "bevy_render::camera::projection::Projection" };
+const ScalingMode: BevyType<ScalingMode> = { typeName: "bevy_render::camera::projection::ScalingMode" };
+const WindowOrigin: BevyType<WindowOrigin> = { typeName: "bevy_render::camera::projection::WindowOrigin" };
+const Color: BevyType<Color> = { typeName: "bevy_render::color::Color" };
+const SkinnedMesh: BevyType<SkinnedMesh> = { typeName: "bevy_render::mesh::mesh::skinning::SkinnedMesh" };
+const Aabb: BevyType<Aabb> = { typeName: "bevy_render::primitives::Aabb" };
+const CubemapFrusta: BevyType<CubemapFrusta> = { typeName: "bevy_render::primitives::CubemapFrusta" };
+const Frustum: BevyType<Frustum> = { typeName: "bevy_render::primitives::Frustum" };
+const Msaa: BevyType<Msaa> = { typeName: "bevy_render::view::Msaa" };
+const ComputedVisibility: BevyType<ComputedVisibility> = { typeName: "bevy_render::view::visibility::ComputedVisibility" };
+const Visibility: BevyType<Visibility> = { typeName: "bevy_render::view::visibility::Visibility" };
+const VisibleEntities: BevyType<VisibleEntities> = { typeName: "bevy_render::view::visibility::VisibleEntities" };
+// bevy_sprite
 type Mesh2dHandle = unknown;
-const Mesh2dHandle: BevyType<Mesh2dHandle> = { typeName: "bevy_sprite::mesh2d::mesh::Mesh2dHandle" };
-
 type Anchor = unknown;
-const Anchor: BevyType<Anchor> = { typeName: "bevy_sprite::sprite::Anchor" };
-
 type Sprite = {
-    color: Color,
-    flip_x: bool,
-    flip_y: bool,
-    custom_size: Vec2 | null,
-    anchor: Anchor,
+  color: Color,
+  flip_x: boolean,
+  flip_y: boolean,
+  custom_size: Vec2 | null,
+  rect: Rect | null,
+  anchor: Anchor,
 };
+
+const Mesh2dHandle: BevyType<Mesh2dHandle> = { typeName: "bevy_sprite::mesh2d::mesh::Mesh2dHandle" };
+const Anchor: BevyType<Anchor> = { typeName: "bevy_sprite::sprite::Anchor" };
 const Sprite: BevyType<Sprite> = { typeName: "bevy_sprite::sprite::Sprite" };
+// bevy_hierarchy
+type Children = unknown;
+type Parent = unknown;
 
+const Children: BevyType<Children> = { typeName: "bevy_hierarchy::components::children::Children" };
+const Parent: BevyType<Parent> = { typeName: "bevy_hierarchy::components::parent::Parent" };
+// bevy_text
 type HorizontalAlign = unknown;
-const HorizontalAlign: BevyType<HorizontalAlign> = { typeName: "bevy_text::text::HorizontalAlign" };
-
+type Text = {
+  sections: TextSection[],
+  alignment: TextAlignment,
+};
 type TextAlignment = {
-    vertical: VerticalAlign,
-    horizontal: HorizontalAlign,
+  vertical: VerticalAlign,
+  horizontal: HorizontalAlign,
 };
-const TextAlignment: BevyType<TextAlignment> = { typeName: "bevy_text::text::TextAlignment" };
-
 type TextSection = {
-    value: string,
-    style: TextStyle,
+  value: string,
+  style: TextStyle,
 };
-const TextSection: BevyType<TextSection> = { typeName: "bevy_text::text::TextSection" };
-
 type TextStyle = {
-    font: HandleFont,
-    font_size: f32,
-    color: Color,
+  font: HandleFont,
+  font_size: number,
+  color: Color,
 };
-const TextStyle: BevyType<TextStyle> = { typeName: "bevy_text::text::TextStyle" };
-
 type VerticalAlign = unknown;
-const VerticalAlign: BevyType<VerticalAlign> = { typeName: "bevy_text::text::VerticalAlign" };
 
-type Stopwatch = {
-    elapsed: Duration,
-    paused: bool,
+const HorizontalAlign: BevyType<HorizontalAlign> = { typeName: "bevy_text::text::HorizontalAlign" };
+const Text: BevyType<Text> = { typeName: "bevy_text::text::Text" };
+const TextAlignment: BevyType<TextAlignment> = { typeName: "bevy_text::text::TextAlignment" };
+const TextSection: BevyType<TextSection> = { typeName: "bevy_text::text::TextSection" };
+const TextStyle: BevyType<TextStyle> = { typeName: "bevy_text::text::TextStyle" };
+const VerticalAlign: BevyType<VerticalAlign> = { typeName: "bevy_text::text::VerticalAlign" };
+// glam
+type BVec2 = {
+  x: boolean,
+  y: boolean,
+};
+type BVec3 = {
+  x: boolean,
+  y: boolean,
+  z: boolean,
+};
+type BVec4 = {
+  x: boolean,
+  y: boolean,
+  z: boolean,
+  w: boolean,
+};
+type BVec3A = unknown;
+type BVec4A = unknown;
+type Affine2 = {
+  matrix2: Mat2,
+  translation: Vec2,
+};
+type Affine3A = {
+  matrix3: Mat3A,
+  translation: Vec3A,
 };
-const Stopwatch: BevyType<Stopwatch> = { typeName: "bevy_time::stopwatch::Stopwatch" };
-
-type Time = {
-    delta: Duration,
-    last_update: Instant | null,
-    delta_seconds_f64: f64,
-    delta_seconds: f32,
-    seconds_since_startup: f64,
-    time_since_startup: Duration,
-    startup: Instant,
+type Mat3 = {
+  x_axis: Vec3,
+  y_axis: Vec3,
+  z_axis: Vec3,
 };
-const Time: BevyType<Time> = { typeName: "bevy_time::time::Time" };
-
-type Timer = {
-    stopwatch: Stopwatch,
-    duration: Duration,
-    repeating: bool,
-    finished: bool,
-    times_finished_this_tick: u32,
+type Mat2 = {
+  x_axis: Vec2,
+  y_axis: Vec2,
 };
-const Timer: BevyType<Timer> = { typeName: "bevy_time::timer::Timer" };
-
+type Mat3A = {
+  x_axis: Vec3A,
+  y_axis: Vec3A,
+  z_axis: Vec3A,
+};
+type Mat4 = {
+  x_axis: Vec4,
+  y_axis: Vec4,
+  z_axis: Vec4,
+  w_axis: Vec4,
+};
+type Quat = unknown;
+type Vec3A = {
+  x: number,
+  y: number,
+  z: number,
+};
+type Vec4 = {
+  x: number,
+  y: number,
+  z: number,
+  w: number,
+};
+type Vec2 = {
+  x: number,
+  y: number,
+};
+type Vec3 = {
+  x: number,
+  y: number,
+  z: number,
+};
+type DAffine2 = {
+  matrix2: DMat2,
+  translation: DVec2,
+};
+type DAffine3 = {
+  matrix3: DMat3,
+  translation: DVec3,
+};
+type DMat2 = {
+  x_axis: DVec2,
+  y_axis: DVec2,
+};
+type DMat3 = {
+  x_axis: DVec3,
+  y_axis: DVec3,
+  z_axis: DVec3,
+};
+type DMat4 = {
+  x_axis: DVec4,
+  y_axis: DVec4,
+  z_axis: DVec4,
+  w_axis: DVec4,
+};
+type DQuat = unknown;
+type DVec2 = {
+  x: number,
+  y: number,
+};
+type DVec3 = {
+  x: number,
+  y: number,
+  z: number,
+};
+type DVec4 = {
+  x: number,
+  y: number,
+  z: number,
+  w: number,
+};
+type IVec2 = {
+  x: number,
+  y: number,
+};
+type IVec3 = {
+  x: number,
+  y: number,
+  z: number,
+};
+type IVec4 = {
+  x: number,
+  y: number,
+  z: number,
+  w: number,
+};
+type UVec2 = {
+  x: number,
+  y: number,
+};
+type UVec3 = {
+  x: number,
+  y: number,
+  z: number,
+};
+type UVec4 = {
+  x: number,
+  y: number,
+  z: number,
+  w: number,
+};
+
+const BVec2: BevyType<BVec2> = { typeName: "glam::bool::bvec2::BVec2" };
+const BVec3: BevyType<BVec3> = { typeName: "glam::bool::bvec3::BVec3" };
+const BVec4: BevyType<BVec4> = { typeName: "glam::bool::bvec4::BVec4" };
+const BVec3A: BevyType<BVec3A> = { typeName: "glam::bool::sse2::bvec3a::BVec3A" };
+const BVec4A: BevyType<BVec4A> = { typeName: "glam::bool::sse2::bvec4a::BVec4A" };
+const Affine2: BevyType<Affine2> = { typeName: "glam::f32::affine2::Affine2" };
+const Affine3A: BevyType<Affine3A> = { typeName: "glam::f32::affine3a::Affine3A" };
+const Mat3: BevyType<Mat3> = { typeName: "glam::f32::mat3::Mat3" };
+const Mat2: BevyType<Mat2> = { typeName: "glam::f32::sse2::mat2::Mat2" };
+const Mat3A: BevyType<Mat3A> = { typeName: "glam::f32::sse2::mat3a::Mat3A" };
+const Mat4: BevyType<Mat4> = { typeName: "glam::f32::sse2::mat4::Mat4" };
+const Quat: BevyType<Quat> = { typeName: "glam::f32::sse2::quat::Quat" };
+const Vec3A: BevyType<Vec3A> = { typeName: "glam::f32::sse2::vec3a::Vec3A" };
+const Vec4: BevyType<Vec4> = { typeName: "glam::f32::sse2::vec4::Vec4" };
+const Vec2: BevyType<Vec2> = { typeName: "glam::f32::vec2::Vec2" };
+const Vec3: BevyType<Vec3> = { typeName: "glam::f32::vec3::Vec3" };
+const DAffine2: BevyType<DAffine2> = { typeName: "glam::f64::daffine2::DAffine2" };
+const DAffine3: BevyType<DAffine3> = { typeName: "glam::f64::daffine3::DAffine3" };
+const DMat2: BevyType<DMat2> = { typeName: "glam::f64::dmat2::DMat2" };
+const DMat3: BevyType<DMat3> = { typeName: "glam::f64::dmat3::DMat3" };
+const DMat4: BevyType<DMat4> = { typeName: "glam::f64::dmat4::DMat4" };
+const DQuat: BevyType<DQuat> = { typeName: "glam::f64::dquat::DQuat" };
+const DVec2: BevyType<DVec2> = { typeName: "glam::f64::dvec2::DVec2" };
+const DVec3: BevyType<DVec3> = { typeName: "glam::f64::dvec3::DVec3" };
+const DVec4: BevyType<DVec4> = { typeName: "glam::f64::dvec4::DVec4" };
+const IVec2: BevyType<IVec2> = { typeName: "glam::i32::ivec2::IVec2" };
+const IVec3: BevyType<IVec3> = { typeName: "glam::i32::ivec3::IVec3" };
+const IVec4: BevyType<IVec4> = { typeName: "glam::i32::ivec4::IVec4" };
+const UVec2: BevyType<UVec2> = { typeName: "glam::u32::uvec2::UVec2" };
+const UVec3: BevyType<UVec3> = { typeName: "glam::u32::uvec3::UVec3" };
+const UVec4: BevyType<UVec4> = { typeName: "glam::u32::uvec4::UVec4" };
+// bevy_transform
 type GlobalTransform = unknown;
-const GlobalTransform: BevyType<GlobalTransform> = { typeName: "bevy_transform::components::global_transform::GlobalTransform" };
-
 type Transform = {
-    translation: Vec3,
-    rotation: Quat,
-    scale: Vec3,
+  translation: Vec3,
+  rotation: Quat,
+  scale: Vec3,
 };
+
+const GlobalTransform: BevyType<GlobalTransform> = { typeName: "bevy_transform::components::global_transform::GlobalTransform" };
 const Transform: BevyType<Transform> = { typeName: "bevy_transform::components::transform::Transform" };
+// bevy_animation
+type AnimationPlayer = {
+  paused: boolean,
+  repeat: boolean,
+  speed: number,
+  elapsed: number,
+  animation_clip: HandleAnimationClip,
+};
 
+const AnimationPlayer: BevyType<AnimationPlayer> = { typeName: "bevy_animation::AnimationPlayer" };
+// bevy_ui
 type FocusPolicy = unknown;
-const FocusPolicy: BevyType<FocusPolicy> = { typeName: "bevy_ui::focus::FocusPolicy" };
-
 type Interaction = unknown;
-const Interaction: BevyType<Interaction> = { typeName: "bevy_ui::focus::Interaction" };
-
 type Size = {
-    width: f32,
-    height: f32,
+  width: Val,
+  height: Val,
 };
-const Size: BevyType<Size> = { typeName: "bevy_ui::geometry::Size" };
-
-type SizeVal = {
-    width: Val,
-    height: Val,
+type UiRect = {
+  left: Val,
+  right: Val,
+  top: Val,
+  bottom: Val,
 };
-const SizeVal: BevyType<SizeVal> = { typeName: "bevy_ui::geometry::Size<bevy_ui::ui_node::Val>" };
-
-type UiRectVal = {
-    left: Val,
-    right: Val,
-    top: Val,
-    bottom: Val,
-};
-const UiRectVal: BevyType<UiRectVal> = { typeName: "bevy_ui::geometry::UiRect<bevy_ui::ui_node::Val>" };
-
 type AlignContent = unknown;
-const AlignContent: BevyType<AlignContent> = { typeName: "bevy_ui::ui_node::AlignContent" };
-
 type AlignItems = unknown;
-const AlignItems: BevyType<AlignItems> = { typeName: "bevy_ui::ui_node::AlignItems" };
-
 type AlignSelf = unknown;
-const AlignSelf: BevyType<AlignSelf> = { typeName: "bevy_ui::ui_node::AlignSelf" };
-
 type CalculatedSize = {
-    size: Size,
+  size: Size,
 };
-const CalculatedSize: BevyType<CalculatedSize> = { typeName: "bevy_ui::ui_node::CalculatedSize" };
-
 type Direction = unknown;
-const Direction: BevyType<Direction> = { typeName: "bevy_ui::ui_node::Direction" };
-
 type Display = unknown;
-const Display: BevyType<Display> = { typeName: "bevy_ui::ui_node::Display" };
-
 type FlexDirection = unknown;
-const FlexDirection: BevyType<FlexDirection> = { typeName: "bevy_ui::ui_node::FlexDirection" };
-
 type FlexWrap = unknown;
-const FlexWrap: BevyType<FlexWrap> = { typeName: "bevy_ui::ui_node::FlexWrap" };
-
 type JustifyContent = unknown;
-const JustifyContent: BevyType<JustifyContent> = { typeName: "bevy_ui::ui_node::JustifyContent" };
-
+type Node = {
+  size: Vec2,
+};
 type Overflow = unknown;
-const Overflow: BevyType<Overflow> = { typeName: "bevy_ui::ui_node::Overflow" };
-
 type PositionType = unknown;
-const PositionType: BevyType<PositionType> = { typeName: "bevy_ui::ui_node::PositionType" };
-
 type Style = {
-    display: Display,
-    position_type: PositionType,
-    direction: Direction,
-    flex_direction: FlexDirection,
-    flex_wrap: FlexWrap,
-    align_items: AlignItems,
-    align_self: AlignSelf,
-    align_content: AlignContent,
-    justify_content: JustifyContent,
-    position: UiRectVal,
-    margin: UiRectVal,
-    padding: UiRectVal,
-    border: UiRectVal,
-    flex_grow: f32,
-    flex_shrink: f32,
-    flex_basis: Val,
-    size: SizeVal,
-    min_size: SizeVal,
-    max_size: SizeVal,
-    aspect_ratio: f32 | null,
-    overflow: Overflow,
+  display: Display,
+  position_type: PositionType,
+  direction: Direction,
+  flex_direction: FlexDirection,
+  flex_wrap: FlexWrap,
+  align_items: AlignItems,
+  align_self: AlignSelf,
+  align_content: AlignContent,
+  justify_content: JustifyContent,
+  position: UiRect,
+  margin: UiRect,
+  padding: UiRect,
+  border: UiRect,
+  flex_grow: number,
+  flex_shrink: number,
+  flex_basis: Val,
+  size: Size,
+  min_size: Size,
+  max_size: Size,
+  aspect_ratio: number | null,
+  overflow: Overflow,
 };
-const Style: BevyType<Style> = { typeName: "bevy_ui::ui_node::Style" };
-
 type UiColor = unknown;
-const UiColor: BevyType<UiColor> = { typeName: "bevy_ui::ui_node::UiColor" };
-
 type UiImage = unknown;
-const UiImage: BevyType<UiImage> = { typeName: "bevy_ui::ui_node::UiImage" };
-
 type Val = unknown;
-const Val: BevyType<Val> = { typeName: "bevy_ui::ui_node::Val" };
-
 type Button = {
 };
-const Button: BevyType<Button> = { typeName: "bevy_ui::widget::button::Button" };
-
 type ImageMode = unknown;
-const ImageMode: BevyType<ImageMode> = { typeName: "bevy_ui::widget::image::ImageMode" };
-
-type Rangef32 = unknown;
-const Rangef32: BevyType<Rangef32> = { typeName: "core::ops::range::Range<f32>" };
-
-type OptionString = unknown;
-const OptionString: BevyType<OptionString> = { typeName: "core::option::Option<alloc::string::String>" };
-
-type Optionf32 = unknown;
-const Optionf32: BevyType<Optionf32> = { typeName: "core::option::Option<f32>" };
-
-type Duration = unknown;
-const Duration: BevyType<Duration> = { typeName: "core::time::Duration" };
-
-type Mat3 = {
-    x_axis: Vec3,
-    y_axis: Vec3,
-    z_axis: Vec3,
-};
-const Mat3: BevyType<Mat3> = { typeName: "glam::f32::mat3::Mat3" };
-
-type Mat2 = {
-    x_axis: Vec2,
-    y_axis: Vec2,
-};
-const Mat2: BevyType<Mat2> = { typeName: "glam::f32::sse2::mat2::Mat2" };
-
-type Mat4 = {
-    x_axis: Vec4,
-    y_axis: Vec4,
-    z_axis: Vec4,
-    w_axis: Vec4,
-};
-const Mat4: BevyType<Mat4> = { typeName: "glam::f32::sse2::mat4::Mat4" };
-
-type Quat = unknown;
-const Quat: BevyType<Quat> = { typeName: "glam::f32::sse2::quat::Quat" };
-
-type Vec4 = {
-    x: f32,
-    y: f32,
-    z: f32,
-    w: f32,
-};
-const Vec4: BevyType<Vec4> = { typeName: "glam::f32::sse2::vec4::Vec4" };
-
-type Vec2 = {
-    x: f32,
-    y: f32,
-};
-const Vec2: BevyType<Vec2> = { typeName: "glam::f32::vec2::Vec2" };
-
-type Vec3 = {
-    x: f32,
-    y: f32,
-    z: f32,
-
-    lerp(other: Vec3, t: f32): Vec3;
-};
-const Vec3: BevyType<Vec3> = { typeName: "glam::f32::vec3::Vec3" };
 
-type IVec2 = {
-    x: i32,
-    y: i32,
-};
-const IVec2: BevyType<IVec2> = { typeName: "glam::i32::ivec2::IVec2" };
-
-type IVec3 = {
-    x: i32,
-    y: i32,
-    z: i32,
-};
-const IVec3: BevyType<IVec3> = { typeName: "glam::i32::ivec3::IVec3" };
-
-type IVec4 = {
-    x: i32,
-    y: i32,
-    z: i32,
-    w: i32,
-};
-const IVec4: BevyType<IVec4> = { typeName: "glam::i32::ivec4::IVec4" };
-
-type UVec2 = {
-    x: u32,
-    y: u32,
-};
-const UVec2: BevyType<UVec2> = { typeName: "glam::u32::uvec2::UVec2" };
-
-type UVec3 = {
-    x: u32,
-    y: u32,
-    z: u32,
-};
-const UVec3: BevyType<UVec3> = { typeName: "glam::u32::uvec3::UVec3" };
-
-type UVec4 = {
-    x: u32,
-    y: u32,
-    z: u32,
-    w: u32,
-};
-const UVec4: BevyType<UVec4> = { typeName: "glam::u32::uvec4::UVec4" };
-
-type HashSetString = unknown;
-const HashSetString: BevyType<HashSetString> = { typeName: "hashbrown::set::HashSet<alloc::string::String>" };
-
-type Instant = unknown;
-const Instant: BevyType<Instant> = { typeName: "std::time::Instant" };
+const FocusPolicy: BevyType<FocusPolicy> = { typeName: "bevy_ui::focus::FocusPolicy" };
+const Interaction: BevyType<Interaction> = { typeName: "bevy_ui::focus::Interaction" };
+const Size: BevyType<Size> = { typeName: "bevy_ui::geometry::Size" };
+const UiRect: BevyType<UiRect> = { typeName: "bevy_ui::geometry::UiRect" };
+const AlignContent: BevyType<AlignContent> = { typeName: "bevy_ui::ui_node::AlignContent" };
+const AlignItems: BevyType<AlignItems> = { typeName: "bevy_ui::ui_node::AlignItems" };
+const AlignSelf: BevyType<AlignSelf> = { typeName: "bevy_ui::ui_node::AlignSelf" };
+const CalculatedSize: BevyType<CalculatedSize> = { typeName: "bevy_ui::ui_node::CalculatedSize" };
+const Direction: BevyType<Direction> = { typeName: "bevy_ui::ui_node::Direction" };
+const Display: BevyType<Display> = { typeName: "bevy_ui::ui_node::Display" };
+const FlexDirection: BevyType<FlexDirection> = { typeName: "bevy_ui::ui_node::FlexDirection" };
+const FlexWrap: BevyType<FlexWrap> = { typeName: "bevy_ui::ui_node::FlexWrap" };
+const JustifyContent: BevyType<JustifyContent> = { typeName: "bevy_ui::ui_node::JustifyContent" };
+const Node: BevyType<Node> = { typeName: "bevy_ui::ui_node::Node" };
+const Overflow: BevyType<Overflow> = { typeName: "bevy_ui::ui_node::Overflow" };
+const PositionType: BevyType<PositionType> = { typeName: "bevy_ui::ui_node::PositionType" };
+const Style: BevyType<Style> = { typeName: "bevy_ui::ui_node::Style" };
+const UiColor: BevyType<UiColor> = { typeName: "bevy_ui::ui_node::UiColor" };
+const UiImage: BevyType<UiImage> = { typeName: "bevy_ui::ui_node::UiImage" };
+const Val: BevyType<Val> = { typeName: "bevy_ui::ui_node::Val" };
+const Button: BevyType<Button> = { typeName: "bevy_ui::widget::button::Button" };
+const ImageMode: BevyType<ImageMode> = { typeName: "bevy_ui::widget::image::ImageMode" };