@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-KQCN6AKJ.cjs

@@ -0,0 +1,3042 @@
+'use strict';
+
+var chunkFEWUHQNM_cjs = require('./chunk-FEWUHQNM.cjs');
+var chunkKKP7JKN4_cjs = require('./chunk-KKP7JKN4.cjs');
+var chunkDTGBOSEM_cjs = require('./chunk-DTGBOSEM.cjs');
+var chunk6EX3I5P4_cjs = require('./chunk-6EX3I5P4.cjs');
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var ans = require('@holoscript/core-types/ans');
+
+// src/compiler/AndroidFeatureGenerators.ts
+function hasGeoTraits(composition) {
+  const geoTraitNames = [
+    "geo_anchor",
+    "geo_persist",
+    "geo_radius",
+    "geo_compass_heading",
+    "geo_altitude",
+    "geo_cloud_anchor",
+    "geo_terrain_snap",
+    "geo_session_continuity",
+    "geo_proximity_trigger",
+    "geo_discoverable",
+    "geo_arcore_geospatial",
+    "geo_arkit_geo_anchor",
+    // ARCore Geospatial API traits (M.010.15)
+    "geospatial_vps",
+    "geospatial_anchor",
+    "geospatial_terrain_anchor",
+    "geospatial_rooftop_anchor",
+    "geospatial_streetscape",
+    "geospatial_heading"
+  ];
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (geoTraitNames.includes(name)) return true;
+    }
+  }
+  return false;
+}
+function hasGeospatialVPSTraits(composition) {
+  const geospatialTraitNames = [
+    "geospatial_vps",
+    "geospatial_anchor",
+    "geospatial_terrain_anchor",
+    "geospatial_rooftop_anchor",
+    "geospatial_streetscape",
+    "geospatial_heading"
+  ];
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (geospatialTraitNames.includes(name)) return true;
+    }
+  }
+  return false;
+}
+function emitGeoAnchorSetup(compiler, composition) {
+  compiler.emit("");
+  compiler.emit("// === Geo-Anchor: GPS-pinned persistent holograms ===");
+  compiler.emit(
+    "private var fusedLocationClient: com.google.android.gms.location.FusedLocationProviderClient? = null"
+  );
+  compiler.emit("private val geoAnchors = mutableMapOf<String, Anchor>()");
+  compiler.emit("");
+  compiler.emit("private fun setupGeoAnchors() {");
+  compiler.indentLevel++;
+  compiler.emit(
+    "fusedLocationClient = com.google.android.gms.location.LocationServices.getFusedLocationProviderClient(this)"
+  );
+  compiler.emit("");
+  const usesGeospatial = compiler.compositionHasTrait(composition, "geo_arcore_geospatial");
+  if (usesGeospatial) {
+    compiler.emit("// Enable ARCore Geospatial API (VPS)");
+    compiler.emit("val session = arFragment.arSceneView.session ?: return");
+    compiler.emit("val config = session.config");
+    compiler.emit("config.geospatialMode = Config.GeospatialMode.ENABLED");
+    compiler.emit("session.configure(config)");
+    compiler.emit("");
+  }
+  for (const obj of composition.objects || []) {
+    const traits = obj.traits || [];
+    const hasGeoAnchor = traits.some((t) => {
+      const name = typeof t === "string" ? t : t.name;
+      return name === "geo_anchor";
+    });
+    if (!hasGeoAnchor) continue;
+    const geoAnchorTrait = traits.find((t) => {
+      const name = typeof t === "string" ? t : t.name;
+      return name === "geo_anchor";
+    });
+    const config = typeof geoAnchorTrait === "string" ? {} : geoAnchorTrait?.config || {};
+    const lat = config.latitude ?? 0;
+    const lng = config.longitude ?? 0;
+    const altTrait = traits.find((t) => {
+      const name = typeof t === "string" ? t : t.name;
+      return name === "geo_altitude";
+    });
+    const altConfig = typeof altTrait === "string" ? {} : altTrait?.config || {};
+    const alt = altConfig.meters ?? 0;
+    const headingTrait = traits.find((t) => {
+      const name = typeof t === "string" ? t : t.name;
+      return name === "geo_compass_heading";
+    });
+    const headingConfig = typeof headingTrait === "string" ? {} : headingTrait?.config || {};
+    const heading = headingConfig.degrees ?? 0;
+    compiler.emit(`// Geo-anchor: ${compiler.escapeStringValue(obj.name, "Kotlin")}`);
+    compiler.emit(
+      `createGeoAnchor("${compiler.escapeStringValue(obj.name, "Kotlin")}", ${lat}, ${lng}, ${alt}, ${heading}f)`
+    );
+  }
+  const usesPersist = compiler.compositionHasTrait(composition, "geo_persist");
+  const usesCloud = compiler.compositionHasTrait(composition, "geo_cloud_anchor");
+  if (usesPersist || usesCloud) {
+    compiler.emit("");
+    compiler.emit("// Restore persisted geo anchors");
+    compiler.emit("restoreGeoAnchors()");
+  }
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit(
+    "private fun createGeoAnchor(name: String, lat: Double, lng: Double, alt: Double, heading: Float) {"
+  );
+  compiler.indentLevel++;
+  compiler.emit("val session = arFragment.arSceneView.session ?: return");
+  compiler.emit("val earth = session.earth ?: return");
+  compiler.emit("if (earth.trackingState != TrackingState.TRACKING) return");
+  compiler.emit("");
+  compiler.emit(
+    "val anchor = earth.createAnchor(lat, lng, alt, 0f, 0f, Math.sin(Math.toRadians(heading.toDouble() / 2)).toFloat(), Math.cos(Math.toRadians(heading.toDouble() / 2)).toFloat())"
+  );
+  compiler.emit("geoAnchors[name] = anchor");
+  compiler.emit("");
+  compiler.emit("val anchorNode = AnchorNode(anchor)");
+  compiler.emit("anchorNode.setParent(arFragment.arSceneView.scene)");
+  compiler.emit("");
+  compiler.emit("NodeFactory.createDefaultNode(this) { renderable ->");
+  compiler.indentLevel++;
+  compiler.emit("val node = TransformableNode(arFragment.transformationSystem)");
+  compiler.emit("node.setParent(anchorNode)");
+  compiler.emit("node.renderable = renderable");
+  compiler.emit("placedNodes[name] = node");
+  compiler.emit('android.util.Log.d("HoloScript", "Geo-anchored: $name at ($lat, $lng, $alt)")');
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  if (usesPersist || usesCloud) {
+    compiler.emit("private fun saveGeoAnchorToCloud(name: String, anchor: Anchor) {");
+    compiler.indentLevel++;
+    compiler.emit("val session = arFragment.arSceneView.session ?: return");
+    compiler.emit("session.hostCloudAnchorAsync(anchor, 365) { cloudId, state ->");
+    compiler.indentLevel++;
+    compiler.emit("if (state == Anchor.CloudAnchorState.SUCCESS && cloudId != null) {");
+    compiler.indentLevel++;
+    compiler.emit('val prefs = getSharedPreferences("geo_anchors", MODE_PRIVATE)');
+    compiler.emit("prefs.edit().putString(name, cloudId).apply()");
+    compiler.emit('android.util.Log.d("HoloScript", "Cloud anchor saved: $name -> $cloudId")');
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+    compiler.emit("private fun restoreGeoAnchors() {");
+    compiler.indentLevel++;
+    compiler.emit('val prefs = getSharedPreferences("geo_anchors", MODE_PRIVATE)');
+    compiler.emit("val session = arFragment.arSceneView.session ?: return");
+    compiler.emit("for ((name, cloudId) in prefs.all) {");
+    compiler.indentLevel++;
+    compiler.emit("val id = cloudId as? String ?: continue");
+    compiler.emit("session.resolveCloudAnchorAsync(id) { anchor, state ->");
+    compiler.indentLevel++;
+    compiler.emit("if (state == Anchor.CloudAnchorState.SUCCESS && anchor != null) {");
+    compiler.indentLevel++;
+    compiler.emit("geoAnchors[name] = anchor");
+    compiler.emit("val anchorNode = AnchorNode(anchor)");
+    compiler.emit("anchorNode.setParent(arFragment.arSceneView.scene)");
+    compiler.emit('android.util.Log.d("HoloScript", "Restored cloud anchor: $name")');
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+}
+function emitGeospatialVPSSetup(compiler, composition) {
+  compiler.emit("");
+  compiler.emit("// === ARCore Geospatial API: VPS street-level geo-anchoring ===");
+  compiler.emit("private var earth: Earth? = null");
+  compiler.emit("private val geospatialAnchors = mutableMapOf<String, Anchor>()");
+  compiler.emit("");
+  compiler.emit("private fun setupGeospatialVPS() {");
+  compiler.indentLevel++;
+  compiler.emit("val session = arFragment.arSceneView.session ?: return");
+  compiler.emit("val config = session.config");
+  compiler.emit("config.geospatialMode = Config.GeospatialMode.ENABLED");
+  const usesStreetscape = compiler.compositionHasTrait(composition, "geospatial_streetscape");
+  if (usesStreetscape) {
+    compiler.emit("config.streetscapeGeometryMode = Config.StreetscapeGeometryMode.ENABLED");
+  }
+  compiler.emit("session.configure(config)");
+  compiler.emit("");
+  compiler.emit("// Monitor geospatial tracking state");
+  compiler.emit("arFragment.arSceneView.scene.addOnUpdateListener {");
+  compiler.indentLevel++;
+  compiler.emit("val sessionRef = arFragment.arSceneView.session ?: return@addOnUpdateListener");
+  compiler.emit("earth = sessionRef.earth");
+  compiler.emit("val trackingState = earth?.trackingState ?: return@addOnUpdateListener");
+  compiler.emit("if (trackingState != TrackingState.TRACKING) return@addOnUpdateListener");
+  compiler.emit("");
+  compiler.emit("val geospatialState = earth?.cameraGeospatialPose ?: return@addOnUpdateListener");
+  compiler.emit("val horizontalAccuracy = geospatialState.horizontalAccuracy");
+  compiler.emit("val headingAccuracy = geospatialState.headingAccuracy");
+  compiler.emit("");
+  compiler.emit(
+    `if (horizontalAccuracy > ${chunkDTGBOSEM_cjs.GEOSPATIAL_DEFAULTS.vps.accuracyThreshold} || headingAccuracy > ${chunkDTGBOSEM_cjs.GEOSPATIAL_DEFAULTS.vps.headingAccuracyThreshold}) {`
+  );
+  compiler.indentLevel++;
+  compiler.emit("// Accuracy not yet sufficient for anchoring");
+  compiler.emit("return@addOnUpdateListener");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit(
+    'android.util.Log.d("HoloScript", "Geospatial tracking: accuracy=$horizontalAccuracy m, heading=$headingAccuracy deg")'
+  );
+  if (usesStreetscape) {
+    compiler.emit("");
+    compiler.emit("// Process Streetscape Geometry meshes");
+    compiler.emit("processStreetscapeGeometry(sessionRef)");
+  }
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit(
+    "private fun createGeospatialAnchor(name: String, lat: Double, lng: Double, alt: Double, heading: Float) {"
+  );
+  compiler.indentLevel++;
+  compiler.emit("val earthRef = earth ?: return");
+  compiler.emit("if (earthRef.trackingState != TrackingState.TRACKING) return");
+  compiler.emit("");
+  compiler.emit(
+    "val anchor = earthRef.createAnchor(lat, lng, alt, 0f, 0f, Math.sin(Math.toRadians(heading.toDouble() / 2)).toFloat(), Math.cos(Math.toRadians(heading.toDouble() / 2)).toFloat())"
+  );
+  compiler.emit("geospatialAnchors[name] = anchor");
+  compiler.emit("");
+  compiler.emit("val anchorNode = AnchorNode(anchor)");
+  compiler.emit("anchorNode.setParent(arFragment.arSceneView.scene)");
+  compiler.emit("");
+  compiler.emit("NodeFactory.createDefaultNode(this) { renderable ->");
+  compiler.indentLevel++;
+  compiler.emit("val node = TransformableNode(arFragment.transformationSystem)");
+  compiler.emit("node.setParent(anchorNode)");
+  compiler.emit("node.renderable = renderable");
+  compiler.emit("placedNodes[name] = node");
+  compiler.emit('android.util.Log.d("HoloScript", "Geospatial anchor: $name at ($lat, $lng, $alt)")');
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  if (compiler.compositionHasTrait(composition, "geospatial_terrain_anchor")) {
+    compiler.emit(
+      "private fun resolveTerrainAnchor(name: String, lat: Double, lng: Double, altOffset: Double, heading: Float) {"
+    );
+    compiler.indentLevel++;
+    compiler.emit("val earthRef = earth ?: return");
+    compiler.emit("if (earthRef.trackingState != TrackingState.TRACKING) return");
+    compiler.emit("");
+    compiler.emit("val qx = 0f");
+    compiler.emit(
+      "val qy = Math.sin(Math.toRadians(heading.toDouble() / 2)).toFloat()"
+    );
+    compiler.emit("val qz = 0f");
+    compiler.emit(
+      "val qw = Math.cos(Math.toRadians(heading.toDouble() / 2)).toFloat()"
+    );
+    compiler.emit("");
+    compiler.emit(
+      "earthRef.resolveAnchorOnTerrainAsync(lat, lng, altOffset, qx, qy, qz, qw) { anchor, state ->"
+    );
+    compiler.indentLevel++;
+    compiler.emit("if (state == Anchor.TerrainAnchorState.SUCCESS && anchor != null) {");
+    compiler.indentLevel++;
+    compiler.emit("geospatialAnchors[name] = anchor");
+    compiler.emit("val anchorNode = AnchorNode(anchor)");
+    compiler.emit("anchorNode.setParent(arFragment.arSceneView.scene)");
+    compiler.emit("");
+    compiler.emit(
+      "NodeFactory.createDefaultNode(this@" + compiler.options.className + "Activity) { renderable ->"
+    );
+    compiler.indentLevel++;
+    compiler.emit("val node = TransformableNode(arFragment.transformationSystem)");
+    compiler.emit("node.setParent(anchorNode)");
+    compiler.emit("node.renderable = renderable");
+    compiler.emit("placedNodes[name] = node");
+    compiler.emit('android.util.Log.d("HoloScript", "Terrain anchor resolved: $name")');
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (compiler.compositionHasTrait(composition, "geospatial_rooftop_anchor")) {
+    compiler.emit(
+      "private fun resolveRooftopAnchor(name: String, lat: Double, lng: Double, altOffset: Double, heading: Float) {"
+    );
+    compiler.indentLevel++;
+    compiler.emit("val earthRef = earth ?: return");
+    compiler.emit("if (earthRef.trackingState != TrackingState.TRACKING) return");
+    compiler.emit("");
+    compiler.emit("val qx = 0f");
+    compiler.emit(
+      "val qy = Math.sin(Math.toRadians(heading.toDouble() / 2)).toFloat()"
+    );
+    compiler.emit("val qz = 0f");
+    compiler.emit(
+      "val qw = Math.cos(Math.toRadians(heading.toDouble() / 2)).toFloat()"
+    );
+    compiler.emit("");
+    compiler.emit(
+      "earthRef.resolveAnchorOnRooftopAsync(lat, lng, altOffset, qx, qy, qz, qw) { anchor, state ->"
+    );
+    compiler.indentLevel++;
+    compiler.emit("if (state == Anchor.RooftopAnchorState.SUCCESS && anchor != null) {");
+    compiler.indentLevel++;
+    compiler.emit("geospatialAnchors[name] = anchor");
+    compiler.emit("val anchorNode = AnchorNode(anchor)");
+    compiler.emit("anchorNode.setParent(arFragment.arSceneView.scene)");
+    compiler.emit("");
+    compiler.emit(
+      "NodeFactory.createDefaultNode(this@" + compiler.options.className + "Activity) { renderable ->"
+    );
+    compiler.indentLevel++;
+    compiler.emit("val node = TransformableNode(arFragment.transformationSystem)");
+    compiler.emit("node.setParent(anchorNode)");
+    compiler.emit("node.renderable = renderable");
+    compiler.emit("placedNodes[name] = node");
+    compiler.emit('android.util.Log.d("HoloScript", "Rooftop anchor resolved: $name")');
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (usesStreetscape) {
+    compiler.emit("private fun processStreetscapeGeometry(session: Session) {");
+    compiler.indentLevel++;
+    compiler.emit(
+      "val streetscapeGeometries = session.getAllTrackables(StreetscapeGeometry::class.java)"
+    );
+    compiler.emit("for (geometry in streetscapeGeometries) {");
+    compiler.indentLevel++;
+    compiler.emit("if (geometry.trackingState != TrackingState.TRACKING) continue");
+    compiler.emit("");
+    compiler.emit("val mesh = geometry.meshes.firstOrNull() ?: continue");
+    compiler.emit("val type = geometry.type");
+    compiler.emit(
+      'android.util.Log.d("HoloScript", "Streetscape geometry: type=$type, vertices=${mesh.vertexList.size}")'
+    );
+    compiler.emit("");
+    compiler.emit("// Streetscape mesh available for occlusion, raycasting, or rendering");
+    compiler.emit("// Type is TERRAIN or BUILDING");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+}
+function hasDepthScanTraits(composition) {
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (chunkDTGBOSEM_cjs.DEPTH_SCANNER_TRAITS.includes(name)) return true;
+    }
+  }
+  return false;
+}
+function emitDepthScanSetup(compiler, composition) {
+  const hasMlArcore = compiler.compositionHasTrait(composition, "depth_ml_arcore");
+  const hasConfidence = compiler.compositionHasTrait(composition, "depth_confidence_map");
+  const hasAutoSelect = compiler.compositionHasTrait(composition, "depth_auto_select");
+  const hasMeshGenerate = compiler.compositionHasTrait(composition, "depth_mesh_generate");
+  const hasMeshToHolo = compiler.compositionHasTrait(composition, "depth_mesh_to_holo");
+  const hasRealtime = compiler.compositionHasTrait(composition, "depth_realtime");
+  const hasExport = compiler.compositionHasTrait(composition, "depth_export");
+  compiler.emit("");
+  compiler.emit("// === Depth Scanner: ARCore depth, ToF, stereo (M.010.02b) ===");
+  compiler.emit(
+    `private val depthConfidenceThreshold = ${chunkDTGBOSEM_cjs.DEPTH_SCANNER_DEFAULTS.scan.confidenceThreshold}`
+  );
+  compiler.emit(`private val depthMaxMeters = ${chunkDTGBOSEM_cjs.DEPTH_SCANNER_DEFAULTS.scan.maxDepthMeters}f`);
+  compiler.emit(`private val depthMeshDecimation = ${chunkDTGBOSEM_cjs.DEPTH_SCANNER_DEFAULTS.scan.meshDecimation}f`);
+  compiler.emit("private var depthImage: android.media.Image? = null");
+  if (hasConfidence) {
+    compiler.emit("private var depthConfidenceImage: android.media.Image? = null");
+  }
+  compiler.emit("");
+  compiler.emit("private fun setupDepthScanner() {");
+  compiler.indentLevel++;
+  compiler.emit("val session = arFragment.arSceneView.session ?: return");
+  compiler.emit("val config = session.config");
+  compiler.emit("if (!session.isDepthModeSupported(Config.DepthMode.AUTOMATIC)) {");
+  compiler.indentLevel++;
+  compiler.emit(
+    'android.util.Log.w("HoloScript", "Depth scanner unavailable: ARCore DepthMode.AUTOMATIC is not supported on this device")'
+  );
+  compiler.emit("return");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("config.depthMode = Config.DepthMode.AUTOMATIC");
+  compiler.emit("session.configure(config)");
+  compiler.emit('android.util.Log.d("HoloScript", "Depth scanner: DepthMode.AUTOMATIC enabled")');
+  compiler.emit("");
+  if (hasAutoSelect) {
+    compiler.emit("// Auto-select best depth source: ToF > ARCore ML > Stereo");
+    compiler.emit("detectDepthSource()");
+    compiler.emit("");
+  }
+  if (hasRealtime) {
+    compiler.emit("// Continuous depth frame processing in render loop");
+    compiler.emit("arFragment.arSceneView.scene.addOnUpdateListener { _ ->");
+    compiler.indentLevel++;
+    compiler.emit("val frame = arFragment.arSceneView.arFrame ?: return@addOnUpdateListener");
+    compiler.emit("processDepthFrame(frame)");
+    compiler.indentLevel--;
+    compiler.emit("}");
+  }
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("private fun processDepthFrame(frame: Frame) {");
+  compiler.indentLevel++;
+  compiler.emit("try {");
+  compiler.indentLevel++;
+  if (hasMlArcore) {
+    compiler.emit("// ARCore ML depth: acquire 16-bit depth image");
+    compiler.emit("depthImage?.close()");
+    compiler.emit("depthImage = frame.acquireDepthImage16Bits()");
+  } else {
+    compiler.emit("depthImage?.close()");
+    compiler.emit("depthImage = frame.acquireDepthImage16Bits()");
+  }
+  if (hasConfidence) {
+    compiler.emit("");
+    compiler.emit("// Confidence map: per-pixel confidence (0-255)");
+    compiler.emit("depthConfidenceImage?.close()");
+    compiler.emit("depthConfidenceImage = frame.acquireRawDepthConfidenceImage()");
+  }
+  if (hasMeshGenerate) {
+    compiler.emit("");
+    compiler.emit("val depthImg = depthImage ?: return");
+    compiler.emit("generateMeshFromDepth(depthImg)");
+  }
+  compiler.indentLevel--;
+  compiler.emit("} catch (e: Exception) {");
+  compiler.indentLevel++;
+  compiler.emit('android.util.Log[3]("HoloScript", "Depth frame unavailable: ${e.message}")');
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  if (hasAutoSelect) {
+    compiler.emit("private fun detectDepthSource() {");
+    compiler.indentLevel++;
+    compiler.emit("val session = arFragment.arSceneView.session ?: return");
+    compiler.emit("");
+    compiler.emit("// Check ToF sensor availability");
+    compiler.emit(
+      'val hasToF = packageManager.hasSystemFeature("android.hardware.sensor.proximity")'
+    );
+    compiler.emit("");
+    compiler.emit("// Check ARCore depth support");
+    compiler.emit("val hasARCoreDepth = session.isDepthModeSupported(Config.DepthMode.AUTOMATIC)");
+    compiler.emit("");
+    compiler.emit("// Check dual camera for stereo depth");
+    compiler.emit(
+      "val cameraManager = getSystemService(android.hardware.camera2.CameraManager::class.java)"
+    );
+    compiler.emit("val hasStereo = (cameraManager?.cameraIdList?.size ?: 0) >= 2");
+    compiler.emit("");
+    compiler.emit("// Priority: ToF > ARCore ML > Stereo");
+    compiler.emit("val depthSource = when {");
+    compiler.indentLevel++;
+    compiler.emit('hasToF -> "ToF"');
+    compiler.emit('hasARCoreDepth -> "ARCore_ML"');
+    compiler.emit('hasStereo -> "Stereo"');
+    compiler.emit('else -> "None"');
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit(
+      'android.util.Log.d("HoloScript", "Depth source selected: $depthSource (ToF=$hasToF, ARCore=$hasARCoreDepth, Stereo=$hasStereo)")'
+    );
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (hasMeshGenerate) {
+    compiler.emit("private fun generateMeshFromDepth(depthImage: android.media.Image) {");
+    compiler.indentLevel++;
+    compiler.emit("val width = depthImage.width");
+    compiler.emit("val height = depthImage.height");
+    compiler.emit("val buffer = depthImage.planes[0].buffer");
+    compiler.emit("val vertices = mutableListOf<Vector3>()");
+    compiler.emit("val indices = mutableListOf<Int>()");
+    compiler.emit("");
+    compiler.emit("// Convert depth pixels to 3D points with decimation");
+    compiler.emit("val step = (1.0f / depthMeshDecimation).toInt().coerceAtLeast(1)");
+    compiler.emit("for (y in 0 until height step step) {");
+    compiler.indentLevel++;
+    compiler.emit("for (x in 0 until width step step) {");
+    compiler.indentLevel++;
+    compiler.emit("val depthMm = buffer.getShort((y * width + x) * 2).toInt() and 0xFFFF");
+    compiler.emit("val depthM = depthMm / 1000.0f");
+    compiler.emit("if (depthM <= 0f || depthM > depthMaxMeters) continue");
+    compiler.emit("");
+    compiler.emit("// Unproject pixel to 3D point (simplified pinhole model)");
+    compiler.emit("val fx = width / 2.0f  // focal length approximation");
+    compiler.emit("val fy = height / 2.0f");
+    compiler.emit("val cx = width / 2.0f");
+    compiler.emit("val cy = height / 2.0f");
+    compiler.emit("val px = (x - cx) / fx * depthM");
+    compiler.emit("val py = (y - cy) / fy * depthM");
+    compiler.emit("vertices.add(Vector3(px, py, depthM))");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+    compiler.emit("// Triangulate adjacent points into mesh");
+    compiler.emit("val cols = width / step");
+    compiler.emit("for (row in 0 until (vertices.size / cols) - 1) {");
+    compiler.indentLevel++;
+    compiler.emit("for (col in 0 until cols - 1) {");
+    compiler.indentLevel++;
+    compiler.emit("val i = row * cols + col");
+    compiler.emit("indices.add(i)");
+    compiler.emit("indices.add(i + 1)");
+    compiler.emit("indices.add(i + cols)");
+    compiler.emit("indices.add(i + 1)");
+    compiler.emit("indices.add(i + cols + 1)");
+    compiler.emit("indices.add(i + cols)");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+    compiler.emit(
+      'android.util.Log.d("HoloScript", "Depth mesh: ${vertices.size} vertices, ${indices.size / 3} triangles")'
+    );
+    if (hasMeshToHolo) {
+      compiler.emit("convertMeshToHolo(vertices, indices)");
+    }
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (hasMeshToHolo) {
+    compiler.emit("private fun convertMeshToHolo(vertices: List<Vector3>, indices: List<Int>) {");
+    compiler.indentLevel++;
+    compiler.emit("// Convert mesh vertices + classification to HoloScript entities");
+    compiler.emit("val holoEntities = mutableListOf<Map<String, Any>>()");
+    compiler.emit("for ((i, vertex) in vertices.withIndex()) {");
+    compiler.indentLevel++;
+    compiler.emit("holoEntities.add(mapOf(");
+    compiler.indentLevel++;
+    compiler.emit('"type" to "DepthPoint",');
+    compiler.emit('"id" to "dp_$i",');
+    compiler.emit('"position" to listOf(vertex[0], vertex[1], vertex[2]),');
+    compiler.emit('"classification" to "unknown"');
+    compiler.indentLevel--;
+    compiler.emit("))");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit(
+      'android.util.Log.d("HoloScript", "Converted ${holoEntities.size} depth points to .holo entities")'
+    );
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (hasExport) {
+    const format = chunkDTGBOSEM_cjs.DEPTH_SCANNER_DEFAULTS.export.format;
+    compiler.emit("private fun exportDepthMesh(vertices: List<Vector3>, indices: List<Int>) {");
+    compiler.indentLevel++;
+    compiler.emit(`val format = "${format}"`);
+    compiler.emit('val filename = "depth_scan_${System.currentTimeMillis()}.$format"');
+    compiler.emit("val file = java.io.File(getExternalFilesDir(null), filename)");
+    compiler.emit("");
+    compiler.emit('if (format == "obj") {');
+    compiler.indentLevel++;
+    compiler.emit("val sb = StringBuilder()");
+    compiler.emit('sb.appendLine("# HoloScript Depth Scan Export")');
+    compiler.emit("for (v in vertices) {");
+    compiler.indentLevel++;
+    compiler.emit('sb.appendLine("v ${v[0]} ${v[1]} ${v[2]}")');
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("for (i in indices.indices step 3) {");
+    compiler.indentLevel++;
+    compiler.emit('sb.appendLine("f ${indices[i]+1} ${indices[i+1]+1} ${indices[i+2]+1}")');
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("file.writeText(sb.toString())");
+    compiler.indentLevel--;
+    compiler.emit("} else {");
+    compiler.indentLevel++;
+    compiler.emit("// GLB export: binary glTF format");
+    compiler.emit('android.util.Log.d("HoloScript", "GLB export requires glTF serializer library")');
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+    compiler.emit('android.util.Log.d("HoloScript", "Depth mesh exported: ${file.absolutePath}")');
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+}
+function hasPortalARTraits(composition) {
+  const portalNames = chunk6EX3I5P4_cjs.PORTAL_AR_TRAITS;
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (portalNames.includes(name)) return true;
+    }
+  }
+  return false;
+}
+function emitPortalARSetup(compiler, composition) {
+  compiler.emit("");
+  compiler.emit("// === Portal AR: full-scene holographic layer behind reality ===");
+  compiler.emit("private var portalSession: Session? = null");
+  compiler.emit("private var portalRenderer: HolographicRenderer? = null");
+  compiler.emit("private var depthTexture: Image? = null");
+  compiler.emit("private var sceneMesh: Mesh? = null");
+  compiler.emit("");
+  compiler.emit("private fun setupPortalAR() {");
+  compiler.indentLevel++;
+  compiler.emit("val session = arFragment.arSceneView.session ?: return");
+  compiler.emit("");
+  compiler.emit("// Enable depth mode for portal occlusion");
+  compiler.emit("val config = Config(session)");
+  compiler.emit("config.depthMode = Config.DepthMode.AUTOMATIC");
+  compiler.emit("config.lightEstimationMode = Config.LightEstimationMode.ENVIRONMENTAL_HDR");
+  if (compiler.compositionHasTrait(composition, "portal_world_mesh") || compiler.compositionHasTrait(composition, "portal_mesh_occlusion")) {
+    compiler.emit("config.planeFindingMode = Config.PlaneFindingMode.HORIZONTAL_AND_VERTICAL");
+    compiler.emit("// Enable scene mesh for portal world mesh integration");
+    compiler.emit("if (session.isDepthModeSupported(Config.DepthMode.AUTOMATIC)) {");
+    compiler.indentLevel++;
+    compiler.emit("config.depthMode = Config.DepthMode.AUTOMATIC");
+    compiler.indentLevel--;
+    compiler.emit("}");
+  }
+  compiler.emit("session.configure(config)");
+  compiler.emit("portalSession = session");
+  compiler.emit("");
+  compiler.emit("// Create holographic render layer behind reality");
+  compiler.emit("portalRenderer = HolographicRenderer(this)");
+  compiler.emit("portalRenderer?.initialize(session)");
+  compiler.emit("");
+  if (compiler.compositionHasTrait(composition, "portal_occlusion")) {
+    compiler.emit("// Portal occlusion: real objects block holograms via depth buffer");
+    compiler.emit("arFragment.arSceneView.scene.addOnUpdateListener { _ ->");
+    compiler.indentLevel++;
+    compiler.emit("val frame = arFragment.arSceneView.arFrame ?: return@addOnUpdateListener");
+    compiler.emit("try {");
+    compiler.indentLevel++;
+    compiler.emit("depthTexture = frame.acquireDepthImage16Bits()");
+    compiler.emit("portalRenderer?.updateDepthOcclusion(depthTexture!!)");
+    compiler.indentLevel--;
+    compiler.emit("} catch (e: Exception) {");
+    compiler.indentLevel++;
+    compiler.emit("// Depth not available on this frame");
+    compiler.indentLevel--;
+    compiler.emit("} finally {");
+    compiler.indentLevel++;
+    compiler.emit("depthTexture?.close()");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (compiler.compositionHasTrait(composition, "portal_parallax")) {
+    compiler.emit("// Portal parallax: depth-correct parallax from device pose");
+    compiler.emit("arFragment.arSceneView.scene.addOnUpdateListener { _ ->");
+    compiler.indentLevel++;
+    compiler.emit("val frame = arFragment.arSceneView.arFrame ?: return@addOnUpdateListener");
+    compiler.emit("val cameraPose = frame.camera.pose");
+    compiler.emit("portalRenderer?.applyParallaxCorrection(cameraPose)");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (compiler.compositionHasTrait(composition, "portal_depth_fade")) {
+    compiler.emit("// Portal depth fade: holograms fade at distance");
+    compiler.emit("portalRenderer?.enableDepthFade(nearPlane = 0.1f, farPlane = 10.0f)");
+    compiler.emit("");
+  }
+  if (compiler.compositionHasTrait(composition, "portal_world_mesh") || compiler.compositionHasTrait(composition, "portal_mesh_occlusion")) {
+    compiler.emit("// Portal world mesh: scene mesh for realistic occlusion");
+    compiler.emit("arFragment.arSceneView.scene.addOnUpdateListener { _ ->");
+    compiler.indentLevel++;
+    compiler.emit("val frame = arFragment.arSceneView.arFrame ?: return@addOnUpdateListener");
+    compiler.emit("try {");
+    compiler.indentLevel++;
+    compiler.emit("val rawDepth = frame.acquireRawDepthImage16Bits()");
+    compiler.emit("sceneMesh = portalRenderer?.reconstructMesh(rawDepth)");
+    compiler.emit("portalRenderer?.updateMeshOcclusion(sceneMesh!!)");
+    compiler.emit("rawDepth.close()");
+    compiler.indentLevel--;
+    compiler.emit("} catch (e: Exception) { /* depth not available */ }");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (compiler.compositionHasTrait(composition, "portal_peek_through")) {
+    compiler.emit("// Portal peek through: tilt phone to reveal holographic layer");
+    compiler.emit("val sensorManager = getSystemService(SENSOR_SERVICE) as SensorManager");
+    compiler.emit("val accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)");
+    compiler.emit("val portalTiltThreshold = 30.0f // degrees");
+    compiler.emit("sensorManager.registerListener(object : SensorEventListener {");
+    compiler.indentLevel++;
+    compiler.emit("override fun onSensorChanged(event: SensorEvent) {");
+    compiler.indentLevel++;
+    compiler.emit(
+      "val tiltAngle = Math.toDegrees(Math.atan2(event.values[1].toDouble(), event.values[2].toDouble())).toFloat()"
+    );
+    compiler.emit("portalRenderer?.setPortalVisibility(Math.abs(tiltAngle) > portalTiltThreshold)");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {}");
+    compiler.indentLevel--;
+    compiler.emit("}, accelerometer, SensorManager.SENSOR_DELAY_UI)");
+    compiler.emit("");
+  }
+  if (compiler.compositionHasTrait(composition, "portal_boundary")) {
+    compiler.emit("// Portal boundary: configurable shape (circle/rect)");
+    compiler.emit("val portalBoundary = PortalBoundary()");
+    compiler.emit("portalBoundary.shape = PortalBoundary.Shape.CIRCLE // configurable");
+    compiler.emit("portalBoundary.radius = 1.5f");
+    compiler.emit("portalRenderer?.setBoundary(portalBoundary)");
+    compiler.emit("");
+  }
+  if (compiler.compositionHasTrait(composition, "portal_lighting_match")) {
+    compiler.emit("// Portal lighting match: use ARCore light estimation");
+    compiler.emit("arFragment.arSceneView.scene.addOnUpdateListener { _ ->");
+    compiler.indentLevel++;
+    compiler.emit("val frame = arFragment.arSceneView.arFrame ?: return@addOnUpdateListener");
+    compiler.emit("val lightEstimate = frame.lightEstimate");
+    compiler.emit("if (lightEstimate != null && lightEstimate.state == LightEstimate.State.VALID) {");
+    compiler.indentLevel++;
+    compiler.emit("val intensity = lightEstimate.pixelIntensity");
+    compiler.emit("val colorCorrection = FloatArray(4)");
+    compiler.emit("lightEstimate.getColorCorrection(colorCorrection, 0)");
+    compiler.emit("portalRenderer?.updateLighting(intensity, colorCorrection)");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  compiler.emit('print("[HoloScript] Portal AR initialized")');
+  compiler.indentLevel--;
+  compiler.emit("}");
+}
+function hasHandTrackingTraits(composition) {
+  const handTraitNames = chunk6EX3I5P4_cjs.CAMERA_HAND_TRACKING_TRAITS;
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (handTraitNames.includes(name)) return true;
+    }
+  }
+  return false;
+}
+function emitHandTrackingSetup(compiler, composition) {
+  compiler.emit("");
+  compiler.emit("// === Camera Hand Tracking: MediaPipe Hands (M.010.04) ===");
+  compiler.emit("private var handsolution: com.google.mediapipe.solutions.hands.Hands? = null");
+  compiler.emit("");
+  const twoHands = compiler.compositionHasTrait(composition, "camera_hand_two_hands");
+  const maxHands = twoHands ? 2 : 1;
+  const hasPinch = compiler.compositionHasTrait(composition, "camera_hand_gesture_pinch");
+  const hasPoint = compiler.compositionHasTrait(composition, "camera_hand_gesture_point");
+  const hasPalm = compiler.compositionHasTrait(composition, "camera_hand_gesture_palm");
+  const hasFist = compiler.compositionHasTrait(composition, "camera_hand_gesture_fist");
+  const hasConfidence = compiler.compositionHasTrait(composition, "camera_hand_confidence");
+  const hasSkeleton = compiler.compositionHasTrait(composition, "camera_hand_skeleton");
+  const hasToSpatial = compiler.compositionHasTrait(composition, "camera_hand_to_spatial");
+  compiler.emit("private fun setupHandTracking() {");
+  compiler.indentLevel++;
+  compiler.emit("val options = com.google.mediapipe.solutions.hands.HandsOptions.builder()");
+  compiler.emit(`    .setMaxNumHands(${maxHands})`);
+  compiler.emit("    .setStaticImageMode(false)");
+  compiler.emit(
+    "    .setRunningMode(com.google.mediapipe.solutions.hands.Hands.RUNNING_MODE_LIVE_STREAM)"
+  );
+  if (hasConfidence) {
+    compiler.emit("    .setMinHandDetectionConfidence(0.7f)");
+  } else {
+    compiler.emit("    .setMinHandDetectionConfidence(0.5f)");
+  }
+  compiler.emit("    .setMinTrackingConfidence(0.5f)");
+  compiler.emit("    .build()");
+  compiler.emit("");
+  compiler.emit("handsolution = com.google.mediapipe.solutions.hands.Hands(this, options)");
+  compiler.emit("handsolution?.setResultListener { result ->");
+  compiler.indentLevel++;
+  compiler.emit("processHandResults(result)");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("// Start CameraX front camera feed");
+  compiler.emit("startCameraForHandTracking()");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("private fun startCameraForHandTracking() {");
+  compiler.indentLevel++;
+  compiler.emit(
+    "val cameraProviderFuture = androidx.camera.lifecycle.ProcessCameraProvider.getInstance(this)"
+  );
+  compiler.emit("cameraProviderFuture.addListener({");
+  compiler.indentLevel++;
+  compiler.emit("val cameraProvider = cameraProviderFuture.get()");
+  compiler.emit("val preview = androidx.camera.core.Preview.Builder().build()");
+  compiler.emit("val imageAnalysis = androidx.camera.core.ImageAnalysis.Builder()");
+  compiler.emit(
+    "    .setBackpressureStrategy(androidx.camera.core.ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)"
+  );
+  compiler.emit("    .build()");
+  compiler.emit(
+    "imageAnalysis.setAnalyzer(java.util.concurrent.Executors.newSingleThreadExecutor()) { imageProxy ->"
+  );
+  compiler.indentLevel++;
+  compiler.emit("handsolution?.send(imageProxy)");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("val cameraSelector = androidx.camera.core.CameraSelector.DEFAULT_FRONT_CAMERA");
+  compiler.emit("cameraProvider.unbindAll()");
+  compiler.emit("cameraProvider.bindToLifecycle(this, cameraSelector, preview, imageAnalysis)");
+  compiler.indentLevel--;
+  compiler.emit("}, androidx.core.content.ContextCompat.getMainExecutor(this))");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit(
+    "private fun processHandResults(result: com.google.mediapipe.solutions.hands.HandsResult) {"
+  );
+  compiler.indentLevel++;
+  compiler.emit("if (result.multiHandLandmarks().isEmpty()) return");
+  compiler.emit("");
+  compiler.emit("for ((handIndex, landmarks) in result.multiHandLandmarks().withIndex()) {");
+  compiler.indentLevel++;
+  if (hasSkeleton) {
+    compiler.emit("// 21-joint skeleton data");
+    compiler.emit("val wrist = landmarks.landmarkList[0]");
+    compiler.emit("val thumbCmc = landmarks.landmarkList[1]");
+    compiler.emit("val thumbMcp = landmarks.landmarkList[2]");
+    compiler.emit("val thumbIp = landmarks.landmarkList[3]");
+    compiler.emit("val thumbTip = landmarks.landmarkList[4]");
+    compiler.emit("val indexMcp = landmarks.landmarkList[5]");
+    compiler.emit("val indexPip = landmarks.landmarkList[6]");
+    compiler.emit("val indexDip = landmarks.landmarkList[7]");
+    compiler.emit("val indexTip = landmarks.landmarkList[8]");
+    compiler.emit("val middleMcp = landmarks.landmarkList[9]");
+    compiler.emit("val middlePip = landmarks.landmarkList[10]");
+    compiler.emit("val middleDip = landmarks.landmarkList[11]");
+    compiler.emit("val middleTip = landmarks.landmarkList[12]");
+    compiler.emit("val ringMcp = landmarks.landmarkList[13]");
+    compiler.emit("val ringPip = landmarks.landmarkList[14]");
+    compiler.emit("val ringDip = landmarks.landmarkList[15]");
+    compiler.emit("val ringTip = landmarks.landmarkList[16]");
+    compiler.emit("val pinkyMcp = landmarks.landmarkList[17]");
+    compiler.emit("val pinkyPip = landmarks.landmarkList[18]");
+    compiler.emit("val pinkyDip = landmarks.landmarkList[19]");
+    compiler.emit("val pinkyTip = landmarks.landmarkList[20]");
+    compiler.emit("");
+  } else {
+    compiler.emit("// Key landmarks for gesture recognition");
+    compiler.emit("val thumbTip = landmarks.landmarkList[4]");
+    compiler.emit("val indexMcp = landmarks.landmarkList[5]");
+    compiler.emit("val indexPip = landmarks.landmarkList[6]");
+    compiler.emit("val indexTip = landmarks.landmarkList[8]");
+    compiler.emit("val middleMcp = landmarks.landmarkList[9]");
+    compiler.emit("val middlePip = landmarks.landmarkList[10]");
+    compiler.emit("val middleTip = landmarks.landmarkList[12]");
+    compiler.emit("val ringMcp = landmarks.landmarkList[13]");
+    compiler.emit("val ringPip = landmarks.landmarkList[14]");
+    compiler.emit("val ringTip = landmarks.landmarkList[16]");
+    compiler.emit("val pinkyMcp = landmarks.landmarkList[17]");
+    compiler.emit("val pinkyPip = landmarks.landmarkList[18]");
+    compiler.emit("val pinkyTip = landmarks.landmarkList[20]");
+    compiler.emit("");
+  }
+  if (hasConfidence) {
+    compiler.emit("// Filter low-confidence landmarks");
+    compiler.emit("val minConfidence = 0.7f");
+    compiler.emit(
+      "if (thumbTip.visibility < minConfidence || indexTip.visibility < minConfidence) {"
+    );
+    compiler.indentLevel++;
+    compiler.emit("continue");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (hasPinch) {
+    compiler.emit("// Pinch gesture: thumb tip close to index tip");
+    compiler.emit("val pinchDist = Math.sqrt(");
+    compiler.emit(
+      "    Math.pow((thumbTip[0] - indexTip[0]).toDouble(), 2.0) +"
+    );
+    compiler.emit("    Math.pow((thumbTip[1] - indexTip[1]).toDouble(), 2.0)");
+    compiler.emit(").toFloat()");
+    compiler.emit("if (pinchDist < 0.05f) {");
+    compiler.indentLevel++;
+    compiler.emit('android.util.Log.d("HoloScript", "Hand $handIndex: PINCH detected")');
+    if (hasToSpatial) {
+      compiler.emit('onSpatialInput("pinch", handIndex, thumbTip[0], thumbTip[1], thumbTip[2])');
+    }
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (hasPoint) {
+    compiler.emit("// Point gesture: index extended, others curled");
+    compiler.emit("val indexExtended = indexTip[1] < indexMcp[1]");
+    compiler.emit("val middleCurled = middleTip[1] > middlePip[1]");
+    compiler.emit("val ringCurled = ringTip[1] > ringPip[1]");
+    compiler.emit("val pinkyCurled = pinkyTip[1] > pinkyPip[1]");
+    compiler.emit("if (indexExtended && middleCurled && ringCurled && pinkyCurled) {");
+    compiler.indentLevel++;
+    compiler.emit('android.util.Log.d("HoloScript", "Hand $handIndex: POINT detected")');
+    if (hasToSpatial) {
+      compiler.emit('onSpatialInput("point", handIndex, indexTip[0], indexTip[1], indexTip[2])');
+    }
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (hasPalm) {
+    compiler.emit("// Palm gesture: all fingertips above MCPs (open hand)");
+    compiler.emit("val allExtended = indexTip[1] < indexMcp[1] && middleTip[1] < middleMcp[1] &&");
+    compiler.emit("    ringTip[1] < ringMcp[1] && pinkyTip[1] < pinkyMcp[1]");
+    compiler.emit("if (allExtended) {");
+    compiler.indentLevel++;
+    compiler.emit('android.util.Log.d("HoloScript", "Hand $handIndex: PALM detected")');
+    if (hasToSpatial) {
+      compiler.emit('onSpatialInput("palm", handIndex, indexTip[0], indexTip[1], indexTip[2])');
+    }
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (hasFist) {
+    compiler.emit("// Fist gesture: all fingertips below PIPs (closed hand)");
+    compiler.emit("val allCurled = indexTip[1] > indexPip[1] && middleTip[1] > middlePip[1] &&");
+    compiler.emit("    ringTip[1] > ringPip[1] && pinkyTip[1] > pinkyPip[1]");
+    compiler.emit("if (allCurled) {");
+    compiler.indentLevel++;
+    compiler.emit('android.util.Log.d("HoloScript", "Hand $handIndex: FIST detected")');
+    if (hasToSpatial) {
+      compiler.emit('onSpatialInput("fist", handIndex, indexTip[0], indexTip[1], indexTip[2])');
+    }
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  if (hasToSpatial) {
+    compiler.emit("");
+    compiler.emit(
+      "private fun onSpatialInput(gesture: String, handIndex: Int, x: Float, y: Float, z: Float) {"
+    );
+    compiler.indentLevel++;
+    compiler.emit("// Bridge to HoloScript spatial_input event system");
+    compiler.emit("val event = mapOf(");
+    compiler.indentLevel++;
+    compiler.emit('"type" to "hand_gesture",');
+    compiler.emit('"gesture" to gesture,');
+    compiler.emit('"handIndex" to handIndex,');
+    compiler.emit('"x" to x, "y" to y, "z" to z');
+    compiler.indentLevel--;
+    compiler.emit(")");
+    compiler.emit('android.util.Log.d("HoloScript", "SpatialInput: $event")');
+    compiler.indentLevel--;
+    compiler.emit("}");
+  }
+}
+function hasAuthoringTraits(composition) {
+  const authoringNames = chunkDTGBOSEM_cjs.SPATIAL_AUTHORING_TRAITS;
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (authoringNames.includes(name)) return true;
+    }
+  }
+  return false;
+}
+function emitAuthoringSetup(compiler, composition) {
+  compiler.lines = [];
+  compiler.indentLevel = 0;
+  compiler.emit("// === Spatial Authoring Setup (M.010.08) ===");
+  compiler.emit("");
+  const hasGyro = compiler.compositionHasTrait(composition, "author_gyro_place");
+  const hasPinch = compiler.compositionHasTrait(composition, "author_pinch_scale");
+  const hasSwipe = compiler.compositionHasTrait(composition, "author_swipe_browse");
+  const hasVoice = compiler.compositionHasTrait(composition, "author_voice_cmd");
+  const hasShake = compiler.compositionHasTrait(composition, "author_shake_undo");
+  if (hasGyro) {
+    compiler.emit(`private val gyroFilterAlpha = ${chunkDTGBOSEM_cjs.SPATIAL_AUTHORING_DEFAULTS.gyroFilterAlpha}f`);
+    compiler.emit("private var sensorManager: android.hardware.SensorManager? = null");
+    compiler.emit("private var rotationSensor: android.hardware.Sensor? = null");
+  }
+  if (hasPinch) {
+    compiler.emit(`private val pinchScaleMin = ${chunkDTGBOSEM_cjs.SPATIAL_AUTHORING_DEFAULTS.pinchScaleMin}f`);
+    compiler.emit(`private val pinchScaleMax = ${chunkDTGBOSEM_cjs.SPATIAL_AUTHORING_DEFAULTS.pinchScaleMax}f`);
+    compiler.emit("private var scaleGestureDetector: android.view.ScaleGestureDetector? = null");
+  }
+  if (hasSwipe) {
+    compiler.emit("private var gestureDetector: android.view.GestureDetector? = null");
+  }
+  if (hasVoice) {
+    compiler.emit(`private val speechLocale = "${chunkDTGBOSEM_cjs.SPATIAL_AUTHORING_DEFAULTS.speechLocale}"`);
+    compiler.emit("private var speechRecognizer: android.speech.SpeechRecognizer? = null");
+  }
+  if (hasShake) {
+    compiler.emit(`private val shakeThreshold = ${chunkDTGBOSEM_cjs.SPATIAL_AUTHORING_DEFAULTS.shakeThreshold}f`);
+    compiler.emit(`private val undoStackDepth = ${chunkDTGBOSEM_cjs.SPATIAL_AUTHORING_DEFAULTS.undoStackDepth}`);
+    compiler.emit("private val undoStack = ArrayDeque<() -> Unit>()");
+  }
+  return compiler.lines.join("\n");
+}
+function emitAuthoringInlineSetup(compiler, composition) {
+  compiler.emit("");
+  compiler.emit("// --- Spatial Authoring inline setup (M.010.08) ---");
+  if (compiler.compositionHasTrait(composition, "author_gyro_place")) {
+    compiler.emit("private fun setupGyroPlacement() {");
+    compiler.indentLevel++;
+    compiler.emit(
+      "sensorManager = getSystemService(SENSOR_SERVICE) as android.hardware.SensorManager"
+    );
+    compiler.emit(
+      "rotationSensor = sensorManager?.getDefaultSensor(android.hardware.Sensor.TYPE_ROTATION_VECTOR)"
+    );
+    compiler.indentLevel--;
+    compiler.emit("}");
+  }
+  if (compiler.compositionHasTrait(composition, "author_pinch_scale")) {
+    compiler.emit("private fun setupPinchScale() {");
+    compiler.indentLevel++;
+    compiler.emit(
+      "scaleGestureDetector = android.view.ScaleGestureDetector(this, object : android.view.ScaleGestureDetector.SimpleOnScaleGestureListener() {"
+    );
+    compiler.indentLevel++;
+    compiler.emit("override fun onScale(detector: android.view.ScaleGestureDetector): Boolean {");
+    compiler.indentLevel++;
+    compiler.emit("val factor = detector.scaleFactor.coerceIn(pinchScaleMin, pinchScaleMax)");
+    compiler.emit("selectedNode?.localScale = selectedNode?.localScale?.let { it.scaled(factor) }");
+    compiler.emit("return true");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("})");
+    compiler.indentLevel--;
+    compiler.emit("}");
+  }
+  if (compiler.compositionHasTrait(composition, "author_shake_undo")) {
+    compiler.emit("private fun setupShakeUndo() {");
+    compiler.indentLevel++;
+    compiler.emit(
+      "val accelerometer = sensorManager?.getDefaultSensor(android.hardware.Sensor.TYPE_ACCELEROMETER)"
+    );
+    compiler.emit("// Shake detection triggers undoStack.removeLastOrNull()?.invoke()");
+    compiler.indentLevel--;
+    compiler.emit("}");
+  }
+}
+function hasNPUSceneTraits(composition) {
+  const npuNames = chunk6EX3I5P4_cjs.NPU_SCENE_TRAITS;
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (npuNames.includes(name)) return true;
+    }
+  }
+  return false;
+}
+function emitNPUSceneSetup(compiler, composition) {
+  compiler.lines = [];
+  compiler.indentLevel = 0;
+  const pkg = compiler.options.packageName;
+  const cls = compiler.options.className;
+  const defaults = chunk6EX3I5P4_cjs.NPU_SCENE_DEFAULTS;
+  const usedTraits = /* @__PURE__ */ new Set();
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (chunk6EX3I5P4_cjs.NPU_SCENE_TRAITS.includes(name)) {
+        usedTraits.add(name);
+      }
+    }
+  }
+  compiler.emit("// Auto-generated by HoloScript AndroidCompiler \u2014 NPU Scene Understanding");
+  compiler.emit(
+    `// Source: composition "${compiler.escapeStringValue(composition.name, "Kotlin")}"`
+  );
+  compiler.emit("// Requires ML Kit, CameraX, NNAPI delegate");
+  compiler.emit("// Do not edit manually \u2014 regenerate from .holo source");
+  compiler.emit("");
+  compiler.emit(`package ${pkg}`);
+  compiler.emit("");
+  compiler.emit("import android.graphics.Bitmap");
+  compiler.emit("import android.graphics.Rect");
+  compiler.emit("import android.util.Log");
+  compiler.emit("import android.util.Size");
+  compiler.emit("import androidx.camera.core.ImageAnalysis");
+  compiler.emit("import androidx.camera.core.ImageProxy");
+  compiler.emit("import androidx.lifecycle.ViewModel");
+  compiler.emit("import androidx.lifecycle.viewModelScope");
+  compiler.emit("import kotlinx.coroutines.flow.MutableStateFlow");
+  compiler.emit("import kotlinx.coroutines.flow.StateFlow");
+  compiler.emit("import kotlinx.coroutines.launch");
+  if (usedTraits.has("npu_detect")) {
+    compiler.emit("import com.google.mlkit.vision.common.InputImage");
+    compiler.emit("import com.google.mlkit.vision.objects.ObjectDetection");
+    compiler.emit("import com.google.mlkit.vision.objects.ObjectDetector");
+    compiler.emit("import com.google.mlkit.vision.objects.defaults.ObjectDetectorOptions");
+  }
+  if (usedTraits.has("npu_classify")) {
+    compiler.emit("import com.google.mlkit.vision.common.InputImage");
+    compiler.emit("import com.google.mlkit.vision.label.ImageLabeling");
+    compiler.emit("import com.google.mlkit.vision.label.ImageLabeler");
+    compiler.emit("import com.google.mlkit.vision.label.defaults.ImageLabelerOptions");
+  }
+  if (usedTraits.has("npu_segment")) {
+    compiler.emit("import com.google.mlkit.vision.segmentation.Segmentation");
+    compiler.emit("import com.google.mlkit.vision.segmentation.selfie.SelfieSegmenterOptions");
+  }
+  if (usedTraits.has("npu_model_custom")) {
+    compiler.emit("import org.tensorflow.lite.Interpreter");
+    compiler.emit("import org.tensorflow.lite.nnapi.NnApiDelegate");
+    compiler.emit("import com.google.mlkit.common.model.LocalModel");
+  }
+  compiler.emit("");
+  compiler.emit("/** A single detection result from NPU scene understanding. */");
+  compiler.emit("data class NPUDetection(");
+  compiler.indentLevel++;
+  compiler.emit("val label: String,");
+  compiler.emit("val confidence: Float,");
+  compiler.emit("val boundingBox: Rect? = null,");
+  compiler.emit("val position: FloatArray? = null,");
+  compiler.emit("val segmentationMask: Bitmap? = null,");
+  compiler.emit("val depthValue: Float? = null");
+  compiler.indentLevel--;
+  compiler.emit(")");
+  compiler.emit("");
+  compiler.emit(`class ${cls}NPUSceneManager : ViewModel() {`);
+  compiler.indentLevel++;
+  compiler.emit("");
+  compiler.emit("private val _detections = MutableStateFlow<List<NPUDetection>>(emptyList())");
+  compiler.emit("val detections: StateFlow<List<NPUDetection>> = _detections");
+  compiler.emit("");
+  compiler.emit("private val _isProcessing = MutableStateFlow(false)");
+  compiler.emit("val isProcessing: StateFlow<Boolean> = _isProcessing");
+  compiler.emit("");
+  compiler.emit("private var inferenceCount: Int = 0");
+  compiler.emit(`private val confidenceThreshold: Float = ${defaults.confidenceThreshold}f`);
+  compiler.emit(`private val maxDetections: Int = ${defaults.maxDetections}`);
+  compiler.emit(`private val targetFPS: Int = ${defaults.targetFPS}`);
+  compiler.emit(`private val entityScale: Float = ${defaults.entityScale}f`);
+  compiler.emit(`private val labelOffsetY: Float = ${defaults.labelOffsetY}f`);
+  compiler.emit("private var frameCounter: Int = 0");
+  compiler.emit("private var lastProcessTimeMs: Long = 0");
+  compiler.emit("");
+  if (usedTraits.has("npu_detect")) {
+    compiler.emit("// MARK: Object Detection (npu_detect)");
+    compiler.emit("");
+    compiler.emit("private val objectDetector: ObjectDetector by lazy {");
+    compiler.indentLevel++;
+    compiler.emit("val options = ObjectDetectorOptions.Builder()");
+    compiler.emit("    .setDetectorMode(ObjectDetectorOptions.STREAM_MODE)");
+    compiler.emit("    .enableMultipleObjects()");
+    compiler.emit("    .enableClassification()");
+    compiler.emit("    .build()");
+    compiler.emit("ObjectDetection.getClient(options)");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+    compiler.emit("fun detectObjects(image: InputImage) {");
+    compiler.indentLevel++;
+    compiler.emit("objectDetector.process(image)");
+    compiler.emit("    .addOnSuccessListener { objects ->");
+    compiler.indentLevel++;
+    compiler.emit("val results = objects");
+    compiler.emit(
+      "    .filter { it.labels.isNotEmpty() && (it.labels.firstOrNull()?.confidence ?: 0f) >= confidenceThreshold }"
+    );
+    compiler.emit("    .take(maxDetections)");
+    compiler.emit("    .map { obj ->");
+    compiler.indentLevel++;
+    compiler.emit("NPUDetection(");
+    compiler.emit('    label = obj.labels.firstOrNull()?.text ?: "unknown",');
+    compiler.emit("    confidence = obj.labels.firstOrNull()?.confidence ?: 0f,");
+    compiler.emit("    boundingBox = obj.boundingBox");
+    compiler.emit(")");
+    compiler.indentLevel--;
+    compiler.emit("    }");
+    compiler.emit("_detections.value = results");
+    compiler.emit("inferenceCount++");
+    compiler.emit('Log.d("HoloScript", "Detected ${results.size} objects")');
+    compiler.indentLevel--;
+    compiler.emit("    }");
+    compiler.emit("    .addOnFailureListener { e ->");
+    compiler.indentLevel++;
+    compiler.emit('Log.e("HoloScript", "Object detection failed", e)');
+    compiler.indentLevel--;
+    compiler.emit("    }");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (usedTraits.has("npu_classify")) {
+    compiler.emit("// MARK: Classification (npu_classify)");
+    compiler.emit("");
+    compiler.emit("private val imageLabeler: ImageLabeler by lazy {");
+    compiler.indentLevel++;
+    compiler.emit("val options = ImageLabelerOptions.Builder()");
+    compiler.emit(`    .setConfidenceThreshold(${defaults.confidenceThreshold}f)`);
+    compiler.emit("    .build()");
+    compiler.emit("ImageLabeling.getClient(options)");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+    compiler.emit("fun classifyImage(image: InputImage) {");
+    compiler.indentLevel++;
+    compiler.emit("imageLabeler.process(image)");
+    compiler.emit("    .addOnSuccessListener { labels ->");
+    compiler.indentLevel++;
+    compiler.emit("val results = labels");
+    compiler.emit("    .filter { it.confidence >= confidenceThreshold }");
+    compiler.emit("    .take(maxDetections)");
+    compiler.emit("    .map { label ->");
+    compiler.indentLevel++;
+    compiler.emit("NPUDetection(label = label.text, confidence = label.confidence)");
+    compiler.indentLevel--;
+    compiler.emit("    }");
+    compiler.emit("_detections.value = results");
+    compiler.emit("inferenceCount++");
+    compiler.indentLevel--;
+    compiler.emit("    }");
+    compiler.emit("    .addOnFailureListener { e ->");
+    compiler.indentLevel++;
+    compiler.emit('Log.e("HoloScript", "Image classification failed", e)');
+    compiler.indentLevel--;
+    compiler.emit("    }");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (usedTraits.has("npu_segment")) {
+    compiler.emit("// MARK: Segmentation (npu_segment)");
+    compiler.emit("");
+    compiler.emit("private val segmenter by lazy {");
+    compiler.indentLevel++;
+    compiler.emit("val options = SelfieSegmenterOptions.Builder()");
+    compiler.emit("    .setDetectorMode(SelfieSegmenterOptions.STREAM_MODE)");
+    compiler.emit("    .enableRawSizeMask()");
+    compiler.emit("    .build()");
+    compiler.emit("Segmentation.getClient(options)");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+    compiler.emit("fun segmentScene(image: InputImage) {");
+    compiler.indentLevel++;
+    compiler.emit("segmenter.process(image)");
+    compiler.emit("    .addOnSuccessListener { mask ->");
+    compiler.indentLevel++;
+    compiler.emit("val buffer = mask.buffer");
+    compiler.emit("val width = mask.width");
+    compiler.emit("val height = mask.height");
+    compiler.emit("val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)");
+    compiler.emit("_detections.value = listOf(NPUDetection(");
+    compiler.emit('    label = "person_segmentation", confidence = 1.0f,');
+    compiler.emit("    segmentationMask = bitmap");
+    compiler.emit("))");
+    compiler.emit("inferenceCount++");
+    compiler.indentLevel--;
+    compiler.emit("    }");
+    compiler.emit("    .addOnFailureListener { e ->");
+    compiler.indentLevel++;
+    compiler.emit('Log.e("HoloScript", "Segmentation failed", e)');
+    compiler.indentLevel--;
+    compiler.emit("    }");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (usedTraits.has("npu_entity_pipe")) {
+    compiler.emit("// MARK: Entity Pipeline (npu_entity_pipe)");
+    compiler.emit("");
+    compiler.emit(
+      "fun mapDetectionsToEntities(detections: List<NPUDetection>, arFragment: com.google.ar.sceneform.ux.ArFragment) {"
+    );
+    compiler.indentLevel++;
+    compiler.emit("val scene = arFragment.arSceneView.scene");
+    compiler.emit("for (detection in detections) {");
+    compiler.indentLevel++;
+    compiler.emit("val bbox = detection.boundingBox ?: continue");
+    compiler.emit("val centerX = (bbox.left + bbox.right) / 2f");
+    compiler.emit("val centerY = (bbox.top + bbox.bottom) / 2f");
+    compiler.emit("val frame = arFragment.arSceneView.arFrame ?: continue");
+    compiler.emit("val hits = frame.hitTest(centerX, centerY)");
+    compiler.emit("val hit = hits.firstOrNull() ?: continue");
+    compiler.emit("val anchor = hit.createAnchor()");
+    compiler.emit("val anchorNode = com.google.ar.sceneform.AnchorNode(anchor)");
+    compiler.emit("anchorNode.setParent(scene)");
+    compiler.emit("com.google.ar.sceneform.rendering.MaterialFactory");
+    compiler.emit("    .makeOpaqueWithColor(arFragment.requireContext(),");
+    compiler.emit("        com.google.ar.sceneform.rendering.Color(0.2f, 0.6f, 1.0f, 0.6f))");
+    compiler.emit("    .thenAccept { material ->");
+    compiler.indentLevel++;
+    compiler.emit(
+      `val renderable = com.google.ar.sceneform.rendering.ShapeFactory.makeSphere(${defaults.entityScale}f, com.google.ar.sceneform.math.Vector3.zero(), material)`
+    );
+    compiler.emit(
+      "val node = com.google.ar.sceneform.ux.TransformableNode(arFragment.transformationSystem)"
+    );
+    compiler.emit("node.setParent(anchorNode)");
+    compiler.emit("node.renderable = renderable");
+    compiler.emit("node.name = detection.label");
+    compiler.emit('Log.d("HoloScript", "Entity created: ${detection.label}")');
+    compiler.indentLevel--;
+    compiler.emit("    }");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (usedTraits.has("npu_realtime")) {
+    compiler.emit("// MARK: Realtime Processing (npu_realtime)");
+    compiler.emit("");
+    compiler.emit("fun createImageAnalyzer(): ImageAnalysis.Analyzer {");
+    compiler.indentLevel++;
+    compiler.emit("return ImageAnalysis.Analyzer { imageProxy ->");
+    compiler.indentLevel++;
+    compiler.emit("frameCounter++");
+    compiler.emit("val now = System.currentTimeMillis()");
+    compiler.emit("val intervalMs = 1000L / targetFPS");
+    compiler.emit("if (now - lastProcessTimeMs < intervalMs) {");
+    compiler.indentLevel++;
+    compiler.emit("imageProxy.close()");
+    compiler.emit("return@Analyzer");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("lastProcessTimeMs = now");
+    compiler.emit("_isProcessing.value = true");
+    compiler.emit("");
+    compiler.emit("@androidx.camera.core.ExperimentalGetImage");
+    compiler.emit("val mediaImage = imageProxy.image");
+    compiler.emit("if (mediaImage != null) {");
+    compiler.indentLevel++;
+    compiler.emit(
+      "val image = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)"
+    );
+    if (usedTraits.has("npu_classify")) {
+      compiler.emit("classifyImage(image)");
+    }
+    if (usedTraits.has("npu_detect")) {
+      compiler.emit("detectObjects(image)");
+    }
+    if (usedTraits.has("npu_segment")) {
+      compiler.emit("segmentScene(image)");
+    }
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("_isProcessing.value = false");
+    compiler.emit("imageProxy.close()");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (usedTraits.has("npu_model_custom")) {
+    compiler.emit("// MARK: Custom Model (npu_model_custom)");
+    compiler.emit("");
+    compiler.emit("private var customInterpreter: Interpreter? = null");
+    compiler.emit("");
+    compiler.emit("fun loadCustomModel(context: android.content.Context, assetPath: String) {");
+    compiler.indentLevel++;
+    compiler.emit("val localModel = LocalModel.Builder()");
+    compiler.emit("    .setAssetFilePath(assetPath)");
+    compiler.emit("    .build()");
+    compiler.emit("");
+    compiler.emit("// NNAPI delegate for hardware acceleration");
+    compiler.emit("val nnApiDelegate = NnApiDelegate()");
+    compiler.emit("val options = Interpreter.Options().addDelegate(nnApiDelegate)");
+    compiler.emit("");
+    compiler.emit("val modelFile = context.assets.open(assetPath)");
+    compiler.emit("val buffer = modelFile.readBytes()");
+    compiler.emit("val byteBuffer = java.nio.ByteBuffer.allocateDirect(buffer.size)");
+    compiler.emit("byteBuffer.put(buffer)");
+    compiler.emit("customInterpreter = Interpreter(byteBuffer, options)");
+    compiler.emit('Log.d("HoloScript", "Custom model loaded with NNAPI: $assetPath")');
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (usedTraits.has("npu_label_overlay")) {
+    compiler.emit("// MARK: Label Overlay (npu_label_overlay)");
+    compiler.emit("");
+    compiler.emit("fun createLabelOverlay(");
+    compiler.emit("    detection: NPUDetection,");
+    compiler.emit("    arFragment: com.google.ar.sceneform.ux.ArFragment,");
+    compiler.emit("    anchorNode: com.google.ar.sceneform.AnchorNode");
+    compiler.emit(") {");
+    compiler.indentLevel++;
+    compiler.emit("com.google.ar.sceneform.rendering.ViewRenderable.builder()");
+    compiler.emit(
+      "    .setView(arFragment.requireContext(), android.widget.TextView(arFragment.requireContext()).apply {"
+    );
+    compiler.indentLevel++;
+    compiler.emit('text = "${detection.label} (${(detection.confidence * 100).toInt()}%)"');
+    compiler.emit("setTextColor(android.graphics.Color.WHITE)");
+    compiler.emit("setBackgroundColor(android.graphics.Color.argb(180, 0, 0, 0))");
+    compiler.emit("setPadding(12, 6, 12, 6)");
+    compiler.emit("textSize = 12f");
+    compiler.indentLevel--;
+    compiler.emit("    })");
+    compiler.emit("    .build()");
+    compiler.emit("    .thenAccept { renderable ->");
+    compiler.indentLevel++;
+    compiler.emit("val labelNode = com.google.ar.sceneform.Node()");
+    compiler.emit("labelNode.setParent(anchorNode)");
+    compiler.emit(
+      `labelNode.localPosition = com.google.ar.sceneform.math.Vector3(0f, ${defaults.labelOffsetY}f, 0f)`
+    );
+    compiler.emit("labelNode.renderable = renderable");
+    compiler.emit('Log.d("HoloScript", "Label overlay: ${detection.label}")');
+    compiler.indentLevel--;
+    compiler.emit("    }");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  compiler.indentLevel--;
+  compiler.emit("}");
+  return compiler.lines.join("\n");
+}
+var init_AndroidFeatureGenerators = chunkHCCQLAA4_cjs.__esm({
+  "src/compiler/AndroidFeatureGenerators.ts"() {
+    chunkDTGBOSEM_cjs.init_geospatial();
+    chunkDTGBOSEM_cjs.init_depth_scanner();
+    chunk6EX3I5P4_cjs.init_portal_ar();
+    chunk6EX3I5P4_cjs.init_camera_hand_tracking();
+    chunk6EX3I5P4_cjs.init_npu_scene();
+    chunkDTGBOSEM_cjs.init_spatial_authoring();
+  }
+});
+
+// src/compiler/AndroidARGenerators.ts
+function toKotlinFloatLiteral(value, fallback) {
+  const numeric = typeof value === "number" ? value : Number(value);
+  const resolved = Number.isFinite(numeric) ? numeric : fallback;
+  return `${resolved}f`;
+}
+function toKotlinVector3(value, fallback) {
+  const components = Array.isArray(value) && value.length >= 3 ? [value[0], value[1], value[2]] : typeof value === "number" ? [value, value, value] : fallback;
+  return `Vector3(${components.map((component, index) => toKotlinFloatLiteral(component, fallback[index])).join(", ")})`;
+}
+function generateActivityFile(compiler, composition) {
+  compiler.lines = [];
+  compiler.indentLevel = 0;
+  const pkg = compiler.options.packageName;
+  const cls = compiler.options.className;
+  compiler.emit("// Auto-generated by HoloScript AndroidCompiler");
+  compiler.emit(
+    `// Source: composition "${compiler.escapeStringValue(composition.name, "Kotlin")}"`
+  );
+  compiler.emit("// Do not edit manually \u2014 regenerate from .holo source");
+  compiler.emit("");
+  compiler.emit(`package ${pkg}`);
+  compiler.emit("");
+  compiler.emit("import android.os.Bundle");
+  compiler.emit("import android.view.MotionEvent");
+  compiler.emit("import android.view.View");
+  compiler.emit("import android.widget.Toast");
+  compiler.emit("import androidx.appcompat.app.AppCompatActivity");
+  compiler.emit("import androidx.lifecycle.ViewModelProvider");
+  compiler.emit("import com.google.ar.core.*");
+  compiler.emit("import com.google.ar.core.exceptions.*");
+  compiler.emit("import com.google.ar.sceneform.*");
+  compiler.emit("import com.google.ar.sceneform.math.Vector3");
+  compiler.emit("import com.google.ar.sceneform.rendering.*");
+  compiler.emit("import com.google.ar.sceneform.ux.*");
+  compiler.emit("import java.util.concurrent.CompletableFuture");
+  compiler.emit("");
+  compiler.emit(`class ${cls}Activity : AppCompatActivity() {`);
+  compiler.indentLevel++;
+  compiler.emit("private lateinit var arFragment: ArFragment");
+  compiler.emit("private lateinit var sceneState: SceneState");
+  compiler.emit("private val placedNodes = mutableMapOf<String, TransformableNode>()");
+  compiler.emit("");
+  compiler.emit("override fun onCreate(savedInstanceState: Bundle?) {");
+  compiler.indentLevel++;
+  compiler.emit("super.onCreate(savedInstanceState)");
+  compiler.emit(`setContentView(R.layout.activity_ar_scene)`);
+  compiler.emit("");
+  compiler.emit("sceneState = ViewModelProvider(this)[SceneState::class.java]");
+  compiler.emit(
+    "arFragment = supportFragmentManager.findFragmentById(R.id.ar_fragment) as ArFragment"
+  );
+  compiler.emit("");
+  compiler.emit("setupARSession()");
+  compiler.emit("setupTapListener()");
+  compiler.emit("setupUI()");
+  if (hasGeoTraits(composition)) {
+    compiler.emit("setupGeoAnchors()");
+  }
+  if (hasGeospatialVPSTraits(composition)) {
+    compiler.emit("setupGeospatialVPS()");
+  }
+  if (hasDepthScanTraits(composition)) {
+    compiler.emit("setupDepthScanner()");
+  }
+  if (hasPortalARTraits(composition)) {
+    compiler.emit("setupPortalAR()");
+  }
+  if (hasHandTrackingTraits(composition)) {
+    compiler.emit("setupHandTracking()");
+  }
+  if (hasAuthoringTraits(composition)) {
+    compiler.emit("setupSpatialAuthoring()");
+  }
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("private fun setupARSession() {");
+  compiler.indentLevel++;
+  compiler.emit("arFragment.arSceneView.scene.addOnUpdateListener { frameTime ->");
+  compiler.indentLevel++;
+  compiler.emit("val frame = arFragment.arSceneView.arFrame ?: return@addOnUpdateListener");
+  compiler.emit("");
+  compiler.emit("// Track planes");
+  compiler.emit("for (plane in frame.getUpdatedTrackables(Plane::class.java)) {");
+  compiler.indentLevel++;
+  compiler.emit("if (plane.trackingState == TrackingState.TRACKING) {");
+  compiler.indentLevel++;
+  compiler.emit("sceneState.onPlaneDetected(plane)");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("private fun setupTapListener() {");
+  compiler.indentLevel++;
+  compiler.emit("arFragment.setOnTapArPlaneListener { hitResult, plane, motionEvent ->");
+  compiler.indentLevel++;
+  compiler.emit(
+    "if (plane.type != Plane.Type.HORIZONTAL_UPWARD_FACING) return@setOnTapArPlaneListener"
+  );
+  compiler.emit("");
+  compiler.emit("placeObject(hitResult)");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("private fun placeObject(hitResult: HitResult) {");
+  compiler.indentLevel++;
+  compiler.emit("val anchor = hitResult.createAnchor()");
+  compiler.emit("val anchorNode = AnchorNode(anchor)");
+  compiler.emit("anchorNode.setParent(arFragment.arSceneView.scene)");
+  compiler.emit("");
+  if (composition.objects?.length) {
+    compiler.emit("// Create one renderable node per HoloScript object");
+    for (const obj of composition.objects) {
+      const methodName = `create${compiler.sanitizeName(obj.name)}`;
+      const objectName = compiler.escapeStringValue(obj.name, "Kotlin");
+      const position = toKotlinVector3(compiler.findObjProp(obj, "position"), [0, 0, 0]);
+      const scale = toKotlinVector3(compiler.findObjProp(obj, "scale"), [1, 1, 1]);
+      compiler.emit(`NodeFactory.${methodName}(this) { renderable ->`);
+      compiler.indentLevel++;
+      compiler.emit(
+        `attachRenderableToAnchor(anchorNode, "${objectName}", renderable, ${position}, ${scale})`
+      );
+      compiler.indentLevel--;
+      compiler.emit("}");
+    }
+  } else {
+    compiler.emit("// Create fallback node for empty scenes");
+    compiler.emit("NodeFactory.createDefaultNode(this) { renderable ->");
+    compiler.indentLevel++;
+    compiler.emit(
+      'attachRenderableToAnchor(anchorNode, "default", renderable, Vector3(0f, 0f, 0f), Vector3(1f, 1f, 1f))'
+    );
+    compiler.indentLevel--;
+    compiler.emit("}");
+  }
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("private fun attachRenderableToAnchor(");
+  compiler.indentLevel++;
+  compiler.emit("anchorNode: AnchorNode,");
+  compiler.emit("objectName: String,");
+  compiler.emit("renderable: Renderable,");
+  compiler.emit("localPosition: Vector3,");
+  compiler.emit("localScale: Vector3");
+  compiler.indentLevel--;
+  compiler.emit(") {");
+  compiler.indentLevel++;
+  compiler.emit("val transformableNode = TransformableNode(arFragment.transformationSystem)");
+  compiler.emit("transformableNode.setParent(anchorNode)");
+  compiler.emit("transformableNode.renderable = renderable");
+  compiler.emit("transformableNode.localPosition = localPosition");
+  compiler.emit("transformableNode.localScale = localScale");
+  compiler.emit("transformableNode.select()");
+  compiler.emit("");
+  compiler.emit('val id = "$objectName-${java.util.UUID.randomUUID()}"');
+  compiler.emit("placedNodes[id] = transformableNode");
+  compiler.emit("");
+  compiler.emit("// Setup interaction");
+  compiler.emit("transformableNode.setOnTapListener { _, _ ->");
+  compiler.indentLevel++;
+  compiler.emit("sceneState.onNodeTapped(id)");
+  compiler.emit("animateNodeTap(transformableNode)");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit('android.util.Log.d("HoloScript", "Placed object: $objectName as $id")');
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("private fun animateNodeTap(node: TransformableNode) {");
+  compiler.indentLevel++;
+  compiler.emit("val originalScale = node.localScale");
+  compiler.emit(
+    "val scaledUp = Vector3(originalScale[0] * 1.2f, originalScale[1] * 1.2f, originalScale[2] * 1.2f)"
+  );
+  compiler.emit("");
+  compiler.emit("android.animation.ObjectAnimator.ofObject(");
+  compiler.indentLevel++;
+  compiler.emit('node, "localScale",');
+  compiler.emit("com.google.ar.sceneform.math.Vector3Evaluator(),");
+  compiler.emit("originalScale, scaledUp, originalScale");
+  compiler.indentLevel--;
+  compiler.emit(").apply {");
+  compiler.indentLevel++;
+  compiler.emit("duration = 200");
+  compiler.emit("start()");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("private fun setupUI() {");
+  compiler.indentLevel++;
+  compiler.emit("findViewById<View>(R.id.reset_button)?.setOnClickListener {");
+  compiler.indentLevel++;
+  compiler.emit("resetScene()");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("private fun resetScene() {");
+  compiler.indentLevel++;
+  compiler.emit("for (node in placedNodes.values) {");
+  compiler.indentLevel++;
+  compiler.emit("node.anchor?.detach()");
+  compiler.emit("node.setParent(null)");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("placedNodes.clear()");
+  compiler.emit("");
+  compiler.emit("sceneState.reset()");
+  compiler.emit('Toast.makeText(this, "Scene reset", Toast.LENGTH_SHORT).show()');
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("override fun onResume() {");
+  compiler.indentLevel++;
+  compiler.emit("super.onResume()");
+  compiler.emit("checkARCoreAvailability()");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("private fun checkARCoreAvailability() {");
+  compiler.indentLevel++;
+  compiler.emit("val availability = ArCoreApk.getInstance().checkAvailability(this)");
+  compiler.emit("if (availability.isTransient) {");
+  compiler.indentLevel++;
+  compiler.emit("android.os.Handler(mainLooper).postDelayed({ checkARCoreAvailability() }, 200)");
+  compiler.emit("return");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("if (!availability.isSupported) {");
+  compiler.indentLevel++;
+  compiler.emit(
+    'Toast.makeText(this, "ARCore is not supported on this device", Toast.LENGTH_LONG).show()'
+  );
+  compiler.emit("finish()");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  if (hasGeoTraits(composition)) {
+    emitGeoAnchorSetup(compiler, composition);
+  }
+  if (hasGeospatialVPSTraits(composition)) {
+    emitGeospatialVPSSetup(compiler, composition);
+  }
+  if (hasDepthScanTraits(composition)) {
+    emitDepthScanSetup(compiler, composition);
+  }
+  if (hasPortalARTraits(composition)) {
+    emitPortalARSetup(compiler, composition);
+  }
+  if (hasHandTrackingTraits(composition)) {
+    emitHandTrackingSetup(compiler, composition);
+  }
+  if (hasAuthoringTraits(composition)) {
+    emitAuthoringInlineSetup(compiler, composition);
+  }
+  compiler.indentLevel--;
+  compiler.emit("}");
+  return compiler.lines.join("\n");
+}
+function generateStateFile(compiler, composition) {
+  compiler.lines = [];
+  compiler.indentLevel = 0;
+  const pkg = compiler.options.packageName;
+  compiler.emit("// Auto-generated by HoloScript AndroidCompiler");
+  compiler.emit(`// State: ${compiler.escapeStringValue(composition.name, "Kotlin")}`);
+  compiler.emit("");
+  compiler.emit(`package ${pkg}`);
+  compiler.emit("");
+  compiler.emit("import androidx.lifecycle.ViewModel");
+  compiler.emit("import androidx.lifecycle.MutableLiveData");
+  compiler.emit("import androidx.lifecycle.LiveData");
+  compiler.emit("import com.google.ar.core.Plane");
+  compiler.emit("");
+  compiler.emit("class SceneState : ViewModel() {");
+  compiler.indentLevel++;
+  if (composition.state) {
+    compiler.emit("// === State Properties ===");
+    for (const prop of composition.state.properties) {
+      const kotlinType = compiler.toKotlinType(prop.value);
+      const kotlinValue = compiler.toKotlinValue(prop.value);
+      compiler.emit(
+        `private val _${compiler.escapeStringValue(prop.key, "Kotlin")} = MutableLiveData(${kotlinValue})`
+      );
+      compiler.emit(
+        `val ${compiler.escapeStringValue(prop.key, "Kotlin")}: LiveData<${kotlinType}> get() = _${compiler.escapeStringValue(prop.key, "Kotlin")}`
+      );
+      compiler.emit("");
+    }
+  }
+  compiler.emit("// === AR State ===");
+  compiler.emit("private val _detectedPlanes = MutableLiveData<List<Plane>>(emptyList())");
+  compiler.emit("val detectedPlanes: LiveData<List<Plane>> get() = _detectedPlanes");
+  compiler.emit("");
+  compiler.emit("private val _tappedNodes = MutableLiveData<String?>()");
+  compiler.emit("val tappedNodes: LiveData<String?> get() = _tappedNodes");
+  compiler.emit("");
+  compiler.emit("fun onPlaneDetected(plane: Plane) {");
+  compiler.indentLevel++;
+  compiler.emit("val current = _detectedPlanes.value.orEmpty().toMutableList()");
+  compiler.emit("if (!current.contains(plane)) {");
+  compiler.indentLevel++;
+  compiler.emit("current.add(plane)");
+  compiler.emit("_detectedPlanes.value = current");
+  compiler.emit('android.util.Log.d("HoloScript", "Plane detected: ${plane.type}")');
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("fun onNodeTapped(nodeId: String) {");
+  compiler.indentLevel++;
+  compiler.emit("_tappedNodes.value = nodeId");
+  compiler.emit('android.util.Log.d("HoloScript", "Node tapped: $nodeId")');
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("fun reset() {");
+  compiler.indentLevel++;
+  compiler.emit("_detectedPlanes.value = emptyList()");
+  compiler.emit("_tappedNodes.value = null");
+  if (composition.state) {
+    for (const prop of composition.state.properties) {
+      const kotlinValue = compiler.toKotlinValue(prop.value);
+      compiler.emit(
+        `_${compiler.escapeStringValue(prop.key, "Kotlin")}.value = ${kotlinValue}`
+      );
+    }
+  }
+  compiler.emit('android.util.Log.d("HoloScript", "State reset")');
+  compiler.indentLevel--;
+  compiler.emit("}");
+  if (composition.logic?.actions) {
+    compiler.emit("");
+    compiler.emit("// === Actions ===");
+    for (const action of composition.logic.actions) {
+      compileAction(compiler, action);
+    }
+  }
+  compiler.indentLevel--;
+  compiler.emit("}");
+  return compiler.lines.join("\n");
+}
+function generateNodeFactoryFile(compiler, composition) {
+  compiler.lines = [];
+  compiler.indentLevel = 0;
+  const pkg = compiler.options.packageName;
+  compiler.emit("// Auto-generated by HoloScript AndroidCompiler");
+  compiler.emit(`// Node Factory: ${compiler.escapeStringValue(composition.name, "Kotlin")}`);
+  compiler.emit("");
+  compiler.emit(`package ${pkg}`);
+  compiler.emit("");
+  compiler.emit("import android.content.Context");
+  compiler.emit("import com.google.ar.sceneform.math.Vector3");
+  compiler.emit("import com.google.ar.sceneform.rendering.*");
+  compiler.emit("import com.google.android.filament.utils.Float3");
+  compiler.emit("");
+  compiler.emit("object NodeFactory {");
+  compiler.indentLevel++;
+  compiler.emit("fun createDefaultNode(context: Context, callback: (Renderable) -> Unit) {");
+  compiler.indentLevel++;
+  if (composition.objects?.length) {
+    const firstObj = composition.objects[0];
+    const color = compiler.findObjProp(firstObj, "color");
+    compiler.emit("MaterialFactory.makeOpaqueWithColor(");
+    compiler.indentLevel++;
+    compiler.emit("context,");
+    compiler.emit(`Color(${compiler.toAndroidColor(color)})`);
+    compiler.indentLevel--;
+    compiler.emit(").thenAccept { material ->");
+    compiler.indentLevel++;
+    const meshType = compiler.findObjProp(firstObj, "mesh") || compiler.findObjProp(firstObj, "type") || "cube";
+    const geometry = compiler.getSceneformGeometry(meshType);
+    compiler.emit(`${geometry}.thenAccept { renderable ->`);
+    compiler.indentLevel++;
+    compiler.emit("renderable.material = material");
+    compiler.emit("callback(renderable)");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+  } else {
+    compiler.emit("MaterialFactory.makeOpaqueWithColor(context, Color(android.graphics.Color.BLUE))");
+    compiler.emit("    .thenCompose { material ->");
+    compiler.emit(
+      "        ShapeFactory.makeCube(Vector3(0.1f, 0.1f, 0.1f), Vector3.zero(), material)"
+    );
+    compiler.emit("    }");
+    compiler.emit("    .thenAccept { renderable -> callback(renderable) }");
+  }
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  for (const obj of composition.objects || []) {
+    compileObjectFactory(compiler, obj);
+  }
+  compiler.indentLevel--;
+  compiler.emit("}");
+  return compiler.lines.join("\n");
+}
+function compileObjectFactory(compiler, obj) {
+  const methodName = `create${compiler.sanitizeName(obj.name)}`;
+  compiler.emit(`fun ${methodName}(context: Context, callback: (Renderable) -> Unit) {`);
+  compiler.indentLevel++;
+  const color = compiler.findObjProp(obj, "color");
+  const meshType = compiler.findObjProp(obj, "mesh") || compiler.findObjProp(obj, "type") || "cube";
+  compiler.emit("MaterialFactory.makeOpaqueWithColor(");
+  compiler.indentLevel++;
+  compiler.emit("context,");
+  compiler.emit(`Color(${compiler.toAndroidColor(color)})`);
+  compiler.indentLevel--;
+  compiler.emit(").thenAccept { material ->");
+  compiler.indentLevel++;
+  const geometry = compiler.getSceneformGeometry(meshType);
+  compiler.emit(`${geometry}.thenAccept { renderable ->`);
+  compiler.indentLevel++;
+  compiler.emit("renderable.material = material");
+  compiler.emit("callback(renderable)");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+}
+function generateManifestFile(compiler, composition) {
+  const pkg = compiler.options.packageName;
+  const cls = compiler.options.className;
+  const hasGeo = hasGeoTraits(composition);
+  const hasGeospatialVPS = hasGeospatialVPSTraits(composition);
+  const geoPermissions = hasGeo || hasGeospatialVPS ? `
+    <!-- Geo-Anchor: Location permissions -->
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />` : "";
+  const geospatialApiKeyMeta = hasGeospatialVPS ? `
+        <!-- ARCore Geospatial API key (replace with your key from Google Cloud Console) -->
+        <meta-data android:name="com.google.android.ar.API_KEY" android:value="\${GEOSPATIAL_API_KEY}" />` : "";
+  return `<?xml version="1.0" encoding="utf-8"?>
+<!-- Auto-generated by HoloScript AndroidCompiler -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="${pkg}">
+
+    <!-- AR Required -->
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-feature android:name="android.hardware.camera.ar" android:required="true" />
+
+    <!-- ARCore Required -->
+    <uses-feature android:glEsVersion="0x00030000" android:required="true" />${geoPermissions}
+
+    <application
+        android:allowBackup="true"
+        android:label="${compiler.escapeStringValue(composition.name, "XML")}"
+        android:supportsRtl="true"
+        android:theme="@style/Theme.AppCompat.NoActionBar">
+
+        <!-- ARCore metadata -->
+        <meta-data android:name="com.google.ar.core" android:value="required" />${geospatialApiKeyMeta}
+
+        <activity
+            android:name=".${cls}Activity"
+            android:exported="true"
+            android:configChanges="orientation|screenSize"
+            android:screenOrientation="locked">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>`;
+}
+function generateBuildGradle(compiler, composition) {
+  const hasGeospatialVPS = hasGeospatialVPSTraits(composition);
+  const hasDepthScan = hasDepthScanTraits(composition);
+  const hasHandTracking = hasHandTrackingTraits(composition);
+  const geospatialDeps = hasGeospatialVPS ? `
+    // ARCore Geospatial API (included in com.google.ar:core >= 1.31.0)
+    // Location services for VPS
+    implementation 'com.google.android.gms:play-services-location:21.1.0'` : "";
+  const depthScanDeps = hasDepthScan ? `
+    // ARCore Depth API (M.010.02b)
+    implementation 'com.google.ar:core:1.40.0'` : "";
+  const handTrackingDeps = hasHandTracking ? `
+    // MediaPipe Hands \u2014 camera-based hand tracking (M.010.04)
+    implementation 'com.google.mediapipe:solution-hands:0.10.14'
+    // CameraX for front camera feed
+    implementation 'androidx.camera:camera-core:1.3.1'
+    implementation 'androidx.camera:camera-camera2:1.3.1'
+    implementation 'androidx.camera:camera-lifecycle:1.3.1'` : "";
+  const hasAuthoring = hasAuthoringTraits(composition);
+  const authoringDeps = hasAuthoring ? `
+    // Spatial Authoring \u2014 speech recognition (M.010.08)
+    implementation 'androidx.recyclerview:recyclerview:1.3.2'` : "";
+  return `// Auto-generated by HoloScript AndroidCompiler
+// Source: ${compiler.escapeStringValue(composition.name, "Kotlin")}
+
+plugins {
+    id 'com.android.application'
+    id 'org.jetbrains.kotlin.android'
+}
+
+android {
+    namespace '${compiler.options.packageName}'
+    compileSdk ${compiler.options.targetSdk}
+
+    defaultConfig {
+        applicationId "${compiler.options.packageName}"
+        minSdk ${compiler.options.minSdk}
+        targetSdk ${compiler.options.targetSdk}
+        versionCode 1
+        versionName "1.0"
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = '17'
+    }
+
+    buildFeatures {
+        viewBinding true
+        compose ${compiler.options.useJetpackCompose}
+    }
+}
+
+dependencies {
+    implementation 'androidx.core:core-ktx:1.12.0'
+    implementation 'androidx.appcompat:appcompat:1.6.1'
+    implementation 'com.google.android.material:material:1.11.0'
+    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.7.0'
+    implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.7.0'
+
+    // ARCore (>= 1.31.0 includes Geospatial API)
+    implementation 'com.google.ar:core:1.41.0'
+
+    // Sceneform (maintained fork)
+    implementation 'com.gorisse.thomas:sceneform:1.22.0'${geospatialDeps}${depthScanDeps}${handTrackingDeps}${authoringDeps}
+
+    // Optional: Jetpack Compose
+    ${compiler.options.useJetpackCompose ? `implementation platform('androidx.compose:compose-bom:2024.01.00')
+    implementation 'androidx.compose.ui:ui'
+    implementation 'androidx.compose.material3:material3'
+    implementation 'androidx.activity:activity-compose:1.8.2'` : "// Compose disabled"}
+}`;
+}
+function compileAction(compiler, action) {
+  const rawName = compiler.sanitizeName(action.name);
+  const name = rawName.charAt(0).toLowerCase() + rawName.slice(1);
+  compiler.emit(`fun ${name}() {`);
+  compiler.indentLevel++;
+  compiler.emit(
+    `android.util.Log.d("HoloScript", "Action: ${compiler.escapeStringValue(action.name, "Kotlin")}")`
+  );
+  compiler.emit("// Action implementation");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+}
+var init_AndroidARGenerators = chunkHCCQLAA4_cjs.__esm({
+  "src/compiler/AndroidARGenerators.ts"() {
+    init_AndroidFeatureGenerators();
+  }
+});
+
+// src/compiler/AndroidPeripheralGenerators.ts
+function hasHapticTraits(composition) {
+  const names = chunkDTGBOSEM_cjs.HAPTIC_FEEDBACK_TRAITS;
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (names.includes(name)) return true;
+    }
+  }
+  return false;
+}
+function emitHapticSetup(compiler, composition) {
+  compiler.lines = [];
+  compiler.indentLevel = 0;
+  const pkg = compiler.options.packageName;
+  const cls = compiler.options.className;
+  compiler.emit("// Auto-generated by HoloScript AndroidCompiler \u2014 Haptic Feedback");
+  compiler.emit(
+    `// Source: composition "${compiler.escapeStringValue(composition.name, "Kotlin")}"`
+  );
+  compiler.emit("// Requires Android API 26+ (VibrationEffect)");
+  compiler.emit("");
+  compiler.emit(`package ${pkg}`);
+  compiler.emit("");
+  compiler.emit("import android.content.Context");
+  compiler.emit("import android.os.Build");
+  compiler.emit("import android.os.VibrationEffect");
+  compiler.emit("import android.os.Vibrator");
+  compiler.emit("import android.os.VibratorManager");
+  compiler.emit("import android.view.HapticFeedbackConstants");
+  compiler.emit("");
+  compiler.emit(`class ${cls}HapticManager(private val context: Context) {`);
+  compiler.indentLevel++;
+  compiler.emit("");
+  compiler.emit("private val vibrator: Vibrator = if (Build.VERSION.SDK_INT >= 31) {");
+  compiler.indentLevel++;
+  compiler.emit(
+    "(context.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as VibratorManager).defaultVibrator"
+  );
+  compiler.indentLevel--;
+  compiler.emit("} else {");
+  compiler.indentLevel++;
+  compiler.emit(
+    '@Suppress("DEPRECATION") context.getSystemService(Context.VIBRATOR_SERVICE) as Vibrator'
+  );
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("private var intensityMultiplier: Float = 1.0f");
+  compiler.emit("private var enabled: Boolean = true");
+  compiler.emit("");
+  if (compiler.compositionHasTrait(composition, "haptic_enable")) {
+    compiler.emit("fun setEnabled(on: Boolean) { enabled = on }");
+    compiler.emit("");
+  }
+  if (compiler.compositionHasTrait(composition, "haptic_intensity")) {
+    compiler.emit("fun setIntensity(value: Float) { intensityMultiplier = value.coerceIn(0f, 1f) }");
+    compiler.emit("");
+  }
+  compiler.emit("fun onTouch() { vibrate(VibrationEffect.EFFECT_CLICK) }");
+  compiler.emit("fun onGrab() { vibrate(VibrationEffect.EFFECT_HEAVY_CLICK) }");
+  compiler.emit("fun onThrow() { vibrate(VibrationEffect.EFFECT_DOUBLE_CLICK) }");
+  compiler.emit("fun onImpact() { vibrate(VibrationEffect.EFFECT_TICK) }");
+  compiler.emit("fun onSelect() { vibrate(VibrationEffect.EFFECT_CLICK) }");
+  compiler.emit("");
+  if (compiler.compositionHasTrait(composition, "haptic_proximity")) {
+    compiler.emit("fun onProximity(distance: Float) {");
+    compiler.indentLevel++;
+    compiler.emit("if (!enabled) return");
+    compiler.emit(
+      "val amplitude = ((1.0f - distance.coerceIn(0f, 1f)) * 255 * intensityMultiplier).toInt()"
+    );
+    compiler.emit("vibrator.vibrate(VibrationEffect.createOneShot(50, amplitude.coerceIn(1, 255)))");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (compiler.compositionHasTrait(composition, "haptic_pattern_library")) {
+    compiler.emit("fun playPattern(timings: LongArray, amplitudes: IntArray) {");
+    compiler.indentLevel++;
+    compiler.emit("if (!enabled) return");
+    compiler.emit("vibrator.vibrate(VibrationEffect.createWaveform(timings, amplitudes, -1))");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  compiler.emit("private fun vibrate(effectId: Int) {");
+  compiler.indentLevel++;
+  compiler.emit("if (!enabled) return");
+  compiler.emit("vibrator.vibrate(VibrationEffect.createPredefined(effectId))");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  return compiler.lines.join("\n");
+}
+function hasNearbyTraits(composition) {
+  const names = chunkDTGBOSEM_cjs.NEARBY_CONNECTIONS_TRAITS;
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (names.includes(name)) return true;
+    }
+  }
+  return false;
+}
+function emitNearbySetup(compiler, composition) {
+  compiler.lines = [];
+  compiler.indentLevel = 0;
+  const pkg = compiler.options.packageName;
+  const cls = compiler.options.className;
+  compiler.emit("// Auto-generated by HoloScript AndroidCompiler \u2014 Nearby Connections");
+  compiler.emit(
+    `// Source: composition "${compiler.escapeStringValue(composition.name, "Kotlin")}"`
+  );
+  compiler.emit("// Requires Google Play Services Nearby");
+  compiler.emit("");
+  compiler.emit(`package ${pkg}`);
+  compiler.emit("");
+  compiler.emit("import android.content.Context");
+  compiler.emit("import android.util.Log");
+  compiler.emit("import com.google.android.gms.nearby.Nearby");
+  compiler.emit("import com.google.android.gms.nearby.connection.*");
+  compiler.emit("");
+  compiler.emit(`class ${cls}NearbyManager(private val context: Context) {`);
+  compiler.indentLevel++;
+  compiler.emit("");
+  compiler.emit('private val TAG = "HoloNearby"');
+  compiler.emit('private val SERVICE_ID = "com.holoscript.nearby"');
+  compiler.emit("private val connectedEndpoints = mutableSetOf<String>()");
+  compiler.emit("");
+  compiler.emit("private val connectionCallback = object : ConnectionLifecycleCallback() {");
+  compiler.indentLevel++;
+  compiler.emit("override fun onConnectionInitiated(endpointId: String, info: ConnectionInfo) {");
+  compiler.indentLevel++;
+  compiler.emit("Nearby.getConnectionsClient(context).acceptConnection(endpointId, payloadCallback)");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit(
+    "override fun onConnectionResult(endpointId: String, result: ConnectionResolution) {"
+  );
+  compiler.indentLevel++;
+  compiler.emit("if (result.status.isSuccess) { connectedEndpoints.add(endpointId) }");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit(
+    "override fun onDisconnected(endpointId: String) { connectedEndpoints.remove(endpointId) }"
+  );
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("private val payloadCallback = object : PayloadCallback() {");
+  compiler.indentLevel++;
+  compiler.emit("override fun onPayloadReceived(endpointId: String, payload: Payload) {");
+  compiler.indentLevel++;
+  compiler.emit('Log.d(TAG, "Payload received from $endpointId")');
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit(
+    "override fun onPayloadTransferUpdate(endpointId: String, update: PayloadTransferUpdate) {}"
+  );
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  if (compiler.compositionHasTrait(composition, "nearby_advertise")) {
+    compiler.emit("fun startAdvertising() {");
+    compiler.indentLevel++;
+    compiler.emit(
+      "val options = AdvertisingOptions.Builder().setStrategy(Strategy.P2P_CLUSTER).build()"
+    );
+    compiler.emit(
+      'Nearby.getConnectionsClient(context).startAdvertising("HoloDevice", SERVICE_ID, connectionCallback, options)'
+    );
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (compiler.compositionHasTrait(composition, "nearby_discover")) {
+    compiler.emit("fun startDiscovery() {");
+    compiler.indentLevel++;
+    compiler.emit(
+      "val options = DiscoveryOptions.Builder().setStrategy(Strategy.P2P_CLUSTER).build()"
+    );
+    compiler.emit(
+      "Nearby.getConnectionsClient(context).startDiscovery(SERVICE_ID, object : EndpointDiscoveryCallback() {"
+    );
+    compiler.indentLevel++;
+    compiler.emit("override fun onEndpointFound(endpointId: String, info: DiscoveredEndpointInfo) {");
+    compiler.indentLevel++;
+    compiler.emit(
+      'Nearby.getConnectionsClient(context).requestConnection("HoloDevice", endpointId, connectionCallback)'
+    );
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit(
+      'override fun onEndpointLost(endpointId: String) { Log.d(TAG, "Lost $endpointId") }'
+    );
+    compiler.indentLevel--;
+    compiler.emit("}, options)");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (compiler.compositionHasTrait(composition, "nearby_broadcast")) {
+    compiler.emit("fun broadcast(data: ByteArray) {");
+    compiler.indentLevel++;
+    compiler.emit("val payload = Payload.fromBytes(data)");
+    compiler.emit(
+      "connectedEndpoints.forEach { Nearby.getConnectionsClient(context).sendPayload(it, payload) }"
+    );
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  compiler.emit("fun disconnect() {");
+  compiler.indentLevel++;
+  compiler.emit("Nearby.getConnectionsClient(context).stopAllEndpoints()");
+  compiler.emit("connectedEndpoints.clear()");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  return compiler.lines.join("\n");
+}
+function hasFoldableTraits(composition) {
+  const names = chunkDTGBOSEM_cjs.FOLDABLE_DISPLAY_TRAITS;
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (names.includes(name)) return true;
+    }
+  }
+  return false;
+}
+function emitFoldableSetup(compiler, composition) {
+  compiler.lines = [];
+  compiler.indentLevel = 0;
+  const pkg = compiler.options.packageName;
+  const cls = compiler.options.className;
+  compiler.emit("// Auto-generated by HoloScript AndroidCompiler \u2014 Foldable Display");
+  compiler.emit(
+    `// Source: composition "${compiler.escapeStringValue(composition.name, "Kotlin")}"`
+  );
+  compiler.emit("// Requires Jetpack WindowManager");
+  compiler.emit("");
+  compiler.emit(`package ${pkg}`);
+  compiler.emit("");
+  compiler.emit("import android.app.Activity");
+  compiler.emit("import android.util.Log");
+  compiler.emit("import androidx.lifecycle.ViewModel");
+  compiler.emit("import androidx.lifecycle.viewModelScope");
+  compiler.emit("import androidx.window.layout.FoldingFeature");
+  compiler.emit("import androidx.window.layout.WindowInfoTracker");
+  compiler.emit("import kotlinx.coroutines.flow.MutableStateFlow");
+  compiler.emit("import kotlinx.coroutines.flow.StateFlow");
+  compiler.emit("import kotlinx.coroutines.launch");
+  compiler.emit("");
+  compiler.emit(`class ${cls}FoldableManager : ViewModel() {`);
+  compiler.indentLevel++;
+  compiler.emit("");
+  compiler.emit("private val _foldState = MutableStateFlow<FoldState>(FoldState.FLAT)");
+  compiler.emit("val foldState: StateFlow<FoldState> = _foldState");
+  compiler.emit("");
+  compiler.emit("private val _hingeAngle = MutableStateFlow(180f)");
+  compiler.emit("val hingeAngle: StateFlow<Float> = _hingeAngle");
+  compiler.emit("");
+  compiler.emit("enum class FoldState { FLAT, HALF_OPENED, FOLDED }");
+  compiler.emit("");
+  compiler.emit("fun observeWindowLayout(activity: Activity) {");
+  compiler.indentLevel++;
+  compiler.emit("viewModelScope.launch {");
+  compiler.indentLevel++;
+  compiler.emit(
+    "WindowInfoTracker.getOrCreate(activity).windowLayoutInfo(activity).collect { layoutInfo ->"
+  );
+  compiler.indentLevel++;
+  compiler.emit(
+    "val foldingFeature = layoutInfo.displayFeatures.filterIsInstance<FoldingFeature>().firstOrNull()"
+  );
+  compiler.emit("if (foldingFeature != null) {");
+  compiler.indentLevel++;
+  compiler.emit("_foldState.value = when {");
+  compiler.indentLevel++;
+  compiler.emit("FoldingFeature.State.HALF_OPENED -> FoldState.HALF_OPENED");
+  compiler.emit("FoldingFeature.State.FLAT -> FoldState.FLAT");
+  compiler.emit("else -> FoldState.FOLDED");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  if (compiler.compositionHasTrait(composition, "foldable_hinge_angle")) {
+    compiler.emit("// Hinge angle exposed via foldingFeature orientation");
+    compiler.emit(
+      'Log.d("HoloFoldable", "Fold state: ${foldingFeature.state}, orientation: ${foldingFeature.orientation}")'
+    );
+  }
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  if (compiler.compositionHasTrait(composition, "foldable_split_view")) {
+    compiler.emit(
+      "fun isSplitViewRecommended(): Boolean = _foldState.value == FoldState.HALF_OPENED"
+    );
+    compiler.emit("");
+  }
+  if (compiler.compositionHasTrait(composition, "foldable_tabletop")) {
+    compiler.emit("fun isTabletopMode(): Boolean = _foldState.value == FoldState.HALF_OPENED");
+    compiler.emit("");
+  }
+  compiler.indentLevel--;
+  compiler.emit("}");
+  return compiler.lines.join("\n");
+}
+function hasDexTraits(composition) {
+  const names = chunkDTGBOSEM_cjs.SAMSUNG_DEX_TRAITS;
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (names.includes(name)) return true;
+    }
+  }
+  return false;
+}
+function emitDexSetup(compiler, composition) {
+  compiler.lines = [];
+  compiler.indentLevel = 0;
+  const pkg = compiler.options.packageName;
+  const cls = compiler.options.className;
+  compiler.emit("// Auto-generated by HoloScript AndroidCompiler \u2014 Samsung DeX");
+  compiler.emit(
+    `// Source: composition "${compiler.escapeStringValue(composition.name, "Kotlin")}"`
+  );
+  compiler.emit("// Samsung DeX mode detection and desktop UI transition");
+  compiler.emit("");
+  compiler.emit(`package ${pkg}`);
+  compiler.emit("");
+  compiler.emit("import android.app.Activity");
+  compiler.emit("import android.content.res.Configuration");
+  compiler.emit("import android.util.Log");
+  compiler.emit("");
+  compiler.emit(`class ${cls}DexManager(private val activity: Activity) {`);
+  compiler.indentLevel++;
+  compiler.emit("");
+  compiler.emit('private val TAG = "HoloDex"');
+  compiler.emit("");
+  compiler.emit("fun isDeXMode(): Boolean {");
+  compiler.indentLevel++;
+  compiler.emit("val config = activity.resources.configuration");
+  compiler.emit("return try {");
+  compiler.indentLevel++;
+  compiler.emit("val configClass = config.javaClass");
+  compiler.emit(
+    'val semDesktopModeEnabled = configClass.getField("SEM_DESKTOP_MODE_ENABLED").getInt(configClass)'
+  );
+  compiler.emit('val enabledField = configClass.getField("semDesktopModeEnabled").getInt(config)');
+  compiler.emit("enabledField == semDesktopModeEnabled");
+  compiler.indentLevel--;
+  compiler.emit("} catch (e: Exception) { false }");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  if (compiler.compositionHasTrait(composition, "dex_handoff")) {
+    compiler.emit("fun onDexModeChanged(isDex: Boolean) {");
+    compiler.indentLevel++;
+    compiler.emit("if (isDex) {");
+    compiler.indentLevel++;
+    compiler.emit('Log.d(TAG, "DeX connected \u2014 switching to desktop 3D editor")');
+    compiler.emit("enableDesktopLayout()");
+    compiler.indentLevel--;
+    compiler.emit("} else {");
+    compiler.indentLevel++;
+    compiler.emit('Log.d(TAG, "DeX disconnected \u2014 switching to mobile AR")');
+    compiler.emit("enableMobileLayout()");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (compiler.compositionHasTrait(composition, "dex_desktop_controls")) {
+    compiler.emit("fun enableDesktopLayout() {");
+    compiler.indentLevel++;
+    compiler.emit("// Enable mouse/keyboard controls, enlarge UI targets");
+    compiler.emit('Log.d(TAG, "Desktop layout enabled with mouse/keyboard support")');
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (compiler.compositionHasTrait(composition, "dex_resolution_adapt")) {
+    compiler.emit("fun adaptResolution() {");
+    compiler.indentLevel++;
+    compiler.emit("val display = activity.windowManager.defaultDisplay");
+    compiler.emit("val metrics = android.util.DisplayMetrics()");
+    compiler.emit('@Suppress("DEPRECATION") display.getRealMetrics(metrics)');
+    compiler.emit('Log.d(TAG, "External display: ${metrics.widthPixels}x${metrics.heightPixels}")');
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  compiler.emit("private fun enableMobileLayout() {");
+  compiler.indentLevel++;
+  compiler.emit('Log.d(TAG, "Mobile AR layout restored")');
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  return compiler.lines.join("\n");
+}
+function hasLensTraits(composition) {
+  const names = chunkDTGBOSEM_cjs.GOOGLE_LENS_TRAITS;
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (names.includes(name)) return true;
+    }
+  }
+  return false;
+}
+function emitLensSetup(compiler, composition) {
+  compiler.lines = [];
+  compiler.indentLevel = 0;
+  const pkg = compiler.options.packageName;
+  const cls = compiler.options.className;
+  const usedTraits = /* @__PURE__ */ new Set();
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (chunkDTGBOSEM_cjs.GOOGLE_LENS_TRAITS.includes(name)) {
+        usedTraits.add(name);
+      }
+    }
+  }
+  compiler.emit("// Auto-generated by HoloScript AndroidCompiler \u2014 Google Lens Integration");
+  compiler.emit(
+    `// Source: composition "${compiler.escapeStringValue(composition.name, "Kotlin")}"`
+  );
+  compiler.emit("// Requires ML Kit (vision, text, translate)");
+  compiler.emit("");
+  compiler.emit(`package ${pkg}`);
+  compiler.emit("");
+  compiler.emit("import android.graphics.Bitmap");
+  compiler.emit("import android.util.Log");
+  compiler.emit("import androidx.lifecycle.ViewModel");
+  compiler.emit("import androidx.lifecycle.viewModelScope");
+  compiler.emit("import kotlinx.coroutines.flow.MutableStateFlow");
+  compiler.emit("import kotlinx.coroutines.flow.StateFlow");
+  compiler.emit("import kotlinx.coroutines.launch");
+  if (usedTraits.has("lens_recognize") || usedTraits.has("lens_product_id") || usedTraits.has("lens_plant_animal_id") || usedTraits.has("lens_landmark_info")) {
+    compiler.emit("import com.google.mlkit.vision.common.InputImage");
+    compiler.emit("import com.google.mlkit.vision.objects.ObjectDetection");
+    compiler.emit("import com.google.mlkit.vision.objects.defaults.ObjectDetectorOptions");
+    compiler.emit("import com.google.mlkit.vision.label.ImageLabeling");
+    compiler.emit("import com.google.mlkit.vision.label.defaults.ImageLabelerOptions");
+  }
+  if (usedTraits.has("lens_text_overlay") || usedTraits.has("lens_translate")) {
+    compiler.emit("import com.google.mlkit.vision.text.TextRecognition");
+    compiler.emit("import com.google.mlkit.vision.text.latin.TextRecognizerOptions");
+  }
+  if (usedTraits.has("lens_translate")) {
+    compiler.emit("import com.google.mlkit.nl.translate.TranslateLanguage");
+    compiler.emit("import com.google.mlkit.nl.translate.Translation");
+    compiler.emit("import com.google.mlkit.nl.translate.TranslatorOptions");
+  }
+  compiler.emit("");
+  compiler.emit(
+    "data class LensDetection(val label: String, val confidence: Float, val text: String? = null)"
+  );
+  compiler.emit("");
+  compiler.emit(`class ${cls}LensManager : ViewModel() {`);
+  compiler.indentLevel++;
+  compiler.emit("");
+  compiler.emit('private val TAG = "HoloLens"');
+  compiler.emit("private val _detections = MutableStateFlow<List<LensDetection>>(emptyList())");
+  compiler.emit("val detections: StateFlow<List<LensDetection>> = _detections");
+  compiler.emit("");
+  if (usedTraits.has("lens_recognize")) {
+    compiler.emit("private val objectDetector by lazy {");
+    compiler.indentLevel++;
+    compiler.emit("ObjectDetection.getClient(ObjectDetectorOptions.Builder()");
+    compiler.emit("    .setDetectorMode(ObjectDetectorOptions.STREAM_MODE)");
+    compiler.emit("    .enableMultipleObjects().enableClassification().build())");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+    compiler.emit("fun recognizeObjects(image: InputImage) {");
+    compiler.indentLevel++;
+    compiler.emit("objectDetector.process(image).addOnSuccessListener { objects ->");
+    compiler.indentLevel++;
+    compiler.emit(
+      "_detections.value = objects.flatMap { it.labels }.map { LensDetection(it.text, it.confidence) }"
+    );
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (usedTraits.has("lens_text_overlay")) {
+    compiler.emit(
+      "private val textRecognizer by lazy { TextRecognition.getClient(TextRecognizerOptions.Builder().build()) }"
+    );
+    compiler.emit("");
+    compiler.emit("fun recognizeText(image: InputImage) {");
+    compiler.indentLevel++;
+    compiler.emit("textRecognizer.process(image).addOnSuccessListener { visionText ->");
+    compiler.indentLevel++;
+    compiler.emit('Log.d(TAG, "Recognized: ${visionText.text}")');
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (usedTraits.has("lens_translate")) {
+    compiler.emit(
+      'fun translateText(text: String, targetLang: String = "es", callback: (String) -> Unit) {'
+    );
+    compiler.indentLevel++;
+    compiler.emit("val options = TranslatorOptions.Builder()");
+    compiler.emit("    .setSourceLanguage(TranslateLanguage.ENGLISH)");
+    compiler.emit("    .setTargetLanguage(targetLang).build()");
+    compiler.emit("val translator = Translation.getClient(options)");
+    compiler.emit("translator.downloadModelIfNeeded().addOnSuccessListener {");
+    compiler.indentLevel++;
+    compiler.emit("translator.translate(text).addOnSuccessListener { callback(it) }");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  compiler.indentLevel--;
+  compiler.emit("}");
+  return compiler.lines.join("\n");
+}
+function hasWebXRTraits(composition) {
+  const names = chunkDTGBOSEM_cjs.WEBXR_TRAITS;
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (names.includes(name)) return true;
+    }
+  }
+  return false;
+}
+function collectWebXRTraits(composition) {
+  const usedTraits = /* @__PURE__ */ new Set();
+  for (const obj of composition.objects || []) {
+    for (const trait of obj.traits || []) {
+      const name = typeof trait === "string" ? trait : trait.name;
+      if (chunkDTGBOSEM_cjs.WEBXR_TRAITS.includes(name)) {
+        usedTraits.add(name);
+      }
+    }
+  }
+  return usedTraits;
+}
+function emitWebXRSetup(compiler, composition) {
+  compiler.lines = [];
+  compiler.indentLevel = 0;
+  const usedTraits = collectWebXRTraits(composition);
+  const compositionName = compiler.escapeStringValue(composition.name, "TypeScript");
+  const sessionType = usedTraits.has("webxr_session") ? "immersive-ar" : usedTraits.has("webxr_inline") ? "inline" : "immersive-ar";
+  const refSpace = usedTraits.has("webxr_reference_space") ? "local-floor" : "local";
+  const requiredFeatures = [];
+  if (usedTraits.has("webxr_hit_test")) requiredFeatures.push("hit-test");
+  if (usedTraits.has("webxr_anchors")) requiredFeatures.push("anchors");
+  if (usedTraits.has("webxr_light_estimation")) requiredFeatures.push("light-estimation");
+  if (usedTraits.has("webxr_dom_overlay")) requiredFeatures.push("dom-overlay");
+  if (usedTraits.has("webxr_depth_sensing")) requiredFeatures.push("depth-sensing");
+  if (usedTraits.has("webxr_hand_tracking")) requiredFeatures.push("hand-tracking");
+  if (usedTraits.has("webxr_layers")) requiredFeatures.push("layers");
+  compiler.emit("<!DOCTYPE html>");
+  compiler.emit(`<html lang="en">`);
+  compiler.emit("<head>");
+  compiler.indentLevel++;
+  compiler.emit('<meta charset="utf-8">');
+  compiler.emit('<meta name="viewport" content="width=device-width, initial-scale=1.0">');
+  compiler.emit(`<title>${compositionName} \u2014 WebXR</title>`);
+  compiler.emit("<style>");
+  compiler.indentLevel++;
+  compiler.emit("body { margin: 0; overflow: hidden; }");
+  compiler.emit("canvas { display: block; }");
+  if (usedTraits.has("webxr_dom_overlay")) {
+    compiler.emit(
+      "#overlay { position: absolute; top: 0; left: 0; width: 100%; height: 100%; pointer-events: none; z-index: 1; }"
+    );
+    compiler.emit(
+      "#overlay .ui-panel { pointer-events: auto; background: rgba(0,0,0,0.6); color: #fff; padding: 12px; border-radius: 8px; margin: 16px; font-family: sans-serif; }"
+    );
+  }
+  compiler.emit(
+    "#no-xr { display: none; padding: 20px; text-align: center; font-family: sans-serif; }"
+  );
+  compiler.indentLevel--;
+  compiler.emit("</style>");
+  compiler.emit('<script type="importmap">');
+  compiler.emit(
+    '{ "imports": { "three": "https://unpkg.com/three@0.160.0/build/three.module.js", "three/addons/": "https://unpkg.com/three@0.160.0/examples/jsm/" } }'
+  );
+  compiler.emit("</script>");
+  compiler.indentLevel--;
+  compiler.emit("</head>");
+  compiler.emit("<body>");
+  compiler.indentLevel++;
+  if (usedTraits.has("webxr_dom_overlay")) {
+    compiler.emit('<div id="overlay">');
+    compiler.indentLevel++;
+    compiler.emit(`<div class="ui-panel">${compositionName}</div>`);
+    compiler.indentLevel--;
+    compiler.emit("</div>");
+  }
+  compiler.emit('<div id="no-xr">WebXR not supported on this browser/device.</div>');
+  compiler.emit('<script type="module">');
+  compiler.indentLevel++;
+  compiler.emit("import * as THREE from 'three';");
+  compiler.emit("");
+  compiler.emit("if (!navigator.xr) {");
+  compiler.indentLevel++;
+  compiler.emit("document.getElementById('no-xr').style.display = 'block';");
+  compiler.emit("throw new Error('WebXR not supported');");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("const renderer = new THREE.WebGLRenderer({ alpha: true, antialias: true });");
+  compiler.emit("renderer.setPixelRatio(window.devicePixelRatio);");
+  compiler.emit("renderer.setSize(window.innerWidth, window.innerHeight);");
+  compiler.emit("renderer.xr.enabled = true;");
+  compiler.emit("document.body.appendChild(renderer.domElement);");
+  compiler.emit("");
+  compiler.emit("const scene = new THREE.Scene();");
+  compiler.emit(
+    "const camera = new THREE.PerspectiveCamera(70, window.innerWidth / window.innerHeight, 0.01, 100);"
+  );
+  compiler.emit("");
+  compiler.emit("scene.add(new THREE.AmbientLight(0xffffff, 0.6));");
+  if (usedTraits.has("webxr_light_estimation")) {
+    compiler.emit("");
+    compiler.emit("// WebXR Light Estimation");
+    compiler.emit("const estimatedLight = new THREE.DirectionalLight(0xffffff, 1.0);");
+    compiler.emit("estimatedLight.position.set(0.5, 1, 0.5);");
+    compiler.emit("scene.add(estimatedLight);");
+    compiler.emit("let xrLightProbe = null;");
+  }
+  compiler.emit("");
+  compiler.emit("// Scene objects from HoloScript composition");
+  for (const obj of composition.objects || []) {
+    const objName = obj.name || "Object";
+    const shape = compiler.findObjProp(obj, "shape");
+    const color = compiler.findObjProp(obj, "color");
+    const position = compiler.findObjProp(obj, "position");
+    let geometryClass = "BoxGeometry(0.1, 0.1, 0.1)";
+    if (shape === "sphere") geometryClass = "SphereGeometry(0.05, 32, 32)";
+    else if (shape === "cylinder") geometryClass = "CylinderGeometry(0.05, 0.05, 0.1, 32)";
+    else if (shape === "plane") geometryClass = "PlaneGeometry(0.2, 0.2)";
+    const colorHex = typeof color === "string" ? color : "#4488ff";
+    const pos = Array.isArray(position) && position.length >= 3 ? position : [0, 0, -1];
+    compiler.emit("{");
+    compiler.indentLevel++;
+    compiler.emit(`const geometry = new THREE.${geometryClass};`);
+    compiler.emit(`const material = new THREE.MeshStandardMaterial({ color: '${colorHex}' });`);
+    compiler.emit("const mesh = new THREE.Mesh(geometry, material);");
+    compiler.emit(`mesh.name = '${compiler.escapeStringValue(objName, "TypeScript")}';`);
+    compiler.emit(`mesh.position.set(${pos[0]}, ${pos[1]}, ${pos[2]});`);
+    compiler.emit("scene.add(mesh);");
+    compiler.indentLevel--;
+    compiler.emit("}");
+  }
+  compiler.emit("");
+  if (usedTraits.has("webxr_hit_test")) {
+    compiler.emit("// Hit test reticle");
+    compiler.emit("const reticle = new THREE.Mesh(");
+    compiler.emit("  new THREE.RingGeometry(0.05, 0.06, 32).rotateX(-Math.PI / 2),");
+    compiler.emit("  new THREE.MeshBasicMaterial({ color: 0x00ff00 })");
+    compiler.emit(");");
+    compiler.emit("reticle.matrixAutoUpdate = false;");
+    compiler.emit("reticle.visible = false;");
+    compiler.emit("scene.add(reticle);");
+    compiler.emit("let hitTestSource = null;");
+    compiler.emit("");
+  }
+  if (usedTraits.has("webxr_framebuffer")) {
+    compiler.emit("let xrFramebuffer = null;");
+    compiler.emit("");
+  }
+  if (usedTraits.has("webxr_anchors")) {
+    compiler.emit("const anchors = new Map();");
+    compiler.emit("");
+    compiler.emit("async function createAnchor(frame, refSpace, position) {");
+    compiler.indentLevel++;
+    compiler.emit("const anchorPose = new XRRigidTransform(position);");
+    compiler.emit("const anchor = await frame.createAnchor(anchorPose, refSpace);");
+    compiler.emit("anchors.set(anchor, position);");
+    compiler.emit("return anchor;");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (usedTraits.has("webxr_hand_tracking")) {
+    compiler.emit("function updateHands(frame, refSpace) {");
+    compiler.indentLevel++;
+    compiler.emit("for (const source of frame.session.inputSources) {");
+    compiler.indentLevel++;
+    compiler.emit("if (!source.hand) continue;");
+    compiler.emit("for (const [name, jointSpace] of source.hand) {");
+    compiler.indentLevel++;
+    compiler.emit("const jointPose = frame.getJointPose(jointSpace, refSpace);");
+    compiler.emit("if (jointPose) { /* joint position: jointPose.transform.position */ }");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  compiler.emit("// Session configuration");
+  compiler.emit("const sessionOptions = {");
+  compiler.indentLevel++;
+  if (requiredFeatures.length > 0) {
+    const featStr = requiredFeatures.map((f) => `'${f}'`).join(", ");
+    compiler.emit(`requiredFeatures: [${featStr}],`);
+  }
+  if (usedTraits.has("webxr_dom_overlay")) {
+    compiler.emit("domOverlay: { root: document.getElementById('overlay') },");
+  }
+  if (usedTraits.has("webxr_depth_sensing")) {
+    compiler.emit(
+      'depthSensing: { usagePreference: ["cpu-optimized"], dataFormatPreference: ["luminance-alpha"] },'
+    );
+  }
+  compiler.indentLevel--;
+  compiler.emit("};");
+  compiler.emit("");
+  compiler.emit(
+    `navigator.xr.requestSession('${sessionType}', sessionOptions).then(async (session) => {`
+  );
+  compiler.indentLevel++;
+  compiler.emit(`const refSpace = await session.requestReferenceSpace('${refSpace}');`);
+  compiler.emit("renderer.xr.setReferenceSpace(refSpace);");
+  compiler.emit("renderer.xr.setSession(session);");
+  compiler.emit("");
+  if (usedTraits.has("webxr_hit_test")) {
+    compiler.emit("// Initialize hit test source");
+    compiler.emit("const viewerSpace = await session.requestReferenceSpace('viewer');");
+    compiler.emit("hitTestSource = await session.requestHitTestSource({ space: viewerSpace });");
+    compiler.emit("");
+  }
+  if (usedTraits.has("webxr_light_estimation")) {
+    compiler.emit("// Initialize light probe");
+    compiler.emit("xrLightProbe = await session.requestLightProbe();");
+    compiler.emit("");
+  }
+  if (usedTraits.has("webxr_layers")) {
+    compiler.emit("// XR Layers");
+    compiler.emit("const xrProjectionLayer = renderer.xr.getBaseLayer();");
+    compiler.emit("");
+  }
+  compiler.emit("renderer.setAnimationLoop((timestamp, frame) => {");
+  compiler.indentLevel++;
+  compiler.emit("if (!frame) return;");
+  compiler.emit("");
+  if (usedTraits.has("webxr_hit_test")) {
+    compiler.emit("if (hitTestSource) {");
+    compiler.indentLevel++;
+    compiler.emit("const hitTestResults = frame.getHitTestResults(hitTestSource);");
+    compiler.emit("if (hitTestResults.length > 0) {");
+    compiler.indentLevel++;
+    compiler.emit("const hit = hitTestResults[0];");
+    compiler.emit("reticle.visible = true;");
+    compiler.emit("reticle.matrix.fromArray(hit.getPose(refSpace).transform.matrix);");
+    compiler.indentLevel--;
+    compiler.emit("} else { reticle.visible = false; }");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (usedTraits.has("webxr_light_estimation")) {
+    compiler.emit("if (xrLightProbe) {");
+    compiler.indentLevel++;
+    compiler.emit("const estimate = frame.getLightEstimate(xrLightProbe);");
+    compiler.emit("if (estimate) {");
+    compiler.indentLevel++;
+    compiler.emit("const dir = estimate.primaryLightDirection;");
+    compiler.emit("estimatedLight.position.set(dir[0], dir[1], dir[2]);");
+    compiler.emit("estimatedLight.intensity = estimate.primaryLightIntensity?.y || 1.0;");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (usedTraits.has("webxr_depth_sensing")) {
+    compiler.emit("// Depth sensing");
+    compiler.emit("const viewerPose = frame.getViewerPose(refSpace);");
+    compiler.emit("if (viewerPose) {");
+    compiler.indentLevel++;
+    compiler.emit("for (const view of viewerPose.views) {");
+    compiler.indentLevel++;
+    compiler.emit("const depthInfo = frame.getDepthInformation(view);");
+    compiler.emit("if (depthInfo) { /* depthInfo.data contains depth buffer */ }");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
+  }
+  if (usedTraits.has("webxr_hand_tracking")) {
+    compiler.emit("updateHands(frame, refSpace);");
+    compiler.emit("");
+  }
+  if (usedTraits.has("webxr_framebuffer")) {
+    compiler.emit("xrFramebuffer = renderer.xr.getBaseLayer()?.framebuffer || null;");
+    compiler.emit("");
+  }
+  compiler.emit("renderer.render(scene, camera);");
+  compiler.indentLevel--;
+  compiler.emit("});");
+  compiler.emit("");
+  compiler.emit("session.addEventListener('end', () => {");
+  compiler.indentLevel++;
+  compiler.emit("renderer.setAnimationLoop(null);");
+  if (usedTraits.has("webxr_hit_test")) {
+    compiler.emit("hitTestSource = null;");
+  }
+  compiler.indentLevel--;
+  compiler.emit("});");
+  compiler.indentLevel--;
+  compiler.emit(
+    "}).catch(err => { console.error('WebXR session failed:', err); document.getElementById('no-xr').style.display = 'block'; });"
+  );
+  compiler.indentLevel--;
+  compiler.emit("</script>");
+  compiler.indentLevel--;
+  compiler.emit("</body>");
+  compiler.emit("</html>");
+  return compiler.lines.join("\n");
+}
+var init_AndroidPeripheralGenerators = chunkHCCQLAA4_cjs.__esm({
+  "src/compiler/AndroidPeripheralGenerators.ts"() {
+    chunkDTGBOSEM_cjs.init_haptic_feedback();
+    chunkDTGBOSEM_cjs.init_nearby_connections();
+    chunkDTGBOSEM_cjs.init_foldable_display();
+    chunkDTGBOSEM_cjs.init_samsung_dex();
+    chunkDTGBOSEM_cjs.init_google_lens();
+    chunkDTGBOSEM_cjs.init_webxr();
+  }
+});
+
+// src/compiler/AndroidCompiler.ts
+var AndroidCompiler_exports = {};
+chunkHCCQLAA4_cjs.__export(AndroidCompiler_exports, {
+  AndroidCompiler: () => exports.AndroidCompiler,
+  compileToAndroid: () => compileToAndroid
+});
+function compileToAndroid(composition, options) {
+  const compiler = new exports.AndroidCompiler(options);
+  return Promise.resolve(compiler.compile(composition, "test-token", void 0));
+}
+exports.AndroidCompiler = void 0;
+var init_AndroidCompiler = chunkHCCQLAA4_cjs.__esm({
+  "src/compiler/AndroidCompiler.ts"() {
+    chunkKKP7JKN4_cjs.init_CompilerBase();
+    init_AndroidARGenerators();
+    init_AndroidFeatureGenerators();
+    init_AndroidPeripheralGenerators();
+    chunkFEWUHQNM_cjs.init_AndroidKotlinHelpers();
+    exports.AndroidCompiler = class extends chunkKKP7JKN4_cjs.CompilerBase {
+      constructor(options = {}) {
+        super();
+        this.compilerName = "AndroidCompiler";
+        this.lines = [];
+        this.indentLevel = 0;
+        this.options = {
+          packageName: options.packageName || "com.holoscript.generated",
+          className: options.className || "GeneratedARScene",
+          indent: options.indent || "    ",
+          minSdk: options.minSdk || 26,
+          targetSdk: options.targetSdk || 34,
+          useJetpackCompose: options.useJetpackCompose ?? true,
+          useSceneform: options.useSceneform ?? true,
+          useFilament: options.useFilament ?? false
+        };
+      }
+      getRequiredCapability() {
+        return ans.ANSCapabilityPath.ANDROID;
+      }
+      compile(composition, agentToken, outputPath) {
+        this.validateCompilerAccess(agentToken, outputPath);
+        const result = {
+          activityFile: generateActivityFile(this, composition),
+          stateFile: generateStateFile(this, composition),
+          nodeFactoryFile: generateNodeFactoryFile(this, composition),
+          manifestFile: generateManifestFile(this, composition),
+          buildGradle: generateBuildGradle(this, composition)
+        };
+        if (hasNPUSceneTraits(composition)) {
+          result.npuSceneSetup = emitNPUSceneSetup(this, composition);
+        }
+        if (hasAuthoringTraits(composition)) {
+          result.authoringSetup = emitAuthoringSetup(this, composition);
+        }
+        if (hasHapticTraits(composition)) {
+          result.hapticSetup = emitHapticSetup(this, composition);
+        }
+        if (hasNearbyTraits(composition)) {
+          result.nearbySetup = emitNearbySetup(this, composition);
+        }
+        if (hasFoldableTraits(composition)) {
+          result.foldableSetup = emitFoldableSetup(this, composition);
+        }
+        if (hasDexTraits(composition)) {
+          result.dexSetup = emitDexSetup(this, composition);
+        }
+        if (hasLensTraits(composition)) {
+          result.lensSetup = emitLensSetup(this, composition);
+        }
+        if (hasWebXRTraits(composition)) {
+          result.webxrSetup = emitWebXRSetup(this, composition);
+        }
+        return result;
+      }
+      emit(line) {
+        const indent = this.options.indent.repeat(this.indentLevel);
+        this.lines.push(indent + line);
+      }
+      /** @deprecated Use sanitizeNameCapitalized from AndroidKotlinHelpers */
+      sanitizeName(name) {
+        return chunkFEWUHQNM_cjs.sanitizeNameCapitalized(name);
+      }
+      /** @deprecated Use getSceneformGeometry from AndroidKotlinHelpers */
+      getSceneformGeometry(meshType) {
+        return chunkFEWUHQNM_cjs.getSceneformGeometry(meshType);
+      }
+      /** @deprecated Use findObjProp from AndroidKotlinHelpers */
+      findObjProp(obj, key) {
+        return chunkFEWUHQNM_cjs.findObjProp(obj, key);
+      }
+      /** @deprecated Use toKotlinType from AndroidKotlinHelpers */
+      toKotlinType(value) {
+        return chunkFEWUHQNM_cjs.toKotlinType(value);
+      }
+      /** @deprecated Use toKotlinValue from AndroidKotlinHelpers */
+      toKotlinValue(value) {
+        return chunkFEWUHQNM_cjs.toKotlinValue(value, (s, t) => this.escapeStringValue(s, t));
+      }
+      /** @deprecated Use toAndroidColor from AndroidKotlinHelpers */
+      toAndroidColor(value) {
+        return chunkFEWUHQNM_cjs.toAndroidColor(value);
+      }
+      /** @deprecated Use compositionHasTrait from AndroidKotlinHelpers */
+      compositionHasTrait(composition, traitName) {
+        return chunkFEWUHQNM_cjs.compositionHasTrait(composition, traitName);
+      }
+    };
+  }
+});
+
+exports.AndroidCompiler_exports = AndroidCompiler_exports;
+exports.compileToAndroid = compileToAndroid;
+exports.init_AndroidCompiler = init_AndroidCompiler;
+//# sourceMappingURL=chunk-KQCN6AKJ.cjs.map
+//# sourceMappingURL=chunk-KQCN6AKJ.cjs.map