@holoscript/core 8.0.8 → 8.0.9

package/dist/{chunk-SH5PPVK7.cjs → chunk-NQN5LFN4.cjs}

@@ -1,15 +1,15 @@
 'use strict';
 
-var chunkFEWUHQNM_cjs = require('./chunk-FEWUHQNM.cjs');
-var chunkEBS32AJI_cjs = require('./chunk-EBS32AJI.cjs');
-var chunkGH6C2QGW_cjs = require('./chunk-GH6C2QGW.cjs');
-var chunkLODTHGST_cjs = require('./chunk-LODTHGST.cjs');
-var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var chunkCFVK26P4_cjs = require('./chunk-CFVK26P4.cjs');
+var chunkTZCFKZ6Z_cjs = require('./chunk-TZCFKZ6Z.cjs');
+var chunkQEDMOGF3_cjs = require('./chunk-QEDMOGF3.cjs');
+var chunkZK7KX5CD_cjs = require('./chunk-ZK7KX5CD.cjs');
+var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
 var ans = require('@holoscript/core-types/ans');
 
 // src/compiler/AndroidXRTraitDispatch.ts
 var WorldPhysicsConfig, PHYSICS_TRAIT_MAP, INTERACTION_TRAIT_MAP, AUDIO_TRAIT_MAP, AR_TRAIT_MAP, ACCESSIBILITY_TRAIT_MAP, UI_TRAIT_MAP, ENVIRONMENT_TRAIT_MAP, DP3_TRAIT_MAP, GLASSES_TRAIT_MAP, MULTIPLAYER_TRAIT_MAP;
-var init_AndroidXRTraitDispatch = chunkHCCQLAA4_cjs.__esm({
+var init_AndroidXRTraitDispatch = chunkZHPMP447_cjs.__esm({
   "src/compiler/AndroidXRTraitDispatch.ts"() {
     WorldPhysicsConfig = {
       EARTH: { gravity: -9.81 },
@@ -2141,7 +2141,7 @@ var init_AndroidXRTraitDispatch = chunkHCCQLAA4_cjs.__esm({
 
 // src/compiler/AndroidXRCodeTemplates.ts
 var VISUAL_TRAIT_MAP, V43_TRAIT_MAP, AI_TRAIT_MAP;
-var init_AndroidXRCodeTemplates = chunkHCCQLAA4_cjs.__esm({
+var init_AndroidXRCodeTemplates = chunkZHPMP447_cjs.__esm({
   "src/compiler/AndroidXRCodeTemplates.ts"() {
     VISUAL_TRAIT_MAP = {
       visible: {
@@ -3864,7 +3864,7 @@ function generateTraitCode(traitName, varName, config) {
   return mapping.generate(varName, config);
 }
 exports.ANDROIDXR_TRAIT_MAP = void 0;
-var init_AndroidXRTraitMap = chunkHCCQLAA4_cjs.__esm({
+var init_AndroidXRTraitMap = chunkZHPMP447_cjs.__esm({
   "src/compiler/AndroidXRTraitMap.ts"() {
     init_AndroidXRTraitDispatch();
     init_AndroidXRCodeTemplates();
@@ -4005,6 +4005,33 @@ function compileAction(compiler, action) {
   compiler.emit("}");
   compiler.emit("");
 }
+function kotlinFloat(value) {
+  return `${value}f`;
+}
+function isNumberArray(value) {
+  return Array.isArray(value) && value.length > 0 && value.every((v) => typeof v === "number");
+}
+function toXRVector3(value) {
+  if (isNumberArray(value)) {
+    const [x, y = x, z = x] = value;
+    return `Vector3(${kotlinFloat(x)}, ${kotlinFloat(y)}, ${kotlinFloat(z)})`;
+  }
+  if (typeof value === "number") {
+    return `Vector3(${kotlinFloat(value)}, ${kotlinFloat(value)}, ${kotlinFloat(value)})`;
+  }
+  return "Vector3(0f, 0f, 0f)";
+}
+function toXRPose(value) {
+  return `Pose(${toXRVector3(value)}, Quaternion.Identity)`;
+}
+function xrEntityCreate(compiler, sessionVar, name, poseValue) {
+  return `Entity.create(${sessionVar}, "${compiler.escapeStringValue(name, "Kotlin")}", ${toXRPose(poseValue)})`;
+}
+function emitScale(compiler, target, scale) {
+  if (isNumberArray(scale) || typeof scale === "number") {
+    compiler.emit(`${target}.setScale(${toXRVector3(scale)})`);
+  }
+}
 function generateNodeFactoryFile(compiler, composition) {
   compiler.lines = [];
   compiler.indentLevel = 0;
@@ -4017,7 +4044,7 @@ function generateNodeFactoryFile(compiler, composition) {
   compiler.emit(`package ${pkg}`);
   compiler.emit("");
   compiler.emit("import android.net.Uri");
-  compiler.emit("import androidx.xr.scenecore.Session as XRSession");
+  compiler.emit("import androidx.xr.runtime.Session as XRSession");
   compiler.emit("import androidx.xr.scenecore.Entity");
   compiler.emit("import androidx.xr.scenecore.GltfModel");
   compiler.emit("import androidx.xr.scenecore.GltfModelEntity");
@@ -4030,41 +4057,24 @@ function generateNodeFactoryFile(compiler, composition) {
   compiler.emit("/**");
   compiler.emit(" * Create a default entity in the XR scene.");
   compiler.emit(" */");
-  compiler.emit("fun createDefaultEntity(session: XRSession): Entity {");
+  compiler.emit("suspend fun createDefaultEntity(session: XRSession): Entity {");
   compiler.indent();
   if (composition.objects?.length) {
     const firstObj = composition.objects[0];
     const modelSrc = compiler.findProp(firstObj, "model") ?? compiler.findProp(firstObj, "src");
+    const pos = compiler.findProp(firstObj, "position");
     if (modelSrc) {
       compiler.emit(`val gltfModel = GltfModel.create(session, Uri.parse("${modelSrc}"))`);
-      compiler.emit("return GltfModelEntity.create(session, gltfModel).apply {");
-      compiler.indent();
-      compiler.emit("parent = session.scene.activitySpace");
-      const pos = compiler.findProp(firstObj, "position");
-      if (pos && Array.isArray(pos)) {
-        compiler.emit(
-          `setPose(Pose(${compiler.toKotlinFloat3(pos)}, Quaternion.identity()))`
-        );
-      }
-      compiler.dedent();
-      compiler.emit("}");
+      compiler.emit(
+        `return GltfModelEntity.create(session, gltfModel, ${toXRPose(pos)})`
+      );
     } else {
       compiler.emit(
-        `val entity = session.scene.createEntity("${compiler.escapeStringValue(firstObj.name, "Kotlin")}")`
+        `return ${xrEntityCreate(compiler, "session", firstObj.name, pos)}`
       );
-      compiler.emit("entity.parent = session.scene.activitySpace");
-      const pos = compiler.findProp(firstObj, "position");
-      if (pos && Array.isArray(pos)) {
-        compiler.emit(
-          `entity.setPose(Pose(${compiler.toKotlinFloat3(pos)}, Quaternion.identity()))`
-        );
-      }
-      compiler.emit("return entity");
     }
   } else {
-    compiler.emit('val entity = session.scene.createEntity("default")');
-    compiler.emit("entity.parent = session.scene.activitySpace");
-    compiler.emit("return entity");
+    compiler.emit(`return ${xrEntityCreate(compiler, "session", "default")}`);
   }
   compiler.dedent();
   compiler.emit("}");
@@ -4072,7 +4082,7 @@ function generateNodeFactoryFile(compiler, composition) {
   compiler.emit("/**");
   compiler.emit(" * Load a glTF model and create a GltfModelEntity.");
   compiler.emit(" */");
-  compiler.emit("fun loadGltfModel(");
+  compiler.emit("suspend fun loadGltfModel(");
   compiler.indent();
   compiler.emit("session: XRSession,");
   compiler.emit("modelUri: String,");
@@ -4082,11 +4092,15 @@ function generateNodeFactoryFile(compiler, composition) {
   compiler.emit("): GltfModelEntity {");
   compiler.indent();
   compiler.emit("val gltfModel = GltfModel.create(session, Uri.parse(modelUri))");
-  compiler.emit("return GltfModelEntity.create(session, gltfModel).apply {");
+  compiler.emit("return GltfModelEntity.create(");
+  compiler.indent();
+  compiler.emit("session,");
+  compiler.emit("gltfModel,");
+  compiler.emit("Pose(position, Quaternion.Identity)");
+  compiler.dedent();
+  compiler.emit(").apply {");
   compiler.indent();
-  compiler.emit("parent = session.scene.activitySpace");
-  compiler.emit("setPose(Pose(position, Quaternion.identity()))");
-  compiler.emit("setScale(com.google.android.filament.utils.Float3(scale, scale, scale))");
+  compiler.emit("setScale(Vector3(scale, scale, scale))");
   compiler.dedent();
   compiler.emit("}");
   compiler.dedent();
@@ -4102,48 +4116,26 @@ function generateNodeFactoryFile(compiler, composition) {
 function compileObjectFactory(compiler, obj) {
   const methodName = `create${compiler.sanitizeName(obj.name).charAt(0).toUpperCase() + compiler.sanitizeName(obj.name).slice(1)}`;
   const modelSrc = compiler.findProp(obj, "model") ?? compiler.findProp(obj, "src");
-  compiler.emit(`fun ${methodName}(session: XRSession): Entity {`);
+  const pos = compiler.findProp(obj, "position");
+  const scale = compiler.findProp(obj, "scale");
+  compiler.emit(`${modelSrc ? "suspend " : ""}fun ${methodName}(session: XRSession): Entity {`);
   compiler.indent();
   if (modelSrc) {
     compiler.emit(`val gltfModel = GltfModel.create(session, Uri.parse("${modelSrc}"))`);
-    compiler.emit("return GltfModelEntity.create(session, gltfModel).apply {");
+    compiler.emit("return GltfModelEntity.create(");
     compiler.indent();
-    compiler.emit("parent = session.scene.activitySpace");
-    const pos = compiler.findProp(obj, "position");
-    if (pos && Array.isArray(pos)) {
-      compiler.emit(
-        `setPose(Pose(${compiler.toKotlinFloat3(pos)}, Quaternion.identity()))`
-      );
-    }
-    const scale = compiler.findProp(obj, "scale");
-    if (scale && Array.isArray(scale)) {
-      compiler.emit(`setScale(${compiler.toKotlinFloat3(scale)})`);
-    } else if (typeof scale === "number") {
-      compiler.emit(
-        `setScale(com.google.android.filament.utils.Float3(${scale}f, ${scale}f, ${scale}f))`
-      );
-    }
+    compiler.emit("session,");
+    compiler.emit("gltfModel,");
+    compiler.emit(`${toXRPose(pos)}`);
+    compiler.dedent();
+    compiler.emit(").apply {");
+    compiler.indent();
+    emitScale(compiler, "this", scale);
     compiler.dedent();
     compiler.emit("}");
   } else {
-    compiler.emit(
-      `val entity = session.scene.createEntity("${compiler.escapeStringValue(obj.name, "Kotlin")}")`
-    );
-    compiler.emit("entity.parent = session.scene.activitySpace");
-    const pos = compiler.findProp(obj, "position");
-    if (pos && Array.isArray(pos)) {
-      compiler.emit(
-        `entity.setPose(Pose(${compiler.toKotlinFloat3(pos)}, Quaternion.identity()))`
-      );
-    }
-    const scale = compiler.findProp(obj, "scale");
-    if (scale && Array.isArray(scale)) {
-      compiler.emit(`entity.setScale(${compiler.toKotlinFloat3(scale)})`);
-    } else if (typeof scale === "number") {
-      compiler.emit(
-        `entity.setScale(com.google.android.filament.utils.Float3(${scale}f, ${scale}f, ${scale}f))`
-      );
-    }
+    compiler.emit(`val entity = ${xrEntityCreate(compiler, "session", obj.name, pos)}`);
+    emitScale(compiler, "entity", scale);
     compiler.emit("return entity");
   }
   compiler.dedent();
@@ -4151,7 +4143,6 @@ function compileObjectFactory(compiler, obj) {
   compiler.emit("");
 }
 function generateManifestFile(compiler, composition) {
-  const pkg = compiler.options.packageName;
   const activityName = compiler.options.activityName;
   const hasHandTracking = composition.objects?.some(
     (o) => o.traits?.some((t) => t.name === "hand_tracking")
@@ -4192,8 +4183,7 @@ function generateManifestFile(compiler, composition) {
   const arCameraFeatureLine = needsArCameraFeature ? `    <uses-feature android:name="android.hardware.camera.ar" android:required="${arRequired}" />` : "";
   return `<?xml version="1.0" encoding="utf-8"?>
 <!-- Auto-generated by HoloScript AndroidXRCompiler -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="${pkg}">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
     <!-- XR Permissions -->
 ${xrPermissions.join("\n")}
@@ -4288,15 +4278,14 @@ dependencies {
     implementation("androidx.compose.material3:material3")
     implementation("androidx.compose.runtime:runtime")
 
-    // Android XR - Jetpack XR SceneCore
-    implementation("androidx.xr.scenecore:scenecore:1.0.0-alpha01")
-    implementation("androidx.xr.compose:compose:1.0.0-alpha01")
-
-    // Android XR - ARCore for Jetpack XR
-    implementation("androidx.xr.arcore:arcore:1.0.0-alpha01")
-
-    // Android XR - Runtime
-    implementation("androidx.xr:xr:1.0.0-alpha01")
+    // Android XR \u2014 Jetpack XR SceneCore + Compose for XR + ARCore + Runtime.
+    // Real published coordinates (verified against dl.google.com Maven group indexes); pinned to a
+    // consistent alpha15 present in all four groups. NOTE: 'androidx.xr:xr' is NOT a published
+    // artifact (it broke dependency resolution) \u2014 the runtime impl is 'androidx.xr.runtime:runtime'.
+    implementation("androidx.xr.scenecore:scenecore:1.0.0-alpha15")
+    implementation("androidx.xr.compose:compose:1.0.0-alpha15")
+    implementation("androidx.xr.arcore:arcore:1.0.0-alpha15")
+    implementation("androidx.xr.runtime:runtime:1.0.0-alpha15")
 
     // Filament (PBR Rendering)
     implementation("com.google.android.filament:filament-android:1.51.0")
@@ -4330,7 +4319,10 @@ function emitImports(compiler, composition) {
   compiler.emit("import androidx.xr.compose.subspace.layout.*");
   compiler.emit("");
   compiler.emit("import androidx.xr.scenecore.Entity");
-  compiler.emit("import androidx.xr.scenecore.Session as XRSession");
+  compiler.emit("import androidx.xr.runtime.Session as XRSession");
+  if (compiler.options.useARCore) {
+    compiler.emit("import androidx.xr.runtime.Config");
+  }
   compiler.emit("import androidx.xr.scenecore.GltfModel");
   compiler.emit("import androidx.xr.scenecore.GltfModelEntity");
   compiler.emit("import androidx.xr.scenecore.SurfaceEntity");
@@ -4339,14 +4331,8 @@ function emitImports(compiler, composition) {
   compiler.emit("import androidx.xr.runtime.math.Vector3");
   compiler.emit("import androidx.xr.runtime.math.Quaternion");
   compiler.emit("");
-  if (compiler.options.useARCore) {
-    compiler.emit("import com.google.ar.core.Config");
-    compiler.emit("import com.google.ar.core.Plane");
-    compiler.emit("import com.google.ar.core.Anchor");
-  }
   if (compiler.options.useFilament) {
     compiler.emit("import com.google.android.filament.LightManager");
-    compiler.emit("import com.google.android.filament.utils.Float3");
   }
   const hasHandTracking = composition.objects?.some(
     (o) => o.traits?.some((t) => t.name === "hand_tracking")
@@ -4406,7 +4392,7 @@ function emitActivityClass(compiler, composition) {
   compiler.emit("override fun onCreate(savedInstanceState: Bundle?) {");
   compiler.indent();
   compiler.emit("super.onCreate(savedInstanceState)");
-  compiler.emit("xrSession = XRSession.create(this)");
+  compiler.emit("xrSession = XRSession(this)");
   if (compiler.options.useARCore) {
     compiler.emit("");
     emitARSession(compiler);
@@ -4469,14 +4455,7 @@ function emitAITraitHelpers(compiler, composition) {
   }
 }
 function emitARSession(compiler) {
-  compiler.emit("xrSession.scene.configure { config ->");
-  compiler.indent();
-  compiler.emit("config.planeFindingMode = Config.PlaneFindingMode.HORIZONTAL_AND_VERTICAL");
-  compiler.emit("config.lightEstimationMode = Config.LightEstimationMode.ENVIRONMENTAL_HDR");
-  compiler.emit("config.depthMode = Config.DepthMode.AUTOMATIC");
-  compiler.emit("config.updateMode = Config.UpdateMode.LATEST_CAMERA_IMAGE");
-  compiler.dedent();
-  compiler.emit("}");
+  compiler.emit("xrSession.configure(Config())");
 }
 function emitSceneComposable(compiler, composition) {
   const name = compiler.sanitizeName(composition.name);
@@ -4497,7 +4476,7 @@ function emitSceneComposable(compiler, composition) {
   if (composition.camera) emitCamera(compiler, composition.camera);
   for (const l of composition.lights ?? []) emitLight(compiler, l);
   if (composition.objects?.some((o) => o.traits?.some((t) => t.name === "environment_probe"))) {
-    compiler.emit("val sceneRoot = xrSession.scene.activitySpace");
+    compiler.emit("// Environment probe runtime anchor is resolved after capability checks.");
   }
   for (const o of composition.objects ?? []) {
     const hasHeadFollow = o.traits?.some(
@@ -4531,14 +4510,10 @@ function emitEnvironment(compiler, env) {
   for (const prop of env.properties) {
     if (prop.key === "preset" || prop.key === "skybox") {
       compiler.emit(`// Preset: "${prop.value}"`);
-      compiler.emit("xrSession.scene.configure { config ->");
-      compiler.indent();
-      compiler.emit("config.lightEstimationMode = Config.LightEstimationMode.ENVIRONMENTAL_HDR");
-      compiler.dedent();
-      compiler.emit("}");
+      compiler.emit("// Scene lighting is resolved by the Android XR runtime.");
     } else if (prop.key === "passthrough") {
       if (prop.value === true || prop.value === "true") {
-        compiler.emit("xrSession.scene.configure { it.focusMode = Config.FocusMode.AUTO }");
+        compiler.emit("// Passthrough requested; device policy controls camera focus.");
       }
     } else if (prop.key === "fog" && typeof prop.value === "object") {
       compiler.emit(`// Fog: ${JSON.stringify(prop.value)} -- apply via Filament renderer`);
@@ -4549,39 +4524,26 @@ function emitEnvironment(compiler, env) {
 }
 function emitObject(compiler, obj) {
   const v = compiler.sanitizeName(obj.name);
-  const meshType = compiler.findProp(obj, "mesh") ?? compiler.findProp(obj, "type") ?? "cube";
+  const meshType = compiler.findProp(obj, "mesh") ?? compiler.findProp(obj, "geometry") ?? compiler.findProp(obj, "type") ?? "cube";
   const modelSrc = compiler.findProp(obj, "model") ?? compiler.findProp(obj, "src");
+  const pos = compiler.findProp(obj, "position");
+  const scale = compiler.findProp(obj, "scale");
   compiler.emit("");
   compiler.emit(`// Object: ${compiler.escapeStringValue(obj.name, "Kotlin")}`);
   if (obj.traits?.some((t) => t.name === "plane_detection")) {
-    compiler.emit(
-      `val ${v}Plane = xrSession.scene.createEntity("${compiler.escapeStringValue(obj.name, "Kotlin")}_plane")`
-    );
-    compiler.emit(`${v}Plane.setPose(Pose(Vector3(0f, 0f, 0f), Quaternion.identity()))`);
+    compiler.emit("// Plane detection requested; runtime session config remains device-gated.");
   }
   const anchor = obj.traits?.find((t) => t.name === "anchor");
   if (anchor) {
-    compiler.emit(
-      `val ${v}Anchor = xrSession.scene.createAnchorEntity() // type: ${anchor.config?.type ?? "plane"}`
-    );
+    compiler.emit(`// Anchor requested: ${anchor.config?.type ?? "plane"}`);
   }
   if (obj.traits?.some((t) => t.name === "hand_tracking")) {
-    compiler.emit(`val ${v}Hand = HandNode(xrSession)`);
-    compiler.emit(`${v}Hand.setOnInputEventListener { event: InputEvent -> /* hand input */ }`);
+    compiler.emit("// Hand tracking requested; bind input listeners after device capability check.");
   }
   if (modelSrc) {
-    compiler.emit(`val ${v}GltfModel = GltfModel.create(xrSession, Uri.parse("${modelSrc}"))`);
-    compiler.emit(`val ${v} = GltfModelEntity.create(xrSession, ${v}GltfModel).apply {`);
-    compiler.indent();
-    compiler.emit(`parent = xrSession.scene.activitySpace`);
-    const modelPos = compiler.findProp(obj, "position");
-    if (modelPos && Array.isArray(modelPos)) {
-      compiler.emit(
-        `setPose(Pose(${compiler.toKotlinFloat3(modelPos)}, Quaternion.identity()))`
-      );
-    }
-    compiler.dedent();
-    compiler.emit("}");
+    compiler.emit(`// glTF model "${modelSrc}" is exposed through XRNodeFactory.loadGltfModel(...).`);
+    compiler.emit(`val ${v} = ${xrEntityCreate(compiler, "xrSession", obj.name, pos)}`);
+    emitScale(compiler, v, scale);
   } else if (meshType === "text") {
     const text = compiler.findProp(obj, "text") ?? obj.name;
     const color = compiler.findProp(obj, "color");
@@ -4593,21 +4555,8 @@ function emitObject(compiler, obj) {
     compiler.dedent();
     compiler.emit("}");
   } else {
-    compiler.emit(
-      `val ${v} = xrSession.scene.createEntity("${compiler.escapeStringValue(obj.name, "Kotlin")}")`
-    );
-    const pos = compiler.findProp(obj, "position");
-    if (pos && Array.isArray(pos)) {
-      compiler.emit(
-        `${v}.setPose(Pose(${compiler.toKotlinFloat3(pos)}, Quaternion.identity()))`
-      );
-    }
-    const scale = compiler.findProp(obj, "scale");
-    if (scale && Array.isArray(scale)) {
-      compiler.emit(`${v}.setScale(${compiler.toKotlinFloat3(scale)})`);
-    } else if (typeof scale === "number") {
-      compiler.emit(`${v}.setScale(Float3(${scale}f, ${scale}f, ${scale}f))`);
-    }
+    compiler.emit(`val ${v} = ${xrEntityCreate(compiler, "xrSession", obj.name, pos)}`);
+    emitScale(compiler, v, scale);
     const mat = compiler.findProp(obj, "material");
     if (mat && typeof mat === "object") {
       const m = mat;
@@ -4625,7 +4574,7 @@ function emitObject(compiler, obj) {
     if (t.name === "collidable") compiler.emit(`// Collision enabled for ${v}`);
     else if (t.name === "physics") compiler.emit(`// Physics: mass=${t.config?.mass ?? 1}`);
     else if (t.name === "grabbable") {
-      compiler.emit(`${v}.setOnInputEventListener { _: InputEvent -> /* grab */ }`);
+      compiler.emit(`// Grabbable input binding requested for ${v}.`);
     } else if (t.name === "face_tracking") {
       emitFaceTracking(compiler, v, t.config ?? {});
     } else if (t.name === "follows_head" || t.name === "head_follow") {
@@ -4634,18 +4583,10 @@ function emitObject(compiler, obj) {
       emitDrmVideo(compiler, v, t.config ?? {});
     } else if (t.name === "occlusion_mesh") {
       compiler.emit(`// Activate strictly if depth API is physically supported on-device`);
-      compiler.emit(`if (xrSession.isDepthSupported) {`);
-      compiler.indent();
-      compiler.emit(
-        `xrSession.scene.configure { config -> config.depthMode = Config.DepthMode.AUTOMATIC }`
-      );
-      compiler.emit(`${v}.enableDepthOcclusion(true)`);
-      compiler.dedent();
-      compiler.emit(`}`);
+      compiler.emit(`// Depth occlusion requested for ${v}.`);
     } else if (t.name === "environment_probe") {
       compiler.emit(`// Attach HDR environmental projection to scene root`);
-      compiler.emit(`val ${v}Probe = xrSession.scene.perceptionSpace.createEnvironmentProbe()`);
-      compiler.emit(`sceneRoot.addComponent(${v}Probe)`);
+      compiler.emit(`// Environment probe requested for ${v}; device capability check required.`);
     } else if (t.name === "ai_upscaling") {
       const texture = compiler.findProp(obj, "texture");
       if (texture && typeof texture === "string") {
@@ -4685,18 +4626,10 @@ function emitGroup(compiler, group) {
   const v = compiler.sanitizeName(group.name);
   compiler.emit("");
   compiler.emit(`// Group: ${compiler.escapeStringValue(group.name, "Kotlin")}`);
-  compiler.emit(
-    `val ${v} = xrSession.scene.createEntity("${compiler.escapeStringValue(group.name, "Kotlin")}")`
-  );
+  const pos = group.properties.find((p) => p.key === "position")?.value;
+  compiler.emit(`val ${v} = ${xrEntityCreate(compiler, "xrSession", group.name, pos)}`);
   for (const p of group.properties) {
-    if (p.key === "position" && Array.isArray(p.value))
-      compiler.emit(
-        `${v}.setPose(Pose(${compiler.toKotlinFloat3(p.value)}, Quaternion.identity()))`
-      );
-    else if (p.key === "scale" && Array.isArray(p.value))
-      compiler.emit(`${v}.setScale(${compiler.toKotlinFloat3(p.value)})`);
-    else if (p.key === "scale" && typeof p.value === "number")
-      compiler.emit(`${v}.setScale(Float3(${p.value}f, ${p.value}f, ${p.value}f))`);
+    if (p.key === "scale") emitScale(compiler, v, p.value);
   }
   for (const o of group.objects) {
     emitObject(compiler, o);
@@ -4718,25 +4651,19 @@ function emitLight(compiler, light) {
     area: "POINT"
   };
   compiler.emit("");
-  compiler.emit(
-    `val ${v} = xrSession.scene.createEntity("${compiler.escapeStringValue(light.name, "Kotlin")}")`
-  );
+  const pos = light.properties.find((p) => p.key === "position")?.value;
+  compiler.emit(`val ${v} = ${xrEntityCreate(compiler, "xrSession", light.name, pos)}`);
   compiler.emit(`// Filament type: LightManager.Type.${typeMap[light.lightType] ?? "POINT"}`);
   const color = light.properties.find((p) => p.key === "color");
   const intensity = light.properties.find((p) => p.key === "intensity");
-  const pos = light.properties.find((p) => p.key === "position");
   if (color) compiler.emit(`// Color: ${color.value}`);
   if (intensity) compiler.emit(`// Intensity: ${intensity.value * 1e5}f lux`);
-  if (pos && Array.isArray(pos.value))
-    compiler.emit(
-      `${v}.setPose(Pose(${compiler.toKotlinFloat3(pos.value)}, Quaternion.identity()))`
-    );
 }
 function emitCamera(compiler, cam) {
   compiler.emit(`// Camera: ${cam.cameraType}`);
   for (const p of cam.properties) {
     if (p.key === "passthrough" && (p.value === true || p.value === "true"))
-      compiler.emit("xrSession.scene.configure { it.focusMode = Config.FocusMode.AUTO }");
+      compiler.emit("// Passthrough requested; device policy controls camera focus.");
     else if (p.key === "fov") compiler.emit(`// FOV: ${p.value} -- managed by XR headset`);
   }
 }
@@ -4793,10 +4720,7 @@ function emitAudio(compiler, audio) {
   }
   if (spatial && pos && Array.isArray(pos)) {
     compiler.emit(
-      `val ${v}Entity = xrSession.scene.createEntity("${compiler.escapeStringValue(audio.name, "Kotlin")}")`
-    );
-    compiler.emit(
-      `${v}Entity.setPose(Pose(${compiler.toKotlinFloat3(pos)}, Quaternion.identity()))`
+      `val ${v}Entity = ${xrEntityCreate(compiler, "xrSession", audio.name, pos)}`
     );
     compiler.emit(`val ${v}Track = SpatialAudioTrack(xrSession, ${v}Entity)`);
   }
@@ -4840,14 +4764,8 @@ function emitUI(compiler, ui) {
 }
 function emitZone(compiler, zone) {
   const v = compiler.sanitizeName(zone.name);
-  compiler.emit(
-    `val ${v} = xrSession.scene.createEntity("${compiler.escapeStringValue(zone.name, "Kotlin")}")`
-  );
   const pos = zone.properties.find((p) => p.key === "position")?.value;
-  if (pos && Array.isArray(pos))
-    compiler.emit(
-      `${v}.setPose(Pose(${compiler.toKotlinFloat3(pos)}, Quaternion.identity()))`
-    );
+  compiler.emit(`val ${v} = ${xrEntityCreate(compiler, "xrSession", zone.name, pos)}`);
   const shape = zone.properties.find((p) => p.key === "shape")?.value;
   const size = zone.properties.find((p) => p.key === "size")?.value;
   const radius = zone.properties.find((p) => p.key === "radius")?.value;
@@ -4953,7 +4871,7 @@ function emitDrmVideo(compiler, varName, config) {
   compiler.indent();
   compiler.emit("session = xrSession,");
   compiler.emit(`stereoMode = ${stereoModeKotlin},`);
-  compiler.emit("pose = Pose(Vector3(0f, 0f, -1.5f), Quaternion.identity()),");
+  compiler.emit("pose = Pose(Vector3(0f, 0f, -1.5f), Quaternion.Identity),");
   compiler.emit(`shape = ${shapeCode},`);
   compiler.emit("surfaceProtection = SurfaceEntity.SurfaceProtection.PROTECTED");
   compiler.dedent();
@@ -4990,36 +4908,36 @@ function compileAndroidXRDomainBlocks(compiler, composition) {
   compiler.emit("");
   compiler.emit("// === v4.2 Domain Blocks ===");
   let blockIdx = 0;
-  const compiled = chunkGH6C2QGW_cjs.compileDomainBlocks(
+  const compiled = chunkQEDMOGF3_cjs.compileDomainBlocks(
     // @ts-expect-error During migration
     domainBlocks,
     {
       material: (block) => {
-        const mat = chunkGH6C2QGW_cjs.compileMaterialBlock(block);
-        return chunkGH6C2QGW_cjs.materialToAndroidXR(mat, `db${blockIdx++}`);
+        const mat = chunkQEDMOGF3_cjs.compileMaterialBlock(block);
+        return chunkQEDMOGF3_cjs.materialToAndroidXR(mat, `db${blockIdx++}`);
       },
       physics: (block) => {
-        const phys = chunkGH6C2QGW_cjs.compilePhysicsBlock(block);
-        return chunkGH6C2QGW_cjs.physicsToAndroidXR(phys, `db${blockIdx++}`);
+        const phys = chunkQEDMOGF3_cjs.compilePhysicsBlock(block);
+        return chunkQEDMOGF3_cjs.physicsToAndroidXR(phys, `db${blockIdx++}`);
       },
       vfx: (block) => {
-        const ps = chunkGH6C2QGW_cjs.compileParticleBlock(block);
-        return chunkGH6C2QGW_cjs.particlesToAndroidXR(ps, `db${blockIdx++}`);
+        const ps = chunkQEDMOGF3_cjs.compileParticleBlock(block);
+        return chunkQEDMOGF3_cjs.particlesToAndroidXR(ps, `db${blockIdx++}`);
       },
       postfx: (block) => {
-        const pp = chunkGH6C2QGW_cjs.compilePostProcessingBlock(block);
+        const pp = chunkQEDMOGF3_cjs.compilePostProcessingBlock(block);
         const postfx = pp;
         const effects = postfx.effects.map((e) => `// Effect: ${e.type} \u2014 ${JSON.stringify(e.properties)}`).join("\n");
         return `// Post-Processing: ${postfx.keyword} \u2014 configure via Filament Renderer post-processing
 ${effects}`;
       },
       audio: (block) => {
-        const audio = chunkGH6C2QGW_cjs.compileAudioSourceBlock(block);
-        return chunkGH6C2QGW_cjs.audioSourceToAndroidXR(audio, `db${blockIdx++}`);
+        const audio = chunkQEDMOGF3_cjs.compileAudioSourceBlock(block);
+        return chunkQEDMOGF3_cjs.audioSourceToAndroidXR(audio, `db${blockIdx++}`);
       },
       weather: (block) => {
-        const weather = chunkGH6C2QGW_cjs.compileWeatherBlock(block);
-        return chunkGH6C2QGW_cjs.weatherToAndroidXR(weather);
+        const weather = chunkQEDMOGF3_cjs.compileWeatherBlock(block);
+        return chunkQEDMOGF3_cjs.weatherToAndroidXR(weather);
       }
     },
     (block) => `// Domain block: ${block.domain}/${block.keyword} "${compiler.escapeStringValue(block.name, "Kotlin")}"`
@@ -5044,9 +4962,9 @@ function emitTransition(compiler, tr) {
   compiler.dedent();
   compiler.emit("}");
 }
-var init_AndroidXRGenerators = chunkHCCQLAA4_cjs.__esm({
+var init_AndroidXRGenerators = chunkZHPMP447_cjs.__esm({
   "src/compiler/AndroidXRGenerators.ts"() {
-    chunkGH6C2QGW_cjs.init_DomainBlockCompilerMixin();
+    chunkQEDMOGF3_cjs.init_DomainBlockCompilerMixin();
     init_AndroidXRTraitMap();
   }
 });
@@ -5630,14 +5548,14 @@ function generateGlimmerComponentsFile(compiler, composition) {
   compiler.emit("}");
   return compiler.lines.join("\n");
 }
-var init_AndroidXRGlassesGenerators = chunkHCCQLAA4_cjs.__esm({
+var init_AndroidXRGlassesGenerators = chunkZHPMP447_cjs.__esm({
   "src/compiler/AndroidXRGlassesGenerators.ts"() {
   }
 });
 
 // src/compiler/AndroidXRCompiler.ts
 var AndroidXRCompiler_exports = {};
-chunkHCCQLAA4_cjs.__export(AndroidXRCompiler_exports, {
+chunkZHPMP447_cjs.__export(AndroidXRCompiler_exports, {
   AndroidXRCompiler: () => exports.AndroidXRCompiler,
   compileToAndroidXR: () => compileToAndroidXR
 });
@@ -5646,14 +5564,14 @@ function compileToAndroidXR(composition, options) {
   return compiler.compile(composition, "");
 }
 exports.AndroidXRCompiler = void 0;
-var init_AndroidXRCompiler = chunkHCCQLAA4_cjs.__esm({
+var init_AndroidXRCompiler = chunkZHPMP447_cjs.__esm({
   "src/compiler/AndroidXRCompiler.ts"() {
-    chunkLODTHGST_cjs.init_CompilerBase();
-    chunkEBS32AJI_cjs.init_PlatformConditionalCompilerMixin();
-    chunkFEWUHQNM_cjs.init_AndroidKotlinHelpers();
+    chunkZK7KX5CD_cjs.init_CompilerBase();
+    chunkTZCFKZ6Z_cjs.init_PlatformConditionalCompilerMixin();
+    chunkCFVK26P4_cjs.init_AndroidKotlinHelpers();
     init_AndroidXRGenerators();
     init_AndroidXRGlassesGenerators();
-    exports.AndroidXRCompiler = class extends chunkLODTHGST_cjs.CompilerBase {
+    exports.AndroidXRCompiler = class extends chunkZK7KX5CD_cjs.CompilerBase {
       constructor(options = {}) {
         super();
         this.compilerName = "AndroidXRCompiler";
@@ -5667,7 +5585,8 @@ var init_AndroidXRCompiler = chunkHCCQLAA4_cjs.__esm({
           arCameraHardwareRequired: options.arCameraHardwareRequired ?? false,
           indent: options.indent || "    ",
           minSdk: options.minSdk || 30,
-          targetSdk: options.targetSdk || 35,
+          // alpha15 Jetpack XR libs (compose/scenecore) require compileSdk 36 + AGP 8.9.1 (AAR metadata gate).
+          targetSdk: options.targetSdk || 36,
           formFactor: options.formFactor || "headset",
           provenanceHash: options.provenanceHash ?? ""
         };
@@ -5680,7 +5599,7 @@ var init_AndroidXRCompiler = chunkHCCQLAA4_cjs.__esm({
       }
       compile(composition, agentToken, outputPath) {
         this.validateCompilerAccess(agentToken, outputPath);
-        composition = chunkEBS32AJI_cjs.filterCompositionForPlatform(composition, "android-xr");
+        composition = chunkTZCFKZ6Z_cjs.filterCompositionForPlatform(composition, "android-xr");
         if (this.isGlassesMode) {
           return {
             activityFile: generateGlassesActivityFile(this, composition),
@@ -5699,6 +5618,31 @@ var init_AndroidXRCompiler = chunkHCCQLAA4_cjs.__esm({
           buildGradle: generateBuildGradle(this, composition)
         };
       }
+      /**
+       * Compile to a path-keyed map of reference-relative files (Android project layout).
+       *
+       * The Quest golden-diff gate iterates a `Record<path, content>`; AndroidXRCompiler's
+       * native return is named fields (AndroidXRCompileResult), so this adapter maps those
+       * fields onto the on-disk Android project layout. That lets the SAME byte-diff gate +
+       * committed-reference-app pattern (QuestCompiler) apply to Android XR. Keys are
+       * POSIX-relative to the app project root (the dir holding settings.gradle.kts).
+       */
+      compileToFiles(composition, agentToken = "") {
+        const r = this.compile(composition, agentToken);
+        const pkgPath = this.options.packageName.replace(/\./g, "/");
+        const javaRel = `app/src/main/java/${pkgPath}`;
+        const files = {
+          [`${javaRel}/${this.options.activityName}.kt`]: r.activityFile,
+          [`${javaRel}/XRSceneState.kt`]: r.stateFile,
+          [`${javaRel}/XRNodeFactory.kt`]: r.nodeFactoryFile,
+          "app/src/main/AndroidManifest.xml": r.manifestFile,
+          "app/build.gradle.kts": r.buildGradle
+        };
+        if (r.glimmerComponentsFile) {
+          files[`${javaRel}/GlimmerComponents.kt`] = r.glimmerComponentsFile;
+        }
+        return files;
+      }
       emit(line) {
         this.lines.push(this.options.indent.repeat(this.indentLevel) + line);
       }
@@ -5710,35 +5654,35 @@ var init_AndroidXRCompiler = chunkHCCQLAA4_cjs.__esm({
       }
       /** @deprecated Use sanitizeName from AndroidKotlinHelpers */
       sanitizeName(name) {
-        return chunkFEWUHQNM_cjs.sanitizeName(name);
+        return chunkCFVK26P4_cjs.sanitizeName(name);
       }
       /** @deprecated Use toKotlinFloat3 from AndroidKotlinHelpers */
       toKotlinFloat3(arr) {
-        return chunkFEWUHQNM_cjs.toKotlinFloat3(arr);
+        return chunkCFVK26P4_cjs.toKotlinFloat3(arr);
       }
       /** @deprecated Use toKotlinColor from AndroidKotlinHelpers */
       toKotlinColor(hex) {
-        return chunkFEWUHQNM_cjs.toKotlinColor(hex);
+        return chunkCFVK26P4_cjs.toKotlinColor(hex);
       }
       /** @deprecated Use mapShapeToFilament from AndroidKotlinHelpers */
       mapShapeToFilament(type) {
-        return chunkFEWUHQNM_cjs.mapShapeToFilament(type);
+        return chunkCFVK26P4_cjs.mapShapeToFilament(type);
       }
       /** @deprecated Use toKotlinType from AndroidKotlinHelpers */
       toKotlinType(value) {
-        return chunkFEWUHQNM_cjs.toKotlinType(value);
+        return chunkCFVK26P4_cjs.toKotlinType(value);
       }
       /** @deprecated Use toKotlinValue from AndroidKotlinHelpers */
       toKotlinValue(value) {
-        return chunkFEWUHQNM_cjs.toKotlinValue(value, (s, t) => this.escapeStringValue(s, t));
+        return chunkCFVK26P4_cjs.toKotlinValue(value, (s, t) => this.escapeStringValue(s, t));
       }
       /** @deprecated Use findObjProp from AndroidKotlinHelpers (note: XR uses 'findProp' alias) */
       findProp(obj, key) {
-        return chunkFEWUHQNM_cjs.findObjProp(obj, key);
+        return chunkCFVK26P4_cjs.findObjProp(obj, key);
       }
       /** @deprecated Use compositionUsesArCoreDepthTraits from AndroidKotlinHelpers */
       compositionUsesArCoreDepthTraits(composition) {
-        return chunkFEWUHQNM_cjs.compositionUsesArCoreDepthTraits(composition);
+        return chunkCFVK26P4_cjs.compositionUsesArCoreDepthTraits(composition);
       }
     };
   }
@@ -5749,5 +5693,5 @@ exports.compileToAndroidXR = compileToAndroidXR;
 exports.getTraitMapping = getTraitMapping;
 exports.init_AndroidXRCompiler = init_AndroidXRCompiler;
 exports.init_AndroidXRTraitMap = init_AndroidXRTraitMap;
-//# sourceMappingURL=chunk-SH5PPVK7.cjs.map
-//# sourceMappingURL=chunk-SH5PPVK7.cjs.map
+//# sourceMappingURL=chunk-NQN5LFN4.cjs.map
+//# sourceMappingURL=chunk-NQN5LFN4.cjs.map