react-native-acoustic-connect-beta 19.0.5 → 19.0.7

package/AcousticConnectRN.podspec

@@ -115,12 +115,45 @@ Pod::Spec.new do |s|
     # Implementation (C++ objects)
     "cpp/**/*.{hpp,cpp}",
   ]
+  # Unit tests live in ios/Tests and belong to the UnitTests test_spec below,
+  # not to the library target (source_files globs ios/**/*.swift).
+  s.exclude_files = "ios/Tests/**"
 
   s.pod_target_xcconfig = {
     # C++ compiler flags, mainly for folly.
-    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES"
+    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES",
+    # @testable import (UnitTests test_spec) needs testability in Debug.
+    "ENABLE_TESTABILITY[config=Debug]" => "YES"
   }
 
+  # Native unit tests. Run through a consumer app's Pods project:
+  #   Podfile: pod 'AcousticConnectRN', :path => '../..', :testspecs => ['UnitTests']
+  #   xcodebuild test -workspace <app>.xcworkspace -scheme AcousticConnectRN \
+  #     -destination 'platform=iOS Simulator,name=<booted sim>'
+  # The tests use Swift Testing. They do NOT `@testable import` the pod
+  # module — see the source_files comment below for why that's impossible.
+  s.test_spec 'UnitTests' do |ts|
+    # The sources under test are compiled directly into the test bundle
+    # instead of `@testable import`ing the pod module: nitrogen's generated
+    # Swift compatibility header emits C++ thunks referencing nitro C++ types
+    # (margelo::nitro::ArrayBufferHolder) without including their headers, so
+    # the AcousticConnectRN clang module cannot be built by any Swift client —
+    # including a test target. Compiling the files here is safe: the linker
+    # pulls static-archive members lazily, so the parent lib's copies of
+    # these objects are never loaded and no duplicate symbols arise.
+    ts.source_files = [
+      'ios/Tests/**/*.swift',
+      'ios/ConnectRNParsing.swift',
+      'nitrogen/generated/ios/swift/Variant_Bool_String_Double.swift',
+    ]
+    # ios/ConnectRNParsing.swift does `import Connect`. CocoaPods test_specs
+    # inherit the parent spec's dependencies implicitly, so this line is
+    # observably redundant today — declared explicitly anyway so the test
+    # bundle's dependency on the Connect SDK doesn't rely on that inheritance
+    # behavior remaining unchanged (e.g. a future migration off CocoaPods).
+    ts.dependency dependencyName, *dependencyRequirements
+  end
+
   s.resource_bundle = {
     'AcousticConnectRNConfig' => ['ios/AcousticConnectRNConfig.json'],
   }

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 19.0.7 (2026-07-03)
+
+### Reverts
+
+* Revert "Beta ReactNativeConnect build: 18.0.36" ([609ad7d](https://github.com/aipoweredmarketer/react-native-acoustic-connect-beta/commit/609ad7d3244ec06f27dced5864d40585c5b3c9cf))
+## [19.0.6](https://github.com/aipoweredmarketer/react-native-acoustic-connect-beta/compare/19.0.5...19.0.6) (2026-07-02)
 ## [19.0.5](https://github.com/aipoweredmarketer/react-native-acoustic-connect-beta/compare/19.0.4...19.0.5) (2026-07-02)
 ## [19.0.4](https://github.com/aipoweredmarketer/react-native-acoustic-connect-beta/compare/19.0.3...19.0.4) (2026-07-01)
 ## [19.0.3](https://github.com/aipoweredmarketer/react-native-acoustic-connect-beta/compare/19.0.2...19.0.3) (2026-06-30)

package/android/build.gradle

@@ -32,6 +32,7 @@ def isNewArchitectureEnabled() {
 
 apply plugin: "com.android.library"
 apply plugin: 'org.jetbrains.kotlin.android'
+apply plugin: 'jacoco'
 apply from: '../nitrogen/generated/android/AcousticConnectRN+autolinking.gradle'
 
 if (isNewArchitectureEnabled()) {
@@ -117,6 +118,17 @@ android {
     disable "GradleCompatible"
   }
 
+  testOptions {
+    unitTests {
+      // Unstubbed android.jar methods return defaults instead of throwing —
+      // needed for the few framework calls Robolectric doesn't cover.
+      returnDefaultValues = true
+      // Robolectric needs the library manifest + resources on the test
+      // classpath.
+      includeAndroidResources = true
+    }
+  }
+
   compileOptions {
     sourceCompatibility JavaVersion.VERSION_1_8
     targetCompatibility JavaVersion.VERSION_1_8
@@ -233,3 +245,62 @@ if (isNewArchitectureEnabled()) {
     codegenJavaPackageName = "com.acousticconnectrn"
   }
 }
+
+// JVM unit tests (android/src/test) — run from a consumer app's gradle, e.g.
+//   cd example/android && ./gradlew :react-native-acoustic-connect-beta:testDebugUnitTest
+// No emulator: testDebugUnitTest does not trigger externalNativeBuild/CMake.
+// RN + nitro are compileOnly above (provided by the host app), so they are
+// re-declared for the test runtime classpath; the Connect SDK is already
+// `implementation` and flows to tests automatically. Note: nitro's Promise is
+// JNI-backed, so the push*/logIdentity Promise-returning methods cannot be
+// exercised in JVM tests — they are covered by the sample-build CI gates.
+dependencies {
+  testImplementation "junit:junit:4.13.2"
+  testImplementation "io.mockk:mockk:1.13.16"
+  // @Config(sdk = [35]) in the tests until Robolectric supports SDK 36.
+  testImplementation "org.robolectric:robolectric:4.14.1"
+  // Deliberately `+`, matching the compileOnly declaration above: this
+  // coordinate never resolves from a repository — the RN Gradle plugin
+  // substitutes it with the HOST app's `com.facebook.react:react-android`
+  // at resolution time, so tests always run against the same RN version the
+  // consuming build uses. Pinning (e.g. `0.82.1`) would name an artifact
+  // version that doesn't exist on Maven for RN >= 0.72 and adds only false
+  // precision; without the substitution both forms fail loudly.
+  //noinspection GradleDynamicVersion
+  testImplementation "com.facebook.react:react-native:+"
+  testImplementation project(":react-native-nitro-modules")
+}
+
+// Coverage for the JVM unit tests. Robolectric needs
+// includeNoLocationClasses to attribute coverage to instrumented classes.
+tasks.withType(Test).configureEach {
+  jacoco {
+    includeNoLocationClasses = true
+    excludes = ['jdk.internal.*']
+  }
+}
+
+// XML (parsed by the Jenkins Slack summary) + HTML (archived artifact)
+// coverage report over the debug unit tests. Registered afterEvaluate
+// because AGP creates the variant test task then. Generated nitro bindings
+// are excluded — they are codegen output, not logic this module owns.
+project.afterEvaluate {
+  tasks.register('jacocoDebugUnitTestReport', JacocoReport) {
+    dependsOn 'testDebugUnitTest'
+    group = 'verification'
+    description = 'JaCoCo coverage report for the debug JVM unit tests.'
+
+    def generatedExcludes = ['com/margelo/nitro/**', '**/BuildConfig*']
+    classDirectories.setFrom(files(
+      fileTree(dir: "${buildDir}/tmp/kotlin-classes/debug", excludes: generatedExcludes),
+      fileTree(dir: "${buildDir}/intermediates/javac/debug", includes: ['**/classes/**'], excludes: generatedExcludes)
+    ))
+    sourceDirectories.setFrom(files("${projectDir}/src/main/java"))
+    executionData.setFrom(fileTree(dir: buildDir, includes: ['jacoco/testDebugUnitTest.exec']))
+
+    reports {
+      xml.required = true
+      html.required = true
+    }
+  }
+}

package/android/src/main/assets/ConnectBasicConfig.properties

@@ -1,4 +1,4 @@
-#Thu Jul 02 09:57:28 PDT 2026
+#Fri Jul 03 01:59:06 PDT 2026
 UseWhiteList=true
 PrintScreen=3
 UseRandomSample=false

package/android/src/main/java/com/acousticconnectrn/HybridAcousticConnectRN.kt

@@ -1206,7 +1206,8 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
      * @param values The map to be converted.
      * @return A HashMap<String?, String?> representation of the input map which library can use.
      */
-    private fun convertToMap(values: Map<String, Variant_Boolean_String_Double>): HashMap<String?, String?> {
+    // internal (not private) so the unit tests in src/test can exercise it.
+    internal fun convertToMap(values: Map<String, Variant_Boolean_String_Double>): HashMap<String?, String?> {
         val map = HashMap<String?, String?>()
         for (key in values.keys) {
             val value = values[key]
@@ -1223,7 +1224,8 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
      * @param values The map to be converted.
      * @return A HashMap<String?, String?> representation of the input map which library can use.
      */
-    private fun convertToMapAny(values: Map<String, Variant_Boolean_String_Double>): java.util.HashMap<String?, Any?>? {
+    // internal (not private) so the unit tests in src/test can exercise it.
+    internal fun convertToMapAny(values: Map<String, Variant_Boolean_String_Double>): java.util.HashMap<String?, Any?>? {
         val map = HashMap<String?, Any?>()
         for (key in values.keys) {
             val value = values[key]

package/ios/ConnectRNParsing.swift

@@ -0,0 +1,154 @@
+// Copyright (C) 2026 Acoustic, L.P. All rights reserved.
+//
+// NOTICE: This file contains material that is confidential and proprietary to
+// Acoustic, L.P. and/or other developers. No license is granted under any intellectual or
+// industrial property rights of Acoustic, L.P. except as may be provided in an agreement with
+// Acoustic, L.P. Any unauthorized copying or distribution of content from this file is
+// prohibited.
+
+import Foundation
+import Connect
+import OSLog
+
+// Same subsystem/category as the bridge's config logger so the extraction
+// does not change where these lines surface in Console.app.
+private let configLog = Logger(subsystem: "com.acoustic.AcousticConnectRN", category: "config")
+
+/// Pure parsing / mapping / conversion logic extracted from
+/// `HybridAcousticConnectRN` (behaviour-preserving extraction) so it can be
+/// unit-tested without constructing the hybrid — the hybrid's `init`
+/// dispatches `load()`, which enables the real SDK with the bundled AppKey.
+internal enum ConnectRNParsing {
+
+    internal enum IOSPushMode: Equatable {
+        case automatic, manual
+        var descriptor: String { self == .automatic ? "automatic" : "manual" }
+    }
+
+    /// Lenient `PushEnabled` parser — accepts a `Bool` directly, or a string
+    /// like `"true"`/`"false"`/`"yes"`/`"no"`. Anything else falls back to
+    /// `false` with a warning so a typo in the JSON doesn't silently enable
+    /// push when the developer thought they'd turned it off.
+    static func parsePushEnabled(_ raw: Any?) -> Bool {
+        if let b = raw as? Bool { return b }
+        if let n = raw as? NSNumber { return n.boolValue }
+        if let s = raw as? String {
+            switch s.lowercased() {
+            case "true", "yes", "1": return true
+            case "false", "no", "0", "": return false
+            default:
+                configLog.warning("PushEnabled string \"\(s, privacy: .public)\" not recognised. Falling back to false.")
+                return false
+            }
+        }
+        if raw != nil {
+            configLog.warning("PushEnabled is set but is neither a Bool nor a recognised string. Falling back to false.")
+        }
+        return false
+    }
+
+    static func parseIOSPushMode(_ raw: String?) -> IOSPushMode {
+        switch raw?.lowercased() {
+        case "automatic", "auto", nil, "":
+            return .automatic
+        case "manual":
+            return .manual
+        default:
+            configLog.error("iOSPushMode \"\(raw ?? "", privacy: .public)\" not recognised. Allowed values: \"automatic\", \"manual\". Falling back to \"automatic\".")
+            return .automatic
+        }
+    }
+
+    /// Resolves `PushEnabled` + `iOSPushMode` + `iOSAppGroupIdentifier` from the
+    /// bundled config into a `ConnectPushConfig`. Validation errors are logged
+    /// at `.error`; soft mismatches at `.warning`. The SDK always falls back to
+    /// a safe default (`.off`) so an invalid config never crashes the app.
+    static func resolvePushConfig(from connectData: [String: Any]) -> ConnectPushConfig {
+        let pushEnabled = parsePushEnabled(connectData["PushEnabled"])
+        let iOSPushModeRaw = connectData["iOSPushMode"] as? String
+        let groupId = connectData["iOSAppGroupIdentifier"] as? String
+
+        configLog.info("PushEnabled: \(pushEnabled)")
+
+        // Inconsistency: iOSPushMode is set but PushEnabled is false. The
+        // mode value would never take effect; warn the developer so they
+        // know to fix one or the other.
+        if !pushEnabled, let raw = iOSPushModeRaw, !raw.isEmpty {
+            configLog.error("iOSPushMode \"\(raw, privacy: .public)\" is set but PushEnabled is false. Ignoring iOSPushMode; SDK will run with push disabled.")
+            return .off
+        }
+
+        guard pushEnabled else {
+            configLog.info("iOSPushMode: (not used, PushEnabled is false)")
+            configLog.info("iOSAppGroupIdentifier: (not used, PushEnabled is false)")
+            return .off
+        }
+
+        let mode = parseIOSPushMode(iOSPushModeRaw)
+        configLog.info("iOSPushMode: \(mode.descriptor, privacy: .public)")
+        if let groupId = groupId, !groupId.isEmpty {
+            configLog.info("iOSAppGroupIdentifier: \(groupId, privacy: .public)")
+        } else {
+            configLog.warning("iOSAppGroupIdentifier is not set. Required if your app uses a Notification Service or Notification Content extension to render rich push payloads.")
+        }
+
+        switch mode {
+        case .automatic:
+            return ConnectPushConfig(mode: .automatic, appGroupIdentifier: groupId)
+        case .manual:
+            return ConnectPushConfig(mode: .manual, appGroupIdentifier: groupId)
+        }
+    }
+
+    // Note: nsError(from: PushErrorInfo) stays in HybridAcousticConnectRN —
+    // PushErrorInfo is a C++-backed nitro type, and this file is also
+    // compiled into the UnitTests bundle, which builds without C++ interop.
+
+    /// Maps the JS-facing module name to the config store's module name
+    /// ("Connect" → "TLFCoreModule").
+    static func storeModuleName(for moduleName: String) -> String {
+        if moduleName.caseInsensitiveCompare("Connect") == .orderedSame {
+            return "TLFCoreModule"
+        }
+        return moduleName
+    }
+
+    static func convertToAnyDictionary(input: [String: Variant_Bool_String_Double]) -> [String: Any] {
+        var result: [String: Any] = [:]
+
+        for (key, value) in input {
+            switch value {
+            case .first(let boolValue):
+                result[key] = boolValue
+            case .second(let stringValue):
+                result[key] = stringValue
+            case .third(let doubleValue):
+                result[key] = doubleValue
+            }
+        }
+
+        return result
+    }
+
+    static func convertVariantToAny(_ variant: Variant_Bool_String_Double) -> Any {
+        switch variant {
+        case .first(let boolValue):
+            return boolValue
+        case .second(let stringValue):
+            return stringValue
+        case .third(let doubleValue):
+            return doubleValue
+        }
+    }
+
+    static func logLevel(from level: Double) -> kConnectMonitoringLevelType {
+        let intValue: Int = Int(level)
+        if intValue == 0 {
+            return kConnectMonitoringLevelType.connectMonitoringLevelIgnore
+        } else if intValue == 1 {
+            return kConnectMonitoringLevelType.connectMonitoringLevelCellularAndWiFi
+        } else {
+            return kConnectMonitoringLevelType.connectMonitoringLevelWiFi
+        }
+    }
+}

package/ios/HybridAcousticConnectRN.swift

@@ -143,7 +143,7 @@ class HybridAcousticConnectRN: HybridAcousticConnectRNSpec {
             configLog.info("KillSwitchUrl: \(killSwitch, privacy: .public)")
         }
 
-        let pushConfig = self.resolvePushConfig(from: connectData)
+        let pushConfig = ConnectRNParsing.resolvePushConfig(from: connectData)
 
         // Non-release integrations (useRelease:false — the AcousticConnectDebug
         // SDK variant) turn on the Connect/Tealeaf/EOCore verbose native logging
@@ -174,84 +174,9 @@ class HybridAcousticConnectRN: HybridAcousticConnectRNSpec {
         bridgeLog.info("SDK initialised: appKey length=\(appKey.count), push=\(pushConfig.modeDescription, privacy: .public), isReactNative=true, wrapNavigationContainer=true")
     }
 
-    /// Resolves `PushEnabled` + `iOSPushMode` + `iOSAppGroupIdentifier` from the
-    /// bundled config into a `ConnectPushConfig`. Validation errors are logged
-    /// at `.error`; soft mismatches at `.warning`. The SDK always falls back to
-    /// a safe default (`.off`) so an invalid config never crashes the app.
-    @MainActor
-    private func resolvePushConfig(from connectData: [String: Any]) -> ConnectPushConfig {
-        let pushEnabled = self.parsePushEnabled(connectData["PushEnabled"])
-        let iOSPushModeRaw = connectData["iOSPushMode"] as? String
-        let groupId = connectData["iOSAppGroupIdentifier"] as? String
-
-        configLog.info("PushEnabled: \(pushEnabled)")
-
-        // Inconsistency: iOSPushMode is set but PushEnabled is false. The
-        // mode value would never take effect; warn the developer so they
-        // know to fix one or the other.
-        if !pushEnabled, let raw = iOSPushModeRaw, !raw.isEmpty {
-            configLog.error("iOSPushMode \"\(raw, privacy: .public)\" is set but PushEnabled is false. Ignoring iOSPushMode; SDK will run with push disabled.")
-            return .off
-        }
-
-        guard pushEnabled else {
-            configLog.info("iOSPushMode: (not used, PushEnabled is false)")
-            configLog.info("iOSAppGroupIdentifier: (not used, PushEnabled is false)")
-            return .off
-        }
-
-        let mode = self.parseIOSPushMode(iOSPushModeRaw)
-        configLog.info("iOSPushMode: \(mode.descriptor, privacy: .public)")
-        if let groupId = groupId, !groupId.isEmpty {
-            configLog.info("iOSAppGroupIdentifier: \(groupId, privacy: .public)")
-        } else {
-            configLog.warning("iOSAppGroupIdentifier is not set. Required if your app uses a Notification Service or Notification Content extension to render rich push payloads.")
-        }
-
-        switch mode {
-        case .automatic:
-            return ConnectPushConfig(mode: .automatic, appGroupIdentifier: groupId)
-        case .manual:
-            return ConnectPushConfig(mode: .manual, appGroupIdentifier: groupId)
-        }
-    }
-
-    /// Lenient `PushEnabled` parser — accepts a `Bool` directly, or a string
-    /// like `"true"`/`"false"`/`"yes"`/`"no"`. Anything else falls back to
-    /// `false` with a warning so a typo in the JSON doesn't silently enable
-    /// push when the developer thought they'd turned it off.
-    private func parsePushEnabled(_ raw: Any?) -> Bool {
-        if let b = raw as? Bool { return b }
-        if let n = raw as? NSNumber { return n.boolValue }
-        if let s = raw as? String {
-            switch s.lowercased() {
-            case "true", "yes", "1": return true
-            case "false", "no", "0", "": return false
-            default:
-                configLog.warning("PushEnabled string \"\(s, privacy: .public)\" not recognised. Falling back to false.")
-                return false
-            }
-        }
-        if raw != nil {
-            configLog.warning("PushEnabled is set but is neither a Bool nor a recognised string. Falling back to false.")
-        }
-        return false
-    }
-
-    private enum IOSPushMode { case automatic, manual
-        var descriptor: String { self == .automatic ? "automatic" : "manual" } }
-
-    private func parseIOSPushMode(_ raw: String?) -> IOSPushMode {
-        switch raw?.lowercased() {
-        case "automatic", "auto", nil, "":
-            return .automatic
-        case "manual":
-            return .manual
-        default:
-            configLog.error("iOSPushMode \"\(raw ?? "", privacy: .public)\" not recognised. Allowed values: \"automatic\", \"manual\". Falling back to \"automatic\".")
-            return .automatic
-        }
-    }
+    // Push-config resolution and the PushEnabled / iOSPushMode parsers moved
+    // to ConnectRNParsing (behaviour-preserving extraction) so
+    // they are unit-testable without constructing this hybrid.
 
     /// Reads and returns the `Connect` dictionary from the bundled
     /// `AcousticConnectRNConfig.json`. The bundle is populated at pod install
@@ -488,7 +413,10 @@ class HybridAcousticConnectRN: HybridAcousticConnectRNSpec {
     // MARK: - Push: helpers
 
     /// Builds an `NSError` from the structured bridge error object, shared by
-    /// `pushDidFailToRegister` and `pushDidReceiveAuthorization`.
+    /// `pushDidFailToRegister` and `pushDidReceiveAuthorization`. Kept here
+    /// (not in ConnectRNParsing) because `PushErrorInfo` is a C++-backed
+    /// nitro type and ConnectRNParsing is also compiled into the UnitTests
+    /// bundle, which builds without C++ interop.
     private static func nsError(from info: PushErrorInfo) -> NSError {
         NSError(
             domain: info.domain ?? "ConnectRNBridge",
@@ -816,39 +744,18 @@ class HybridAcousticConnectRN: HybridAcousticConnectRNSpec {
         return true
     }
     
+    // The bodies below moved to ConnectRNParsing (behaviour-preserving
+    // extraction); these thin delegates keep the class API stable.
     func testModuleName(moduleName: String) throws -> String {
-        if (moduleName.caseInsensitiveCompare("Connect") == .orderedSame) {
-            return "TLFCoreModule"
-        }
-        return moduleName
+        return ConnectRNParsing.storeModuleName(for: moduleName)
     }
-  
-    func convertToAnyDictionary(input: [String: Variant_Bool_String_Double]) -> [String: Any] {
-        var result: [String: Any] = [:]
-
-        for (key, value) in input {
-            switch value {
-            case .first(let boolValue):
-                result[key] = boolValue
-            case .second(let stringValue):
-                result[key] = stringValue
-            case .third(let doubleValue):
-                result[key] = doubleValue
-            }
-        }
 
-        return result
+    func convertToAnyDictionary(input: [String: Variant_Bool_String_Double]) -> [String: Any] {
+        return ConnectRNParsing.convertToAnyDictionary(input: input)
     }
 
     func convertVariantToAny(_ variant: Variant_Bool_String_Double) -> Any {
-        switch variant {
-        case .first(let boolValue):
-            return boolValue
-        case .second(let stringValue):
-            return stringValue
-        case .third(let doubleValue):
-            return doubleValue
-        }
+        return ConnectRNParsing.convertVariantToAny(variant)
     }
     
 //    func convertKeyValueMapToDictionary(_ keyValueMap: KeyValueMap) -> [AnyHashable: Any] {
@@ -863,14 +770,7 @@ class HybridAcousticConnectRN: HybridAcousticConnectRNSpec {
 //    }
     
     func getLogLevelHelper(level: Double) throws -> kConnectMonitoringLevelType {
-        let intValue: Int = Int(level)
-        if intValue == 0 {
-            return kConnectMonitoringLevelType.connectMonitoringLevelIgnore
-        } else if intValue == 1 {
-            return kConnectMonitoringLevelType.connectMonitoringLevelCellularAndWiFi
-        } else {
-            return kConnectMonitoringLevelType.connectMonitoringLevelWiFi
-        }
+        return ConnectRNParsing.logLevel(from: level)
     }
     
     func getLogLevel(level: Double) throws -> kConnectMonitoringLevelType {

package/package.json

@@ -76,6 +76,7 @@
         "android/gradle.properties",
         "android/CMakeLists.txt",
         "android/src",
+        "!android/src/test/**",
         "android/config.gradle",
         "android/src/main/assets/**",
         "ios/**/*.h",
@@ -83,6 +84,7 @@
         "ios/**/*.mm",
         "ios/**/*.cpp",
         "ios/**/*.swift",
+        "!ios/Tests/**",
         "ios/AcousticConnectRNConfig.json",
         "app.plugin.js",
         "plugin/build",
@@ -225,7 +227,7 @@
     "source": "src/index",
     "summary": "react-native ios android tealeaf connect cxa wxca er enhanced-replay",
     "types": "./lib/typescript/src/index.d.ts",
-    "version": "19.0.5",
+    "version": "19.0.7",
     "workspaces": [
         "example",
         "Examples/bare-workflow"