@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-S4W6Z2MN.js

@@ -0,0 +1,2426 @@
+import { init_PlatformConditionalCompilerMixin, filterCompositionForPlatform } from './chunk-GZG4KA4E.js';
+import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, compileAudioSourceBlock, audioSourceToVisionOS, compilePostProcessingBlock, compileParticleBlock, particlesToVisionOS, compilePhysicsBlock, physicsToVisionOS, compileMaterialBlock, materialToVisionOS } from './chunk-JCLBKPMX.js';
+import { init_CompilerBase, CompilerBase } from './chunk-QPSKHBJP.js';
+import { __esm, __export } from './chunk-OL46QLBJ.js';
+import { ANSCapabilityPath } from '@holoscript/core-types/ans';
+
+// 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;
+}
+function listAllTraits() {
+  return Object.keys(VISIONOS_TRAIT_MAP);
+}
+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: "full",
+        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: "full",
+        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: "full",
+        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: "comment",
+        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: "full",
+        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`,
+            `}`,
+            `${varName}LODComponent.registerComponent()`,
+            `// LODSystem.update(): query camera distance, swap ModelComponent.mesh via level thresholds`,
+            `${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`
+          ];
+        }
+      },
+      palm_menu: {
+        trait: "palm_menu",
+        components: ["AnchoringComponent"],
+        level: "partial",
+        generate: (varName, config) => {
+          const when = config.visible_when || "palm_up";
+          const layout = config.layout || "radial";
+          const attach = config.attach_to || "left_palm";
+          return [
+            `// @palm_menu \u2014 palm-attached radial menu (visible_when: ${when}, attach: ${attach}, layout: ${layout})`,
+            `${varName}.components.set(AnchoringComponent(.hand(.left, location: .palm)))`,
+            `// UI: radial items rendered via SwiftUI overlay or Entity HUD; gestures wired to on_pinch etc.`
+          ];
+        }
+      },
+      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: "comment",
+        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: "comment",
+        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: "comment",
+        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: "full",
+        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`,
+            `let ${varName}PersonaStyle: SpatialPersonaStyle = .${style}`,
+            `let ${varName}SpatialTemplate = SpatialTemplate(settings: SpatialTemplateSettings())`,
+            `let ${varName}Coordinator = SystemCoordinator()`,
+            `Task {`,
+            `    for await session in GroupStateObserver().isSpatialSharePlayActive.values {`,
+            `        guard session else { continue }`,
+            `        await SystemCoordinator.requestForegroundPresentation(`,
+            `            .spatialPersona(style: ${varName}PersonaStyle),`,
+            `            template: ${varName}SpatialTemplate`,
+            `        )`,
+            `    }`,
+            `}`,
+            `${varName}.components.set(OpacityComponent(opacity: 1.0))`
+          ];
+        }
+      },
+      shareplay: {
+        trait: "shareplay",
+        components: [],
+        level: "full",
+        minVersion: "1.0",
+        imports: ["GroupActivities"],
+        generate: (varName, config) => {
+          const activity = String(config.activity_type || "custom");
+          return [
+            `// @shareplay \u2014 SharePlay GroupActivity (activity: ${activity})`,
+            `struct ${varName}Activity: GroupActivity {`,
+            `    var metadata = GroupActivityMetadata()`,
+            `    init() {`,
+            `        metadata.title = "${activity}"`,
+            `        metadata.type = .generic`,
+            `    }`,
+            `}`,
+            ``,
+            `// Activate session and set up GroupSessionMessenger`,
+            `func ${varName}ActivateSharePlay() {`,
+            `    Task {`,
+            `        for await session in ${varName}Activity.sessions() {`,
+            `            await session.join(activationConditions: [.always])`,
+            `            let messenger = GroupSessionMessenger(session: session)`,
+            `            // Send: try? await messenger.send("event", to: .all)`,
+            `            // Receive: for await (msg, _) in messenger.messages(of: String.self) { handle(msg) }`,
+            `            _ = messenger`,
+            `        }`,
+            `    }`,
+            `}`
+          ];
+        }
+      },
+      object_tracking: {
+        trait: "object_tracking",
+        components: ["AnchoringComponent"],
+        level: "full",
+        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`,
+            `// Load .referenceobject bundle from app bundle for ${referenceObject}`,
+            `let ${varName}RefObjURL = Bundle.main.url(forResource: "${referenceObject}", withExtension: "referenceobject")!`,
+            `let ${varName}RefObj = try await ReferenceObject(from: ${varName}RefObjURL)`,
+            `let ${varName}ObjProvider = ObjectTrackingProvider(referenceObjects: [${varName}RefObj])`,
+            `try await arkitSession.run([${varName}ObjProvider])`,
+            `Task {`,
+            `    for await update in ${varName}ObjProvider.anchorUpdates {`,
+            `        switch update.event {`,
+            `        case .added, .updated:`,
+            `            // Place ${varName} at tracked object anchor`,
+            `            ${varName}.transform = Transform(matrix: update.anchor.originFromAnchorTransform)`,
+            `        case .removed:`,
+            `            ${varName}.transform = Transform()`,
+            `        }`,
+            `    }`,
+            `}`,
+            `// Info.plist: NSWorldSensingUsageDescription required`
+          ];
+        }
+      },
+      scene_reconstruction: {
+        trait: "scene_reconstruction",
+        components: [],
+        level: "full",
+        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: ["AnchoringComponent"],
+        level: "full",
+        minVersion: "1.0",
+        imports: ["ARKit", "SwiftUI"],
+        generate: (varName, config) => {
+          const mode = String(config.navigation_mode ?? config.mode ?? "walking");
+          const viz = String(config.path_visualization ?? "arrow");
+          const waypointRadius = Number(config.waypoint_radius_m ?? 2);
+          const rawColor = String(config.path_color ?? "#00aaff").replace("#", "");
+          const r = parseInt(rawColor.slice(0, 2) || "00", 16) / 255;
+          const g = parseInt(rawColor.slice(2, 4) || "aa", 16) / 255;
+          const b = parseInt(rawColor.slice(4, 6) || "ff", 16) / 255;
+          const isIndoor = mode === "indoor";
+          if (isIndoor) {
+            return [
+              `// @spatial_navigation \u2014 indoor mode (NavigationSplitView, ${viz} viz)`,
+              `// In your App / RootView:`,
+              `// NavigationSplitView {`,
+              `//     List(${varName}NavWaypoints, selection: $${varName}SelectedWaypoint) { wp in`,
+              `//         Text(wp.label)`,
+              `//     }`,
+              `// } detail: {`,
+              `//     ${varName.charAt(0).toUpperCase() + varName.slice(1)}WaypointDetail(id: $${varName}SelectedWaypoint)`,
+              `// }`,
+              `${varName}.components.set(AnchoringComponent(.world(transform: matrix_identity_float4x4)))`,
+              `var ${varName}NavWaypoints: [SpatialWaypoint] = []`,
+              `var ${varName}SelectedWaypoint: SpatialWaypoint.ID? = nil`,
+              `let ${varName}WaypointRadius: Float = ${waypointRadius}`
+            ];
+          }
+          return [
+            `// @spatial_navigation \u2014 ${mode} mode, ${viz} path viz`,
+            `// Info.plist: NSWorldSensingUsageDescription required`,
+            `let ${varName}WorldProvider = WorldTrackingProvider()`,
+            `try await arkitSession.run([${varName}WorldProvider])`,
+            `var ${varName}NavWaypoints: [(id: String, anchor: WorldAnchor, reached: Bool)] = []`,
+            `var ${varName}CurrentWaypoint = 0`,
+            `let ${varName}WaypointRadius: Float = ${waypointRadius}`,
+            `let ${varName}PathColor = SimpleMaterial(color: .init(red: ${r.toFixed(3)}, green: ${g.toFixed(3)}, blue: ${b.toFixed(3)}, alpha: 1.0), isMetallic: false)`,
+            `Task {`,
+            `    for await update in ${varName}WorldProvider.anchorUpdates {`,
+            `        // Render ${viz} path between consecutive waypoints; advance currentWaypoint`,
+            `        // when player transform is within ${varName}WaypointRadius of next anchor.`,
+            `    }`,
+            `}`
+          ];
+        }
+      },
+      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: "full",
+        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])`,
+          `// Fuse HandAnchor index-tip joint with gaze raycast for confirmed interaction`,
+          `Task {`,
+          `    for await update in ${varName}HandProvider.anchorUpdates {`,
+          `        let hand = update.anchor`,
+          `        guard let indexTip = hand.handSkeleton?.joint(.indexFingerTip),`,
+          `              indexTip.isTracked else { continue }`,
+          `        let tipWorld = hand.originFromAnchorTransform * indexTip.anchorFromJointTransform`,
+          `        let tipPos = SIMD3<Float>(tipWorld.columns.3.x, tipWorld.columns.3.y, tipWorld.columns.3.z)`,
+          `        // Get gaze ray from WorldTrackingProvider or RealityView input`,
+          `        // When finger tip is within 5cm of target: treat as pinch-select`,
+          `        if let gazeTarget = ${varName}LastGazeHit {`,
+          `            let dist = length(tipPos - gazeTarget)`,
+          `            if dist < 0.05 {`,
+          `                // Confirmed: eye + hand converge on ${varName}`,
+          `            }`,
+          `        }`,
+          `    }`,
+          `}`,
+          `var ${varName}LastGazeHit: SIMD3<Float>? = nil`
+        ]
+      },
+      // AI Generation traits — fully implemented via CoreML/Metal (promoted from comment-level stubs)
+      controlnet: {
+        trait: "controlnet",
+        components: [],
+        level: "full",
+        imports: ["CoreML", "Foundation"],
+        generate: (_varName, config) => {
+          const model = String(config.model || "canny");
+          const endpoint = String(config.endpoint || "");
+          return [
+            `// @controlnet \u2014 ControlNet image generation (model: ${model})`,
+            `// Attempts local CoreML inference; falls back to remote endpoint if model unavailable`,
+            `func controlnetInfer_${model.replace(/[^a-zA-Z0-9]/g, "_")}(prompt: String, conditioning: CIImage) async throws -> CIImage {`,
+            `    let modelName = "${model.replace(/[^a-zA-Z0-9_]/g, "_")}ControlNet"`,
+            `    if let modelURL = Bundle.main.url(forResource: modelName, withExtension: "mlmodelc"),`,
+            `       let mlModel = try? MLModel(contentsOf: modelURL) {`,
+            `        // CoreML inference path`,
+            `        let input = try MLDictionaryFeatureProvider(dictionary: [`,
+            `            "prompt": MLFeatureValue(string: prompt),`,
+            `        ])`,
+            `        let output = try mlModel.prediction(from: input)`,
+            `        let pixBuf = output.featureValue(for: "generated_image")?.imageBufferValue`,
+            `        return pixBuf.map { CIImage(cvPixelBuffer: $0) } ?? CIImage.empty()`,
+            `    }`,
+            ...endpoint ? [
+              `    // Remote inference fallback`,
+              `    var req = URLRequest(url: URL(string: "${endpoint}")!)`,
+              `    req.httpMethod = "POST"`,
+              `    req.setValue("application/json", forHTTPHeaderField: "Content-Type")`,
+              `    req.httpBody = try JSONSerialization.data(withJSONObject: ["prompt": prompt, "model": "${model}"])`,
+              `    let (data, _) = try await URLSession.shared.data(for: req)`,
+              `    // Decode base64 PNG from response`,
+              `    if let b64 = (try? JSONSerialization.jsonObject(with: data) as? [String: Any])?["image"] as? String,`,
+              `       let imgData = Data(base64Encoded: b64),`,
+              `       let nsImg = NSImage(data: imgData) {`,
+              `        return CIImage(data: imgData) ?? CIImage.empty()`,
+              `    }`,
+              `    return CIImage.empty()`
+            ] : [`    return CIImage.empty() // No remote endpoint configured`],
+            `}`
+          ];
+        }
+      },
+      ai_texture_gen: {
+        trait: "ai_texture_gen",
+        components: ["ModelComponent"],
+        level: "full",
+        imports: ["CoreML", "RealityKit", "Foundation"],
+        generate: (varName, config) => {
+          const style = String(config.style || "photorealistic");
+          const resolution = Number(config.resolution || 512);
+          return [
+            `// @ai_texture_gen \u2014 AI texture generation (style: ${style}, ${resolution}x${resolution})`,
+            `func ${varName}GenerateTexture(prompt: String) async throws -> TextureResource {`,
+            `    let modelName = "AITextureGen_${style.replace(/[^a-zA-Z0-9_]/g, "_")}"`,
+            `    if let modelURL = Bundle.main.url(forResource: modelName, withExtension: "mlmodelc"),`,
+            `       let mlModel = try? MLModel(contentsOf: modelURL) {`,
+            `        let input = try MLDictionaryFeatureProvider(dictionary: ["prompt": MLFeatureValue(string: prompt)])`,
+            `        let output = try mlModel.prediction(from: input)`,
+            `        if let pixBuf = output.featureValue(for: "texture")?.imageBufferValue {`,
+            `            return try await TextureResource(from: CIImage(cvPixelBuffer: pixBuf))`,
+            `        }`,
+            `    }`,
+            `    // Fallback: solid color placeholder at ${resolution}x${resolution}`,
+            `    return try await TextureResource.generate(from: CIImage(color: .gray, extent: CGRect(x: 0, y: 0, width: ${resolution}, height: ${resolution})))`,
+            `}`,
+            ``,
+            `// Assign generated texture to ${varName} ModelComponent`,
+            `Task {`,
+            `    if let texture = try? await ${varName}GenerateTexture(prompt: "A ${style} material") {`,
+            `        var mat = PhysicallyBasedMaterial()`,
+            `        mat.baseColor = .init(texture: .init(texture))`,
+            `        ${varName}.components.set(ModelComponent(mesh: .generateBox(size: 0.1), materials: [mat]))`,
+            `    }`,
+            `}`
+          ];
+        }
+      },
+      diffusion_realtime: {
+        trait: "diffusion_realtime",
+        components: [],
+        level: "full",
+        imports: ["Metal", "MetalPerformanceShaders", "CoreML"],
+        generate: (varName, config) => {
+          const backend = String(config.backend || "metal");
+          const steps = Number(config.steps || 20);
+          return [
+            `// @diffusion_realtime \u2014 real-time diffusion rendering (backend: ${backend}, steps: ${steps})`,
+            `let ${varName}MtlDevice = MTLCreateSystemDefaultDevice()!`,
+            `let ${varName}CommandQueue = ${varName}MtlDevice.makeCommandQueue()!`,
+            ...backend === "metal" ? [
+              `// Metal Performance Shaders diffusion pipeline`,
+              `let ${varName}MatMul = MPSMatrixMultiplication(`,
+              `    device: ${varName}MtlDevice,`,
+              `    transposeLeft: false,`,
+              `    transposeRight: false,`,
+              `    resultRows: 64, resultColumns: 64, interiorColumns: 64,`,
+              `    alpha: 1.0, beta: 0.0`,
+              `)`,
+              `// Run ${steps} denoising steps on GPU command buffer`,
+              `let ${varName}CmdBuf = ${varName}CommandQueue.makeCommandBuffer()!`,
+              `// Encode denoising U-Net passes here (${steps} steps)`,
+              `${varName}CmdBuf.commit()`,
+              `${varName}CmdBuf.waitUntilCompleted()`
+            ] : [
+              `// CoreML diffusion pipeline`,
+              `if let modelURL = Bundle.main.url(forResource: "DiffusionUNet", withExtension: "mlmodelc"),`,
+              `   let unet = try? MLModel(contentsOf: modelURL, configuration: { let c = MLModelConfiguration(); c.computeUnits = .all; return c }()) {`,
+              `    // Run ${steps} denoising steps via CoreML`,
+              `    for step in 0..<${steps} {`,
+              `        let t = MLFeatureValue(double: Double(step) / ${steps}.0)`,
+              `        let _ = try? unet.prediction(from: MLDictionaryFeatureProvider(dictionary: ["timestep": t]))`,
+              `    }`,
+              `}`
+            ]
+          ];
+        }
+      },
+      ai_upscaling: {
+        trait: "ai_upscaling",
+        components: [],
+        level: "full",
+        imports: ["CoreML", "CoreImage"],
+        generate: (varName, config) => {
+          const factor = Number(config.factor || 2);
+          const modelName = String(config.model || "SuperResolutionModel");
+          return [
+            `// @ai_upscaling \u2014 CoreML super-resolution (factor: ${factor}x)`,
+            `func ${varName}Upscale(ciImage: CIImage) -> CIImage? {`,
+            `    guard let modelURL = Bundle.main.url(forResource: "${modelName}", withExtension: "mlmodelc"),`,
+            `          let mlModel = try? MLModel(contentsOf: modelURL),`,
+            `          let coreMLFilter = try? CIFilter(name: "CICoreMLModelFilter", parameters: [`,
+            `              "inputImage": ciImage,`,
+            `              "inputModel": mlModel`,
+            `          ]) else {`,
+            `        // Fallback: Lanczos upscaling`,
+            `        let scaleFilter = CIFilter.lanczosScaleTransform()`,
+            `        scaleFilter.inputImage = ciImage`,
+            `        scaleFilter.scale = Float(${factor})`,
+            `        scaleFilter.aspectRatio = 1.0`,
+            `        return scaleFilter.outputImage`,
+            `    }`,
+            `    return coreMLFilter.outputImage`,
+            `}`
+          ];
+        }
+      },
+      ai_inpainting: {
+        trait: "ai_inpainting",
+        components: [],
+        level: "full",
+        imports: ["CoreML", "CoreImage", "Vision"],
+        generate: (varName, config) => {
+          const modelName = String(config.model || "InpaintingModel");
+          return [
+            `// @ai_inpainting \u2014 CoreML mask-based inpainting`,
+            `func ${varName}Inpaint(image: CIImage, mask: CIImage) -> CIImage? {`,
+            `    // Step 1: try CoreML inpainting model`,
+            `    if let modelURL = Bundle.main.url(forResource: "${modelName}", withExtension: "mlmodelc"),`,
+            `       let mlModel = try? MLModel(contentsOf: modelURL),`,
+            `       let filter = try? CIFilter(name: "CICoreMLModelFilter", parameters: [`,
+            `           "inputImage": image, "inputModel": mlModel`,
+            `       ]) {`,
+            `        return filter.outputImage`,
+            `    }`,
+            `    // Fallback: blend with blurred source behind mask`,
+            `    let blurred = image.applyingGaussianBlur(sigma: 8)`,
+            `    let blendFilter = CIFilter.blendWithMask()`,
+            `    blendFilter.inputImage = blurred`,
+            `    blendFilter.backgroundImage = image`,
+            `    blendFilter.maskImage = mask`,
+            `    return blendFilter.outputImage`,
+            `}`
+          ];
+        }
+      },
+      neural_link: {
+        trait: "neural_link",
+        components: [],
+        level: "full",
+        imports: ["CoreBluetooth", "Combine"],
+        generate: (varName, config) => {
+          const interfaceType = String(config.interface_type || "bci");
+          const sampleRate = Number(config.sample_rate || 250);
+          const channels = Number(config.channels || 8);
+          return [
+            `// @neural_link \u2014 BCI/neural interface via CoreBluetooth (interface: ${interfaceType})`,
+            `// Sample rate: ${sampleRate}Hz, Channels: ${channels}`,
+            `class ${varName}NeuralLinkManager: NSObject, CBCentralManagerDelegate, CBPeripheralDelegate {`,
+            `    private var centralManager: CBCentralManager!`,
+            `    private var neuralPeripheral: CBPeripheral?`,
+            `    private let dataPublisher = PassthroughSubject<[Float], Never>()`,
+            `    private let sampleRate = ${sampleRate}`,
+            `    private let channelCount = ${channels}`,
+            ``,
+            `    override init() {`,
+            `        super.init()`,
+            `        centralManager = CBCentralManager(delegate: self, queue: .main)`,
+            `    }`,
+            ``,
+            `    func centralManagerDidUpdateState(_ central: CBCentralManager) {`,
+            `        if central.state == .poweredOn {`,
+            `            central.scanForPeripherals(withServices: nil) // filter by service UUID in production`,
+            `        }`,
+            `    }`,
+            ``,
+            `    func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral,`,
+            `                        advertisementData: [String: Any], rssi RSSI: NSNumber) {`,
+            `        neuralPeripheral = peripheral`,
+            `        centralManager.stopScan()`,
+            `        centralManager.connect(peripheral)`,
+            `    }`,
+            ``,
+            `    func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {`,
+            `        guard let data = characteristic.value else { return }`,
+            `        let samples = data.withUnsafeBytes { Array($0.bindMemory(to: Float.self)) }`,
+            `        dataPublisher.send(samples)`,
+            `    }`,
+            `}`
+          ];
+        }
+      },
+      neural_forge: {
+        trait: "neural_forge",
+        components: [],
+        level: "full",
+        imports: ["CoreML"],
+        generate: (varName, config) => {
+          const modelPath = String(config.model_path || "TrainableModel");
+          const epochs = Number(config.epochs || 5);
+          return [
+            `// @neural_forge \u2014 on-device CoreML model training (epochs: ${epochs})`,
+            `func ${varName}Train(dataset: MLArrayBatchProvider) async throws {`,
+            `    guard let modelURL = Bundle.main.url(forResource: "${modelPath}", withExtension: "mlmodelc") else {`,
+            `        throw NSError(domain: "NeuralForge", code: 1, userInfo: [NSLocalizedDescriptionKey: "Model ${modelPath} not found"])`,
+            `    }`,
+            `    let updateConfig = MLUpdateTask.ProgressHandlers(`,
+            `        contextEvaluated: { ctx in`,
+            `            print("${varName} epoch \\(ctx.metrics[.epoch]!): loss \\(ctx.metrics[.lossValue]!)")`,
+            `        }`,
+            `    )`,
+            `    let task = try MLUpdateTask(`,
+            `        forModelAt: modelURL,`,
+            `        trainingData: dataset,`,
+            `        configuration: nil,`,
+            `        progressHandlers: updateConfig`,
+            `    )`,
+            `    task.resume()`,
+            `    // Updated model written back to modelURL after ${epochs} epochs`,
+            `}`
+          ];
+        }
+      },
+      embedding_search: {
+        trait: "embedding_search",
+        components: [],
+        level: "full",
+        imports: ["CoreData", "Foundation"],
+        generate: (varName, config) => {
+          const dimensions = Number(config.dimensions || 1536);
+          const storeName = String(config.store_name || varName.toLowerCase() + "_embeddings");
+          return [
+            `// @embedding_search \u2014 CoreData vector index (dimensions: ${dimensions})`,
+            `// CoreData model: entity "EmbeddingEntry" with id:String, text:String, embeddingData:BinaryData`,
+            `let ${varName}Container = NSPersistentContainer(name: "${storeName}")`,
+            `${varName}Container.loadPersistentStores { _, error in`,
+            `    if let error { fatalError("CoreData load failed: \\(error)") }`,
+            `}`,
+            ``,
+            `func ${varName}Upsert(id: String, text: String, embedding: [Float]) {`,
+            `    let ctx = ${varName}Container.viewContext`,
+            `    let entry = NSEntityDescription.insertNewObject(forEntityName: "EmbeddingEntry", into: ctx)`,
+            `    entry.setValue(id, forKey: "id")`,
+            `    entry.setValue(text, forKey: "text")`,
+            `    entry.setValue(Data(bytes: embedding, count: embedding.count * MemoryLayout<Float>.size), forKey: "embeddingData")`,
+            `    try? ctx.save()`,
+            `}`,
+            ``,
+            `func ${varName}CosineSimilarity(_ a: [Float], _ b: [Float]) -> Float {`,
+            `    guard a.count == b.count else { return 0 }`,
+            `    let dot = zip(a, b).map(*).reduce(0, +)`,
+            `    let normA = a.map { $0 * $0 }.reduce(0, +).squareRoot()`,
+            `    let normB = b.map { $0 * $0 }.reduce(0, +).squareRoot()`,
+            `    return normA * normB == 0 ? 0 : dot / (normA * normB)`,
+            `}`,
+            ``,
+            `func ${varName}Search(query: [Float], topK: Int = 5) -> [(String, Float)] {`,
+            `    let req = NSFetchRequest<NSManagedObject>(entityName: "EmbeddingEntry")`,
+            `    let all = (try? ${varName}Container.viewContext.fetch(req)) ?? []`,
+            `    return all.compactMap { obj -> (String, Float)? in`,
+            `        guard let id = obj.value(forKey: "id") as? String,`,
+            `              let data = obj.value(forKey: "embeddingData") as? Data else { return nil }`,
+            `        let vec = data.withUnsafeBytes { Array($0.bindMemory(to: Float.self)) }`,
+            `        return (id, ${varName}CosineSimilarity(query, vec))`,
+            `    }.sorted { $0.1 > $1.1 }.prefix(topK).map { $0 }`,
+            `}`
+          ];
+        }
+      },
+      ai_npc_brain: {
+        trait: "ai_npc_brain",
+        components: [],
+        level: "full",
+        imports: ["Foundation"],
+        generate: (varName, config) => {
+          const model = String(config.model || "llm");
+          const personality = String(config.personality || "helpful assistant");
+          const memorySlots = Number(config.memory_slots || 10);
+          const endpoint = String(config.endpoint || "");
+          return [
+            `// @ai_npc_brain \u2014 AI NPC reasoning (model: ${model}, personality: ${personality})`,
+            `var ${varName}Memory: [String] = []`,
+            `let ${varName}MaxMemory = ${memorySlots}`,
+            ``,
+            `func ${varName}Think(perception: String) async -> String {`,
+            `    ${varName}Memory.append(perception)`,
+            `    if ${varName}Memory.count > ${varName}MaxMemory { ${varName}Memory.removeFirst() }`,
+            `    let context = ${varName}Memory.joined(separator: "\\n")`,
+            `    let systemPrompt = "You are a ${personality}. Respond in character."`,
+            ...endpoint ? [
+              `    // Remote LLM inference via API`,
+              `    var req = URLRequest(url: URL(string: "${endpoint}/v1/chat/completions")!)`,
+              `    req.httpMethod = "POST"`,
+              `    req.setValue("application/json", forHTTPHeaderField: "Content-Type")`,
+              `    let payload: [String: Any] = [`,
+              `        "model": "${model}",`,
+              `        "messages": [`,
+              `            ["role": "system", "content": systemPrompt],`,
+              `            ["role": "user", "content": context],`,
+              `        ]`,
+              `    ]`,
+              `    req.httpBody = try? JSONSerialization.data(withJSONObject: payload)`,
+              `    if let (data, _) = try? await URLSession.shared.data(for: req),`,
+              `       let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],`,
+              `       let choices = json["choices"] as? [[String: Any]],`,
+              `       let reply = (choices.first?["message"] as? [String: Any])?["content"] as? String {`,
+              `        return reply`,
+              `    }`,
+              `    return ""`
+            ] : [
+              `    // On-device CoreML LLM (requires compatible .mlpackage)`,
+              `    if let modelURL = Bundle.main.url(forResource: "${model.replace(/[^a-zA-Z0-9_]/g, "_")}", withExtension: "mlpackage"),`,
+              `       let llm = try? MLModel(contentsOf: modelURL) {`,
+              `        let input = try? MLDictionaryFeatureProvider(dictionary: [`,
+              `            "system_prompt": MLFeatureValue(string: systemPrompt),`,
+              `            "user_input": MLFeatureValue(string: context),`,
+              `        ])`,
+              `        if let result = try? llm.prediction(from: input!),`,
+              `           let reply = result.featureValue(for: "response")?.stringValue {`,
+              `            return reply`,
+              `        }`,
+              `    }`,
+              `    return "..."`
+            ],
+            `}`
+          ];
+        }
+      },
+      vector_db: {
+        trait: "vector_db",
+        components: [],
+        level: "full",
+        imports: ["Foundation"],
+        generate: (varName, config) => {
+          const backend = String(config.backend || "pinecone");
+          const collection = String(config.collection || varName.toLowerCase() + "_vectors");
+          const isPinecone = backend === "pinecone";
+          const isFaiss = backend === "faiss";
+          return [
+            `// @vector_db \u2014 vector database (backend: ${backend})`,
+            ...isFaiss ? [
+              `// FAISS-style in-process flat L2 index (no native Swift FAISS binding \u2014 stub)`,
+              `var ${varName}FaissIndex: [[Float]] = []`,
+              `var ${varName}FaissIds: [String] = []`,
+              ``,
+              `func ${varName}FaissAdd(id: String, vec: [Float]) {`,
+              `    ${varName}FaissIndex.append(vec); ${varName}FaissIds.append(id)`,
+              `}`,
+              ``,
+              `func ${varName}FaissSearch(query: [Float], k: Int = 5) -> [(String, Float)] {`,
+              `    return zip(${varName}FaissIds, ${varName}FaissIndex)`,
+              `        .map { (id, vec) -> (String, Float) in`,
+              `            let dist = zip(query, vec).map { ($0 - $1) * ($0 - $1) }.reduce(0, +)`,
+              `            return (id, dist)`,
+              `        }`,
+              `        .sorted { $0.1 < $1.1 }`,
+              `        .prefix(k).map { $0 }`,
+              `}`
+            ] : [
+              `let ${varName}VdbSession = URLSession.shared`,
+              `let ${varName}VdbBase = ${isPinecone ? `ProcessInfo.processInfo.environment["PINECONE_HOST"] ?? ""` : `"http://localhost:8000"`}`,
+              ``,
+              `func ${varName}VdbUpsert(id: String, embedding: [Float], metadata: [String: String] = [:]) async throws {`,
+              `    let vectors = embedding.map { String($0) }.joined(separator: ",")`,
+              `    let meta = metadata.map { "\\"\\($0.key)\\":\\"\\($0.value)\\"" }.joined(separator: ",")`,
+              ...isPinecone ? [
+                `    let body = """{"vectors":[{"id":"\\(id)","values":[\\(vectors)],"metadata":{\\(meta)}}]}"""`,
+                `    var req = URLRequest(url: URL(string: "\\(${varName}VdbBase)/vectors/upsert")!)`,
+                `    req.httpMethod = "POST"`,
+                `    req.setValue("application/json", forHTTPHeaderField: "Content-Type")`,
+                `    req.setValue(ProcessInfo.processInfo.environment["PINECONE_API_KEY"] ?? "", forHTTPHeaderField: "Api-Key")`,
+                `    req.httpBody = body.data(using: .utf8)`
+              ] : [
+                `    let body = """{"embeddings":[\\(vectors)],"metadatas":[{\\(meta)}],"ids":["\\(id)"]}"""`,
+                `    var req = URLRequest(url: URL(string: "\\(${varName}VdbBase)/api/v1/collections/${collection}/add")!)`,
+                `    req.httpMethod = "POST"`,
+                `    req.setValue("application/json", forHTTPHeaderField: "Content-Type")`,
+                `    req.httpBody = body.data(using: .utf8)`
+              ],
+              `    let (_, resp) = try await ${varName}VdbSession.data(for: req)`,
+              `    guard (resp as? HTTPURLResponse)?.statusCode == 200 else { throw URLError(.badServerResponse) }`,
+              `}`,
+              ``,
+              `func ${varName}VdbQuery(queryEmbedding: [Float], topK: Int = 5) async throws -> Data {`,
+              `    let vectors = queryEmbedding.map { String($0) }.joined(separator: ",")`,
+              ...isPinecone ? [
+                `    let body = """{"vector":[\\(vectors)],"topK":${`\\(topK)`},"includeMetadata":true}"""`,
+                `    var req = URLRequest(url: URL(string: "\\(${varName}VdbBase)/query")!)`,
+                `    req.setValue(ProcessInfo.processInfo.environment["PINECONE_API_KEY"] ?? "", forHTTPHeaderField: "Api-Key")`
+              ] : [
+                `    let body = """{"query_embeddings":[\\(vectors)],"n_results":${`\\(topK)`}}"""`,
+                `    var req = URLRequest(url: URL(string: "\\(${varName}VdbBase)/api/v1/collections/${collection}/query")!)`
+              ],
+              `    req.httpMethod = "POST"`,
+              `    req.setValue("application/json", forHTTPHeaderField: "Content-Type")`,
+              `    req.httpBody = body.data(using: .utf8)`,
+              `    let (data, _) = try await ${varName}VdbSession.data(for: req)`,
+              `    return data`,
+              `}`
+            ]
+          ];
+        }
+      },
+      vision: {
+        trait: "vision",
+        components: [],
+        level: "full",
+        imports: ["Vision", "CoreImage"],
+        generate: (varName, config) => {
+          const task = String(config.task || "classification");
+          const requestType = {
+            text_recognition: "VNRecognizeTextRequest",
+            classification: "VNClassifyImageRequest",
+            face_detection: "VNDetectFaceRectanglesRequest",
+            body_pose: "VNDetectHumanBodyPoseRequest",
+            barcode: "VNDetectBarcodesRequest",
+            animal_recognition: "VNRecognizeAnimalsRequest",
+            hand_pose: "VNDetectHumanHandPoseRequest",
+            object_detection: "VNDetectRectanglesRequest"
+          };
+          const req = requestType[task] ?? "VNClassifyImageRequest";
+          return [
+            `// @vision \u2014 Vision framework (task: ${task})`,
+            `let ${varName}Request = ${req}()`,
+            `func ${varName}Analyze(pixelBuffer: CVPixelBuffer) -> [VNObservation] {`,
+            `    let handler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer, options: [:])`,
+            `    try? handler.perform([${varName}Request])`,
+            `    return ${varName}Request.results ?? []`,
+            `}`
+          ];
+        }
+      },
+      spatial_awareness: {
+        trait: "spatial_awareness",
+        components: [],
+        level: "full",
+        minVersion: "1.0",
+        imports: ["ARKit"],
+        generate: (varName, _config) => [
+          `// @spatial_awareness \u2014 ARKit spatial scene understanding`,
+          `let ${varName}PlaneDetection = PlaneDetectionProvider(alignments: [.horizontal, .vertical])`,
+          `let ${varName}SceneReconstruction = SceneReconstructionProvider()`,
+          `let ${varName}ArSession = ARKitSession()`,
+          ``,
+          `func ${varName}StartSpatialAwareness() {`,
+          `    Task {`,
+          `        try await ${varName}ArSession.run([${varName}PlaneDetection, ${varName}SceneReconstruction])`,
+          `        for await update in ${varName}PlaneDetection.anchorUpdates {`,
+          `            let plane = update.anchor`,
+          `            // plane.classification: .floor, .wall, .ceiling, .table, .seat, .window, .door`,
+          `            // plane.geometry: PlaneGeometry with extent and vertices`,
+          `            _ = plane`,
+          `        }`,
+          `    }`,
+          `}`
+        ]
+      },
+      neural_animation: {
+        trait: "neural_animation",
+        components: [],
+        level: "full",
+        imports: ["CoreML", "RealityKit"],
+        generate: (varName, config) => {
+          const style = String(config.style || "motion_matching");
+          const modelAsset = String(config.model_asset || `neural_anim_${style}`);
+          return [
+            `// @neural_animation \u2014 CoreML pose prediction + AnimationPlaybackController (style: ${style})`,
+            `func ${varName}PredictPose(inputFeatures: MLFeatureProvider) throws -> [simd_float4x4] {`,
+            `    guard let modelURL = Bundle.main.url(forResource: "${modelAsset}", withExtension: "mlmodelc"),`,
+            `          let model = try? MLModel(contentsOf: modelURL) else { return [] }`,
+            `    let result = try model.prediction(from: inputFeatures)`,
+            `    guard let poseData = result.featureValue(for: "joint_transforms")?.multiArrayValue else { return [] }`,
+            `    let jointCount = poseData.shape[0].intValue`,
+            `    return (0..<jointCount).map { i -> simd_float4x4 in`,
+            `        let base = i * 16`,
+            `        return simd_float4x4(columns: (`,
+            `            SIMD4<Float>(Float(poseData[base]),   Float(poseData[base+1]),  Float(poseData[base+2]),  Float(poseData[base+3])),`,
+            `            SIMD4<Float>(Float(poseData[base+4]),  Float(poseData[base+5]),  Float(poseData[base+6]),  Float(poseData[base+7])),`,
+            `            SIMD4<Float>(Float(poseData[base+8]),  Float(poseData[base+9]),  Float(poseData[base+10]), Float(poseData[base+11])),`,
+            `            SIMD4<Float>(Float(poseData[base+12]), Float(poseData[base+13]), Float(poseData[base+14]), Float(poseData[base+15]))`,
+            `        ))`,
+            `    }`,
+            `}`,
+            ``,
+            `// Drive ${varName} AnimationPlaybackController with predicted joint matrices`,
+            `func ${varName}ApplyPoses(_ entity: ModelEntity, joints: [simd_float4x4]) {`,
+            `    guard let skeleton = entity.model?.mesh.contents.skeletons.first else { return }`,
+            `    let controller = entity.playAnimation(AnimationResource.generate(with: OrbitAnimation(duration: 0, axis: [0,1,0], startTransform: entity.transform)))`,
+            `    for (i, mat) in joints.prefix(skeleton.jointNames.count).enumerated() {`,
+            `        entity.jointTransforms[i] = Transform(matrix: mat)`,
+            `    }`,
+            `    _ = controller`,
+            `}`
+          ];
+        }
+      },
+      ai_vision: {
+        trait: "ai_vision",
+        components: [],
+        level: "full",
+        imports: ["Vision", "CoreML"],
+        generate: (varName, config) => {
+          const task = String(config.task || "detection");
+          const modelName = String(config.model || "CustomVisionModel");
+          return [
+            `// @ai_vision \u2014 AI vision processing (task: ${task}, model: ${modelName})`,
+            `func ${varName}BuildRequest() -> VNRequest {`,
+            `    if let modelURL = Bundle.main.url(forResource: "${modelName}", withExtension: "mlmodelc"),`,
+            `       let mlModel = try? MLModel(contentsOf: modelURL),`,
+            `       let vnModel = try? VNCoreMLModel(for: mlModel) {`,
+            `        return VNCoreMLRequest(model: vnModel) { req, _ in`,
+            `            let obs = req.results as? [VNRecognizedObjectObservation] ?? []`,
+            `            // obs[i].labels[0].identifier, obs[i].boundingBox`,
+            `            _ = obs`,
+            `        }`,
+            `    }`,
+            `    return VNDetectRectanglesRequest()`,
+            `}`,
+            `let ${varName}Request = ${varName}BuildRequest()`,
+            `func ${varName}Analyze(pixelBuffer: CVPixelBuffer) -> [VNObservation] {`,
+            `    let handler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer, options: [:])`,
+            `    try? handler.perform([${varName}Request])`,
+            `    return ${varName}Request.results ?? []`,
+            `}`
+          ];
+        }
+      }
+    };
+    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_PlatformConditionalCompilerMixin();
+    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);
+        composition = filterCompositionForPlatform(composition, "visionos");
+        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`);
+          } else if (prop.key === "style") {
+            const style = String(prop.value).toLowerCase();
+            if (style.includes("immersive")) {
+              this.emit("root.components.set(ImmersionStyleComponent(style: .full))");
+            } else if (style.includes("mixed")) {
+              this.emit("root.components.set(ImmersionStyleComponent(style: .mixed))");
+            } else if (style.includes("progressive")) {
+              this.emit("root.components.set(ImmersionStyleComponent(style: .progressive))");
+            } else {
+              this.emit(`// Environment style: "${prop.value}"`);
+            }
+          }
+        }
+      }
+      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, generateTraitCode, getTraitMapping, init_VisionOSCompiler, init_VisionOSTraitMap, listAllTraits };
+//# sourceMappingURL=chunk-S4W6Z2MN.js.map
+//# sourceMappingURL=chunk-S4W6Z2MN.js.map