diff --git a/Package.resolved b/Package.resolved
index 908ee008e9..2a874dae52 100644
--- a/Package.resolved
+++ b/Package.resolved
@@ -1,4 +1,5 @@
 {
+  "originHash" : "5eadfee9e0b253b1df4d25252f723cb36734ddef72daf92d852b242f15fa076d",
   "pins" : [
     {
       "identity" : "swift-argument-parser",
@@ -27,6 +28,15 @@
         "version" : "1.0.0"
       }
     },
+    {
+      "identity" : "swift-custom-dump",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/pointfreeco/swift-custom-dump",
+      "state" : {
+        "revision" : "82645ec760917961cfa08c9c0c7104a57a0fa4b1",
+        "version" : "1.3.3"
+      }
+    },
     {
       "identity" : "swift-docc-plugin",
       "kind" : "remoteSourceControl",
@@ -41,10 +51,10 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/pointfreeco/xctest-dynamic-overlay",
       "state" : {
-        "revision" : "302891700c7fa3b92ebde9fe7b42933f8349f3c7",
-        "version" : "1.0.0"
+        "revision" : "a3f634d1a409c7979cabc0a71b3f26ffa9fc8af1",
+        "version" : "1.4.3"
       }
     }
   ],
-  "version" : 2
+  "version" : 3
 }
diff --git a/Package.swift b/Package.swift
index 6a6a93bba5..d2b4dd1389 100644
--- a/Package.swift
+++ b/Package.swift
@@ -14,17 +14,30 @@ let package = Package(
     .library(
       name: "Parsing",
       targets: ["Parsing"]
-    )
+    ),
+    .library(name: "Conversions", targets: ["Parsing"])
   ],
   dependencies: [
     .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.0.0"),
     .package(url: "https://github.com/pointfreeco/swift-case-paths", from: "1.0.0"),
+    .package(url: "https://github.com/pointfreeco/swift-custom-dump", from: "1.3.3"),
     .package(url: "https://github.com/google/swift-benchmark", from: "0.1.1"),
   ],
   targets: [
     .target(
       name: "Parsing",
-      dependencies: [.product(name: "CasePaths", package: "swift-case-paths")]
+      dependencies: [
+        .product(name: "CasePaths", package: "swift-case-paths"),
+        .product(name: "CustomDump", package: "swift-custom-dump"),
+        .target(name: "Conversions")
+      ]
+    ),
+    .target(
+      name: "Conversions",
+      dependencies: [
+        .product(name: "CustomDump", package: "swift-custom-dump"),
+        .product(name: "CasePaths", package: "swift-case-paths")
+      ]
     ),
     .testTarget(
       name: "ParsingTests",
diff --git a/Sources/Parsing/Conversions/BinaryFloatingPoint.swift b/Sources/Conversions/BinaryFloatingPoint.swift
similarity index 100%
rename from Sources/Parsing/Conversions/BinaryFloatingPoint.swift
rename to Sources/Conversions/BinaryFloatingPoint.swift
diff --git a/Sources/Parsing/ConvertingError.swift b/Sources/Conversions/ConvertingError.swift
similarity index 100%
rename from Sources/Parsing/ConvertingError.swift
rename to Sources/Conversions/ConvertingError.swift
diff --git a/Sources/Parsing/Conversions/AnyConversion.swift b/Sources/Conversions/Core/AnyConversion.swift
similarity index 89%
rename from Sources/Parsing/Conversions/AnyConversion.swift
rename to Sources/Conversions/Core/AnyConversion.swift
index 17a0a7f01c..43973a43e3 100644
--- a/Sources/Parsing/Conversions/AnyConversion.swift
+++ b/Sources/Conversions/Core/AnyConversion.swift
@@ -121,6 +121,24 @@ public struct AnyConversion<Input, Output>: Conversion {
     self._unapply = conversion.unapply
   }
 
+
+  /// Creates a conversion that wraps the given closures in its ``apply(_:)`` and ``unapply(_:)``
+  /// methods
+  ///
+  /// - Parameters:
+  ///   - apply: A closure that attempts to convert an input into an output. `apply` is executed
+  ///     each time the ``apply(_:)`` method is called on the resulting conversion
+  ///   - unapply: A closure that attempts to convert an output into an input. `unapply` is executed
+  ///     each time the ``unapply(_:)`` method is called on the resulting conversion.
+  @inlinable
+  public init(
+    apply: @escaping (Input) throws -> Output,
+    unapply: @escaping (Output) throws -> Input
+  ) {
+    self._apply = apply
+    self._unapply = unapply
+  }
+
   /// Creates a conversion that wraps the given closures in its ``apply(_:)`` and ``unapply(_:)``
   /// methods, throwing an error when `nil` is returned.
   ///
diff --git a/Sources/Conversions/Core/Conversion.swift b/Sources/Conversions/Core/Conversion.swift
new file mode 100644
index 0000000000..52fa8418e6
--- /dev/null
+++ b/Sources/Conversions/Core/Conversion.swift
@@ -0,0 +1,51 @@
+
+/// Declares a type that can asynchronously transform an `Input` value into an `Output` value *and* transform an
+/// `Output` value back into an `Input` value.
+///
+/// Useful in bidirectionally tranforming types, like when writing something to the disk.
+/// printability via ``Parser/map(_:)-18m9d``.
+@rethrows public protocol Conversion<Input, Output> {
+  // The type of values this conversion converts from.
+  associatedtype Input
+
+  // The type of values this conversion converts to.
+  associatedtype Output
+
+  associatedtype Body
+
+  /// Attempts to asynchronously transform an input into an output.
+  ///
+  /// See ``Conversion/apply(_:)`` for the reverse process.
+  ///
+  /// - Parameter input: An input value.
+  /// - Returns: A transformed output value.
+  @Sendable func apply(_ input: Input) throws -> Output
+
+  /// Attempts to asynchronously transform an output back into an input.
+  ///
+  /// The reverse process of ``Conversion/apply(_:)``.
+  ///
+  /// - Parameter output: An output value.
+  /// - Returns: An "un"-transformed input value.
+  @Sendable func unapply(_ input: Output) throws -> Input
+
+  @ConversionBuilder
+  var body: Body { get }
+}
+
+extension Conversion
+where Body: Conversion, Body.Input == Input, Body.Output == Output {
+  public func apply(_ input: Input) throws -> Output {
+    try self.body.apply(input)
+  }
+
+  public func unapply(_ output: Output) throws -> Input {
+    try self.body.unapply(output)
+  }
+}
+
+extension Conversion where Body == Never {
+  public var body: Body {
+    return fatalError("Body of \(Self.self) should never be called")
+  }
+}
diff --git a/Sources/Conversions/Core/ConversionBuilder.swift b/Sources/Conversions/Core/ConversionBuilder.swift
new file mode 100644
index 0000000000..6fdf757937
--- /dev/null
+++ b/Sources/Conversions/Core/ConversionBuilder.swift
@@ -0,0 +1,26 @@
+//
+//  ConversionBuilder.swift
+//  swift-parsing
+//
+//  Created by Woodrow Melling on 10/24/24.
+//
+
+@resultBuilder
+public enum ConversionBuilder{
+  public static func buildBlock<T>() -> Conversions.Identity<T> {
+    Conversions.Identity()
+  }
+  public static func buildPartialBlock<C: Conversion>(first conversion: C) -> C {
+    conversion
+  }
+
+  public static func buildPartialBlock<
+    C0: Conversion,
+    C1: Conversion
+  >(
+    accumulated c0: C0,
+    next c1: C1
+  ) -> Conversions.Map<C0, C1> where C0.Output == C1.Input {
+    Conversions.Map(upstream: c0, downstream: c1)
+  }
+}
diff --git a/Sources/Parsing/Conversions/ConversionMap.swift b/Sources/Conversions/Core/ConversionMap.swift
similarity index 100%
rename from Sources/Parsing/Conversions/ConversionMap.swift
rename to Sources/Conversions/Core/ConversionMap.swift
diff --git a/Sources/Parsing/Conversions/Conversions.swift b/Sources/Conversions/Core/Conversions.swift
similarity index 100%
rename from Sources/Parsing/Conversions/Conversions.swift
rename to Sources/Conversions/Core/Conversions.swift
diff --git a/Sources/Conversions/Core/Inverted.swift b/Sources/Conversions/Core/Inverted.swift
new file mode 100644
index 0000000000..7f992a8800
--- /dev/null
+++ b/Sources/Conversions/Core/Inverted.swift
@@ -0,0 +1,37 @@
+//
+//  Inverted.swift
+//  swift-parsing
+//
+//  Created by Woodrow Melling on 10/28/24.
+//
+
+extension Conversions {
+  public struct Inverted<C: Conversion>: Conversion {
+    public var conversion: C
+
+    @inlinable
+    public init(_ conversion: C) {
+      self.conversion = conversion
+    }
+
+    @inlinable
+    @inline(__always)
+    public func apply(_ input: C.Output) throws -> C.Input {
+      try conversion.unapply(input)
+    }
+
+    @inlinable
+    @inline(__always)
+    public func unapply(_ output: C.Input) throws -> C.Output {
+      try conversion.apply(output)
+    }
+  }
+}
+
+public extension Conversion {
+  @inlinable
+  @inline(__always)
+  func inverted() -> Conversions.Inverted<Self> {
+    Conversions.Inverted(self)
+  }
+}
diff --git a/Sources/Parsing/Conversions/Data.swift b/Sources/Conversions/Data.swift
similarity index 100%
rename from Sources/Parsing/Conversions/Data.swift
rename to Sources/Conversions/Data.swift
diff --git a/Sources/Conversions/DataString.swift b/Sources/Conversions/DataString.swift
new file mode 100644
index 0000000000..58ac8a27c6
--- /dev/null
+++ b/Sources/Conversions/DataString.swift
@@ -0,0 +1,25 @@
+//
+//  DataString.swift
+//  OpenFestival
+//
+//  Created by Woodrow Melling on 10/25/24.
+//
+
+import Foundation
+
+
+extension Conversions {
+  public struct DataToString: Conversion {
+    public typealias Input = Data
+    public typealias Output = String
+    public init() {}
+
+    public func apply(_ input: Data) -> String {
+      String(decoding: input, as: UTF8.self)
+    }
+    
+    public func unapply(_ output: String) -> Data {
+      Data(output.utf8)
+    }
+  }
+}
diff --git a/Sources/Parsing/EmptyInitializable.swift b/Sources/Conversions/EmptyInitializable.swift
similarity index 100%
rename from Sources/Parsing/EmptyInitializable.swift
rename to Sources/Conversions/EmptyInitializable.swift
diff --git a/Sources/Parsing/Conversions/Enum.swift b/Sources/Conversions/Enum.swift
similarity index 100%
rename from Sources/Parsing/Conversions/Enum.swift
rename to Sources/Conversions/Enum.swift
diff --git a/Sources/Parsing/Conversions/FixedWidthInteger.swift b/Sources/Conversions/FixedWidthInteger.swift
similarity index 100%
rename from Sources/Parsing/Conversions/FixedWidthInteger.swift
rename to Sources/Conversions/FixedWidthInteger.swift
diff --git a/Sources/Parsing/Conversions/Identity.swift b/Sources/Conversions/Identity.swift
similarity index 100%
rename from Sources/Parsing/Conversions/Identity.swift
rename to Sources/Conversions/Identity.swift
diff --git a/Sources/Parsing/Conversions/JSON.swift b/Sources/Conversions/JSON.swift
similarity index 100%
rename from Sources/Parsing/Conversions/JSON.swift
rename to Sources/Conversions/JSON.swift
diff --git a/Sources/Parsing/Conversions/LosslessStringConvertible.swift b/Sources/Conversions/LosslessStringConvertible.swift
similarity index 100%
rename from Sources/Parsing/Conversions/LosslessStringConvertible.swift
rename to Sources/Conversions/LosslessStringConvertible.swift
diff --git a/Sources/Conversions/MapValues.swift b/Sources/Conversions/MapValues.swift
new file mode 100644
index 0000000000..35e86d29ab
--- /dev/null
+++ b/Sources/Conversions/MapValues.swift
@@ -0,0 +1,108 @@
+//
+//  MapValues.swift
+//  OpenFestival
+//
+//  Created by Woodrow Melling on 10/31/24.
+//
+
+
+
+extension Conversions {
+  public struct MapValues<C: Conversion>: Conversion {
+    var transform: C
+    
+    public init(_ transform: C) {
+      self.transform = transform
+    }
+    
+    public init(@ConversionBuilder _ build: () -> C) {
+      self.transform = build()
+    }
+    
+    public func apply(_ input: [C.Input]) throws -> [C.Output] {
+      try input.map(transform.apply)
+    }
+    
+    public func unapply(_ output: [C.Output]) throws -> [C.Input] {
+      try output.map(transform.unapply)
+    }
+  }
+  
+}
+
+
+
+extension Conversions {
+  public struct MapKVPairs<KeyConversion: Conversion, ValueConversion: Conversion>: Conversion
+  where KeyConversion.Input: Hashable & Sendable,
+        KeyConversion.Output: Hashable & Sendable,
+        ValueConversion.Input: Sendable,
+        ValueConversion.Output: Sendable
+  {
+    public typealias Input = [KeyConversion.Input: ValueConversion.Input]
+    public typealias Output = [KeyConversion.Output: ValueConversion.Output]
+    
+    var keyConversion: KeyConversion
+    var valueConversion: ValueConversion
+    
+    public init(keyConversion: KeyConversion, valueConversion: ValueConversion) {
+      self.keyConversion = keyConversion
+      self.valueConversion = valueConversion
+    }
+    
+    public func apply(_ input: Input) throws -> Output {
+      try input.mapKVPairs(
+        keyConversion.apply,
+        valueConversion.apply
+      )
+    }
+    
+    public func unapply(_ output: Output) throws -> Input {
+      try output.mapKVPairs(
+        keyConversion.unapply,
+        valueConversion.unapply
+      )
+    }
+  }
+}
+
+extension Dictionary {
+  func mapKVPairs<NewKey, NewValue>(
+    _ keyTransform:  @escaping (Key) throws -> NewKey,
+    _ valueTransform: @escaping (Value) throws -> NewValue
+  ) rethrows -> [NewKey: NewValue] {
+    return try Dictionary<NewKey, NewValue>(uniqueKeysWithValues: self.map {
+      return try (keyTransform($0.0), valueTransform($0.1))
+    })
+  }
+}
+
+extension Sequence {
+  /// - Parameters:
+  ///   - closure: Transformation to apply to each element
+  /// - Returns: Array of transformed elements in original order
+  public func concurrentMap<T: Sendable>(
+    _ transform: @escaping @Sendable (Element) async throws -> T
+  ) async rethrows -> [T] where Element: Sendable {
+    return try await withThrowingTaskGroup(of: (value: T, offset: Int).self) { group in
+      for (id, element) in self.enumerated() {
+        group.addTask {
+          try await (value: transform(element), offset: id)
+        }
+      }
+      
+      var array: [(value: T, offset: Int)] = []
+      array.reserveCapacity(self.underestimatedCount)
+      for try await result in group {
+        array.append(result)
+      }
+      
+      // Could this sort be avoided somehow? Maybe with an OrderedDictionary?
+      return array.sorted { lhs, rhs in
+        lhs.offset < rhs.offset
+      }
+      .map(\.value)
+    }
+  }
+  
+}
diff --git a/Sources/Parsing/Conversions/Memberwise.swift b/Sources/Conversions/Memberwise.swift
similarity index 97%
rename from Sources/Parsing/Conversions/Memberwise.swift
rename to Sources/Conversions/Memberwise.swift
index a1d1925950..fae0fff6be 100644
--- a/Sources/Parsing/Conversions/Memberwise.swift
+++ b/Sources/Conversions/Memberwise.swift
@@ -117,7 +117,7 @@ extension Conversion {
   ///   struct back into a tuple of values.
   @inlinable
   public static func memberwise<Values, Struct>(
-    _ initializer: @escaping (Values) -> Struct
+    _ initializer: @escaping @Sendable (Values) -> Struct
   ) -> Self where Self == Conversions.Memberwise<Values, Struct> {
     .init(initializer: initializer)
   }
@@ -126,10 +126,10 @@ extension Conversion {
 extension Conversions {
   public struct Memberwise<Values, Struct>: Conversion {
     @usableFromInline
-    let initializer: (Values) -> Struct
+    let initializer: @Sendable (Values) -> Struct
 
     @usableFromInline
-    init(initializer: @escaping (Values) -> Struct) {
+      init(initializer: @escaping @Sendable (Values) -> Struct) {
       self.initializer = initializer
     }
 
diff --git a/Sources/Conversions/ParseableFormatStyleConversion.swift b/Sources/Conversions/ParseableFormatStyleConversion.swift
new file mode 100644
index 0000000000..5b53d7a179
--- /dev/null
+++ b/Sources/Conversions/ParseableFormatStyleConversion.swift
@@ -0,0 +1,65 @@
+//#if os(iOS) || os(macOS) || os(tvOS) || os(watchOS)
+//  import Foundation
+//
+//  @available(iOS 15, macOS 12, tvOS 15, watchOS 8, *)
+//  extension Conversion {
+//    /// A conversion that wraps a parseable format style.
+//    ///
+//    /// This conversion forwards its ``apply(_:)`` and ``unapply(_:)`` methods to the underlying
+//    /// `ParseableFormatStyle` by invoking its parse strategy's `parse` method and its `format`
+//    /// method.
+//    ///
+//    /// See ``formatted(_:)-swift.method`` for a fluent version of this interface that transforms an
+//    /// existing conversion.
+//    ///
+//    /// - Parameter style: A parseable format style.
+//    /// - Returns: A conversion from a string to the given type.
+//    public static func formatted<Style>(
+//      _ style: Style
+//    ) -> Self where Self == Conversions.ParseableFormat<Style> {
+//      .init(style: style)
+//    }
+//
+//    /// Transforms this conversion to a parseable format style's parse input into a conversion to
+//    /// the parseable format style's parse output.
+//    ///
+//    /// A fluent version of ``Conversion/formatted(_:)-swift.type.method``. Equivalent to calling
+//    /// ``map(_:)`` with ``Conversion/formatted(_:)-swift.type.method``:
+//    ///
+//    /// ```swift
+//    /// Parse(.string.formatted(.currency("USD")))
+//    /// // =
+//    /// Parse(.string.map(.formatted(.currency("USD"))))
+//    /// ```
+//    ///
+//    /// - Parameter type: A type that conforms to `LosslessStringConvertible`.
+//    /// - Returns: A conversion from a string to the given type.
+//    public func formatted<Style>(
+//      _ style: Style
+//    ) -> Conversions.Map<Self, Conversions.ParseableFormat<Style>> {
+//      self.map(.formatted(style))
+//    }
+//  }
+//
+//  extension Conversions {
+//    /// A conversion for a parseable format style.
+//    ///
+//    /// You will not typically need to interact with this type directly. Instead you will usually
+//    /// use the ``Conversion/formatted(_:)-swift.type.method`` operation, which constructs this
+//    /// type.
+//    @available(iOS 15, macOS 12, tvOS 15, watchOS 8, *)
+//    public struct ParseableFormat<Style>: Conversion where Style: ParseableFormatStyle {
+//      public let style: Style
+//
+//      @inlinable
+//      public func apply(_ input: Style.Strategy.ParseInput) throws -> Style.Strategy.ParseOutput {
+//        try style.parseStrategy.parse(input)
+//      }
+//
+//      @inlinable
+//      public func unapply(_ output: Style.FormatInput) -> Style.FormatOutput {
+//        self.style.format(output)
+//      }
+//    }
+//  }
+//#endif
diff --git a/Sources/Parsing/PrependableCollection.swift b/Sources/Conversions/PrependableCollection.swift
similarity index 100%
rename from Sources/Parsing/PrependableCollection.swift
rename to Sources/Conversions/PrependableCollection.swift
diff --git a/Sources/Conversions/PrintChanges.swift b/Sources/Conversions/PrintChanges.swift
new file mode 100644
index 0000000000..b68bb1bf85
--- /dev/null
+++ b/Sources/Conversions/PrintChanges.swift
@@ -0,0 +1,28 @@
+//
+//  PrintChanges.swift
+//  OpenFestival
+//
+//  Created by Woodrow Melling on 10/31/24.
+//
+
+import CustomDump
+
+extension Conversion {
+    func _printChanges() -> some Conversion<Input, Output> {
+        AnyConversion(
+            apply: {
+                customDump($0, name: "Before \(Self.self).apply")
+                let result = try self.apply($0)
+                customDump(result, name: "After \(Self.self).apply")
+
+                return result
+            },
+            unapply: {
+                customDump($0, name: "Before \(Self.self).unapply")
+                let result = try self.unapply($0)
+                customDump(result, name: "After \(Self.self) unapply")
+                return result
+            }
+        )
+    }
+}
diff --git a/Sources/Parsing/Conversions/RawRepresentable.swift b/Sources/Conversions/RawRepresentable.swift
similarity index 100%
rename from Sources/Parsing/Conversions/RawRepresentable.swift
rename to Sources/Conversions/RawRepresentable.swift
diff --git a/Sources/Parsing/Conversions/String.swift b/Sources/Conversions/String.swift
similarity index 100%
rename from Sources/Parsing/Conversions/String.swift
rename to Sources/Conversions/String.swift
diff --git a/Sources/Parsing/Conversions/Substring.swift b/Sources/Conversions/Substring.swift
similarity index 100%
rename from Sources/Parsing/Conversions/Substring.swift
rename to Sources/Conversions/Substring.swift
diff --git a/Sources/Conversions/TupleConversion.swift b/Sources/Conversions/TupleConversion.swift
new file mode 100644
index 0000000000..5ae72cc781
--- /dev/null
+++ b/Sources/Conversions/TupleConversion.swift
@@ -0,0 +1,41 @@
+//
+//  TupleConversion.swift
+//  OpenFestival
+//
+//  Created by Woodrow Melling on 10/25/24.
+//
+
+
+public extension Conversions {
+
+  @available(iOS 17, *)
+  @available(macOS 14, *)
+  @available(tvOS 16, *)
+  @available(watchOS 9, *)
+  struct Tuple<each C: Conversion>: Conversion {
+    public typealias Input = (repeat (each C).Input)
+    public typealias Output = (repeat (each C).Output)
+
+    let conversions: (repeat each C)
+
+    public init(_ conversions: repeat each C) {
+      self.conversions = (repeat each conversions)
+    }
+
+    public func apply(_ inputs: Input) throws -> Output {
+      func apply<T: Conversion>(conversion: T, to input: T.Input) throws -> T.Output {
+        try conversion.apply(input)
+      }
+
+      return (repeat try apply(conversion: each conversions, to: each inputs))
+    }
+
+    public func unapply(_ output: (repeat (each C).Output)) throws -> (repeat (each C).Input) {
+      func unapply<T: Conversion>(conversion: T, to output: T.Output) throws -> T.Input {
+        try conversion.unapply(output)
+      }
+
+      return (repeat try unapply(conversion: each conversions, to: each output))
+    }
+  }
+}
diff --git a/Sources/Parsing/Conversions/UTF8View.swift b/Sources/Conversions/UTF8View.swift
similarity index 100%
rename from Sources/Parsing/Conversions/UTF8View.swift
rename to Sources/Conversions/UTF8View.swift
diff --git a/Sources/Parsing/Builders/OneOfBuilder.swift b/Sources/Parsing/Builders/OneOfBuilder.swift
index 7031cc1fbf..9a8fd2296f 100644
--- a/Sources/Parsing/Builders/OneOfBuilder.swift
+++ b/Sources/Parsing/Builders/OneOfBuilder.swift
@@ -1,3 +1,5 @@
+import Conversions
+
 /// A custom parameter attribute that constructs parsers from closures. The constructed parser
 /// runs each parser in the closure, one after another, till one succeeds with an output.
 ///
diff --git a/Sources/Parsing/Builders/ParserBuilder.swift b/Sources/Parsing/Builders/ParserBuilder.swift
index b97b5289de..fe36ce5e7b 100644
--- a/Sources/Parsing/Builders/ParserBuilder.swift
+++ b/Sources/Parsing/Builders/ParserBuilder.swift
@@ -1,3 +1,5 @@
+import Conversions
+
 /// A custom parameter attribute that constructs parsers from closures. The constructed parser
 /// runs a number of parsers, one after the other, and accumulates their outputs.
 ///
diff --git a/Sources/Parsing/Conversion.swift b/Sources/Parsing/Conversion.swift
deleted file mode 100644
index 6bc6500a4f..0000000000
--- a/Sources/Parsing/Conversion.swift
+++ /dev/null
@@ -1,28 +0,0 @@
-/// Declares a type that can transform an `Input` value into an `Output` value *and* transform an
-/// `Output` value back into an `Input` value.
-///
-/// Useful in transforming the output of a parser-printer into some new type while preserving
-/// printability via ``Parser/map(_:)-18m9d``.
-@rethrows public protocol Conversion<Input, Output> {
-  // The type of values this conversion converts from.
-  associatedtype Input
-
-  // The type of values this conversion converts to.
-  associatedtype Output
-
-  /// Attempts to transform an input into an output.
-  ///
-  /// See ``Conversion/apply(_:)`` for the reverse process.
-  ///
-  /// - Parameter input: An input value.
-  /// - Returns: A transformed output value.
-  func apply(_ input: Input) throws -> Output
-
-  /// Attempts to transform an output back into an input.
-  ///
-  /// The reverse process of ``Conversion/apply(_:)``.
-  ///
-  /// - Parameter output: An output value.
-  /// - Returns: An "un"-transformed input value.
-  func unapply(_ output: Output) throws -> Input
-}
diff --git a/Sources/Parsing/Conversions/ParseableFormatStyleConversion.swift b/Sources/Parsing/Conversions/ParseableFormatStyleConversion.swift
deleted file mode 100644
index a3c4b2632e..0000000000
--- a/Sources/Parsing/Conversions/ParseableFormatStyleConversion.swift
+++ /dev/null
@@ -1,65 +0,0 @@
-#if os(iOS) || os(macOS) || os(tvOS) || os(watchOS)
-  import Foundation
-
-  @available(iOS 15, macOS 12, tvOS 15, watchOS 8, *)
-  extension Conversion {
-    /// A conversion that wraps a parseable format style.
-    ///
-    /// This conversion forwards its ``apply(_:)`` and ``unapply(_:)`` methods to the underlying
-    /// `ParseableFormatStyle` by invoking its parse strategy's `parse` method and its `format`
-    /// method.
-    ///
-    /// See ``formatted(_:)-swift.method`` for a fluent version of this interface that transforms an
-    /// existing conversion.
-    ///
-    /// - Parameter style: A parseable format style.
-    /// - Returns: A conversion from a string to the given type.
-    public static func formatted<Style>(
-      _ style: Style
-    ) -> Self where Self == Conversions.ParseableFormat<Style> {
-      .init(style: style)
-    }
-
-    /// Transforms this conversion to a parseable format style's parse input into a conversion to
-    /// the parseable format style's parse output.
-    ///
-    /// A fluent version of ``Conversion/formatted(_:)-swift.type.method``. Equivalent to calling
-    /// ``map(_:)`` with ``Conversion/formatted(_:)-swift.type.method``:
-    ///
-    /// ```swift
-    /// Parse(.string.formatted(.currency("USD")))
-    /// // =
-    /// Parse(.string.map(.formatted(.currency("USD"))))
-    /// ```
-    ///
-    /// - Parameter type: A type that conforms to `LosslessStringConvertible`.
-    /// - Returns: A conversion from a string to the given type.
-    public func formatted<Style>(
-      _ style: Style
-    ) -> Conversions.Map<Self, Conversions.ParseableFormat<Style>> {
-      self.map(.formatted(style))
-    }
-  }
-
-  extension Conversions {
-    /// A conversion for a parseable format style.
-    ///
-    /// You will not typically need to interact with this type directly. Instead you will usually
-    /// use the ``Conversion/formatted(_:)-swift.type.method`` operation, which constructs this
-    /// type.
-    @available(iOS 15, macOS 12, tvOS 15, watchOS 8, *)
-    public struct ParseableFormat<Style>: Conversion where Style: ParseableFormatStyle {
-      public let style: Style
-
-      @inlinable
-      public func apply(_ input: Style.Strategy.ParseInput) throws -> Style.Strategy.ParseOutput {
-        try style.parseStrategy.parse(input)
-      }
-
-      @inlinable
-      public func unapply(_ output: Style.FormatInput) -> Style.FormatOutput {
-        self.style.format(output)
-      }
-    }
-  }
-#endif
diff --git a/Sources/Parsing/Exports.swift b/Sources/Parsing/Exports.swift
new file mode 100644
index 0000000000..bed8280bdb
--- /dev/null
+++ b/Sources/Parsing/Exports.swift
@@ -0,0 +1,8 @@
+//
+//  Exports.swift
+//  swift-parsing
+//
+//  Created by Woodrow Melling on 11/25/24.
+//
+
+@_exported import Conversions
diff --git a/Sources/Parsing/Internal/Deprecations.swift b/Sources/Parsing/Internal/Deprecations.swift
index 904f1f1c66..63ca7857bf 100644
--- a/Sources/Parsing/Internal/Deprecations.swift
+++ b/Sources/Parsing/Internal/Deprecations.swift
@@ -1,5 +1,5 @@
 import Foundation
-
+import Conversions
 // NB: Deprecated after 0.11.0
 
 extension Bool {
diff --git a/Sources/Parsing/ParserPrinter.swift b/Sources/Parsing/ParserPrinter.swift
index 3a7afe3f2f..7d860c3769 100644
--- a/Sources/Parsing/ParserPrinter.swift
+++ b/Sources/Parsing/ParserPrinter.swift
@@ -1,3 +1,5 @@
+import Conversions
+
 /// A ``Parser`` that can incrementally "print" an output value back into an input.
 ///
 /// > Note: Printing is the reverse operation of parsing, so the `Input` is essentially built up
diff --git a/Sources/Parsing/ParserPrinters/Bool.swift b/Sources/Parsing/ParserPrinters/Bool.swift
index eb54a5abee..3ca4f01c07 100644
--- a/Sources/Parsing/ParserPrinters/Bool.swift
+++ b/Sources/Parsing/ParserPrinters/Bool.swift
@@ -1,3 +1,5 @@
+import Conversions
+
 extension Bool {
   /// A parser that consumes a Boolean value from the beginning of a collection of UTF-8 code units.
   ///
diff --git a/Sources/Parsing/ParserPrinters/CaseIterableRawRepresentable.swift b/Sources/Parsing/ParserPrinters/CaseIterableRawRepresentable.swift
index 6b1dd3f8bb..6eb2c2df26 100644
--- a/Sources/Parsing/ParserPrinters/CaseIterableRawRepresentable.swift
+++ b/Sources/Parsing/ParserPrinters/CaseIterableRawRepresentable.swift
@@ -1,3 +1,5 @@
+import Conversions
+
 extension CaseIterable where Self: RawRepresentable, RawValue: FixedWidthInteger {
   /// A parser that consumes a case-iterable, raw representable value from the beginning of a
   /// collection of a substring.
diff --git a/Sources/Parsing/ParserPrinters/Consumed.swift b/Sources/Parsing/ParserPrinters/Consumed.swift
index e2048c12c5..9e96b25fd2 100644
--- a/Sources/Parsing/ParserPrinters/Consumed.swift
+++ b/Sources/Parsing/ParserPrinters/Consumed.swift
@@ -1,3 +1,5 @@
+import Conversions
+
 /// A parser that returns the subsequence of input consumed by another parser.
 public struct Consumed<Input: Collection, Upstream: Parser>: Parser
 where
diff --git a/Sources/Parsing/ParserPrinters/Digits.swift b/Sources/Parsing/ParserPrinters/Digits.swift
index 99bc70f737..cf40ad6c5c 100644
--- a/Sources/Parsing/ParserPrinters/Digits.swift
+++ b/Sources/Parsing/ParserPrinters/Digits.swift
@@ -1,3 +1,5 @@
+import Conversions
+
 /// A parser that consumes a number of digits from the beginning of a collection of UTF-8 code
 /// units.
 ///
diff --git a/Sources/Parsing/ParserPrinters/From.swift b/Sources/Parsing/ParserPrinters/From.swift
index 1bbafe808c..70322d6bc5 100644
--- a/Sources/Parsing/ParserPrinters/From.swift
+++ b/Sources/Parsing/ParserPrinters/From.swift
@@ -1,3 +1,5 @@
+import Conversions
+
 public struct From<Upstream: Conversion, DownstreamInput, Downstream: Parser>: Parser
 where Upstream.Output == DownstreamInput, Downstream.Input == DownstreamInput {
   @usableFromInline
diff --git a/Sources/Parsing/ParserPrinters/Map.swift b/Sources/Parsing/ParserPrinters/Map.swift
index 0ccfb6012e..00b4118c84 100644
--- a/Sources/Parsing/ParserPrinters/Map.swift
+++ b/Sources/Parsing/ParserPrinters/Map.swift
@@ -1,3 +1,5 @@
+import Conversions
+
 extension Parser {
   /// Returns a parser that transforms the output of this parser with a given closure.
   ///
diff --git a/Sources/Parsing/ParserPrinters/Pipe.swift b/Sources/Parsing/ParserPrinters/Pipe.swift
index 7c043fb83a..6445fd9026 100644
--- a/Sources/Parsing/ParserPrinters/Pipe.swift
+++ b/Sources/Parsing/ParserPrinters/Pipe.swift
@@ -1,3 +1,5 @@
+import Conversions
+
 extension Parser {
   /// Returns a parser that runs this parser, pipes its output into the given parser, and returns
   /// the output of the given parser.
diff --git a/Sources/Parsing/ParserPrinters/Prefix.swift b/Sources/Parsing/ParserPrinters/Prefix.swift
index 985fa3dac7..1d5ec7db56 100644
--- a/Sources/Parsing/ParserPrinters/Prefix.swift
+++ b/Sources/Parsing/ParserPrinters/Prefix.swift
@@ -1,3 +1,5 @@
+import Conversions
+
 /// A parser that consumes a subsequence from the beginning of its input.
 ///
 /// This parser is named after `Sequence.prefix`, which it uses under the hood to consume a number
diff --git a/Sources/Parsing/ParserPrinters/PrefixThrough.swift b/Sources/Parsing/ParserPrinters/PrefixThrough.swift
index d7db24f823..72f6bbe729 100644
--- a/Sources/Parsing/ParserPrinters/PrefixThrough.swift
+++ b/Sources/Parsing/ParserPrinters/PrefixThrough.swift
@@ -1,3 +1,5 @@
+import Conversions
+
 /// A parser that consumes a subsequence from the beginning of its input through a given sequence of
 /// elements.
 ///
diff --git a/Sources/Parsing/ParserPrinters/PrefixUpTo.swift b/Sources/Parsing/ParserPrinters/PrefixUpTo.swift
index 899b459013..68cf336537 100644
--- a/Sources/Parsing/ParserPrinters/PrefixUpTo.swift
+++ b/Sources/Parsing/ParserPrinters/PrefixUpTo.swift
@@ -1,3 +1,5 @@
+import Conversions
+
 /// A parser that consumes a subsequence from the beginning of its input up to a given sequence of
 /// elements.
 ///
diff --git a/Sources/Parsing/ParserPrinters/Rest.swift b/Sources/Parsing/ParserPrinters/Rest.swift
index 79a87dae38..3150631baa 100644
--- a/Sources/Parsing/ParserPrinters/Rest.swift
+++ b/Sources/Parsing/ParserPrinters/Rest.swift
@@ -1,3 +1,5 @@
+import Conversions
+
 /// A parser that consumes everything to the end of the collection and returns this subsequence as
 /// its output.
 ///
diff --git a/Sources/Parsing/ParserPrinters/StartsWith.swift b/Sources/Parsing/ParserPrinters/StartsWith.swift
index d21568f005..c04e4c1db3 100644
--- a/Sources/Parsing/ParserPrinters/StartsWith.swift
+++ b/Sources/Parsing/ParserPrinters/StartsWith.swift
@@ -1,3 +1,5 @@
+import Conversions
+
 /// A parser that parses a sequence of elements from its input.
 ///
 /// This parser is named after `Sequence.starts(with:)`, and tests that the input it is parsing
diff --git a/Sources/Parsing/ParserPrinters/Whitespace.swift b/Sources/Parsing/ParserPrinters/Whitespace.swift
index c602697882..f483144adf 100644
--- a/Sources/Parsing/ParserPrinters/Whitespace.swift
+++ b/Sources/Parsing/ParserPrinters/Whitespace.swift
@@ -1,3 +1,5 @@
+import Conversions
+
 /// A parser that consumes whitespace from the beginning of input.
 public struct Whitespace<Length: CountingRange, InputToBytes: Conversion>: Parser
 where
diff --git a/Sources/Parsing/ParsingError.swift b/Sources/Parsing/ParsingError.swift
index 5c03dbc674..01d68fe053 100644
--- a/Sources/Parsing/ParsingError.swift
+++ b/Sources/Parsing/ParsingError.swift
@@ -113,23 +113,23 @@ enum ParsingError: Error {
   }
 
   @usableFromInline
-  struct Context {
+  struct Context: Sendable {
     @usableFromInline
     var debugDescription: String
 
     @usableFromInline
-    var originalInput: Any
+    var originalInput: any Sendable
 
     @usableFromInline
-    var remainingInput: Any
+    var remainingInput: any Sendable
 
     @usableFromInline
     var underlyingError: Error?
 
     @usableFromInline
     init(
-      originalInput: Any,
-      remainingInput: Any,
+      originalInput: any Sendable,
+      remainingInput: any Sendable,
       debugDescription: String,
       underlyingError: Error? = nil
     ) {
@@ -141,7 +141,7 @@ enum ParsingError: Error {
 
     @usableFromInline
     init(
-      remainingInput: Any,
+      remainingInput: any Sendable,
       debugDescription: String,
       underlyingError: Error? = nil
     ) {