@holoscript/core 6.0.4 → 7.0.0

package/dist/chunk-YCXFCXDS.js

@@ -1,1868 +0,0 @@
-import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, compileAudioSourceBlock, audioSourceToVisionOS, compilePostProcessingBlock, compileParticleBlock, particlesToVisionOS, compilePhysicsBlock, physicsToVisionOS, compileMaterialBlock, materialToVisionOS } from './chunk-YQK5JNFK.js';
-import { init_CompilerBase, CompilerBase } from './chunk-6XSERL6L.js';
-import { __esm, __export } from './chunk-2CWOLHTE.js';
-import { ANSCapabilityPath } from '@holoscript/platform';
-
-// src/compiler/VisionOSTraitMap.ts
-function getTraitMapping(traitName) {
-  return VISIONOS_TRAIT_MAP[traitName];
-}
-function generateTraitCode(traitName, varName, config) {
-  const mapping = getTraitMapping(traitName);
-  if (!mapping) {
-    return [`// @${traitName} \u2014 no mapping defined: ${JSON.stringify(config)}`];
-  }
-  return mapping.generate(varName, config);
-}
-function getRequiredImports(traits) {
-  const imports = /* @__PURE__ */ new Set();
-  for (const trait of traits) {
-    const mapping = getTraitMapping(trait);
-    if (mapping?.imports) {
-      mapping.imports.forEach((i) => imports.add(i));
-    }
-  }
-  return Array.from(imports);
-}
-function getMinVisionOSVersion(traits) {
-  let maxVersion = "1.0";
-  for (const trait of traits) {
-    const mapping = getTraitMapping(trait);
-    if (mapping?.minVersion) {
-      if (parseFloat(mapping.minVersion) > parseFloat(maxVersion)) {
-        maxVersion = mapping.minVersion;
-      }
-    }
-  }
-  return maxVersion;
-}
-var PHYSICS_TRAIT_MAP, INTERACTION_TRAIT_MAP, AUDIO_TRAIT_MAP, AR_TRAIT_MAP, VISUAL_TRAIT_MAP, ACCESSIBILITY_TRAIT_MAP, UI_TRAIT_MAP, PORTAL_TRAIT_MAP, V43_TRAIT_MAP, VISIONOS_TRAIT_MAP;
-var init_VisionOSTraitMap = __esm({
-  "src/compiler/VisionOSTraitMap.ts"() {
-    PHYSICS_TRAIT_MAP = {
-      collidable: {
-        trait: "collidable",
-        components: ["CollisionComponent"],
-        level: "full",
-        generate: (varName, config) => {
-          const mode = config.mode || "default";
-          return [
-            `${varName}.components.set(CollisionComponent(shapes: [.generateConvex(from: ${varName}Mesh)], mode: .${mode}))`
-          ];
-        }
-      },
-      physics: {
-        trait: "physics",
-        components: ["CollisionComponent", "PhysicsBodyComponent"],
-        level: "full",
-        generate: (varName, config) => {
-          const mass = config.mass ?? 1;
-          const mode = config.kinematic ? "kinematic" : "dynamic";
-          const friction = config.friction ?? 0.5;
-          const restitution = config.restitution ?? 0.3;
-          return [
-            `${varName}.components.set(CollisionComponent(shapes: [.generateConvex(from: ${varName}Mesh)]))`,
-            `var ${varName}Physics = PhysicsBodyComponent(massProperties: .init(mass: ${mass}), mode: .${mode})`,
-            `${varName}Physics.material = .init(friction: ${friction}, restitution: ${restitution})`,
-            `${varName}.components.set(${varName}Physics)`
-          ];
-        }
-      },
-      static: {
-        trait: "static",
-        components: ["CollisionComponent", "PhysicsBodyComponent"],
-        level: "full",
-        generate: (varName) => [
-          `${varName}.components.set(CollisionComponent(shapes: [.generateConvex(from: ${varName}Mesh)]))`,
-          `${varName}.components.set(PhysicsBodyComponent(mode: .static))`
-        ]
-      },
-      kinematic: {
-        trait: "kinematic",
-        components: ["CollisionComponent", "PhysicsBodyComponent"],
-        level: "full",
-        generate: (varName) => [
-          `${varName}.components.set(CollisionComponent(shapes: [.generateConvex(from: ${varName}Mesh)]))`,
-          `${varName}.components.set(PhysicsBodyComponent(mode: .kinematic))`
-        ]
-      },
-      cloth: {
-        trait: "cloth",
-        components: ["CollisionComponent", "PhysicsBodyComponent"],
-        level: "partial",
-        imports: ["RealityKit", "Metal"],
-        generate: (varName, config) => {
-          const stiffness = config.stiffness ?? 0.8;
-          const damping = config.damping ?? 0.02;
-          const iterations = config.iterations ?? 10;
-          const gravity = config.gravity ?? -9.81;
-          const windStrength = config.wind_strength ?? 0;
-          return [
-            `// @cloth \u2014 Position-Based Dynamics cloth simulation`,
-            `var ${varName}ClothSystem = ClothSimulationComponent()`,
-            `${varName}ClothSystem.stiffness = ${stiffness}`,
-            `${varName}ClothSystem.damping = ${damping}`,
-            `${varName}ClothSystem.solverIterations = ${iterations}`,
-            `${varName}ClothSystem.gravity = SIMD3<Float>(0, ${gravity}, 0)`,
-            ...windStrength ? [`${varName}ClothSystem.wind = SIMD3<Float>(${windStrength}, 0, 0)`] : [],
-            `${varName}.components.set(${varName}ClothSystem)`,
-            ``,
-            `// Register cloth ECS system for Metal compute dispatch`,
-            `ClothSimulationSystem.registerSystem()`,
-            `ClothSimulationSystem.configure(device: MTLCreateSystemDefaultDevice()!)`
-          ];
-        }
-      },
-      soft_body: {
-        trait: "soft_body",
-        components: ["CollisionComponent", "PhysicsBodyComponent"],
-        level: "partial",
-        imports: ["RealityKit", "Metal"],
-        generate: (varName, config) => {
-          const compliance = config.compliance ?? 1e-4;
-          const damping = config.damping ?? 0.01;
-          const iterations = config.iterations ?? 8;
-          const volumeStiffness = config.volume_stiffness ?? 1;
-          const pressure = config.pressure ?? 1;
-          return [
-            `// @soft_body \u2014 Extended PBD (XPBD) soft body simulation`,
-            `var ${varName}SoftBody = SoftBodyComponent()`,
-            `${varName}SoftBody.compliance = ${compliance}`,
-            `${varName}SoftBody.damping = ${damping}`,
-            `${varName}SoftBody.solverIterations = ${iterations}`,
-            `${varName}SoftBody.volumeStiffness = ${volumeStiffness}`,
-            `${varName}SoftBody.pressure = ${pressure}`,
-            `${varName}.components.set(${varName}SoftBody)`,
-            `${varName}.components.set(CollisionComponent(shapes: [.generateConvex(from: ${varName}Mesh)]))`,
-            ``,
-            `// Register soft body ECS system`,
-            `SoftBodySimulationSystem.registerSystem()`,
-            `SoftBodySimulationSystem.configure(device: MTLCreateSystemDefaultDevice()!)`
-          ];
-        }
-      },
-      fluid: {
-        trait: "fluid",
-        components: ["CollisionComponent"],
-        level: "partial",
-        imports: ["RealityKit", "Metal"],
-        generate: (varName, config) => {
-          const particleCount = config.particle_count ?? 1e4;
-          const viscosity = config.viscosity ?? 0.01;
-          const restDensity = config.rest_density ?? 1e3;
-          const smoothingRadius = config.smoothing_radius ?? 0.04;
-          const surfaceTension = config.surface_tension ?? 0.0728;
-          return [
-            `// @fluid \u2014 SPH (Smoothed Particle Hydrodynamics) fluid via Metal compute`,
-            `var ${varName}Fluid = FluidSimulationComponent()`,
-            `${varName}Fluid.particleCount = ${particleCount}`,
-            `${varName}Fluid.viscosity = ${viscosity}`,
-            `${varName}Fluid.restDensity = ${restDensity}`,
-            `${varName}Fluid.smoothingRadius = ${smoothingRadius}`,
-            `${varName}Fluid.surfaceTension = ${surfaceTension}`,
-            `${varName}.components.set(${varName}Fluid)`,
-            ``,
-            `// SPH kernel dispatch \u2014 density, pressure, viscosity, integration passes`,
-            `FluidSimulationSystem.registerSystem()`,
-            `FluidSimulationSystem.configure(`,
-            `    device: MTLCreateSystemDefaultDevice()!,`,
-            `    maxParticles: ${particleCount}`,
-            `)`
-          ];
-        }
-      }
-    };
-    INTERACTION_TRAIT_MAP = {
-      grabbable: {
-        trait: "grabbable",
-        components: ["CollisionComponent", "PhysicsBodyComponent", "InputTargetComponent"],
-        level: "full",
-        generate: (varName, config) => {
-          const mass = config.mass ?? 1;
-          const snapToHand = config.snap_to_hand ?? false;
-          const lines = [
-            `${varName}.components.set(CollisionComponent(shapes: [.generateConvex(from: ${varName}Mesh)]))`,
-            `${varName}.components.set(PhysicsBodyComponent(massProperties: .init(mass: ${mass}), mode: .dynamic))`,
-            `${varName}.components.set(InputTargetComponent(allowedInputTypes: .indirect))`
-          ];
-          if (snapToHand) {
-            lines.push(`// snap_to_hand: true \u2014 implement via DragGesture handler`);
-          }
-          return lines;
-        }
-      },
-      hoverable: {
-        trait: "hoverable",
-        components: ["InputTargetComponent", "HoverEffectComponent"],
-        level: "full",
-        minVersion: "1.0",
-        generate: (varName, config) => {
-          const highlightColor = config.highlight_color || "#ffffff";
-          return [
-            `${varName}.components.set(InputTargetComponent())`,
-            `${varName}.components.set(HoverEffectComponent())`,
-            `// Highlight color: ${highlightColor} \u2014 configure via RealityKit material states`
-          ];
-        }
-      },
-      clickable: {
-        trait: "clickable",
-        components: ["InputTargetComponent", "CollisionComponent"],
-        level: "full",
-        generate: (varName) => [
-          `${varName}.components.set(CollisionComponent(shapes: [.generateConvex(from: ${varName}Mesh)]))`,
-          `${varName}.components.set(InputTargetComponent(allowedInputTypes: .indirect))`,
-          `// Use .gesture(TapGesture().targetedToEntity(${varName})) for tap handling`
-        ]
-      },
-      draggable: {
-        trait: "draggable",
-        components: ["InputTargetComponent", "CollisionComponent"],
-        level: "full",
-        generate: (varName, config) => {
-          const axis = config.constrain_axis;
-          const lines = [
-            `${varName}.components.set(CollisionComponent(shapes: [.generateConvex(from: ${varName}Mesh)]))`,
-            `${varName}.components.set(InputTargetComponent(allowedInputTypes: .indirect))`
-          ];
-          if (axis) {
-            lines.push(`// Constrain drag to axis: ${axis}`);
-          }
-          return lines;
-        }
-      },
-      throwable: {
-        trait: "throwable",
-        components: ["CollisionComponent", "PhysicsBodyComponent", "InputTargetComponent"],
-        level: "full",
-        generate: (varName, config) => {
-          const maxVelocity = config.max_velocity ?? 10;
-          return [
-            `${varName}.components.set(CollisionComponent(shapes: [.generateConvex(from: ${varName}Mesh)]))`,
-            `${varName}.components.set(PhysicsBodyComponent(massProperties: .init(mass: 1.0), mode: .dynamic))`,
-            `${varName}.components.set(InputTargetComponent())`,
-            `// Max velocity: ${maxVelocity} \u2014 clamp in gesture handler`
-          ];
-        }
-      },
-      pointable: {
-        trait: "pointable",
-        components: ["InputTargetComponent"],
-        level: "full",
-        generate: (varName) => [
-          `${varName}.components.set(InputTargetComponent(allowedInputTypes: [.indirect, .direct]))`
-        ]
-      },
-      scalable: {
-        trait: "scalable",
-        components: ["InputTargetComponent", "CollisionComponent"],
-        level: "full",
-        generate: (varName, config) => {
-          const minScale = config.min_scale ?? 0.1;
-          const maxScale = config.max_scale ?? 3;
-          return [
-            `${varName}.components.set(InputTargetComponent())`,
-            `${varName}.components.set(CollisionComponent(shapes: [.generateConvex(from: ${varName}Mesh)]))`,
-            `// @scalable \u2014 attach MagnifyGesture in SwiftUI view:`,
-            `// .gesture(MagnifyGesture().targetedToEntity(${varName}).onChanged { value in`,
-            `//     let s = Float(value.magnification) * initialScale`,
-            `//     let clamped = min(max(s, ${minScale}), ${maxScale})`,
-            `//     value.entity.setScale(SIMD3<Float>(repeating: clamped), relativeTo: value.entity.parent)`,
-            `// })`
-          ];
-        }
-      },
-      rotatable: {
-        trait: "rotatable",
-        components: ["InputTargetComponent", "CollisionComponent"],
-        level: "full",
-        generate: (varName, config) => {
-          const axis = String(config.axis || "y");
-          const axisMap = { x: ".x", y: ".y", z: ".z" };
-          return [
-            `${varName}.components.set(InputTargetComponent())`,
-            `${varName}.components.set(CollisionComponent(shapes: [.generateConvex(from: ${varName}Mesh)]))`,
-            `// @rotatable \u2014 attach RotateGesture3D in SwiftUI view:`,
-            `// .gesture(RotateGesture3D(constrainedToAxis: ${axisMap[axis] || ".y"}).targetedToEntity(${varName}).onChanged { value in`,
-            `//     let rotTransform = Transform(AffineTransform3D(rotation: value.rotation))`,
-            `//     value.entity.transform.rotation = sourceRotation * rotTransform.rotation`,
-            `// })`
-          ];
-        }
-      }
-    };
-    AUDIO_TRAIT_MAP = {
-      audio: {
-        trait: "audio",
-        components: ["AmbientAudioComponent"],
-        level: "full",
-        imports: ["AVFoundation"],
-        generate: (varName, config) => {
-          const src = config.src || config.source || "";
-          const loop = config.loop ?? false;
-          return [
-            `if let audioResource = try? await AudioFileResource(named: "${src}") {`,
-            `    let controller = ${varName}.prepareAudio(audioResource)`,
-            loop ? `    controller.gain = .decibels(-6)` : "",
-            `    controller.play()`,
-            `}`
-          ].filter(Boolean);
-        }
-      },
-      spatial_audio: {
-        trait: "spatial_audio",
-        components: ["SpatialAudioComponent"],
-        level: "full",
-        generate: (varName, config) => {
-          const refDistance = config.refDistance ?? 1;
-          const rolloff = config.rolloff ?? 1;
-          return [
-            `var ${varName}SpatialAudio = SpatialAudioComponent()`,
-            `${varName}SpatialAudio.gain = .decibels(0)`,
-            `${varName}SpatialAudio.directivity = .beam(focus: 0.5)`,
-            `${varName}.components.set(${varName}SpatialAudio)`,
-            `// Reference distance: ${refDistance}, rolloff: ${rolloff}`
-          ];
-        }
-      },
-      ambisonics: {
-        trait: "ambisonics",
-        components: ["AmbientAudioComponent"],
-        level: "full",
-        generate: (varName, config) => {
-          const src = config.src || config.source || "ambisonic_soundscape";
-          const loop = config.loop ?? true;
-          return [
-            `// @ambisonics \u2014 AmbientAudioComponent renders with 3DOF (head + source rotation)`,
-            `${varName}.components.set(AmbientAudioComponent())`,
-            `if let resource = try? await AudioFileResource(named: "${src}", configuration: .init(shouldLoop: ${loop}, loadingStrategy: .stream)) {`,
-            `    ${varName}.playAudio(resource)`,
-            `}`
-          ];
-        }
-      },
-      reverb_zone: {
-        trait: "reverb_zone",
-        components: ["ReverbComponent"],
-        level: "full",
-        minVersion: "2.0",
-        generate: (varName, config) => {
-          const preset = String(config.preset || "largeRoom");
-          const presetMap = {
-            smallRoom: ".smallRoom",
-            mediumRoom: ".mediumRoom",
-            largeRoom: ".largeRoom",
-            veryLargeRoom: ".veryLargeRoom",
-            automatic: ".automatic"
-          };
-          return [
-            `// @reverb_zone \u2014 one active ReverbComponent per entity hierarchy`,
-            `${varName}.components.set(ReverbComponent(reverb: .preset(${presetMap[preset] || ".largeRoom"})))`
-          ];
-        }
-      },
-      audio_occlusion: {
-        trait: "audio_occlusion",
-        components: ["SpatialAudioComponent", "CollisionComponent"],
-        level: "full",
-        generate: (varName, config) => {
-          const focus = config.focus ?? 0.25;
-          return [
-            `// @audio_occlusion \u2014 RealityKit ray-traces occlusion automatically`,
-            `// Entities with CollisionComponent block audio from SpatialAudioComponent sources`,
-            `var ${varName}SpatialAudio = SpatialAudioComponent()`,
-            `${varName}SpatialAudio.directivity = .beam(focus: ${focus})`,
-            `${varName}SpatialAudio.distanceAttenuation = .rolloff(factor: 1.0)`,
-            `${varName}.components.set(${varName}SpatialAudio)`,
-            `${varName}.components.set(CollisionComponent(shapes: [.generateConvex(from: ${varName}Mesh)]))`
-          ];
-        }
-      },
-      head_tracked_audio: {
-        trait: "head_tracked_audio",
-        components: ["SpatialAudioComponent"],
-        level: "full",
-        generate: (varName) => [
-          `var ${varName}Audio = SpatialAudioComponent()`,
-          `${varName}Audio.isHeadTracked = true`,
-          `${varName}.components.set(${varName}Audio)`
-        ]
-      }
-    };
-    AR_TRAIT_MAP = {
-      anchor: {
-        trait: "anchor",
-        components: ["AnchoringComponent"],
-        level: "full",
-        generate: (varName, config) => {
-          const target = String(config.anchor_type || "plane");
-          const targetMap = {
-            plane: ".plane(.horizontal, classification: .any, minimumBounds: SIMD2<Float>(0.1, 0.1))",
-            vertical: ".plane(.vertical, classification: .any, minimumBounds: SIMD2<Float>(0.1, 0.1))",
-            image: '.image(group: "ImageTargets", name: "target")',
-            face: ".face",
-            hand: ".hand(.left, location: .palm)",
-            world: ".world(transform: .identity)"
-          };
-          return [
-            `${varName}.components.set(AnchoringComponent(${targetMap[target] || ".world(transform: .identity)"}))`
-          ];
-        }
-      },
-      plane_detection: {
-        trait: "plane_detection",
-        components: [],
-        level: "full",
-        imports: ["ARKit"],
-        generate: (varName, config) => {
-          const types = config.types || ["horizontal", "vertical"];
-          const alignments = types.map((t) => `.${t}`).join(", ");
-          return [
-            `// @plane_detection \u2014 ARKit PlaneDetectionProvider (requires Full Space)`,
-            `// Info.plist: NSWorldSensingUsageDescription`,
-            `let ${varName}PlaneProvider = PlaneDetectionProvider(alignments: [${alignments}])`,
-            `try await arkitSession.run([${varName}PlaneProvider])`,
-            `Task {`,
-            `    for await update in ${varName}PlaneProvider.anchorUpdates {`,
-            `        let anchor = update.anchor`,
-            `        let extent = anchor.geometry.extent`,
-            `        switch update.event {`,
-            `        case .added, .updated:`,
-            `            let plane = ModelEntity(mesh: .generatePlane(width: extent.width, height: extent.height))`,
-            `            plane.transform = Transform(matrix: anchor.originFromAnchorTransform * extent.anchorFromExtentTransform)`,
-            `        case .removed: break`,
-            `        }`,
-            `    }`,
-            `}`
-          ];
-        }
-      },
-      mesh_detection: {
-        trait: "mesh_detection",
-        components: [],
-        level: "full",
-        imports: ["ARKit"],
-        generate: (varName) => [
-          `// @mesh_detection \u2014 ARKit SceneReconstructionProvider (requires Full Space)`,
-          `// Info.plist: NSWorldSensingUsageDescription`,
-          `let ${varName}SceneProvider = SceneReconstructionProvider()`,
-          `try await arkitSession.run([${varName}SceneProvider])`,
-          `Task {`,
-          `    for await update in ${varName}SceneProvider.anchorUpdates {`,
-          `        let anchor = update.anchor`,
-          `        switch update.event {`,
-          `        case .added, .updated:`,
-          `            let shape = try await ShapeResource.generateStaticMesh(from: anchor)`,
-          `            let meshEntity = ModelEntity()`,
-          `            meshEntity.model = .init(mesh: .generateSphere(radius: 0), materials: [OcclusionMaterial()])`,
-          `            meshEntity.collision = CollisionComponent(shapes: [shape], isStatic: true)`,
-          `            meshEntity.physicsBody = PhysicsBodyComponent(mode: .static)`,
-          `            meshEntity.transform = Transform(matrix: anchor.originFromAnchorTransform)`,
-          `        case .removed: break`,
-          `        }`,
-          `    }`,
-          `}`
-        ]
-      },
-      hand_tracking: {
-        trait: "hand_tracking",
-        components: [],
-        level: "full",
-        imports: ["ARKit"],
-        generate: (varName) => [
-          `// @hand_tracking \u2014 ARKit HandTrackingProvider (requires Full Space)`,
-          `// Info.plist: NSHandsTrackingUsageDescription`,
-          `let ${varName}HandProvider = HandTrackingProvider()`,
-          `try await arkitSession.run([${varName}HandProvider])`,
-          `Task {`,
-          `    for await update in ${varName}HandProvider.anchorUpdates {`,
-          `        let anchor = update.anchor`,
-          `        guard anchor.isTracked, let skeleton = anchor.handSkeleton else { continue }`,
-          `        let tips: [HandSkeleton.JointName] = [.thumbTip, .indexFingerTip, .middleFingerTip, .ringFingerTip, .littleFingerTip]`,
-          `        for joint in tips {`,
-          `            let j = skeleton.joint(joint)`,
-          `            guard j.isTracked else { continue }`,
-          `            let worldPos = anchor.originFromAnchorTransform * j.anchorFromJointTransform`,
-          `            // chirality: anchor.chirality (.left / .right)`,
-          `        }`,
-          `    }`,
-          `}`
-        ]
-      },
-      eye_tracking: {
-        trait: "eye_tracking",
-        components: ["HoverEffectComponent", "InputTargetComponent", "CollisionComponent"],
-        level: "full",
-        generate: (varName) => [
-          `// @eye_tracking \u2014 raw gaze data is system-private on visionOS`,
-          `// Use HoverEffectComponent for gaze-driven visual feedback`,
-          `${varName}.components.set(InputTargetComponent())`,
-          `${varName}.components.set(CollisionComponent(shapes: [.generateConvex(from: ${varName}Mesh)]))`,
-          `${varName}.components.set(HoverEffectComponent())`
-        ]
-      },
-      occlusion: {
-        trait: "occlusion",
-        components: [],
-        level: "full",
-        generate: (_varName) => [
-          `// @occlusion \u2014 RealityKit handles automatically`,
-          `// Ensure object has ModelComponent with proper materials`
-        ]
-      },
-      light_estimation: {
-        trait: "light_estimation",
-        components: ["ImageBasedLightComponent"],
-        level: "full",
-        generate: (varName) => [
-          `// @light_estimation \u2014 ARKit provides environmental lighting automatically`,
-          `${varName}.components.set(ImageBasedLightReceiverComponent(imageBasedLight: root))`
-        ]
-      },
-      world_anchor: {
-        trait: "world_anchor",
-        components: ["AnchoringComponent"],
-        level: "full",
-        generate: (varName, config) => {
-          const persistent = config.persistent ?? true;
-          return [
-            `${varName}.components.set(AnchoringComponent(.world(transform: .identity)))`,
-            persistent ? `// Persist via WorldTrackingProvider.addAnchor()` : `// Non-persistent world anchor`
-          ];
-        }
-      },
-      geospatial: {
-        trait: "geospatial",
-        components: [],
-        level: "unsupported",
-        generate: (_, config) => [
-          `// @geospatial \u2014 NOT available on visionOS (no GPS module on Apple Vision Pro)`,
-          `// Latitude: ${config.latitude}, Longitude: ${config.longitude}`,
-          `// Workaround: use WorldAnchor with GPS coordinates from a paired iPhone`
-        ]
-      }
-    };
-    VISUAL_TRAIT_MAP = {
-      visible: {
-        trait: "visible",
-        components: [],
-        level: "full",
-        generate: (varName, config) => {
-          const visible = config.visible ?? true;
-          return [visible ? "" : `${varName}.isEnabled = false`].filter(Boolean);
-        }
-      },
-      invisible: {
-        trait: "invisible",
-        components: [],
-        level: "full",
-        generate: (varName) => [`${varName}.isEnabled = false`]
-      },
-      billboard: {
-        trait: "billboard",
-        components: ["BillboardComponent"],
-        level: "full",
-        generate: (varName) => [
-          `// @billboard \u2014 built-in RealityKit BillboardComponent (privacy-preserving)`,
-          `${varName}.components.set(BillboardComponent())`
-        ]
-      },
-      particle_emitter: {
-        trait: "particle_emitter",
-        components: ["ParticleEmitterComponent"],
-        level: "full",
-        minVersion: "2.0",
-        generate: (varName, config) => {
-          const rate = config.rate ?? 100;
-          const lifetime = config.lifetime ?? 1;
-          return [
-            `var ${varName}Particles = ParticleEmitterComponent()`,
-            `${varName}Particles.emitterShape = .sphere`,
-            `${varName}Particles.birthRate = ${rate}`,
-            `${varName}Particles.lifeSpan = ${lifetime}`,
-            `${varName}.components.set(${varName}Particles)`
-          ];
-        }
-      },
-      animated: {
-        trait: "animated",
-        components: [],
-        level: "full",
-        generate: (varName, config) => {
-          const clip = config.clip || "";
-          const loop = config.loop ?? true;
-          const speed = config.speed ?? 1;
-          const transition = config.transition ?? 0.25;
-          const lines = [`// @animated \u2014 play animation from USDZ or programmatic AnimationResource`];
-          if (clip) {
-            lines.push(
-              `if let animation = ${varName}.availableAnimations.first(where: { $0.name == "${clip}" }) {`,
-              `    let controller = ${varName}.playAnimation(animation${loop ? ".repeat(duration: .infinity)" : ""}, transitionDuration: ${transition})`,
-              `    controller.speed = ${speed}`,
-              `}`
-            );
-          } else {
-            lines.push(
-              `for animation in ${varName}.availableAnimations {`,
-              `    let controller = ${varName}.playAnimation(animation${loop ? ".repeat(duration: .infinity)" : ""}, transitionDuration: ${transition})`,
-              `    controller.speed = ${speed}`,
-              `}`
-            );
-          }
-          return lines;
-        }
-      },
-      lod: {
-        trait: "lod",
-        components: [],
-        level: "partial",
-        generate: (varName, config) => {
-          const distances = config.distances || [5, 15];
-          const d = distances;
-          return [
-            `// @lod \u2014 no built-in LOD in RealityKit; use custom ECS System`,
-            `// Requires WorldTrackingProvider for camera position (Full Space only)`,
-            `struct ${varName}LODComponent: Component, Codable {`,
-            `    var thresholds: [Float] = [${d[0] ?? 5}, ${d[1] ?? 15}]`,
-            `    var currentLevel: Int = 0`,
-            `}`,
-            `// Register: ${varName}LODComponent.registerComponent()`,
-            `// In LODSystem.update(): query camera distance, swap ModelComponent.mesh`,
-            `${varName}.components.set(${varName}LODComponent())`
-          ];
-        }
-      },
-      shadow_caster: {
-        trait: "shadow_caster",
-        components: ["GroundingShadowComponent"],
-        level: "full",
-        generate: (varName) => [
-          `${varName}.components.set(GroundingShadowComponent(castsShadow: true))`
-        ]
-      },
-      shadow_receiver: {
-        trait: "shadow_receiver",
-        components: ["GroundingShadowComponent"],
-        level: "full",
-        generate: (varName) => [
-          `${varName}.components.set(GroundingShadowComponent(castsShadow: false))`
-        ]
-      }
-    };
-    ACCESSIBILITY_TRAIT_MAP = {
-      accessible: {
-        trait: "accessible",
-        components: ["AccessibilityComponent"],
-        level: "full",
-        generate: (varName, config) => {
-          const label = config.label || "";
-          const hint = config.hint || "";
-          const isButton = config.isButton ?? false;
-          const lines = [`var ${varName}Accessibility = AccessibilityComponent()`];
-          if (label) lines.push(`${varName}Accessibility.label = "${label}"`);
-          if (hint) lines.push(`${varName}Accessibility.hint = "${hint}"`);
-          if (isButton) lines.push(`${varName}Accessibility.isButton = true`);
-          lines.push(`${varName}.components.set(${varName}Accessibility)`);
-          return lines;
-        }
-      },
-      alt_text: {
-        trait: "alt_text",
-        components: ["AccessibilityComponent"],
-        level: "full",
-        generate: (varName, config) => {
-          const text = config.text || "";
-          return [
-            `var ${varName}Accessibility = AccessibilityComponent()`,
-            `${varName}Accessibility.label = "${text}"`,
-            `${varName}.components.set(${varName}Accessibility)`
-          ];
-        }
-      },
-      high_contrast: {
-        trait: "high_contrast",
-        components: [],
-        level: "full",
-        generate: (varName) => [
-          `// @high_contrast \u2014 SwiftUI: @Environment(\\.colorSchemeContrast) var contrast`,
-          `// UIKit: UIAccessibility.isDarkerSystemColorsEnabled`,
-          `if UIAccessibility.isDarkerSystemColorsEnabled {`,
-          `    // Apply high-contrast materials (WCAG 7:1 ratio)`,
-          `    var ${varName}Material = SimpleMaterial()`,
-          `    ${varName}Material.color = .init(tint: .black)`,
-          `    ${varName}.model?.materials = [${varName}Material]`,
-          `}`
-        ]
-      },
-      motion_reduced: {
-        trait: "motion_reduced",
-        components: [],
-        level: "full",
-        generate: (varName) => [
-          `// @motion_reduced \u2014 SwiftUI: @Environment(\\.accessibilityReduceMotion) var reduceMotion`,
-          `if UIAccessibility.isReduceMotionEnabled {`,
-          `    // Skip animations, use instant transitions`,
-          `    ${varName}.stopAllAnimations()`,
-          `} else {`,
-          `    for animation in ${varName}.availableAnimations {`,
-          `        ${varName}.playAnimation(animation.repeat(duration: .infinity))`,
-          `    }`,
-          `}`
-        ]
-      }
-    };
-    UI_TRAIT_MAP = {
-      ui_floating: {
-        trait: "ui_floating",
-        components: [],
-        level: "full",
-        generate: (varName, config) => {
-          const distance = config.distance ?? 0.3;
-          return [
-            `// @ui_floating \u2014 ViewAttachmentComponent (visionOS 2.0+)`,
-            `let ${varName}Panel = Entity()`,
-            `${varName}Panel.components.set(ViewAttachmentComponent(rootView:`,
-            `    VStack {`,
-            `        Text("${config.title || "Info"}")`,
-            `            .font(.headline)`,
-            `    }`,
-            `    .padding()`,
-            `    .glassBackgroundEffect()`,
-            `))`,
-            `${varName}Panel.position = SIMD3<Float>(0, Float(${distance}), 0)`,
-            `${varName}.addChild(${varName}Panel)`
-          ];
-        }
-      },
-      ui_anchored: {
-        trait: "ui_anchored",
-        components: ["AnchoringComponent"],
-        level: "full",
-        generate: (varName, config) => {
-          const to = String(config.to || "world");
-          const anchorMap = {
-            world: ".world(transform: .identity)",
-            head: ".head",
-            left_hand: ".hand(.left, location: .palm)",
-            right_hand: ".hand(.right, location: .palm)"
-          };
-          return [
-            `${varName}.components.set(AnchoringComponent(${anchorMap[to] || ".world(transform: .identity)"}))`
-          ];
-        }
-      },
-      ui_hand_menu: {
-        trait: "ui_hand_menu",
-        components: ["AnchoringComponent"],
-        level: "full",
-        generate: (varName, config) => {
-          const hand = config.hand || "left";
-          const trigger = config.trigger || "palm_up";
-          return [
-            `${varName}.components.set(AnchoringComponent(.hand(.${hand}, location: .palm)))`,
-            `// Trigger: ${trigger} \u2014 implement gesture detection`
-          ];
-        }
-      },
-      ui_billboard: {
-        trait: "ui_billboard",
-        components: ["BillboardComponent"],
-        level: "full",
-        generate: (varName) => [
-          `// @ui_billboard \u2014 BillboardComponent keeps UI facing the user`,
-          `${varName}.components.set(BillboardComponent())`
-        ]
-      },
-      ui_docked: {
-        trait: "ui_docked",
-        components: [],
-        level: "full",
-        generate: (varName, config) => {
-          const position = String(config.position || "bottom");
-          const posMap = {
-            bottom: ".scene(.bottom)",
-            top: ".scene(.top)",
-            leading: ".scene(.leading)",
-            trailing: ".scene(.trailing)"
-          };
-          return [
-            `// @ui_docked \u2014 SwiftUI .ornament() modifier on window content`,
-            `// .ornament(visibility: .visible, attachmentAnchor: ${posMap[position] || ".scene(.bottom)"}, contentAlignment: .${position}) {`,
-            `//     HStack {`,
-            `//         // ${varName} docked controls`,
-            `//     }`,
-            `//     .padding()`,
-            `//     .glassBackgroundEffect()`,
-            `// }`
-          ];
-        }
-      }
-    };
-    PORTAL_TRAIT_MAP = {
-      portal: {
-        trait: "portal",
-        components: ["PortalComponent", "WorldComponent"],
-        level: "full",
-        minVersion: "1.0",
-        generate: (varName, config) => {
-          config.target_world || "portalWorld";
-          return [
-            `let ${varName}World = Entity()`,
-            `${varName}World.components.set(WorldComponent())`,
-            `${varName}.components.set(PortalComponent(target: ${varName}World))`,
-            `// Add content to ${varName}World for portal interior`
-          ];
-        }
-      },
-      volume: {
-        trait: "volume",
-        components: [],
-        level: "full",
-        generate: (varName, config) => {
-          const size = config.size || [0.6, 0.4, 0.4];
-          const s = size;
-          return [
-            `// @volume \u2014 Scene-level: add WindowGroup to your App struct`,
-            `// WindowGroup(id: "${varName}Volume") {`,
-            `//     ${varName}VolumetricView()`,
-            `// }`,
-            `// .windowStyle(.volumetric)`,
-            `// .defaultSize(width: ${s[0]}, height: ${s[1]}, depth: ${s[2]}, in: .meters)`,
-            `//`,
-            `// Open with: openWindow(id: "${varName}Volume")`
-          ];
-        }
-      },
-      immersive: {
-        trait: "immersive",
-        components: [],
-        level: "full",
-        generate: (varName, config) => {
-          const style = String(config.style || "mixed");
-          const styleMap = {
-            mixed: ".mixed",
-            progressive: ".progressive",
-            full: ".full"
-          };
-          return [
-            `// @immersive \u2014 Scene-level: add ImmersiveSpace to your App struct`,
-            `// ImmersiveSpace(id: "${varName}Space") {`,
-            `//     ${varName}ImmersiveView()`,
-            `// }`,
-            `// .immersionStyle(selection: $immersionStyle, in: ${styleMap[style] || ".mixed"})`,
-            `//`,
-            `// Open:    let result = await openImmersiveSpace(id: "${varName}Space")`,
-            `// Dismiss: await dismissImmersiveSpace()`
-          ];
-        }
-      }
-    };
-    V43_TRAIT_MAP = {
-      spatial_persona: {
-        trait: "spatial_persona",
-        components: [],
-        level: "partial",
-        minVersion: "2.0",
-        imports: ["GroupActivities"],
-        generate: (varName, config) => {
-          const style = String(config.style || "realistic");
-          return [
-            `// @spatial_persona \u2014 visionOS 2.0 Spatial Persona (GroupActivities)`,
-            `// Requires SharePlay session; persona renders at ${varName} position`,
-            `// PersonaStyle: ${style}`,
-            `// TODO: configure SystemCoordinator and spatial template`
-          ];
-        }
-      },
-      shareplay: {
-        trait: "shareplay",
-        components: [],
-        level: "partial",
-        minVersion: "1.0",
-        imports: ["GroupActivities"],
-        generate: (varName, config) => {
-          const activity = String(config.activity_type || "custom");
-          return [
-            `// @shareplay \u2014 SharePlay GroupActivity`,
-            `// Activity type: ${activity}`,
-            `// TODO: conform to GroupActivity protocol and activate session`,
-            `// struct HoloActivity: GroupActivity { var metadata = GroupActivityMetadata() }`
-          ];
-        }
-      },
-      object_tracking: {
-        trait: "object_tracking",
-        components: ["AnchoringComponent"],
-        level: "partial",
-        minVersion: "2.0",
-        imports: ["ARKit"],
-        generate: (varName, config) => {
-          const referenceObject = String(config.reference_object || "MyObject");
-          return [
-            `// @object_tracking \u2014 ARKit ObjectTrackingProvider (visionOS 2.0)`,
-            `// Info.plist: NSWorldSensingUsageDescription`,
-            `let ${varName}ObjProvider = ObjectTrackingProvider(referenceObjects: [])`,
-            `// TODO: load ReferenceObject from .referenceobject bundle for ${referenceObject}`,
-            `try await arkitSession.run([${varName}ObjProvider])`
-          ];
-        }
-      },
-      scene_reconstruction: {
-        trait: "scene_reconstruction",
-        components: [],
-        level: "partial",
-        minVersion: "1.0",
-        imports: ["ARKit"],
-        generate: (varName, config) => {
-          const mode = String(config.mode || "mesh");
-          return [
-            `// @scene_reconstruction \u2014 SceneReconstructionProvider (mode: ${mode})`,
-            `// Info.plist: NSWorldSensingUsageDescription`,
-            `let ${varName}SceneProvider = SceneReconstructionProvider(modes: [.${mode}])`,
-            `try await arkitSession.run([${varName}SceneProvider])`,
-            `Task {`,
-            `    for await update in ${varName}SceneProvider.anchorUpdates {`,
-            `        // handle MeshAnchor updates`,
-            `    }`,
-            `}`
-          ];
-        }
-      },
-      volumetric_window: {
-        trait: "volumetric_window",
-        components: ["ModelComponent"],
-        level: "full",
-        minVersion: "1.0",
-        generate: (varName, config) => {
-          const width = Number(config.width || 0.5);
-          const height = Number(config.height || 0.5);
-          const depth = Number(config.depth || 0.5);
-          return [
-            `// @volumetric_window \u2014 WindowGroup with volumetric style`,
-            `// In App.swift: WindowGroup { ContentView() }.windowStyle(.volumetric)`,
-            `// .defaultSize(width: ${width}, height: ${height}, depth: ${depth}, in: .meters)`,
-            `${varName}.components.set(ModelComponent(mesh: .generateBox(size: [${width}, ${height}, ${depth}]), materials: []))`
-          ];
-        }
-      },
-      spatial_navigation: {
-        trait: "spatial_navigation",
-        components: [],
-        level: "comment",
-        minVersion: "1.0",
-        generate: (varName, _config) => [
-          `// @spatial_navigation \u2014 spatial navigation for ${varName}`,
-          `// TODO: implement NavigationSplitView or custom spatial nav`
-        ]
-      },
-      eye_tracked: {
-        trait: "eye_tracked",
-        components: ["InputTargetComponent", "HoverEffectComponent"],
-        level: "full",
-        minVersion: "1.0",
-        generate: (varName, _config) => [
-          `${varName}.components.set(InputTargetComponent())`,
-          `${varName}.components.set(HoverEffectComponent())`,
-          `// Eye tracking: entity responds to gaze via SwiftUI .onHover or RealityView gesture`
-        ]
-      },
-      realitykit_mesh: {
-        trait: "realitykit_mesh",
-        components: ["ModelComponent"],
-        level: "full",
-        minVersion: "1.0",
-        generate: (varName, config) => {
-          const shape = String(config.shape || "box");
-          const shapeMap = {
-            box: ".generateBox(size: [0.1, 0.1, 0.1])",
-            sphere: ".generateSphere(radius: 0.05)",
-            cylinder: ".generateCylinder(height: 0.1, radius: 0.05)",
-            plane: ".generatePlane(width: 0.5, height: 0.5)"
-          };
-          return [
-            `${varName}.components.set(ModelComponent(mesh: .${shapeMap[shape] || shapeMap["box"]}, materials: [SimpleMaterial()]))`
-          ];
-        }
-      },
-      eye_hand_fusion: {
-        trait: "eye_hand_fusion",
-        components: ["InputTargetComponent"],
-        level: "partial",
-        minVersion: "2.0",
-        imports: ["ARKit"],
-        generate: (varName, _config) => [
-          `// @eye_hand_fusion \u2014 combined eye + hand tracking (visionOS 2.0)`,
-          `let ${varName}HandProvider = HandTrackingProvider()`,
-          `try await arkitSession.run([${varName}HandProvider])`,
-          `// TODO: correlate HandAnchor joint positions with gaze raycast hit`
-        ]
-      },
-      // AI Generation traits — comment-level stubs (GPU compute not native to RealityKit)
-      controlnet: {
-        trait: "controlnet",
-        components: [],
-        level: "comment",
-        generate: (_varName, config) => [
-          `// @controlnet \u2014 ControlNet image generation (model: ${String(config.model || "canny")})`,
-          `// TODO: route to CoreML / remote inference endpoint`
-        ]
-      },
-      ai_texture_gen: {
-        trait: "ai_texture_gen",
-        components: ["ModelComponent"],
-        level: "comment",
-        generate: (varName, config) => [
-          `// @ai_texture_gen \u2014 AI texture generation (style: ${String(config.style || "photorealistic")})`,
-          `// TODO: generate texture via CoreML or API, then assign to ${varName} ModelComponent`
-        ]
-      },
-      diffusion_realtime: {
-        trait: "diffusion_realtime",
-        components: [],
-        level: "comment",
-        generate: (_varName, config) => [
-          `// @diffusion_realtime \u2014 real-time diffusion rendering (backend: ${String(config.backend || "metal")})`,
-          `// TODO: integrate Metal Performance Shaders or CoreML pipeline`
-        ]
-      },
-      ai_upscaling: {
-        trait: "ai_upscaling",
-        components: [],
-        level: "comment",
-        generate: (_varName, config) => [
-          `// @ai_upscaling \u2014 AI upscaling (factor: ${String(config.factor || 2)}x)`,
-          `// TODO: apply CoreML super-resolution model to texture`
-        ]
-      },
-      ai_inpainting: {
-        trait: "ai_inpainting",
-        components: [],
-        level: "comment",
-        generate: (_varName, _config) => [
-          `// @ai_inpainting \u2014 AI inpainting`,
-          `// TODO: apply mask-based inpainting via CoreML`
-        ]
-      },
-      neural_link: {
-        trait: "neural_link",
-        components: [],
-        level: "comment",
-        generate: (_varName, config) => [
-          `// @neural_link \u2014 neural interface link (interface: ${String(config.interface_type || "bci")})`,
-          `// TODO: implement BCI signal processing pipeline`
-        ]
-      },
-      neural_forge: {
-        trait: "neural_forge",
-        components: [],
-        level: "comment",
-        generate: (_varName, _config) => [
-          `// @neural_forge \u2014 neural network model forge`,
-          `// TODO: integrate on-device CoreML model training`
-        ]
-      },
-      embedding_search: {
-        trait: "embedding_search",
-        components: [],
-        level: "comment",
-        generate: (_varName, config) => [
-          `// @embedding_search \u2014 vector embedding search (dimensions: ${String(config.dimensions || 1536)})`,
-          `// TODO: implement CoreData or CloudKit vector index`
-        ]
-      },
-      ai_npc_brain: {
-        trait: "ai_npc_brain",
-        components: [],
-        level: "comment",
-        generate: (_varName, config) => [
-          `// @ai_npc_brain \u2014 AI NPC brain (model: ${String(config.model || "llm")})`,
-          `// TODO: integrate local LLM or API-based NPC reasoning`
-        ]
-      },
-      vector_db: {
-        trait: "vector_db",
-        components: [],
-        level: "comment",
-        generate: (_varName, _config) => [
-          `// @vector_db \u2014 vector database`,
-          `// TODO: integrate local or remote vector store (e.g. FAISS, Pinecone)`
-        ]
-      },
-      vision: {
-        trait: "vision",
-        components: [],
-        level: "comment",
-        imports: ["Vision"],
-        generate: (_varName, config) => [
-          `// @vision \u2014 Vision framework (task: ${String(config.task || "classification")})`,
-          `// TODO: configure VNRequest pipeline for ${String(config.task || "classification")}`
-        ]
-      },
-      spatial_awareness: {
-        trait: "spatial_awareness",
-        components: [],
-        level: "comment",
-        minVersion: "1.0",
-        imports: ["ARKit"],
-        generate: (_varName, _config) => [
-          `// @spatial_awareness \u2014 spatial scene understanding`,
-          `// TODO: combine PlaneDetectionProvider + SceneReconstructionProvider`
-        ]
-      },
-      neural_animation: {
-        trait: "neural_animation",
-        components: [],
-        level: "comment",
-        generate: (_varName, config) => [
-          `// @neural_animation \u2014 neural network-driven animation (style: ${String(config.style || "motion_matching")})`,
-          `// TODO: integrate CoreML pose prediction with AnimationPlaybackController`
-        ]
-      },
-      ai_vision: {
-        trait: "ai_vision",
-        components: [],
-        level: "comment",
-        imports: ["Vision"],
-        generate: (_varName, config) => [
-          `// @ai_vision \u2014 AI vision processing (task: ${String(config.task || "detection")})`,
-          `// TODO: configure VNDetectRectanglesRequest or custom CoreML model`
-        ]
-      }
-    };
-    VISIONOS_TRAIT_MAP = {
-      ...PHYSICS_TRAIT_MAP,
-      ...INTERACTION_TRAIT_MAP,
-      ...AUDIO_TRAIT_MAP,
-      ...AR_TRAIT_MAP,
-      ...VISUAL_TRAIT_MAP,
-      ...ACCESSIBILITY_TRAIT_MAP,
-      ...UI_TRAIT_MAP,
-      ...PORTAL_TRAIT_MAP,
-      ...V43_TRAIT_MAP
-    };
-  }
-});
-
-// src/compiler/VisionOSCompiler.ts
-var VisionOSCompiler_exports = {};
-__export(VisionOSCompiler_exports, {
-  VisionOSCompiler: () => VisionOSCompiler
-});
-var VisionOSCompiler;
-var init_VisionOSCompiler = __esm({
-  "src/compiler/VisionOSCompiler.ts"() {
-    init_VisionOSTraitMap();
-    init_CompilerBase();
-    init_DomainBlockCompilerMixin();
-    VisionOSCompiler = class extends CompilerBase {
-      constructor(options = {}) {
-        super();
-        this.compilerName = "VisionOSCompiler";
-        this.lines = [];
-        this.indentLevel = 0;
-        this.options = {
-          structName: options.structName || "GeneratedScene",
-          indent: options.indent || "    ",
-          useRealityComposerPro: options.useRealityComposerPro ?? false
-        };
-      }
-      getRequiredCapability() {
-        return ANSCapabilityPath.VISIONOS;
-      }
-      compile(composition, agentToken, outputPath) {
-        this.validateCompilerAccess(agentToken, outputPath);
-        this.lines = [];
-        this.indentLevel = 0;
-        this.emit("// Auto-generated by HoloScript VisionOSCompiler");
-        this.emit(
-          `// Source: composition "${this.escapeStringValue(composition.name, "Swift")}"`
-        );
-        this.emit("// Do not edit manually \u2014 regenerate from .holo source");
-        this.emit("");
-        this.emit("import SwiftUI");
-        this.emit("import RealityKit");
-        this.emit("import RealityKitContent");
-        const allTraits = this.collectAllTraits(composition);
-        const requiredImports = getRequiredImports(allTraits);
-        for (const imp of requiredImports) {
-          this.emit(`import ${imp}`);
-        }
-        if (composition.audio?.length && !requiredImports.includes("AVFoundation")) {
-          this.emit("import AVFoundation");
-        }
-        const minVersion = getMinVisionOSVersion(allTraits);
-        if (minVersion !== "1.0") {
-          this.emit(`// Requires visionOS ${minVersion}+`);
-        }
-        this.emit("");
-        if (composition.state) {
-          this.emit("@Observable");
-          this.emit(`class ${this.options.structName}State {`);
-          this.indentLevel++;
-          for (const prop of composition.state.properties) {
-            const swiftType = this.toSwiftType(prop.value);
-            const swiftVal = this.toSwiftValue(prop.value);
-            this.emit(
-              `var ${this.escapeStringValue(prop.key, "Swift")}: ${swiftType} = ${swiftVal}`
-            );
-          }
-          this.indentLevel--;
-          this.emit("}");
-          this.emit("");
-        }
-        this.emit(`struct ${this.options.structName}: View {`);
-        this.indentLevel++;
-        if (composition.state) {
-          this.emit(`@State private var state = ${this.options.structName}State()`);
-          this.emit("");
-        }
-        this.emit("var body: some View {");
-        this.indentLevel++;
-        this.emit("RealityView { content in");
-        this.indentLevel++;
-        this.emit("let root = Entity()");
-        this.emit(`root.name = "${this.escapeStringValue(composition.name, "Swift")}"`);
-        if (composition.environment) {
-          this.compileEnvironment(composition.environment);
-        }
-        if (composition.lights) {
-          for (const light of composition.lights) {
-            this.compileLight(light);
-          }
-        }
-        if (composition.objects) {
-          for (const obj of composition.objects) {
-            this.compileObject(obj, "root");
-          }
-        }
-        if (composition.spatialGroups) {
-          for (const group of composition.spatialGroups) {
-            this.compileSpatialGroup(group, "root");
-          }
-        }
-        if (composition.audio) {
-          for (const audio of composition.audio) {
-            this.compileAudio(audio);
-          }
-        }
-        if (composition.zones) {
-          for (const zone of composition.zones) {
-            this.compileZone(zone);
-          }
-        }
-        this.emit("");
-        this.emit("content.add(root)");
-        this.indentLevel--;
-        this.emit("}");
-        const grabbables = composition.objects?.filter((o) => o.traits?.some((t) => t.name === "grabbable")) || [];
-        if (grabbables.length > 0) {
-          this.emit(".gesture(DragGesture().targetedToAnyEntity().onChanged { value in");
-          this.indentLevel++;
-          this.emit(
-            "value.entity.position = value.convert(value.location3D, from: .local, to: .scene)"
-          );
-          this.indentLevel--;
-          this.emit("})");
-        }
-        this.indentLevel--;
-        this.emit("}");
-        if (composition.timelines) {
-          for (const tl of composition.timelines) {
-            this.compileTimeline(tl);
-          }
-        }
-        if (composition.transitions) {
-          for (const tr of composition.transitions) {
-            this.compileTransition(tr);
-          }
-        }
-        this.indentLevel--;
-        this.emit("}");
-        if (composition.effects) {
-          this.emit("");
-          this.compileEffects(composition.effects);
-        }
-        this.compileVisionOSDomainBlocks(composition);
-        return this.lines.join("\n");
-      }
-      compileVisionOSDomainBlocks(composition) {
-        const domainBlocks = composition.domainBlocks ?? [];
-        if (domainBlocks.length === 0) return;
-        this.emit("");
-        this.emit("// === v4.2 Domain Blocks ===");
-        let blockIdx = 0;
-        const compiled = compileDomainBlocks(
-          domainBlocks,
-          {
-            material: (block) => {
-              const mat = compileMaterialBlock(block);
-              return materialToVisionOS(mat, `db${blockIdx++}`);
-            },
-            physics: (block) => {
-              const phys = compilePhysicsBlock(block);
-              return physicsToVisionOS(phys, `db${blockIdx++}`);
-            },
-            vfx: (block) => {
-              const ps = compileParticleBlock(block);
-              return particlesToVisionOS(ps, `db${blockIdx++}`);
-            },
-            postfx: (block) => {
-              const pp = compilePostProcessingBlock(block);
-              return `// Post-Processing: ${pp.keyword} \u2014 configure via RealityKit RenderCallbacks`;
-            },
-            audio: (block) => {
-              const audio = compileAudioSourceBlock(block);
-              return audioSourceToVisionOS(audio, `db${blockIdx++}`);
-            },
-            weather: (block) => {
-              const weather = compileWeatherBlock(block);
-              const w = weather;
-              const layers = w.layers.map((l) => `// Layer: ${l.type} \u2014 ${JSON.stringify(l.properties)}`).join("\n");
-              return `// Weather: ${w.keyword} "${w.name || ""}" \u2014 implement via custom RealityKit particles
-${layers}`;
-            }
-          },
-          (block) => `// Domain block: ${block.domain}/${block.keyword} "${this.escapeStringValue(block.name, "Swift")}"`
-        );
-        for (const line of compiled) {
-          for (const l of line.split("\n")) {
-            this.emit(l);
-          }
-        }
-      }
-      compileEnvironment(env) {
-        this.emit("");
-        this.emit("// === Environment ===");
-        for (const prop of env.properties) {
-          if (prop.key === "preset" || prop.key === "skybox") {
-            this.emit(`// Environment preset: "${prop.value}" \u2014 configure via ImageBasedLight`);
-            this.emit('if let iblResource = try? await EnvironmentResource(named: "IBL") {');
-            this.indentLevel++;
-            this.emit("let iblComponent = ImageBasedLightComponent(source: .single(iblResource))");
-            this.emit("root.components.set(iblComponent)");
-            this.emit("root.components.set(ImageBasedLightReceiverComponent(imageBasedLight: root))");
-            this.indentLevel--;
-            this.emit("}");
-          } else if (prop.key === "fog" && typeof prop.value === "object") {
-            this.emit(
-              `// Fog: ${JSON.stringify(prop.value)} \u2014 not natively supported, use post-processing`
-            );
-          } else if (prop.key === "ambient_light") {
-            this.emit(`// Ambient light: ${prop.value} \u2014 handled via IBL intensity`);
-          }
-        }
-      }
-      compileLight(light) {
-        const varName = this.sanitizeName(light.name);
-        this.emit("");
-        this.emit(`// Light: ${this.escapeStringValue(light.name, "Swift")}`);
-        const typeMap = {
-          directional: "DirectionalLightComponent",
-          point: "PointLightComponent",
-          spot: "SpotLightComponent"
-        };
-        const rkType = typeMap[light.lightType];
-        if (rkType) {
-          this.emit(`let ${varName} = Entity()`);
-          this.emit(`${varName}.name = "${this.escapeStringValue(light.name, "Swift")}"`);
-          const colorProp = light.properties.find((p) => p.key === "color");
-          const intensityProp = light.properties.find((p) => p.key === "intensity");
-          const posProp = light.properties.find((p) => p.key === "position");
-          if (light.lightType === "point") {
-            this.emit(`var ${varName}Light = PointLightComponent()`);
-            if (colorProp)
-              this.emit(`${varName}Light.color = .init(${this.toUIColor(colorProp.value)})`);
-            if (intensityProp)
-              this.emit(`${varName}Light.intensity = ${intensityProp.value * 1e3}`);
-          } else if (light.lightType === "directional") {
-            this.emit(`var ${varName}Light = DirectionalLightComponent()`);
-            if (colorProp)
-              this.emit(`${varName}Light.color = .init(${this.toUIColor(colorProp.value)})`);
-            if (intensityProp)
-              this.emit(`${varName}Light.intensity = ${intensityProp.value * 1e3}`);
-          } else if (light.lightType === "spot") {
-            this.emit(`var ${varName}Light = SpotLightComponent()`);
-            if (colorProp)
-              this.emit(`${varName}Light.color = .init(${this.toUIColor(colorProp.value)})`);
-            if (intensityProp)
-              this.emit(`${varName}Light.intensity = ${intensityProp.value * 1e3}`);
-          }
-          this.emit(`${varName}.components.set(${varName}Light)`);
-          if (posProp && Array.isArray(posProp.value)) {
-            this.emit(`${varName}.position = ${this.toSIMD3(posProp.value)}`);
-          }
-          this.emit(`root.addChild(${varName})`);
-        } else {
-          this.emit(`// Light type "${light.lightType}" not directly supported in RealityKit`);
-        }
-      }
-      compileObject(obj, parentVar) {
-        if (this.isUIComponent(obj)) {
-          this.compileUIComponent(obj, parentVar);
-          return;
-        }
-        const varName = this.sanitizeName(obj.name);
-        const meshType = this.findObjProp(obj, "mesh") || this.findObjProp(obj, "type") || "cube";
-        const isText = meshType === "text";
-        const isModel = !!this.findObjProp(obj, "model") || !!this.findObjProp(obj, "src");
-        const isLight = ["directional", "point", "spot", "hemisphere", "ambient", "area"].includes(
-          meshType
-        );
-        const isSparkles = meshType === "sparkles";
-        this.emit("");
-        this.emit(`// Object: ${this.escapeStringValue(obj.name, "Swift")}`);
-        if (isLight) {
-          this.emit(
-            `// Light object "${this.escapeStringValue(obj.name, "Swift")}" \u2014 handled via light components`
-          );
-          return;
-        }
-        if (isText) {
-          this.emit(`let ${varName} = Entity()`);
-          this.emit(`${varName}.name = "${this.escapeStringValue(obj.name, "Swift")}"`);
-          const text = this.findObjProp(obj, "text");
-          const fontSize = this.findObjProp(obj, "font_size") || 0.1;
-          if (text) {
-            this.emit(`let ${varName}Mesh = MeshResource.generateText("${text}",`);
-            this.emit(`    extrusionDepth: 0.001,`);
-            this.emit(`    font: .systemFont(ofSize: CGFloat(${fontSize * 10})),`);
-            this.emit(`    containerFrame: .zero,`);
-            this.emit(`    alignment: .center,`);
-            this.emit(`    lineBreakMode: .byWordWrapping)`);
-            this.emit(
-              `${varName}.components.set(ModelComponent(mesh: ${varName}Mesh, materials: [SimpleMaterial(color: ${this.toUIColor(this.findObjProp(obj, "color") || "#ffffff")}, isMetallic: false)]))`
-            );
-          }
-        } else if (isModel) {
-          const src = this.findObjProp(obj, "model") || this.findObjProp(obj, "src");
-          this.emit(`let ${varName} = try! await Entity(named: "${src}", in: realityKitContentBundle)`);
-          this.emit(`${varName}.name = "${this.escapeStringValue(obj.name, "Swift")}"`);
-        } else if (isSparkles) {
-          this.emit(`// Sparkles: use ParticleEmitterComponent in visionOS 2.0+`);
-          this.emit(`let ${varName} = Entity()`);
-          this.emit(`${varName}.name = "${this.escapeStringValue(obj.name, "Swift")}"`);
-        } else {
-          const meshMap = {
-            sphere: ".generateSphere(radius: 0.5)",
-            box: ".generateBox(size: 1.0)",
-            cube: ".generateBox(size: 1.0)",
-            plane: ".generatePlane(width: 1.0, depth: 1.0)",
-            cylinder: ".generateBox(size: 1.0)",
-            // No cylinder in RealityKit, use box
-            cone: ".generateBox(size: 1.0)",
-            torus: ".generateBox(size: 1.0)"
-          };
-          const meshGen = meshMap[meshType] || ".generateBox(size: 1.0)";
-          const size = this.findObjProp(obj, "size");
-          const radius = this.findObjProp(obj, "radius");
-          let meshCall = meshGen;
-          if (meshType === "sphere" && radius) {
-            meshCall = `.generateSphere(radius: ${radius})`;
-          } else if ((meshType === "box" || meshType === "cube") && size) {
-            if (Array.isArray(size)) {
-              meshCall = `.generateBox(width: ${size[0]}, height: ${size[1]}, depth: ${size[2]})`;
-            } else {
-              meshCall = `.generateBox(size: ${size})`;
-            }
-          } else if (meshType === "plane" && size) {
-            meshCall = `.generatePlane(width: ${size}, depth: ${size})`;
-          }
-          this.emit(`let ${varName}Mesh = MeshResource${meshCall}`);
-          const material = this.findObjProp(obj, "material");
-          if (material && typeof material === "object") {
-            const mat = material;
-            this.emit(`var ${varName}Material = PhysicallyBasedMaterial()`);
-            if (mat.color)
-              this.emit(`${varName}Material.baseColor = .init(tint: ${this.toUIColor(mat.color)})`);
-            if (mat.roughness !== void 0)
-              this.emit(`${varName}Material.roughness = .init(floatLiteral: ${mat.roughness})`);
-            if (mat.metalness !== void 0)
-              this.emit(`${varName}Material.metallic = .init(floatLiteral: ${mat.metalness})`);
-            if (mat.emissive)
-              this.emit(
-                `${varName}Material.emissiveColor = .init(color: ${this.toUIColor(mat.emissive)})`
-              );
-            if (mat.emissiveIntensity)
-              this.emit(`${varName}Material.emissiveIntensity = ${mat.emissiveIntensity}`);
-            this.emit(
-              `let ${varName} = ModelEntity(mesh: ${varName}Mesh, materials: [${varName}Material])`
-            );
-          } else {
-            this.emit(
-              `let ${varName} = ModelEntity(mesh: ${varName}Mesh, materials: [SimpleMaterial()])`
-            );
-          }
-          this.emit(`${varName}.name = "${this.escapeStringValue(obj.name, "Swift")}"`);
-          if (obj.traits) {
-            for (const trait of obj.traits) {
-              const config = trait.config || {};
-              const traitCode = generateTraitCode(trait.name, varName, config);
-              for (const line of traitCode) {
-                if (line) this.emit(line);
-              }
-            }
-          }
-        }
-        const pos = this.findObjProp(obj, "position");
-        if (pos) this.emit(`${varName}.position = ${this.toSIMD3(pos)}`);
-        const rot = this.findObjProp(obj, "rotation");
-        if (rot && Array.isArray(rot)) {
-          const radX = rot[0] * Math.PI / 180;
-          const radY = rot[1] * Math.PI / 180;
-          const radZ = rot[2] * Math.PI / 180;
-          this.emit(
-            `${varName}.orientation = simd_quatf(angle: ${radX.toFixed(4)}, axis: SIMD3<Float>(1, 0, 0)) * simd_quatf(angle: ${radY.toFixed(4)}, axis: SIMD3<Float>(0, 1, 0)) * simd_quatf(angle: ${radZ.toFixed(4)}, axis: SIMD3<Float>(0, 0, 1))`
-          );
-        }
-        const scale = this.findObjProp(obj, "scale");
-        if (scale) this.emit(`${varName}.scale = ${this.toSIMD3(scale)}`);
-        this.emit(`${parentVar}.addChild(${varName})`);
-        if (obj.children) {
-          for (const child of obj.children) {
-            this.compileObject(child, varName);
-          }
-        }
-      }
-      compileSpatialGroup(group, parentVar) {
-        const varName = this.sanitizeName(group.name);
-        this.emit("");
-        this.emit(`// Spatial Group: ${this.escapeStringValue(group.name, "Swift")}`);
-        this.emit(`let ${varName} = Entity()`);
-        this.emit(`${varName}.name = "${this.escapeStringValue(group.name, "Swift")}"`);
-        for (const prop of group.properties) {
-          if (prop.key === "position" && Array.isArray(prop.value)) {
-            this.emit(`${varName}.position = ${this.toSIMD3(prop.value)}`);
-          }
-        }
-        this.emit(`${parentVar}.addChild(${varName})`);
-        for (const obj of group.objects) {
-          this.compileObject(obj, varName);
-        }
-        if (group.groups) {
-          for (const sub of group.groups) {
-            this.compileSpatialGroup(sub, varName);
-          }
-        }
-      }
-      compileAudio(audio) {
-        const varName = this.sanitizeName(audio.name);
-        this.emit("");
-        this.emit(`// Audio: ${this.escapeStringValue(audio.name, "Swift")}`);
-        this.emit(`let ${varName} = Entity()`);
-        this.emit(`${varName}.name = "${this.escapeStringValue(audio.name, "Swift")}"`);
-        const src = audio.properties.find((p) => p.key === "src" || p.key === "source")?.value;
-        const spatial = audio.properties.find((p) => p.key === "spatial")?.value;
-        if (src) {
-          this.emit(`if let audioResource = try? await AudioFileResource(named: "${src}") {`);
-          this.indentLevel++;
-          if (spatial) {
-            this.emit(`let audioController = ${varName}.prepareAudio(audioResource)`);
-            this.emit(`${varName}.components.set(SpatialAudioComponent())`);
-          } else {
-            this.emit(`let audioController = ${varName}.prepareAudio(audioResource)`);
-            this.emit(`${varName}.components.set(AmbientAudioComponent())`);
-          }
-          this.emit("audioController.play()");
-          this.indentLevel--;
-          this.emit("}");
-        }
-        const pos = audio.properties.find((p) => p.key === "position")?.value;
-        if (pos) this.emit(`${varName}.position = ${this.toSIMD3(pos)}`);
-        this.emit(`root.addChild(${varName})`);
-      }
-      compileZone(zone) {
-        const varName = this.sanitizeName(zone.name);
-        this.emit("");
-        this.emit(`// Zone: ${this.escapeStringValue(zone.name, "Swift")}`);
-        this.emit(`let ${varName} = Entity()`);
-        this.emit(`${varName}.name = "${this.escapeStringValue(zone.name, "Swift")}"`);
-        const shape = zone.properties.find((p) => p.key === "shape")?.value;
-        if (shape === "box") {
-          const size = zone.properties.find((p) => p.key === "size")?.value;
-          if (size && Array.isArray(size)) {
-            this.emit(
-              `${varName}.components.set(CollisionComponent(shapes: [.generateBox(size: ${this.toSIMD3(size)})]))`
-            );
-          }
-        } else if (shape === "sphere") {
-          const radius = zone.properties.find((p) => p.key === "radius")?.value;
-          if (radius) {
-            this.emit(
-              `${varName}.components.set(CollisionComponent(shapes: [.generateSphere(radius: ${radius})]))`
-            );
-          }
-        }
-        const pos = zone.properties.find((p) => p.key === "position")?.value;
-        if (pos) this.emit(`${varName}.position = ${this.toSIMD3(pos)}`);
-        this.emit(`// Zone handlers: ${zone.handlers?.map((h) => h.event).join(", ") || "none"}`);
-        this.emit(`root.addChild(${varName})`);
-      }
-      compileTimeline(tl) {
-        const varName = this.sanitizeName(tl.name);
-        this.emit("");
-        this.emit(`func play${varName}() async {`);
-        this.indentLevel++;
-        let lastTime = 0;
-        for (const entry of tl.entries) {
-          const delay = entry.time - lastTime;
-          if (delay > 0) {
-            this.emit(`try? await Task.sleep(nanoseconds: ${Math.round(delay * 1e9)})`);
-          }
-          if (entry.action.kind === "animate") {
-            this.emit(
-              `// Animate "${entry.action.target}": ${JSON.stringify(entry.action.properties)}`
-            );
-          } else if (entry.action.kind === "emit") {
-            this.emit(`// Emit: "${entry.action.event}"`);
-          } else if (entry.action.kind === "call") {
-            this.emit(`// Call: ${entry.action.method}`);
-          }
-          lastTime = entry.time;
-        }
-        if (tl.loop) {
-          this.emit(`await play${varName}() // loop`);
-        }
-        this.indentLevel--;
-        this.emit("}");
-      }
-      compileTransition(tr) {
-        const varName = this.sanitizeName(tr.name);
-        this.emit("");
-        this.emit(`func ${varName}() {`);
-        this.indentLevel++;
-        const target = tr.properties.find((p) => p.key === "target")?.value;
-        this.emit(`// Transition to: "${target}"`);
-        this.emit(`// Effect: ${tr.properties.find((p) => p.key === "effect")?.value || "default"}`);
-        this.indentLevel--;
-        this.emit("}");
-      }
-      compileEffects(effects) {
-        this.emit("// === Post-Processing Notes ===");
-        this.emit("// visionOS uses system-level rendering; post-processing is limited.");
-        for (const effect of effects.effects) {
-          this.emit(`// Effect: ${effect.effectType} \u2014 ${JSON.stringify(effect.properties)}`);
-        }
-      }
-      /**
-       * Compile UI component to SwiftUI attachment
-       */
-      compileUIComponent(obj, parentVar) {
-        const varName = this.sanitizeName(obj.name);
-        const uiType = this.findObjProp(obj, "type") || "panel";
-        this.emit("");
-        this.emit(`// UI Component: ${this.escapeStringValue(obj.name, "Swift")}`);
-        switch (uiType) {
-          case "ui_panel":
-            this.compileUIPanel(obj, varName, parentVar);
-            break;
-          case "ui_button":
-            this.compileUIButton(obj, varName, parentVar);
-            break;
-          case "ui_text":
-            this.compileUIText(obj, varName, parentVar);
-            break;
-          case "ui_slider":
-            this.compileUISlider(obj, varName, parentVar);
-            break;
-          case "ui_input":
-            this.compileUIInput(obj, varName, parentVar);
-            break;
-          case "ui_image":
-            this.compileUIImage(obj, varName, parentVar);
-            break;
-          default:
-            this.emit(`// Unknown UI component type: ${uiType}`);
-        }
-      }
-      compileUIPanel(obj, varName, parentVar) {
-        const width = this.findObjProp(obj, "width") || 400;
-        const height = this.findObjProp(obj, "height") || 300;
-        const pos = this.findObjProp(obj, "position");
-        this.emit(
-          `// SwiftUI Panel attachment for "${this.escapeStringValue(obj.name, "Swift")}"`
-        );
-        this.emit(`let ${varName} = Entity()`);
-        this.emit(`${varName}.name = "${this.escapeStringValue(obj.name, "Swift")}"`);
-        if (pos) {
-          this.emit(`${varName}.position = ${this.toSIMD3(pos)}`);
-        }
-        this.emit(`// Attach SwiftUI view via ViewAttachmentComponent`);
-        this.emit(`// ${varName}.components.set(ViewAttachmentComponent {`);
-        this.emit(`//     VStack {`);
-        if (obj.children) {
-          for (const child of obj.children) {
-            this.emit(`//         // Child: ${this.escapeStringValue(child.name, "Swift")}`);
-          }
-        }
-        this.emit(`//     }`);
-        this.emit(`//     .frame(width: ${width}, height: ${height})`);
-        this.emit(`// })`);
-        this.emit(`${parentVar}.addChild(${varName})`);
-      }
-      compileUIButton(obj, varName, parentVar) {
-        const text = this.findObjProp(obj, "text") || "Button";
-        const pos = this.findObjProp(obj, "position");
-        this.emit(`let ${varName} = Entity()`);
-        this.emit(`${varName}.name = "${this.escapeStringValue(obj.name, "Swift")}"`);
-        if (pos) {
-          this.emit(`${varName}.position = ${this.toSIMD3(pos)}`);
-        }
-        this.emit(`// SwiftUI Button: "${text}"`);
-        this.emit(`// Implement via ViewAttachmentComponent with Button { Text("${text}") }`);
-        this.emit(`${varName}.components.set(InputTargetComponent())`);
-        this.emit(
-          `${varName}.components.set(CollisionComponent(shapes: [.generateBox(size: SIMD3<Float>(0.2, 0.08, 0.01))]))`
-        );
-        this.emit(`${parentVar}.addChild(${varName})`);
-      }
-      compileUIText(obj, varName, parentVar) {
-        const content = this.findObjProp(obj, "content") || this.findObjProp(obj, "text") || "";
-        const fontSize = this.findObjProp(obj, "fontSize") || 16;
-        const color = this.findObjProp(obj, "color") || "#ffffff";
-        this.emit(`let ${varName}Mesh = MeshResource.generateText("${content}",`);
-        this.emit(`    extrusionDepth: 0.001,`);
-        this.emit(`    font: .systemFont(ofSize: ${fontSize}),`);
-        this.emit(`    containerFrame: .zero,`);
-        this.emit(`    alignment: .center,`);
-        this.emit(`    lineBreakMode: .byWordWrapping)`);
-        this.emit(
-          `let ${varName} = ModelEntity(mesh: ${varName}Mesh, materials: [SimpleMaterial(color: ${this.toUIColor(color)}, isMetallic: false)])`
-        );
-        this.emit(`${varName}.name = "${this.escapeStringValue(obj.name, "Swift")}"`);
-        this.emit(`${parentVar}.addChild(${varName})`);
-      }
-      compileUISlider(obj, varName, parentVar) {
-        const min = this.findObjProp(obj, "min") ?? 0;
-        const max = this.findObjProp(obj, "max") ?? 100;
-        const value = this.findObjProp(obj, "value") ?? 50;
-        const pos = this.findObjProp(obj, "position");
-        this.emit(`let ${varName} = Entity()`);
-        this.emit(`${varName}.name = "${this.escapeStringValue(obj.name, "Swift")}"`);
-        if (pos) {
-          this.emit(`${varName}.position = ${this.toSIMD3(pos)}`);
-        }
-        this.emit(`// SwiftUI Slider: min=${min}, max=${max}, value=${value}`);
-        this.emit(
-          `// Implement via ViewAttachmentComponent with Slider(value: $value, in: ${min}...${max})`
-        );
-        this.emit(`${varName}.components.set(InputTargetComponent())`);
-        this.emit(`${parentVar}.addChild(${varName})`);
-      }
-      compileUIInput(obj, varName, parentVar) {
-        const placeholder = this.findObjProp(obj, "placeholder") || "";
-        const pos = this.findObjProp(obj, "position");
-        this.emit(`let ${varName} = Entity()`);
-        this.emit(`${varName}.name = "${this.escapeStringValue(obj.name, "Swift")}"`);
-        if (pos) {
-          this.emit(`${varName}.position = ${this.toSIMD3(pos)}`);
-        }
-        this.emit(`// SwiftUI TextField with placeholder: "${placeholder}"`);
-        this.emit(
-          `// Implement via ViewAttachmentComponent with TextField("${placeholder}", text: $text)`
-        );
-        this.emit(`${varName}.components.set(InputTargetComponent())`);
-        this.emit(`${parentVar}.addChild(${varName})`);
-      }
-      compileUIImage(obj, varName, parentVar) {
-        const src = this.findObjProp(obj, "src") || "";
-        const width = this.findObjProp(obj, "width") || 100;
-        const height = this.findObjProp(obj, "height") || 100;
-        const pos = this.findObjProp(obj, "position");
-        this.emit(`let ${varName} = Entity()`);
-        this.emit(`${varName}.name = "${this.escapeStringValue(obj.name, "Swift")}"`);
-        if (pos) {
-          this.emit(`${varName}.position = ${this.toSIMD3(pos)}`);
-        }
-        this.emit(`// Image: ${src} (${width}x${height})`);
-        this.emit(
-          `let ${varName}Mesh = MeshResource.generatePlane(width: ${width / 1e3}, depth: ${height / 1e3})`
-        );
-        this.emit(`if let texture = try? await TextureResource(named: "${src}") {`);
-        this.indentLevel++;
-        this.emit(`var ${varName}Material = UnlitMaterial()`);
-        this.emit(`${varName}Material.color = .init(texture: .init(texture))`);
-        this.emit(
-          `${varName}.components.set(ModelComponent(mesh: ${varName}Mesh, materials: [${varName}Material]))`
-        );
-        this.indentLevel--;
-        this.emit(`}`);
-        this.emit(`${parentVar}.addChild(${varName})`);
-      }
-      /**
-       * Check if object is a UI component
-       */
-      isUIComponent(obj) {
-        const type = this.findObjProp(obj, "type");
-        const uiTypes = ["ui_panel", "ui_button", "ui_text", "ui_slider", "ui_input", "ui_image"];
-        return uiTypes.includes(type || "");
-      }
-      /**
-       * Get all traits used in composition for imports
-       */
-      collectAllTraits(composition) {
-        const traits = [];
-        const collectFromObject = (obj) => {
-          if (obj.traits) {
-            for (const trait of obj.traits) {
-              if (!traits.includes(trait.name)) {
-                traits.push(trait.name);
-              }
-            }
-          }
-          if (obj.children) {
-            obj.children.forEach(collectFromObject);
-          }
-        };
-        composition.objects?.forEach(collectFromObject);
-        composition.spatialGroups?.forEach((group) => {
-          group.objects.forEach(collectFromObject);
-        });
-        return traits;
-      }
-      // ─── Helpers ───────────────────────────────────────────────────────────
-      emit(line) {
-        this.lines.push(this.options.indent.repeat(this.indentLevel) + line);
-      }
-      sanitizeName(name) {
-        return name.replace(/[^a-zA-Z0-9_]/g, "_");
-      }
-      toSIMD3(arr) {
-        if (Array.isArray(arr) && arr.length >= 3) {
-          return `SIMD3<Float>(${arr[0]}, ${arr[1]}, ${arr[2]})`;
-        }
-        return `SIMD3<Float>(${arr}, ${arr}, ${arr})`;
-      }
-      toUIColor(value) {
-        if (typeof value === "string" && value.startsWith("#")) {
-          const hex = value.slice(1);
-          const r = parseInt(hex.substring(0, 2), 16) / 255;
-          const g = parseInt(hex.substring(2, 4), 16) / 255;
-          const b = parseInt(hex.substring(4, 6), 16) / 255;
-          return `.init(red: ${r.toFixed(3)}, green: ${g.toFixed(3)}, blue: ${b.toFixed(3)}, alpha: 1.0)`;
-        }
-        return ".white";
-      }
-      toSwiftType(value) {
-        if (typeof value === "number") return Number.isInteger(value) ? "Int" : "Float";
-        if (typeof value === "boolean") return "Bool";
-        if (typeof value === "string") return "String";
-        if (Array.isArray(value)) return "[Any]";
-        return "Any";
-      }
-      toSwiftValue(value) {
-        if (typeof value === "number") return Number.isInteger(value) ? `${value}` : `${value}`;
-        if (typeof value === "boolean") return value ? "true" : "false";
-        if (typeof value === "string") return `"${this.escapeStringValue(value, "Swift")}"`;
-        if (value === null) return "nil";
-        return "nil";
-      }
-      findObjProp(obj, key) {
-        return obj.properties?.find((p) => p.key === key)?.value;
-      }
-    };
-  }
-});
-
-export { VisionOSCompiler, VisionOSCompiler_exports, init_VisionOSCompiler };
-//# sourceMappingURL=chunk-YCXFCXDS.js.map
-//# sourceMappingURL=chunk-YCXFCXDS.js.map