Feat/asset packs validation

packages/asset-packs/scripts/validate.ts

@@ -1,19 +1,41 @@
 import { getTriggerComponent, assertValidTriggerComponent } from '../src/types';
+import { validateComposite } from '../src/validation';
+import type { ValidationError } from '../src/validation';
 import { LocalFileSystem } from './utils/local';
 
 async function main() {
   const local = new LocalFileSystem('./packs');
   const assetPacks = await local.getAssetPacks();
+  const allErrors: ValidationError[] = [];
+
   for (const assetPack of assetPacks) {
     const assetsPath = local.getAssetsPath(assetPack.name);
     const assets = await local.getAssets(assetsPath);
     for (const asset of assets) {
-      console.log(asset.name, '✅');
+      // Existing validation: trigger action refs must have id and name
       const triggerComponent = getTriggerComponent(asset);
       if (triggerComponent) assertValidTriggerComponent(asset.name, triggerComponent);
+
+      // Composite component dependency validation
+      const errors = validateComposite(asset.composite.components, asset.name);
+      for (const error of errors) {
+        const prefix = error.severity === 'error' ? '❌' : '⚠️';
+        console.error(`${prefix} [${error.rule}] ${error.message}`);
+        if (error.severity === 'error') allErrors.push(error);
+      }
+
+      console.log(asset.name, '✅');
     }
     console.log(assetPack.name, '✅');
   }
+
+  if (allErrors.length > 0) {
+    console.error(`\n${allErrors.length} validation error(s) found:`);
+    allErrors.forEach(e => console.error(`  ❌ [${e.rule}] ${e.message}`));
+    process.exit(1);
+  }
+
+  console.log('\nAll assets validated successfully ✅');
 }
 
 main().catch(error => {

packages/asset-packs/src/validation/helpers.ts

@@ -0,0 +1,55 @@
+import type { AssetComposite } from '../types';
+
+// SDK defaults for GltfContainer collision masks (from @dcl/ecs)
+const CL_POINTER = 1;
+const CL_PHYSICS = 2;
+const GLTF_DEFAULT_VISIBLE_MASK = 0; // CL_NONE
+const GLTF_DEFAULT_INVISIBLE_MASK = CL_PHYSICS;
+
+type Component = AssetComposite['components'][number];
+
+export function getComponent(components: Component[], name: string): Component | undefined {
+  return components.find(c => c.name === name);
+}
+
+export function hasComponent(components: Component[], name: string): boolean {
+  return components.some(c => c.name === name);
+}
+
+export function getComponentData(components: Component[], name: string): any | undefined {
+  return getComponent(components, name)?.data?.['0']?.json;
+}
+
+/**
+ * Check if entity has a collider with the given mask.
+ * GltfContainer is considered a valid pointer collider because GLTF models
+ * can have internal collider meshes (*_collider) that the SDK uses for raycasting.
+ */
+export function hasPointerCollider(components: Component[]): boolean {
+  const meshCollider = getComponentData(components, 'core::MeshCollider');
+  if (meshCollider && (meshCollider.collisionMask & CL_POINTER) !== 0) return true;
+
+  // GltfContainer models support pointer raycasting via their visible meshes
+  // and internal *_collider meshes, even without explicit collision masks
+  if (hasComponent(components, 'core::GltfContainer')) return true;
+
+  return false;
+}
+
+/**
+ * Check if entity has any explicit collision mask > 0 set.
+ * Uses SDK defaults when values are not specified in the composite.
+ */
+export function hasAnyCollisionMask(components: Component[]): boolean {
+  const meshCollider = getComponentData(components, 'core::MeshCollider');
+  if (meshCollider && meshCollider.collisionMask > 0) return true;
+
+  const gltf = getComponentData(components, 'core::GltfContainer');
+  if (gltf) {
+    const visibleMask = gltf.visibleMeshesCollisionMask ?? GLTF_DEFAULT_VISIBLE_MASK;
+    const invisibleMask = gltf.invisibleMeshesCollisionMask ?? GLTF_DEFAULT_INVISIBLE_MASK;
+    if (visibleMask > 0 || invisibleMask > 0) return true;
+  }
+
+  return false;
+}

packages/asset-packs/src/validation/index.ts

@@ -0,0 +1,12 @@
+import type { AssetComposite } from '../types';
+import type { ValidationError } from './rules';
+import { rules } from './rules';
+
+export type { ValidationError } from './rules';
+
+export function validateComposite(
+  components: AssetComposite['components'],
+  assetName: string,
+): ValidationError[] {
+  return rules.flatMap(rule => rule.validate(components, assetName));
+}