catalyst-core 0.3.0-beta.5 → 0.3.0-canary.2

package/dist/native/buildErrorFormat.js

@@ -0,0 +1,57 @@
+"use strict";
+
+const pc = require("ansis");
+
+// src/native is a CJS-only subtree (see src/native/package.json) and cannot
+// synchronously require() the ESM errors/index.js module under Node 20, so
+// output-mode formatting for buildAppAndroid.js/buildAppIos.js is
+// hand-rolled here rather than shared with errors/index.js's box/formatVerbose/
+// formatDebug — those two files are the only callers, and both native build
+// failure sites need the same minimal shape.
+
+function resolveOutputMode() {
+  if (process.argv.includes("--debug")) return "debug";
+  if (process.argv.includes("--verbose")) return "verbose";
+  return "default";
+}
+function box(bodyLines) {
+  const width = 70;
+  const top = pc.red(`┌${"─".repeat(width)}`);
+  const bottom = pc.red(`└${"─".repeat(width)}`);
+  const body = bodyLines.map(line => line === "" ? pc.red("│") : `${pc.red("│")} ${line}`);
+  return [top, ...body, bottom].join("\n");
+}
+
+/**
+ * Format a native build failure for terminal output. `code`/`category`
+ * identify the generic upstream-toolchain wrapper (ANDROID-000/IOS-000 —
+ * see errors/ANDROID/ANDROID-000.md and errors/IOS/IOS-000.md); the
+ * upstream message is always shown verbatim, never reinterpreted.
+ */
+function formatBuildError({
+  code,
+  category,
+  upstreamName,
+  error
+}) {
+  // Xcode/Gradle tooling (via execSync and friends) can reject with a plain
+  // string, null, or undefined instead of an Error instance — normalize
+  // before touching .message/.stack so a non-Error failure still prints
+  // something useful instead of throwing or rendering "undefined".
+  const message = error instanceof Error ? error.message : String(error);
+  const stack = error instanceof Error ? error.stack || "(no stack available)" : "(no stack available)";
+  const mode = resolveOutputMode();
+  if (mode === "default") {
+    return `[${code}] Build failed (upstream: ${upstreamName})\n→ ${message}`;
+  }
+  const lines = [`❌ Build failed (upstream: ${upstreamName})`, `Code: ${code}`, `Category: ${category}`, `Time: ${new Date().toISOString()}`, "", `Problem: ${message}`];
+  if (mode === "debug") {
+    lines.push("", "Environment:", `  node: ${process.version}`, `  platform: ${process.platform}`);
+    lines.push("", "Stack trace:", ...stack.split("\n").map(l => `  ${l}`));
+  }
+  return box(lines);
+}
+module.exports = {
+  resolveOutputMode,
+  formatBuildError
+};

package/dist/native/buildIos/config.js

@@ -121,15 +121,29 @@ module.exports = function createConfigPhase(ctx) {
   async function generateConfigConstants() {
     progress.start("config");
     try {
+      // CatalystCoreLogic (#432): ConfigConstants moved into the nested
+      // CoreLogic/ package so it can be consumed by swift-test-only code
+      // without pulling in UIKit. This generator must write to the new
+      // location, not the old Sources/Core/Constants/ path.
       const appConfigPath = path.join(PROJECT_DIR,
       // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal - PROJECT_DIR is the fixed generated iOS project directory.
-      "Sources", "Core", "Constants", "ConfigConstants.swift");
+      "CoreLogic", "Sources", "CatalystCoreLogic", "Constants", "ConfigConstants.swift");
       const appConfigDir = path.dirname(appConfigPath);
       if (!fs.existsSync(appConfigDir)) fs.mkdirSync(appConfigDir, {
         recursive: true
       });
+
+      // CatalystCoreLogic's Package.swift declares platforms: [.iOS(.v17),
+      // .macOS(.v13)] so `swift test` can run this file on plain macOS (no
+      // simulator). UIKit doesn't exist there, so CGFloat needs the same
+      // canImport guard already used in the checked-in CatalystConstants.swift.
       let configContent = `// This file is auto-generated. Do not edit.
 import Foundation
+#if canImport(UIKit)
+import UIKit
+#elseif canImport(CoreGraphics)
+import CoreGraphics
+#endif
 
 public enum ConfigConstants {
     public static let url = "${url}"`;

package/dist/native/buildIos/index.js

@@ -6,7 +6,7 @@ const {
 } = require("child_process");
 const fs = require("fs");
 const path = require("path");
-const TerminalProgress = require("../TerminalProgress.js").default;
+const TerminalProgress = require("../terminalProgress.js").default;
 const createConfigPhase = require("./config.js");
 const createPluginsPhase = require("./plugins.js");
 const createAssetsPhase = require("./assets.js");

package/dist/native/buildIos/plugins.js

@@ -158,15 +158,23 @@ import PackageDescription
 
 let package = Package(
     name: "iosnativeWebView",
-    platforms: [.iOS(.v17)],
+    platforms: [.iOS(.v17), .macOS(.v13)],
     products: [
         .library(name: "CatalystCore", targets: ["CatalystCore"])`;
         if (isNotificationsEnabled) {
           packageContent += `,\n        .library(name: "CatalystNotifications", targets: ["CatalystNotifications"])`;
         }
+
+        // CatalystCoreLogic (#432) is a local nested package (CoreLogic/), not a
+        // remote dependency, so it has no `url` and cannot flow through
+        // mergePackageDependency/formatSwiftPackageEntries (both keyed on url).
+        // Emitted as a literal .package(path:) entry instead. Its own
+        // Package.swift is static/checked-in (no config-dependent content), so
+        // it is never itself regenerated here.
         packageContent += `
     ],
     dependencies: [
+        .package(path: "CoreLogic"),
 ${formatSwiftPackageEntries(packageDependencies).join(",\n")}
     ],
     targets: [
@@ -175,6 +183,7 @@ ${formatSwiftPackageEntries(packageDependencies).join(",\n")}
         .target(
             name: "CatalystCore",
             dependencies: [
+                .product(name: "CatalystCoreLogic", package: "CoreLogic"),
 ${formatSwiftProductEntries(coreDependencies).join(",\n")}
             ],
             path: "Sources/Core"

package/dist/native/iosnativeWebView/CoreLogic/Package.swift

@@ -0,0 +1,36 @@
+// swift-tools-version: 5.9
+// Nested package for UIKit-free logic (#432).
+// Static/checked-in — never generated. Unlike the parent Package.swift,
+// this file has no config-dependent content (no plugin manifests, no
+// notifications gate), so buildIos/plugins.js does not regenerate it.
+//
+// Kept as a genuinely separate SPM package (not a target inside the parent
+// package) because `swift test`/`swift build` at the parent package root
+// always resolves and builds every target in the graph regardless of
+// --target/--filter scoping — verified directly: with CatalystCoreLogic as
+// a target of the parent package, `swift test --filter
+// BootTimingUtilityTests` still compiled CatalystCore and failed on
+// `import UIKit`. A separate package with its own root sidesteps this:
+// `swift test --package-path CoreLogic` only resolves this package's own
+// graph (zero dependencies), never touches the parent package or its
+// UIKit/GoogleSignIn-importing files.
+import PackageDescription
+
+let package = Package(
+    name: "CatalystCoreLogic",
+    platforms: [.iOS(.v17), .macOS(.v13)],
+    products: [
+        .library(name: "CatalystCoreLogic", targets: ["CatalystCoreLogic"])
+    ],
+    targets: [
+        .target(
+            name: "CatalystCoreLogic",
+            path: "Sources/CatalystCoreLogic"
+        ),
+        .testTarget(
+            name: "CatalystCoreLogicTests",
+            dependencies: ["CatalystCoreLogic"],
+            path: "Tests/CatalystCoreLogicTests"
+        )
+    ]
+)

package/dist/native/iosnativeWebView/{Sources/Core → CoreLogic/Sources/CatalystCoreLogic}/Camera/VideoStreamState.swift

@@ -15,7 +15,7 @@ import Foundation
 //   HOLD      → STOPPING  (stop() called during hold)
 //   STOPPING  → IDLE      (session torn down)
 
-enum VideoStreamState {
+public enum VideoStreamState {
     case idle
     case starting
     case streaming

package/dist/native/iosnativeWebView/{Sources/Core → CoreLogic/Sources/CatalystCoreLogic}/Camera/VideoStreamStateMachine.swift

@@ -8,19 +8,21 @@ private final class WeakListenerBox {
     init(_ value: VideoStreamStateListener) { self.value = value }
 }
 
-class VideoStreamStateMachine {
+public class VideoStreamStateMachine {
 
     private var _state: VideoStreamState = .idle
     private var listeners: [WeakListenerBox] = []
     private let lock = NSLock()
 
-    var state: VideoStreamState {
+    public init() {}
+
+    public var state: VideoStreamState {
         lock.lock()
         defer { lock.unlock() }
         return _state
     }
 
-    var isActive: Bool {
+    public var isActive: Bool {
         lock.lock()
         defer { lock.unlock() }
         return _state.isActive
@@ -39,7 +41,7 @@ class VideoStreamStateMachine {
     }
 
     @discardableResult
-    func transition(to next: VideoStreamState) -> Bool {
+    public func transition(to next: VideoStreamState) -> Bool {
         lock.lock()
         let prev = _state
         guard prev.canTransitionTo(next) else {

package/dist/native/iosnativeWebView/{Sources/Core → CoreLogic/Sources/CatalystCoreLogic}/Utils/BootTimingUtility.swift

@@ -9,13 +9,13 @@
 import Foundation
 import os
 
-enum AppBoot {
-    static let nativeStartMs = Int64(ProcessInfo.processInfo.systemUptime * 1000)
+public enum AppBoot {
+    public static let nativeStartMs = Int64(ProcessInfo.processInfo.systemUptime * 1000)
 }
 
 #if DEBUG
 // Global app launch timestamp for all timing measurements
-let APP_LAUNCH_TIME = CFAbsoluteTimeGetCurrent()
+public let APP_LAUNCH_TIME = CFAbsoluteTimeGetCurrent()
 
 private let timingLogger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "com.app", category: "Timing")
 

package/dist/native/iosnativeWebView/{Sources/Core → CoreLogic/Sources/CatalystCoreLogic}/Utils/FrameworkServerUtils.swift

@@ -90,7 +90,7 @@ private class ConnectionWrapper: Hashable {
 
 // MARK: - Framework Server Utils
 
-class FrameworkServerUtils {
+public class FrameworkServerUtils {
 
     // Constants from unified configuration
     static let FRAMEWORK_PORT_RANGE_START: UInt16 = CatalystConstants.NetworkServer.portRangeStart
@@ -98,7 +98,7 @@ class FrameworkServerUtils {
     static let SESSION_TIMEOUT_SECONDS: TimeInterval = CatalystConstants.NetworkServer.sessionTimeout
 
     // Singleton instance
-    static let shared = FrameworkServerUtils()
+    public static let shared = FrameworkServerUtils()
 
     // Server state
     private var listener: NWListener?
@@ -134,7 +134,7 @@ class FrameworkServerUtils {
      * Initialize and start the framework server
      * @return Boolean indicating success/failure of server startup
      */
-    func startServer() -> Bool {
+    public func startServer() -> Bool {
         logger.debug("Starting framework server...")
 
         if self.isServerRunning {
@@ -283,7 +283,7 @@ class FrameworkServerUtils {
      * @param mimeType MIME type
      * @return URL where the file can be accessed, or nil if failed
      */
-    func copyAndServeFile(originalFile: URL, fileName: String, mimeType: String) -> String? {
+    public func copyAndServeFile(originalFile: URL, fileName: String, mimeType: String) -> String? {
         guard isServerRunning, let cacheDirectory = cacheDirectory else {
             logger.error("Cannot copy and serve file - server not running or cache not initialized")
             return nil
@@ -328,7 +328,7 @@ class FrameworkServerUtils {
     /**
      * Check if server is running
      */
-    func isRunning() -> Bool {
+    public func isRunning() -> Bool {
         return isServerRunning
     }
 
@@ -484,10 +484,15 @@ class FrameworkServerUtils {
             return nil
         }
 
-        guard let identity = firstItem[kSecImportItemIdentity as String] as! SecIdentity? else {
+        guard let identityAny = firstItem[kSecImportItemIdentity as String],
+              CFGetTypeID(identityAny as CFTypeRef) == SecIdentityGetTypeID() else {
             logger.error("No identity found in PKCS#12 import")
             return nil
         }
+        let identity = identityAny as! SecIdentity  // swiftlint:disable:this force_cast
+        // ^ SecIdentity is a CoreFoundation type with no Swift-native
+        // bridge; `as?` can't express it. The CFTypeID check above is the
+        // real guard.
 
         logger.info("✅ Successfully loaded identity from PKCS#12 file")
         return identity
@@ -502,13 +507,13 @@ class FrameworkServerUtils {
         if let identity = loadIdentityFromP12(),
            let secIdentity = sec_identity_create(identity) {
             let tlsOptions = NWProtocolTLS.Options()
-            
+
             // Set the identity
             sec_protocol_options_set_local_identity(tlsOptions.securityProtocolOptions, secIdentity)
-            
+
             // Set minimum TLS version
             sec_protocol_options_set_min_tls_protocol_version(tlsOptions.securityProtocolOptions, .TLSv12)
-            
+
             // Add TLS to the protocol stack
             parameters.defaultProtocolStack.applicationProtocols.insert(tlsOptions, at: 0)
 

package/dist/native/iosnativeWebView/{Sources/Core → CoreLogic/Sources/CatalystCoreLogic}/Utils/NetworkMonitor.swift

@@ -2,13 +2,13 @@ import Foundation
 import Network
 import os
 
-struct NetworkStatus {
-    let isOnline: Bool
-    let type: String?
+public struct NetworkStatus {
+    public let isOnline: Bool
+    public let type: String?
 }
 
-final class NetworkMonitor {
-    static let shared = NetworkMonitor()
+public final class NetworkMonitor {
+    public static let shared = NetworkMonitor()
 
     private let monitor: NWPathMonitor
     private let monitorQueue = DispatchQueue(label: "com.catalyst.network.monitor")
@@ -32,12 +32,12 @@ final class NetworkMonitor {
         }
     }
 
-    var currentStatus: NetworkStatus {
+    public var currentStatus: NetworkStatus {
         stateQueue.sync { latestStatus }
     }
 
     @discardableResult
-    func addListener(_ listener: @escaping (NetworkStatus) -> Void) -> UUID {
+    public func addListener(_ listener: @escaping (NetworkStatus) -> Void) -> UUID {
         let id = UUID()
 
         stateQueue.async { [weak self] in
@@ -55,7 +55,7 @@ final class NetworkMonitor {
         return id
     }
 
-    func removeListener(_ id: UUID) {
+    public func removeListener(_ id: UUID) {
         stateQueue.async { [weak self] in
             self?.listeners.removeValue(forKey: id)
         }
@@ -87,7 +87,9 @@ final class NetworkMonitor {
         }
     }
 
-    private static func mapPathToStatus(_ path: NWPath) -> NetworkStatus {
+    // Internal (not private) so @testable import can exercise this pure
+    // mapping logic directly without needing a live NWPathMonitor callback.
+    static func mapPathToStatus(_ path: NWPath) -> NetworkStatus {
         let isOnline = path.status == .satisfied
 
         let type: String?

package/dist/native/iosnativeWebView/{Sources/Core → CoreLogic/Sources/CatalystCoreLogic}/Utils/NotificationHandlerProvider.swift

@@ -11,7 +11,7 @@ import Foundation
 /// Allows the App target to inject the real NotificationManager when notifications are enabled
 public class NotificationHandlerProvider {
     public static var shared: NotificationHandlerProtocol = NullNotificationHandler.shared
-    
+
     /// Inject the notification handler at app startup
     /// Call this from the App target when notifications are enabled
     public static func inject(_ handler: NotificationHandlerProtocol) {

package/dist/native/iosnativeWebView/{Sources/Core → CoreLogic/Sources/CatalystCoreLogic}/Utils/URLWhitelistManager.swift

@@ -22,8 +22,8 @@ private struct CategorizedPatterns {
 /// - Query parameters and hash fragments are stripped before matching
 /// - Matching is case-insensitive
 /// - Ports are kept as-is (user must include port in pattern if URL has explicit port)
-class URLWhitelistManager {
-    static let shared = URLWhitelistManager()
+public class URLWhitelistManager {
+    public static let shared = URLWhitelistManager()
 
     private var accessControlEnabled: Bool = false
     private var patterns: CategorizedPatterns?
@@ -66,7 +66,7 @@ class URLWhitelistManager {
     }
 
     /// Check if URL whitelisting is enabled
-    var isAccessControlEnabled: Bool {
+    public var isAccessControlEnabled: Bool {
         return syncQueue.sync { self.accessControlEnabled }
     }
 
@@ -74,7 +74,7 @@ class URLWhitelistManager {
     /// If access control is disabled, all URLs are allowed
     /// - Parameter url: The URL to check
     /// - Returns: true if URL is allowed, false otherwise
-    func isUrlAllowed(_ url: URL) -> Bool {
+    public func isUrlAllowed(_ url: URL) -> Bool {
         return isUrlAllowed(url.absoluteString)
     }
 
@@ -82,7 +82,7 @@ class URLWhitelistManager {
     /// If access control is disabled, all URLs are allowed
     /// - Parameter urlString: The URL string to check
     /// - Returns: true if URL is allowed, false otherwise
-    func isUrlAllowed(_ urlString: String) -> Bool {
+    public func isUrlAllowed(_ urlString: String) -> Bool {
         return syncQueue.sync {
             // If access control is disabled, allow everything
             if !self.accessControlEnabled {
@@ -139,7 +139,7 @@ class URLWhitelistManager {
     /// If access control is disabled, nothing is considered external
     /// - Parameter url: The URL to check
     /// - Returns: true if URL is external, false if it's whitelisted
-    func isExternalDomain(_ url: URL) -> Bool {
+    public func isExternalDomain(_ url: URL) -> Bool {
         return isExternalDomain(url.absoluteString)
     }
 
@@ -147,7 +147,7 @@ class URLWhitelistManager {
     /// If access control is disabled, nothing is considered external
     /// - Parameter urlString: The URL string to check
     /// - Returns: true if URL is external, false if it's whitelisted
-    func isExternalDomain(_ urlString: String) -> Bool {
+    public func isExternalDomain(_ urlString: String) -> Bool {
         // If access control is disabled, nothing is external
         if !self.accessControlEnabled {
             return false

package/dist/native/iosnativeWebView/CoreLogic/Tests/CatalystCoreLogicTests/AnyCodableTests.swift

@@ -0,0 +1,154 @@
+import XCTest
+@testable import CatalystCoreLogic
+
+/**
+ * Unit tests for AnyCodable
+ *
+ * AnyCodable's encode/decode both try a fixed sequence of types (bool, int,
+ * double, string, array, dictionary) — these tests exercise every branch of
+ * both chains directly, plus the NotificationConfig.data field (the actual
+ * production use site) round-tripping through it.
+ */
+final class AnyCodableTests: XCTestCase {
+
+    // MARK: - Decode: each branch of the type-sniffing chain
+
+    func testDecode_Bool() throws {
+        let json = "true"
+        let decoded = try JSONDecoder().decode(AnyCodable.self, from: Data(json.utf8))
+        XCTAssertEqual(decoded.value as? Bool, true)
+    }
+
+    func testDecode_Int() throws {
+        let json = "42"
+        let decoded = try JSONDecoder().decode(AnyCodable.self, from: Data(json.utf8))
+        XCTAssertEqual(decoded.value as? Int, 42)
+    }
+
+    func testDecode_Double() throws {
+        let json = "3.14"
+        let decoded = try JSONDecoder().decode(AnyCodable.self, from: Data(json.utf8))
+        XCTAssertEqual(decoded.value as? Double, 3.14)
+    }
+
+    func testDecode_String() throws {
+        let json = "\"hello\""
+        let decoded = try JSONDecoder().decode(AnyCodable.self, from: Data(json.utf8))
+        XCTAssertEqual(decoded.value as? String, "hello")
+    }
+
+    func testDecode_Array() throws {
+        let json = "[1, 2, 3]"
+        let decoded = try JSONDecoder().decode(AnyCodable.self, from: Data(json.utf8))
+        let array = try XCTUnwrap(decoded.value as? [Any])
+        XCTAssertEqual(array.count, 3)
+        XCTAssertEqual(array[0] as? Int, 1)
+    }
+
+    func testDecode_Dictionary() throws {
+        let json = #"{"key": "value", "count": 5}"#
+        let decoded = try JSONDecoder().decode(AnyCodable.self, from: Data(json.utf8))
+        let dict = try XCTUnwrap(decoded.value as? [String: Any])
+        XCTAssertEqual(dict["key"] as? String, "value")
+        XCTAssertEqual(dict["count"] as? Int, 5)
+    }
+
+    func testDecode_UnsupportedType_ThrowsDataCorrupted() {
+        // `null` isn't handled by any branch (no explicit null case), so
+        // decoding should fail rather than silently succeed with a wrong value.
+        let json = "null"
+        XCTAssertThrowsError(
+            try JSONDecoder().decode(AnyCodable.self, from: Data(json.utf8))
+        )
+    }
+
+    // MARK: - Encode: each branch of the type-checking chain
+
+    func testEncode_Bool() throws {
+        let encodable = AnyCodable(true)
+        let data = try JSONEncoder().encode(encodable)
+        XCTAssertEqual(String(data: data, encoding: .utf8), "true")
+    }
+
+    func testEncode_Int() throws {
+        let encodable = AnyCodable(42)
+        let data = try JSONEncoder().encode(encodable)
+        XCTAssertEqual(String(data: data, encoding: .utf8), "42")
+    }
+
+    func testEncode_Double() throws {
+        let encodable = AnyCodable(3.14)
+        let data = try JSONEncoder().encode(encodable)
+        XCTAssertEqual(String(data: data, encoding: .utf8), "3.14")
+    }
+
+    func testEncode_String() throws {
+        let encodable = AnyCodable("hello")
+        let data = try JSONEncoder().encode(encodable)
+        XCTAssertEqual(String(data: data, encoding: .utf8), "\"hello\"")
+    }
+
+    func testEncode_Array() throws {
+        let encodable = AnyCodable([1, 2, 3])
+        let data = try JSONEncoder().encode(encodable)
+        let decoded = try JSONSerialization.jsonObject(with: data) as? [Int]
+        XCTAssertEqual(decoded, [1, 2, 3])
+    }
+
+    func testEncode_Dictionary() throws {
+        let encodable = AnyCodable(["key": "value"])
+        let data = try JSONEncoder().encode(encodable)
+        let decoded = try JSONSerialization.jsonObject(with: data) as? [String: String]
+        XCTAssertEqual(decoded, ["key": "value"])
+    }
+
+    func testEncode_UnsupportedType_Throws() {
+        struct NotCodableAtAll {}
+        let encodable = AnyCodable(NotCodableAtAll())
+        XCTAssertThrowsError(try JSONEncoder().encode(encodable))
+    }
+
+    // MARK: - Round trip via NotificationConfig.data (the real production use site)
+
+    func testNotificationConfig_DataFieldRoundTripsMixedTypes() throws {
+        let config = NotificationConfig(
+            title: "Test",
+            body: "Body",
+            data: [
+                "flag": true,
+                "count": 7,
+                "label": "hello",
+                "list": [1, 2, 3],
+            ]
+        )
+
+        let json = try XCTUnwrap(config.toJSON())
+        let restored = try XCTUnwrap(NotificationConfig.fromJSON(json))
+        let data = try XCTUnwrap(restored.data)
+
+        XCTAssertEqual(data["flag"]?.value as? Bool, true)
+        XCTAssertEqual(data["count"]?.value as? Int, 7)
+        XCTAssertEqual(data["label"]?.value as? String, "hello")
+        XCTAssertEqual((data["list"]?.value as? [Any])?.count, 3)
+    }
+
+    func testNotificationConfig_NilDataFieldRoundTrips() throws {
+        let config = NotificationConfig(title: "Test", body: "Body", data: nil)
+
+        let json = try XCTUnwrap(config.toJSON())
+        let restored = try XCTUnwrap(NotificationConfig.fromJSON(json))
+
+        XCTAssertNil(restored.data)
+    }
+
+    func testNotificationConfig_FromJSON_InvalidJSON_ReturnsNil() {
+        XCTAssertNil(NotificationConfig.fromJSON("{not valid json"))
+    }
+
+    func testNotificationConfig_FromJSON_NonUTF8_ReturnsNil() {
+        // fromJSON's own guard (data(using: .utf8)) is defensive — exercised
+        // indirectly since almost all Swift Strings are representable as
+        // UTF8. Documented as effectively unreachable in practice, not
+        // asserted here.
+    }
+}

package/dist/native/iosnativeWebView/{iosnativeWebViewTests → CoreLogic/Tests/CatalystCoreLogicTests}/BootTimingUtilityTests.swift

@@ -1,6 +1,6 @@
 import XCTest
 import Foundation
-@testable import CatalystCore
+@testable import CatalystCoreLogic
 
 /**
  * Unit tests for BootTimingUtility
@@ -94,10 +94,17 @@ final class BootTimingUtilityTests: XCTestCase {
         XCTAssertGreaterThan(elapsedAfter, elapsedBefore,
             "Elapsed time should increase over time")
 
-        // Verify the difference is approximately 10ms (with tolerance for system variance)
+        // Verify the difference is at least the ~10ms sleep, with a floor
+        // to catch a broken/zero calculation. No upper bound: this was
+        // previously capped at 50ms "accounting for system load", but
+        // that's asserting real OS scheduler latency for Thread.sleep,
+        // which a shared/loaded CI runner can legitimately exceed (seen:
+        // 62ms) with zero relation to whether APP_LAUNCH_TIME-based
+        // elapsed-time math is correct. The floor + the
+        // elapsedAfter > elapsedBefore check above already cover the
+        // logic this test exists to verify.
         let difference = elapsedAfter - elapsedBefore
         XCTAssertGreaterThan(difference, 5.0, "Time difference should be at least 5ms")
-        XCTAssertLessThan(difference, 50.0, "Time difference should be less than 50ms (accounting for system load)")
         #else
         XCTAssertTrue(true, "Skipping DEBUG-only test in RELEASE build")
         #endif
@@ -193,14 +200,25 @@ final class BootTimingUtilityTests: XCTestCase {
         let expectation = self.expectation(description: "Concurrent logging completes")
         expectation.expectedFulfillmentCount = 10
 
+        // Raising the wait timeout alone did not fix this test: it failed at
+        // exactly 10s, then again at exactly 60s after that bump -- a hit-the-
+        // timeout-precisely pattern is scheduling starvation, not slowness.
+        // `.background` QoS is deliberately deprioritized by the OS and can be
+        // starved indefinitely under CPU contention on a busy CI host, so no
+        // timeout is safe against it. `.userInitiated` still exercises the
+        // thing this test actually verifies (logWithTimestamp handles
+        // concurrent calls without crashing/corrupting) without depending on
+        // background-priority scheduling ever getting CPU time.
         for i in 0..<10 {
-            DispatchQueue.global(qos: .background).async {
+            DispatchQueue.global(qos: .userInitiated).async {
                 logWithTimestamp("Concurrent log \(i)")
                 expectation.fulfill()
             }
         }
 
-        waitForExpectations(timeout: 10.0) { error in
+        // Kept generous as headroom for host variance (~15-20% build/test time
+        // swings observed run-to-run on shared CI runners), not as the fix.
+        waitForExpectations(timeout: 60.0) { error in
             XCTAssertNil(error, "Concurrent logging should complete without errors")
         }
     }