expo-orb 0.1.0 → 0.2.2

package/build/ExpoBreathingExerciseModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBreathingExerciseModule.js","sourceRoot":"","sources":["../src/ExpoBreathingExerciseModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAUzD,MAAM,MAAM,GAAG,mBAAmB,CAAkC,uBAAuB,CAAC,CAAC;AAE7F,eAAe,MAAM,CAAC;AAEtB,MAAM,UAAU,sBAAsB,CAAC,OAAyB;IAC9D,MAAM,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC;AACzC,CAAC;AAED,MAAM,UAAU,qBAAqB;IACnC,MAAM,CAAC,qBAAqB,EAAE,CAAC;AACjC,CAAC;AAED,MAAM,UAAU,sBAAsB;IACpC,MAAM,CAAC,sBAAsB,EAAE,CAAC;AAClC,CAAC;AAED,MAAM,UAAU,uBAAuB;IACrC,MAAM,CAAC,uBAAuB,EAAE,CAAC;AACnC,CAAC;AAED,MAAM,iBAAiB,GAA8C;IACnE,QAAQ,EAAE;QACR,MAAM,EAAE;YACN,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,EAAE;YAC3E,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE;YACrE,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE;SAC7E;QACD,MAAM,EAAE,CAAC;KACV;IACD,GAAG,EAAE;QACH,MAAM,EAAE;YACN,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,EAAE;YAC3E,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE;YACrE,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE;YAC5E,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE;SACvE;QACD,MAAM,EAAE,CAAC;KACV;IACD,UAAU,EAAE;QACV,MAAM,EAAE;YACN,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,EAAE;YAC3E,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE;SAC7E;QACD,MAAM,EAAE,EAAE;KACX;IACD,OAAO,EAAE;QACP,MAAM,EAAE;YACN,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,YAAY,EAAE;YAC3E,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE;SAC7E;QACD,MAAM,EAAE,CAAC;KACV;CACF,CAAC;AAEF,MAAM,UAAU,kBAAkB,CAAC,MAAuB;IACxD,OAAO,iBAAiB,CAAC,MAAM,CAAC,CAAC;AACnC,CAAC","sourcesContent":["import { NativeModule, requireNativeModule } from 'expo';\nimport type { BreathingPattern, BreathingPreset } from './ExpoBreathingExercise.types';\n\ndeclare class ExpoBreathingExerciseModuleType extends NativeModule {\n  startBreathingExercise(pattern: BreathingPattern): void;\n  stopBreathingExercise(): void;\n  pauseBreathingExercise(): void;\n  resumeBreathingExercise(): void;\n}\n\nconst module = requireNativeModule<ExpoBreathingExerciseModuleType>('ExpoBreathingExercise');\n\nexport default module;\n\nexport function startBreathingExercise(pattern: BreathingPattern): void {\n  module.startBreathingExercise(pattern);\n}\n\nexport function stopBreathingExercise(): void {\n  module.stopBreathingExercise();\n}\n\nexport function pauseBreathingExercise(): void {\n  module.pauseBreathingExercise();\n}\n\nexport function resumeBreathingExercise(): void {\n  module.resumeBreathingExercise();\n}\n\nconst BREATHING_PRESETS: Record<BreathingPreset, BreathingPattern> = {\n  relaxing: {\n    phases: [\n      { phase: 'inhale', duration: 4000, targetScale: 1.35, label: 'Breathe In' },\n      { phase: 'holdIn', duration: 7000, targetScale: 1.35, label: 'Hold' },\n      { phase: 'exhale', duration: 8000, targetScale: 0.75, label: 'Breathe Out' },\n    ],\n    cycles: 4,\n  },\n  box: {\n    phases: [\n      { phase: 'inhale', duration: 4000, targetScale: 1.35, label: 'Breathe In' },\n      { phase: 'holdIn', duration: 4000, targetScale: 1.35, label: 'Hold' },\n      { phase: 'exhale', duration: 4000, targetScale: 0.75, label: 'Breathe Out' },\n      { phase: 'holdOut', duration: 4000, targetScale: 0.75, label: 'Hold' },\n    ],\n    cycles: 4,\n  },\n  energizing: {\n    phases: [\n      { phase: 'inhale', duration: 2000, targetScale: 1.35, label: 'Breathe In' },\n      { phase: 'exhale', duration: 2000, targetScale: 0.75, label: 'Breathe Out' },\n    ],\n    cycles: 10,\n  },\n  calming: {\n    phases: [\n      { phase: 'inhale', duration: 4000, targetScale: 1.35, label: 'Breathe In' },\n      { phase: 'exhale', duration: 6000, targetScale: 0.75, label: 'Breathe Out' },\n    ],\n    cycles: 6,\n  },\n};\n\nexport function getBreathingPreset(preset: BreathingPreset): BreathingPattern {\n  return BREATHING_PRESETS[preset];\n}\n"]}

package/build/ExpoBreathingExerciseView.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { ExpoBreathingExerciseViewProps } from './ExpoBreathingExercise.types';
+export default function ExpoBreathingExerciseView(props: ExpoBreathingExerciseViewProps): React.JSX.Element;
+//# sourceMappingURL=ExpoBreathingExerciseView.d.ts.map

package/build/ExpoBreathingExerciseView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBreathingExerciseView.d.ts","sourceRoot":"","sources":["../src/ExpoBreathingExerciseView.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAE,8BAA8B,EAAE,MAAM,+BAA+B,CAAC;AAK/E,MAAM,CAAC,OAAO,UAAU,yBAAyB,CAAC,KAAK,EAAE,8BAA8B,qBAEtF"}

package/build/ExpoBreathingExerciseView.js

@@ -0,0 +1,7 @@
+import { requireNativeView } from 'expo';
+import * as React from 'react';
+const NativeView = requireNativeView('ExpoBreathingExercise');
+export default function ExpoBreathingExerciseView(props) {
+    return <NativeView {...props}/>;
+}
+//# sourceMappingURL=ExpoBreathingExerciseView.js.map

package/build/ExpoBreathingExerciseView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBreathingExerciseView.js","sourceRoot":"","sources":["../src/ExpoBreathingExerciseView.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AACzC,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,MAAM,UAAU,GACd,iBAAiB,CAAC,uBAAuB,CAAC,CAAC;AAE7C,MAAM,CAAC,OAAO,UAAU,yBAAyB,CAAC,KAAqC;IACrF,OAAO,CAAC,UAAU,CAAC,IAAI,KAAK,CAAC,EAAG,CAAC;AACnC,CAAC","sourcesContent":["import { requireNativeView } from 'expo';\nimport * as React from 'react';\n\nimport { ExpoBreathingExerciseViewProps } from './ExpoBreathingExercise.types';\n\nconst NativeView: React.ComponentType<ExpoBreathingExerciseViewProps> =\n  requireNativeView('ExpoBreathingExercise');\n\nexport default function ExpoBreathingExerciseView(props: ExpoBreathingExerciseViewProps) {\n  return <NativeView {...props} />;\n}\n"]}

package/build/index.d.ts

@@ -1,4 +1,7 @@
 export { default, setOrbActivity } from './ExpoOrbModule';
 export { default as ExpoOrbView } from './ExpoOrbView';
 export * from './ExpoOrb.types';
+export { default as ExpoBreathingExerciseModule, startBreathingExercise, stopBreathingExercise, pauseBreathingExercise, resumeBreathingExercise, getBreathingPreset, } from './ExpoBreathingExerciseModule';
+export { default as ExpoBreathingExerciseView } from './ExpoBreathingExerciseView';
+export * from './ExpoBreathingExercise.types';
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,eAAe,CAAC;AACvD,cAAe,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,eAAe,CAAC;AACvD,cAAe,iBAAiB,CAAC;AAEjC,OAAO,EACL,OAAO,IAAI,2BAA2B,EACtC,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,uBAAuB,EACvB,kBAAkB,GACnB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,OAAO,IAAI,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AACnF,cAAc,+BAA+B,CAAC"}

package/build/index.js

@@ -1,4 +1,7 @@
 export { default, setOrbActivity } from './ExpoOrbModule';
 export { default as ExpoOrbView } from './ExpoOrbView';
 export * from './ExpoOrb.types';
+export { default as ExpoBreathingExerciseModule, startBreathingExercise, stopBreathingExercise, pauseBreathingExercise, resumeBreathingExercise, getBreathingPreset, } from './ExpoBreathingExerciseModule';
+export { default as ExpoBreathingExerciseView } from './ExpoBreathingExerciseView';
+export * from './ExpoBreathingExercise.types';
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,eAAe,CAAC;AACvD,cAAe,iBAAiB,CAAC","sourcesContent":["export { default, setOrbActivity } from './ExpoOrbModule';\nexport { default as ExpoOrbView } from './ExpoOrbView';\nexport * from  './ExpoOrb.types';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,eAAe,CAAC;AACvD,cAAe,iBAAiB,CAAC;AAEjC,OAAO,EACL,OAAO,IAAI,2BAA2B,EACtC,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,uBAAuB,EACvB,kBAAkB,GACnB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,OAAO,IAAI,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AACnF,cAAc,+BAA+B,CAAC","sourcesContent":["export { default, setOrbActivity } from './ExpoOrbModule';\nexport { default as ExpoOrbView } from './ExpoOrbView';\nexport * from  './ExpoOrb.types';\n\nexport {\n  default as ExpoBreathingExerciseModule,\n  startBreathingExercise,\n  stopBreathingExercise,\n  pauseBreathingExercise,\n  resumeBreathingExercise,\n  getBreathingPreset,\n} from './ExpoBreathingExerciseModule';\nexport { default as ExpoBreathingExerciseView } from './ExpoBreathingExerciseView';\nexport * from './ExpoBreathingExercise.types';\n"]}

package/expo-module.config.json

@@ -1,9 +1,9 @@
 {
   "platforms": ["apple", "android", "web"],
   "apple": {
-    "modules": ["ExpoOrbModule"]
+    "modules": ["ExpoOrbModule", "ExpoBreathingExerciseModule"]
   },
   "android": {
-    "modules": ["expo.modules.orb.ExpoOrbModule"]
+    "modules": ["expo.modules.orb.ExpoOrbModule", "expo.modules.breathing.ExpoBreathingExerciseModule"]
   }
 }

package/ios/Breathing/BreathingConfiguration.swift

@@ -0,0 +1,57 @@
+import SwiftUI
+
+public struct BreathingConfiguration {
+    var blobColors: [Color]
+    var innerBlobColor: Color
+    var glowColor: Color
+    var particleColor: Color
+    var progressRingColor: Color
+    var textColor: Color
+    var showProgressRing: Bool
+    var showTextCue: Bool
+    var showInnerBlob: Bool
+    var showShadow: Bool
+    var showParticles: Bool
+    var showWavyBlobs: Bool
+    var showGlowEffects: Bool
+    var pointCount: Int
+    var wobbleIntensity: Double
+
+    public init(
+        blobColors: [Color] = [
+            Color(red: 0.4, green: 0.7, blue: 0.9),
+            Color(red: 0.3, green: 0.5, blue: 0.8),
+            Color(red: 0.5, green: 0.3, blue: 0.7)
+        ],
+        innerBlobColor: Color = Color.white.opacity(0.3),
+        glowColor: Color = .white,
+        particleColor: Color = .white,
+        progressRingColor: Color = Color.white.opacity(0.5),
+        textColor: Color = .white,
+        showProgressRing: Bool = true,
+        showTextCue: Bool = true,
+        showInnerBlob: Bool = true,
+        showShadow: Bool = true,
+        showParticles: Bool = true,
+        showWavyBlobs: Bool = true,
+        showGlowEffects: Bool = true,
+        pointCount: Int = 8,
+        wobbleIntensity: Double = 1.0
+    ) {
+        self.blobColors = blobColors
+        self.innerBlobColor = innerBlobColor
+        self.glowColor = glowColor
+        self.particleColor = particleColor
+        self.progressRingColor = progressRingColor
+        self.textColor = textColor
+        self.showProgressRing = showProgressRing
+        self.showTextCue = showTextCue
+        self.showInnerBlob = showInnerBlob
+        self.showShadow = showShadow
+        self.showParticles = showParticles
+        self.showWavyBlobs = showWavyBlobs
+        self.showGlowEffects = showGlowEffects
+        self.pointCount = pointCount
+        self.wobbleIntensity = wobbleIntensity
+    }
+}

package/ios/Breathing/BreathingExerciseView.swift

@@ -0,0 +1,451 @@
+import SwiftUI
+
+public struct BreathingExerciseView: View {
+    private let config: BreathingConfiguration
+
+    public init(configuration: BreathingConfiguration = BreathingConfiguration()) {
+        self.config = configuration
+    }
+
+    public var body: some View {
+        TimelineView(.animation) { timeline in
+            GeometryReader { geometry in
+                let size = min(geometry.size.width, geometry.size.height)
+                let elapsedTime = timeline.date.timeIntervalSinceReferenceDate
+
+                // Update all animation state
+                let animState = updateAllAnimations(at: timeline.date, pointCount: config.pointCount)
+
+                ZStack {
+                    // Progress ring (behind blob)
+                    if config.showProgressRing && animState.isActive {
+                        ProgressRingView(
+                            progress: animState.phaseProgress,
+                            color: config.progressRingColor,
+                            lineWidth: 4,
+                            size: size * 0.95
+                        )
+                    }
+
+                    // Base gradient background layer
+                    LinearGradient(
+                        colors: config.blobColors,
+                        startPoint: .bottom,
+                        endPoint: .top
+                    )
+
+                    // Base depth glows - creates depth with rotating glow effects
+                    baseDepthGlows(size: size, elapsedTime: elapsedTime)
+
+                    // Wavy blobs - adds organic movement with flowing blob shapes
+                    if config.showWavyBlobs {
+                        wavyBlob(size: size, elapsedTime: elapsedTime)
+                        wavyBlobTwo(size: size, elapsedTime: elapsedTime)
+                    }
+
+                    // Core glow effects - adds bright, energetic core glow animations
+                    if config.showGlowEffects {
+                        coreGlowEffects(size: size, elapsedTime: elapsedTime)
+                    }
+
+                    // Particles - overlays floating particle effects for additional dynamism
+                    if config.showParticles {
+                        particleView
+                            .frame(maxWidth: size, maxHeight: size)
+                    }
+                }
+                // Inner glows overlay for depth
+                .overlay {
+                    realisticInnerGlows
+                }
+                // Mask with morphing blob shape
+                .mask {
+                    MorphingBlobShape(
+                        center: CGPoint(x: size / 2, y: size / 2),
+                        baseRadius: animState.scale * 0.7 * size / 2,
+                        pointCount: config.pointCount,
+                        offsets: animState.wobbleOffsets
+                    )
+                }
+                .frame(width: size, height: size)
+                .overlay {
+                    // Text cue
+                    if config.showTextCue && !animState.label.isEmpty {
+                        BreathingTextCue(
+                            text: animState.label,
+                            color: config.textColor
+                        )
+                    }
+                }
+                .modifier(
+                    BreathingShadowModifier(
+                        colors: config.showShadow ? config.blobColors : [.clear],
+                        radius: size * 0.06,
+                        scale: animState.scale
+                    )
+                )
+            }
+            .aspectRatio(1, contentMode: .fit)
+        }
+    }
+
+    // MARK: - Visual Effects (from OrbView)
+
+    private var particleView: some View {
+        ZStack {
+            BreathingParticlesView(
+                color: config.particleColor,
+                particleCount: 15,
+                speedRange: 10...20,
+                sizeRange: 1...3,
+                opacityRange: 0.1...0.4
+            )
+            .blur(radius: 1)
+
+            BreathingParticlesView(
+                color: config.particleColor,
+                particleCount: 10,
+                speedRange: 20...35,
+                sizeRange: 0.5...2,
+                opacityRange: 0.3...0.7
+            )
+        }
+        .blendMode(.plusLighter)
+    }
+
+    private func wavyBlob(size: CGFloat, elapsedTime: Double) -> some View {
+        let blobSpeed: Double = 20
+
+        return RotatingGlowView(
+            color: .white.opacity(0.75),
+            rotationSpeed: blobSpeed * 1.5,
+            direction: .clockwise,
+            elapsedTime: elapsedTime
+        )
+        .mask {
+            WavyBlobView(color: .white, loopDuration: 60 / blobSpeed * 1.75)
+                .frame(maxWidth: size * 1.875)
+                .offset(x: 0, y: size * 0.31)
+        }
+        .blur(radius: 1)
+        .blendMode(.plusLighter)
+    }
+
+    private func wavyBlobTwo(size: CGFloat, elapsedTime: Double) -> some View {
+        let blobSpeed: Double = 20
+
+        return RotatingGlowView(
+            color: .white,
+            rotationSpeed: blobSpeed * 0.75,
+            direction: .counterClockwise,
+            elapsedTime: elapsedTime
+        )
+        .mask {
+            WavyBlobView(color: .white, loopDuration: 60 / blobSpeed * 2.25)
+                .frame(maxWidth: size * 1.25)
+                .rotationEffect(.degrees(90))
+                .offset(x: 0, y: size * -0.31)
+        }
+        .opacity(0.5)
+        .blur(radius: 1)
+        .blendMode(.plusLighter)
+    }
+
+    private func coreGlowEffects(size: CGFloat, elapsedTime: Double) -> some View {
+        let speed: Double = 18.0
+        let glowIntensity: Double = 0.8
+
+        return ZStack {
+            RotatingGlowView(
+                color: config.glowColor,
+                rotationSpeed: speed * 1.2,
+                direction: .clockwise,
+                elapsedTime: elapsedTime
+            )
+            .blur(radius: size * 0.08)
+            .opacity(glowIntensity)
+
+            RotatingGlowView(
+                color: config.glowColor,
+                rotationSpeed: speed * 0.9,
+                direction: .clockwise,
+                elapsedTime: elapsedTime
+            )
+            .blur(radius: size * 0.06)
+            .opacity(glowIntensity)
+            .blendMode(.plusLighter)
+        }
+        .padding(size * 0.08)
+    }
+
+    private func baseDepthGlows(size: CGFloat, elapsedTime: Double) -> some View {
+        let speed: Double = 18.0
+
+        return ZStack {
+            // Outer glow
+            RotatingGlowView(
+                color: config.glowColor,
+                rotationSpeed: speed * 0.75,
+                direction: .counterClockwise,
+                elapsedTime: elapsedTime
+            )
+            .padding(size * 0.03)
+            .blur(radius: size * 0.06)
+            .rotationEffect(.degrees(180))
+            .blendMode(.destinationOver)
+
+            // Outer ring
+            RotatingGlowView(
+                color: config.glowColor.opacity(0.5),
+                rotationSpeed: speed * 0.25,
+                direction: .clockwise,
+                elapsedTime: elapsedTime
+            )
+            .frame(maxWidth: size * 0.94)
+            .rotationEffect(.degrees(180))
+            .padding(8)
+            .blur(radius: size * 0.032)
+        }
+    }
+
+    private var orbOutlineColor: LinearGradient {
+        LinearGradient(
+            colors: [.white, .clear],
+            startPoint: .bottom,
+            endPoint: .top
+        )
+    }
+
+    private var realisticInnerGlows: some View {
+        ZStack {
+            // Outer stroke with heavy blur
+            Circle()
+                .stroke(orbOutlineColor, lineWidth: 8)
+                .blur(radius: 32)
+                .blendMode(.plusLighter)
+
+            // Inner stroke with light blur
+            Circle()
+                .stroke(orbOutlineColor, lineWidth: 4)
+                .blur(radius: 12)
+                .blendMode(.plusLighter)
+
+            Circle()
+                .stroke(orbOutlineColor, lineWidth: 1)
+                .blur(radius: 4)
+                .blendMode(.plusLighter)
+        }
+        .padding(1)
+    }
+
+    private struct AnimState {
+        let scale: Double
+        let wobbleOffsets: [Double]
+        let phaseProgress: Double
+        let label: String
+        let isActive: Bool
+    }
+
+    private func updateAllAnimations(at date: Date, pointCount: Int) -> AnimState {
+        let state = BreathingSharedState.shared
+
+        // Always update wobble animation (organic movement even when idle)
+        updateWobble(at: date, pointCount: pointCount)
+
+        // Handle breathing state
+        switch state.state {
+        case .stopped, .complete:
+            return AnimState(
+                scale: 1.0,
+                wobbleOffsets: state.wobbleOffsets,
+                phaseProgress: 0,
+                label: "",
+                isActive: false
+            )
+
+        case .paused:
+            return AnimState(
+                scale: state.currentScale,
+                wobbleOffsets: state.wobbleOffsets,
+                phaseProgress: state.phaseProgress,
+                label: state.currentLabel,
+                isActive: true
+            )
+
+        case .running:
+            // Update phase timing
+            updatePhaseState(at: date)
+
+            // Calculate scale and progress based on phase
+            let currentPhaseConfig = state.phases.isEmpty ? nil : state.phases[state.currentPhaseIndex]
+            let scale: Double
+            let ringProgress: Double
+
+            if let phase = currentPhaseConfig?.phase {
+                switch phase {
+                case .inhale:
+                    // Ease-out cubic for smooth deceleration toward target
+                    let easedProgress = easeOutCubic(state.phaseProgress)
+                    scale = state.startScale + (state.targetScale - state.startScale) * easedProgress
+                    ringProgress = easedProgress  // 0 -> 1
+                case .exhale:
+                    let easedProgress = easeOutCubic(state.phaseProgress)
+                    scale = state.startScale + (state.targetScale - state.startScale) * easedProgress
+                    ringProgress = 1.0 - easedProgress  // 1 -> 0
+                case .holdIn:
+                    // Hold at expanded scale, ring stays full
+                    scale = state.targetScale
+                    ringProgress = 1.0
+                case .holdOut:
+                    // Hold at contracted scale, ring stays empty
+                    scale = state.targetScale
+                    ringProgress = 0.0
+                case .idle:
+                    scale = state.targetScale
+                    ringProgress = 0.0
+                }
+            } else {
+                scale = 1.0
+                ringProgress = 0.0
+            }
+
+            state.currentScale = scale
+
+            return AnimState(
+                scale: scale,
+                wobbleOffsets: state.wobbleOffsets,
+                phaseProgress: ringProgress,
+                label: state.currentLabel,
+                isActive: true
+            )
+        }
+    }
+
+    private func updatePhaseState(at date: Date) {
+        let state = BreathingSharedState.shared
+        guard !state.phases.isEmpty else { return }
+
+        let currentPhaseConfig = state.phases[state.currentPhaseIndex]
+        let elapsed = date.timeIntervalSince(state.phaseStartTime)
+        let duration = currentPhaseConfig.duration
+
+        // Calculate progress through current phase
+        state.phaseProgress = min(1.0, elapsed / duration)
+
+        // Check if phase is complete
+        if elapsed >= duration {
+            // Move to next phase
+            state.currentPhaseIndex = (state.currentPhaseIndex + 1) % state.phases.count
+
+            // Check if we completed a cycle
+            if state.currentPhaseIndex == 0 {
+                state.currentCycle += 1
+
+                // Check if exercise is complete
+                if let totalCycles = state.totalCycles, state.currentCycle >= totalCycles {
+                    state.state = .complete
+                    state.totalDuration = date.timeIntervalSince(state.exerciseStartTime)
+                    state.onExerciseComplete?(state.currentCycle, state.totalDuration)
+                    return
+                }
+            }
+
+            // Start new phase
+            state.phaseStartTime = date
+            let newPhaseConfig = state.phases[state.currentPhaseIndex]
+            state.currentPhase = newPhaseConfig.phase
+            state.currentLabel = newPhaseConfig.label
+            state.startScale = state.currentScale  // Remember where we're starting from
+            state.targetScale = newPhaseConfig.targetScale
+            state.phaseProgress = 0
+
+            // Update wobble intensity based on phase
+            switch newPhaseConfig.phase {
+            case .inhale, .exhale:
+                state.wobbleIntensity = 1.0
+            case .holdIn, .holdOut:
+                state.wobbleIntensity = 0.3
+            case .idle:
+                state.wobbleIntensity = 0.5
+            }
+
+            // Fire phase change callback
+            state.onPhaseChange?(
+                newPhaseConfig.phase,
+                newPhaseConfig.label,
+                state.currentPhaseIndex,
+                state.currentCycle
+            )
+        }
+    }
+
+    private func updateWobble(at date: Date, pointCount: Int) {
+        let state = BreathingSharedState.shared
+
+        // Initialize arrays if needed
+        if state.wobbleOffsets.count != pointCount {
+            state.wobbleOffsets = (0..<pointCount).map { _ in 0.0 }
+            state.wobbleTargets = (0..<pointCount).map { _ in 0.0 }
+            state.lastWobbleUpdate = date
+            state.lastWobbleTargetUpdate = date
+        }
+
+        let now = date
+        let dt = now.timeIntervalSince(state.lastWobbleUpdate)
+        state.lastWobbleUpdate = now
+
+        // Generate new random targets periodically (slower, more organic)
+        let timeSinceTargetUpdate = now.timeIntervalSince(state.lastWobbleTargetUpdate)
+        if timeSinceTargetUpdate > 1.8 {
+            state.lastWobbleTargetUpdate = now
+
+            let intensity = state.wobbleIntensity * config.wobbleIntensity
+            let maxOffset = 0.18 * intensity
+
+            state.wobbleTargets = (0..<pointCount).map { i in
+                let phase = Double(i) / Double(pointCount) * 2.0 * .pi
+                let wave1 = sin(phase * 2 + Double.random(in: 0...1)) * 0.6
+                let wave2 = cos(phase * 3 + Double.random(in: 0...1)) * 0.4
+                let baseOffset = Double.random(in: -maxOffset...maxOffset)
+                return baseOffset * (1.0 + wave1 + wave2) * 0.5
+            }
+        }
+
+        // Smoothly interpolate current offsets toward targets
+        let interpolationSpeed = 1.8
+        let factor = min(1.0, dt * interpolationSpeed)
+
+        for i in 0..<pointCount {
+            let current = state.wobbleOffsets[i]
+            let target = state.wobbleTargets[i]
+            state.wobbleOffsets[i] = current + (target - current) * factor
+        }
+    }
+}
+
+struct BreathingShadowModifier: ViewModifier {
+    let colors: [Color]
+    let radius: CGFloat
+    let scale: Double
+
+    func body(content: Content) -> some View {
+        content
+            .shadow(color: colors.first?.opacity(0.4) ?? .clear, radius: radius * scale, x: 0, y: radius * 0.3 * scale)
+            .shadow(color: colors.first?.opacity(0.2) ?? .clear, radius: radius * 2 * scale, x: 0, y: radius * 0.5 * scale)
+    }
+}
+
+// Easing functions
+private func easeOutCubic(_ t: Double) -> Double {
+    let t1 = t - 1
+    return t1 * t1 * t1 + 1
+}
+
+private func easeInOutCubic(_ t: Double) -> Double {
+    if t < 0.5 {
+        return 4 * t * t * t
+    } else {
+        let t1 = -2 * t + 2
+        return 1 - (t1 * t1 * t1) / 2
+    }
+}

package/ios/Breathing/BreathingParticlesView.swift

@@ -0,0 +1,81 @@
+import SwiftUI
+
+/// Pure SwiftUI particle system - no SpriteKit, no console warnings
+struct BreathingParticlesView: View {
+    let color: Color
+    let particleCount: Int
+    let speedRange: ClosedRange<Double>
+    let sizeRange: ClosedRange<CGFloat>
+    let opacityRange: ClosedRange<Double>
+
+    init(
+        color: Color = .white,
+        particleCount: Int = 20,
+        speedRange: ClosedRange<Double> = 10...30,
+        sizeRange: ClosedRange<CGFloat> = 0.5...2.0,
+        opacityRange: ClosedRange<Double> = 0.1...0.8
+    ) {
+        self.color = color
+        self.particleCount = particleCount
+        self.speedRange = speedRange
+        self.sizeRange = sizeRange
+        self.opacityRange = opacityRange
+    }
+
+    var body: some View {
+        TimelineView(.animation) { timeline in
+            Canvas { context, size in
+                let time = timeline.date.timeIntervalSinceReferenceDate
+
+                for i in 0..<particleCount {
+                    // Use deterministic seed based on particle index
+                    let seed = Double(i) * 1.618033988749895 // Golden ratio for good distribution
+
+                    // Particle properties derived from seed
+                    let baseX = fract(seed * 0.7)
+                    let _ = fract(seed * 1.3) // Reserved for future horizontal variation
+                    let particleSpeed = speedRange.lowerBound + fract(seed * 2.1) * (speedRange.upperBound - speedRange.lowerBound)
+                    let particleSize = sizeRange.lowerBound + CGFloat(fract(seed * 3.7)) * (sizeRange.upperBound - sizeRange.lowerBound)
+                    let baseOpacity = opacityRange.lowerBound + fract(seed * 4.3) * (opacityRange.upperBound - opacityRange.lowerBound)
+                    let lifetime = 2.0 + fract(seed * 5.1) * 2.0 // 2-4 seconds
+
+                    // Calculate current position in lifecycle
+                    let phase = fract((time * particleSpeed / 100.0 + seed) / lifetime)
+
+                    // Y position: rise from bottom to top
+                    let y = size.height * (1.0 - phase)
+
+                    // X position: slight horizontal drift
+                    let drift = sin(time * 0.5 + seed * 10) * 20
+                    let x = baseX * size.width + drift
+
+                    // Opacity: fade in and out
+                    let fadeIn = min(1.0, phase * 5.0) // Quick fade in
+                    let fadeOut = min(1.0, (1.0 - phase) * 3.0) // Slower fade out
+                    let opacity = baseOpacity * fadeIn * fadeOut
+
+                    // Scale: grow then shrink
+                    let scalePhase = phase < 0.3 ? phase / 0.3 : (1.0 - (phase - 0.3) / 0.7)
+                    let scale = 0.5 + scalePhase * 0.5
+
+                    // Draw particle
+                    let rect = CGRect(
+                        x: x - particleSize * scale / 2,
+                        y: y - particleSize * scale / 2,
+                        width: particleSize * scale,
+                        height: particleSize * scale
+                    )
+
+                    context.fill(
+                        Circle().path(in: rect),
+                        with: .color(color.opacity(opacity))
+                    )
+                }
+            }
+        }
+    }
+
+    private func fract(_ x: Double) -> Double {
+        x - floor(x)
+    }
+}