IOSPeripheralGenerators.ts

import type { HoloComposition } from '../parser/HoloCompositionTypes';
import type { IOSCompiler } from './IOSCompiler';
import { escapeStringValue } from './CompilerBase';
import { CAMERA_HAND_TRACKING_TRAITS } from '../traits/constants/mobile/camera-hand-tracking';
import { FACE_TRACKING_TRAITS } from '../traits/constants/mobile/face-tracking';
import { IOS_OBJECT_CAPTURE_TRAITS } from '../traits/constants/mobile/ios-object-capture';
import { SHAREPLAY_TRAITS } from '../traits/constants/mobile/shareplay';
import { UWB_POSITIONING_TRAITS } from '../traits/constants/mobile/uwb-positioning';
import { AIRPODS_SPATIAL_AUDIO_TRAITS } from '../traits/constants/mobile/airpods-spatial-audio';

export function hasHandTrackingTraits(composition: HoloComposition): boolean {
  const handTraitNames: ReadonlyArray<string> = 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;
}

export function generateHandTrackingFile(
  compiler: IOSCompiler,
  composition: HoloComposition
): string {
  compiler.lines = [];
  compiler.indentLevel = 0;

  const cls = compiler.options.className;

  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('// Auto-generated by HoloScript IOSCompiler — Hand Tracking integration');
  compiler.emit(
    `// Source: composition "${escapeStringValue(composition.name as string, 'Swift')}"`
  );
  compiler.emit('// Requires iOS 14.0+, Vision framework');
  compiler.emit('// Do not edit manually — regenerate from .holo source');
  compiler.emit('');
  compiler.emit('import Foundation');
  compiler.emit('import Vision');
  compiler.emit('import AVFoundation');
  compiler.emit('import UIKit');
  compiler.emit('');

  // HandGesture enum
  compiler.emit('/// Recognized hand gestures from camera-based tracking.');
  compiler.emit('enum HandGesture: String {');
  compiler.indentLevel++;
  if (hasPinch) compiler.emit('case pinch = "pinch"');
  if (hasPoint) compiler.emit('case point = "point"');
  if (hasPalm) compiler.emit('case palm = "palm"');
  if (hasFist) compiler.emit('case fist = "fist"');
  compiler.emit('case none = "none"');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // HandTrackingManager class
  compiler.emit(`class ${cls}HandTrackingManager: NSObject, ObservableObject {`);
  compiler.indentLevel++;
  compiler.emit('@Published var currentGesture: HandGesture = .none');
  compiler.emit('@Published var handCount: Int = 0');
  if (hasSkeleton) {
    compiler.emit(
      '@Published var jointPositions: [[VNHumanHandPoseObservation.JointName: VNRecognizedPoint]] = []'
    );
  }
  compiler.emit('');
  compiler.emit('private var captureSession: AVCaptureSession?');
  compiler.emit('private let handPoseRequest = VNDetectHumanHandPoseRequest()');
  compiler.emit('private let sequenceHandler = VNSequenceRequestHandler()');
  if (hasConfidence) {
    compiler.emit('private let minConfidence: Float = 0.7');
  } else {
    compiler.emit('private let minConfidence: Float = 0.5');
  }
  compiler.emit('');

  // init
  compiler.emit('override init() {');
  compiler.indentLevel++;
  compiler.emit('super.init()');
  compiler.emit(`handPoseRequest.maximumHandCount = ${maxHands}`);
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // startTracking
  compiler.emit('func startTracking() {');
  compiler.indentLevel++;
  compiler.emit('let session = AVCaptureSession()');
  compiler.emit('session.sessionPreset = .high');
  compiler.emit('');
  compiler.emit(
    'guard let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .front),'
  );
  compiler.emit('      let input = try? AVCaptureDeviceInput(device: device) else {');
  compiler.indentLevel++;
  compiler.emit('print("[HoloScript] Failed to access front camera")');
  compiler.emit('return');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit('session.addInput(input)');
  compiler.emit('');
  compiler.emit('let output = AVCaptureVideoDataOutput()');
  compiler.emit(
    'output.setSampleBufferDelegate(self, queue: DispatchQueue(label: "handTracking"))'
  );
  compiler.emit('session.addOutput(output)');
  compiler.emit('');
  compiler.emit('captureSession = session');
  compiler.emit('session.startRunning()');
  compiler.emit('print("[HoloScript] Hand tracking started")');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // stopTracking
  compiler.emit('func stopTracking() {');
  compiler.indentLevel++;
  compiler.emit('captureSession?.stopRunning()');
  compiler.emit('captureSession = nil');
  compiler.emit('print("[HoloScript] Hand tracking stopped")');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // processObservation
  compiler.emit('private func processObservation(_ observation: VNHumanHandPoseObservation) {');
  compiler.indentLevel++;
  compiler.emit('guard let thumbTip = try? observation.recognizedPoint(.thumbTip),');
  compiler.emit('      let indexTip = try? observation.recognizedPoint(.indexTip),');
  compiler.emit('      let indexMCP = try? observation.recognizedPoint(.indexMCP),');
  compiler.emit('      let middleTip = try? observation.recognizedPoint(.middleTip),');
  compiler.emit('      let middleMCP = try? observation.recognizedPoint(.middleMCP),');
  compiler.emit('      let middlePIP = try? observation.recognizedPoint(.middlePIP),');
  compiler.emit('      let ringTip = try? observation.recognizedPoint(.ringTip),');
  compiler.emit('      let ringMCP = try? observation.recognizedPoint(.ringMCP),');
  compiler.emit('      let ringPIP = try? observation.recognizedPoint(.ringPIP),');
  compiler.emit('      let littleTip = try? observation.recognizedPoint(.littleTip),');
  compiler.emit('      let littleMCP = try? observation.recognizedPoint(.littleMCP),');
  compiler.emit('      let littlePIP = try? observation.recognizedPoint(.littlePIP),');
  compiler.emit('      let indexPIP = try? observation.recognizedPoint(.indexPIP)');
  compiler.emit('else { return }');
  compiler.emit('');

  if (hasConfidence) {
    compiler.emit('// Filter low-confidence joints');
    compiler.emit(
      'guard thumbTip.confidence > minConfidence && indexTip.confidence > minConfidence else { return }'
    );
    compiler.emit('');
  }

  if (hasSkeleton) {
    compiler.emit('// Extract all 21 joints');
    compiler.emit('var joints: [VNHumanHandPoseObservation.JointName: VNRecognizedPoint] = [:]');
    compiler.emit('let allJoints: [VNHumanHandPoseObservation.JointName] = [');
    compiler.indentLevel++;
    compiler.emit('.wrist, .thumbCMC, .thumbMP, .thumbIP, .thumbTip,');
    compiler.emit('.indexMCP, .indexPIP, .indexDIP, .indexTip,');
    compiler.emit('.middleMCP, .middlePIP, .middleDIP, .middleTip,');
    compiler.emit('.ringMCP, .ringPIP, .ringDIP, .ringTip,');
    compiler.emit('.littleMCP, .littlePIP, .littleDIP, .littleTip');
    compiler.indentLevel--;
    compiler.emit(']');
    compiler.emit('for jointName in allJoints {');
    compiler.indentLevel++;
    compiler.emit('if let point = try? observation.recognizedPoint(jointName) {');
    compiler.indentLevel++;
    compiler.emit('joints[jointName] = point');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // Gesture recognition
  if (hasPinch) {
    compiler.emit('// Pinch gesture: thumb tip close to index tip');
    compiler.emit(
      'let pinchDist = hypot(thumbTip.location[0] - indexTip.location[0], thumbTip.location[1] - indexTip.location[1])'
    );
    compiler.emit('if pinchDist < 0.05 {');
    compiler.indentLevel++;
    compiler.emit('DispatchQueue.main.async { self.currentGesture = .pinch }');
    if (hasToSpatial) {
      compiler.emit('emitSpatialInput(gesture: .pinch, location: thumbTip.location)');
    }
    compiler.emit('return');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  if (hasPoint) {
    compiler.emit('// Point gesture: index extended, others curled');
    compiler.emit('let indexExtended = indexTip.location[1] > indexMCP.location[1]');
    compiler.emit('let middleCurled = middleTip.location[1] < middlePIP.location[1]');
    compiler.emit('let ringCurled = ringTip.location[1] < ringPIP.location[1]');
    compiler.emit('let littleCurled = littleTip.location[1] < littlePIP.location[1]');
    compiler.emit('if indexExtended && middleCurled && ringCurled && littleCurled {');
    compiler.indentLevel++;
    compiler.emit('DispatchQueue.main.async { self.currentGesture = .point }');
    if (hasToSpatial) {
      compiler.emit('emitSpatialInput(gesture: .point, location: indexTip.location)');
    }
    compiler.emit('return');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  if (hasPalm) {
    compiler.emit('// Palm gesture: all fingertips above MCPs (open hand)');
    compiler.emit('let allExtended = indexTip.location[1] > indexMCP.location[1] &&');
    compiler.emit('    middleTip.location[1] > middleMCP.location[1] &&');
    compiler.emit('    ringTip.location[1] > ringMCP.location[1] &&');
    compiler.emit('    littleTip.location[1] > littleMCP.location[1]');
    compiler.emit('if allExtended {');
    compiler.indentLevel++;
    compiler.emit('DispatchQueue.main.async { self.currentGesture = .palm }');
    if (hasToSpatial) {
      compiler.emit('emitSpatialInput(gesture: .palm, location: indexTip.location)');
    }
    compiler.emit('return');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  if (hasFist) {
    compiler.emit('// Fist gesture: all fingertips below PIPs (closed hand)');
    compiler.emit('let allCurled = indexTip.location[1] < indexPIP.location[1] &&');
    compiler.emit('    middleTip.location[1] < middlePIP.location[1] &&');
    compiler.emit('    ringTip.location[1] < ringPIP.location[1] &&');
    compiler.emit('    littleTip.location[1] < littlePIP.location[1]');
    compiler.emit('if allCurled {');
    compiler.indentLevel++;
    compiler.emit('DispatchQueue.main.async { self.currentGesture = .fist }');
    if (hasToSpatial) {
      compiler.emit('emitSpatialInput(gesture: .fist, location: indexTip.location)');
    }
    compiler.emit('return');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  compiler.emit('DispatchQueue.main.async { self.currentGesture = .none }');
  compiler.indentLevel--;
  compiler.emit('}');

  // Spatial input bridge
  if (hasToSpatial) {
    compiler.emit('');
    compiler.emit('private func emitSpatialInput(gesture: HandGesture, location: CGPoint) {');
    compiler.indentLevel++;
    compiler.emit('// Bridge to HoloScript spatial_input event system');
    compiler.emit('let event: [String: Any] = [');
    compiler.indentLevel++;
    compiler.emit('"type": "hand_gesture",');
    compiler.emit('"gesture": gesture.rawValue,');
    compiler.emit('"x": location[0],');
    compiler.emit('"y": location[1]');
    compiler.indentLevel--;
    compiler.emit(']');
    compiler.emit('print("[HoloScript] SpatialInput: \\(event)")');
    compiler.indentLevel--;
    compiler.emit('}');
  }

  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // AVCaptureVideoDataOutputSampleBufferDelegate extension
  compiler.emit(
    `extension ${cls}HandTrackingManager: AVCaptureVideoDataOutputSampleBufferDelegate {`
  );
  compiler.indentLevel++;
  compiler.emit(
    'func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {'
  );
  compiler.indentLevel++;
  compiler.emit(
    'guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }'
  );
  compiler.emit('');
  compiler.emit(
    'let handler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer, orientation: .up, options: [:])'
  );
  compiler.emit('do {');
  compiler.indentLevel++;
  compiler.emit('try handler.perform([handPoseRequest])');
  compiler.emit('guard let results = handPoseRequest.results else { return }');
  compiler.emit('');
  compiler.emit('DispatchQueue.main.async {');
  compiler.indentLevel++;
  compiler.emit('self.handCount = results.count');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit('for observation in results {');
  compiler.indentLevel++;
  compiler.emit('processObservation(observation)');
  if (hasSkeleton) {
    compiler.emit('// Update joint positions on main thread');
    compiler.emit('DispatchQueue.main.async {');
    compiler.indentLevel++;
    compiler.emit('// jointPositions updated via processObservation');
    compiler.indentLevel--;
    compiler.emit('}');
  }
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('} catch {');
  compiler.indentLevel++;
  compiler.emit('print("[HoloScript] Hand pose detection error: \\(error)")');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');

  return compiler.lines.join('\n');
}

export function hasObjectCaptureTraits(composition: HoloComposition): boolean {
  const captureNames: ReadonlyArray<string> = IOS_OBJECT_CAPTURE_TRAITS;
  for (const obj of composition.objects || []) {
    for (const trait of obj.traits || []) {
      const name = typeof trait === 'string' ? trait : trait.name;
      if (captureNames.includes(name)) return true;
    }
  }
  return false;
}

export function collectObjectCaptureTraits(composition: HoloComposition): Set<string> {
  const captureNames: ReadonlyArray<string> = IOS_OBJECT_CAPTURE_TRAITS;
  const found = new Set<string>();
  for (const obj of composition.objects || []) {
    for (const t of obj.traits || []) {
      const name = typeof t === 'string' ? t : t.name;
      if (captureNames.includes(name)) found.add(name);
    }
  }
  return found;
}

export function generateObjectCaptureFile(
  compiler: IOSCompiler,
  composition: HoloComposition
): string {
  compiler.lines = [];
  compiler.indentLevel = 0;

  const cls = compiler.options.className;
  const traits = collectObjectCaptureTraits(composition);

  compiler.emit('// Auto-generated by HoloScript IOSCompiler — Object Capture integration');
  compiler.emit(
    `// Source: composition "${escapeStringValue(composition.name as string, 'Swift')}"`
  );
  compiler.emit('// Requires iOS 17.0+, RealityKit Object Capture API');
  compiler.emit('// Do not edit manually — regenerate from .holo source');
  compiler.emit('');
  compiler.emit('import Foundation');
  compiler.emit('import RealityKit');
  compiler.emit('import SwiftUI');
  compiler.emit('import Combine');
  compiler.emit('import os');
  compiler.emit('');

  // ── HoloCapturedEntity model ──
  compiler.emit('struct HoloCapturedEntity: Identifiable {');
  compiler.indentLevel++;
  compiler.emit('let id = UUID()');
  compiler.emit('let name: String');
  compiler.emit('let modelURL: URL');
  compiler.emit('let boundingBox: BoundingBox');
  compiler.emit('let detailLevel: DetailLevel');
  compiler.emit('let pbrMaterials: PBRMaterialSet?');
  compiler.emit('');
  compiler.emit('struct BoundingBox {');
  compiler.indentLevel++;
  compiler.emit('let center: SIMD3<Float>');
  compiler.emit('let extents: SIMD3<Float>');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit('enum DetailLevel: String, CaseIterable {');
  compiler.indentLevel++;
  compiler.emit('case preview');
  compiler.emit('case reduced');
  compiler.emit('case medium');
  compiler.emit('case full');
  compiler.emit('case raw');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit('struct PBRMaterialSet {');
  compiler.indentLevel++;
  compiler.emit('let diffuseMap: URL?');
  compiler.emit('let normalMap: URL?');
  compiler.emit('let roughnessMap: URL?');
  compiler.emit('let metallicMap: URL?');
  compiler.emit('let aoMap: URL?');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ── ObjectCaptureManager class ──
  compiler.emit(`class ${cls}ObjectCaptureManager: ObservableObject {`);
  compiler.indentLevel++;
  compiler.emit('');
  compiler.emit(
    'private let logger = Logger(subsystem: "net.holoscript", category: "ObjectCapture")'
  );
  compiler.emit('');
  compiler.emit('enum CaptureState: Equatable {');
  compiler.indentLevel++;
  compiler.emit('case ready');
  compiler.emit('case capturing');
  compiler.emit('case processing');
  compiler.emit('case completed');
  compiler.emit('case failed(String)');
  compiler.emit('');
  compiler.emit('static func == (lhs: CaptureState, rhs: CaptureState) -> Bool {');
  compiler.indentLevel++;
  compiler.emit('switch (lhs, rhs) {');
  compiler.emit('case (.ready, .ready), (.capturing, .capturing),');
  compiler.emit('     (.processing, .processing), (.completed, .completed): return true');
  compiler.emit('case (.failed(let a), .failed(let b)): return a == b');
  compiler.emit('default: return false');
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit('@Published var state: CaptureState = .ready');
  compiler.emit('@Published var progress: Float = 0.0');
  compiler.emit('@Published var capturedEntity: HoloCapturedEntity?');
  compiler.emit('@Published var feedbackMessages: [String] = []');
  compiler.emit('');
  compiler.emit('private var captureSession: ObjectCaptureSession?');
  compiler.emit('private var outputDirectory: URL');
  compiler.emit('private var cancellables = Set<AnyCancellable>()');
  compiler.emit('');

  // ── init ──
  compiler.emit('init() {');
  compiler.indentLevel++;
  compiler.emit(
    'let docs = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!'
  );
  compiler.emit(
    'self.outputDirectory = docs.appendingPathComponent("HoloCaptures", isDirectory: true)'
  );
  compiler.emit(
    'try? FileManager.default.createDirectory(at: outputDirectory, withIntermediateDirectories: true)'
  );
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ── isSupported ──
  compiler.emit('var isSupported: Bool {');
  compiler.indentLevel++;
  compiler.emit('ObjectCaptureSession.isSupported');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ── startCapture ──
  compiler.emit('func startCapture() {');
  compiler.indentLevel++;
  compiler.emit('guard isSupported else {');
  compiler.indentLevel++;
  compiler.emit('state = .failed("Object Capture not supported on this device")');
  compiler.emit('return');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit('let session = ObjectCaptureSession()');
  compiler.emit('self.captureSession = session');
  compiler.emit('');
  compiler.emit('var configuration = ObjectCaptureSession.Configuration()');
  compiler.emit(
    'configuration.checkpointDirectory = outputDirectory.appendingPathComponent("Checkpoints")'
  );
  compiler.emit('configuration.isOverCaptureEnabled = true');
  compiler.emit('session.start(imagesDirectory: outputDirectory.appendingPathComponent("Images"),');
  compiler.emit('             configuration: configuration)');
  compiler.emit('');
  compiler.emit('observeSession(session)');
  compiler.emit('state = .capturing');
  compiler.emit('logger.info("[HoloScript] Object Capture session started")');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ── stopCapture ──
  compiler.emit('func stopCapture() {');
  compiler.indentLevel++;
  compiler.emit('captureSession?.finish()');
  compiler.emit('logger.info("[HoloScript] Object Capture session finished")');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ── observeSession (feedback) ──
  if (traits.has('object_capture_feedback') || traits.has('object_capture')) {
    compiler.emit('private func observeSession(_ session: ObjectCaptureSession) {');
    compiler.indentLevel++;
    compiler.emit('session.stateUpdates.sink { [weak self] newState in');
    compiler.indentLevel++;
    compiler.emit('guard let self = self else { return }');
    compiler.emit('switch newState {');
    compiler.emit('case .ready:');
    compiler.indentLevel++;
    compiler.emit('self.feedbackMessages.append("Ready to capture")');
    compiler.indentLevel--;
    compiler.emit('case .detecting:');
    compiler.indentLevel++;
    compiler.emit('self.feedbackMessages.append("Detecting object...")');
    compiler.indentLevel--;
    compiler.emit('case .capturing:');
    compiler.indentLevel++;
    compiler.emit('self.feedbackMessages.append("Move slowly around the object")');
    compiler.indentLevel--;
    compiler.emit('case .finishing:');
    compiler.indentLevel++;
    compiler.emit('self.feedbackMessages.append("Finishing capture...")');
    compiler.indentLevel--;
    compiler.emit('case .completed:');
    compiler.indentLevel++;
    compiler.emit('self.state = .processing');
    compiler.emit('self.feedbackMessages.append("Capture complete — processing...")');
    compiler.emit('self.processCapture()');
    compiler.indentLevel--;
    compiler.emit('case .failed(let error):');
    compiler.indentLevel++;
    compiler.emit('self.state = .failed(error.localizedDescription)');
    compiler.indentLevel--;
    compiler.emit('default:');
    compiler.indentLevel++;
    compiler.emit('break');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}.store(in: &cancellables)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ── processCapture (PhotogrammetrySession) ──
  if (traits.has('photogrammetry_scan') || traits.has('object_capture')) {
    compiler.emit('private func processCapture() {');
    compiler.indentLevel++;
    compiler.emit('Task {');
    compiler.indentLevel++;
    compiler.emit('do {');
    compiler.indentLevel++;
    compiler.emit('let inputFolder = outputDirectory.appendingPathComponent("Images")');
    compiler.emit('let request = makePhotogrammetryRequest()');
    compiler.emit('let session = try PhotogrammetrySession(input: inputFolder)');
    compiler.emit('');
    compiler.emit('try session.process(requests: [request])');
    compiler.emit('');
    compiler.emit('for try await output in session.outputs {');
    compiler.indentLevel++;
    compiler.emit('switch output {');
    compiler.emit('case .requestProgress(let request, let fraction):');
    compiler.indentLevel++;
    compiler.emit('await MainActor.run { self.progress = Float(fraction) }');
    compiler.indentLevel--;
    compiler.emit('case .requestComplete(let request, let result):');
    compiler.indentLevel++;
    compiler.emit('await MainActor.run {');
    compiler.indentLevel++;
    compiler.emit('self.handlePhotogrammetryResult(result)');
    compiler.emit('self.state = .completed');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('case .requestError(let request, let error):');
    compiler.indentLevel++;
    compiler.emit('await MainActor.run { self.state = .failed(error.localizedDescription) }');
    compiler.indentLevel--;
    compiler.emit('default: break');
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('} catch {');
    compiler.indentLevel++;
    compiler.emit('await MainActor.run { self.state = .failed(error.localizedDescription) }');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ── makePhotogrammetryRequest with detail level ──
  if (traits.has('object_capture_lod') || traits.has('object_capture')) {
    compiler.emit('private func makePhotogrammetryRequest() -> PhotogrammetrySession.Request {');
    compiler.indentLevel++;
    compiler.emit('let outputURL = outputDirectory.appendingPathComponent("model.usdz")');
    compiler.emit(
      '// .full detail level captures PBR maps (diffuse, normal, roughness, metallic, AO)'
    );
    compiler.emit('return .modelFile(url: outputURL, detail: .full)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');

    compiler.emit('func generateAllLODs() async throws -> [HoloCapturedEntity.DetailLevel: URL] {');
    compiler.indentLevel++;
    compiler.emit('var results: [HoloCapturedEntity.DetailLevel: URL] = [:]');
    compiler.emit('let inputFolder = outputDirectory.appendingPathComponent("Images")');
    compiler.emit('let session = try PhotogrammetrySession(input: inputFolder)');
    compiler.emit('');
    compiler.emit('for level in HoloCapturedEntity.DetailLevel.allCases {');
    compiler.indentLevel++;
    compiler.emit(
      'let url = outputDirectory.appendingPathComponent("model_\\(level.rawValue).usdz")'
    );
    compiler.emit('let detail: PhotogrammetrySession.Request.Detail');
    compiler.emit('switch level {');
    compiler.emit('case .preview: detail = .preview');
    compiler.emit('case .reduced: detail = .reduced');
    compiler.emit('case .medium: detail = .medium');
    compiler.emit('case .full: detail = .full');
    compiler.emit('case .raw: detail = .raw');
    compiler.emit('}');
    compiler.emit(
      'let request = PhotogrammetrySession.Request.modelFile(url: url, detail: detail)'
    );
    compiler.emit('try session.process(requests: [request])');
    compiler.emit('for try await output in session.outputs {');
    compiler.indentLevel++;
    compiler.emit('if case .requestComplete = output { results[level] = url; break }');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('return results');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ── PBR texture extraction ──
  if (traits.has('pbr_texture_extract') || traits.has('object_capture')) {
    compiler.emit(
      'private func extractPBRMaterials(from modelURL: URL) -> HoloCapturedEntity.PBRMaterialSet? {'
    );
    compiler.indentLevel++;
    compiler.emit('let baseDir = modelURL.deletingLastPathComponent()');
    compiler.emit('let diffuse = baseDir.appendingPathComponent("diffuse.png")');
    compiler.emit('let normal = baseDir.appendingPathComponent("normal.png")');
    compiler.emit('let roughness = baseDir.appendingPathComponent("roughness.png")');
    compiler.emit('let metallic = baseDir.appendingPathComponent("metallic.png")');
    compiler.emit('let ao = baseDir.appendingPathComponent("ao.png")');
    compiler.emit('');
    compiler.emit('return HoloCapturedEntity.PBRMaterialSet(');
    compiler.emit(
      '    diffuseMap: FileManager.default.fileExists(atPath: diffuse.path) ? diffuse : nil,'
    );
    compiler.emit(
      '    normalMap: FileManager.default.fileExists(atPath: normal.path) ? normal : nil,'
    );
    compiler.emit(
      '    roughnessMap: FileManager.default.fileExists(atPath: roughness.path) ? roughness : nil,'
    );
    compiler.emit(
      '    metallicMap: FileManager.default.fileExists(atPath: metallic.path) ? metallic : nil,'
    );
    compiler.emit('    aoMap: FileManager.default.fileExists(atPath: ao.path) ? ao : nil');
    compiler.emit(')');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ── handlePhotogrammetryResult ──
  compiler.emit(
    'private func handlePhotogrammetryResult(_ result: PhotogrammetrySession.Result) {'
  );
  compiler.indentLevel++;
  compiler.emit('switch result {');
  compiler.emit('case .modelFile(let url):');
  compiler.indentLevel++;
  compiler.emit('logger.info("[HoloScript] Model generated at \\(url.path)")');
  if (traits.has('pbr_texture_extract') || traits.has('object_capture')) {
    compiler.emit('let pbr = extractPBRMaterials(from: url)');
  }
  compiler.emit('capturedEntity = HoloCapturedEntity(');
  compiler.emit('    name: "captured_object",');
  compiler.emit('    modelURL: url,');
  compiler.emit('    boundingBox: HoloCapturedEntity.BoundingBox(center: .zero, extents: .one),');
  compiler.emit('    detailLevel: .full,');
  if (traits.has('pbr_texture_extract') || traits.has('object_capture')) {
    compiler.emit('    pbrMaterials: pbr');
  } else {
    compiler.emit('    pbrMaterials: nil');
  }
  compiler.emit(')');
  compiler.indentLevel--;
  compiler.emit('default:');
  compiler.indentLevel++;
  compiler.emit('logger.warning("[HoloScript] Unexpected photogrammetry result type")');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ── USDZ export ──
  if (traits.has('object_capture_export_usdz') || traits.has('object_capture')) {
    compiler.emit('func exportUSDZ() -> URL? {');
    compiler.indentLevel++;
    compiler.emit('let usdzURL = outputDirectory.appendingPathComponent("export.usdz")');
    compiler.emit('guard let modelURL = capturedEntity?.modelURL else { return nil }');
    compiler.emit('do {');
    compiler.indentLevel++;
    compiler.emit('try FileManager.default.copyItem(at: modelURL, to: usdzURL)');
    compiler.emit('logger.info("[HoloScript] USDZ exported to \\(usdzURL.path)")');
    compiler.emit('return usdzURL');
    compiler.indentLevel--;
    compiler.emit('} catch {');
    compiler.indentLevel++;
    compiler.emit(
      'logger.error("[HoloScript] USDZ export failed: \\(error.localizedDescription)")'
    );
    compiler.emit('return nil');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ── Convert to .holo ──
  if (traits.has('object_capture_to_holo') || traits.has('object_capture')) {
    compiler.emit('func convertToHolo() -> String? {');
    compiler.indentLevel++;
    compiler.emit('guard let entity = capturedEntity else { return nil }');
    compiler.emit('');
    compiler.emit('var holo = "scene CapturedObject {\\n"');
    compiler.emit('holo += "  object \\(entity.name) {\\n"');
    compiler.emit('holo += "    model: \\"\\(entity.modelURL.lastPathComponent)\\"\\n"');
    compiler.emit(
      'holo += "    position: [\\(entity.boundingBox.center[0]), \\(entity.boundingBox.center[1]), \\(entity.boundingBox.center[2])]\\n"'
    );
    compiler.emit(
      'holo += "    scale: [\\(entity.boundingBox.extents[0]), \\(entity.boundingBox.extents[1]), \\(entity.boundingBox.extents[2])]\\n"'
    );
    compiler.emit('holo += "    traits: [object_capture, photogrammetry_scan]\\n"');
    if (traits.has('pbr_texture_extract')) {
      compiler.emit('if let pbr = entity.pbrMaterials {');
      compiler.indentLevel++;
      compiler.emit('if pbr.diffuseMap != nil { holo += "    diffuse_map: \\"diffuse.png\\"\\n" }');
      compiler.emit('if pbr.normalMap != nil { holo += "    normal_map: \\"normal.png\\"\\n" }');
      compiler.emit(
        'if pbr.roughnessMap != nil { holo += "    roughness_map: \\"roughness.png\\"\\n" }'
      );
      compiler.emit(
        'if pbr.metallicMap != nil { holo += "    metallic_map: \\"metallic.png\\"\\n" }'
      );
      compiler.emit('if pbr.aoMap != nil { holo += "    ao_map: \\"ao.png\\"\\n" }');
      compiler.indentLevel--;
      compiler.emit('}');
    }
    compiler.emit('holo += "  }\\n"');
    compiler.emit('holo += "}\\n"');
    compiler.emit('return holo');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ── SwiftUI View ──
  if (traits.has('object_capture_guide') || traits.has('object_capture')) {
    compiler.emit(`struct ${cls}ObjectCaptureView: View {`);
    compiler.indentLevel++;
    compiler.emit(`@StateObject private var manager = ${cls}ObjectCaptureManager()`);
    compiler.emit('');
    compiler.emit('var body: some View {');
    compiler.indentLevel++;
    compiler.emit('ZStack {');
    compiler.indentLevel++;
    compiler.emit('if let session = manager.captureSession {');
    compiler.indentLevel++;
    compiler.emit('ObjectCapturePointCloudView(session: session)');
    compiler.emit('    .edgesIgnoringSafeArea(.all)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('VStack {');
    compiler.indentLevel++;
    compiler.emit('Spacer()');
    compiler.emit('');

    // ── Feedback messages ──
    compiler.emit('// Coverage indicator and feedback');
    compiler.emit('if !manager.feedbackMessages.isEmpty {');
    compiler.indentLevel++;
    compiler.emit('Text(manager.feedbackMessages.last ?? "")');
    compiler.emit('    .font(.caption)');
    compiler.emit('    .foregroundColor(.white)');
    compiler.emit('    .padding(8)');
    compiler.emit('    .background(Color.black.opacity(0.6))');
    compiler.emit('    .cornerRadius(8)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');

    // ── Progress indicator ──
    compiler.emit('if manager.state == .processing {');
    compiler.indentLevel++;
    compiler.emit('ProgressView(value: Double(manager.progress))');
    compiler.emit('    .progressViewStyle(.linear)');
    compiler.emit('    .padding()');
    compiler.emit('Text("Processing: \\(Int(manager.progress * 100))%")');
    compiler.emit('    .foregroundColor(.white)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');

    // ── Capture controls ──
    compiler.emit('HStack(spacing: 20) {');
    compiler.indentLevel++;
    compiler.emit('switch manager.state {');
    compiler.emit('case .ready:');
    compiler.indentLevel++;
    compiler.emit('Button("Start Capture") { manager.startCapture() }');
    compiler.emit('    .buttonStyle(.borderedProminent)');
    compiler.indentLevel--;
    compiler.emit('case .capturing:');
    compiler.indentLevel++;
    compiler.emit('Button("Finish Capture") { manager.stopCapture() }');
    compiler.emit('    .buttonStyle(.borderedProminent)');
    compiler.emit('    .tint(.red)');
    compiler.indentLevel--;
    compiler.emit('case .completed:');
    compiler.indentLevel++;
    compiler.emit('if let entity = manager.capturedEntity {');
    compiler.indentLevel++;
    compiler.emit('NavigationLink("Preview Model") {');
    compiler.indentLevel++;
    compiler.emit(`${cls}ModelPreviewView(url: entity.modelURL)`);
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('.buttonStyle(.borderedProminent)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('case .failed(let message):');
    compiler.indentLevel++;
    compiler.emit('Text("Error: \\(message)")');
    compiler.emit('    .foregroundColor(.red)');
    compiler.indentLevel--;
    compiler.emit('default: EmptyView()');
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('.padding()');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');

    // ── Model preview ──
    compiler.emit(`struct ${cls}ModelPreviewView: View {`);
    compiler.indentLevel++;
    compiler.emit('let url: URL');
    compiler.emit('');
    compiler.emit('var body: some View {');
    compiler.indentLevel++;
    compiler.emit('Model3D(url: url) { model in');
    compiler.indentLevel++;
    compiler.emit('model.resizable()');
    compiler.emit('    .aspectRatio(contentMode: .fit)');
    compiler.indentLevel--;
    compiler.emit('} placeholder: {');
    compiler.indentLevel++;
    compiler.emit('ProgressView()');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('.navigationTitle("Captured Object")');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
  }

  return compiler.lines.join('\n');
}

export function hasSharePlayTraits(composition: HoloComposition): boolean {
  const sharePlayNames: ReadonlyArray<string> = SHAREPLAY_TRAITS;
  for (const obj of composition.objects || []) {
    for (const trait of obj.traits || []) {
      const name = typeof trait === 'string' ? trait : trait.name;
      if (sharePlayNames.includes(name)) return true;
    }
  }
  return false;
}

export function generateSharePlayFile(compiler: IOSCompiler, composition: HoloComposition): string {
  compiler.lines = [];
  compiler.indentLevel = 0;

  const cls = compiler.options.className;

  compiler.emit('// Auto-generated by HoloScript IOSCompiler — SharePlay Multi-User AR');
  compiler.emit(
    `// Source: composition "${escapeStringValue(composition.name as string, 'Swift')}"`
  );
  compiler.emit('// Requires iOS 15.4+, GroupActivities framework');
  compiler.emit('// Do not edit manually — regenerate from .holo source');
  compiler.emit('');
  compiler.emit('import Foundation');
  compiler.emit('import GroupActivities');
  compiler.emit('import ARKit');
  compiler.emit('import SceneKit');
  compiler.emit('import RealityKit');
  compiler.emit('import SwiftUI');
  compiler.emit('import Combine');
  compiler.emit('');

  // ─── GroupActivity conforming type ──────────────────────────────
  compiler.emit('// MARK: - GroupActivity Definition');
  compiler.emit('');
  compiler.emit('struct HoloGroupActivity: GroupActivity {');
  compiler.indentLevel++;
  compiler.emit(`let sceneName: String`);
  compiler.emit('');
  compiler.emit('var metadata: GroupActivityMetadata {');
  compiler.indentLevel++;
  compiler.emit('var meta = GroupActivityMetadata()');
  compiler.emit(`meta.title = NSLocalizedString("HoloScript AR Session", comment: "")`);
  compiler.emit('meta.type = .generic');
  compiler.emit('return meta');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── Codable messages for scene sync ────────────────────────────
  compiler.emit('// MARK: - Sync Messages (Codable, Loro CRDT-inspired diffs)');
  compiler.emit('');
  compiler.emit('struct SceneStateDiff: Codable {');
  compiler.indentLevel++;
  compiler.emit('let senderId: String');
  compiler.emit('let timestamp: TimeInterval');
  compiler.emit('let entityUpdates: [EntityUpdate]');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit('struct EntityUpdate: Codable {');
  compiler.indentLevel++;
  compiler.emit('let entityId: String');
  compiler.emit('let ownerId: String?');
  compiler.emit('let position: [Float]?');
  compiler.emit('let rotation: [Float]?');
  compiler.emit('let scale: [Float]?');
  compiler.emit('let properties: [String: String]?');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit('struct FullStateSnapshot: Codable {');
  compiler.indentLevel++;
  compiler.emit('let senderId: String');
  compiler.emit('let timestamp: TimeInterval');
  compiler.emit('let entities: [EntityUpdate]');
  compiler.emit('let ownershipMap: [String: String]');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── Ownership transfer message ─────────────────────────────────
  if (compiler.compositionHasTrait(composition, 'shareplay_entity_ownership')) {
    compiler.emit('struct OwnershipTransferRequest: Codable {');
    compiler.indentLevel++;
    compiler.emit('let entityId: String');
    compiler.emit('let fromParticipantId: String');
    compiler.emit('let toParticipantId: String');
    compiler.emit('let timestamp: TimeInterval');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── SharePlayManager class ─────────────────────────────────────
  compiler.emit(`// MARK: - ${cls}SharePlayManager`);
  compiler.emit('');
  compiler.emit(`class ${cls}SharePlayManager: NSObject, ObservableObject {`);
  compiler.indentLevel++;
  compiler.emit('');

  // Properties
  compiler.emit('// Session state');
  compiler.emit('private var groupSession: GroupSession<HoloGroupActivity>?');
  compiler.emit('private var messenger: GroupSessionMessenger?');
  compiler.emit('private var subscriptions = Set<AnyCancellable>()');
  compiler.emit('private var tasks = [Task<Void, Never>]()');
  compiler.emit('');
  compiler.emit('@Published var isSessionActive: Bool = false');
  compiler.emit('@Published var isHost: Bool = false');
  compiler.emit('@Published var participants: [Participant] = []');
  compiler.emit('@Published var localParticipantId: String = UUID().uuidString');
  compiler.emit('');

  // Ownership tracking
  if (compiler.compositionHasTrait(composition, 'shareplay_entity_ownership')) {
    compiler.emit('// Entity ownership map: entityId -> participantId');
    compiler.emit('private var entityOwnership: [String: String] = [:]');
    compiler.emit('');
  }

  // Scene state for sync
  if (compiler.compositionHasTrait(composition, 'shareplay_sync')) {
    compiler.emit('// Scene state for CRDT-inspired sync');
    compiler.emit('private var sceneEntities: [String: EntityUpdate] = [:]');
    compiler.emit('private var lastSyncTimestamp: TimeInterval = 0');
    compiler.emit('');
  }

  // Local anchor mapping
  if (compiler.compositionHasTrait(composition, 'shareplay_anchor_local')) {
    compiler.emit(
      '// Local AR anchor mapping — each participant maps shared positions to local space'
    );
    compiler.emit('private var localWorldTransform: simd_float4x4 = matrix_identity_float4x4');
    compiler.emit('private var sharedToLocalOffset: simd_float3 = .zero');
    compiler.emit('');
  }

  // Spatial audio
  if (compiler.compositionHasTrait(composition, 'shareplay_voice_spatial')) {
    compiler.emit('// Spatial audio for participant voices');
    compiler.emit(
      'private var spatialAudioExperience: SpatialAudioExperience = .custom(fixedToScene: true)'
    );
    compiler.emit('');
  }

  // Mute zones
  if (compiler.compositionHasTrait(composition, 'shareplay_mute_zone')) {
    compiler.emit('// Spatial mute zones — regions where audio attenuates');
    compiler.emit('struct MuteZone {');
    compiler.indentLevel++;
    compiler.emit('let center: simd_float3');
    compiler.emit('let radius: Float');
    compiler.emit('let attenuation: Float // 0.0 = full mute, 1.0 = no effect');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('private var muteZones: [MuteZone] = []');
    compiler.emit('');
  }

  // ─── Init ───────────────────────────────────────────────────────
  compiler.emit('override init() {');
  compiler.indentLevel++;
  compiler.emit('super.init()');
  compiler.emit('observeGroupSessions()');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── Session lifecycle: shareplay_session ───────────────────────
  compiler.emit('// MARK: - Session Lifecycle');
  compiler.emit('');
  compiler.emit('private func observeGroupSessions() {');
  compiler.indentLevel++;
  compiler.emit('let activity = HoloGroupActivity(sceneName: "' + cls + '")');
  compiler.emit('Task {');
  compiler.indentLevel++;
  compiler.emit('for await session in activity.sessions() {');
  compiler.indentLevel++;
  compiler.emit('configureSession(session)');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  compiler.emit('private func configureSession(_ session: GroupSession<HoloGroupActivity>) {');
  compiler.indentLevel++;
  compiler.emit('self.groupSession = session');
  compiler.emit('self.messenger = GroupSessionMessenger(session: session)');
  compiler.emit('');
  compiler.emit('// State machine: .waitingForActivation -> .joined');
  compiler.emit('session.$state.sink { [weak self] state in');
  compiler.indentLevel++;
  compiler.emit('guard let self = self else { return }');
  compiler.emit('switch state {');
  compiler.emit('case .joined:');
  compiler.indentLevel++;
  compiler.emit('self.isSessionActive = true');
  compiler.emit('self.setupMessageHandlers()');
  compiler.indentLevel--;
  compiler.emit('case .waitingForActivation:');
  compiler.indentLevel++;
  compiler.emit('session.join()');
  compiler.indentLevel--;
  compiler.emit('default:');
  compiler.indentLevel++;
  compiler.emit('self.isSessionActive = false');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('.store(in: &subscriptions)');
  compiler.emit('');

  // Track participants
  compiler.emit('session.$activeParticipants.sink { [weak self] active in');
  compiler.indentLevel++;
  compiler.emit('self?.participants = Array(active)');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('.store(in: &subscriptions)');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── Host authority: shareplay_host ──────────────────────────────
  if (compiler.compositionHasTrait(composition, 'shareplay_host')) {
    compiler.emit('// MARK: - Host Authority');
    compiler.emit('');
    compiler.emit('func becomeHost() {');
    compiler.indentLevel++;
    compiler.emit('isHost = true');
    compiler.emit('broadcastSceneState() // Host pushes authoritative state to all participants');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('private func broadcastSceneState() {');
    compiler.indentLevel++;
    compiler.emit('guard isHost, let messenger = messenger else { return }');
    compiler.emit('let snapshot = FullStateSnapshot(');
    compiler.indentLevel++;
    compiler.emit('senderId: localParticipantId,');
    compiler.emit('timestamp: Date().timeIntervalSince1970,');
    compiler.emit('entities: Array(sceneEntities.values),');
    compiler.emit('ownershipMap: entityOwnership');
    compiler.indentLevel--;
    compiler.emit(')');
    compiler.emit('Task {');
    compiler.indentLevel++;
    compiler.emit('try? await messenger.send(snapshot)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── Join flow: shareplay_join ───────────────────────────────────
  if (compiler.compositionHasTrait(composition, 'shareplay_join')) {
    compiler.emit('// MARK: - Join Flow');
    compiler.emit('');
    compiler.emit('func startSharePlay() async throws {');
    compiler.indentLevel++;
    compiler.emit('let activity = HoloGroupActivity(sceneName: "' + cls + '")');
    compiler.emit('let result = try await activity.prepareForActivation()');
    compiler.emit('switch result {');
    compiler.emit('case .activationPreferred:');
    compiler.indentLevel++;
    compiler.emit('activity.activate()');
    compiler.indentLevel--;
    compiler.emit('case .activationDisabled:');
    compiler.indentLevel++;
    compiler.emit('break // SharePlay not available in current FaceTime call');
    compiler.indentLevel--;
    compiler.emit('default:');
    compiler.indentLevel++;
    compiler.emit('break');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── Message handlers: shareplay_sync ────────────────────────────
  compiler.emit('// MARK: - Message Handlers');
  compiler.emit('');
  compiler.emit('private func setupMessageHandlers() {');
  compiler.indentLevel++;
  compiler.emit('guard let messenger = messenger else { return }');
  compiler.emit('');

  // Scene state diffs
  if (compiler.compositionHasTrait(composition, 'shareplay_sync')) {
    compiler.emit('// Receive scene state diffs (Loro CRDT-inspired: last-writer-wins per entity)');
    compiler.emit('let diffTask = Task {');
    compiler.indentLevel++;
    compiler.emit('for await (diff, _) in messenger.messages(of: SceneStateDiff.self) {');
    compiler.indentLevel++;
    compiler.emit('await MainActor.run {');
    compiler.indentLevel++;
    compiler.emit('self.applySceneDiff(diff)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('tasks.append(diffTask)');
    compiler.emit('');
  }

  // Late join snapshots
  if (compiler.compositionHasTrait(composition, 'shareplay_late_join')) {
    compiler.emit('// Receive full state snapshots for late-joining participants');
    compiler.emit('let snapshotTask = Task {');
    compiler.indentLevel++;
    compiler.emit('for await (snapshot, _) in messenger.messages(of: FullStateSnapshot.self) {');
    compiler.indentLevel++;
    compiler.emit('await MainActor.run {');
    compiler.indentLevel++;
    compiler.emit('self.applyFullSnapshot(snapshot)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('tasks.append(snapshotTask)');
    compiler.emit('');
  }

  // Ownership transfer
  if (compiler.compositionHasTrait(composition, 'shareplay_entity_ownership')) {
    compiler.emit('// Receive ownership transfer requests');
    compiler.emit('let ownershipTask = Task {');
    compiler.indentLevel++;
    compiler.emit(
      'for await (request, _) in messenger.messages(of: OwnershipTransferRequest.self) {'
    );
    compiler.indentLevel++;
    compiler.emit('await MainActor.run {');
    compiler.indentLevel++;
    compiler.emit('self.handleOwnershipTransfer(request)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('tasks.append(ownershipTask)');
    compiler.emit('');
  }

  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── Sync helpers ────────────────────────────────────────────────
  if (compiler.compositionHasTrait(composition, 'shareplay_sync')) {
    compiler.emit('// MARK: - Scene Sync (Loro CRDT-inspired diff application)');
    compiler.emit('');
    compiler.emit('func sendSceneUpdate(_ updates: [EntityUpdate]) {');
    compiler.indentLevel++;
    compiler.emit('guard let messenger = messenger else { return }');
    compiler.emit('let diff = SceneStateDiff(');
    compiler.indentLevel++;
    compiler.emit('senderId: localParticipantId,');
    compiler.emit('timestamp: Date().timeIntervalSince1970,');
    compiler.emit('entityUpdates: updates');
    compiler.indentLevel--;
    compiler.emit(')');
    compiler.emit('Task {');
    compiler.indentLevel++;
    compiler.emit('try? await messenger.send(diff)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('private func applySceneDiff(_ diff: SceneStateDiff) {');
    compiler.indentLevel++;
    compiler.emit('guard diff.timestamp > lastSyncTimestamp else { return }');
    compiler.emit('for update in diff.entityUpdates {');
    compiler.indentLevel++;
    compiler.emit('sceneEntities[update.entityId] = update');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('lastSyncTimestamp = diff.timestamp');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── Late join snapshot ──────────────────────────────────────────
  if (compiler.compositionHasTrait(composition, 'shareplay_late_join')) {
    compiler.emit('// MARK: - Late Join');
    compiler.emit('');
    compiler.emit('func requestFullState() {');
    compiler.indentLevel++;
    compiler.emit('// Late joiner requests state — host responds with snapshot');
    compiler.emit('guard let messenger = messenger else { return }');
    compiler.emit('Task {');
    compiler.indentLevel++;
    compiler.emit('let request = SceneStateDiff(');
    compiler.indentLevel++;
    compiler.emit('senderId: localParticipantId,');
    compiler.emit('timestamp: 0, // Signal: requesting full state');
    compiler.emit('entityUpdates: []');
    compiler.indentLevel--;
    compiler.emit(')');
    compiler.emit('try? await messenger.send(request)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('private func applyFullSnapshot(_ snapshot: FullStateSnapshot) {');
    compiler.indentLevel++;
    compiler.emit('sceneEntities.removeAll()');
    compiler.emit('for entity in snapshot.entities {');
    compiler.indentLevel++;
    compiler.emit('sceneEntities[entity.entityId] = entity');
    compiler.indentLevel--;
    compiler.emit('}');

    if (compiler.compositionHasTrait(composition, 'shareplay_entity_ownership')) {
      compiler.emit('entityOwnership = snapshot.ownershipMap');
    }

    compiler.emit('lastSyncTimestamp = snapshot.timestamp');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── Entity ownership ────────────────────────────────────────────
  if (compiler.compositionHasTrait(composition, 'shareplay_entity_ownership')) {
    compiler.emit('// MARK: - Entity Ownership');
    compiler.emit('');
    compiler.emit('func claimOwnership(entityId: String) {');
    compiler.indentLevel++;
    compiler.emit('entityOwnership[entityId] = localParticipantId');
    compiler.emit('guard let messenger = messenger else { return }');
    compiler.emit('let request = OwnershipTransferRequest(');
    compiler.indentLevel++;
    compiler.emit('entityId: entityId,');
    compiler.emit('fromParticipantId: "",');
    compiler.emit('toParticipantId: localParticipantId,');
    compiler.emit('timestamp: Date().timeIntervalSince1970');
    compiler.indentLevel--;
    compiler.emit(')');
    compiler.emit('Task {');
    compiler.indentLevel++;
    compiler.emit('try? await messenger.send(request)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('func transferOwnership(entityId: String, toParticipant: String) {');
    compiler.indentLevel++;
    compiler.emit('guard entityOwnership[entityId] == localParticipantId else { return }');
    compiler.emit('entityOwnership[entityId] = toParticipant');
    compiler.emit('guard let messenger = messenger else { return }');
    compiler.emit('let request = OwnershipTransferRequest(');
    compiler.indentLevel++;
    compiler.emit('entityId: entityId,');
    compiler.emit('fromParticipantId: localParticipantId,');
    compiler.emit('toParticipantId: toParticipant,');
    compiler.emit('timestamp: Date().timeIntervalSince1970');
    compiler.indentLevel--;
    compiler.emit(')');
    compiler.emit('Task {');
    compiler.indentLevel++;
    compiler.emit('try? await messenger.send(request)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('func isOwnedByLocal(entityId: String) -> Bool {');
    compiler.indentLevel++;
    compiler.emit('return entityOwnership[entityId] == localParticipantId');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('private func handleOwnershipTransfer(_ request: OwnershipTransferRequest) {');
    compiler.indentLevel++;
    compiler.emit('entityOwnership[request.entityId] = request.toParticipantId');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── Local anchor mapping ────────────────────────────────────────
  if (compiler.compositionHasTrait(composition, 'shareplay_anchor_local')) {
    compiler.emit('// MARK: - Local Anchor Mapping');
    compiler.emit('');
    compiler.emit(
      'func calibrateLocalAnchor(arFrame: ARFrame, sharedReferencePoint: simd_float3) {'
    );
    compiler.indentLevel++;
    compiler.emit('// Each participant creates a local ARKit anchor and maps shared positions');
    compiler.emit('let cameraPos = arFrame.camera.transform.columns.3');
    compiler.emit(
      'sharedToLocalOffset = simd_float3(cameraPos[0], cameraPos[1], cameraPos[2]) - sharedReferencePoint'
    );
    compiler.emit('localWorldTransform = arFrame.camera.transform');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('func sharedToLocal(_ sharedPosition: simd_float3) -> simd_float3 {');
    compiler.indentLevel++;
    compiler.emit('return sharedPosition + sharedToLocalOffset');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('func localToShared(_ localPosition: simd_float3) -> simd_float3 {');
    compiler.indentLevel++;
    compiler.emit('return localPosition - sharedToLocalOffset');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── Spatial audio: shareplay_voice_spatial ──────────────────────
  if (compiler.compositionHasTrait(composition, 'shareplay_voice_spatial')) {
    compiler.emit('// MARK: - Spatial Audio');
    compiler.emit('');
    compiler.emit('func configureSpatialAudio() {');
    compiler.indentLevel++;
    compiler.emit('// SpatialAudioExperience.custom(fixedToScene: true) for participant voices');
    compiler.emit('guard let session = groupSession else { return }');
    compiler.emit('session.spatialAudioExperience = .custom(fixedToScene: true)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── Mute zones: shareplay_mute_zone ─────────────────────────────
  if (compiler.compositionHasTrait(composition, 'shareplay_mute_zone')) {
    compiler.emit('// MARK: - Mute Zones');
    compiler.emit('');
    compiler.emit(
      'func addMuteZone(center: simd_float3, radius: Float, attenuation: Float = 0.0) {'
    );
    compiler.indentLevel++;
    compiler.emit(
      'muteZones.append(MuteZone(center: center, radius: radius, attenuation: attenuation))'
    );
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('func audioAttenuation(at position: simd_float3) -> Float {');
    compiler.indentLevel++;
    compiler.emit('var minAttenuation: Float = 1.0');
    compiler.emit('for zone in muteZones {');
    compiler.indentLevel++;
    compiler.emit('let distance = simd_distance(position, zone.center)');
    compiler.emit('if distance < zone.radius {');
    compiler.indentLevel++;
    compiler.emit('let factor = distance / zone.radius');
    compiler.emit('let zoneAttenuation = zone.attenuation + (1.0 - zone.attenuation) * factor');
    compiler.emit('minAttenuation = min(minAttenuation, zoneAttenuation)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('return minAttenuation');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── Cleanup ─────────────────────────────────────────────────────
  compiler.emit('// MARK: - Cleanup');
  compiler.emit('');
  compiler.emit('func endSession() {');
  compiler.indentLevel++;
  compiler.emit('tasks.forEach { $0.cancel() }');
  compiler.emit('tasks.removeAll()');
  compiler.emit('subscriptions.removeAll()');
  compiler.emit('groupSession?.end()');
  compiler.emit('groupSession = nil');
  compiler.emit('messenger = nil');
  compiler.emit('isSessionActive = false');
  compiler.indentLevel--;
  compiler.emit('}');

  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── SwiftUI View ────────────────────────────────────────────────
  compiler.emit(`// MARK: - ${cls}SharePlayView`);
  compiler.emit('');
  compiler.emit(`struct ${cls}SharePlayView: View {`);
  compiler.indentLevel++;
  compiler.emit(`@StateObject private var manager = ${cls}SharePlayManager()`);
  compiler.emit('');
  compiler.emit('var body: some View {');
  compiler.indentLevel++;
  compiler.emit('VStack {');
  compiler.indentLevel++;

  compiler.emit('// Session status');
  compiler.emit('HStack {');
  compiler.indentLevel++;
  compiler.emit('Image(systemName: manager.isSessionActive ? "person.2.fill" : "person.2")');
  compiler.emit('Text(manager.isSessionActive ? "SharePlay Active" : "SharePlay Inactive")');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('.padding()');
  compiler.emit('');

  compiler.emit('// Participant list');
  compiler.emit('if !manager.participants.isEmpty {');
  compiler.indentLevel++;
  compiler.emit('List(manager.participants, id: \\.id) { participant in');
  compiler.indentLevel++;
  compiler.emit('HStack {');
  compiler.indentLevel++;
  compiler.emit('Image(systemName: "person.circle")');
  compiler.emit('Text("Participant \\(participant.id)")');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('.frame(maxHeight: 200)');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  compiler.emit('// Shared AR scene placeholder');
  compiler.emit('ZStack {');
  compiler.indentLevel++;
  compiler.emit('Color.black.opacity(0.3)');
  compiler.emit('Text("Shared AR Scene")');
  compiler.emit('    .foregroundColor(.white)');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('.frame(maxWidth: .infinity, maxHeight: .infinity)');
  compiler.emit('.cornerRadius(12)');
  compiler.emit('.padding()');

  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');

  return compiler.lines.join('\n');
}

export function hasFaceTrackingTraits(composition: HoloComposition): boolean {
  const faceTraitNames: ReadonlyArray<string> = FACE_TRACKING_TRAITS;
  for (const obj of composition.objects || []) {
    for (const trait of obj.traits || []) {
      const name = typeof trait === 'string' ? trait : trait.name;
      if (faceTraitNames.includes(name)) return true;
    }
  }
  return false;
}

export function generateFaceTrackingFile(
  compiler: IOSCompiler,
  composition: HoloComposition
): string {
  compiler.lines = [];
  compiler.indentLevel = 0;

  const cls = compiler.options.className;

  const hasBlendshapes = compiler.compositionHasTrait(composition, 'face_blendshapes');
  const hasMesh = compiler.compositionHasTrait(composition, 'face_mesh');
  const hasTransform = compiler.compositionHasTrait(composition, 'face_transform');
  const hasAvatarDrive = compiler.compositionHasTrait(composition, 'face_avatar_drive');
  const hasMirror = compiler.compositionHasTrait(composition, 'face_blendshape_mirror');
  const hasPuppet = compiler.compositionHasTrait(composition, 'face_puppet');
  const hasRetarget = compiler.compositionHasTrait(composition, 'face_retarget');
  const hasEmotion = compiler.compositionHasTrait(composition, 'face_emotion_detect');
  const hasGaze = compiler.compositionHasTrait(composition, 'face_gaze_direction');
  const hasTongue = compiler.compositionHasTrait(composition, 'face_tongue_detect');

  compiler.emit('// Auto-generated by HoloScript IOSCompiler — TrueDepth Face Tracking');
  compiler.emit(
    `// Source: composition "${escapeStringValue(composition.name as string, 'Swift')}"`
  );
  compiler.emit('// Requires iOS 11.0+, ARKit, TrueDepth camera');
  compiler.emit('// Do not edit manually — regenerate from .holo source');
  compiler.emit('');
  compiler.emit('import Foundation');
  compiler.emit('import ARKit');
  compiler.emit('import SceneKit');
  compiler.emit('import SwiftUI');
  compiler.emit('import Combine');
  compiler.emit('');

  // DetectedEmotion enum
  if (hasEmotion) {
    compiler.emit('/// Emotions derived from ARKit blendshape combinations.');
    compiler.emit('enum DetectedEmotion: String, CaseIterable {');
    compiler.indentLevel++;
    compiler.emit('case neutral = "neutral"');
    compiler.emit('case happy = "happy"');
    compiler.emit('case sad = "sad"');
    compiler.emit('case surprised = "surprised"');
    compiler.emit('case angry = "angry"');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // FaceTrackingManager class
  compiler.emit(`class ${cls}FaceTrackingManager: NSObject, ObservableObject, ARSessionDelegate {`);
  compiler.indentLevel++;

  // Published properties
  compiler.emit('@Published var isTracking: Bool = false');
  if (hasBlendshapes || hasAvatarDrive || hasMirror || hasPuppet) {
    compiler.emit('@Published var blendShapes: [ARFaceAnchor.BlendShapeLocation: NSNumber] = [:]');
  }
  if (hasMesh) {
    compiler.emit('@Published var faceVertexCount: Int = 0');
  }
  if (hasTransform) {
    compiler.emit('@Published var headTransform: simd_float4x4 = matrix_identity_float4x4');
  }
  if (hasEmotion) {
    compiler.emit('@Published var currentEmotion: DetectedEmotion = .neutral');
  }
  if (hasGaze) {
    compiler.emit('@Published var gazeDirection: simd_float3 = simd_float3(0, 0, -1)');
  }
  if (hasTongue) {
    compiler.emit('@Published var isTongueOut: Bool = false');
  }
  if (hasRetarget) {
    compiler.emit('@Published var retargetedBlendShapes: [String: Float] = [:]');
    compiler.emit(
      'var retargetMap: [ARFaceAnchor.BlendShapeLocation: (target: String, scale: Float)] = [:]'
    );
  }
  compiler.emit('');
  compiler.emit('private var arSession: ARSession?');
  compiler.emit('');

  // init
  compiler.emit('override init() {');
  compiler.indentLevel++;
  compiler.emit('super.init()');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // startTracking
  compiler.emit('func startTracking() {');
  compiler.indentLevel++;
  compiler.emit('guard ARFaceTrackingConfiguration.isSupported else {');
  compiler.indentLevel++;
  compiler.emit('print("[HoloScript] TrueDepth face tracking not supported on this device")');
  compiler.emit('return');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit('let configuration = ARFaceTrackingConfiguration()');
  if (hasMesh) {
    compiler.emit('configuration.maximumNumberOfTrackedFaces = 1');
  }
  compiler.emit('');
  compiler.emit('let session = ARSession()');
  compiler.emit('session.delegate = self');
  compiler.emit('session.run(configuration)');
  compiler.emit('arSession = session');
  compiler.emit('');
  compiler.emit('DispatchQueue.main.async {');
  compiler.indentLevel++;
  compiler.emit('self.isTracking = true');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('print("[HoloScript] Face tracking started")');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // stopTracking
  compiler.emit('func stopTracking() {');
  compiler.indentLevel++;
  compiler.emit('arSession?.pause()');
  compiler.emit('arSession = nil');
  compiler.emit('DispatchQueue.main.async {');
  compiler.indentLevel++;
  compiler.emit('self.isTracking = false');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('print("[HoloScript] Face tracking stopped")');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ARSessionDelegate — session(_ didUpdate:)
  compiler.emit('// MARK: - ARSessionDelegate');
  compiler.emit('');
  compiler.emit('func session(_ session: ARSession, didUpdate anchors: [ARAnchor]) {');
  compiler.indentLevel++;
  compiler.emit(
    'guard let faceAnchor = anchors.compactMap({ $0 as? ARFaceAnchor }).first else { return }'
  );
  compiler.emit('');

  if (hasBlendshapes || hasAvatarDrive || hasMirror || hasPuppet) {
    compiler.emit('let shapes = faceAnchor.blendShapes');
    compiler.emit('DispatchQueue.main.async {');
    compiler.indentLevel++;
    compiler.emit('self.blendShapes = shapes');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  if (hasMesh) {
    compiler.emit('// Face mesh: 1220 vertices topology');
    compiler.emit('let geometry = faceAnchor.geometry');
    compiler.emit('DispatchQueue.main.async {');
    compiler.indentLevel++;
    compiler.emit('self.faceVertexCount = geometry.vertices.count');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  if (hasTransform) {
    compiler.emit('// Head position and orientation in world space');
    compiler.emit('DispatchQueue.main.async {');
    compiler.indentLevel++;
    compiler.emit('self.headTransform = faceAnchor.transform');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  if (hasGaze) {
    compiler.emit('// Gaze direction from lookAtPoint');
    compiler.emit('let lookAt = faceAnchor.lookAtPoint');
    compiler.emit('DispatchQueue.main.async {');
    compiler.indentLevel++;
    compiler.emit('self.gazeDirection = simd_float3(lookAt[0], lookAt[1], lookAt[2])');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  if (hasTongue) {
    compiler.emit('// Tongue detection');
    compiler.emit('let tongueValue = shapes[.tongueOut]?.floatValue ?? 0.0');
    compiler.emit('DispatchQueue.main.async {');
    compiler.indentLevel++;
    compiler.emit('self.isTongueOut = tongueValue > 0.5');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  if (hasEmotion) {
    compiler.emit('// Emotion detection from blendshape combinations');
    compiler.emit('self.detectEmotion(from: faceAnchor.blendShapes)');
    compiler.emit('');
  }

  if (hasRetarget) {
    compiler.emit('// Retarget blendshapes to non-human topology');
    compiler.emit('self.applyRetargeting(from: faceAnchor.blendShapes)');
    compiler.emit('');
  }

  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // Mirror / Avatar Drive methods
  if (hasMirror || hasAvatarDrive) {
    compiler.emit('// MARK: - Blendshape Mirror');
    compiler.emit('');
    compiler.emit('/// Returns all 52 blendshape coefficients as a dictionary of String to Float.');
    compiler.emit('func getBlendShapeCoefficients() -> [String: Float] {');
    compiler.indentLevel++;
    compiler.emit('var result: [String: Float] = [:]');
    compiler.emit('for (key, value) in blendShapes {');
    compiler.indentLevel++;
    compiler.emit('result[key.rawValue] = value.floatValue');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('return result');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  if (hasAvatarDrive) {
    compiler.emit('/// Drives avatar morph targets with current face blendshapes.');
    compiler.emit('func driveAvatar(morphTargets: inout [String: Float]) {');
    compiler.indentLevel++;
    compiler.emit('for (key, value) in blendShapes {');
    compiler.indentLevel++;
    compiler.emit('morphTargets[key.rawValue] = value.floatValue');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  if (hasPuppet) {
    compiler.emit('// MARK: - Puppet Mode');
    compiler.emit('');
    compiler.emit('/// Puppet mode: avatar responds exclusively to face input.');
    compiler.emit(
      '/// Returns a complete morph target dictionary derived solely from face tracking.'
    );
    compiler.emit('func getPuppetMorphTargets() -> [String: Float] {');
    compiler.indentLevel++;
    compiler.emit('var targets: [String: Float] = [:]');
    compiler.emit('for (key, value) in blendShapes {');
    compiler.indentLevel++;
    compiler.emit('targets[key.rawValue] = value.floatValue');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('return targets');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  if (hasRetarget) {
    compiler.emit('// MARK: - Retargeting');
    compiler.emit('');
    compiler.emit(
      '/// Applies retarget map to remap/scale blendshapes for non-human avatar topologies.'
    );
    compiler.emit(
      'private func applyRetargeting(from shapes: [ARFaceAnchor.BlendShapeLocation: NSNumber]) {'
    );
    compiler.indentLevel++;
    compiler.emit('var result: [String: Float] = [:]');
    compiler.emit('for (arkitShape, value) in shapes {');
    compiler.indentLevel++;
    compiler.emit('if let mapping = retargetMap[arkitShape] {');
    compiler.indentLevel++;
    compiler.emit('result[mapping.target] = value.floatValue * mapping.scale');
    compiler.indentLevel--;
    compiler.emit('} else {');
    compiler.indentLevel++;
    compiler.emit('result[arkitShape.rawValue] = value.floatValue');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('DispatchQueue.main.async {');
    compiler.indentLevel++;
    compiler.emit('self.retargetedBlendShapes = result');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  if (hasEmotion) {
    compiler.emit('// MARK: - Emotion Detection');
    compiler.emit('');
    compiler.emit('/// Derives emotion from blendshape combinations.');
    compiler.emit(
      'private func detectEmotion(from shapes: [ARFaceAnchor.BlendShapeLocation: NSNumber]) {'
    );
    compiler.indentLevel++;
    compiler.emit('let mouthSmileL = shapes[.mouthSmileLeft]?.floatValue ?? 0.0');
    compiler.emit('let mouthSmileR = shapes[.mouthSmileRight]?.floatValue ?? 0.0');
    compiler.emit('let mouthFrownL = shapes[.mouthFrownLeft]?.floatValue ?? 0.0');
    compiler.emit('let mouthFrownR = shapes[.mouthFrownRight]?.floatValue ?? 0.0');
    compiler.emit('let eyeWideL = shapes[.eyeWideLeft]?.floatValue ?? 0.0');
    compiler.emit('let eyeWideR = shapes[.eyeWideRight]?.floatValue ?? 0.0');
    compiler.emit('let jawOpen = shapes[.jawOpen]?.floatValue ?? 0.0');
    compiler.emit('let browDownL = shapes[.browDownLeft]?.floatValue ?? 0.0');
    compiler.emit('let browDownR = shapes[.browDownRight]?.floatValue ?? 0.0');
    compiler.emit('let mouthPressL = shapes[.mouthPressLeft]?.floatValue ?? 0.0');
    compiler.emit('let mouthPressR = shapes[.mouthPressRight]?.floatValue ?? 0.0');
    compiler.emit('');
    compiler.emit('let emotion: DetectedEmotion');
    compiler.emit('');
    compiler.emit('// Happy: mouthSmile > 0.5');
    compiler.emit('if (mouthSmileL + mouthSmileR) / 2.0 > 0.5 {');
    compiler.indentLevel++;
    compiler.emit('emotion = .happy');
    compiler.indentLevel--;
    compiler.emit('// Sad: mouthFrown > 0.5');
    compiler.emit('} else if (mouthFrownL + mouthFrownR) / 2.0 > 0.5 {');
    compiler.indentLevel++;
    compiler.emit('emotion = .sad');
    compiler.indentLevel--;
    compiler.emit('// Surprised: eyeWide + jawOpen');
    compiler.emit('} else if ((eyeWideL + eyeWideR) / 2.0 > 0.3) && (jawOpen > 0.3) {');
    compiler.indentLevel++;
    compiler.emit('emotion = .surprised');
    compiler.indentLevel--;
    compiler.emit('// Angry: browDown + mouthPress');
    compiler.emit(
      '} else if ((browDownL + browDownR) / 2.0 > 0.4) && ((mouthPressL + mouthPressR) / 2.0 > 0.3) {'
    );
    compiler.indentLevel++;
    compiler.emit('emotion = .angry');
    compiler.indentLevel--;
    compiler.emit('} else {');
    compiler.indentLevel++;
    compiler.emit('emotion = .neutral');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('DispatchQueue.main.async {');
    compiler.indentLevel++;
    compiler.emit('self.currentEmotion = emotion');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // SwiftUI preview with live blendshape coefficients
  compiler.emit('// MARK: - SwiftUI Preview');
  compiler.emit('');
  compiler.emit(`struct ${cls}FaceTrackingPreview: View {`);
  compiler.indentLevel++;
  compiler.emit(`@StateObject private var manager = ${cls}FaceTrackingManager()`);
  compiler.emit('');
  compiler.emit('var body: some View {');
  compiler.indentLevel++;
  compiler.emit('VStack(alignment: .leading, spacing: 8) {');
  compiler.indentLevel++;
  compiler.emit('Text("Face Tracking").font(.headline)');
  compiler.emit('Text("Tracking: \\(manager.isTracking ? "Active" : "Inactive")")');
  if (hasBlendshapes || hasAvatarDrive || hasMirror || hasPuppet) {
    compiler.emit('');
    compiler.emit('Text("Blendshapes (\\(manager.blendShapes.count))").font(.subheadline)');
    compiler.emit('ScrollView {');
    compiler.indentLevel++;
    compiler.emit(
      'ForEach(Array(manager.blendShapes.keys).sorted(by: { $0.rawValue < $1.rawValue }), id: \\.rawValue) { key in'
    );
    compiler.indentLevel++;
    compiler.emit('HStack {');
    compiler.indentLevel++;
    compiler.emit('Text(key.rawValue).font(.caption).frame(width: 200, alignment: .leading)');
    compiler.emit('ProgressView(value: Double(truncating: manager.blendShapes[key] ?? 0))');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
  }
  if (hasEmotion) {
    compiler.emit('Text("Emotion: \\(manager.currentEmotion.rawValue)").font(.subheadline)');
  }
  if (hasGaze) {
    compiler.emit(
      'Text("Gaze: \\(manager.gazeDirection[0], specifier: "%.2f"), \\(manager.gazeDirection[1], specifier: "%.2f"), \\(manager.gazeDirection[2], specifier: "%.2f")").font(.caption)'
    );
  }
  if (hasTongue) {
    compiler.emit('Text("Tongue Out: \\(manager.isTongueOut ? "Yes" : "No")").font(.caption)');
  }
  if (hasMesh) {
    compiler.emit('Text("Face Vertices: \\(manager.faceVertexCount)").font(.caption)');
  }
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('.padding()');
  compiler.emit('.onAppear { manager.startTracking() }');
  compiler.emit('.onDisappear { manager.stopTracking() }');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit(`#Preview {`);
  compiler.indentLevel++;
  compiler.emit(`${cls}FaceTrackingPreview()`);
  compiler.indentLevel--;
  compiler.emit('}');

  return compiler.lines.join('\n');
}

export function hasUWBPositioningTraits(composition: HoloComposition): boolean {
  const uwbNames: ReadonlyArray<string> = UWB_POSITIONING_TRAITS;
  for (const obj of composition.objects || []) {
    for (const trait of obj.traits || []) {
      const name = typeof trait === 'string' ? trait : trait.name;
      if (uwbNames.includes(name)) return true;
    }
  }
  return false;
}

export function generateUWBPositioningFile(
  compiler: IOSCompiler,
  composition: HoloComposition
): string {
  compiler.lines = [];
  compiler.indentLevel = 0;

  const cls = compiler.options.className;

  compiler.emit('// Auto-generated by HoloScript IOSCompiler — UWB Positioning');
  compiler.emit(
    `// Source: composition "${escapeStringValue(composition.name as string, 'Swift')}"`
  );
  compiler.emit('// Requires iOS 16+, U1/U2 chip (iPhone 11+), Nearby Interaction framework');
  compiler.emit('// Do not edit manually — regenerate from .holo source');
  compiler.emit('');
  compiler.emit('import Foundation');
  compiler.emit('import NearbyInteraction');
  compiler.emit('import MultipeerConnectivity');
  compiler.emit('import ARKit');
  compiler.emit('import SceneKit');
  compiler.emit('import SwiftUI');
  if (compiler.options.useCombine) {
    compiler.emit('import Combine');
  }
  compiler.emit('');

  // ─── Peer model ────────────────────────────────────────────────
  compiler.emit('// MARK: - UWB Peer Model');
  compiler.emit('');
  compiler.emit('struct UWBPeer: Identifiable, Hashable {');
  compiler.indentLevel++;
  compiler.emit('let id: String');
  compiler.emit('let discoveryToken: NIDiscoveryToken');
  compiler.emit('var distance: Float?');
  compiler.emit('var direction: simd_float3?');
  compiler.emit('var lastSeen: Date = Date()');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── Delegate protocol ─────────────────────────────────────────
  compiler.emit('// MARK: - UWB Positioning Delegate');
  compiler.emit('');
  compiler.emit(`protocol ${cls}UWBDelegate: AnyObject {`);
  compiler.indentLevel++;
  compiler.emit('func didDiscoverPeer(_ peer: UWBPeer)');
  compiler.emit('func didUpdatePeer(_ peer: UWBPeer)');
  compiler.emit('func didLosePeer(_ peerId: String)');
  if (compiler.compositionHasTrait(composition, 'uwb_handoff')) {
    compiler.emit('func didReceiveHandoff(entityId: String, from peer: UWBPeer)');
  }
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── Main manager class ────────────────────────────────────────
  compiler.emit('// MARK: - UWB Positioning Manager');
  compiler.emit('');
  compiler.emit(`class ${cls}UWBManager: NSObject, ObservableObject {`);
  compiler.indentLevel++;
  compiler.emit('');
  compiler.emit('@Published var peers: [String: UWBPeer] = [:]');
  compiler.emit('@Published var isScanning = false');
  compiler.emit('');
  compiler.emit(`weak var delegate: ${cls}UWBDelegate?`);
  compiler.emit('');
  compiler.emit('private var niSession: NISession?');
  compiler.emit('private var peerTokenMap: [NIDiscoveryToken: String] = [:]');
  compiler.emit('private var mcSession: MCSession?');
  compiler.emit('private var mcAdvertiser: MCNearbyServiceAdvertiser?');
  compiler.emit('private var mcBrowser: MCNearbyServiceBrowser?');
  compiler.emit('private let serviceType = "holo-uwb"');
  compiler.emit('private let localPeerId = MCPeerID(displayName: UIDevice.current.name)');
  if (compiler.options.useCombine) {
    compiler.emit('private var cancellables = Set<AnyCancellable>()');
  }
  compiler.emit('');

  // ─── init ──────────────────────────────────────────────────────
  compiler.emit('override init() {');
  compiler.indentLevel++;
  compiler.emit('super.init()');
  compiler.emit('setupNISession()');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── NISession setup ───────────────────────────────────────────
  compiler.emit('// MARK: - NISession Setup');
  compiler.emit('');
  compiler.emit('private func setupNISession() {');
  compiler.indentLevel++;
  compiler.emit('guard NISession.isSupported else {');
  compiler.indentLevel++;
  compiler.emit('print("[UWB] Nearby Interaction not supported on this device")');
  compiler.emit('return');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('niSession = NISession()');
  compiler.emit('niSession?.delegate = self');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── uwb_discover: start/stop scanning ─────────────────────────
  if (compiler.compositionHasTrait(composition, 'uwb_discover')) {
    compiler.emit('// MARK: - Discovery (uwb_discover)');
    compiler.emit('');
    compiler.emit('func startDiscovery() {');
    compiler.indentLevel++;
    compiler.emit('guard !isScanning else { return }');
    compiler.emit('');
    compiler.emit(
      'let session = MCSession(peer: localPeerId, securityIdentity: nil, encryptionPreference: .required)'
    );
    compiler.emit('session.delegate = self');
    compiler.emit('mcSession = session');
    compiler.emit('');
    compiler.emit(
      'mcAdvertiser = MCNearbyServiceAdvertiser(peer: localPeerId, discoveryInfo: nil, serviceType: serviceType)'
    );
    compiler.emit('mcAdvertiser?.delegate = self');
    compiler.emit('mcAdvertiser?.startAdvertisingPeer()');
    compiler.emit('');
    compiler.emit(
      'mcBrowser = MCNearbyServiceBrowser(peer: localPeerId, serviceType: serviceType)'
    );
    compiler.emit('mcBrowser?.delegate = self');
    compiler.emit('mcBrowser?.startBrowsingForPeers()');
    compiler.emit('');
    compiler.emit('isScanning = true');
    compiler.emit('print("[UWB] Discovery started")');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('func stopDiscovery() {');
    compiler.indentLevel++;
    compiler.emit('mcAdvertiser?.stopAdvertisingPeer()');
    compiler.emit('mcBrowser?.stopBrowsingForPeers()');
    compiler.emit('mcSession?.disconnect()');
    compiler.emit('isScanning = false');
    compiler.emit('print("[UWB] Discovery stopped")');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── uwb_range: distance measurement ──────────────────────────
  if (compiler.compositionHasTrait(composition, 'uwb_range')) {
    compiler.emit('// MARK: - Ranging (uwb_range)');
    compiler.emit('');
    compiler.emit('func distanceToPeer(_ peerId: String) -> Float? {');
    compiler.indentLevel++;
    compiler.emit('return peers[peerId]?.distance');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('func nearestPeer() -> UWBPeer? {');
    compiler.indentLevel++;
    compiler.emit('return peers.values');
    compiler.emit('    .filter { $0.distance != nil }');
    compiler.emit('    .min { ($0.distance ?? .infinity) < ($1.distance ?? .infinity) }');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── uwb_direction: direction vector ───────────────────────────
  if (compiler.compositionHasTrait(composition, 'uwb_direction')) {
    compiler.emit('// MARK: - Direction (uwb_direction)');
    compiler.emit('');
    compiler.emit('func directionToPeer(_ peerId: String) -> simd_float3? {');
    compiler.indentLevel++;
    compiler.emit('return peers[peerId]?.direction');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('func azimuthToPeer(_ peerId: String) -> Float? {');
    compiler.indentLevel++;
    compiler.emit('guard let dir = peers[peerId]?.direction else { return nil }');
    compiler.emit('return atan2(dir[0], dir[2])');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('func elevationToPeer(_ peerId: String) -> Float? {');
    compiler.indentLevel++;
    compiler.emit('guard let dir = peers[peerId]?.direction else { return nil }');
    compiler.emit('return asin(dir[1])');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── uwb_handoff: holographic content handoff ──────────────────
  if (compiler.compositionHasTrait(composition, 'uwb_handoff')) {
    compiler.emit('// MARK: - Handoff (uwb_handoff)');
    compiler.emit('');
    compiler.emit('func handoffEntity(_ entityId: String, toPeer peerId: String) {');
    compiler.indentLevel++;
    compiler.emit('guard let session = mcSession else {');
    compiler.indentLevel++;
    compiler.emit('print("[UWB] No active session for handoff")');
    compiler.emit('return');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('let payload: [String: String] = [');
    compiler.indentLevel++;
    compiler.emit('"type": "uwb_handoff",');
    compiler.emit('"entityId": entityId,');
    compiler.emit('"senderId": localPeerId.displayName');
    compiler.indentLevel--;
    compiler.emit(']');
    compiler.emit('');
    compiler.emit(
      'guard let data = try? JSONSerialization.data(withJSONObject: payload) else { return }'
    );
    compiler.emit('');
    compiler.emit(
      'if let mcPeer = session.connectedPeers.first(where: { $0.displayName == peerId }) {'
    );
    compiler.indentLevel++;
    compiler.emit('try? session.send(data, toPeers: [mcPeer], with: .reliable)');
    compiler.emit('print("[UWB] Handoff entity \\(entityId) to \\(peerId)")');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('func handoffToNearest(_ entityId: String) {');
    compiler.indentLevel++;
    compiler.emit('guard let nearest = nearestPeer() else {');
    compiler.indentLevel++;
    compiler.emit('print("[UWB] No nearby peer for handoff")');
    compiler.emit('return');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('handoffEntity(entityId, toPeer: nearest.id)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── uwb_anchor_peer: use peer as spatial anchor ───────────────
  if (compiler.compositionHasTrait(composition, 'uwb_anchor_peer')) {
    compiler.emit('// MARK: - Peer Anchor (uwb_anchor_peer)');
    compiler.emit('');
    compiler.emit('func anchorPosition(for peerId: String) -> SCNVector3? {');
    compiler.indentLevel++;
    compiler.emit('guard let peer = peers[peerId],');
    compiler.emit('      let distance = peer.distance,');
    compiler.emit('      let direction = peer.direction else { return nil }');
    compiler.emit('let pos = direction * distance');
    compiler.emit('return SCNVector3(pos[0], pos[1], pos[2])');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── uwb_controller: use device as spatial controller ──────────
  if (compiler.compositionHasTrait(composition, 'uwb_controller')) {
    compiler.emit('// MARK: - Spatial Controller (uwb_controller)');
    compiler.emit('');
    compiler.emit('func controllerTransform(for peerId: String) -> SCNMatrix4? {');
    compiler.indentLevel++;
    compiler.emit('guard let peer = peers[peerId],');
    compiler.emit('      let distance = peer.distance,');
    compiler.emit('      let direction = peer.direction else { return nil }');
    compiler.emit('let pos = direction * distance');
    compiler.emit('let lookAt = SCNMatrix4LookAt(');
    compiler.indentLevel++;
    compiler.emit('SCNVector3(pos[0], pos[1], pos[2]),');
    compiler.emit('SCNVector3Zero,');
    compiler.emit('SCNVector3(0, 1, 0))');
    compiler.indentLevel--;
    compiler.emit('return lookAt');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── Shared token exchange helper ──────────────────────────────
  compiler.emit('// MARK: - Token Exchange');
  compiler.emit('');
  compiler.emit('private func shareDiscoveryToken(with mcPeer: MCPeerID) {');
  compiler.indentLevel++;
  compiler.emit('guard let token = niSession?.discoveryToken,');
  compiler.emit(
    '      let data = try? NSKeyedArchiver.archivedData(withRootObject: token, requiringSecureCoding: true) else { return }'
  );
  compiler.emit('try? mcSession?.send(data, toPeers: [mcPeer], with: .reliable)');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  compiler.emit('private func startRanging(with token: NIDiscoveryToken) {');
  compiler.indentLevel++;
  compiler.emit('let config = NINearbyPeerConfiguration(peerToken: token)');
  compiler.emit('niSession?.run(config)');
  compiler.emit('print("[UWB] Ranging session started")');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── Cleanup ───────────────────────────────────────────────────
  compiler.emit('func invalidate() {');
  compiler.indentLevel++;
  compiler.emit('niSession?.invalidate()');
  compiler.emit('mcAdvertiser?.stopAdvertisingPeer()');
  compiler.emit('mcBrowser?.stopBrowsingForPeers()');
  compiler.emit('mcSession?.disconnect()');
  compiler.emit('peers.removeAll()');
  compiler.emit('isScanning = false');
  compiler.indentLevel--;
  compiler.emit('}');

  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── NISessionDelegate ─────────────────────────────────────────
  compiler.emit('// MARK: - NISessionDelegate');
  compiler.emit('');
  compiler.emit(`extension ${cls}UWBManager: NISessionDelegate {`);
  compiler.indentLevel++;
  compiler.emit('');
  compiler.emit('func session(_ session: NISession, didUpdate nearbyObjects: [NINearbyObject]) {');
  compiler.indentLevel++;
  compiler.emit('for obj in nearbyObjects {');
  compiler.indentLevel++;
  compiler.emit('guard let peerId = peerTokenMap[obj.discoveryToken] else { continue }');
  compiler.emit(
    'var peer = peers[peerId] ?? UWBPeer(id: peerId, discoveryToken: obj.discoveryToken)'
  );
  compiler.emit('peer.distance = obj.distance');
  compiler.emit('peer.direction = obj.direction');
  compiler.emit('peer.lastSeen = Date()');
  compiler.emit('peers[peerId] = peer');
  compiler.emit('delegate?.didUpdatePeer(peer)');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit(
    'func session(_ session: NISession, didRemove nearbyObjects: [NINearbyObject], reason: NINearbyObject.RemovalReason) {'
  );
  compiler.indentLevel++;
  compiler.emit('for obj in nearbyObjects {');
  compiler.indentLevel++;
  compiler.emit('if let peerId = peerTokenMap[obj.discoveryToken] {');
  compiler.indentLevel++;
  compiler.emit('peers.removeValue(forKey: peerId)');
  compiler.emit('peerTokenMap.removeValue(forKey: obj.discoveryToken)');
  compiler.emit('delegate?.didLosePeer(peerId)');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit('func sessionWasSuspended(_ session: NISession) {');
  compiler.indentLevel++;
  compiler.emit('print("[UWB] Session suspended")');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit('func sessionSuspensionEnded(_ session: NISession) {');
  compiler.indentLevel++;
  compiler.emit('print("[UWB] Session suspension ended — restarting")');
  compiler.emit('guard let token = session.discoveryToken else { return }');
  compiler.emit('let config = NINearbyPeerConfiguration(peerToken: token)');
  compiler.emit('session.run(config)');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit('func session(_ session: NISession, didInvalidateWith error: Error) {');
  compiler.indentLevel++;
  compiler.emit('print("[UWB] Session invalidated: \\(error.localizedDescription)")');
  compiler.emit('setupNISession()');
  compiler.indentLevel--;
  compiler.emit('}');

  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── MCSessionDelegate ─────────────────────────────────────────
  compiler.emit('// MARK: - MCSessionDelegate');
  compiler.emit('');
  compiler.emit(`extension ${cls}UWBManager: MCSessionDelegate {`);
  compiler.indentLevel++;
  compiler.emit('');
  compiler.emit(
    'func session(_ session: MCSession, peer peerID: MCPeerID, didChange state: MCSessionState) {'
  );
  compiler.indentLevel++;
  compiler.emit('switch state {');
  compiler.emit('case .connected:');
  compiler.indentLevel++;
  compiler.emit('print("[UWB] Peer connected: \\(peerID.displayName)")');
  compiler.emit('shareDiscoveryToken(with: peerID)');
  compiler.indentLevel--;
  compiler.emit('case .notConnected:');
  compiler.indentLevel++;
  compiler.emit('print("[UWB] Peer disconnected: \\(peerID.displayName)")');
  compiler.emit('peers.removeValue(forKey: peerID.displayName)');
  compiler.emit('delegate?.didLosePeer(peerID.displayName)');
  compiler.indentLevel--;
  compiler.emit('case .connecting:');
  compiler.indentLevel++;
  compiler.emit('print("[UWB] Peer connecting: \\(peerID.displayName)")');
  compiler.indentLevel--;
  compiler.emit('@unknown default:');
  compiler.indentLevel++;
  compiler.emit('break');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit(
    'func session(_ session: MCSession, didReceive data: Data, fromPeer peerID: MCPeerID) {'
  );
  compiler.indentLevel++;

  // Handle discovery token exchange
  compiler.emit('// Try to decode as NI discovery token');
  compiler.emit(
    'if let token = try? NSKeyedUnarchiver.unarchivedObject(ofClass: NIDiscoveryToken.self, from: data) {'
  );
  compiler.indentLevel++;
  compiler.emit('peerTokenMap[token] = peerID.displayName');
  compiler.emit('let peer = UWBPeer(id: peerID.displayName, discoveryToken: token)');
  compiler.emit('peers[peerID.displayName] = peer');
  compiler.emit('delegate?.didDiscoverPeer(peer)');
  compiler.emit('startRanging(with: token)');
  compiler.emit('return');
  compiler.indentLevel--;
  compiler.emit('}');

  // Handle handoff messages
  if (compiler.compositionHasTrait(composition, 'uwb_handoff')) {
    compiler.emit('');
    compiler.emit('// Try to decode as handoff payload');
    compiler.emit(
      'if let json = try? JSONSerialization.jsonObject(with: data) as? [String: String],'
    );
    compiler.emit('   json["type"] == "uwb_handoff",');
    compiler.emit('   let entityId = json["entityId"],');
    compiler.emit('   let peer = peers[peerID.displayName] {');
    compiler.indentLevel++;
    compiler.emit('delegate?.didReceiveHandoff(entityId: entityId, from: peer)');
    compiler.indentLevel--;
    compiler.emit('}');
  }

  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit(
    'func session(_ session: MCSession, didReceive stream: InputStream, withName streamName: String, fromPeer peerID: MCPeerID) {}'
  );
  compiler.emit(
    'func session(_ session: MCSession, didStartReceivingResourceWithName resourceName: String, fromPeer peerID: MCPeerID, with progress: Progress) {}'
  );
  compiler.emit(
    'func session(_ session: MCSession, didFinishReceivingResourceWithName resourceName: String, fromPeer peerID: MCPeerID, at localURL: URL?, withError error: Error?) {}'
  );

  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── MCNearbyServiceAdvertiserDelegate ──────────────────────────
  compiler.emit('// MARK: - MCNearbyServiceAdvertiserDelegate');
  compiler.emit('');
  compiler.emit(`extension ${cls}UWBManager: MCNearbyServiceAdvertiserDelegate {`);
  compiler.indentLevel++;
  compiler.emit('');
  compiler.emit(
    'func advertiser(_ advertiser: MCNearbyServiceAdvertiser, didReceiveInvitationFromPeer peerID: MCPeerID, withContext context: Data?, invitationHandler: @escaping (Bool, MCSession?) -> Void) {'
  );
  compiler.indentLevel++;
  compiler.emit('invitationHandler(true, mcSession)');
  compiler.indentLevel--;
  compiler.emit('}');

  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── MCNearbyServiceBrowserDelegate ─────────────────────────────
  compiler.emit('// MARK: - MCNearbyServiceBrowserDelegate');
  compiler.emit('');
  compiler.emit(`extension ${cls}UWBManager: MCNearbyServiceBrowserDelegate {`);
  compiler.indentLevel++;
  compiler.emit('');
  compiler.emit(
    'func browser(_ browser: MCNearbyServiceBrowser, foundPeer peerID: MCPeerID, withDiscoveryInfo info: [String: String]?) {'
  );
  compiler.indentLevel++;
  compiler.emit('guard let session = mcSession else { return }');
  compiler.emit('browser.invitePeer(peerID, to: session, withContext: nil, timeout: 10)');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit('func browser(_ browser: MCNearbyServiceBrowser, lostPeer peerID: MCPeerID) {');
  compiler.indentLevel++;
  compiler.emit('print("[UWB] Lost peer: \\(peerID.displayName)")');
  compiler.indentLevel--;
  compiler.emit('}');

  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── SwiftUI Preview ──────────────────────────────────────────
  compiler.emit('// MARK: - SwiftUI Preview');
  compiler.emit('');
  compiler.emit(`struct ${cls}UWBPreview: View {`);
  compiler.indentLevel++;
  compiler.emit(`@StateObject private var uwb = ${cls}UWBManager()`);
  compiler.emit('');
  compiler.emit('var body: some View {');
  compiler.indentLevel++;
  compiler.emit('VStack {');
  compiler.indentLevel++;
  compiler.emit('Text("UWB Peers: \\(uwb.peers.count)")');
  compiler.emit('ForEach(Array(uwb.peers.values)) { peer in');
  compiler.indentLevel++;
  compiler.emit('HStack {');
  compiler.indentLevel++;
  compiler.emit('Text(peer.id)');
  compiler.emit('Spacer()');
  compiler.emit('if let dist = peer.distance {');
  compiler.indentLevel++;
  compiler.emit('Text(String(format: "%.2f m", dist))');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit('#Preview {');
  compiler.indentLevel++;
  compiler.emit(`${cls}UWBPreview()`);
  compiler.indentLevel--;
  compiler.emit('}');

  return compiler.lines.join('\n');
}

export function hasSpatialAudioTraits(composition: HoloComposition): boolean {
  const spatialNames: ReadonlyArray<string> = AIRPODS_SPATIAL_AUDIO_TRAITS;
  for (const obj of composition.objects || []) {
    for (const trait of obj.traits || []) {
      const name = typeof trait === 'string' ? trait : trait.name;
      if (spatialNames.includes(name)) return true;
    }
  }
  return false;
}

export function collectSpatialAudioTraits(composition: HoloComposition): Set<string> {
  const spatialNames: ReadonlyArray<string> = AIRPODS_SPATIAL_AUDIO_TRAITS;
  const found = new Set<string>();
  for (const obj of composition.objects || []) {
    for (const t of obj.traits || []) {
      const name = typeof t === 'string' ? t : t.name;
      if (spatialNames.includes(name)) found.add(name);
    }
  }
  return found;
}

export function generateSpatialAudioFile(
  compiler: IOSCompiler,
  composition: HoloComposition
): string {
  compiler.lines = [];
  compiler.indentLevel = 0;

  const cls = compiler.options.className;
  const traits = collectSpatialAudioTraits(composition);

  compiler.emit('// Auto-generated by HoloScript IOSCompiler — AirPods Spatial Audio');
  compiler.emit(
    `// Source: composition "${escapeStringValue(composition.name as string, 'Swift')}"`
  );
  compiler.emit('// Requires iOS 15+, AirPods Pro/Max with head tracking');
  compiler.emit('// Do not edit manually — regenerate from .holo source');
  compiler.emit('');
  compiler.emit('import Foundation');
  compiler.emit('import AVFoundation');
  compiler.emit('import PHASE');
  compiler.emit('import ARKit');
  compiler.emit('import CoreMotion');
  compiler.emit('import SwiftUI');
  compiler.emit('import Combine');
  compiler.emit('');

  // ─── Audio source model ───────────────────────────────────────────
  compiler.emit('// MARK: - Audio Source Model');
  compiler.emit('');
  compiler.emit('struct HoloAudioSource: Identifiable {');
  compiler.indentLevel++;
  compiler.emit('let id: String');
  compiler.emit('var position: simd_float3');
  compiler.emit('var audioFile: String');
  compiler.emit('var gain: Float = 1.0');
  if (traits.has('audio_falloff')) {
    compiler.emit('var falloffModel: AudioFalloffModel = .inverseDistance');
    compiler.emit('var minDistance: Float = 0.5');
    compiler.emit('var maxDistance: Float = 20.0');
  }
  if (traits.has('audio_directivity')) {
    compiler.emit('var innerConeAngle: Float = 90.0');
    compiler.emit('var outerConeAngle: Float = 180.0');
    compiler.emit('var outerGain: Float = 0.2');
  }
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  if (traits.has('audio_falloff')) {
    compiler.emit('enum AudioFalloffModel {');
    compiler.indentLevel++;
    compiler.emit('case inverseDistance');
    compiler.emit('case linear');
    compiler.emit('case exponential');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── Main manager class ──────────────────────────────────────────
  compiler.emit(`// MARK: - ${cls}SpatialAudioManager`);
  compiler.emit('');
  compiler.emit(`class ${cls}SpatialAudioManager: NSObject, ObservableObject {`);
  compiler.indentLevel++;

  // Properties
  compiler.emit('');
  compiler.emit('private var phaseEngine: PHASEEngine?');
  compiler.emit('private var listener: PHASEListener?');
  compiler.emit('private var sources: [String: PHASESource] = [:]');
  compiler.emit('private var soundEvents: [String: PHASESoundEvent] = [:]');
  compiler.emit('@Published var isActive: Bool = false');
  compiler.emit('@Published var audioSources: [HoloAudioSource] = []');
  if (traits.has('audio_head_track')) {
    compiler.emit('');
    compiler.emit('private let headphoneMotionManager = CMHeadphoneMotionManager()');
    compiler.emit('@Published var headTrackingActive: Bool = false');
  }
  compiler.emit('');
  compiler.emit('private var cancellables = Set<AnyCancellable>()');
  compiler.emit('private var arSession: ARSession?');
  compiler.emit('');

  // ─── Setup ──────────────────────────────────────────────────────
  compiler.emit('// MARK: - Setup');
  compiler.emit('');
  compiler.emit('func setupSpatialAudio(arSession: ARSession) {');
  compiler.indentLevel++;
  compiler.emit('self.arSession = arSession');
  compiler.emit('');
  compiler.emit('let engine = PHASEEngine(updateMode: .automatic)');
  compiler.emit('self.phaseEngine = engine');
  compiler.emit('');
  compiler.emit('// Create listener at camera position');
  compiler.emit('let listener = PHASEListener(engine: engine)');
  compiler.emit('self.listener = listener');
  compiler.emit('try? engine.rootObject.addChild(listener)');
  compiler.emit('');
  compiler.emit('try? engine.start()');
  compiler.emit('isActive = true');
  if (traits.has('audio_head_track')) {
    compiler.emit('');
    compiler.emit('startHeadTracking()');
  }
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── Head tracking (audio_head_track) ────────────────────────────
  if (traits.has('audio_head_track')) {
    compiler.emit('// MARK: - Head Tracking (CMHeadphoneMotionManager)');
    compiler.emit('');
    compiler.emit('func startHeadTracking() {');
    compiler.indentLevel++;
    compiler.emit('guard CMHeadphoneMotionManager.authorizationStatus() == .authorized ||');
    compiler.emit('      CMHeadphoneMotionManager.authorizationStatus() == .notDetermined else {');
    compiler.indentLevel++;
    compiler.emit('print("[SpatialAudio] Head tracking not authorized")');
    compiler.emit('return');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('guard headphoneMotionManager.isDeviceMotionAvailable else {');
    compiler.indentLevel++;
    compiler.emit('print("[SpatialAudio] AirPods head tracking not available")');
    compiler.emit('return');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit(
      'headphoneMotionManager.startDeviceMotionUpdates(to: .main) { [weak self] motion, error in'
    );
    compiler.indentLevel++;
    compiler.emit('guard let self = self, let motion = motion else { return }');
    compiler.emit('self.headTrackingActive = true');
    compiler.emit('self.updateListenerOrientation(from: motion)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('func stopHeadTracking() {');
    compiler.indentLevel++;
    compiler.emit('headphoneMotionManager.stopDeviceMotionUpdates()');
    compiler.emit('headTrackingActive = false');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('private func updateListenerOrientation(from motion: CMDeviceMotion) {');
    compiler.indentLevel++;
    compiler.emit('guard let listener = self.listener else { return }');
    compiler.emit('let attitude = motion.attitude');
    compiler.emit('let rotation = simd_quatf(');
    compiler.indentLevel++;
    compiler.emit('angle: Float(attitude.yaw),');
    compiler.emit('axis: simd_float3(0, 1, 0)');
    compiler.indentLevel--;
    compiler.emit(')');
    compiler.emit('listener.transform = simd_float4x4(rotation)');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── 3D audio sources (audio_source_3d) ─────────────────────────
  if (traits.has('audio_source_3d')) {
    compiler.emit('// MARK: - 3D Audio Sources');
    compiler.emit('');
    compiler.emit('func addAudioSource(_ source: HoloAudioSource) {');
    compiler.indentLevel++;
    compiler.emit('guard let engine = phaseEngine else { return }');
    compiler.emit('');
    compiler.emit('let phaseSource = PHASESource(engine: engine)');
    compiler.emit('var transform = matrix_identity_float4x4');
    compiler.emit('transform.columns.3 = simd_float4(source.position, 1.0)');
    compiler.emit('phaseSource.transform = transform');
    compiler.emit('try? engine.rootObject.addChild(phaseSource)');
    compiler.emit('');
    compiler.emit('sources[source.id] = phaseSource');
    compiler.emit('audioSources.append(source)');
    compiler.emit('');
    compiler.emit(
      'loadAndPlayAudio(sourceId: source.id, audioFile: source.audioFile, gain: source.gain)'
    );
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('func updateSourcePosition(id: String, position: simd_float3) {');
    compiler.indentLevel++;
    compiler.emit('guard let source = sources[id] else { return }');
    compiler.emit('var transform = matrix_identity_float4x4');
    compiler.emit('transform.columns.3 = simd_float4(position, 1.0)');
    compiler.emit('source.transform = transform');
    compiler.emit('if let idx = audioSources.firstIndex(where: { $0.id == id }) {');
    compiler.indentLevel++;
    compiler.emit('audioSources[idx].position = position');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
    compiler.emit('func removeAudioSource(id: String) {');
    compiler.indentLevel++;
    compiler.emit('soundEvents[id]?.stopAndInvalidate()');
    compiler.emit('soundEvents.removeValue(forKey: id)');
    compiler.emit('sources[id]?.parent?.removeChild(sources[id]!)');
    compiler.emit('sources.removeValue(forKey: id)');
    compiler.emit('audioSources.removeAll { $0.id == id }');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── Audio loading & playback pipeline ──────────────────────────
  compiler.emit('// MARK: - Audio Pipeline');
  compiler.emit('');
  compiler.emit(
    'private func loadAndPlayAudio(sourceId: String, audioFile: String, gain: Float) {'
  );
  compiler.indentLevel++;
  compiler.emit('guard let engine = phaseEngine, let source = sources[sourceId] else { return }');
  compiler.emit('');
  compiler.emit(
    'guard let url = Bundle.main.url(forResource: audioFile, withExtension: nil) else {'
  );
  compiler.indentLevel++;
  compiler.emit('print("[SpatialAudio] Audio file not found: \\(audioFile)")');
  compiler.emit('return');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit('do {');
  compiler.indentLevel++;
  compiler.emit('try engine.assetRegistry.registerSoundAsset(');
  compiler.indentLevel++;
  compiler.emit('url: url,');
  compiler.emit('identifier: sourceId,');
  compiler.emit('assetType: .resident,');
  compiler.emit('channelLayout: nil,');
  compiler.emit('normalizationMode: .dynamic');
  compiler.indentLevel--;
  compiler.emit(')');
  compiler.emit('');

  // Build spatial pipeline
  compiler.emit(
    'let channelLayout = AVAudioChannelLayout(layoutTag: kAudioChannelLayoutTag_Mono)!'
  );
  compiler.emit('let samplerNodeDef = PHASESamplerNodeDefinition(');
  compiler.indentLevel++;
  compiler.emit('soundAssetIdentifier: sourceId,');
  compiler.emit('channelLayout: channelLayout');
  compiler.indentLevel--;
  compiler.emit(')');
  compiler.emit('samplerNodeDef.playbackMode = .looping');
  compiler.emit(
    'samplerNodeDef.setCalibrationMode(calibrationMode: .relativeSpl, level: Double(gain * 20))'
  );
  compiler.emit('');

  // Spatial pipeline with distance attenuation
  if (traits.has('audio_falloff')) {
    compiler.emit('// Distance-based falloff (audio_falloff)');
    compiler.emit('let distanceModelParameters = PHASEGeometricSpreadingDistanceModelParameters()');
    compiler.emit(
      'distanceModelParameters.fadeOutParameters = PHASEDistanceModelFadeOutParameters('
    );
    compiler.indentLevel++;
    compiler.emit('cullDistance: 20.0');
    compiler.indentLevel--;
    compiler.emit(')');
    compiler.emit('distanceModelParameters.rolloffFactor = 1.0');
    compiler.emit('');
    compiler.emit(
      'let spatialPipelineDef = PHASESpatialPipeline(flags: [.directPathTransmission])!'
    );
    compiler.emit(
      'spatialPipelineDef.entries[PHASESpatialCategory.directPath]!.sendLevel = Double(gain)'
    );
    compiler.emit('');
    compiler.emit('let spatialMixerDef = PHASESpatialMixerDefinition(');
    compiler.indentLevel++;
    compiler.emit('spatialPipeline: spatialPipelineDef');
    compiler.indentLevel--;
    compiler.emit(')');
    compiler.emit('spatialMixerDef.distanceModelParameters = distanceModelParameters');
  } else {
    compiler.emit(
      'let spatialPipelineDef = PHASESpatialPipeline(flags: [.directPathTransmission])!'
    );
    compiler.emit(
      'spatialPipelineDef.entries[PHASESpatialCategory.directPath]!.sendLevel = Double(gain)'
    );
    compiler.emit('');
    compiler.emit('let spatialMixerDef = PHASESpatialMixerDefinition(');
    compiler.indentLevel++;
    compiler.emit('spatialPipeline: spatialPipelineDef');
    compiler.indentLevel--;
    compiler.emit(')');
  }
  compiler.emit('');

  // Directivity cone
  if (traits.has('audio_directivity')) {
    compiler.emit('// Directional audio cone (audio_directivity)');
    compiler.emit('let directivityModelParameters = PHASECardioidDirectivityModelParameters(');
    compiler.indentLevel++;
    compiler.emit('subbandParameters: [');
    compiler.indentLevel++;
    compiler.emit('PHASECardioidDirectivityModelSubbandParameters()');
    compiler.indentLevel--;
    compiler.emit(']');
    compiler.indentLevel--;
    compiler.emit(')');
    compiler.emit('spatialMixerDef.sourceDirectivityModelParameters = directivityModelParameters');
    compiler.emit('');
  }

  compiler.emit('let soundEventNodeDef = PHASEMixerNodeDefinition(');
  compiler.indentLevel++;
  compiler.emit('spatialMixerDefinition: spatialMixerDef');
  compiler.indentLevel--;
  compiler.emit(')');
  compiler.emit('');
  compiler.emit('let soundEvent = try PHASESoundEvent(');
  compiler.indentLevel++;
  compiler.emit('engine: engine,');
  compiler.emit('rootNode: samplerNodeDef,');
  compiler.emit('mixerNode: soundEventNodeDef,');
  compiler.emit('source: source,');
  compiler.emit('listener: self.listener!');
  compiler.indentLevel--;
  compiler.emit(')');
  compiler.emit('');
  compiler.emit('soundEvents[sourceId] = soundEvent');
  compiler.emit('soundEvent.start()');
  compiler.indentLevel--;
  compiler.emit('} catch {');
  compiler.indentLevel++;
  compiler.emit('print("[SpatialAudio] Error: \\(error)")');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── ARKit world tracking integration ────────────────────────────
  compiler.emit('// MARK: - ARKit Integration');
  compiler.emit('');
  compiler.emit('func updateListenerFromCamera(frame: ARFrame) {');
  compiler.indentLevel++;
  compiler.emit('listener?.transform = frame.camera.transform');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── Reverb matching (audio_reverb_match) ───────────────────────
  if (traits.has('audio_reverb_match')) {
    compiler.emit('// MARK: - Room Reverb Matching (audio_reverb_match)');
    compiler.emit('');
    compiler.emit('func configureReverbFromRoom(preset: PHASEReverbPreset = .mediumRoom) {');
    compiler.indentLevel++;
    compiler.emit('guard let engine = phaseEngine else { return }');
    compiler.emit('let reverb = PHASEMediumParameters()');
    compiler.emit('reverb.preset = preset');
    compiler.emit('engine.defaultReverbPreset = preset');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── Audio occlusion (audio_occlusion) ───────────────────────────
  if (traits.has('audio_occlusion')) {
    compiler.emit('// MARK: - Audio Occlusion (audio_occlusion)');
    compiler.emit('');
    compiler.emit(
      'func updateOcclusionForSource(id: String, occluded: Bool, attenuationDb: Float = -12.0) {'
    );
    compiler.indentLevel++;
    compiler.emit('guard let event = soundEvents[id] else { return }');
    compiler.emit('if occluded {');
    compiler.indentLevel++;
    compiler.emit('// Reduce level when occluded by physical/holographic objects');
    compiler.emit('event.setMixerParameter(');
    compiler.indentLevel++;
    compiler.emit('value: Double(attenuationDb),');
    compiler.emit('parameter: PHASESoundEventNodeDefinition.MixerParameter.leftInput');
    compiler.indentLevel--;
    compiler.emit(')');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.emit('');
  }

  // ─── Cleanup ─────────────────────────────────────────────────────
  compiler.emit('// MARK: - Cleanup');
  compiler.emit('');
  compiler.emit('func teardown() {');
  compiler.indentLevel++;
  compiler.emit('for (_, event) in soundEvents {');
  compiler.indentLevel++;
  compiler.emit('event.stopAndInvalidate()');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('soundEvents.removeAll()');
  compiler.emit('sources.removeAll()');
  if (traits.has('audio_head_track')) {
    compiler.emit('stopHeadTracking()');
  }
  compiler.emit('phaseEngine?.stop()');
  compiler.emit('phaseEngine = nil');
  compiler.emit('isActive = false');
  compiler.indentLevel--;
  compiler.emit('}');

  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');

  // ─── SwiftUI View ────────────────────────────────────────────────
  compiler.emit(`// MARK: - ${cls}SpatialAudioView`);
  compiler.emit('');
  compiler.emit(`struct ${cls}SpatialAudioView: View {`);
  compiler.indentLevel++;
  compiler.emit(`@ObservedObject var manager: ${cls}SpatialAudioManager`);
  compiler.emit('');
  compiler.emit('var body: some View {');
  compiler.indentLevel++;
  compiler.emit('VStack {');
  compiler.indentLevel++;
  compiler.emit('HStack {');
  compiler.indentLevel++;
  compiler.emit('Image(systemName: manager.isActive ? "airpodspro" : "airpods")');
  compiler.emit('Text(manager.isActive ? "Spatial Audio Active" : "Spatial Audio Inactive")');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('.font(.headline)');
  if (traits.has('audio_head_track')) {
    compiler.emit('');
    compiler.emit('if manager.headTrackingActive {');
    compiler.indentLevel++;
    compiler.emit('Label("Head Tracking", systemImage: "person.wave.2")');
    compiler.indentLevel--;
    compiler.emit('}');
  }
  if (traits.has('audio_source_3d')) {
    compiler.emit('');
    compiler.emit('List(manager.audioSources) { source in');
    compiler.indentLevel++;
    compiler.emit('HStack {');
    compiler.indentLevel++;
    compiler.emit('Image(systemName: "speaker.wave.3")');
    compiler.emit('Text(source.id)');
    compiler.emit('Spacer()');
    compiler.emit(
      'Text(String(format: "(%.1f, %.1f, %.1f)", source.position[0], source.position[1], source.position[2]))'
    );
    compiler.indentLevel--;
    compiler.emit('}');
    compiler.indentLevel--;
    compiler.emit('}');
  }
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.indentLevel--;
  compiler.emit('}');
  compiler.emit('');
  compiler.emit(`#Preview {`);
  compiler.indentLevel++;
  compiler.emit(`${cls}SpatialAudioView(manager: ${cls}SpatialAudioManager())`);
  compiler.indentLevel--;
  compiler.emit('}');

  return compiler.lines.join('\n');
}