diff --git a/Sources/ApacheBeam/Client/ApiServiceDescriptor.swift b/Sources/ApacheBeam/Client/ApiServiceDescriptor.swift
index 66aeaea..359e3e0 100644
--- a/Sources/ApacheBeam/Client/ApiServiceDescriptor.swift
+++ b/Sources/ApacheBeam/Client/ApiServiceDescriptor.swift
@@ -37,6 +37,8 @@
 }
 
 extension ApiServiceDescriptor {
+    /// Populate the ``ApiServiceDescriptor`` from the Beam protobuf representation
+    /// - Parameter proto: A valid protocol buffer
     init(proto: Org_Apache_Beam_Model_Pipeline_V1_ApiServiceDescriptor) {
         url = proto.url
     }
@@ -51,6 +53,14 @@
 extension ApiServiceDescriptor: Hashable {}
 
 public extension ApiServiceDescriptor {
+    /// Convenience function to decode an ApiServiceDescriptor from a text or JSON encoded protocol buffer passed as environment variable.
+    /// This technique is used by Runners when launching containers.
+    ///
+    /// - Parameters:
+    ///   - env: The name of the environment variable to check
+    ///   - format: The variable's encoding.
+    /// - Returns: An ``ApiServiceDescriptor`` for the specified service.
+    /// 
     static func from(env: String, format: EncodedAs = .textproto) throws -> ApiServiceDescriptor {
         switch format {
         case .textproto:
diff --git a/Sources/ApacheBeam/Internal/Array+Helpers.swift b/Sources/ApacheBeam/Internal/Array+Helpers.swift
index 9718f32..12d8411 100644
--- a/Sources/ApacheBeam/Internal/Array+Helpers.swift
+++ b/Sources/ApacheBeam/Internal/Array+Helpers.swift
@@ -17,6 +17,8 @@
  */
 
 extension [(String, String)] {
+    /// Convenience function that converts an aray of (String,String) elements into a dictionary type.
+    /// - Returns: A dictionary of `[String:String]`
     func dict() -> [String: String] {
         reduce(into: [:]) { $0[$1.0] = $1.1 }
     }
diff --git a/Sources/ApacheBeam/Internal/Data+Decoding.swift b/Sources/ApacheBeam/Internal/Data+Decoding.swift
index f6cd290..35ddb34 100644
--- a/Sources/ApacheBeam/Internal/Data+Decoding.swift
+++ b/Sources/ApacheBeam/Internal/Data+Decoding.swift
@@ -19,8 +19,10 @@
 import Foundation
 
 extension Data {
-    /// advanced(by:) has issues on non-macOS Foundation implementations
     @inlinable
+    /// A safer version of `advanced(by:)`. On non-macOS Foundation implementations ``advanced(by:)`` segfaults on ``Data`` elements with size 0.
+    /// - Parameter by: Number of elements to advance
+    /// - Returns: A possibly different ``Data`` element.
     func safeAdvance(by: Int) -> Data {
         #if os(macOS)
             return advanced(by: by)
@@ -36,6 +38,7 @@
     }
 
     /// Read a variable length integer from the current data
+    /// - Returns: An integer of up to 64 bits.
     mutating func varint() throws -> Int {
         var advance = 0
         let result = try withUnsafeBytes {
@@ -68,20 +71,27 @@
         return result
     }
 
+    
+    /// Decodes a Beam time value, which is a Java Instant that has been encoded to sort properly
+    /// - Returns: A Date value
     mutating func instant() throws -> Date {
         let millis = try next(Int64.self) &+ Int64(-9_223_372_036_854_775_808)
         return Date(millisecondsSince1970: millis)
     }
 
-    /// Read a length prefixed chunk of data
+    
+    /// Implements the Beam length-prefixed byte blob encoding
+    /// - Returns: A ``Data`` with a size defined by the length encoding
     mutating func subdata() throws -> Data {
         let length = try varint()
         let result = subdata(in: 0 ..< length)
         self = safeAdvance(by: length)
         return result
     }
-
-    /// Extracts a fixed width type. Coming off the wire this will always be bigendian
+    
+    /// Read a fixed length integer of the specified type. In Beam the wire encoding is always a Java-style bigendian value
+    /// - Parameter _: The integer type of read
+    /// - Returns: The integer value read.
     mutating func next<T: FixedWidthInteger>(_: T.Type) throws -> T {
         let size = MemoryLayout<T>.size
         let bigEndian = withUnsafeBytes {
@@ -91,6 +101,10 @@
         return T(bigEndian: bigEndian)
     }
 
+    
+    /// Read a fixed length floating point value of the specified type.
+    /// - Parameter _: The floating point type to read
+    /// - Returns: The floating point value
     mutating func next<T: FloatingPoint>(_: T.Type) throws -> T {
         let result = withUnsafeBytes {
             $0.load(as: T.self)
diff --git a/Sources/ApacheBeam/Internal/Data+Encoding.swift b/Sources/ApacheBeam/Internal/Data+Encoding.swift
index 3b0d6ae..82c2b19 100644
--- a/Sources/ApacheBeam/Internal/Data+Encoding.swift
+++ b/Sources/ApacheBeam/Internal/Data+Encoding.swift
@@ -19,6 +19,8 @@
 import Foundation
 
 extension Data {
+    /// Encode a variable length integer up to 64-bits
+    /// - Parameter value: The value to encode
     mutating func varint(_ value: Int) {
         var current = UInt64(value)
         while current >= 0x80 {
@@ -28,21 +30,27 @@
         append(UInt8(current))
     }
 
+    
+    /// Append a Date as a modified Java Instant onto the. Resolution will be milliseconds.
+    /// - Parameter value: the date/time value to encode.
     mutating func instant(_ value: Date) {
         let be = (Int64(value.millisecondsSince1970) &- Int64(-9_223_372_036_854_775_808)).bigEndian
         Swift.withUnsafeBytes(of: be) {
             self.append(contentsOf: $0)
         }
     }
-
-    // In Beam integers go on and off the wire in bigEndian format. This matches the original Java lineage.
+    
+    /// Append a fixed-width integer in a Java way (bigendian) to match Beam
+    /// - Parameter value: the value to encode
     mutating func next(_ value: some FixedWidthInteger) {
         let be = value.bigEndian
         Swift.withUnsafeBytes(of: be) {
             self.append(contentsOf: $0)
         }
     }
-
+    
+    /// Append fixed-width floating point values in IEEE format.
+    /// - Parameter value: floating point value to append
     mutating func next(_ value: some FloatingPoint) {
         Swift.withUnsafeBytes(of: value) {
             self.append(contentsOf: $0)
diff --git a/Sources/ApacheBeam/Internal/Date+Timestamp.swift b/Sources/ApacheBeam/Internal/Date+Timestamp.swift
index 63dd57b..6a54cb2 100644
--- a/Sources/ApacheBeam/Internal/Date+Timestamp.swift
+++ b/Sources/ApacheBeam/Internal/Date+Timestamp.swift
@@ -19,10 +19,13 @@
 import Foundation
 
 extension Date {
+    /// Convenience property to extract Java-style milliseconds since the UNIX epoch
     var millisecondsSince1970: Int64 {
         Int64((timeIntervalSince1970 * 1000.0).rounded())
     }
-
+    
+    /// Create a ``Date`` from UNIX epoch milliseconds
+    /// - Parameter millisecondsSince1970: Milliseconds to convert
     init(millisecondsSince1970: Int64) {
         self = Date(timeIntervalSince1970: Double(millisecondsSince1970) / 1000.0)
     }
diff --git a/Sources/ApacheBeam/Internal/Dictionary+Helpers.swift b/Sources/ApacheBeam/Internal/Dictionary+Helpers.swift
index feedd19..52814ea 100644
--- a/Sources/ApacheBeam/Internal/Dictionary+Helpers.swift
+++ b/Sources/ApacheBeam/Internal/Dictionary+Helpers.swift
@@ -17,7 +17,9 @@
  */
 
 public extension Dictionary where Key: Comparable {
-    /// Return key-value pairs sorted by key.
+    
+    /// Return the elements of a dictionary in a stable ordering
+    /// - Returns: An array of pairs sorted by key
     func sorted() -> [(Key, Value)] {
         map { ($0, $1) }.sorted(by: { $0.0 < $1.0 })
     }
diff --git a/Sources/ApacheBeam/Internal/PipelineProto+Coder.swift b/Sources/ApacheBeam/Internal/PipelineProto+Coder.swift
index a8c2603..7479e93 100644
--- a/Sources/ApacheBeam/Internal/PipelineProto+Coder.swift
+++ b/Sources/ApacheBeam/Internal/PipelineProto+Coder.swift
@@ -17,6 +17,9 @@
  */
 
 extension PipelineProto {
+    /// Construct an appropriate coder representation from the current pipeline, perhaps also encoding component coders.
+    /// - Parameter from: The ``Coder`` to convert.
+    /// - Returns: ``PipelineComponent`` representing this coder
     mutating func coder(from: Coder) -> PipelineComponent {
         let componentCoders: [String] = switch from {
         case let .keyvalue(keyCoder, valueCoder):
diff --git a/Sources/ApacheBeam/Internal/PipelineProto+Environment.swift b/Sources/ApacheBeam/Internal/PipelineProto+Environment.swift
index ba130bd..f8f0034 100644
--- a/Sources/ApacheBeam/Internal/PipelineProto+Environment.swift
+++ b/Sources/ApacheBeam/Internal/PipelineProto+Environment.swift
@@ -17,6 +17,9 @@
  */
 
 extension PipelineProto {
+    /// Encode a native ``Environment`` into its protobuf form as a ``PipelineComponent``
+    /// - Parameter from: the ``Environment`` to encode
+    /// - Returns: A ``PipelineComponent`` representation 
     mutating func environment(from: Environment) throws -> PipelineComponent {
         try environment { _ in
             try .with {
diff --git a/Sources/ApacheBeam/Internal/PipelineProto+Initializers.swift b/Sources/ApacheBeam/Internal/PipelineProto+Initializers.swift
index d17ef35..502ed64 100644
--- a/Sources/ApacheBeam/Internal/PipelineProto+Initializers.swift
+++ b/Sources/ApacheBeam/Internal/PipelineProto+Initializers.swift
@@ -16,6 +16,8 @@
  * limitations under the License.
  */
 
+/// An enumeration for representing various elements of a pipeline protocol buffer. This enum is used
+/// when constructing the pipeline for submission to a portable runner.
 enum PipelineComponent {
     case none
     case transform(String, PTransformProto)
@@ -23,7 +25,8 @@
     case coder(String, CoderProto)
     case windowingStrategy(String, WindowingStrategyProto)
     case environment(String, EnvironmentProto)
-
+    
+    /// The name of the pipeline component. Most components in the protocol buffer have a name used to reference the component throughout the pipeline structure.
     var name: String {
         switch self {
         case .none:
@@ -41,6 +44,8 @@
         }
     }
 
+    
+    /// The PTransfrom protocol buffer for this component. Returns ``nil`` for everything except a ``transform`` type.
     var transform: PTransformProto? {
         if case let .transform(_, pTransformProto) = self {
             return pTransformProto
@@ -50,16 +55,23 @@
     }
 }
 
-/// Convenience function for creating new pipeline elements. Note that these shouldn't be accessed concurrently
-/// but this isn't a problem itself since trying to access the proto concurrently throws an error.
+// Convenience function for creating new pipeline elements. Note that these shouldn't be accessed concurrently
+// but this isn't a problem itself since trying to access the proto concurrently throws an error.
 extension PipelineProto {
+    
+    /// Adds a new `PTransform` protocol buffer to the pipeline along with an internal reference name to be used by other parts of the pipeline.
+    /// - Parameter mapper: A closure that returns the `PTransform` protocol buffer. Includes the reference id as a parameter in case it is needed.
+    /// - Returns: A ``PipelineComponent`` representing this `PTransform`
     mutating func transform(_ mapper: @escaping (String) throws -> PTransformProto) throws -> PipelineComponent {
         let name = "ref_PTransform_\(components.transforms.count + 1)"
         let proto = try mapper(name)
         components.transforms[name] = proto
         return .transform(name, proto)
     }
-
+    
+    /// Adds a new `PCollection` protocol buffer to the pipeline along with an internal reference name to be used elsewhere (e.g. `PTransform`s)
+    /// - Parameter mapper: A closure that returns the `PCollection` protocol buffer. It is passed the reference name in case that is useful
+    /// - Returns: A ``PipelineComponent`` representing the `PCollection`
     mutating func collection(_ mapper: @escaping (String) throws -> PCollectionProto) throws -> PipelineComponent {
         let name = "ref_PCollection_\(components.pcollections.count + 1)"
         let proto = try mapper(name)
diff --git a/Sources/ApacheBeam/Transforms/Basic.swift b/Sources/ApacheBeam/Transforms/Basic.swift
index ed9b452..71d70a3 100644
--- a/Sources/ApacheBeam/Transforms/Basic.swift
+++ b/Sources/ApacheBeam/Transforms/Basic.swift
@@ -18,9 +18,22 @@
 
 import Foundation
 
-/// Creating Static Values
+// Utility Transforms
 public extension PCollection {
-    /// Each time the input fires output all of the values in this list.
+    /// For each item from the input ``PCollection`` emit all of the items in a static list of values.
+    ///
+    /// This transform is most commonly used with ``impulse()`` to create an intial set of inputs for the pipeline. The values passed to
+    /// this transform are encoded in the pipeline submission making it suitable for passing information from input parameters, such as a set
+    /// of files to process.
+    ///
+    /// Note that because these values are encoded in the pipeline itself that they are subject to the maximum size of a protocol buffer (2GB)
+    /// and large inputs can affect submitting the pipeline to the runner.
+    ///
+    /// - Parameters:
+    ///     - values: An array of ``Codable`` values to be emitted for each input record
+    ///     - name: An optional name for this transform. By default it will use the source file and line number for easy debugging
+    ///
+    /// - Returns: A ``PCollection`` containing contaings items of type `Value`
     func create<Value: Codable>(_ values: [Value], name: String? = nil, _file: String = #fileID, _line: Int = #line) -> PCollection<Value> {
         pstream(name: name ?? "\(_file):\(_line)", type: .bounded, values) { values, input, output in
             for try await (_, ts, w) in input {
@@ -32,7 +45,7 @@
     }
 }
 
-/// Convenience logging mappers
+// Logging Transforms
 public extension PCollection {
     @discardableResult
     func log(prefix: String, _ name: String? = nil, _file: String = #fileID, _line: Int = #line) -> PCollection<Of> where Of == String {
@@ -58,16 +71,37 @@
     }
 }
 
-/// Modifying Values
+// Mapping Operations
 public extension PCollection {
-    /// Modify a value without changing its window or timestamp
+    /// Perform a scalar transformation of input values from a ``PCollection`` to another type without modifying the window or the timestamp.
+    ///
+    ///  For example, the following code would return a ``PCollection<String>`` if applied to an input ``PCollection`` whose value has
+    ///  a ``String`` property named `name`
+    ///  ```swift
+    ///    input.map { $0.name }
+    ///  ```
+    /// Note: The return type of the mapping function is treated as a scalar even if it is an iterable type. To return multiple values from a single input
+    /// use ``flatMap(name:_file:_line:_:)`` instead.
+    ///
+    /// - Parameters:
+    ///     - name: An optional name for this transform. By default it will use the file name and line number for easy debugging.
+    ///     - fn: A trailing closure specifying the mapping function
+    ///
+    /// - Returns: A ``PCollection<Out>`` of scalar transformations.
     func map<Out>(name: String? = nil, _file: String = #fileID, _line: Int = #line, _ fn: @Sendable @escaping (Of) -> Out) -> PCollection<Out> {
         pardo(name: name ?? "\(_file):\(_line)") { input, output in
             output.emit(fn(input.value))
         }
     }
 
-    /// Map function to convert a tuple pair into an encodable key-value pair
+    /// Map a scalar input into a tuple representing a key-value pair. This is most commonly used in conjunction with ``groupByKey()`` transformations but can
+    /// be used as a scalar transform to Beam's native key-value coding type.
+    ///
+    /// - Parameters:
+    ///   - name: An optional name for this transform. By default it will use the file name and line number for easy debugging.
+    ///   - fn: A trailing closure specifying the mapping function
+    ///
+    /// - Returns: A ``PCollection<KV<K,V>>`` which is encoded using Beam's native key value coding.
     func map<K, V>(name: String? = nil, _file: String = #fileID, _line: Int = #line, _ fn: @Sendable @escaping (Of) -> (K, V)) -> PCollection<KV<K, V>> {
         pardo(name: name ?? "\(_file):\(_line)") { input, output in
             let (key, value) = fn(input.value)
@@ -75,9 +109,16 @@
         }
     }
 
-    /// Produce multiple outputs as a single value without modifying window or timestamp
-    func flatMap<Out>(name: String? = nil, _file: String = #fileID, _line: Int = #line, _ fn: @Sendable @escaping (Of) -> [Out]) -> PCollection<Out> {
-        pardo(name: name ?? "\(_file):\(_line)") { input, output in
+    /// Map a ``PCollection`` to zero or more outputs by returning a ``Sequence``
+    ///
+    /// - Parameters:
+    ///   - name: An optional name for this transform. By default it will use the source filename and line number for easy debugging.
+    ///   - fn: A trailing closure that returns a ``Sequence``.
+    ///
+    /// - Returns: A ``PCollection`` of values with the type ``Sequence.Element``
+    ///
+    func flatMap<S:Sequence>(name: String? = nil,_file: String = #fileID,_line: Int = #line,_ fn: @Sendable @escaping (Of) -> S) -> PCollection<S.Element> {
+        pardo(name: name ?? "\(_file):\(_line)") { input,output in
             for i in fn(input.value) {
                 output.emit(i)
             }
@@ -85,8 +126,15 @@
     }
 }
 
-/// Modifying Timestamps
+// Timestamp Operations
 public extension PCollection {
+    /// Modifies the timestamps of values in the input ``PCollection`` according to user specified logic
+    /// - Parameters:
+    ///   - name: An optional name for this transform. By default it will use the source filename and line number for easy debugging.
+    ///   - fn: A trailing closure that returns the new timestamp for the input value.
+    ///
+    /// - Returns: A ``PCollection`` with modified timestamps.
+    ///
     func timestamp(name: String? = nil, _file: String = #fileID, _line: Int = #line, _ fn: @Sendable @escaping (Of) -> Date) -> PCollection<Of> {
         pstream(name: name ?? "\(_file):\(_line)") { input, output in
             for try await (value, _, w) in input {
@@ -97,7 +145,12 @@
 }
 
 public extension PCollection<Never> {
-    /// Convenience function to add an impulse when we are at the root of the pipeline
+    /// A convience implementation of ``create(_:name:_file:_line:)-38du`` that prepends an ``impulse()`` transform to a pipeline root.
+    /// - Parameters:
+    ///   - values: The values to emit when the impulse item is received
+    ///   - name: An optional name for this transform. By default it will use the source filename and line number for easy debugging.
+    ///
+    /// - Returns: A ``PCollection`` of values from the static list
     func create<Value: Codable>(_ values: [Value], name: String? = nil, _file: String = #fileID, _line: Int = #line) -> PCollection<Value> {
         impulse().create(values, name: name, _file: _file, _line: _line)
     }
diff --git a/Sources/ApacheBeam/Transforms/BuiltIn+Elements.swift b/Sources/ApacheBeam/Transforms/BuiltIn+Elements.swift
index 5c10295..0743bd5 100644
--- a/Sources/ApacheBeam/Transforms/BuiltIn+Elements.swift
+++ b/Sources/ApacheBeam/Transforms/BuiltIn+Elements.swift
@@ -20,6 +20,10 @@
 
 public extension PCollection {
     // No Output
+    /// Apply a closure-based ``DoFn`` to an input ``PCollection`` that returns no output.
+    /// - Parameters:
+    ///   - name: A name for this transform
+    ///   - fn: A closure that implements a DoFn by taking a single ``PInput`` and emitting no outputs
     func pardo(name: String, _ fn: @Sendable @escaping (PInput<Of>) async throws -> Void) {
         pstream(name: name) { input in
             for try await element in input {
@@ -29,6 +33,11 @@
     }
 
     // One Output
+    /// Apply a closure-based ``DoFn`` to an input ``PCollection`` that emits to a single output ``PCollection``
+    /// - Parameters:
+    ///   - name: A name for this transform
+    ///   - fn: <#fn description#>
+    /// - Returns: <#description#>
     func pardo<O0>(name: String, _ fn: @Sendable @escaping (PInput<Of>, POutput<O0>) async throws -> Void) -> PCollection<O0> {
         pstream(name: name) { input, output in
             for try await element in input {
diff --git a/Sources/ApacheBeam/Transforms/BuiltIn.swift b/Sources/ApacheBeam/Transforms/BuiltIn.swift
index cf0d8b2..5ee71d5 100644
--- a/Sources/ApacheBeam/Transforms/BuiltIn.swift
+++ b/Sources/ApacheBeam/Transforms/BuiltIn.swift
@@ -203,7 +203,9 @@
 }
 
 public extension PCollection {
-    /// Core GroupByKey transform. Requires a pair input
+    /// The built-in Beam GroupByKey transform. Requires that the input be a Beam key-value type.
+    ///
+    /// - Returns: A ``PCollection`` of type `KV<K,V>` where the value of the key-value pair is a `Sequence` of all values associated with the key `K`
     func groupByKey<K, V>() -> PCollection<KV<K, V>> where Of == KV<K, V> {
         // Adjust the coder for the pcollection to reflect GBK semantcs
         let output = PCollection<KV<K, V>>(coder: .keyvalue(.of(type: K.self)!, .of(type: [V].self)!), type: streamType)
diff --git a/Sources/ApacheBeam/Transforms/IO/FileIO.swift b/Sources/ApacheBeam/Transforms/IO/FileIO.swift
index 5bd2079..e7b6e15 100644
--- a/Sources/ApacheBeam/Transforms/IO/FileIO.swift
+++ b/Sources/ApacheBeam/Transforms/IO/FileIO.swift
@@ -18,12 +18,33 @@
 
 import Foundation
 
+/// Defines a protocol for transforms that know how to read from external File-like systems given an input
+/// collection of paths.
 public protocol FileIOSource {
+    /// A static function definition that takes `(path,matched_filename)` pairs output by ``readFiles(matching:)`` or some other source
+    /// and reads them as a single data output.
+    ///
+    /// - Parameter matching: An input ``PCollection`` of pairs representing a `(path,matched_filename)`
+    /// where `path` and `matched_filename` are dependent on the specific source.
+    /// - Returns: A ``PCollection`` of binary `Data` elements. Note that the original path and filename is not carried with the data.
     static func readFiles(matching: PCollection<KV<String, String>>) -> PCollection<Data>
+   
+    /// Static function definition for reading a list of files matching some pattern at a given path. The definition of "path" largely depends on the
+    /// source type. For example, for remote object stores that might be a bucket or a bucket prefix while for a local filesystem it would be a
+    /// standard file path. It is best to check the specific transform's documentation to verify
+    ///
+    ///
+    /// - Parameter matching: A pair representing the path to check and pattern to check with.
+    ///
+    /// - Returns: A list of pairs of the form `(path,matched_filename)`
     static func listFiles(matching: PCollection<KV<String, String>>) -> PCollection<KV<String, String>>
 }
 
 public extension PCollection<KV<String, String>> {
+    /// A transform for reading files from a concrete ``FileIOSource``.
+    /// - Parameter `_`: The type of ``FileIOSource`` to use. For example ``LocalStorage.self``
+    ///
+    /// - Returns: The data elements from the ``readFiles(matching:)`` implementation for this ``FileIOSource``
     func readFiles<Source: FileIOSource>(in _: Source.Type) -> PCollection<Data> {
         Source.readFiles(matching: self)
     }
diff --git a/Sources/ApacheBeam/Transforms/IO/GoogleCloud/GoogleStorage.swift b/Sources/ApacheBeam/Transforms/IO/GoogleCloud/GoogleStorage.swift
index b289f94..0481f7e 100644
--- a/Sources/ApacheBeam/Transforms/IO/GoogleCloud/GoogleStorage.swift
+++ b/Sources/ApacheBeam/Transforms/IO/GoogleCloud/GoogleStorage.swift
@@ -69,7 +69,13 @@
             }
         }
     }
-
+    
+    /// Match files in a Google Cloud Storage Bucket matching the prefix given by `(bucket,prefix)` string pairs.
+    ///
+    /// Note: Currently only the DefaultTokenProvider is supported.
+    ///
+    /// - Parameter matching: A ``PCollection`` of `(bucket,prefix)` pairs.
+    /// - Returns: A ``PCollection`` of `(bucket,file)` pairs.
     public static func listFiles(matching: PCollection<KV<String, String>>) -> PCollection<KV<String, String>> {
         matching.pstream(type: .bounded) { matching, output in
 
diff --git a/Sources/ApacheBeam/Transforms/IO/Local/LocalStorage.swift b/Sources/ApacheBeam/Transforms/IO/Local/LocalStorage.swift
index 51a04a5..aea4820 100644
--- a/Sources/ApacheBeam/Transforms/IO/Local/LocalStorage.swift
+++ b/Sources/ApacheBeam/Transforms/IO/Local/LocalStorage.swift
@@ -32,7 +32,6 @@
 
     public static func listFiles(matching: PCollection<KV<String, String>>) -> PCollection<KV<String, String>> {
         matching.pstream(type: .bounded) { input, output in
-            let fm = FileManager.default
             for try await (pathAndPattern, ts, w) in input {
                 let path = pathAndPattern.key
                 let patterns = try pathAndPattern.values.map { try Regex($0) }
diff --git a/Sources/Documentation.docc/ApacheBeam.md b/Sources/Documentation.docc/ApacheBeam.md
new file mode 100644
index 0000000..d0920b0
--- /dev/null
+++ b/Sources/Documentation.docc/ApacheBeam.md
@@ -0,0 +1,13 @@
+# ``ApacheBeam``
+
+<!--@START_MENU_TOKEN@-->Summary<!--@END_MENU_TOKEN@-->
+
+## Overview
+
+<!--@START_MENU_TOKEN@-->Text<!--@END_MENU_TOKEN@-->
+
+## Topics
+
+### <!--@START_MENU_TOKEN@-->Group<!--@END_MENU_TOKEN@-->
+
+- <!--@START_MENU_TOKEN@-->``Symbol``<!--@END_MENU_TOKEN@-->