bleam 0.0.8 → 0.0.10

package/templates/native/App.tsx

@@ -0,0 +1,26 @@
+import NativeScript from '@nativescript/react-native'
+import { StyleSheet, Text, View } from 'react-native'
+
+NativeScript.init()
+
+export default function App() {
+  return (
+    <View style={styles.canvas}>
+      <Text style={styles.title}>Bleam</Text>
+      <Text style={styles.message}>
+        Run a Bleam project with npx bleam new or bleam dev.
+      </Text>
+    </View>
+  )
+}
+
+const styles = StyleSheet.create({
+  canvas: {
+    flex: 1,
+    alignItems: 'center',
+    justifyContent: 'center',
+    backgroundColor: '#0b0b0b',
+  },
+  title: { color: '#f5f5f5', fontSize: 28, fontWeight: '700' },
+  message: { color: '#888', fontSize: 14, marginTop: 10 },
+})

package/templates/native/app.json

@@ -0,0 +1,12 @@
+{
+  "expo": {
+    "name": "Bleam",
+    "slug": "bleam",
+    "version": "1.0.0",
+    "platforms": ["ios"],
+    "ios": {
+      "appleTeamId": "5SZ3H5P69M",
+      "bundleIdentifier": "dev.bleam.app"
+    }
+  }
+}

package/templates/native/index.ts

@@ -0,0 +1,8 @@
+import { registerRootComponent } from 'expo'
+
+import App from './App'
+
+// registerRootComponent calls AppRegistry.registerComponent('main', () => App);
+// It also ensures that whether you load the app in Expo Go or in a native build,
+// the environment is set up appropriately
+registerRootComponent(App)

package/templates/native/ios/.xcode.env

@@ -0,0 +1,11 @@
+# This `.xcode.env` file is versioned and is used to source the environment
+# used when running script phases inside Xcode.
+# To customize your local environment, you can create an `.xcode.env.local`
+# file that is not versioned.
+
+# NODE_BINARY variable contains the PATH to the node executable.
+#
+# Customize the NODE_BINARY variable here.
+# For example, to use nvm with brew, add the following line
+# . "$(brew --prefix nvm)/nvm.sh" --no-use
+export NODE_BINARY=$(command -v node)

package/templates/native/ios/Bleam/AI/Flux2/Configuration/Flux2Config.swift

@@ -0,0 +1,288 @@
+// Flux2Config.swift - Flux.2 Transformer Configuration
+// Copyright 2025 Vincent Gourbin
+
+import Foundation
+
+// MARK: - Model Selection
+
+/// Flux.2 model variants
+public enum Flux2Model: String, CaseIterable, Sendable {
+    /// Flux.2 Klein 4B - 4B parameters, Qwen3-4B text encoder (Apache 2.0)
+    case klein4B = "klein-4b"
+    /// Flux.2 Klein 9B - 9B parameters, Qwen3-8B text encoder (Apache 2.0)
+    case klein9B = "klein-9b"
+
+    public var displayName: String {
+        switch self {
+        case .klein4B: return "Flux.2 Klein 4B"
+        case .klein9B: return "Flux.2 Klein 9B"
+        }
+    }
+
+    /// Whether this is a base (non-distilled) model for training
+    public var isBaseModel: Bool {
+        false
+    }
+
+    /// Whether this model can be used for inference
+    public var isForInference: Bool {
+        true
+    }
+
+    /// Whether this model can be used for LoRA training
+    public var isForTraining: Bool {
+        false
+    }
+
+    /// Get the base (non-distilled) variant for training, if available
+    public var trainingVariant: Flux2Model {
+        .klein4B
+    }
+
+    /// Get the distilled variant for inference (validation images during training)
+    public var inferenceVariant: Flux2Model {
+        .klein4B
+    }
+
+    /// Whether this model uses guidance embeddings
+    public var usesGuidanceEmbeds: Bool {
+        false
+    }
+
+    /// Joint attention dimension (text encoder output)
+    public var jointAttentionDim: Int {
+        switch self {
+        case .klein4B: return 7680   // Qwen3-4B: 3 × 2560
+        case .klein9B: return 12288  // Qwen3-8B: 3 × 4096
+        }
+    }
+
+    /// Get the transformer configuration for this model
+    public var transformerConfig: Flux2TransformerConfig {
+        switch self {
+        case .klein4B: return .klein4B
+        case .klein9B: return .klein9B
+        }
+    }
+
+    /// Estimated VRAM usage in GB
+    public var estimatedVRAM: Int {
+        switch self {
+        case .klein4B: return 13
+        case .klein9B: return 20
+        }
+    }
+
+    /// License information
+    public var license: String {
+        "Apache 2.0"
+    }
+
+    /// Whether this model can be used commercially
+    public var isCommercialUseAllowed: Bool {
+        true
+    }
+
+    /// Recommended number of inference steps for optimal quality
+    public var defaultSteps: Int {
+        4
+    }
+
+    /// Recommended guidance scale for optimal quality
+    public var defaultGuidance: Float {
+        1.0
+    }
+
+    /// Estimated generation time in seconds (1024x1024 on M2 Max)
+    public var estimatedTimeSeconds: Int {
+        switch self {
+        case .klein4B: return 26
+        case .klein9B: return 45
+        }
+    }
+
+    /// Maximum number of reference images for I2I generation
+    /// Source: https://docs.bfl.ai/flux_2/flux2_image_editing
+    public var maxReferenceImages: Int {
+        4
+    }
+}
+
+// MARK: - Transformer Configuration
+
+/// Configuration for the Flux.2 diffusion transformer
+public struct Flux2TransformerConfig: Codable, Sendable {
+    /// Patch size for input embedding (1 for Flux.2)
+    public var patchSize: Int
+
+    /// Number of input channels (128 for Flux.2 latents)
+    public var inChannels: Int
+
+    /// Number of output channels (same as input)
+    public var outChannels: Int
+
+    /// Number of double-stream transformer blocks
+    public var numLayers: Int
+
+    /// Number of single-stream transformer blocks
+    public var numSingleLayers: Int
+
+    /// Dimension of each attention head
+    public var attentionHeadDim: Int
+
+    /// Number of attention heads
+    public var numAttentionHeads: Int
+
+    /// Inner dimension for transformer (numAttentionHeads * attentionHeadDim)
+    public var innerDim: Int {
+        numAttentionHeads * attentionHeadDim
+    }
+
+    /// Dimension of joint attention (from Mistral embeddings: 15360)
+    public var jointAttentionDim: Int
+
+    /// Dimension of pooled projection (time + guidance embeddings)
+    public var pooledProjectionDim: Int
+
+    /// Whether to use guidance embedding
+    public var guidanceEmbeds: Bool
+
+    /// Axes dimensions for RoPE [T, H, W, L]
+    public var axesDimsRope: [Int]
+
+    /// Base theta for RoPE
+    public var ropeTheta: Float
+
+    /// MLP expansion ratio (3.0 for Flux.2, determines FFN hidden dimension)
+    public var mlpRatio: Float
+
+    /// Activation function for feedforward
+    public var activationFunction: String
+
+    public init(
+        patchSize: Int = 1,
+        inChannels: Int = 128,
+        outChannels: Int = 128,
+        numLayers: Int = 8,
+        numSingleLayers: Int = 48,
+        attentionHeadDim: Int = 128,
+        numAttentionHeads: Int = 48,
+        jointAttentionDim: Int = 15360,
+        pooledProjectionDim: Int = 768,
+        guidanceEmbeds: Bool = true,
+        axesDimsRope: [Int] = [32, 32, 32, 32],
+        ropeTheta: Float = 2000.0,
+        mlpRatio: Float = 3.0,
+        activationFunction: String = "silu"
+    ) {
+        self.patchSize = patchSize
+        self.inChannels = inChannels
+        self.outChannels = outChannels
+        self.numLayers = numLayers
+        self.numSingleLayers = numSingleLayers
+        self.attentionHeadDim = attentionHeadDim
+        self.numAttentionHeads = numAttentionHeads
+        self.jointAttentionDim = jointAttentionDim
+        self.pooledProjectionDim = pooledProjectionDim
+        self.guidanceEmbeds = guidanceEmbeds
+        self.axesDimsRope = axesDimsRope
+        self.ropeTheta = ropeTheta
+        self.mlpRatio = mlpRatio
+        self.activationFunction = activationFunction
+    }
+
+    /// Flux.2 Klein 4B configuration
+    /// 4B parameters, 5 double + 20 single blocks
+    public static let klein4B = Flux2TransformerConfig(
+        patchSize: 1,
+        inChannels: 128,
+        outChannels: 128,
+        numLayers: 5,
+        numSingleLayers: 20,
+        attentionHeadDim: 128,
+        numAttentionHeads: 24,      // 24 × 128 = 3072
+        jointAttentionDim: 7680,    // Qwen3-4B: 3 × 2560
+        pooledProjectionDim: 768,
+        guidanceEmbeds: false,
+        axesDimsRope: [32, 32, 32, 32],
+        ropeTheta: 2000.0,
+        mlpRatio: 3.0,
+        activationFunction: "silu"
+    )
+
+    /// Flux.2 Klein 9B configuration
+    /// 9B parameters, 8 double + 24 single blocks
+    public static let klein9B = Flux2TransformerConfig(
+        patchSize: 1,
+        inChannels: 128,
+        outChannels: 128,
+        numLayers: 8,
+        numSingleLayers: 24,
+        attentionHeadDim: 128,
+        numAttentionHeads: 32,      // 32 × 128 = 4096
+        jointAttentionDim: 12288,   // Qwen3-8B: 3 × 4096
+        pooledProjectionDim: 768,
+        guidanceEmbeds: false,
+        axesDimsRope: [32, 32, 32, 32],
+        ropeTheta: 2000.0,
+        mlpRatio: 3.0,
+        activationFunction: "silu"
+    )
+
+    // MARK: - Codable
+
+    enum CodingKeys: String, CodingKey {
+        case patchSize = "patch_size"
+        case inChannels = "in_channels"
+        case outChannels = "out_channels"
+        case numLayers = "num_layers"
+        case numSingleLayers = "num_single_layers"
+        case attentionHeadDim = "attention_head_dim"
+        case numAttentionHeads = "num_attention_heads"
+        case jointAttentionDim = "joint_attention_dim"
+        case pooledProjectionDim = "pooled_projection_dim"
+        case guidanceEmbeds = "guidance_embeds"
+        case axesDimsRope = "axes_dims_rope"
+        case ropeTheta = "rope_theta"
+        case mlpRatio = "mlp_ratio"
+        case activationFunction = "activation_function"
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+
+        patchSize = try container.decodeIfPresent(Int.self, forKey: .patchSize) ?? 1
+        inChannels = try container.decodeIfPresent(Int.self, forKey: .inChannels) ?? 128
+        outChannels = try container.decodeIfPresent(Int.self, forKey: .outChannels) ?? 128
+        numLayers = try container.decodeIfPresent(Int.self, forKey: .numLayers) ?? 8
+        numSingleLayers = try container.decodeIfPresent(Int.self, forKey: .numSingleLayers) ?? 48
+        attentionHeadDim = try container.decodeIfPresent(Int.self, forKey: .attentionHeadDim) ?? 128
+        numAttentionHeads = try container.decodeIfPresent(Int.self, forKey: .numAttentionHeads) ?? 48
+        jointAttentionDim = try container.decodeIfPresent(Int.self, forKey: .jointAttentionDim) ?? 15360
+        pooledProjectionDim = try container.decodeIfPresent(Int.self, forKey: .pooledProjectionDim) ?? 768
+        guidanceEmbeds = try container.decodeIfPresent(Bool.self, forKey: .guidanceEmbeds) ?? true
+        axesDimsRope = try container.decodeIfPresent([Int].self, forKey: .axesDimsRope) ?? [32, 32, 32, 32]
+        ropeTheta = try container.decodeIfPresent(Float.self, forKey: .ropeTheta) ?? 2000.0
+        mlpRatio = try container.decodeIfPresent(Float.self, forKey: .mlpRatio) ?? 3.0
+        activationFunction = try container.decodeIfPresent(String.self, forKey: .activationFunction) ?? "silu"
+    }
+
+    /// Load configuration from a JSON file
+    public static func load(from url: URL) throws -> Flux2TransformerConfig {
+        let data = try Data(contentsOf: url)
+        return try JSONDecoder().decode(Flux2TransformerConfig.self, from: data)
+    }
+}
+
+extension Flux2TransformerConfig: CustomStringConvertible {
+    public var description: String {
+        """
+        Flux2TransformerConfig(
+            layers: \(numLayers) double + \(numSingleLayers) single,
+            heads: \(numAttentionHeads) × \(attentionHeadDim) = \(innerDim),
+            jointDim: \(jointAttentionDim),
+            rope: \(axesDimsRope) θ=\(ropeTheta)
+        )
+        """
+    }
+}

package/templates/native/ios/Bleam/AI/Flux2/Configuration/MemoryConfig.swift

@@ -0,0 +1,233 @@
+// MemoryConfig.swift - Centralized memory management configuration
+// Copyright 2025 Vincent Gourbin
+
+import Foundation
+import MLX
+
+/// Centralized memory configuration for GPU cache management
+///
+/// Provides dynamic memory management that adapts to:
+/// - System RAM availability
+/// - Image resolution being generated
+        /// - Model size (currently Klein 4B only in image-studio)
+///
+/// On high-RAM systems (64GB+), allows more cache for better performance.
+/// On lower-RAM systems, uses conservative limits to prevent OOM.
+public struct MemoryConfig {
+
+    // MARK: - Constants
+
+    private static let MB = 1024 * 1024
+    private static let GB = 1024 * 1024 * 1024
+
+    // MARK: - Cache Profiles
+
+    /// Memory profile presets - used as hints for dynamic calculation
+    public enum CacheProfile: String, CaseIterable, Sendable {
+        case conservative  // Minimize memory usage (slower)
+        case balanced      // Balance speed and memory
+        case performance   // Maximize speed (more memory)
+        case auto          // Dynamic based on available RAM
+
+        /// Human-readable description
+        public var description: String {
+            switch self {
+            case .conservative: return "Conservative - Minimize memory (may be slower)"
+            case .balanced: return "Balanced - Good tradeoff"
+            case .performance: return "Performance - Maximize speed (uses more memory)"
+            case .auto: return "Auto - Dynamic based on available RAM"
+            }
+        }
+    }
+
+    // MARK: - System Information
+
+    /// Get system RAM in GB
+    public static var systemRAMGB: Int {
+        Int(ProcessInfo.processInfo.physicalMemory / UInt64(GB))
+    }
+
+    /// Estimate available RAM in GB (rough heuristic)
+    /// Reserves ~8GB for system + other apps
+    public static var estimatedAvailableRAMGB: Int {
+        max(8, systemRAMGB - 8)
+    }
+
+    /// Calculate what percentage of RAM we can safely use for GPU cache
+    /// Higher RAM systems can afford to use more cache
+    public static var safeCachePercentage: Double {
+        let ram = systemRAMGB
+        switch ram {
+        case ..<24: return 0.03   // 3% - Very conservative for 16-24GB
+        case 24..<48: return 0.05 // 5% - Conservative for 24-48GB
+        case 48..<96: return 0.08 // 8% - Moderate for 48-96GB
+        case 96..<192: return 0.12 // 12% - Performance for 96-192GB
+        default: return 0.15      // 15% - High performance for 192GB+
+        }
+    }
+
+    // MARK: - Dynamic Cache Calculation
+
+    /// Calculate recommended cache limit based on system RAM
+    /// Returns bytes, or nil for unlimited
+    public static func recommendedCacheLimit() -> Int? {
+        let ram = systemRAMGB
+
+        // Very high RAM systems (128GB+) can use unlimited cache
+        if ram >= 128 {
+            return nil
+        }
+
+        // Calculate based on percentage of RAM
+        let cacheBytes = Int(Double(ram * GB) * safeCachePercentage)
+
+        // Clamp to reasonable bounds
+        let minCache = 256 * MB   // At least 256 MB
+        let maxCache = 8 * GB     // At most 8 GB
+
+        return min(max(cacheBytes, minCache), maxCache)
+    }
+
+    /// Calculate cache limit for a specific resolution
+    /// Larger images need more cache for intermediate computations
+    public static func cacheLimitForResolution(width: Int, height: Int, model: Flux2Model) -> Int {
+        let pixels = width * height
+        let baseLimit = recommendedCacheLimit() ?? (4 * GB)
+
+        // Scale factor based on resolution
+        // 512x512 = 262144 pixels (base)
+        // 1024x1024 = 1048576 pixels (4x)
+        // 2048x2048 = 4194304 pixels (16x)
+        let basePixels = 512 * 512
+        let scaleFactor = max(1.0, sqrt(Double(pixels) / Double(basePixels)))
+
+        // Model size factor
+        let modelFactor: Double = 1.0
+
+        let adjustedLimit = Int(Double(baseLimit) * scaleFactor * modelFactor)
+
+        // Clamp to available RAM (leave at least 8GB for system)
+        let maxAllowed = (systemRAMGB - 8) * GB
+        return min(adjustedLimit, maxAllowed)
+    }
+
+    // MARK: - Profile-based Limits (for manual override)
+
+    /// Get cache limit for a specific profile
+    public static func cacheLimitForProfile(_ profile: CacheProfile) -> Int? {
+        switch profile {
+        case .auto:
+            return recommendedCacheLimit()
+        case .conservative:
+            return 512 * MB
+        case .balanced:
+            return min(2 * GB, (systemRAMGB / 32) * GB)
+        case .performance:
+            return min(4 * GB, (systemRAMGB / 16) * GB)
+        }
+    }
+
+    // MARK: - Cache Limit Application
+
+    /// Apply cache limit dynamically based on system RAM
+    public static func applyDynamicCacheLimit() {
+        if let limit = recommendedCacheLimit() {
+            Memory.cacheLimit = limit
+            Flux2Debug.log("GPU cache limit: \(limit / MB) MB (dynamic, \(systemRAMGB) GB RAM)")
+        } else {
+            Flux2Debug.log("GPU cache: unlimited (\(systemRAMGB) GB RAM)")
+        }
+    }
+
+    /// Apply cache limit for a specific profile
+    public static func applyCacheLimit(_ profile: CacheProfile) {
+        if let limit = cacheLimitForProfile(profile) {
+            Memory.cacheLimit = limit
+            Flux2Debug.log("GPU cache limit: \(limit / MB) MB (\(profile.rawValue) profile)")
+        } else {
+            Flux2Debug.log("GPU cache: unlimited (\(profile.rawValue) profile)")
+        }
+    }
+
+    /// Apply cache limit with specific byte value
+    public static func applyCacheLimit(bytes: Int) {
+        Memory.cacheLimit = bytes
+        Flux2Debug.log("GPU cache limit: \(bytes / MB) MB")
+    }
+
+    /// Clear GPU cache
+    public static func clearCache() {
+        Memory.clearCache()
+    }
+
+    // MARK: - Phase-Specific Limits
+
+    /// Per-phase cache limits for granular control during generation
+    public struct PhaseLimits: Sendable {
+        public let textEncoding: Int   // Text encoder phase
+        public let denoising: Int      // Transformer denoising loop
+        public let vaeDecoding: Int    // VAE decode phase
+
+        public init(textEncoding: Int, denoising: Int, vaeDecoding: Int) {
+            self.textEncoding = textEncoding
+            self.denoising = denoising
+            self.vaeDecoding = vaeDecoding
+        }
+
+        /// Get dynamic phase limits based on model and system RAM
+        /// Automatically scales based on available memory
+        public static func forModel(_ model: Flux2Model, profile: CacheProfile) -> PhaseLimits {
+            // Use dynamic calculation for auto profile
+            if profile == .auto {
+                return dynamicLimitsForModel(model)
+            }
+
+            switch profile {
+            case .auto:
+                return dynamicLimitsForModel(model)
+            case .conservative:
+                return PhaseLimits(textEncoding: 256 * MB, denoising: 512 * MB, vaeDecoding: 256 * MB)
+            case .balanced:
+                return PhaseLimits(textEncoding: 512 * MB, denoising: 1 * GB, vaeDecoding: 512 * MB)
+            case .performance:
+                return PhaseLimits(textEncoding: 1 * GB, denoising: 2 * GB, vaeDecoding: 1 * GB)
+            }
+        }
+
+        /// Calculate dynamic limits based on available RAM
+        private static func dynamicLimitsForModel(_ model: Flux2Model) -> PhaseLimits {
+            let baseLimit = recommendedCacheLimit() ?? (4 * GB)
+
+            _ = model
+            let (textRatio, denoiseRatio, vaeRatio): (Double, Double, Double) = (0.25, 0.6, 0.3)
+
+            return PhaseLimits(
+                textEncoding: Int(Double(baseLimit) * textRatio),
+                denoising: Int(Double(baseLimit) * denoiseRatio),
+                vaeDecoding: Int(Double(baseLimit) * vaeRatio)
+            )
+        }
+    }
+
+    // MARK: - Memory Monitoring
+
+    /// Log current memory state
+    public static func logMemoryState(context: String = "") {
+        let prefix = context.isEmpty ? "" : "[\(context)] "
+        let recommended = recommendedCacheLimit()
+        let limitStr = recommended.map { "\($0 / MB) MB" } ?? "unlimited"
+        Flux2Debug.log("\(prefix)System: \(systemRAMGB) GB RAM, recommended cache: \(limitStr)")
+    }
+
+    /// Get a summary of current memory configuration
+    public static var configurationSummary: String {
+        let recommended = recommendedCacheLimit()
+        let limitStr = recommended.map { "\($0 / MB) MB" } ?? "unlimited"
+        return """
+        Memory Configuration:
+          System RAM: \(systemRAMGB) GB
+          Safe cache %: \(Int(safeCachePercentage * 100))%
+          Recommended cache: \(limitStr)
+        """
+    }
+}