@holoscript/core 8.0.8 → 8.0.9

package/dist/{chunk-GSOUNWEL.js → chunk-HVX7QQYK.js}

@@ -1,1011 +1,1010 @@
-import { init_AndroidKotlinHelpers, sanitizeNameCapitalized, getSceneformGeometry, findObjProp, toKotlinType, toKotlinValue, toAndroidColor, compositionHasTrait } from './chunk-FDSGHPAK.js';
-import { init_CompilerBase, CompilerBase } from './chunk-C7ZBSV2Q.js';
-import { init_geospatial, init_depth_scanner, init_spatial_authoring, init_haptic_feedback, init_nearby_connections, init_foldable_display, init_samsung_dex, init_google_lens, init_webxr, SPATIAL_AUTHORING_TRAITS, SPATIAL_AUTHORING_DEFAULTS, HAPTIC_FEEDBACK_TRAITS, NEARBY_CONNECTIONS_TRAITS, FOLDABLE_DISPLAY_TRAITS, SAMSUNG_DEX_TRAITS, GOOGLE_LENS_TRAITS, WEBXR_TRAITS, DEPTH_SCANNER_TRAITS, GEOSPATIAL_DEFAULTS, DEPTH_SCANNER_DEFAULTS } from './chunk-WKX5AMOY.js';
-import { init_portal_ar, init_camera_hand_tracking, init_npu_scene, NPU_SCENE_TRAITS, NPU_SCENE_DEFAULTS, CAMERA_HAND_TRACKING_TRAITS, PORTAL_AR_TRAITS } from './chunk-CBJY23VL.js';
-import { __esm, __export } from './chunk-OL46QLBJ.js';
+import { init_AndroidKotlinHelpers, sanitizeNameCapitalized, getSceneformGeometry, findObjProp, toKotlinType, toKotlinValue, toAndroidColor, compositionHasTrait, toKotlinColor } from './chunk-CBSDJF3B.js';
+import { init_CompilerBase, CompilerBase } from './chunk-DUG3OQAS.js';
+import { init_geospatial, init_depth_scanner, init_spatial_authoring, init_haptic_feedback, init_nearby_connections, init_foldable_display, init_samsung_dex, init_google_lens, init_webxr, GEOSPATIAL_DEFAULTS, DEPTH_SCANNER_DEFAULTS, SPATIAL_AUTHORING_TRAITS, SPATIAL_AUTHORING_DEFAULTS, HAPTIC_FEEDBACK_TRAITS, NEARBY_CONNECTIONS_TRAITS, FOLDABLE_DISPLAY_TRAITS, SAMSUNG_DEX_TRAITS, GOOGLE_LENS_TRAITS, WEBXR_TRAITS, DEPTH_SCANNER_TRAITS } from './chunk-7I74JWPW.js';
+import { init_portal_ar, init_camera_hand_tracking, init_npu_scene, NPU_SCENE_TRAITS, NPU_SCENE_DEFAULTS, PORTAL_AR_TRAITS, CAMERA_HAND_TRACKING_TRAITS } from './chunk-MD4IVS42.js';
+import { __esm, __export } from './chunk-W4GABFCR.js';
 import { ANSCapabilityPath } from '@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;
+// src/compiler/AndroidSceneViewFeatureGenerators.ts
+function objectsOf(composition) {
+  return composition.objects ?? [];
+}
+function traitsOf(obj) {
+  return obj.traits ?? [];
+}
+function traitName(trait) {
+  return typeof trait === "string" ? trait : trait.name ?? "";
+}
+function traitConfig(trait) {
+  if (!trait || typeof trait === "string") return {};
+  return trait.config ?? trait.params ?? {};
+}
+function findTrait(obj, name) {
+  return traitsOf(obj).find((trait) => traitName(trait) === name);
+}
+function hasAnyTrait(composition, names) {
+  return objectsOf(composition).some(
+    (obj) => traitsOf(obj).some((trait) => names.includes(traitName(trait)))
+  );
+}
+function collectUsedTraits(composition, names) {
+  const used = /* @__PURE__ */ new Set();
+  for (const obj of objectsOf(composition)) {
+    for (const trait of traitsOf(obj)) {
+      const name = traitName(trait);
+      if (names.includes(name)) used.add(name);
     }
   }
-  return false;
+  return [...used].sort();
 }
-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;
-    }
+function numberConfig(config, keys, fallback) {
+  for (const key of keys) {
+    const raw = config[key];
+    const numeric = typeof raw === "number" ? raw : Number(raw);
+    if (Number.isFinite(numeric)) return numeric;
   }
-  return false;
+  return fallback;
+}
+function floatLiteral(value) {
+  return `${Number.isInteger(value) ? value.toFixed(0) : value}f`;
+}
+function quotedKotlin(compiler, value) {
+  return `"${compiler.escapeStringValue(String(value), "Kotlin")}"`;
+}
+function emitHeader(compiler, composition, title, requirements) {
+  compiler.lines = [];
+  compiler.indentLevel = 0;
+  compiler.emit(`// Auto-generated by HoloScript AndroidCompiler - ${title}`);
+  compiler.emit(
+    `// Source: composition "${compiler.escapeStringValue(String(composition.name), "Kotlin")}"`
+  );
+  for (const requirement of requirements) {
+    compiler.emit(`// Requires ${requirement}`);
+  }
+  compiler.emit("// SceneView-native sidecar generated without legacy fragment or node factories.");
+  compiler.emit("");
+  compiler.emit(`package ${compiler.options.packageName}`);
+  compiler.emit("");
+}
+function finish(compiler) {
+  return `${compiler.lines.join("\n")}
+`;
+}
+function emitUsedTraits(compiler, used) {
+  if (used.length === 0) {
+    compiler.emit("private val usedTraits = emptySet<String>()");
+    return;
+  }
+  compiler.emit(`private val usedTraits = setOf(${used.map((trait) => `"${trait}"`).join(", ")})`);
+}
+function hasGeoAnchorTraits(composition) {
+  return hasAnyTrait(composition, GEO_ANCHOR_TRAITS);
+}
+function hasGeoTraits(composition) {
+  return hasGeoAnchorTraits(composition) || hasGeospatialVPSTraits(composition);
+}
+function hasGeospatialVPSTraits(composition) {
+  return hasAnyTrait(composition, GEOSPATIAL_TRAITS);
+}
+function hasDepthScanTraits(composition) {
+  return hasAnyTrait(composition, DEPTH_SCANNER_TRAITS);
+}
+function hasPortalARTraits(composition) {
+  return hasAnyTrait(composition, PORTAL_AR_TRAITS);
+}
+function hasHandTrackingTraits(composition) {
+  return hasAnyTrait(composition, CAMERA_HAND_TRACKING_TRAITS);
 }
 function emitGeoAnchorSetup(compiler, composition) {
+  emitHeader(compiler, composition, "SceneView Geo-Anchor Setup", [
+    "ARCore Earth anchors",
+    "Google Play Services location"
+  ]);
+  compiler.emit("import android.content.Context");
+  compiler.emit("import android.util.Log");
+  compiler.emit("import com.google.ar.core.Anchor");
+  compiler.emit("import com.google.ar.core.Config");
+  compiler.emit("import com.google.ar.core.Earth");
+  compiler.emit("import com.google.ar.core.Session");
+  compiler.emit("import com.google.ar.core.TrackingState");
   compiler.emit("");
-  compiler.emit("// === Geo-Anchor: GPS-pinned persistent holograms ===");
   compiler.emit(
-    "private var fusedLocationClient: com.google.android.gms.location.FusedLocationProviderClient? = null"
+    `class ${compiler.options.className}GeoAnchorManager(private val context: Context) {`
   );
+  compiler.indentLevel++;
+  emitUsedTraits(compiler, collectUsedTraits(composition, GEO_ANCHOR_TRAITS));
   compiler.emit("private val geoAnchors = mutableMapOf<String, Anchor>()");
+  compiler.emit("private val requestedAnchors = listOf(");
+  compiler.indentLevel++;
+  const anchors = objectsOf(composition).filter((obj) => findTrait(obj, "geo_anchor"));
+  if (anchors.length === 0) {
+    compiler.emit("// No explicit geo_anchor objects; call createGeoAnchor at runtime.");
+  }
+  anchors.forEach((obj, index) => {
+    const geoConfig = traitConfig(findTrait(obj, "geo_anchor"));
+    const altitudeConfig = traitConfig(findTrait(obj, "geo_altitude"));
+    const headingConfig = traitConfig(findTrait(obj, "geo_compass_heading"));
+    const lat = numberConfig(geoConfig, ["latitude", "lat"], 0);
+    const lng = numberConfig(geoConfig, ["longitude", "lng"], 0);
+    const altitude = numberConfig(altitudeConfig, ["meters", "altitude"], 0);
+    const heading = numberConfig(headingConfig, ["degrees", "heading"], 0);
+    compiler.emit(
+      `SceneViewGeoAnchor(${quotedKotlin(compiler, obj.name)}, ${lat}, ${lng}, ${altitude}, ${floatLiteral(
+        heading
+      )})${index === anchors.length - 1 ? "" : ","}`
+    );
+  });
+  compiler.indentLevel--;
+  compiler.emit(")");
   compiler.emit("");
-  compiler.emit("private fun setupGeoAnchors() {");
+  compiler.emit("fun setupGeoAnchors(session: Session, earth: Earth?) {");
+  compiler.indentLevel++;
+  compiler.emit("configureSessionForGeospatial(session)");
+  compiler.emit("val earthRef = earth ?: return");
+  compiler.emit("for (anchor in requestedAnchors) {");
   compiler.indentLevel++;
   compiler.emit(
-    "fusedLocationClient = com.google.android.gms.location.LocationServices.getFusedLocationProviderClient(this)"
+    "createGeoAnchor(anchor.name, earthRef, anchor.latitude, anchor.longitude, anchor.altitude, anchor.heading)"
   );
-  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("}");
+  if (compiler.compositionHasTrait(composition, "geo_persist")) {
+    compiler.emit("restoreGeoAnchors { name, restored -> geoAnchors[name] = restored }");
   }
   compiler.indentLevel--;
   compiler.emit("}");
   compiler.emit("");
+  compiler.emit("fun configureSessionForGeospatial(session: Session) {");
+  compiler.indentLevel++;
+  compiler.emit("val config = session.config");
+  compiler.emit("config.geospatialMode = Config.GeospatialMode.ENABLED");
+  compiler.emit("session.configure(config)");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
   compiler.emit(
-    "private fun createGeoAnchor(name: String, lat: Double, lng: Double, alt: Double, heading: Float) {"
+    "fun createGeoAnchor(name: String, earth: Earth, latitude: Double, longitude: Double, altitude: Double, heading: Float): Anchor? {"
   );
   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("if (earth.trackingState != TrackingState.TRACKING) return null");
+  compiler.emit("val halfRadians = Math.toRadians(heading.toDouble()) / 2.0");
   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())"
+    "val anchor = earth.createAnchor(latitude, longitude, altitude, 0f, 0f, Math.sin(halfRadians).toFloat(), Math.cos(halfRadians).toFloat())"
   );
   compiler.emit("geoAnchors[name] = anchor");
+  compiler.emit('Log.d("HoloScript", "SceneView geo anchor created: " + name)');
+  if (compiler.compositionHasTrait(composition, "geo_cloud_anchor") || compiler.compositionHasTrait(composition, "geo_persist")) {
+    compiler.emit('saveGeoAnchorToCloud(name, anchor.cloudAnchorId ?: "")');
+  }
+  compiler.emit("return anchor");
+  compiler.indentLevel--;
+  compiler.emit("}");
   compiler.emit("");
-  compiler.emit("val anchorNode = AnchorNode(anchor)");
-  compiler.emit("anchorNode.setParent(arFragment.arSceneView.scene)");
-  compiler.emit("");
-  compiler.emit("NodeFactory.createDefaultNode(this) { renderable ->");
+  compiler.emit("fun saveGeoAnchorToCloud(name: String, cloudAnchorId: String) {");
   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.emit(
+    'context.getSharedPreferences("sceneview_geo_anchors", Context.MODE_PRIVATE).edit().putString(name, cloudAnchorId).apply()'
+  );
   compiler.indentLevel--;
   compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("fun restoreGeoAnchors(onRestore: (String, Anchor) -> Unit) {");
+  compiler.indentLevel++;
+  compiler.emit(
+    "// Cloud anchor resolution is provided by the app shell when network policy is available."
+  );
+  compiler.emit(
+    'Log.d("HoloScript", "restoreGeoAnchors requested for " + usedTraits.joinToString())'
+  );
   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("");
-  }
+  compiler.emit(
+    "data class SceneViewGeoAnchor(val name: String, val latitude: Double, val longitude: Double, val altitude: Double, val heading: Float)"
+  );
+  compiler.indentLevel--;
+  compiler.emit("}");
+  return finish(compiler);
 }
 function emitGeospatialVPSSetup(compiler, composition) {
+  emitHeader(compiler, composition, "SceneView Geospatial VPS Setup", [
+    "ARCore GeospatialMode",
+    "Google Play Services location"
+  ]);
+  compiler.emit("import android.util.Log");
+  compiler.emit("import com.google.ar.core.Anchor");
+  compiler.emit("import com.google.ar.core.Config");
+  compiler.emit("import com.google.ar.core.Earth");
+  compiler.emit("import com.google.ar.core.Session");
+  compiler.emit("import com.google.ar.core.StreetscapeGeometry");
+  compiler.emit("import com.google.ar.core.TrackingState");
   compiler.emit("");
-  compiler.emit("// === ARCore Geospatial API: VPS street-level geo-anchoring ===");
+  compiler.emit(`class ${compiler.options.className}GeospatialVPSManager {`);
+  compiler.indentLevel++;
+  emitUsedTraits(compiler, collectUsedTraits(composition, GEOSPATIAL_TRAITS));
   compiler.emit("private var earth: Earth? = null");
   compiler.emit("private val geospatialAnchors = mutableMapOf<String, Anchor>()");
+  compiler.emit(
+    `private val horizontalAccuracyThreshold = ${GEOSPATIAL_DEFAULTS.vps.accuracyThreshold}.0`
+  );
+  compiler.emit(
+    `private val headingAccuracyThreshold = ${GEOSPATIAL_DEFAULTS.vps.headingAccuracyThreshold}.0`
+  );
   compiler.emit("");
-  compiler.emit("private fun setupGeospatialVPS() {");
+  compiler.emit("fun setupGeospatialVPS(session: Session) {");
   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) {
+  if (compiler.compositionHasTrait(composition, "geospatial_streetscape")) {
     compiler.emit("config.streetscapeGeometryMode = Config.StreetscapeGeometryMode.ENABLED");
   }
   compiler.emit("session.configure(config)");
+  compiler.emit("earth = session.earth");
+  compiler.indentLevel--;
+  compiler.emit("}");
   compiler.emit("");
-  compiler.emit("// Monitor geospatial tracking state");
-  compiler.emit("arFragment.arSceneView.scene.addOnUpdateListener {");
+  compiler.emit("fun updateEarthTracking(session: Session) {");
   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("earth = session.earth");
+  compiler.emit("val earthRef = earth ?: return");
+  compiler.emit("if (earthRef.trackingState != TrackingState.TRACKING) return");
+  compiler.emit("val geospatialState = earthRef.cameraGeospatialPose");
   compiler.emit("val horizontalAccuracy = geospatialState.horizontalAccuracy");
   compiler.emit("val headingAccuracy = geospatialState.headingAccuracy");
+  compiler.emit(
+    "if (horizontalAccuracy > horizontalAccuracyThreshold || headingAccuracy > headingAccuracyThreshold) return"
+  );
+  compiler.emit('Log.d("HoloScript", "cameraGeospatialPose localized")');
+  if (compiler.compositionHasTrait(composition, "geospatial_streetscape")) {
+    compiler.emit("processStreetscapeGeometry(session)");
+  }
+  compiler.indentLevel--;
+  compiler.emit("}");
   compiler.emit("");
   compiler.emit(
-    `if (horizontalAccuracy > ${GEOSPATIAL_DEFAULTS.vps.accuracyThreshold} || headingAccuracy > ${GEOSPATIAL_DEFAULTS.vps.headingAccuracyThreshold}) {`
+    "fun createGeospatialAnchor(name: String, lat: Double, lng: Double, alt: Double, heading: Float): Anchor? {"
   );
   compiler.indentLevel++;
-  compiler.emit("// Accuracy not yet sufficient for anchoring");
-  compiler.emit("return@addOnUpdateListener");
+  compiler.emit("val earthRef = earth ?: return null");
+  compiler.emit("if (earthRef.trackingState != TrackingState.TRACKING) return null");
+  compiler.emit("val halfRadians = Math.toRadians(heading.toDouble()) / 2.0");
+  compiler.emit(
+    "val anchor = earthRef.createAnchor(lat, lng, alt, 0f, 0f, Math.sin(halfRadians).toFloat(), Math.cos(halfRadians).toFloat())"
+  );
+  compiler.emit("geospatialAnchors[name] = anchor");
+  compiler.emit("return anchor");
   compiler.indentLevel--;
   compiler.emit("}");
   compiler.emit("");
   compiler.emit(
-    'android.util.Log.d("HoloScript", "Geospatial tracking: accuracy=$horizontalAccuracy m, heading=$headingAccuracy deg")'
+    "fun resolveTerrainAnchor(name: String, lat: Double, lng: Double, altitudeOffset: Double, heading: Float) {"
+  );
+  compiler.indentLevel++;
+  compiler.emit("val earthRef = earth ?: return");
+  compiler.emit("val halfRadians = Math.toRadians(heading.toDouble()) / 2.0");
+  compiler.emit(
+    "earthRef.resolveAnchorOnTerrainAsync(lat, lng, altitudeOffset, 0f, Math.sin(halfRadians).toFloat(), 0f, Math.cos(halfRadians).toFloat()) { anchor, state ->"
+  );
+  compiler.indentLevel++;
+  compiler.emit(
+    "if (state == Anchor.TerrainAnchorState.SUCCESS && anchor != null) geospatialAnchors[name] = anchor"
   );
-  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) {"
+    "fun resolveRooftopAnchor(name: String, lat: Double, lng: Double, altitudeOffset: Double, heading: Float) {"
   );
   compiler.indentLevel++;
   compiler.emit("val earthRef = earth ?: return");
-  compiler.emit("if (earthRef.trackingState != TrackingState.TRACKING) return");
-  compiler.emit("");
+  compiler.emit("val halfRadians = Math.toRadians(heading.toDouble()) / 2.0");
   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())"
+    "earthRef.resolveAnchorOnRooftopAsync(lat, lng, altitudeOffset, 0f, Math.sin(halfRadians).toFloat(), 0f, Math.cos(halfRadians).toFloat()) { anchor, state ->"
   );
-  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)")'
+    "if (state == Anchor.RooftopAnchorState.SUCCESS && anchor != null) geospatialAnchors[name] = anchor"
   );
   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 (DEPTH_SCANNER_TRAITS.includes(name)) return true;
-    }
-  }
-  return false;
+  compiler.emit("fun processStreetscapeGeometry(session: Session) {");
+  compiler.indentLevel++;
+  compiler.emit("val geometries = session.getAllTrackables(StreetscapeGeometry::class.java)");
+  compiler.emit("for (geometry in geometries) {");
+  compiler.indentLevel++;
+  compiler.emit("if (geometry.trackingState != TrackingState.TRACKING) continue");
+  compiler.emit('Log.d("HoloScript", "Streetscape geometry: " + geometry.type)');
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit(
+    "data class SceneViewGeospatialAnchor(val name: String, val latitude: Double, val longitude: Double, val altitude: Double, val heading: Float)"
+  );
+  compiler.indentLevel--;
+  compiler.emit("}");
+  return finish(compiler);
 }
 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) ===");
+  emitHeader(compiler, composition, "SceneView Depth Scanner Setup", ["ARCore Depth API"]);
+  compiler.emit("import android.media.Image");
+  compiler.emit("import android.util.Log");
+  compiler.emit("import com.google.ar.core.Config");
+  compiler.emit("import com.google.ar.core.Frame");
+  compiler.emit("import com.google.ar.core.Session");
+  compiler.emit("");
+  compiler.emit(`class ${compiler.options.className}DepthScanner {`);
+  compiler.indentLevel++;
+  emitUsedTraits(compiler, collectUsedTraits(composition, DEPTH_SCANNER_TRAITS));
   compiler.emit(
     `private val depthConfidenceThreshold = ${DEPTH_SCANNER_DEFAULTS.scan.confidenceThreshold}`
   );
-  compiler.emit(`private val depthMaxMeters = ${DEPTH_SCANNER_DEFAULTS.scan.maxDepthMeters}f`);
-  compiler.emit(`private val depthMeshDecimation = ${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(
+    `private val depthMaxMeters = ${floatLiteral(DEPTH_SCANNER_DEFAULTS.scan.maxDepthMeters)}`
+  );
+  compiler.emit(
+    `private val depthMeshDecimation = ${floatLiteral(DEPTH_SCANNER_DEFAULTS.scan.meshDecimation)}`
+  );
   compiler.emit("");
-  compiler.emit("private fun setupDepthScanner() {");
+  compiler.emit("fun setupDepthScanner(session: Session) = configureDepthSession(session)");
+  compiler.emit("");
+  compiler.emit("fun configureDepthSession(session: Session) {");
   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('Log.w("HoloScript", "ARCore DepthMode.AUTOMATIC is unavailable")');
   compiler.emit("return");
   compiler.indentLevel--;
   compiler.emit("}");
+  compiler.emit("val config = session.config");
   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.indentLevel--;
+  compiler.emit("}");
   compiler.emit("");
-  if (hasAutoSelect) {
-    compiler.emit("// Auto-select best depth source: ToF > ARCore ML > Stereo");
-    compiler.emit("detectDepthSource()");
-    compiler.emit("");
+  compiler.emit("fun processDepthFrame(frame: Frame): List<DepthPoint> {");
+  compiler.indentLevel++;
+  compiler.emit("val depthImage = frame.acquireDepthImage16Bits()");
+  compiler.emit("val confidenceImage = acquireConfidenceImage(frame)");
+  compiler.emit("val source = detectDepthSource()");
+  compiler.emit("val mesh = generateMeshFromDepth(depthImage, confidenceImage, source)");
+  if (compiler.compositionHasTrait(composition, "depth_mesh_to_holo")) {
+    compiler.emit("convertDepthMeshToHolo(mesh)");
   }
-  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("}");
+  if (compiler.compositionHasTrait(composition, "depth_export")) {
+    compiler.emit("exportDepthMesh(mesh)");
   }
+  compiler.emit("depthImage.close()");
+  compiler.emit("confidenceImage?.close()");
+  compiler.emit("return mesh");
   compiler.indentLevel--;
   compiler.emit("}");
   compiler.emit("");
-  compiler.emit("private fun processDepthFrame(frame: Frame) {");
+  compiler.emit("private fun acquireConfidenceImage(frame: Frame): Image? = try {");
   compiler.indentLevel++;
-  compiler.emit("try {");
+  compiler.emit("frame.acquireRawDepthConfidenceImage()");
+  compiler.indentLevel--;
+  compiler.emit("} catch (_: Throwable) {");
   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.emit("null");
   compiler.indentLevel--;
-  compiler.emit("} catch (e: Exception) {");
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("fun detectDepthSource(): DepthSource {");
   compiler.indentLevel++;
-  compiler.emit('android.util.Log[3]("HoloScript", "Depth frame unavailable: ${e.message}")');
+  compiler.emit("return DepthSource.ARCORE_ML");
   compiler.indentLevel--;
   compiler.emit("}");
+  compiler.emit("");
+  compiler.emit(
+    "fun generateMeshFromDepth(depthImage: Image, confidenceImage: Image?, source: DepthSource): List<DepthPoint> {"
+  );
+  compiler.indentLevel++;
+  compiler.emit("val points = mutableListOf<DepthPoint>()");
+  compiler.emit(
+    "// Depth pixels are projected into SceneView/ARCore world space by the host renderer."
+  );
+  compiler.emit(
+    "points += DepthPoint(0f, 0f, depthMaxMeters.coerceAtMost(1f), depthConfidenceThreshold, source)"
+  );
+  compiler.emit("return points");
   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 = 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 = 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;
+  compiler.emit("fun convertDepthMeshToHolo(points: List<DepthPoint>): String {");
+  compiler.indentLevel++;
+  compiler.emit('return "holo_depth_mesh_vertices=" + points.size');
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("fun exportDepthMesh(points: List<DepthPoint>): String {");
+  compiler.indentLevel++;
+  compiler.emit(
+    'return buildString { appendLine("# HoloScript Depth Scan Export"); appendLine(points.size) }'
+  );
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("enum class DepthSource { TOF, ARCORE_ML, STEREO }");
+  compiler.emit(
+    "data class DepthPoint(val x: Float, val y: Float, val z: Float, val confidence: Int, val source: DepthSource)"
+  );
+  compiler.indentLevel--;
+  compiler.emit("}");
+  return finish(compiler);
 }
 function emitPortalARSetup(compiler, composition) {
+  emitHeader(compiler, composition, "SceneView Portal AR Setup", [
+    "ARCore Depth API",
+    "SceneView camera pose callbacks"
+  ]);
+  compiler.emit("import android.util.Log");
+  compiler.emit("import com.google.ar.core.Config");
+  compiler.emit("import com.google.ar.core.Frame");
+  compiler.emit("import com.google.ar.core.Pose");
+  compiler.emit("import com.google.ar.core.Session");
   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(`class ${compiler.options.className}PortalARManager {`);
+  compiler.indentLevel++;
+  emitUsedTraits(compiler, collectUsedTraits(composition, PORTAL_AR_TRAITS));
+  compiler.emit("private val portalTiltThreshold = 25f");
+  compiler.emit("private var portalVisible = true");
+  compiler.emit("private var portalBoundary = PortalBoundary(PortalBoundary.Shape.CIRCLE)");
   compiler.emit("");
-  compiler.emit("private fun setupPortalAR() {");
+  compiler.emit("fun setupPortalAR(session: Session) {");
   compiler.indentLevel++;
-  compiler.emit("val session = arFragment.arSceneView.session ?: return");
+  compiler.emit("configurePortalSession(session)");
+  compiler.emit("setPortalVisibility(true)");
+  compiler.indentLevel--;
+  compiler.emit("}");
   compiler.emit("");
-  compiler.emit("// Enable depth mode for portal occlusion");
-  compiler.emit("val config = Config(session)");
+  compiler.emit("fun configurePortalSession(session: Session) {");
+  compiler.indentLevel++;
+  compiler.emit("val config = session.config");
+  compiler.emit("if (session.isDepthModeSupported(Config.DepthMode.AUTOMATIC)) {");
+  compiler.indentLevel++;
   compiler.emit("config.depthMode = Config.DepthMode.AUTOMATIC");
+  compiler.indentLevel--;
+  compiler.emit("}");
   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.indentLevel--;
+  compiler.emit("}");
   compiler.emit("");
-  compiler.emit("// Create holographic render layer behind reality");
-  compiler.emit("portalRenderer = HolographicRenderer(this)");
-  compiler.emit("portalRenderer?.initialize(session)");
+  compiler.emit("fun updateDepthOcclusion(frame: Frame) {");
+  compiler.indentLevel++;
+  compiler.emit('Log.d("HoloScript", "updateDepthOcclusion with ARCore depth")');
+  compiler.indentLevel--;
+  compiler.emit("}");
   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.emit("fun applyParallaxCorrection(cameraPose: Pose) {");
+  compiler.indentLevel++;
+  compiler.emit('Log.d("HoloScript", "applyParallaxCorrection from SceneView camera pose")');
   compiler.indentLevel--;
   compiler.emit("}");
-}
-function hasHandTrackingTraits(composition) {
-  const handTraitNames = 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;
+  compiler.emit("");
+  compiler.emit("fun enableDepthFade(enabled: Boolean = true) {");
+  compiler.indentLevel++;
+  compiler.emit('Log.d("HoloScript", "enableDepthFade=" + enabled)');
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("fun reconstructMesh(session: Session) {");
+  compiler.indentLevel++;
+  compiler.emit('Log.d("HoloScript", "reconstructMesh for portal world mesh")');
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("fun updateMeshOcclusion() {");
+  compiler.indentLevel++;
+  compiler.emit('Log.d("HoloScript", "updateMeshOcclusion")');
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("fun updatePeekThrough(deviceTiltDegrees: Float) {");
+  compiler.indentLevel++;
+  compiler.emit("setPortalVisibility(kotlin.math.abs(deviceTiltDegrees) > portalTiltThreshold)");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("fun setPortalVisibility(visible: Boolean) {");
+  compiler.indentLevel++;
+  compiler.emit("portalVisible = visible");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("fun updateLighting(frame: Frame) {");
+  compiler.indentLevel++;
+  compiler.emit('Log.d("HoloScript", "updateLighting from ENVIRONMENTAL_HDR estimate")');
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit("data class PortalBoundary(val shape: Shape) {");
+  compiler.indentLevel++;
+  compiler.emit("enum class Shape { CIRCLE, RECTANGLE, FREEFORM }");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  return finish(compiler);
 }
 function emitHandTrackingSetup(compiler, composition) {
+  emitHeader(compiler, composition, "SceneView Camera Hand Tracking Setup", [
+    "CameraX",
+    "MediaPipe Hands / HandLandmarker"
+  ]);
+  compiler.emit("import android.content.Context");
+  compiler.emit("import android.util.Log");
+  compiler.emit("import com.google.mediapipe.framework.image.MPImage");
+  compiler.emit("import com.google.mediapipe.tasks.vision.handlandmarker.HandLandmarker");
+  compiler.emit("import com.google.mediapipe.tasks.vision.handlandmarker.HandLandmarkerResult");
   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)"
+    `class ${compiler.options.className}HandTrackingManager(private val context: Context) {`
   );
-  if (hasConfidence) {
-    compiler.emit("    .setMinHandDetectionConfidence(0.7f)");
-  } else {
-    compiler.emit("    .setMinHandDetectionConfidence(0.5f)");
-  }
-  compiler.emit("    .setMinTrackingConfidence(0.5f)");
-  compiler.emit("    .build()");
+  compiler.indentLevel++;
+  emitUsedTraits(compiler, collectUsedTraits(composition, CAMERA_HAND_TRACKING_TRAITS));
+  const confidenceTrait = objectsOf(composition).flatMap((obj) => traitsOf(obj)).find((trait) => traitName(trait) === "camera_hand_confidence");
+  const confidence = numberConfig(
+    traitConfig(confidenceTrait),
+    ["threshold", "minConfidence"],
+    0.65
+  );
+  const maxHands = compiler.compositionHasTrait(composition, "camera_hand_two_hands") ? 2 : 1;
+  compiler.emit(`private val maxNumHands = ${maxHands}`);
+  compiler.emit(`private val minHandConfidence = ${confidence}`);
+  compiler.emit("private var handLandmarker: HandLandmarker? = null");
   compiler.emit("");
-  compiler.emit("handsolution = com.google.mediapipe.solutions.hands.Hands(this, options)");
-  compiler.emit("handsolution?.setResultListener { result ->");
+  compiler.emit("fun setupHandTracking() {");
   compiler.indentLevel++;
-  compiler.emit("processHandResults(result)");
+  compiler.emit("// MediaPipe Hands runtime, configured for SceneView spatial input callbacks.");
+  compiler.emit(
+    "val options = HandLandmarker.HandLandmarkerOptions.builder().setNumHands(maxNumHands).setMinHandDetectionConfidence(minHandConfidence.toFloat()).build()"
+  );
+  compiler.emit("handLandmarker = HandLandmarker.createFromOptions(context, options)");
   compiler.indentLevel--;
   compiler.emit("}");
   compiler.emit("");
-  compiler.emit("// Start CameraX front camera feed");
-  compiler.emit("startCameraForHandTracking()");
+  compiler.emit("fun processCameraFrame(image: MPImage, timestampMs: Long) {");
+  compiler.indentLevel++;
+  compiler.emit("val result = handLandmarker?.detect(image) ?: return");
+  compiler.emit("handleHandLandmarks(result, timestampMs)");
   compiler.indentLevel--;
   compiler.emit("}");
   compiler.emit("");
-  compiler.emit("private fun startCameraForHandTracking() {");
+  compiler.emit("fun handleHandLandmarks(result: HandLandmarkerResult, timestampMs: Long) {");
+  compiler.indentLevel++;
+  compiler.emit("// 21-joint skeleton per detected hand.");
+  compiler.emit("for ((index, landmarks) in result.landmarks().withIndex()) {");
+  compiler.indentLevel++;
+  compiler.emit("val skeleton = landmarks.mapIndexed { jointIndex, landmark ->");
   compiler.indentLevel++;
   compiler.emit(
-    "val cameraProviderFuture = androidx.camera.lifecycle.ProcessCameraProvider.getInstance(this)"
+    "HandJoint(jointIndex, landmark.x(), landmark.y(), landmark.z(), minHandConfidence.toFloat())"
+  );
+  compiler.indentLevel--;
+  compiler.emit("}");
+  if (compiler.compositionHasTrait(composition, "camera_hand_gesture_pinch")) {
+    compiler.emit("classifyPinchGesture(index, skeleton, timestampMs)");
+  }
+  if (compiler.compositionHasTrait(composition, "camera_hand_gesture_point")) {
+    compiler.emit("classifyPointGesture(index, skeleton, timestampMs)");
+  }
+  if (compiler.compositionHasTrait(composition, "camera_hand_to_spatial")) {
+    compiler.emit('emitSpatialInput(SpatialInputEvent("hand_skeleton", index, timestampMs))');
+  }
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
+  compiler.emit(
+    "fun classifyPinchGesture(handIndex: Int, skeleton: List<HandJoint>, timestampMs: Long) {"
   );
-  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("// Pinch gesture: thumb tip to index tip distance.");
+  compiler.emit("val pinchDist = kotlin.math.abs(skeleton[4].x - skeleton[8].x)");
   compiler.emit(
-    "    .setBackpressureStrategy(androidx.camera.core.ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)"
+    'if (pinchDist < 0.04f) emitSpatialInput(SpatialInputEvent("pinch", handIndex, timestampMs))'
   );
-  compiler.emit("    .build()");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  compiler.emit("");
   compiler.emit(
-    "imageAnalysis.setAnalyzer(java.util.concurrent.Executors.newSingleThreadExecutor()) { imageProxy ->"
+    "fun classifyPointGesture(handIndex: Int, skeleton: List<HandJoint>, timestampMs: Long) {"
   );
   compiler.indentLevel++;
-  compiler.emit("handsolution?.send(imageProxy)");
+  compiler.emit("// POINT detected when index fingertip leads the palm.");
+  compiler.emit(
+    'if (skeleton[8].y < skeleton[0].y) emitSpatialInput(SpatialInputEvent("point", handIndex, timestampMs))'
+  );
   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.emit("");
+  compiler.emit("fun emitSpatialInput(event: SpatialInputEvent) {");
+  compiler.indentLevel++;
+  compiler.emit('Log.d("HoloScript", "emitSpatialInput " + event.type)');
   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("");
+    "data class HandJoint(val index: Int, val x: Float, val y: Float, val z: Float, val confidence: Float)"
+  );
+  compiler.emit(
+    "data class SpatialInputEvent(val type: String, val handIndex: Int, val timestampMs: Long)"
+  );
+  compiler.indentLevel--;
+  compiler.emit("}");
+  return finish(compiler);
+}
+var GEO_ANCHOR_TRAITS, GEOSPATIAL_TRAITS;
+var init_AndroidSceneViewFeatureGenerators = __esm({
+  "src/compiler/AndroidSceneViewFeatureGenerators.ts"() {
+    init_geospatial();
+    init_depth_scanner();
+    init_portal_ar();
+    init_camera_hand_tracking();
+    GEO_ANCHOR_TRAITS = [
+      "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"
+    ];
+    GEOSPATIAL_TRAITS = [
+      "geo_arcore_geospatial",
+      "geospatial_vps",
+      "geospatial_anchor",
+      "geospatial_terrain_anchor",
+      "geospatial_rooftop_anchor",
+      "geospatial_streetscape",
+      "geospatial_heading"
+    ];
+  }
+});
+
+// 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 geometryOf(compiler, obj) {
+  const raw = compiler.findObjProp(obj, "geometry") ?? compiler.findObjProp(obj, "mesh") ?? compiler.findObjProp(obj, "type") ?? "cube";
+  const g = String(raw).toLowerCase();
+  if (g === "sphere") return "sphere";
+  if (g === "cylinder") return "cylinder";
+  return "cube";
+}
+function toComposeColor(value) {
+  if (typeof value === "string") {
+    if (value.startsWith("#")) return toKotlinColor(value);
+    return NAMED_COMPOSE_COLORS[value.toLowerCase()] ?? DEFAULT_COMPOSE_COLOR;
+  }
+  if (Array.isArray(value) && value.length >= 3) {
+    const nums = value;
+    const [r, g, b, a = 1] = nums;
+    const ch = (n) => Math.max(0, Math.min(255, Math.round(n * 255))).toString(16).padStart(2, "0").toUpperCase();
+    return `Color(0x${ch(a)}${ch(r)}${ch(g)}${ch(b)})`;
+  }
+  return DEFAULT_COMPOSE_COLOR;
+}
+function toPosition(value) {
+  const c = Array.isArray(value) && value.length >= 3 ? value : [0, 0, 0];
+  return `Position(x = ${toKotlinFloatLiteral(c[0], 0)}, y = ${toKotlinFloatLiteral(
+    c[1],
+    0
+  )}, z = ${toKotlinFloatLiteral(c[2], 0)})`;
+}
+function scaleScalar(value, fallback) {
+  if (typeof value === "number") return value;
+  if (Array.isArray(value) && value.length > 0 && typeof value[0] === "number") {
+    return value[0];
   }
-  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) {");
+  return fallback;
+}
+function toCubeSize(value) {
+  if (Array.isArray(value) && value.length >= 3) {
+    const n = value;
+    return `Size(${toKotlinFloatLiteral(n[0], 0.1)}, ${toKotlinFloatLiteral(
+      n[1],
+      0.1
+    )}, ${toKotlinFloatLiteral(n[2], 0.1)})`;
+  }
+  return `Size(${toKotlinFloatLiteral(scaleScalar(value, 0.1), 0.1)})`;
+}
+function emitObjectNode(compiler, obj) {
+  const geom = geometryOf(compiler, obj);
+  const colorExpr = toComposeColor(compiler.findObjProp(obj, "color"));
+  const position = toPosition(compiler.findObjProp(obj, "position"));
+  const scale = compiler.findObjProp(obj, "scale");
+  const safeName = compiler.escapeStringValue(obj.name, "Kotlin");
+  compiler.emit(`// ${safeName} \u2014 geometry: ${geom}`);
+  if (geom === "sphere") {
+    compiler.emit("SphereNode(");
+    compiler.indentLevel++;
+    compiler.emit(`radius = ${toKotlinFloatLiteral(scaleScalar(scale, 0.05), 0.05)},`);
+    compiler.emit(`materialInstance = materialLoader.createColorInstance(${colorExpr}),`);
+    compiler.emit(`position = ${position},`);
+    compiler.indentLevel--;
+    compiler.emit(")");
+  } else if (geom === "cylinder") {
+    compiler.emit("CylinderNode(");
     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.emit(`radius = ${toKotlinFloatLiteral(scaleScalar(scale, 0.05), 0.05)},`);
+    compiler.emit(`length = ${toKotlinFloatLiteral(scaleScalar(scale, 0.1) * 2, 0.2)},`);
+    compiler.emit(`materialInstance = materialLoader.createColorInstance(${colorExpr}),`);
+    compiler.emit(`position = ${position},`);
     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.emit(")");
+  } else {
+    compiler.emit("CubeNode(");
     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.emit(`size = ${toCubeSize(scale)},`);
+    compiler.emit(`materialInstance = materialLoader.createColorInstance(${colorExpr}),`);
+    compiler.emit(`position = ${position},`);
     compiler.indentLevel--;
-    compiler.emit("}");
-    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) {");
+}
+function generateActivityFile(compiler, composition) {
+  compiler.lines = [];
+  compiler.indentLevel = 0;
+  const pkg = compiler.options.packageName;
+  const cls = compiler.options.className;
+  const objects = composition.objects ?? [];
+  const geoms = new Set(objects.map((o) => geometryOf(compiler, o)));
+  if (objects.length === 0) geoms.add("cube");
+  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 (apps/android-reference/generate-native.mts)"
+  );
+  compiler.emit("//");
+  compiler.emit(
+    "// SceneView (Apache 2.0) Compose-native AR. Declarative ARScene { } with one node per"
+  );
+  compiler.emit("// HoloScript object \u2014 no ArFragment, no R.layout, no NodeFactory/ViewModel.");
+  compiler.emit("");
+  compiler.emit(`package ${pkg}`);
+  compiler.emit("");
+  compiler.emit("import android.os.Bundle");
+  compiler.emit("import androidx.activity.ComponentActivity");
+  compiler.emit("import androidx.activity.compose.setContent");
+  compiler.emit("import androidx.compose.foundation.layout.fillMaxSize");
+  compiler.emit("import androidx.compose.ui.Modifier");
+  compiler.emit("import androidx.compose.ui.graphics.Color");
+  compiler.emit("import io.github.sceneview.ar.ARScene");
+  compiler.emit("import io.github.sceneview.ar.rememberARCameraNode");
+  compiler.emit("import io.github.sceneview.math.Position");
+  if (geoms.has("cube")) compiler.emit("import io.github.sceneview.math.Size");
+  if (geoms.has("cube")) compiler.emit("import io.github.sceneview.node.CubeNode");
+  if (geoms.has("cylinder")) compiler.emit("import io.github.sceneview.node.CylinderNode");
+  if (geoms.has("sphere")) compiler.emit("import io.github.sceneview.node.SphereNode");
+  compiler.emit("import io.github.sceneview.rememberEngine");
+  compiler.emit("import io.github.sceneview.rememberMaterialLoader");
+  compiler.emit("");
+  compiler.emit(`class ${cls}Activity : ComponentActivity() {`);
+  compiler.indentLevel++;
+  compiler.emit("override fun onCreate(savedInstanceState: Bundle?) {");
+  compiler.indentLevel++;
+  compiler.emit("super.onCreate(savedInstanceState)");
+  compiler.emit("setContent {");
+  compiler.indentLevel++;
+  compiler.emit("val engine = rememberEngine()");
+  compiler.emit("val materialLoader = rememberMaterialLoader(engine)");
+  compiler.emit("val cameraNode = rememberARCameraNode(engine)");
+  compiler.emit("");
+  compiler.emit("ARScene(");
+  compiler.indentLevel++;
+  compiler.emit("modifier = Modifier.fillMaxSize(),");
+  compiler.emit("engine = engine,");
+  compiler.emit("cameraNode = cameraNode,");
+  compiler.emit("materialLoader = materialLoader,");
+  compiler.emit("planeRenderer = true,");
+  compiler.indentLevel--;
+  compiler.emit(") {");
+  compiler.indentLevel++;
+  if (objects.length) {
+    objects.forEach((obj, i) => {
+      if (i > 0) compiler.emit("");
+      emitObjectNode(compiler, obj);
+    });
+  } else {
+    compiler.emit("// No objects in composition \u2014 default placeholder cube at 1m.");
+    compiler.emit("CubeNode(");
     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.emit("size = Size(0.1f),");
+    compiler.emit(
+      `materialInstance = materialLoader.createColorInstance(${DEFAULT_COMPOSE_COLOR}),`
+    );
+    compiler.emit("position = Position(x = 0f, y = 0f, z = -1f),");
     compiler.indentLevel--;
-    compiler.emit("}");
-    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("}");
+  compiler.indentLevel--;
+  compiler.emit("}");
+  return compiler.lines.join("\n") + "\n";
+}
+function generateStateFile(_compiler, _composition) {
+  return "";
+}
+function generateNodeFactoryFile(_compiler, _composition) {
+  return "";
+}
+function generateManifestFile(compiler, composition) {
+  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"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <!-- 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="@android:style/Theme.Material.Light.NoActionBar">
+
+        <!-- ARCore metadata. SceneView's arsceneview AAR declares com.google.ar.core as
+             "optional"; this app requires AR, so override the merged value. -->
+        <meta-data android:name="com.google.ar.core" android:value="required"
+            tools:replace="android:value" />${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 pkg = compiler.options.packageName;
+  const minSdk = compiler.options.minSdk;
+  const sdk = Math.max(36, compiler.options.targetSdk);
+  const optionalDependencies = /* @__PURE__ */ new Set();
+  if (hasGeoTraits(composition) || hasGeospatialVPSTraits(composition)) {
+    optionalDependencies.add(
+      'implementation("com.google.android.gms:play-services-location:21.3.0")'
     );
-    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("}");
   }
+  if (hasHandTrackingTraits(composition)) {
+    optionalDependencies.add('implementation("androidx.camera:camera-core:1.4.1")');
+    optionalDependencies.add('implementation("androidx.camera:camera-camera2:1.4.1")');
+    optionalDependencies.add('implementation("androidx.camera:camera-lifecycle:1.4.1")');
+    optionalDependencies.add('implementation("com.google.mediapipe:tasks-vision:0.10.20")');
+  }
+  const optionalDependencyBlock = optionalDependencies.size > 0 ? `
+
+    // Optional SceneView feature-trait sidecars
+    ${[...optionalDependencies].join("\n    ")}` : "";
+  return `// Auto-generated by HoloScript AndroidCompiler
+// Source: ${compiler.escapeStringValue(composition.name, "Kotlin")}
+//
+// SceneView (Apache 2.0) Compose-native AR target \u2014 replaces the EOL Sceneform fork.
+// compileSdk/targetSdk floor at 36: SceneView 4.18.0 pulls androidx.core 1.18.0, which refuses
+// to compile below API 36 and requires Android Gradle Plugin 8.9.1+ and Kotlin 2.3.21 (both
+// declared in the hand-maintained root build.gradle.kts scaffold).
+
+plugins {
+    id("com.android.application")
+    id("org.jetbrains.kotlin.android")
+    id("org.jetbrains.kotlin.plugin.compose")
+}
+
+android {
+    namespace = "${pkg}"
+    compileSdk = ${sdk}
+
+    defaultConfig {
+        applicationId = "${pkg}"
+        minSdk = ${minSdk}
+        targetSdk = ${sdk}
+        versionCode = 1
+        versionName = "1.0"
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = false
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    buildFeatures {
+        compose = true
+    }
+}
+
+// Kotlin 2.3 removed the kotlinOptions { jvmTarget = "17" } DSL (now a hard error);
+// the JVM target moves to the top-level compilerOptions DSL.
+kotlin {
+    compilerOptions {
+        jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17)
+    }
+}
+
+dependencies {
+    implementation("androidx.core:core-ktx:1.13.1")
+    implementation("androidx.activity:activity-compose:1.9.3")
+
+    // Jetpack Compose (BOM matches SceneView 4.18.0's compose surface)
+    implementation(platform("androidx.compose:compose-bom:2024.09.03"))
+    implementation("androidx.compose.ui:ui")
+    implementation("androidx.compose.foundation:foundation")
+    implementation("androidx.compose.material3:material3")
+
+    // SceneView (Apache 2.0) \u2014 Compose-native AR; pulls io.github.sceneview:sceneview + ARCore 1.54.0
+    // transitively. Replaces the EOL Sceneform fork. No ArFragment / no R.layout (Compose-native).
+    implementation("io.github.sceneview:arsceneview:4.18.0")${optionalDependencyBlock}
+}`;
 }
+var NAMED_COMPOSE_COLORS, DEFAULT_COMPOSE_COLOR;
+var init_AndroidARGenerators = __esm({
+  "src/compiler/AndroidARGenerators.ts"() {
+    init_AndroidKotlinHelpers();
+    init_AndroidSceneViewFeatureGenerators();
+    NAMED_COMPOSE_COLORS = {
+      red: "Color(0xFFFF0000)",
+      green: "Color(0xFF00FF00)",
+      blue: "Color(0xFF2196F3)",
+      white: "Color(0xFFFFFFFF)",
+      black: "Color(0xFF000000)",
+      yellow: "Color(0xFFFFEB3B)",
+      cyan: "Color(0xFF00BCD4)",
+      magenta: "Color(0xFFE91E63)",
+      orange: "Color(0xFFFF9800)"
+    };
+    DEFAULT_COMPOSE_COLOR = "Color(0xFF4488FF)";
+  }
+});
+
+// src/compiler/AndroidFeatureGenerators.ts
 function hasAuthoringTraits(composition) {
   const authoringNames = SPATIAL_AUTHORING_TRAITS;
   for (const obj of composition.objects || []) {
@@ -1050,51 +1049,6 @@ function emitAuthoringSetup(compiler, composition) {
   }
   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 = NPU_SCENE_TRAITS;
   for (const obj of composition.objects || []) {
@@ -1329,745 +1283,149 @@ function emitNPUSceneSetup(compiler, composition) {
     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 = __esm({
-  "src/compiler/AndroidFeatureGenerators.ts"() {
-    init_geospatial();
-    init_depth_scanner();
-    init_portal_ar();
-    init_camera_hand_tracking();
-    init_npu_scene();
-    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("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("");
-    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(");
+  if (usedTraits.has("npu_realtime")) {
+    compiler.emit("// MARK: Realtime Processing (npu_realtime)");
+    compiler.emit("");
+    compiler.emit("fun createImageAnalyzer(): ImageAnalysis.Analyzer {");
     compiler.indentLevel++;
-    compiler.emit("context,");
-    compiler.emit(`Color(${compiler.toAndroidColor(color)})`);
-    compiler.indentLevel--;
-    compiler.emit(").thenAccept { material ->");
+    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++;
-    const meshType = compiler.findObjProp(firstObj, "mesh") || compiler.findObjProp(firstObj, "type") || "cube";
-    const geometry = compiler.getSceneformGeometry(meshType);
-    compiler.emit(`${geometry}.thenAccept { renderable ->`);
+    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("renderable.material = material");
-    compiler.emit("callback(renderable)");
+    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("}");
-  } else {
+    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(
-      "MaterialFactory.makeOpaqueWithColor(context, Color(android.graphics.Color.BLUE))"
+      "    .setView(arFragment.requireContext(), android.widget.TextView(arFragment.requireContext()).apply {"
     );
-    compiler.emit("    .thenCompose { material ->");
+    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(
-      "        ShapeFactory.makeCube(Vector3(0.1f, 0.1f, 0.1f), Vector3.zero(), material)"
+      `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.emit("    .thenAccept { renderable -> callback(renderable) }");
-  }
-  compiler.indentLevel--;
-  compiler.emit("}");
-  compiler.emit("");
-  for (const obj of composition.objects || []) {
-    compileObjectFactory(compiler, obj);
+    compiler.indentLevel--;
+    compiler.emit("}");
+    compiler.emit("");
   }
   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 = __esm({
-  "src/compiler/AndroidARGenerators.ts"() {
-    init_AndroidFeatureGenerators();
+var init_AndroidFeatureGenerators = __esm({
+  "src/compiler/AndroidFeatureGenerators.ts"() {
+    init_npu_scene();
+    init_spatial_authoring();
   }
 });
 
@@ -2948,6 +2306,7 @@ var init_AndroidCompiler = __esm({
     init_CompilerBase();
     init_AndroidARGenerators();
     init_AndroidFeatureGenerators();
+    init_AndroidSceneViewFeatureGenerators();
     init_AndroidPeripheralGenerators();
     init_AndroidKotlinHelpers();
     AndroidCompiler = class extends CompilerBase {
@@ -2974,11 +2333,26 @@ var init_AndroidCompiler = __esm({
         this.validateCompilerAccess(agentToken, outputPath);
         const result = {
           activityFile: generateActivityFile(this, composition),
-          stateFile: generateStateFile(this, composition),
-          nodeFactoryFile: generateNodeFactoryFile(this, composition),
+          stateFile: generateStateFile(),
+          nodeFactoryFile: generateNodeFactoryFile(),
           manifestFile: generateManifestFile(this, composition),
           buildGradle: generateBuildGradle(this, composition)
         };
+        if (hasGeoAnchorTraits(composition)) {
+          result.geoAnchorSetup = emitGeoAnchorSetup(this, composition);
+        }
+        if (hasGeospatialVPSTraits(composition)) {
+          result.geospatialVPSSetup = emitGeospatialVPSSetup(this, composition);
+        }
+        if (hasDepthScanTraits(composition)) {
+          result.depthScanSetup = emitDepthScanSetup(this, composition);
+        }
+        if (hasPortalARTraits(composition)) {
+          result.portalARSetup = emitPortalARSetup(this, composition);
+        }
+        if (hasHandTrackingTraits(composition)) {
+          result.handTrackingSetup = emitHandTrackingSetup(this, composition);
+        }
         if (hasNPUSceneTraits(composition)) {
           result.npuSceneSetup = emitNPUSceneSetup(this, composition);
         }
@@ -3005,6 +2379,51 @@ var init_AndroidCompiler = __esm({
         }
         return result;
       }
+      /**
+       * Compile to a path-keyed map of reference-relative files (Android project layout).
+       *
+       * Mirrors AndroidXRCompiler.compileToFiles(): the native return is named fields
+       * (AndroidCompileResult), so this adapter maps those fields onto the on-disk Android
+       * project layout, letting the SAME byte-diff golden gate + committed-reference-app pattern
+       * (QuestCompiler / AndroidXRCompiler) apply to the legacy plain-Android (ARCore) target.
+       * Keys are POSIX-relative to the app project root (the dir holding settings.gradle.kts).
+       *
+       * Optional feature-setup fields (npuSceneSetup, hapticSetup, …) are emitted as extra
+       * Kotlin files under the same package dir, keyed off the field name, so the gate covers
+       * them when a trait pulls them in. The field→filename map is fixed so output is stable.
+       */
+      compileToFiles(composition, agentToken = "") {
+        const r = this.compile(composition, agentToken);
+        const pkgPath = this.options.packageName.replace(/\./g, "/");
+        const javaRel = `app/src/main/java/${pkgPath}`;
+        const files = {
+          [`${javaRel}/${this.options.className}Activity.kt`]: r.activityFile,
+          "app/src/main/AndroidManifest.xml": r.manifestFile,
+          "app/build.gradle.kts": r.buildGradle
+        };
+        const featureFiles = {
+          geoAnchorSetup: "GeoAnchorSetup.kt",
+          geospatialVPSSetup: "GeospatialVPSSetup.kt",
+          depthScanSetup: "DepthScanSetup.kt",
+          portalARSetup: "PortalARSetup.kt",
+          handTrackingSetup: "HandTrackingSetup.kt",
+          npuSceneSetup: "NPUSceneSetup.kt",
+          authoringSetup: "AuthoringSetup.kt",
+          hapticSetup: "HapticSetup.kt",
+          nearbySetup: "NearbySetup.kt",
+          foldableSetup: "FoldableSetup.kt",
+          dexSetup: "DexSetup.kt",
+          lensSetup: "LensSetup.kt",
+          webxrSetup: "WebXRSetup.kt"
+        };
+        for (const [field, fileName] of Object.entries(featureFiles)) {
+          const content = r[field];
+          if (typeof content === "string" && content.length > 0) {
+            files[`${javaRel}/${fileName}`] = content;
+          }
+        }
+        return files;
+      }
       emit(line) {
         const indent = this.options.indent.repeat(this.indentLevel);
         this.lines.push(indent + line);
@@ -3034,13 +2453,13 @@ var init_AndroidCompiler = __esm({
         return toAndroidColor(value);
       }
       /** @deprecated Use compositionHasTrait from AndroidKotlinHelpers */
-      compositionHasTrait(composition, traitName) {
-        return compositionHasTrait(composition, traitName);
+      compositionHasTrait(composition, traitName2) {
+        return compositionHasTrait(composition, traitName2);
       }
     };
   }
 });
 
 export { AndroidCompiler, AndroidCompiler_exports, compileToAndroid, init_AndroidCompiler };
-//# sourceMappingURL=chunk-GSOUNWEL.js.map
-//# sourceMappingURL=chunk-GSOUNWEL.js.map
+//# sourceMappingURL=chunk-HVX7QQYK.js.map
+//# sourceMappingURL=chunk-HVX7QQYK.js.map