finishing prep

Packages/SublimationNgrok/Sources/SublimationKVdb/URLSessionClient.swift

@@ -44,14 +44,14 @@ public import SublimationTunnel
 /// a `NgrokServerError` if the save operation fails.
 ///
 /// - SeeAlso: `KVdbTunnelClient`
-public struct URLSessionClient<Key: Sendable>: TunnelClient {
+internal struct URLSessionClient<Key: Sendable>: TunnelClient {
   private let session: URLSession
 
   ///   Initializes a new `URLSessionClient` with the specified session.
   ///
   ///   - Parameter session: The URLSession to use for network requests.
   ///   Defaults to an ephemeral session.
-  public init(session: URLSession = .ephemeral()) { self.session = session }
+  internal init(session: URLSession = .ephemeral()) { self.session = session }
 
   ///   Retrieves the value associated with a key from a specific bucket.
   ///
@@ -62,7 +62,7 @@ public struct URLSessionClient<Key: Sendable>: TunnelClient {
   ///   - Returns: The URL value associated with the key.
   ///
   ///   - Throws: A `NgrokServerError` if the retrieval operation fails.
-  public func getValue(ofKey key: Key, fromBucket bucketName: String) async throws -> URL {
+  internal func getValue(ofKey key: Key, fromBucket bucketName: String) async throws -> URL {
     let url = KVdb.construct(URL.self, forKey: key, atBucket: bucketName)
 
     let data = try await session.data(from: url).0
@@ -81,7 +81,8 @@ public struct URLSessionClient<Key: Sendable>: TunnelClient {
   ///     - bucketName: The name of the bucket to save the value in.
   ///
   ///   - Throws: A `NgrokServerError` if the save operation fails.
-  public func saveValue(_ value: URL, withKey key: Key, inBucket bucketName: String) async throws {
+  internal func saveValue(_ value: URL, withKey key: Key, inBucket bucketName: String) async throws
+  {
     let url = KVdb.construct(URL.self, forKey: key, atBucket: bucketName)
     var request = URLRequest(url: url)
     request.httpBody = value.absoluteString.data(using: .utf8)

Packages/SublimationNgrok/Sources/SublimationNgrok/NgrokCLIAPIConfiguration.swift

@@ -62,6 +62,5 @@ extension NgrokCLIAPIConfiguration {
   ///   using a `Vapor.Application`.
   ///
   ///   - Parameter application: The Vapor application to use for configuration.
-
   public init(application: any Application) { self.init(serverApplication: application) }
 }

Packages/SublimationNgrok/Sources/SublimationNgrok/NgrokCLIAPIServer+TunnelServer.swift

@@ -34,7 +34,7 @@ import SublimationTunnel
 
 extension NgrokCLIAPIServer {
   ///   Runs the server.
-  public func begin(isConnectionRefused: @escaping (ClientError) -> Bool) async {
+  private func begin(isConnectionRefused: @escaping (ClientError) -> Bool) async {
     let start = Date()
     let newTunnel: any Tunnel
     do { newTunnel = try await self.newTunnel(isConnectionRefused: isConnectionRefused) }
@@ -56,7 +56,11 @@ extension NgrokCLIAPIServer {
     internal private(set) var isStarted = false
     func started() { isStarted = true }
   }
+  /// Terminate  the `NgrokProcess`.
   public func shutdown() { self.process.terminate() }
+  /// Starts the process for Ngrok if nessecary and creates a new tunnel.
+  /// - Parameter isConnectionRefused: Closure to test whether the ``ClientError`` is because the server still needs to be started.
+  /// - Throws: If there's an issue starting the server.
   public func run(isConnectionRefused: @escaping @Sendable (ClientError) -> Bool) async throws {
     try await withThrowingTaskGroup(
       of: Void.self,

Packages/SublimationNgrok/Sources/SublimationNgrok/NgrokClient.swift

@@ -41,7 +41,7 @@ extension NgrokClient {
       { try await self.listTunnels().first },
       isConnectionRefused: isConnectionRefused
     )
-    switch networkResult { case let .connectionRefused(error): return .error(error)
+    switch networkResult { case .connectionRefused(let error): return .error(error)
 
       default: return .network(networkResult)
     }

Packages/SublimationNgrok/Sources/SublimationTunnel/NetworkResult.swift

@@ -47,7 +47,7 @@ public enum NetworkResult<T, ConnectionErrorType: Error> {
 }
 
 extension NetworkResult {
-  public init(error: any Error, isConnectionRefused: @escaping (ConnectionErrorType) -> Bool) {
+  package init(error: any Error, isConnectionRefused: @escaping (ConnectionErrorType) -> Bool) {
     guard let error = error as? ConnectionErrorType else {
       self = .failure(error)
       return
@@ -61,15 +61,15 @@ extension NetworkResult {
     self = .failure(error)
   }
 
-  public init(
+  package init(
     _ closure: @escaping () async throws -> T,
     isConnectionRefused: @escaping (ConnectionErrorType) -> Bool
   ) async {
     do { self = try await .success(closure()) }
     catch { self = .init(error: error, isConnectionRefused: isConnectionRefused) }
   }
 
-  public func get() throws -> T? {
+  package func get() throws -> T? {
     switch self { case .connectionRefused: return nil
 
       case .failure(let error): throw error

Packages/SublimationNgrok/Sources/SublimationTunnel/Tunnel.swift

@@ -29,6 +29,7 @@
 
 public import Foundation
 
+/// A tunnel with a name and public url for the server.
 public protocol Tunnel: Sendable {
   var name: String { get }
   var publicURL: URL { get }

Packages/SublimationNgrok/Sources/SublimationTunnel/TunnelClientRepository.swift

@@ -33,18 +33,39 @@ public import Foundation
   public import FoundationNetworking
 #endif
 
+/// A repository for managing writable ``Tunnel`` objects using a ``TunnelClient``.
 public final class TunnelClientRepository<Key: Sendable>: WritableTunnelRepository {
   private let client: any TunnelClient<Key>
   private let bucketName: String
+  /// Create a ``TunnelClientRepository`` using the ``TunnelClient`` and the name of the bucket for the key value pair.
+  /// - Parameters:
+  ///   - client: The ``TunnelClient`` to communicate with.
+  ///   - bucketName: The bucket name for the key value pair.
   public init(client: any TunnelClient<Key>, bucketName: String) {
     self.client = client
     self.bucketName = bucketName
   }
 
+  ///   Retrieves a tunnel for the specified key.
+  ///
+  ///   - Parameter key: The key used to retrieve the tunnel.
+  ///
+  ///   - Throws: An error if the tunnel cannot be retrieved.
+  ///
+  ///   - Returns: The URL of the retrieved tunnel, if available.
   public func tunnel(forKey key: Key) async throws -> URL? {
     try await client.getValue(ofKey: key, fromBucket: bucketName)
   }
 
+  ///   Saves a URL with a key.
+  ///
+  ///   - Parameters:
+  ///     - url: The URL to save.
+  ///     - key: The key to associate with the URL.
+  ///
+  ///   - Throws: An error if the save operation fails.
+  ///
+  ///   - Note: This method is asynchronous.
   public func saveURL(_ url: URL, withKey key: Key) async throws {
     try await client.saveValue(url, withKey: key, inBucket: bucketName)
   }

Packages/SublimationNgrok/Sources/SublimationTunnel/TunnelRepository.swift

@@ -51,6 +51,5 @@ public protocol TunnelRepository<Key>: Sendable {
   ///   - Throws: An error if the tunnel cannot be retrieved.
   ///
   ///   - Returns: The URL of the retrieved tunnel, if available.
-
   func tunnel(forKey key: Key) async throws -> URL?
 }

Packages/SublimationNgrok/Sources/SublimationTunnel/TunnelServer.swift

@@ -44,6 +44,10 @@ public protocol TunnelServer: Sendable {
   @available(*, deprecated) func start(
     isConnectionRefused: @escaping @Sendable (ConnectionErrorType) -> Bool
   )
+  /// Runs TunnelServeer.
+  /// - Parameter isConnectionRefused: Closure to test whether the ``ConnectionErrorType`` is because the server still needs to be started.
+  /// - Throws: If there's an issue starting the server.
   func run(isConnectionRefused: @escaping @Sendable (ConnectionErrorType) -> Bool) async throws
+  /// Shutdown the ``TunnelServer``.
   func shutdown()
 }

Packages/SublimationNgrok/Sources/SublimationTunnel/TunnelSublimatory.swift

@@ -35,12 +35,15 @@ public import SublimationCore
 public typealias RepositoryClientFactory<Key> = (@Sendable @escaping () -> any Application) ->
   any TunnelClient<Key>
 
+/// A `Sublimatory` which uses creates and saves a``Tunnel``.
 public actor TunnelSublimatory<
   WritableTunnelRepositoryFactoryType: WritableTunnelRepositoryFactory,
   TunnelServerFactoryType: TunnelServerFactory
 >: Sublimatory, TunnelServerDelegate {
 
+  /// `Key type
   public typealias Key = WritableTunnelRepositoryFactoryType.TunnelRepositoryType.Key
+  /// Type of Error which can be thrown by the Network Client.
   public typealias ConnectionErrorType = TunnelServerFactoryType.Configuration.Server
     .ConnectionErrorType
   private let factory: TunnelServerFactoryType
@@ -164,7 +167,7 @@ public actor TunnelSublimatory<
   public nonisolated func server(_: any TunnelServer, errorDidOccur error: any Error) {
     Task { await self.onError(error) }
   }
-  func shutdownServer() { server.shutdown() }
+  private func shutdownServer() { server.shutdown() }
   public nonisolated func shutdown() { Task { await self.shutdownServer() } }
   public func run() async throws {
 

Packages/SublimationNgrok/Sources/SublimationTunnel/WritableTunnelRepository.swift

@@ -29,7 +29,7 @@
 
 public import Foundation
 
-/// A repository for managing writable tunnels.
+/// A repository for managing writable ``Tunnel`` objects.
 ///
 /// This protocol extends the `TunnelRepository` protocol
 /// and adds the ability to save a URL with a key.