@holoscript/core 8.0.8 → 8.0.9

package/dist/{chunk-BRNUPDHJ.js → chunk-Z557DVYN.js}

@@ -1,7 +1,7 @@
-import { init_PlatformConditionalCompilerMixin, filterCompositionForPlatform } from './chunk-GW3LKD5C.js';
-import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, compileAudioSourceBlock, audioSourceToVisionOS, compilePostProcessingBlock, compileParticleBlock, particlesToVisionOS, compilePhysicsBlock, physicsToVisionOS, compileMaterialBlock, materialToVisionOS } from './chunk-ZA34AN3R.js';
-import { init_CompilerBase, CompilerBase } from './chunk-C7ZBSV2Q.js';
-import { __esm, __export } from './chunk-OL46QLBJ.js';
+import { init_PlatformConditionalCompilerMixin, filterCompositionForPlatform } from './chunk-DJNH4HFW.js';
+import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, compileAudioSourceBlock, audioSourceToVisionOS, compilePostProcessingBlock, compileParticleBlock, particlesToVisionOS, compilePhysicsBlock, physicsToVisionOS, compileMaterialBlock, materialToVisionOS } 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/VisionOSTraitMap.ts
@@ -1730,10 +1730,14 @@ var init_VisionOSCompiler = __esm({
         this.emit("import RealityKit");
         this.emit("import RealityKitContent");
         const allTraits = this.collectAllTraits(composition);
+        const sharePlayConfig = this.getSharePlayConfig(composition);
         const requiredImports = getRequiredImports(allTraits);
         for (const imp of requiredImports) {
           this.emit(`import ${imp}`);
         }
+        if (sharePlayConfig && !requiredImports.includes("GroupActivities")) {
+          this.emit("import GroupActivities");
+        }
         if (composition.audio?.length && !requiredImports.includes("AVFoundation")) {
           this.emit("import AVFoundation");
         }
@@ -1742,6 +1746,12 @@ var init_VisionOSCompiler = __esm({
           this.emit(`// Requires visionOS ${minVersion}+`);
         }
         this.emit("");
+        const volumetricWindows = this.collectVolumetricWindows(composition);
+        const ornaments = this.collectOrnaments(composition);
+        if (volumetricWindows.length > 0) {
+          this.compileVolumetricWindowDescriptorType();
+          this.emit("");
+        }
         if (composition.state) {
           this.emit("@Observable");
           this.emit(`class ${this.options.structName}State {`);
@@ -1823,6 +1833,12 @@ var init_VisionOSCompiler = __esm({
             this.compileTransition(tr);
           }
         }
+        if (volumetricWindows.length > 0) {
+          this.compileVolumetricWindowScenes(volumetricWindows, ornaments);
+        }
+        if (sharePlayConfig) {
+          this.compileSharePlaySupport(sharePlayConfig);
+        }
         this.indentLevel--;
         this.emit("}");
         if (composition.effects) {
@@ -1960,9 +1976,11 @@ ${layers}`;
           return;
         }
         const varName = this.sanitizeName(obj.name);
-        const meshType = this.findObjProp(obj, "mesh") || this.findObjProp(obj, "type") || "cube";
+        const geometry = this.findObjProp(obj, "geometry");
+        const modelSource = this.getModelSource(obj, geometry);
+        const meshType = this.findObjProp(obj, "mesh") || this.findObjProp(obj, "type") || geometry || "cube";
         const isText = meshType === "text";
-        const isModel = !!this.findObjProp(obj, "model") || !!this.findObjProp(obj, "src");
+        const isModel = !!modelSource || meshType === "model";
         const isLight = ["directional", "point", "spot", "hemisphere", "ambient", "area"].includes(
           meshType
         );
@@ -1992,11 +2010,15 @@ ${layers}`;
             );
           }
         } else if (isModel) {
-          const src = this.findObjProp(obj, "model") || this.findObjProp(obj, "src");
-          this.emit(`let ${varName} = try! await Entity(named: "${src}", in: realityKitContentBundle)`);
+          const src = modelSource ?? "MissingModel";
+          this.emit(`let ${varName}Mesh = MeshResource.generateBox(size: 0.1) // collision proxy`);
+          this.emit(
+            `let ${varName} = try! await ModelEntity(named: "${this.escapeStringValue(String(src), "Swift")}", 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}Mesh = MeshResource.generateBox(size: 0.1) // interaction proxy`);
           this.emit(`let ${varName} = Entity()`);
           this.emit(`${varName}.name = "${this.escapeStringValue(obj.name, "Swift")}"`);
         } else {
@@ -2051,16 +2073,11 @@ ${layers}`;
             );
           }
           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);
-              }
-            }
-          }
         }
+        this.compileObjectTraits(obj, varName);
+        this.compileVolumetricWindowMetadata(obj, varName);
+        this.compileObjectAnimations(obj, varName);
+        this.compileObjectEventHandlers(obj, varName);
         const pos = this.findObjProp(obj, "position");
         if (pos) this.emit(`${varName}.position = ${this.toSIMD3(pos)}`);
         const rot = this.findObjProp(obj, "rotation");
@@ -2194,6 +2211,212 @@ ${layers}`;
         this.indentLevel--;
         this.emit("}");
       }
+      compileObjectTraits(obj, varName) {
+        if (!obj.traits) return;
+        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);
+          }
+        }
+      }
+      compileVolumetricWindowDescriptorType() {
+        this.emit("struct VolumetricWindowDescriptor {");
+        this.indentLevel++;
+        this.emit("let id: String");
+        this.emit("let type: String");
+        this.emit("let minSize: CGSize?");
+        this.emit("let maxSize: CGSize?");
+        this.emit("let cornerRadius: CGFloat?");
+        this.emit("let glassBackground: Bool");
+        this.emit("let opacity: Double");
+        this.indentLevel--;
+        this.emit("}");
+      }
+      compileVolumetricWindowMetadata(obj, varName) {
+        const descriptor = this.getVolumetricWindowDescriptor(obj);
+        if (!descriptor) return;
+        this.emit(`let ${varName}VolumetricWindow = VolumetricWindowDescriptor(`);
+        this.indentLevel++;
+        this.emit(`id: "${this.escapeStringValue(descriptor.objectName, "Swift")}",`);
+        this.emit(`type: "${this.escapeStringValue(descriptor.type, "Swift")}",`);
+        this.emit(`minSize: ${this.toCGSizeValue(descriptor.minSize)}, // min_size`);
+        this.emit(`maxSize: ${this.toCGSizeValue(descriptor.maxSize)}, // max_size`);
+        this.emit(`cornerRadius: ${this.toOptionalNumber(descriptor.cornerRadius)}, // corner_radius`);
+        this.emit(
+          `glassBackground: ${descriptor.glassBackground ? "true" : "false"}, // glass_background`
+        );
+        this.emit(`opacity: ${descriptor.opacity} // opacity`);
+        this.indentLevel--;
+        this.emit(")");
+        this.emit(`_ = ${varName}VolumetricWindow`);
+        this.emit(`${varName}.components.set(OpacityComponent(opacity: ${descriptor.opacity}))`);
+      }
+      compileVolumetricWindowScenes(windows, ornaments) {
+        this.emit("");
+        this.emit("@SceneBuilder");
+        this.emit("static func windowScenes() -> some Scene {");
+        this.indentLevel++;
+        for (const window of windows) {
+          const windowOrnaments = ornaments.filter(
+            (ornament) => ornament.attachTo === window.objectName
+          );
+          this.emit(`WindowGroup(id: "${this.escapeStringValue(window.objectName, "Swift")}") {`);
+          this.indentLevel++;
+          this.emit("Self()");
+          if (window.minSize || window.maxSize) {
+            this.emit(`.frame(${this.toFrameArguments(window)})`);
+          }
+          if (window.cornerRadius !== void 0) {
+            this.emit(`.clipShape(RoundedRectangle(cornerRadius: ${window.cornerRadius}))`);
+          }
+          if (window.glassBackground) {
+            this.emit(".glassBackgroundEffect()");
+          }
+          if (window.opacity !== 1) {
+            this.emit(`.opacity(${window.opacity})`);
+          }
+          for (const ornament of windowOrnaments) {
+            this.compileOrnamentModifier(ornament);
+          }
+          this.indentLevel--;
+          this.emit("}");
+          this.emit(".windowStyle(.volumetric)");
+          this.emit(
+            `.defaultSize(width: ${window.scale[0]}, height: ${window.scale[1]}, depth: ${window.scale[2]}, in: .meters)`
+          );
+        }
+        this.indentLevel--;
+        this.emit("}");
+      }
+      compileOrnamentModifier(ornament) {
+        const anchor = this.toAttachmentAnchor(ornament.position);
+        const alignment = this.toContentAlignment(ornament.position);
+        this.emit(
+          `.ornament(visibility: .visible, attachmentAnchor: ${anchor}, contentAlignment: ${alignment}) {`
+        );
+        this.indentLevel++;
+        this.compileOrnamentContent(ornament);
+        this.emit(`.offset(x: ${ornament.offset[0]}, y: ${ornament.offset[1]})`);
+        this.indentLevel--;
+        this.emit("}");
+      }
+      compileOrnamentContent(ornament) {
+        const uiType = String(ornament.ui.type ?? "button");
+        if (uiType === "toolbar") {
+          const items = Array.isArray(ornament.ui.items) ? ornament.ui.items : [];
+          this.emit("HStack {");
+          this.indentLevel++;
+          for (const item of items) {
+            this.emit(
+              `Button { } label: { Image(systemName: "${this.escapeStringValue(String(item), "Swift")}") }`
+            );
+          }
+          this.indentLevel--;
+          this.emit("}");
+          if (ornament.ui.style === "glass") {
+            this.emit(".glassBackgroundEffect()");
+          }
+          return;
+        }
+        const icon = String(ornament.ui.icon ?? "circle");
+        this.emit(
+          `Button { } label: { Image(systemName: "${this.escapeStringValue(icon, "Swift")}") }`
+        );
+        this.emit(".glassBackgroundEffect()");
+      }
+      compileObjectAnimations(obj, varName) {
+        const animations = this.getObjectDirectives(obj, "animation");
+        for (const animation of animations) {
+          const body = this.asRecord(animation.body);
+          const name = this.sanitizeName(String(animation.name ?? "Animation"));
+          const property = String(body?.property ?? "transform");
+          const from = this.toOptionalNumeric(body?.from) ?? 0;
+          const to = this.toOptionalNumeric(body?.to) ?? 0;
+          const durationMs = this.toOptionalNumeric(body?.duration) ?? 1e3;
+          const durationSeconds = durationMs / 1e3;
+          const axis = property.endsWith(".x") ? "1, 0, 0" : property.endsWith(".z") ? "0, 0, 1" : "0, 1, 0";
+          const animationVar = `${varName}${name}Animation`;
+          this.emit(
+            `// animation "${this.escapeStringValue(String(animation.name ?? name), "Swift")}" -> RealityKit AnimationResource`
+          );
+          this.emit(`let ${animationVar} = FromToByAnimation<Transform>(`);
+          this.indentLevel++;
+          this.emit(`name: "${this.escapeStringValue(String(animation.name ?? name), "Swift")}",`);
+          this.emit(
+            `from: Transform(rotation: simd_quatf(angle: Float(${from}) * .pi / 180, axis: SIMD3<Float>(${axis}))), // ${property} from: ${from}`
+          );
+          this.emit(
+            `to: Transform(rotation: simd_quatf(angle: Float(${to}) * .pi / 180, axis: SIMD3<Float>(${axis}))), // to: ${to}`
+          );
+          this.emit(`duration: ${durationSeconds},`);
+          this.emit("bindTarget: .transform");
+          this.indentLevel--;
+          this.emit(")");
+          this.emit(
+            `if let ${animationVar}Resource = try? AnimationResource.generate(with: ${animationVar}) {`
+          );
+          this.indentLevel++;
+          this.emit(`${varName}.playAnimation(${animationVar}Resource.repeat())`);
+          this.indentLevel--;
+          this.emit("}");
+        }
+      }
+      compileObjectEventHandlers(obj, varName) {
+        const eventNames = (obj.properties ?? []).map((property) => property.key).filter((key) => key.startsWith("on_"));
+        if (eventNames.length === 0) return;
+        this.emit(
+          `let ${varName}EventHandlers = [${eventNames.map((name) => `"${name}"`).join(", ")}]`
+        );
+        this.emit(`_ = ${varName}EventHandlers`);
+        this.emit(`${varName}.components.set(InputTargetComponent())`);
+        for (const eventName of eventNames) {
+          this.emit(`// ${eventName} wired through targeted SwiftUI/RealityView gestures`);
+          if (eventName === "on_gaze_tap") {
+            const target = this.findObjProp(obj, "attach_to");
+            if (typeof target === "string") {
+              this.emit(`// close_window("${this.escapeStringValue(target, "Swift")}")`);
+              this.emit(`// dismissWindow(id: "${this.escapeStringValue(target, "Swift")}")`);
+            }
+          }
+        }
+      }
+      compileSharePlaySupport(config) {
+        const activityType = String(config.activity_type ?? "holoscript_activity");
+        const sync = this.asRecord(config.sync);
+        const syncKeys = sync ? Object.keys(sync).filter((key) => sync[key] === true) : [];
+        const syncKeyList = syncKeys.map((key) => `"${this.escapeStringValue(key, "Swift")}"`).join(", ");
+        this.emit("");
+        this.emit(`struct ${this.options.structName}GroupActivity: GroupActivity {`);
+        this.indentLevel++;
+        this.emit("var metadata: GroupActivityMetadata {");
+        this.indentLevel++;
+        this.emit("var metadata = GroupActivityMetadata()");
+        this.emit(`metadata.title = "${this.escapeStringValue(activityType, "Swift")}"`);
+        this.emit("metadata.type = .generic");
+        this.emit("return metadata");
+        this.indentLevel--;
+        this.emit("}");
+        this.indentLevel--;
+        this.emit("}");
+        this.emit(`static let sharePlaySyncKeys = [${syncKeyList}] // sync`);
+        this.emit("static func activateSharePlay() {");
+        this.indentLevel++;
+        this.emit("Task {");
+        this.indentLevel++;
+        this.emit(`for await session in ${this.options.structName}GroupActivity.sessions() {`);
+        this.indentLevel++;
+        this.emit("await session.join()");
+        this.emit("let messenger = GroupSessionMessenger(session: session)");
+        this.emit("_ = messenger");
+        this.indentLevel--;
+        this.emit("}");
+        this.indentLevel--;
+        this.emit("}");
+        this.indentLevel--;
+        this.emit("}");
+      }
       compileEffects(effects) {
         this.emit("// === Post-Processing Notes ===");
         this.emit("// visionOS uses system-level rendering; post-processing is limited.");
@@ -2377,6 +2600,36 @@ ${layers}`;
         });
         return traits;
       }
+      collectVolumetricWindows(composition) {
+        const windows = [];
+        const collectFromObject = (obj) => {
+          const descriptor = this.getVolumetricWindowDescriptor(obj);
+          if (descriptor) {
+            windows.push(descriptor);
+          }
+          obj.children?.forEach(collectFromObject);
+        };
+        composition.objects?.forEach(collectFromObject);
+        composition.spatialGroups?.forEach((group) => {
+          group.objects.forEach(collectFromObject);
+        });
+        return windows;
+      }
+      collectOrnaments(composition) {
+        const ornaments = [];
+        const collectFromObject = (obj) => {
+          const descriptor = this.getOrnamentDescriptor(obj);
+          if (descriptor) {
+            ornaments.push(descriptor);
+          }
+          obj.children?.forEach(collectFromObject);
+        };
+        composition.objects?.forEach(collectFromObject);
+        composition.spatialGroups?.forEach((group) => {
+          group.objects.forEach(collectFromObject);
+        });
+        return ornaments;
+      }
       // ─── Helpers ───────────────────────────────────────────────────────────
       emit(line) {
         this.lines.push(this.options.indent.repeat(this.indentLevel) + line);
@@ -2417,10 +2670,124 @@ ${layers}`;
       findObjProp(obj, key) {
         return obj.properties?.find((p) => p.key === key)?.value;
       }
+      getVolumetricWindowDescriptor(obj) {
+        const windowConfig = this.findObjProp(obj, "window");
+        const hasWindowTrait = obj.traits?.some(
+          (trait) => trait.name === "window" || trait.name === "volumetric_window"
+        );
+        if (!hasWindowTrait && !windowConfig) return void 0;
+        const config = this.asRecord(windowConfig);
+        const type = String(config?.type ?? "volumetric");
+        if (type !== "volumetric") return void 0;
+        const scale = this.toNumberTuple3(this.findObjProp(obj, "scale"), [0.6, 0.4, 0.12]);
+        return {
+          objectName: obj.name,
+          type,
+          scale,
+          minSize: this.toNumberTuple2(config?.min_size),
+          maxSize: this.toNumberTuple2(config?.max_size),
+          cornerRadius: this.toOptionalNumeric(config?.corner_radius),
+          glassBackground: Boolean(config?.glass_background ?? false),
+          opacity: this.toOptionalNumeric(config?.opacity) ?? 1
+        };
+      }
+      getOrnamentDescriptor(obj) {
+        const hasOrnamentTrait = obj.traits?.some((trait) => trait.name === "ornament");
+        const attachTo = this.findObjProp(obj, "attach_to");
+        if (!hasOrnamentTrait || typeof attachTo !== "string") return void 0;
+        return {
+          objectName: obj.name,
+          attachTo,
+          position: String(this.findObjProp(obj, "position") ?? "bottom"),
+          offset: this.toNumberTuple3(this.findObjProp(obj, "offset"), [0, 0, 0]),
+          ui: this.asRecord(this.findObjProp(obj, "ui")) ?? {}
+        };
+      }
+      getSharePlayConfig(composition) {
+        return this.asRecord(composition.metadata?.shareplay);
+      }
+      getModelSource(obj, geometry) {
+        const explicit = this.findObjProp(obj, "model") || this.findObjProp(obj, "src");
+        if (explicit) return explicit;
+        if (typeof geometry === "string" && /\.(usd|usdz|reality)$/i.test(geometry)) {
+          return geometry;
+        }
+        return void 0;
+      }
+      getObjectDirectives(obj, type) {
+        if (!Array.isArray(obj.directives)) return [];
+        return obj.directives.filter(
+          (directive) => Boolean(directive && typeof directive === "object" && "type" in directive)
+        ).filter((directive) => directive.type === type);
+      }
+      asRecord(value) {
+        if (!value || typeof value !== "object" || Array.isArray(value) || "__bind" in value) {
+          return void 0;
+        }
+        return value;
+      }
+      toOptionalNumeric(value) {
+        return typeof value === "number" ? value : void 0;
+      }
+      toNumberTuple2(value) {
+        if (Array.isArray(value) && value.length >= 2 && typeof value[0] === "number" && typeof value[1] === "number") {
+          return [value[0], value[1]];
+        }
+        return void 0;
+      }
+      toNumberTuple3(value, fallback) {
+        if (Array.isArray(value) && value.length >= 3 && typeof value[0] === "number" && typeof value[1] === "number" && typeof value[2] === "number") {
+          return [value[0], value[1], value[2]];
+        }
+        return fallback;
+      }
+      toCGSizeValue(size) {
+        if (!size) return "nil";
+        return `CGSize(width: ${size[0]}, height: ${size[1]})`;
+      }
+      toOptionalNumber(value) {
+        return value === void 0 ? "nil" : String(value);
+      }
+      toFrameArguments(window) {
+        const args = [];
+        if (window.minSize) {
+          args.push(`minWidth: ${window.minSize[0]}`, `minHeight: ${window.minSize[1]}`);
+        }
+        if (window.maxSize) {
+          args.push(`maxWidth: ${window.maxSize[0]}`, `maxHeight: ${window.maxSize[1]}`);
+        }
+        return args.join(", ");
+      }
+      toAttachmentAnchor(position) {
+        const anchors = {
+          top: ".scene(.top)",
+          bottom: ".scene(.bottom)",
+          leading: ".scene(.leading)",
+          trailing: ".scene(.trailing)",
+          "top-left": ".scene(.topLeading)",
+          "top-right": ".scene(.topTrailing)",
+          "bottom-left": ".scene(.bottomLeading)",
+          "bottom-right": ".scene(.bottomTrailing)"
+        };
+        return anchors[position] ?? ".scene(.bottom)";
+      }
+      toContentAlignment(position) {
+        const alignments = {
+          top: ".top",
+          bottom: ".bottom",
+          leading: ".leading",
+          trailing: ".trailing",
+          "top-left": ".topLeading",
+          "top-right": ".topTrailing",
+          "bottom-left": ".bottomLeading",
+          "bottom-right": ".bottomTrailing"
+        };
+        return alignments[position] ?? ".bottom";
+      }
     };
   }
 });
 
 export { VisionOSCompiler, VisionOSCompiler_exports, generateTraitCode, getTraitMapping, init_VisionOSCompiler, init_VisionOSTraitMap, listAllTraits };
-//# sourceMappingURL=chunk-BRNUPDHJ.js.map
-//# sourceMappingURL=chunk-BRNUPDHJ.js.map
+//# sourceMappingURL=chunk-Z557DVYN.js.map
+//# sourceMappingURL=chunk-Z557DVYN.js.map