auto-git:

[add] src/geometry/model-instance-collider-generation.ts
 [add] src/runtime-three/rapier-collision-world.ts
 [change] AGENTS.md
 [change] CHAT_CONTEXT.md
 [change] architecture.md
 [change] package.json
 [change] prompts-lite.txt
 [change] prompts.txt
 [change] roadmap.md
 [change] src/assets/model-instances.ts
 [change] src/document/migrate-scene-document.ts
 [change] src/document/scene-document-validation.ts
 [change] src/document/scene-document.ts
 [change] src/runtime-three/first-person-navigation-controller.ts
 [change] src/runtime-three/navigation-controller.ts
 [change] src/runtime-three/runtime-host.ts
 [change] src/runtime-three/runtime-scene-build.ts
 [change] src/runtime-three/runtime-scene-validation.ts
 [change] src/viewport-three/viewport-host.ts
 [change] testing.md

src/runtime-three/first-person-navigation-controller.ts

@@ -2,7 +2,7 @@ import { Euler, Vector3 } from "three";
 
 import type { Vec3 } from "../core/vector";
 
-import { FIRST_PERSON_PLAYER_SHAPE, resolveFirstPersonMotion } from "./player-collision";
+import { FIRST_PERSON_PLAYER_SHAPE } from "./player-collision";
 import type { NavigationController, RuntimeControllerContext } from "./navigation-controller";
 
 const LOOK_SENSITIVITY = 0.0022;
@@ -116,17 +116,22 @@ export class FirstPersonNavigationController implements NavigationController {
 
     this.verticalVelocity -= GRAVITY * dt;
 
-    const resolvedMotion = resolveFirstPersonMotion(
+    const resolvedMotion = this.context.resolveFirstPersonMotion(
       this.feetPosition,
       {
         x: horizontalX,
         y: this.verticalVelocity * dt,
         z: horizontalZ
       },
-      FIRST_PERSON_PLAYER_SHAPE,
-      this.context.getRuntimeScene().colliders
+      FIRST_PERSON_PLAYER_SHAPE
     );
 
+    if (resolvedMotion === null) {
+      this.updateCameraTransform();
+      this.publishTelemetry();
+      return;
+    }
+
     this.feetPosition = resolvedMotion.feetPosition;
     this.grounded = resolvedMotion.grounded;
 

src/runtime-three/navigation-controller.ts

@@ -2,6 +2,7 @@ import type { PerspectiveCamera } from "three";
 
 import type { Vec3 } from "../core/vector";
 
+import type { FirstPersonPlayerShape, ResolvedPlayerMotion } from "./player-collision";
 import type { RuntimeNavigationMode, RuntimeSceneDefinition, RuntimeSpawnPoint } from "./runtime-scene-build";
 
 export interface FirstPersonTelemetry {
@@ -16,6 +17,7 @@ export interface RuntimeControllerContext {
   camera: PerspectiveCamera;
   domElement: HTMLCanvasElement;
   getRuntimeScene(): RuntimeSceneDefinition;
+  resolveFirstPersonMotion(feetPosition: Vec3, motion: Vec3, shape: FirstPersonPlayerShape): ResolvedPlayerMotion | null;
   setRuntimeMessage(message: string | null): void;
   setFirstPersonTelemetry(telemetry: FirstPersonTelemetry | null): void;
 }

src/runtime-three/rapier-collision-world.ts

@@ -0,0 +1,278 @@
+import RAPIER from "@dimforge/rapier3d-compat";
+import { Euler, MathUtils, Quaternion, Vector3 } from "three";
+
+import type { Vec3 } from "../core/vector";
+import type {
+  GeneratedModelBoxCollider,
+  GeneratedModelCollider,
+  GeneratedModelCompoundCollider,
+  GeneratedModelHeightfieldCollider,
+  GeneratedModelTriMeshCollider
+} from "../geometry/model-instance-collider-generation";
+
+import type { FirstPersonPlayerShape, ResolvedPlayerMotion } from "./player-collision";
+import type { RuntimeBoxCollider, RuntimeSceneCollider } from "./runtime-scene-build";
+
+const CHARACTER_CONTROLLER_OFFSET = 0.01;
+const COLLISION_EPSILON = 1e-5;
+
+let rapierInitPromise: Promise<typeof RAPIER> | null = null;
+
+function cloneVec3(vector: Vec3): Vec3 {
+  return {
+    x: vector.x,
+    y: vector.y,
+    z: vector.z
+  };
+}
+
+function componentScale(vector: Vec3, scale: Vec3): Vec3 {
+  return {
+    x: vector.x * scale.x,
+    y: vector.y * scale.y,
+    z: vector.z * scale.z
+  };
+}
+
+function createRapierQuaternion(rotationDegrees: Vec3): RAPIER.Rotation {
+  const quaternion = new Quaternion().setFromEuler(
+    new Euler(
+      MathUtils.degToRad(rotationDegrees.x),
+      MathUtils.degToRad(rotationDegrees.y),
+      MathUtils.degToRad(rotationDegrees.z),
+      "XYZ"
+    )
+  );
+
+  return {
+    x: quaternion.x,
+    y: quaternion.y,
+    z: quaternion.z,
+    w: quaternion.w
+  };
+}
+
+function scaleVertices(vertices: Float32Array, scale: Vec3): Float32Array {
+  const scaledVertices = new Float32Array(vertices.length);
+
+  for (let index = 0; index < vertices.length; index += 3) {
+    scaledVertices[index] = vertices[index] * scale.x;
+    scaledVertices[index + 1] = vertices[index + 1] * scale.y;
+    scaledVertices[index + 2] = vertices[index + 2] * scale.z;
+  }
+
+  return scaledVertices;
+}
+
+function scaleBoundsCenter(bounds: { min: Vec3; max: Vec3 }, scale: Vec3): Vec3 {
+  return {
+    x: ((bounds.min.x + bounds.max.x) * 0.5) * scale.x,
+    y: ((bounds.min.y + bounds.max.y) * 0.5) * scale.y,
+    z: ((bounds.min.z + bounds.max.z) * 0.5) * scale.z
+  };
+}
+
+function createFixedBodyForModelCollider(world: RAPIER.World, collider: GeneratedModelCollider): RAPIER.RigidBody {
+  return world.createRigidBody(
+    RAPIER.RigidBodyDesc.fixed()
+      .setTranslation(collider.transform.position.x, collider.transform.position.y, collider.transform.position.z)
+      .setRotation(createRapierQuaternion(collider.transform.rotationDegrees))
+  );
+}
+
+function attachBrushCollider(world: RAPIER.World, collider: RuntimeBoxCollider) {
+  const center = {
+    x: (collider.min.x + collider.max.x) * 0.5,
+    y: (collider.min.y + collider.max.y) * 0.5,
+    z: (collider.min.z + collider.max.z) * 0.5
+  };
+  const halfExtents = {
+    x: (collider.max.x - collider.min.x) * 0.5,
+    y: (collider.max.y - collider.min.y) * 0.5,
+    z: (collider.max.z - collider.min.z) * 0.5
+  };
+
+  world.createCollider(RAPIER.ColliderDesc.cuboid(halfExtents.x, halfExtents.y, halfExtents.z).setTranslation(center.x, center.y, center.z));
+}
+
+function attachSimpleModelCollider(world: RAPIER.World, collider: GeneratedModelBoxCollider) {
+  const body = createFixedBodyForModelCollider(world, collider);
+  const scaledCenter = componentScale(collider.center, collider.transform.scale);
+  const scaledHalfExtents = componentScale(
+    {
+      x: collider.size.x * 0.5,
+      y: collider.size.y * 0.5,
+      z: collider.size.z * 0.5
+    },
+    collider.transform.scale
+  );
+
+  world.createCollider(
+    RAPIER.ColliderDesc.cuboid(scaledHalfExtents.x, scaledHalfExtents.y, scaledHalfExtents.z).setTranslation(
+      scaledCenter.x,
+      scaledCenter.y,
+      scaledCenter.z
+    ),
+    body
+  );
+}
+
+function attachStaticModelCollider(world: RAPIER.World, collider: GeneratedModelTriMeshCollider) {
+  const body = createFixedBodyForModelCollider(world, collider);
+  world.createCollider(RAPIER.ColliderDesc.trimesh(scaleVertices(collider.vertices, collider.transform.scale), collider.indices), body);
+}
+
+function attachTerrainModelCollider(world: RAPIER.World, collider: GeneratedModelHeightfieldCollider) {
+  const body = createFixedBodyForModelCollider(world, collider);
+  const center = scaleBoundsCenter(
+    {
+      min: {
+        x: collider.minX,
+        y: 0,
+        z: collider.minZ
+      },
+      max: {
+        x: collider.maxX,
+        y: 0,
+        z: collider.maxZ
+      }
+    },
+    collider.transform.scale
+  );
+
+  world.createCollider(
+    RAPIER.ColliderDesc.heightfield(collider.rows, collider.cols, collider.heights, {
+      x: (collider.maxX - collider.minX) * collider.transform.scale.x,
+      y: collider.transform.scale.y,
+      z: (collider.maxZ - collider.minZ) * collider.transform.scale.z
+    }).setTranslation(center.x, center.y, center.z),
+    body
+  );
+}
+
+function attachDynamicModelCollider(world: RAPIER.World, collider: GeneratedModelCompoundCollider) {
+  const body = createFixedBodyForModelCollider(world, collider);
+
+  for (const piece of collider.pieces) {
+    const scaledPoints = scaleVertices(piece.points, collider.transform.scale);
+    const descriptor = RAPIER.ColliderDesc.convexHull(scaledPoints);
+
+    if (descriptor === null) {
+      throw new Error(`Dynamic collider piece ${piece.id} could not form a valid convex hull.`);
+    }
+
+    world.createCollider(descriptor, body);
+  }
+}
+
+function attachModelCollider(world: RAPIER.World, collider: GeneratedModelCollider) {
+  switch (collider.kind) {
+    case "box":
+      attachSimpleModelCollider(world, collider);
+      break;
+    case "trimesh":
+      attachStaticModelCollider(world, collider);
+      break;
+    case "heightfield":
+      attachTerrainModelCollider(world, collider);
+      break;
+    case "compound":
+      attachDynamicModelCollider(world, collider);
+      break;
+  }
+}
+
+function feetPositionToColliderCenter(feetPosition: Vec3, shape: FirstPersonPlayerShape): Vec3 {
+  const cylindricalHalfHeight = Math.max(0, (shape.height - shape.radius * 2) * 0.5);
+
+  return {
+    x: feetPosition.x,
+    y: feetPosition.y + shape.radius + cylindricalHalfHeight,
+    z: feetPosition.z
+  };
+}
+
+function colliderCenterToFeetPosition(center: Vec3, shape: FirstPersonPlayerShape): Vec3 {
+  const cylindricalHalfHeight = Math.max(0, (shape.height - shape.radius * 2) * 0.5);
+
+  return {
+    x: center.x,
+    y: center.y - (shape.radius + cylindricalHalfHeight),
+    z: center.z
+  };
+}
+
+export async function initializeRapierCollisionWorld(): Promise<typeof RAPIER> {
+  rapierInitPromise ??= RAPIER.init().then(() => RAPIER);
+  return rapierInitPromise;
+}
+
+export class RapierCollisionWorld {
+  static async create(colliders: RuntimeSceneCollider[], playerShape: FirstPersonPlayerShape): Promise<RapierCollisionWorld> {
+    const rapier = await initializeRapierCollisionWorld();
+    const world = new rapier.World({
+      x: 0,
+      y: 0,
+      z: 0
+    });
+
+    for (const collider of colliders) {
+      if (collider.source === "brush") {
+        attachBrushCollider(world, collider);
+        continue;
+      }
+
+      attachModelCollider(world, collider);
+    }
+
+    const playerCollider = world.createCollider(
+      rapier.ColliderDesc.capsule(Math.max(0, (playerShape.height - playerShape.radius * 2) * 0.5), playerShape.radius)
+    );
+    const characterController = world.createCharacterController(CHARACTER_CONTROLLER_OFFSET);
+
+    characterController.setUp({ x: 0, y: 1, z: 0 });
+    characterController.setSlideEnabled(true);
+    characterController.enableSnapToGround(0.2);
+    characterController.enableAutostep(0.35, 0.15, false);
+    characterController.setMaxSlopeClimbAngle(Math.PI * 0.45);
+    characterController.setMinSlopeSlideAngle(Math.PI * 0.5);
+
+    return new RapierCollisionWorld(world, characterController, playerCollider);
+  }
+
+  private constructor(
+    private readonly world: RAPIER.World,
+    private readonly characterController: RAPIER.KinematicCharacterController,
+    private readonly playerCollider: RAPIER.Collider
+  ) {}
+
+  resolveFirstPersonMotion(feetPosition: Vec3, motion: Vec3, shape: FirstPersonPlayerShape): ResolvedPlayerMotion {
+    const currentCenter = feetPositionToColliderCenter(feetPosition, shape);
+    this.playerCollider.setTranslation(currentCenter);
+    this.characterController.computeColliderMovement(this.playerCollider, motion);
+
+    const correctedMovement = this.characterController.computedMovement();
+    const nextCenter = {
+      x: currentCenter.x + correctedMovement.x,
+      y: currentCenter.y + correctedMovement.y,
+      z: currentCenter.z + correctedMovement.z
+    };
+
+    this.playerCollider.setTranslation(nextCenter);
+
+    return {
+      feetPosition: colliderCenterToFeetPosition(nextCenter, shape),
+      grounded: this.characterController.computedGrounded(),
+      collidedAxes: {
+        x: Math.abs(correctedMovement.x - motion.x) > COLLISION_EPSILON,
+        y: Math.abs(correctedMovement.y - motion.y) > COLLISION_EPSILON,
+        z: Math.abs(correctedMovement.z - motion.z) > COLLISION_EPSILON
+      }
+    };
+  }
+
+  dispose() {
+    this.world.removeCharacterController(this.characterController);
+    this.world.free();
+  }
+}

src/runtime-three/runtime-host.ts

@@ -40,6 +40,8 @@ import {
 
 import { FirstPersonNavigationController } from "./first-person-navigation-controller";
 import type { FirstPersonTelemetry, NavigationController, RuntimeControllerContext } from "./navigation-controller";
+import { FIRST_PERSON_PLAYER_SHAPE } from "./player-collision";
+import { RapierCollisionWorld } from "./rapier-collision-world";
 import { RuntimeInteractionSystem, type RuntimeInteractionDispatcher, type RuntimeInteractionPrompt } from "./runtime-interaction-system";
 import { RuntimeAudioSystem } from "./runtime-audio-system";
 import { OrbitVisitorNavigationController } from "./orbit-visitor-navigation-controller";
@@ -85,6 +87,8 @@ export class RuntimeHost {
   private readonly controllerContext: RuntimeControllerContext;
   private readonly renderer: WebGLRenderer | null;
   private runtimeScene: RuntimeSceneDefinition | null = null;
+  private collisionWorld: RapierCollisionWorld | null = null;
+  private collisionWorldRequestId = 0;
   private currentWorld: RuntimeSceneDefinition["world"] | null = null;
   private currentAdvancedRenderingSettings: AdvancedRenderingSettings | null = null;
   private advancedRenderingComposer: EffectComposer | null = null;
@@ -131,6 +135,7 @@ export class RuntimeHost {
 
         return this.runtimeScene;
       },
+      resolveFirstPersonMotion: (feetPosition, motion, shape) => this.collisionWorld?.resolveFirstPersonMotion(feetPosition, motion, shape) ?? null,
       setRuntimeMessage: (message) => {
         if (message === this.currentRuntimeMessage) {
           return;
@@ -171,6 +176,7 @@ export class RuntimeHost {
     this.rebuildLocalLights(runtimeScene.localLights);
     this.rebuildBrushMeshes(runtimeScene.brushes);
     this.rebuildModelInstances(runtimeScene.modelInstances);
+    void this.rebuildCollisionWorld(runtimeScene.colliders);
     this.audioSystem.loadScene(runtimeScene);
   }
 
@@ -244,6 +250,8 @@ export class RuntimeHost {
     this.clearLocalLights();
     this.clearBrushMeshes();
     this.clearModelInstances();
+    this.collisionWorldRequestId += 1;
+    this.clearCollisionWorld();
     this.audioSystem.dispose();
     this.advancedRenderingComposer?.dispose();
     this.advancedRenderingComposer = null;
@@ -306,6 +314,36 @@ export class RuntimeHost {
     this.applyShadowState();
   }
 
+  private async rebuildCollisionWorld(colliders: RuntimeSceneDefinition["colliders"]) {
+    const requestId = ++this.collisionWorldRequestId;
+
+    this.clearCollisionWorld();
+
+    try {
+      const nextCollisionWorld = await RapierCollisionWorld.create(colliders, FIRST_PERSON_PLAYER_SHAPE);
+
+      if (requestId !== this.collisionWorldRequestId) {
+        nextCollisionWorld.dispose();
+        return;
+      }
+
+      this.collisionWorld = nextCollisionWorld;
+    } catch (error) {
+      if (requestId !== this.collisionWorldRequestId) {
+        return;
+      }
+
+      const message = error instanceof Error ? error.message : "Runner collision initialization failed.";
+      this.currentRuntimeMessage = `Runner collision initialization failed: ${message}`;
+      this.runtimeMessageHandler?.(this.currentRuntimeMessage);
+    }
+  }
+
+  private clearCollisionWorld() {
+    this.collisionWorld?.dispose();
+    this.collisionWorld = null;
+  }
+
   private syncAdvancedRenderingComposer(settings: AdvancedRenderingSettings) {
     if (this.renderer === null) {
       return;

src/runtime-three/runtime-scene-build.ts

@@ -1,3 +1,4 @@
+import type { LoadedModelAsset } from "../assets/gltf-model-import";
 import type { Vec3 } from "../core/vector";
 import { getModelInstances } from "../assets/model-instances";
 import type { BoxBrush, BoxFaceId, FaceUvState } from "../document/brushes";
@@ -5,6 +6,7 @@ import type { SceneDocument } from "../document/scene-document";
 import { cloneWorldSettings, type WorldSettings } from "../document/world-settings";
 import { getEntityInstances, getPrimaryPlayerStartEntity, type EntityInstance } from "../entities/entity-instances";
 import { getBoxBrushBounds } from "../geometry/box-brush";
+import { buildGeneratedModelCollider, type GeneratedColliderBounds, type GeneratedModelCollider } from "../geometry/model-instance-collider-generation";
 import { cloneInteractionLink, getInteractionLinks, type InteractionLink } from "../interactions/interaction-links";
 import { cloneMaterialDef, type MaterialDef } from "../materials/starter-material-library";
 import { cloneFaceUvState } from "../document/brushes";
@@ -28,11 +30,14 @@ export interface RuntimeBoxBrushInstance {
 
 export interface RuntimeBoxCollider {
   kind: "box";
+  source: "brush";
   brushId: string;
   min: Vec3;
   max: Vec3;
 }
 
+export type RuntimeSceneCollider = RuntimeBoxCollider | GeneratedModelCollider;
+
 export interface RuntimeSceneBounds {
   min: Vec3;
   max: Vec3;
@@ -132,7 +137,7 @@ export interface RuntimeSceneDefinition {
   world: WorldSettings;
   localLights: RuntimeLocalLightCollection;
   brushes: RuntimeBoxBrushInstance[];
-  colliders: RuntimeBoxCollider[];
+  colliders: RuntimeSceneCollider[];
   sceneBounds: RuntimeSceneBounds | null;
   modelInstances: RuntimeModelInstance[];
   entities: RuntimeEntityCollection;
@@ -143,6 +148,7 @@ export interface RuntimeSceneDefinition {
 
 interface BuildRuntimeSceneOptions {
   navigationMode?: RuntimeNavigationMode;
+  loadedModelAssets?: Record<string, LoadedModelAsset>;
 }
 
 function cloneVec3(vector: Vec3): Vec3 {
@@ -213,6 +219,7 @@ function buildRuntimeCollider(brush: BoxBrush): RuntimeBoxCollider {
 
   return {
     kind: "box",
+    source: "brush",
     brushId: brush.id,
     min: cloneVec3(bounds.min),
     max: cloneVec3(bounds.max)
@@ -232,21 +239,37 @@ function buildRuntimeModelInstance(modelInstance: SceneDocument["modelInstances"
   };
 }
 
-function combineColliderBounds(colliders: RuntimeBoxCollider[]): RuntimeSceneBounds | null {
+function getColliderBounds(collider: RuntimeSceneCollider): GeneratedColliderBounds {
+  if (collider.source === "brush") {
+    return {
+      min: cloneVec3(collider.min),
+      max: cloneVec3(collider.max)
+    };
+  }
+
+  return {
+    min: cloneVec3(collider.worldBounds.min),
+    max: cloneVec3(collider.worldBounds.max)
+  };
+}
+
+function combineColliderBounds(colliders: RuntimeSceneCollider[]): RuntimeSceneBounds | null {
   if (colliders.length === 0) {
     return null;
   }
 
-  const min = cloneVec3(colliders[0].min);
-  const max = cloneVec3(colliders[0].max);
+  const firstBounds = getColliderBounds(colliders[0]);
+  const min = cloneVec3(firstBounds.min);
+  const max = cloneVec3(firstBounds.max);
 
   for (const collider of colliders.slice(1)) {
-    min.x = Math.min(min.x, collider.min.x);
-    min.y = Math.min(min.y, collider.min.y);
-    min.z = Math.min(min.z, collider.min.z);
-    max.x = Math.max(max.x, collider.max.x);
-    max.y = Math.max(max.y, collider.max.y);
-    max.z = Math.max(max.z, collider.max.z);
+    const bounds = getColliderBounds(collider);
+    min.x = Math.min(min.x, bounds.min.x);
+    min.y = Math.min(min.y, bounds.min.y);
+    min.z = Math.min(min.z, bounds.min.z);
+    max.x = Math.max(max.x, bounds.max.x);
+    max.y = Math.max(max.y, bounds.max.y);
+    max.z = Math.max(max.z, bounds.max.z);
   }
 
   return {
@@ -396,15 +419,33 @@ function assertNever(value: never): never {
 }
 
 export function buildRuntimeSceneFromDocument(document: SceneDocument, options: BuildRuntimeSceneOptions = {}): RuntimeSceneDefinition {
-  assertRuntimeSceneBuildable(document, options.navigationMode ?? "orbitVisitor");
+  assertRuntimeSceneBuildable(document, {
+    navigationMode: options.navigationMode ?? "orbitVisitor",
+    loadedModelAssets: options.loadedModelAssets
+  });
 
   const brushes = Object.values(document.brushes).map((brush) => buildRuntimeBrush(brush, document));
-  const colliders = Object.values(document.brushes).map((brush) => buildRuntimeCollider(brush));
-  const sceneBounds = combineColliderBounds(colliders);
+  const colliders: RuntimeSceneCollider[] = Object.values(document.brushes).map((brush) => buildRuntimeCollider(brush));
   const modelInstances = getModelInstances(document.modelInstances).map(buildRuntimeModelInstance);
   const collections = buildRuntimeSceneCollections(document);
   const interactionLinks = getInteractionLinks(document.interactionLinks).map((link) => cloneInteractionLink(link));
   const playerStartEntity = getPrimaryPlayerStartEntity(document.entities);
+
+  for (const modelInstance of getModelInstances(document.modelInstances)) {
+    const asset = document.assets[modelInstance.assetId];
+
+    if (asset === undefined || asset.kind !== "model") {
+      continue;
+    }
+
+    const generatedCollider = buildGeneratedModelCollider(modelInstance, asset, options.loadedModelAssets?.[modelInstance.assetId]);
+
+    if (generatedCollider !== null) {
+      colliders.push(generatedCollider);
+    }
+  }
+
+  const combinedSceneBounds = combineColliderBounds(colliders);
   const playerStart =
     playerStartEntity === null
       ? null
@@ -419,14 +460,14 @@ export function buildRuntimeSceneFromDocument(document: SceneDocument, options:
     localLights: collections.localLights,
     brushes,
     colliders,
-    sceneBounds,
+    sceneBounds: combinedSceneBounds,
     modelInstances,
     entities: collections.entities,
     interactionLinks,
     playerStart,
     spawn:
       playerStart === null
-        ? buildFallbackSpawn(sceneBounds)
+        ? buildFallbackSpawn(combinedSceneBounds)
         : {
             source: "playerStart",
             entityId: playerStart.entityId,

src/runtime-three/runtime-scene-validation.ts

@@ -1,3 +1,5 @@
+import type { LoadedModelAsset } from "../assets/gltf-model-import";
+import { getModelInstances } from "../assets/model-instances";
 import type { SceneDocument } from "../document/scene-document";
 import {
   assertSceneDocumentIsValid,
@@ -6,6 +8,7 @@ import {
   type SceneDiagnostic
 } from "../document/scene-document-validation";
 import { getPrimaryPlayerStartEntity } from "../entities/entity-instances";
+import { buildGeneratedModelCollider, ModelColliderGenerationError } from "../geometry/model-instance-collider-generation";
 
 export interface RuntimeSceneBuildValidationResult {
   diagnostics: SceneDiagnostic[];
@@ -13,13 +16,18 @@ export interface RuntimeSceneBuildValidationResult {
   warnings: SceneDiagnostic[];
 }
 
+interface ValidateRuntimeSceneBuildOptions {
+  navigationMode: "firstPerson" | "orbitVisitor";
+  loadedModelAssets?: Record<string, LoadedModelAsset>;
+}
+
 export function validateRuntimeSceneBuild(
   document: SceneDocument,
-  navigationMode: "firstPerson" | "orbitVisitor"
+  options: ValidateRuntimeSceneBuildOptions
 ): RuntimeSceneBuildValidationResult {
   const diagnostics: SceneDiagnostic[] = [];
 
-  if (navigationMode === "firstPerson" && getPrimaryPlayerStartEntity(document.entities) === null) {
+  if (options.navigationMode === "firstPerson" && getPrimaryPlayerStartEntity(document.entities) === null) {
     diagnostics.push(
       createDiagnostic(
         "error",
@@ -31,6 +39,39 @@ export function validateRuntimeSceneBuild(
     );
   }
 
+  for (const modelInstance of getModelInstances(document.modelInstances)) {
+    const path = `modelInstances.${modelInstance.id}.collision.mode`;
+    const asset = document.assets[modelInstance.assetId];
+
+    if (modelInstance.collision.mode === "none" || asset === undefined || asset.kind !== "model") {
+      continue;
+    }
+
+    try {
+      const generatedCollider = buildGeneratedModelCollider(modelInstance, asset, options.loadedModelAssets?.[modelInstance.assetId]);
+
+      if (generatedCollider?.mode === "dynamic") {
+        diagnostics.push(
+          createDiagnostic(
+            "warning",
+            "dynamic-model-collider-fixed-query-only",
+            "Dynamic model collision currently generates convex compound pieces for Rapier queries, but the runner still uses them as fixed world collision rather than fully simulated rigid bodies.",
+            path,
+            "build"
+          )
+        );
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Imported model collision generation failed.";
+      const code =
+        error instanceof ModelColliderGenerationError
+          ? error.code
+          : "invalid-model-instance-collision-mode";
+
+      diagnostics.push(createDiagnostic("error", code, message, path, "build"));
+    }
+  }
+
   return {
     diagnostics,
     errors: diagnostics.filter((diagnostic) => diagnostic.severity === "error"),
@@ -38,10 +79,10 @@ export function validateRuntimeSceneBuild(
   };
 }
 
-export function assertRuntimeSceneBuildable(document: SceneDocument, navigationMode: "firstPerson" | "orbitVisitor") {
+export function assertRuntimeSceneBuildable(document: SceneDocument, options: ValidateRuntimeSceneBuildOptions) {
   assertSceneDocumentIsValid(document);
 
-  const validation = validateRuntimeSceneBuild(document, navigationMode);
+  const validation = validateRuntimeSceneBuild(document, options);
 
   if (validation.errors.length > 0) {
     throw new Error(`Runtime build is blocked: ${formatSceneDiagnosticSummary(validation.errors)}`);