@holoscript/core 8.0.8 → 8.0.9

package/dist/{chunk-7VMGP2FW.js → chunk-G6KACNMO.js}

@@ -1,8 +1,8 @@
-import { init_AndroidKotlinHelpers, sanitizeName, toKotlinFloat3, toKotlinColor, mapShapeToFilament, toKotlinType, toKotlinValue, findObjProp, compositionUsesArCoreDepthTraits } from './chunk-FDSGHPAK.js';
-import { init_PlatformConditionalCompilerMixin, filterCompositionForPlatform } from './chunk-GW3LKD5C.js';
-import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, weatherToAndroidXR, compileAudioSourceBlock, audioSourceToAndroidXR, compilePostProcessingBlock, compileParticleBlock, particlesToAndroidXR, compilePhysicsBlock, physicsToAndroidXR, compileMaterialBlock, materialToAndroidXR } from './chunk-ZA34AN3R.js';
-import { init_CompilerBase, CompilerBase } from './chunk-C7ZBSV2Q.js';
-import { __esm, __export } from './chunk-OL46QLBJ.js';
+import { init_AndroidKotlinHelpers, sanitizeName, toKotlinFloat3, toKotlinColor, mapShapeToFilament, toKotlinType, toKotlinValue, findObjProp, compositionUsesArCoreDepthTraits } from './chunk-CBSDJF3B.js';
+import { init_PlatformConditionalCompilerMixin, filterCompositionForPlatform } from './chunk-DJNH4HFW.js';
+import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, weatherToAndroidXR, compileAudioSourceBlock, audioSourceToAndroidXR, compilePostProcessingBlock, compileParticleBlock, particlesToAndroidXR, compilePhysicsBlock, physicsToAndroidXR, compileMaterialBlock, materialToAndroidXR } from './chunk-5LVFTGKH.js';
+import { init_CompilerBase, CompilerBase } from './chunk-DUG3OQAS.js';
+import { __esm, __export } from './chunk-W4GABFCR.js';
 import { ANSCapabilityPath } from '@holoscript/core-types/ans';
 
 // src/compiler/AndroidXRTraitDispatch.ts
@@ -4003,6 +4003,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;
@@ -4015,7 +4042,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");
@@ -4028,41 +4055,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("}");
@@ -4070,7 +4080,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,");
@@ -4080,11 +4090,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();
@@ -4100,48 +4114,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();
@@ -4149,7 +4141,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")
@@ -4190,8 +4181,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")}
@@ -4286,15 +4276,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")
@@ -4328,7 +4317,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");
@@ -4337,14 +4329,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")
@@ -4404,7 +4390,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);
@@ -4467,14 +4453,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);
@@ -4495,7 +4474,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(
@@ -4529,14 +4508,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`);
@@ -4547,39 +4522,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");
@@ -4591,21 +4553,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;
@@ -4623,7 +4572,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") {
@@ -4632,18 +4581,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") {
@@ -4683,18 +4624,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);
@@ -4716,25 +4649,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`);
   }
 }
@@ -4791,10 +4718,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)`);
   }
@@ -4838,14 +4762,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;
@@ -4951,7 +4869,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();
@@ -5665,7 +5583,8 @@ var init_AndroidXRCompiler = __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 ?? ""
         };
@@ -5697,6 +5616,31 @@ var init_AndroidXRCompiler = __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);
       }
@@ -5743,5 +5687,5 @@ var init_AndroidXRCompiler = __esm({
 });
 
 export { ANDROIDXR_TRAIT_MAP, AndroidXRCompiler, AndroidXRCompiler_exports, compileToAndroidXR, getTraitMapping, init_AndroidXRCompiler, init_AndroidXRTraitMap };
-//# sourceMappingURL=chunk-7VMGP2FW.js.map
-//# sourceMappingURL=chunk-7VMGP2FW.js.map
+//# sourceMappingURL=chunk-G6KACNMO.js.map
+//# sourceMappingURL=chunk-G6KACNMO.js.map

package/dist/{chunk-FJPADH77.cjs → chunk-GAWJJAGT.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkE7JP3BS3_cjs = require('./chunk-E7JP3BS3.cjs');
+var chunkQ47JEE2C_cjs = require('./chunk-Q47JEE2C.cjs');
 
 // src/storage/IPFSTypes.ts
 var IPFSUploadError = class extends Error {
@@ -29,7 +29,7 @@ var FileSizeExceededError = class extends Error {
 };
 
 // src/storage/IPFSProviders.ts
-chunkE7JP3BS3_cjs.init_safeJsonParse();
+chunkQ47JEE2C_cjs.init_safeJsonParse();
 var PinataProvider = class {
   constructor(apiKey, apiSecret) {
     this.baseUrl = "https://api.pinata.cloud";
@@ -270,10 +270,10 @@ var InfuraProvider = class {
     }
     const text = await response.text();
     const lines = text.trim().split("\n");
-    const lastLine = chunkE7JP3BS3_cjs.readJson(lines[lines.length - 1]);
+    const lastLine = chunkQ47JEE2C_cjs.readJson(lines[lines.length - 1]);
     let totalSize = 0;
     for (const line of lines) {
-      const data = chunkE7JP3BS3_cjs.readJson(line);
+      const data = chunkQ47JEE2C_cjs.readJson(line);
       totalSize += data.Size || 0;
     }
     return {
@@ -662,5 +662,5 @@ exports.IPFSUploadError = IPFSUploadError;
 exports.InfuraProvider = InfuraProvider;
 exports.NFTStorageProvider = NFTStorageProvider;
 exports.PinataProvider = PinataProvider;
-//# sourceMappingURL=chunk-FJPADH77.cjs.map
-//# sourceMappingURL=chunk-FJPADH77.cjs.map
+//# sourceMappingURL=chunk-GAWJJAGT.cjs.map
+//# sourceMappingURL=chunk-GAWJJAGT.cjs.map