@webspatial/platform-visionos 1.6.1 → 2.0.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@webspatial/platform-visionos",
-  "version": "1.6.1",
+  "version": "2.0.0",
   "description": "Used to publish WebSpatial projects to Apple Vision Pro",
   "type": "commonjs",
   "main": "package.json",
   "engines": {
-    "node": ">=14.15.0"
+    "node": ">=22"
   },
   "repository": {
     "type": "git",

package/web-spatial/JSBCommand.swift

@@ -16,6 +16,7 @@ struct CreateSpatializedStatic3DElement: CommandDataProtocol {
     static let commandType: String = "CreateSpatializedStatic3DElement"
     let modelURL: String?
     let sources: [ModelSource]?
+    let loading: String?
 }
 
 struct CreateSpatializedDynamic3DElement: CommandDataProtocol {
@@ -52,6 +53,12 @@ struct CreateTexture: CommandDataProtocol {
     let url: String
 }
 
+struct UpdateTextureProperties: CommandDataProtocol {
+    static let commandType: String = "UpdateTextureProperties"
+    let id: String
+    let url: String?
+}
+
 struct CreateModelAsset: CommandDataProtocol {
     static let commandType: String = "CreateModelAsset"
     let url: String
@@ -150,6 +157,7 @@ struct UpdateUnlitMaterialProperties: CommandDataProtocol {
     static let commandType: String = "UpdateUnlitMaterialProperties"
     let id: String
     let color: String?
+    let textureId: String?
     let transparent: Bool?
     let opacity: Float?
 }
@@ -267,6 +275,10 @@ struct UpdateSpatializedStatic3DElementProperties: SpatializedElementProperties
     let loop: Bool?
     let animationPaused: Bool?
     let playbackRate: Double?
+    let currentTime: Double?
+    let posterURL: String?
+    let loading: String?
+    let stagemode: String?
 }
 
 struct UpdateSpatializedDynamic3DElementProperties: SpatializedElementProperties {

package/web-spatial/WebMsgCommand.swift

@@ -24,9 +24,8 @@ enum SpatialWebMsgType: String, Encodable {
     case spatialrotateend
     case spatialmagnify
     case spatialmagnifyend
-
     case animationstatechange
-
+    case entitytransformchange
     case objectdestroy
 }
 
@@ -119,6 +118,9 @@ struct ModelLoadFailure: Encodable {
 struct AnimationStateChangeDetail: Encodable {
     let paused: Bool
     let duration: Double
+    let currentTime: Double
+    /// Unix epoch time in milliseconds
+    let timestamp: Double
 }
 
 struct AnimationStateChangeEvent: Encodable {
@@ -126,6 +128,31 @@ struct AnimationStateChangeEvent: Encodable {
     let detail: AnimationStateChangeDetail
 }
 
+/// 16-element column-major representation of the new `entityTransform`,
+/// matching the wire format that JS already uses when sending the matrix to
+/// native via `UpdateSpatializedStatic3DElementProperties.modelTransform`.
+struct EntityTransformChangeDetail: Encodable {
+    let transform: [Double]
+}
+
+struct EntityTransformChangeEvent: Encodable {
+    let type: SpatialWebMsgType = .entitytransformchange
+    let detail: EntityTransformChangeDetail
+
+    /// Emits the transform to the web layer as a 16-element column-major matrix.
+    init(_ transform: AffineTransform3D) {
+        let m = transform.matrix
+        let c0 = m.columns.0, c1 = m.columns.1, c2 = m.columns.2, c3 = m.columns.3
+        let array: [Double] = [
+            c0.x, c0.y, c0.z, 0,
+            c1.x, c1.y, c1.z, 0,
+            c2.x, c2.y, c2.z, 0,
+            c3.x, c3.y, c3.z, 1,
+        ]
+        detail = EntityTransformChangeDetail(transform: array)
+    }
+}
+
 struct SpatialObjectDestroiedEvent: Encodable {
     let type: SpatialWebMsgType = .objectdestroy
 }

package/web-spatial/WebSpatialApp.swift

@@ -40,13 +40,31 @@ struct WebSpatialApp: App {
         )
     }
 
+    func getSceneOrCreate(_ sceneID: String?, _ style: SpatialScene.WindowStyle) -> SpatialScene {
+        if let sceneID, let spatialScene = SpatialApp.Instance.getScene(sceneID) {
+            return spatialScene
+        }
+
+        logger.debug("Missing scene for WindowGroup data. Recreating scene.")
+        return SpatialApp.Instance.createScene(
+            startURL,
+            style,
+            .visible,
+            app.getSceneOptions()
+        )
+    }
+
+    func getSceneOrCreate(_ sceneID: String, _ style: SpatialScene.WindowStyle) -> SpatialScene {
+        return getSceneOrCreate(Optional(sceneID), style)
+    }
+
     var body: some Scene {
         WindowGroup(
             id: SpatialScene.WindowStyle.window.rawValue,
             for: String.self
         ) { $windowData in
-            let spatialScene = SpatialApp.Instance.getScene(windowData)
-            SpatialSceneView(spatialScene: spatialScene!)
+            let spatialScene = getSceneOrCreate(windowData, .window)
+            SpatialSceneView(spatialScene: spatialScene)
         }
         defaultValue: {
             let scene = SpatialApp.Instance.createScene(
@@ -66,20 +84,20 @@ struct WebSpatialApp: App {
         )
 
         WindowGroup(id: SpatialScene.WindowStyle.volume.rawValue, for: String.self) { $windowData in
-            let spatialScene = SpatialApp.Instance.getScene(windowData)
-            SpatialSceneView(spatialScene: spatialScene!)
+            let spatialScene = getSceneOrCreate(windowData, .volume)
+            SpatialSceneView(spatialScene: spatialScene)
                 .frame(
                     minWidth: getCGFloat(
-                        app.getSceneOptions(windowData)?.resizeRange?.minWidth
+                        spatialScene.sceneConfig?.resizeRange?.minWidth
                     ),
                     maxWidth: getCGFloat(
-                        app.getSceneOptions(windowData)?.resizeRange?.maxWidth
+                        spatialScene.sceneConfig?.resizeRange?.maxWidth
                     ),
                     minHeight: getCGFloat(
-                        app.getSceneOptions(windowData)?.resizeRange?.minHeight
+                        spatialScene.sceneConfig?.resizeRange?.minHeight
                     ),
                     maxHeight: getCGFloat(
-                        app.getSceneOptions(windowData)?.resizeRange?.maxHeight
+                        spatialScene.sceneConfig?.resizeRange?.maxHeight
                     )
                 )
         }

package/web-spatial/manager/Dynamic3DManager.swift

@@ -1,6 +1,85 @@
+import CryptoKit
 import Foundation
 import RealityKit
 
+/// Serializes remote URL → local file for each distinct URL string and uses a unique on-disk name
+/// (hash + basename) so concurrent loads never `removeItem` a path another `TextureResource` read
+/// is using (the old `Documents/lastPathComponent` scheme collided across scenes / retries).
+private actor RemoteResourceLoadCache {
+    static let shared = RemoteResourceLoadCache()
+
+    private var inFlight: [String: Task<URL, Error>] = [:]
+
+    func localFileURL(forRemote urlString: String) async throws -> URL {
+        if let existing = inFlight[urlString] {
+            return try await existing.value
+        }
+        let task = Task {
+            try await Self.downloadInstallIfNeeded(urlString: urlString)
+        }
+        inFlight[urlString] = task
+        do {
+            let url = try await task.value
+            inFlight[urlString] = nil
+            return url
+        } catch {
+            inFlight[urlString] = nil
+            throw error
+        }
+    }
+
+    private static func downloadInstallIfNeeded(urlString: String) async throws -> URL {
+        guard let remote = URL(string: urlString) else {
+            throw NSError(
+                domain: "Invalid URL",
+                code: 0,
+                userInfo: [NSLocalizedDescriptionKey: "Failed to create URL from string: \(urlString)"]
+            )
+        }
+        guard let documents = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first else {
+            throw NSError(
+                domain: "Download Error",
+                code: 0,
+                userInfo: [NSLocalizedDescriptionKey: "Documents directory is unavailable"]
+            )
+        }
+        let destination = cacheFileURL(documents: documents, urlString: urlString)
+        let fm = FileManager.default
+        if fm.fileExists(atPath: destination.path) {
+            return destination
+        }
+
+        print("start load")
+        let (tempURL, response) = try await URLSession.shared.download(from: remote)
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw NSError(
+                domain: "HTTP Error",
+                code: 0,
+                userInfo: [NSLocalizedDescriptionKey: "Missing HTTP response"]
+            )
+        }
+        guard (200 ... 299).contains(httpResponse.statusCode) else {
+            throw NSError(
+                domain: "HTTP Error",
+                code: httpResponse.statusCode,
+                userInfo: [NSLocalizedDescriptionKey: "HTTP Error \(httpResponse.statusCode)"]
+            )
+        }
+        try await FileCoordinator.shared.moveReplacingIfExists(from: tempURL, to: destination)
+        print("load complete")
+        return destination
+    }
+
+    private static func cacheFileURL(documents: URL, urlString: String) -> URL {
+        let digest = SHA256.hash(data: Data(urlString.utf8))
+        let hex = digest.prefix(8).reduce(into: "") { $0.append(String(format: "%02x", $1)) }
+        var baseName = URL(string: urlString)?.lastPathComponent ?? "asset"
+        if baseName.isEmpty { baseName = "asset" }
+        let safe = baseName.replacingOccurrences(of: "/", with: "_")
+        return documents.appendingPathComponent("\(hex)_\(safe)")
+    }
+}
+
 enum GeometryCreationError: LocalizedError {
     case invalidType(String)
     case missingFields(String, [String])
@@ -67,7 +146,17 @@ class Dynamic3DManager {
     // Error messages are thrown from createGeometry using GeometryCreationError
 
     static func createUnlitMaterial(_ props: CreateUnlitMaterial, _ tex: TextureResource? = nil) -> SpatialUnlitMaterial {
-        return SpatialUnlitMaterial(props.color ?? "#FFFFFF", tex, props.transparent ?? true, props.opacity ?? 1)
+        let textureSpatialId: String? = {
+            guard let tid = props.textureId, !tid.isEmpty else { return nil }
+            return tid
+        }()
+        return SpatialUnlitMaterial(
+            props.color ?? "#FFFFFF",
+            tex,
+            props.transparent ?? true,
+            props.opacity ?? 1,
+            textureSpatialId: textureSpatialId
+        )
     }
 
     static func loadResourceToLocal(_ urlString: String, loadComplete: @escaping (Result<URL, Error>) -> Void) {
@@ -80,43 +169,14 @@ class Dynamic3DManager {
             loadComplete(.success(localUrl))
             return
         }
-        // load net file
-        guard let url = URL(string: urlString) else {
-            loadComplete(.failure(NSError(domain: "Invalid URL", code: 0, userInfo: [NSLocalizedDescriptionKey: "Failed to create URL from string: \(urlString)"])))
-            return
-        }
-        // Use an immutable URL to avoid capturing a mutable var in concurrent code
-        let documentsUrl = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!.appendingPathComponent(url.lastPathComponent)
-        let session = URLSession(configuration: URLSessionConfiguration.default)
-        var request = URLRequest(url: url)
-        request.httpMethod = "GET"
-        print("start load")
-        let task = session.downloadTask(with: request, completionHandler: { location, response, error in
-            if let error = error {
+        // load net file — coalesced per URL + unique cache filename (see RemoteResourceLoadCache).
+        Task {
+            do {
+                let url = try await RemoteResourceLoadCache.shared.localFileURL(forRemote: urlString)
+                loadComplete(.success(url))
+            } catch {
                 loadComplete(.failure(error))
-                return
             }
-            if let httpResponse = response as? HTTPURLResponse, !(200 ... 299).contains(httpResponse.statusCode) {
-                let error = NSError(domain: "HTTP Error", code: httpResponse.statusCode, userInfo: [NSLocalizedDescriptionKey: "HTTP Error \(httpResponse.statusCode)"])
-                loadComplete(.failure(error))
-                return
-            }
-            guard let location = location else {
-                loadComplete(.failure(NSError(domain: "Download Error", code: 0, userInfo: [NSLocalizedDescriptionKey: "Download location is nil"])))
-                return
-            }
-            Task {
-                do {
-                    try await FileCoordinator.shared.moveReplacingIfExists(from: location, to: documentsUrl)
-                    print("load complete")
-                    loadComplete(.success(documentsUrl))
-                } catch {
-                    print("File operation error: \(error)")
-                    loadComplete(.failure(error))
-                }
-            }
-
-        })
-        task.resume()
+        }
     }
 }

package/web-spatial/manifest.swift

@@ -6,7 +6,8 @@ var pwaManager = PWAManager()
 struct PWAManager: Codable {
     var isLocal: Bool = false
 
-    var start_url: String = "http://localhost:5173/"
+    ///    var start_url: String = "http://localhost:5173/#/"
+    var start_url: String = "http://localhost:5173/#/runtime-capabilities"
 
     // var start_url: String = "http://localhost:5173/#/spatial-drag-gesture"
 

package/web-spatial/model/MaterialSceneRefresh.swift

@@ -0,0 +1,41 @@
+import Foundation
+
+/// Scene-level helpers for keeping RealityKit model components in sync after material / texture changes.
+/// Per-material mutation lives on `SpatialUnlitMaterial` in `dynamic3d/SpatialMaterial.swift`; this type only
+/// orchestrates lookups across `spatialObjects`.
+enum MaterialSceneRefresh {
+    /// After `SpatialUnlitMaterial.updateProperties`, `ModelComponent` may still hold a stale material copy —
+    /// refresh every component and entity that references `materialId`.
+    static func refreshComponentsUsingMaterial(
+        _ materialId: String,
+        spatialObjects: [String: any SpatialObjectProtocol]
+    ) {
+        for (_, obj) in spatialObjects {
+            if let comp = obj as? SpatialModelComponent, comp.usesMaterial(materialId) {
+                comp.refreshMaterials()
+            }
+        }
+        for (_, obj) in spatialObjects {
+            if let entity = obj as? SpatialModelEntity, entity.usesMaterial(materialId) {
+                entity.refreshMaterials()
+            }
+        }
+    }
+
+    /// After `SpatialTextureResource` reloads from a new URL, push `texture.resource` into every bound unlit material and return their ids for `refreshComponentsUsingMaterial`.
+    static func pushReloadedTextureToBoundUnlitMaterials(
+        texture: SpatialTextureResource,
+        textureSpatialId: String,
+        spatialObjects: [String: any SpatialObjectProtocol]
+    ) -> Set<String> {
+        var refreshedMaterialIds = Set<String>()
+        for (_, obj) in spatialObjects {
+            guard let material = obj as? SpatialUnlitMaterial,
+                  material.textureSpatialId == textureSpatialId
+            else { continue }
+            material.updateProperties(color: nil, texture: .some(texture.resource), transparent: nil, opacity: nil)
+            refreshedMaterialIds.insert(material.spatialId)
+        }
+        return refreshedMaterialIds
+    }
+}