@movementinfra/expo-twostep-video 0.1.0

package/ios/ExpoTwostepVideoModule.swift

@@ -0,0 +1,739 @@
+import ExpoModulesCore
+import AVFoundation
+import Photos
+import UIKit
+
+// MARK: - Bridge Module
+
+/// Expo Module that bridges TwoStepVideo Swift library to JavaScript
+public class ExpoTwoStepVideoModule: Module {
+
+    // MARK: - Properties
+
+    private let twoStep = TwoStepVideo()
+    private var activeAssets: [String: VideoAsset] = [:]
+    private var activeCompositions: [String: AVMutableComposition] = [:]
+    private var activeVideoCompositions: [String: AVMutableVideoComposition] = [:]
+
+    // MARK: - Module Definition
+
+    public func definition() -> ModuleDefinition {
+
+        // Module name for JavaScript
+        Name("ExpoTwoStepVideo")
+
+        // MARK: - Events
+
+        /// Event emitted during video export with progress updates
+        /// Event payload: { progress: number (0.0 to 1.0), assetId?: string }
+        Events("onExportProgress")
+
+        // MARK: - Constants
+
+        /// Quality preset constants
+        Property("QUALITY_LOW") { "low" }
+        Property("QUALITY_MEDIUM") { "medium" }
+        Property("QUALITY_HIGH") { "high" }
+        Property("QUALITY_HIGHEST") { "highest" }
+
+        /// Mirror axis constants
+        Property("MIRROR_HORIZONTAL") { "horizontal" }
+        Property("MIRROR_VERTICAL") { "vertical" }
+        Property("MIRROR_BOTH") { "both" }
+
+        // MARK: - Functions
+
+        /// Load a video asset from a file URI
+        /// - Parameter uri: File URI (e.g., "file:///path/to/video.mp4")
+        /// - Returns: Asset ID and metadata
+        AsyncFunction("loadAsset") { (uri: String, promise: Promise) in
+            Task {
+                do {
+                    guard let url = URL(string: uri) else {
+                        promise.reject("INVALID_URI", "Invalid file URI: \(uri)")
+                        return
+                    }
+
+                    let asset = try await self.twoStep.assetLoader.loadAsset(from: url)
+                    let assetId = UUID().uuidString
+
+                    // Store asset for later use
+                    self.activeAssets[assetId] = asset
+
+                    // Return asset info to JavaScript
+                    promise.resolve([
+                        "id": assetId,
+                        "duration": CMTimeGetSeconds(asset.duration),
+                        "width": asset.naturalSize?.width ?? 0,
+                        "height": asset.naturalSize?.height ?? 0,
+                        "frameRate": asset.frameRate ?? 0,
+                        "hasAudio": asset.hasAudio
+                    ])
+                } catch let error as VideoEditingError {
+                    promise.reject("LOAD_FAILED", error.localizedDescription)
+                } catch {
+                    promise.reject("UNKNOWN_ERROR", error.localizedDescription)
+                }
+            }
+        }
+
+        /// Load a video asset from the Photos library
+        /// - Parameter localIdentifier: PHAsset local identifier
+        /// - Returns: Asset ID and metadata
+        AsyncFunction("loadAssetFromPhotos") { (localIdentifier: String, promise: Promise) in
+            Task {
+                do {
+                    let fetchResult = PHAsset.fetchAssets(
+                        withLocalIdentifiers: [localIdentifier],
+                        options: nil
+                    )
+
+                    guard let phAsset = fetchResult.firstObject else {
+                        promise.reject("NOT_FOUND", "PHAsset not found: \(localIdentifier)")
+                        return
+                    }
+
+                    let asset = try await self.twoStep.assetLoader.loadAsset(from: phAsset)
+                    let assetId = UUID().uuidString
+
+                    self.activeAssets[assetId] = asset
+
+                    promise.resolve([
+                        "id": assetId,
+                        "duration": CMTimeGetSeconds(asset.duration),
+                        "width": asset.naturalSize?.width ?? 0,
+                        "height": asset.naturalSize?.height ?? 0,
+                        "frameRate": asset.frameRate ?? 0,
+                        "hasAudio": asset.hasAudio
+                    ])
+                } catch let error as VideoEditingError {
+                    promise.reject("LOAD_FAILED", error.localizedDescription)
+                } catch {
+                    promise.reject("UNKNOWN_ERROR", error.localizedDescription)
+                }
+            }
+        }
+
+        /// Validate a video file URI without loading the full asset
+        /// - Parameter uri: File URI to validate
+        /// - Returns: Boolean indicating if valid
+        AsyncFunction("validateVideoUri") { (uri: String, promise: Promise) in
+            Task {
+                guard let url = URL(string: uri) else {
+                    promise.resolve(false)
+                    return
+                }
+
+                let isValid = await self.twoStep.assetLoader.validateVideoURL(url)
+                promise.resolve(isValid)
+            }
+        }
+
+        /// Trim a video to a single time range
+        /// - Parameters:
+        ///   - assetId: ID of the loaded asset
+        ///   - startTime: Start time in seconds
+        ///   - endTime: End time in seconds
+        /// - Returns: Composition ID
+        AsyncFunction("trimVideo") { (assetId: String, startTime: Double, endTime: Double, promise: Promise) in
+            Task {
+                do {
+                    guard let asset = self.activeAssets[assetId] else {
+                        promise.reject("ASSET_NOT_FOUND", "Asset not found: \(assetId)")
+                        return
+                    }
+
+                    let timeRange = try TimeRange.fromSeconds(start: startTime, end: endTime)
+                    let composition = try await self.twoStep.videoTrimmer.trim(
+                        asset: asset,
+                        to: timeRange
+                    )
+
+                    let compositionId = UUID().uuidString
+                    self.activeCompositions[compositionId] = composition
+
+                    promise.resolve([
+                        "id": compositionId,
+                        "duration": CMTimeGetSeconds(composition.duration)
+                    ])
+                } catch let error as VideoEditingError {
+                    promise.reject("TRIM_FAILED", error.localizedDescription)
+                } catch {
+                    promise.reject("UNKNOWN_ERROR", error.localizedDescription)
+                }
+            }
+        }
+
+        /// Trim a video to multiple time ranges (creates segments)
+        /// - Parameters:
+        ///   - assetId: ID of the loaded asset
+        ///   - segments: Array of {start: number, end: number}
+        /// - Returns: Composition ID
+        AsyncFunction("trimVideoMultiple") { (assetId: String, segments: [[String: Double]], promise: Promise) in
+            Task {
+                do {
+                    guard let asset = self.activeAssets[assetId] else {
+                        promise.reject("ASSET_NOT_FOUND", "Asset not found: \(assetId)")
+                        return
+                    }
+
+                    // Convert JS segments to TimeRanges
+                    var timeRanges: [TimeRange] = []
+                    for segment in segments {
+                        guard let start = segment["start"],
+                              let end = segment["end"] else {
+                            promise.reject("INVALID_SEGMENT", "Segment missing start or end")
+                            return
+                        }
+                        let range = try TimeRange.fromSeconds(start: start, end: end)
+                        timeRanges.append(range)
+                    }
+
+                    let composition = try await self.twoStep.videoTrimmer.trim(
+                        asset: asset,
+                        to: timeRanges
+                    )
+
+                    let compositionId = UUID().uuidString
+                    self.activeCompositions[compositionId] = composition
+
+                    promise.resolve([
+                        "id": compositionId,
+                        "duration": CMTimeGetSeconds(composition.duration)
+                    ])
+                } catch let error as VideoEditingError {
+                    promise.reject("TRIM_FAILED", error.localizedDescription)
+                } catch {
+                    promise.reject("UNKNOWN_ERROR", error.localizedDescription)
+                }
+            }
+        }
+
+        /// Mirror a video horizontally, vertically, or both
+        /// - Parameters:
+        ///   - assetId: ID of the loaded asset
+        ///   - axis: Mirror axis: "horizontal", "vertical", or "both"
+        ///   - startTime: Optional start time in seconds
+        ///   - endTime: Optional end time in seconds
+        /// - Returns: Composition ID
+        AsyncFunction("mirrorVideo") { (assetId: String, axis: String, startTime: Double?, endTime: Double?, promise: Promise) in
+            Task {
+                do {
+                    guard let asset = self.activeAssets[assetId] else {
+                        promise.reject("ASSET_NOT_FOUND", "Asset not found: \(assetId)")
+                        return
+                    }
+
+                    // Parse mirror axis
+                    let mirrorAxis: VideoTransformer.MirrorAxis
+                    switch axis.lowercased() {
+                    case "horizontal": mirrorAxis = .horizontal
+                    case "vertical": mirrorAxis = .vertical
+                    case "both": mirrorAxis = .both
+                    default:
+                        promise.reject("INVALID_AXIS", "Invalid mirror axis: \(axis). Use 'horizontal', 'vertical', or 'both'")
+                        return
+                    }
+
+                    // Parse optional time range
+                    var timeRange: TimeRange? = nil
+                    if let start = startTime, let end = endTime {
+                        timeRange = try TimeRange.fromSeconds(start: start, end: end)
+                    }
+
+                    let (composition, videoComposition) = try await self.twoStep.videoTransformer.mirror(
+                        asset: asset,
+                        axis: mirrorAxis,
+                        timeRange: timeRange
+                    )
+
+                    let compositionId = UUID().uuidString
+                    self.activeCompositions[compositionId] = composition
+                    self.activeVideoCompositions[compositionId] = videoComposition
+
+                    promise.resolve([
+                        "id": compositionId,
+                        "duration": CMTimeGetSeconds(composition.duration)
+                    ])
+                } catch let error as VideoEditingError {
+                    promise.reject("MIRROR_FAILED", error.localizedDescription)
+                } catch {
+                    promise.reject("UNKNOWN_ERROR", error.localizedDescription)
+                }
+            }
+        }
+
+        /// Adjust playback speed of a video
+        /// - Parameters:
+        ///   - assetId: ID of the loaded asset
+        ///   - speed: Speed multiplier (0.25 = 4x slower, 2.0 = 2x faster)
+        ///   - startTime: Optional start time in seconds
+        ///   - endTime: Optional end time in seconds
+        /// - Returns: Composition ID
+        AsyncFunction("adjustSpeed") { (assetId: String, speed: Double, startTime: Double?, endTime: Double?, promise: Promise) in
+            Task {
+                do {
+                    guard let asset = self.activeAssets[assetId] else {
+                        promise.reject("ASSET_NOT_FOUND", "Asset not found: \(assetId)")
+                        return
+                    }
+
+                    // Parse optional time range
+                    var timeRange: TimeRange? = nil
+                    if let start = startTime, let end = endTime {
+                        timeRange = try TimeRange.fromSeconds(start: start, end: end)
+                    }
+
+                    let composition = try await self.twoStep.videoTransformer.adjustSpeed(
+                        asset: asset,
+                        speed: Float(speed),
+                        timeRange: timeRange
+                    )
+
+                    let compositionId = UUID().uuidString
+                    self.activeCompositions[compositionId] = composition
+
+                    promise.resolve([
+                        "id": compositionId,
+                        "duration": CMTimeGetSeconds(composition.duration)
+                    ])
+                } catch let error as VideoEditingError {
+                    promise.reject("SPEED_FAILED", error.localizedDescription)
+                } catch {
+                    promise.reject("UNKNOWN_ERROR", error.localizedDescription)
+                }
+            }
+        }
+
+        /// Transform a video with combined trimming, mirroring, and speed adjustment
+        /// - Parameters:
+        ///   - assetId: ID of the loaded asset
+        ///   - speed: Speed multiplier (default 1.0)
+        ///   - mirrorAxis: Optional mirror axis: "horizontal", "vertical", or "both"
+        ///   - startTime: Optional start time in seconds
+        ///   - endTime: Optional end time in seconds
+        /// - Returns: Composition ID
+        AsyncFunction("transformVideo") { (assetId: String, speed: Double?, mirrorAxis: String?, startTime: Double?, endTime: Double?, promise: Promise) in
+            Task {
+                do {
+                    guard let asset = self.activeAssets[assetId] else {
+                        promise.reject("ASSET_NOT_FOUND", "Asset not found: \(assetId)")
+                        return
+                    }
+
+                    // Parse mirror axis
+                    var axis: VideoTransformer.MirrorAxis? = nil
+                    if let mirrorAxisStr = mirrorAxis {
+                        switch mirrorAxisStr.lowercased() {
+                        case "horizontal": axis = .horizontal
+                        case "vertical": axis = .vertical
+                        case "both": axis = .both
+                        default:
+                            promise.reject("INVALID_AXIS", "Invalid mirror axis: \(mirrorAxisStr)")
+                            return
+                        }
+                    }
+
+                    // Parse optional time range
+                    var timeRange: TimeRange? = nil
+                    if let start = startTime, let end = endTime {
+                        timeRange = try TimeRange.fromSeconds(start: start, end: end)
+                    }
+
+                    let (composition, videoComposition) = try await self.twoStep.videoTransformer.transform(
+                        asset: asset,
+                        speed: Float(speed ?? 1.0),
+                        mirrorAxis: axis,
+                        timeRange: timeRange
+                    )
+
+                    let compositionId = UUID().uuidString
+                    self.activeCompositions[compositionId] = composition
+                    if let vc = videoComposition {
+                        self.activeVideoCompositions[compositionId] = vc
+                    }
+
+                    promise.resolve([
+                        "id": compositionId,
+                        "duration": CMTimeGetSeconds(composition.duration)
+                    ])
+                } catch let error as VideoEditingError {
+                    promise.reject("TRANSFORM_FAILED", error.localizedDescription)
+                } catch {
+                    promise.reject("UNKNOWN_ERROR", error.localizedDescription)
+                }
+            }
+        }
+
+        /// Loop a segment of a video
+        /// - Parameters:
+        ///   - assetId: ID of the loaded asset
+        ///   - startTime: Start time of the segment to loop (in seconds)
+        ///   - endTime: End time of the segment to loop (in seconds)
+        ///   - loopCount: Number of times to repeat the segment (total plays = loopCount + 1)
+        /// - Returns: Composition ID
+        AsyncFunction("loopSegment") { (assetId: String, startTime: Double, endTime: Double, loopCount: Int, promise: Promise) in
+            Task {
+                do {
+                    guard let asset = self.activeAssets[assetId] else {
+                        promise.reject("ASSET_NOT_FOUND", "Asset not found: \(assetId)")
+                        return
+                    }
+
+                    let composition = try await self.twoStep.videoTrimmer.loop(
+                        asset: asset,
+                        startTime: startTime,
+                        endTime: endTime,
+                        loopCount: loopCount
+                    )
+
+                    let compositionId = UUID().uuidString
+                    self.activeCompositions[compositionId] = composition
+
+                    promise.resolve([
+                        "id": compositionId,
+                        "duration": CMTimeGetSeconds(composition.duration),
+                        "loopCount": loopCount,
+                        "totalPlays": loopCount + 1
+                    ])
+                } catch let error as VideoEditingError {
+                    promise.reject("LOOP_FAILED", error.localizedDescription)
+                } catch {
+                    promise.reject("UNKNOWN_ERROR", error.localizedDescription)
+                }
+            }
+        }
+
+        /// Generate thumbnails from a video at specific times
+        /// - Parameters:
+        ///   - assetId: ID of the loaded asset
+        ///   - times: Array of times in seconds
+        ///   - size: Optional size {width: number, height: number}
+        /// - Returns: Array of base64 encoded images
+        AsyncFunction("generateThumbnails") { (assetId: String, times: [Double], size: [String: Double]?, promise: Promise) in
+            Task {
+                do {
+                    guard let asset = self.activeAssets[assetId] else {
+                        promise.reject("ASSET_NOT_FOUND", "Asset not found: \(assetId)")
+                        return
+                    }
+
+                    // Convert times to CMTime
+                    let cmTimes = times.map { CMTime(seconds: $0, preferredTimescale: 600) }
+
+                    // Determine size
+                    var thumbnailSize = CGSize(width: 200, height: 200)
+                    if let size = size,
+                       let width = size["width"],
+                       let height = size["height"] {
+                        thumbnailSize = CGSize(width: width, height: height)
+                    }
+
+                    // Generate thumbnails
+                    let images = try await self.twoStep.videoTrimmer.generateThumbnails(
+                        from: asset,
+                        at: cmTimes,
+                        size: thumbnailSize
+                    )
+
+                    // Convert to base64
+                    let base64Images = images.compactMap { cgImage -> String? in
+                        let uiImage = UIImage(cgImage: cgImage)
+                        guard let pngData = uiImage.pngData() else {
+                            return nil
+                        }
+                        return pngData.base64EncodedString()
+                    }
+
+                    promise.resolve(base64Images)
+                } catch let error as VideoEditingError {
+                    promise.reject("THUMBNAIL_FAILED", error.localizedDescription)
+                } catch {
+                    promise.reject("UNKNOWN_ERROR", error.localizedDescription)
+                }
+            }
+        }
+
+        /// Export a composition to a file
+        /// - Parameters:
+        ///   - compositionId: ID of the composition to export
+        ///   - outputUri: Output file URI (optional, uses temp if not provided)
+        ///   - quality: Quality preset: "low", "medium", "high", "highest"
+        /// - Returns: Output file URI
+        AsyncFunction("exportVideo") { (compositionId: String, outputUri: String?, quality: String?, promise: Promise) in
+            Task {
+                do {
+                    guard let composition = self.activeCompositions[compositionId] else {
+                        promise.reject("COMPOSITION_NOT_FOUND", "Composition not found: \(compositionId)")
+                        return
+                    }
+
+                    // Determine output URL
+                    let outputURL: URL
+                    if let outputUri = outputUri, let url = URL(string: outputUri) {
+                        outputURL = url
+                    } else {
+                        // Use temp directory
+                        let fileName = "export_\(UUID().uuidString).mp4"
+                        outputURL = FileManager.default.temporaryDirectory
+                            .appendingPathComponent(fileName)
+                    }
+
+                    // Get optional video composition (for mirroring)
+                    let videoComposition = self.activeVideoCompositions[compositionId]
+
+                    // Export with or without video composition
+                    let resultURL: URL
+                    if let videoComposition = videoComposition {
+                        // Export with video composition (for mirrored videos)
+                        resultURL = try await self.exportWithVideoComposition(
+                            composition: composition,
+                            videoComposition: videoComposition,
+                            outputURL: outputURL,
+                            compositionId: compositionId
+                        )
+                    } else {
+                        // Determine quality
+                        let exportQuality: ExportConfiguration.Quality
+                        switch quality?.lowercased() {
+                        case "low": exportQuality = .low
+                        case "medium": exportQuality = .medium
+                        case "highest": exportQuality = .highest
+                        default: exportQuality = .high
+                        }
+
+                        // Create config
+                        let config = ExportConfiguration(
+                            outputURL: outputURL,
+                            quality: exportQuality
+                        )
+
+                        // Export with progress
+                        resultURL = try await self.twoStep.videoExporter.export(
+                            composition: composition,
+                            configuration: config,
+                            progressHandler: { [weak self] progress in
+                                // Emit progress event to JavaScript
+                                self?.sendEvent("onExportProgress", [
+                                    "progress": progress,
+                                    "compositionId": compositionId
+                                ])
+                            }
+                        )
+                    }
+
+                    promise.resolve([
+                        "uri": resultURL.absoluteString,
+                        "path": resultURL.path
+                    ])
+                } catch let error as VideoEditingError {
+                    promise.reject("EXPORT_FAILED", error.localizedDescription)
+                } catch {
+                    promise.reject("UNKNOWN_ERROR", error.localizedDescription)
+                }
+            }
+        }
+
+        /// Export an asset directly without composition
+        /// - Parameters:
+        ///   - assetId: ID of the asset to export
+        ///   - outputUri: Output file URI (optional)
+        ///   - quality: Quality preset
+        /// - Returns: Output file URI
+        AsyncFunction("exportAsset") { (assetId: String, outputUri: String?, quality: String?, promise: Promise) in
+            Task {
+                do {
+                    guard let asset = self.activeAssets[assetId] else {
+                        promise.reject("ASSET_NOT_FOUND", "Asset not found: \(assetId)")
+                        return
+                    }
+
+                    let outputURL: URL
+                    if let outputUri = outputUri, let url = URL(string: outputUri) {
+                        outputURL = url
+                    } else {
+                        let fileName = "export_\(UUID().uuidString).mp4"
+                        outputURL = FileManager.default.temporaryDirectory
+                            .appendingPathComponent(fileName)
+                    }
+
+                    let exportQuality: ExportConfiguration.Quality
+                    switch quality?.lowercased() {
+                    case "low": exportQuality = .low
+                    case "medium": exportQuality = .medium
+                    case "highest": exportQuality = .highest
+                    default: exportQuality = .high
+                    }
+
+                    let config = ExportConfiguration(
+                        outputURL: outputURL,
+                        quality: exportQuality
+                    )
+
+                    let resultURL = try await self.twoStep.videoExporter.export(
+                        asset: asset,
+                        configuration: config,
+                        progressHandler: { [weak self] progress in
+                            self?.sendEvent("onExportProgress", [
+                                "progress": progress,
+                                "assetId": assetId
+                            ])
+                        }
+                    )
+
+                    promise.resolve([
+                        "uri": resultURL.absoluteString,
+                        "path": resultURL.path
+                    ])
+                } catch let error as VideoEditingError {
+                    promise.reject("EXPORT_FAILED", error.localizedDescription)
+                } catch {
+                    promise.reject("UNKNOWN_ERROR", error.localizedDescription)
+                }
+            }
+        }
+
+        /// Clean up a temporary file
+        /// - Parameter uri: File URI to clean up
+        Function("cleanupFile") { (uri: String) in
+            guard let url = URL(string: uri) else { return }
+            self.twoStep.videoExporter.cleanupFile(at: url)
+        }
+
+        /// Release an asset from memory
+        /// - Parameter assetId: ID of the asset to release
+        Function("releaseAsset") { (assetId: String) in
+            self.activeAssets.removeValue(forKey: assetId)
+        }
+
+        /// Release a composition from memory
+        /// - Parameter compositionId: ID of the composition to release
+        Function("releaseComposition") { (compositionId: String) in
+            self.activeCompositions.removeValue(forKey: compositionId)
+            self.activeVideoCompositions.removeValue(forKey: compositionId)
+        }
+
+        /// Release all cached assets and compositions
+        Function("releaseAll") {
+            self.activeAssets.removeAll()
+            self.activeCompositions.removeAll()
+            self.activeVideoCompositions.removeAll()
+        }
+
+        // MARK: - Video Player View
+
+        View(ExpoTwostepVideoView.self) {
+            // Events emitted by the view
+            Events("onPlaybackStatusChange", "onProgress", "onEnd", "onError")
+
+            // Prop to set composition ID - view will load it
+            Prop("compositionId") { (view: ExpoTwostepVideoView, compositionId: String?) in
+                guard let compositionId = compositionId else { return }
+                guard let composition = self.activeCompositions[compositionId] else {
+                    view.onError(["error": "Composition not found: \(compositionId)"])
+                    return
+                }
+                let videoComposition = self.activeVideoCompositions[compositionId]
+                view.loadComposition(compositionId: compositionId, composition: composition, videoComposition: videoComposition)
+            }
+
+            // Prop to set asset ID - view will load it for preview
+            Prop("assetId") { (view: ExpoTwostepVideoView, assetId: String?) in
+                guard let assetId = assetId else { return }
+                guard let asset = self.activeAssets[assetId] else {
+                    view.onError(["error": "Asset not found: \(assetId)"])
+                    return
+                }
+                view.loadAsset(assetId: assetId, asset: asset.avAsset)
+            }
+
+            // Prop to enable continuous looping
+            Prop("loop") { (view: ExpoTwostepVideoView, loop: Bool?) in
+                view.shouldLoop = loop ?? false
+            }
+
+            // Playback control functions
+            AsyncFunction("play") { (view: ExpoTwostepVideoView) in
+                view.play()
+            }
+
+            AsyncFunction("pause") { (view: ExpoTwostepVideoView) in
+                view.pause()
+            }
+
+            AsyncFunction("seek") { (view: ExpoTwostepVideoView, time: Double) in
+                view.seek(to: time)
+            }
+
+            AsyncFunction("replay") { (view: ExpoTwostepVideoView) in
+                view.replay()
+            }
+        }
+    }
+
+    // MARK: - Private Helper Methods
+
+    /// Export a composition with a video composition (for mirrored videos)
+    private func exportWithVideoComposition(
+        composition: AVMutableComposition,
+        videoComposition: AVMutableVideoComposition,
+        outputURL: URL,
+        compositionId: String
+    ) async throws -> URL {
+        // Remove existing file if present
+        if FileManager.default.fileExists(atPath: outputURL.path) {
+            try? FileManager.default.removeItem(at: outputURL)
+        }
+
+        guard let exportSession = AVAssetExportSession(
+            asset: composition,
+            presetName: AVAssetExportPresetHighestQuality
+        ) else {
+            throw VideoEditingError.exportFailed(
+                reason: "Failed to create export session"
+            )
+        }
+
+        exportSession.outputURL = outputURL
+        exportSession.outputFileType = .mp4
+        exportSession.videoComposition = videoComposition
+        exportSession.shouldOptimizeForNetworkUse = true
+
+        // Start progress monitoring
+        let progressTask = Task {
+            while !Task.isCancelled && exportSession.status == .exporting {
+                self.sendEvent("onExportProgress", [
+                    "progress": exportSession.progress,
+                    "compositionId": compositionId
+                ])
+                try? await Task.sleep(nanoseconds: 100_000_000) // 0.1 seconds
+            }
+        }
+
+        // Perform export
+        await exportSession.export()
+
+        // Cancel progress monitoring
+        progressTask.cancel()
+
+        // Check export status
+        switch exportSession.status {
+        case .completed:
+            return outputURL
+
+        case .failed:
+            throw VideoEditingError.exportFailed(
+                reason: "Export session failed",
+                underlyingError: exportSession.error
+            )
+
+        case .cancelled:
+            throw VideoEditingError.exportCancelled
+
+        default:
+            throw VideoEditingError.exportFailed(
+                reason: "Export ended with unexpected status: \(exportSession.status.rawValue)"
+            )
+        }
+    }
+}