diff --git a/Package.swift b/Package.swift
index 25d6091b3..b92f17209 100644
--- a/Package.swift
+++ b/Package.swift
@@ -34,7 +34,8 @@ let package = Package(
             ]),
         .testTarget(
             name: "MatchingEngineTests",
-            dependencies: ["_MatchingEngine"]),
+            dependencies: [
+              "_MatchingEngine", "_StringProcessing"]),
         .target(
             name: "_StringProcessing",
             dependencies: ["_MatchingEngine"],
@@ -50,7 +51,7 @@ let package = Package(
             ]),
         .target(
             name: "Prototypes",
-            dependencies: ["_MatchingEngine"]),
+            dependencies: ["_MatchingEngine", "_StringProcessing"]),
 
         // MARK: Scripts
         .executableTarget(
diff --git a/Sources/Exercises/Participants/PEGParticipant.swift b/Sources/Exercises/Participants/PEGParticipant.swift
index 2b8a597f5..21bec6a7c 100644
--- a/Sources/Exercises/Participants/PEGParticipant.swift
+++ b/Sources/Exercises/Participants/PEGParticipant.swift
@@ -40,7 +40,7 @@ private func graphemeBreakPropertyData(forLine line: String) -> GraphemeBreakEnt
   let program = PEG.Program(start: "Entry", environment: ["Entry": entry])
 
   let vm = program.compile(for: String.self)
-  let engine = try! program.transpile(for: String.self)
+  let engine = try! program.transpile()
   _ = (vm, engine)
 
   fatalError("Unsupported")
diff --git a/Sources/Prototypes/PEG/PEGCode.swift b/Sources/Prototypes/PEG/PEGCode.swift
index 2398ca2ff..c33f5759c 100644
--- a/Sources/Prototypes/PEG/PEGCode.swift
+++ b/Sources/Prototypes/PEG/PEGCode.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import _MatchingEngine
+import _StringProcessing
 
 extension PEG.VM {
   struct Code {
diff --git a/Sources/Prototypes/PEG/PEGCompile.swift b/Sources/Prototypes/PEG/PEGCompile.swift
index 7268de450..0592cf6a9 100644
--- a/Sources/Prototypes/PEG/PEGCompile.swift
+++ b/Sources/Prototypes/PEG/PEGCompile.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import _MatchingEngine
+import _StringProcessing
 
 extension PEG.VM {
   typealias InIndex = Input.Index
diff --git a/Sources/Prototypes/PEG/PEGCore.swift b/Sources/Prototypes/PEG/PEGCore.swift
index f8f4458a7..b831cbd0f 100644
--- a/Sources/Prototypes/PEG/PEGCore.swift
+++ b/Sources/Prototypes/PEG/PEGCore.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import _MatchingEngine
+import _StringProcessing
 let emitComments = true
 
 struct PEGCore<
diff --git a/Sources/Prototypes/PEG/PEGTranspile.swift b/Sources/Prototypes/PEG/PEGTranspile.swift
index a6f724a03..df75cea63 100644
--- a/Sources/Prototypes/PEG/PEGTranspile.swift
+++ b/Sources/Prototypes/PEG/PEGTranspile.swift
@@ -10,12 +10,13 @@
 //===----------------------------------------------------------------------===//
 
 import _MatchingEngine
+import _StringProcessing
 
-extension PEG.VM {
-  typealias MEProgram = _MatchingEngine.Program<Input>
-  func transpile() throws -> MEProgram {
-    typealias Builder = MEProgram.Builder
-    var builder = MEProgram.Builder()
+extension PEG.VM where Input == String {
+  typealias MEProg = MEProgram<String>
+  func transpile() throws -> MEProg {
+    typealias Builder = MEProg.Builder
+    var builder = MEProg.Builder()
 
     // Address token info
     //
@@ -110,10 +111,9 @@ extension PEG.VM {
   }
 }
 
-extension PEG.Program {
-  public func transpile<Input: Collection>(
-    for input: Input.Type = Input.self
-  ) throws -> Engine<Input> where Input.Element == Element {
-    try Engine(compile(for: input).vm.transpile())
+extension PEG.Program where Element == Character {
+  public func transpile(
+  ) throws -> Engine<String> {
+    try Engine(compile(for: String.self).vm.transpile())
   }
 }
diff --git a/Sources/Prototypes/PEG/PEGVM.swift b/Sources/Prototypes/PEG/PEGVM.swift
index 58faef2d2..a987b581d 100644
--- a/Sources/Prototypes/PEG/PEGVM.swift
+++ b/Sources/Prototypes/PEG/PEGVM.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import _MatchingEngine
+import _StringProcessing
 
 extension PEG {
 
diff --git a/Sources/Prototypes/PEG/Printing.swift b/Sources/Prototypes/PEG/Printing.swift
index 5d1a8bc64..978250761 100644
--- a/Sources/Prototypes/PEG/Printing.swift
+++ b/Sources/Prototypes/PEG/Printing.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-import _MatchingEngine
+import _StringProcessing
 
 extension PEGCore.Instruction: InstructionProtocol {
   var operandPC: InstructionAddress? { self.pc }
diff --git a/Sources/_StringProcessing/ByteCodeGen.swift b/Sources/_StringProcessing/ByteCodeGen.swift
index 8dbcb9026..cd50d5650 100644
--- a/Sources/_StringProcessing/ByteCodeGen.swift
+++ b/Sources/_StringProcessing/ByteCodeGen.swift
@@ -3,10 +3,10 @@ import _MatchingEngine
 extension Compiler {
   struct ByteCodeGen {
     var options: MatchingOptions
-    var builder = _MatchingEngine.Program<String>.Builder()
+    var builder = Program.Builder()
 
     mutating func finish(
-    ) throws -> _MatchingEngine.Program<String> {
+    ) throws -> Program {
       builder.buildAccept()
       return try builder.assemble()
     }
diff --git a/Sources/_StringProcessing/Compiler.swift b/Sources/_StringProcessing/Compiler.swift
index 64491b8e2..2690e2e95 100644
--- a/Sources/_StringProcessing/Compiler.swift
+++ b/Sources/_StringProcessing/Compiler.swift
@@ -11,11 +11,6 @@
 
 import _MatchingEngine
 
-struct RegexProgram {
-  typealias Program = _MatchingEngine.Program<String>
-  var program: Program
-}
-
 class Compiler {
   let tree: DSLTree
 
@@ -30,12 +25,12 @@ class Compiler {
     self.tree = tree
   }
 
-  __consuming func emit() throws -> RegexProgram {
+  __consuming func emit() throws -> Program {
     // TODO: Handle global options
     var codegen = ByteCodeGen(options: options)
     try codegen.emitNode(tree.root)
     let program = try codegen.finish()
-    return RegexProgram(program: program)
+    return program
   }
 }
 
diff --git a/Sources/_StringProcessing/ConsumerInterface.swift b/Sources/_StringProcessing/ConsumerInterface.swift
index 3979dab34..b6cdbba5b 100644
--- a/Sources/_StringProcessing/ConsumerInterface.swift
+++ b/Sources/_StringProcessing/ConsumerInterface.swift
@@ -18,7 +18,7 @@ extension DSLTree.Node {
   /// the front of an input range
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction? {
+  ) throws -> MEProgram<String>.ConsumeFunction? {
     switch self {
     case .atom(let a):
       return try a.generateConsumer(opts)
@@ -55,7 +55,7 @@ extension DSLTree.Atom {
   // unnecessary...
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction? {
+  ) throws -> MEProgram<String>.ConsumeFunction? {
     switch self {
 
     case let .char(c):
@@ -112,7 +112,7 @@ extension AST.Atom {
 
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction? {
+  ) throws -> MEProgram<String>.ConsumeFunction? {
     // TODO: Wean ourselves off of this type...
     if let cc = self.characterClass?.withMatchLevel(
       opts.matchLevel
@@ -171,7 +171,7 @@ extension AST.Atom {
 extension DSLTree.CustomCharacterClass.Member {
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction {
+  ) throws -> MEProgram<String>.ConsumeFunction {
     switch self {
     case let .atom(a):
       guard let c = try a.generateConsumer(opts) else {
@@ -256,7 +256,7 @@ extension DSLTree.CustomCharacterClass.Member {
 extension AST.CustomCharacterClass.Member {
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction {
+  ) throws -> MEProgram<String>.ConsumeFunction {
     switch self {
     case .custom(let ccc):
       return try ccc.generateConsumer(opts)
@@ -351,7 +351,7 @@ extension AST.CustomCharacterClass.Member {
 extension DSLTree.CustomCharacterClass {
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction {
+  ) throws -> MEProgram<String>.ConsumeFunction {
     // NOTE: Easy way to implement, obviously not performant
     let consumers = try members.map {
       try $0.generateConsumer(opts)
@@ -374,7 +374,7 @@ extension DSLTree.CustomCharacterClass {
 extension AST.CustomCharacterClass {
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction {
+  ) throws -> MEProgram<String>.ConsumeFunction {
     // NOTE: Easy way to implement, obviously not performant
     let consumers = try strippingTriviaShallow.members.map {
       try $0.generateConsumer(opts)
@@ -397,22 +397,22 @@ extension AST.CustomCharacterClass {
 // NOTE: Conveniences, though not most performant
 private func consumeScalarGC(
   _ gc: Unicode.GeneralCategory
-) -> Program<String>.ConsumeFunction {
+) -> MEProgram<String>.ConsumeFunction {
   consumeScalar { gc == $0.properties.generalCategory }
 }
 private func consumeScalarGCs(
   _ gcs: [Unicode.GeneralCategory]
-) -> Program<String>.ConsumeFunction {
+) -> MEProgram<String>.ConsumeFunction {
   consumeScalar { gcs.contains($0.properties.generalCategory) }
 }
 private func consumeScalarProp(
   _ p: @escaping (Unicode.Scalar.Properties) -> Bool
-) -> Program<String>.ConsumeFunction {
+) -> MEProgram<String>.ConsumeFunction {
   consumeScalar { p($0.properties) }
 }
 func consumeScalar(
   _ p: @escaping (Unicode.Scalar) -> Bool
-) -> Program<String>.ConsumeFunction {
+) -> MEProgram<String>.ConsumeFunction {
   { input, bounds in
     // TODO: bounds check?
     let curIdx = bounds.lowerBound
@@ -427,11 +427,11 @@ func consumeScalar(
 extension AST.Atom.CharacterProperty {
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction {
+  ) throws -> MEProgram<String>.ConsumeFunction {
     // Handle inversion for us, albeit not efficiently
     func invert(
-      _ p: @escaping Program<String>.ConsumeFunction
-    ) -> Program<String>.ConsumeFunction {
+      _ p: @escaping MEProgram<String>.ConsumeFunction
+    ) -> MEProgram<String>.ConsumeFunction {
       return { input, bounds in
         if p(input, bounds) != nil { return nil }
         // TODO: semantic level
@@ -444,7 +444,7 @@ extension AST.Atom.CharacterProperty {
     // FIXME: Below is largely scalar based, for convenience,
     // but we want a comprehensive treatment to semantic mode
     // switching.
-    let preInversion: Program<String>.ConsumeFunction =
+    let preInversion: MEProgram<String>.ConsumeFunction =
     try {
       switch kind {
         // TODO: is this modeled differently?
@@ -498,7 +498,7 @@ extension Unicode.BinaryProperty {
   // FIXME: Semantic level, vet for precise defs
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction {
+  ) throws -> MEProgram<String>.ConsumeFunction {
     switch self {
 
     case .asciiHexDigit:
@@ -664,7 +664,7 @@ extension Unicode.POSIXProperty {
   // FIXME: Semantic level, vet for precise defs
   func generateConsumer(
     _ opts: MatchingOptions
-  ) -> Program<String>.ConsumeFunction {
+  ) -> MEProgram<String>.ConsumeFunction {
     // FIXME: semantic levels, modes, etc
     switch self {
     case .alnum:
@@ -710,7 +710,7 @@ extension Unicode.ExtendedGeneralCategory {
   // FIXME: Semantic level
   func generateConsumer(
     _ opts: MatchingOptions
-  ) throws -> Program<String>.ConsumeFunction {
+  ) throws -> MEProgram<String>.ConsumeFunction {
     switch self {
     case .letter:
       return consumeScalarGCs([
diff --git a/Sources/_MatchingEngine/Engine/Backtracking.swift b/Sources/_StringProcessing/Engine/Backtracking.swift
similarity index 100%
rename from Sources/_MatchingEngine/Engine/Backtracking.swift
rename to Sources/_StringProcessing/Engine/Backtracking.swift
diff --git a/Sources/_MatchingEngine/Engine/Consume.swift b/Sources/_StringProcessing/Engine/Consume.swift
similarity index 97%
rename from Sources/_MatchingEngine/Engine/Consume.swift
rename to Sources/_StringProcessing/Engine/Consume.swift
index 011e41a9d..e41115ad0 100644
--- a/Sources/_MatchingEngine/Engine/Consume.swift
+++ b/Sources/_StringProcessing/Engine/Consume.swift
@@ -34,7 +34,7 @@ extension Engine where Input == String {
   public func consume(
     _ input: Input,
     in range: Range<Input.Index>,
-    matchMode: MatchMode = .prefix
+    matchMode: MatchMode = .partialFromFront
   ) -> (Input.Index, CaptureList)? {
     if enableTracing {
       print("Consume: \(input)")
diff --git a/Sources/_MatchingEngine/Engine/Engine.swift b/Sources/_StringProcessing/Engine/Engine.swift
similarity index 94%
rename from Sources/_MatchingEngine/Engine/Engine.swift
rename to Sources/_StringProcessing/Engine/Engine.swift
index 09f3b32c3..6c9c2efa5 100644
--- a/Sources/_MatchingEngine/Engine/Engine.swift
+++ b/Sources/_StringProcessing/Engine/Engine.swift
@@ -13,7 +13,7 @@
 // But, we can play around with this.
 public struct Engine<Input: BidirectionalCollection> where Input.Element: Hashable {
 
-  var program: Program<Input>
+  var program: MEProgram<Input>
 
   // TODO: Pre-allocated register banks
 
@@ -25,7 +25,7 @@ public struct Engine<Input: BidirectionalCollection> where Input.Element: Hashab
   }
 
   public init(
-    _ program: Program<Input>,
+    _ program: MEProgram<Input>,
     enableTracing: Bool? = nil
   ) {
     var program = program
diff --git a/Sources/_MatchingEngine/Engine/InstPayload.swift b/Sources/_StringProcessing/Engine/InstPayload.swift
similarity index 100%
rename from Sources/_MatchingEngine/Engine/InstPayload.swift
rename to Sources/_StringProcessing/Engine/InstPayload.swift
diff --git a/Sources/_MatchingEngine/Engine/Instruction.swift b/Sources/_StringProcessing/Engine/Instruction.swift
similarity index 100%
rename from Sources/_MatchingEngine/Engine/Instruction.swift
rename to Sources/_StringProcessing/Engine/Instruction.swift
diff --git a/Sources/_MatchingEngine/Engine/Builder.swift b/Sources/_StringProcessing/Engine/MEBuilder.swift
similarity index 96%
rename from Sources/_MatchingEngine/Engine/Builder.swift
rename to Sources/_StringProcessing/Engine/MEBuilder.swift
index f6917b142..1f789a52b 100644
--- a/Sources/_MatchingEngine/Engine/Builder.swift
+++ b/Sources/_StringProcessing/Engine/MEBuilder.swift
@@ -9,7 +9,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-extension Program where Input.Element: Hashable {
+import _MatchingEngine // For errors
+
+extension MEProgram where Input.Element: Hashable {
   public struct Builder {
     var instructions: [Instruction] = []
 
@@ -36,7 +38,7 @@ extension Program where Input.Element: Hashable {
   }
 }
 
-extension Program.Builder {
+extension MEProgram.Builder {
   struct AddressFixup {
     var first: AddressToken
     var second: AddressToken? = nil
@@ -49,7 +51,7 @@ extension Program.Builder {
   }
 }
 
-extension Program.Builder {
+extension MEProgram.Builder {
   // TODO: We want a better strategy for fixups, leaving
   // the operand in a differenet form isn't great...
 
@@ -179,14 +181,14 @@ extension Program.Builder {
   }
 
   public mutating func buildConsume(
-    by p: @escaping Program.ConsumeFunction
+    by p: @escaping MEProgram.ConsumeFunction
   ) {
     instructions.append(.init(
       .consumeBy, .init(consumer: makeConsumeFunction(p))))
   }
 
   public mutating func buildAssert(
-    by p: @escaping Program.AssertionFunction
+    by p: @escaping MEProgram.AssertionFunction
   ) {
     instructions.append(.init(
       .assertBy, .init(assertion: makeAssertionFunction(p))))
@@ -230,7 +232,7 @@ extension Program.Builder {
 
   // TODO: Mutating because of fail address fixup, drop when
   // that's removed
-  public mutating func assemble() throws -> Program {
+  public mutating func assemble() throws -> MEProgram {
     // TODO: This will add a fail instruction at the end every
     // time it's assembled. Better to do to the local instruction
     // list copy, but that complicates logic. It's possible we
@@ -275,7 +277,7 @@ extension Program.Builder {
         inst.opcode, payload)
     }
 
-    var regInfo = Program.RegisterInfo()
+    var regInfo = MEProgram.RegisterInfo()
     regInfo.elements = elements.count
     regInfo.sequences = sequences.count
     regInfo.strings = strings.count
@@ -286,7 +288,7 @@ extension Program.Builder {
     regInfo.assertionFunctions = assertionFunctions.count
     regInfo.captures = nextCaptureRegister.rawValue
 
-    return Program(
+    return MEProgram(
       instructions: InstructionList(instructions),
       staticElements: elements.stored,
       staticSequences: sequences.stored,
@@ -300,7 +302,7 @@ extension Program.Builder {
 }
 
 // Address-agnostic interfaces for label-like support
-extension Program.Builder {
+extension MEProgram.Builder {
   public enum _AddressToken {}
   public typealias AddressToken = TypedInt<_AddressToken>
 
@@ -362,7 +364,7 @@ extension Program.Builder {
 }
 
 // Register helpers
-extension Program.Builder {
+extension MEProgram.Builder {
   public mutating func makeCapture() -> CaptureRegister {
     defer { nextCaptureRegister.rawValue += 1 }
     return nextCaptureRegister
@@ -420,13 +422,13 @@ extension Program.Builder {
   // registers without monotonicity required
 
   public mutating func makeConsumeFunction(
-    _ f: @escaping Program.ConsumeFunction
+    _ f: @escaping MEProgram.ConsumeFunction
   ) -> ConsumeFunctionRegister {
     defer { consumeFunctions.append(f) }
     return ConsumeFunctionRegister(consumeFunctions.count)
   }
   public mutating func makeAssertionFunction(
-    _ f: @escaping Program.AssertionFunction
+    _ f: @escaping MEProgram.AssertionFunction
   ) -> AssertionFunctionRegister {
     defer { assertionFunctions.append(f) }
     return AssertionFunctionRegister(assertionFunctions.count)
diff --git a/Sources/_MatchingEngine/Engine/Capture.swift b/Sources/_StringProcessing/Engine/MECapture.swift
similarity index 100%
rename from Sources/_MatchingEngine/Engine/Capture.swift
rename to Sources/_StringProcessing/Engine/MECapture.swift
diff --git a/Sources/_MatchingEngine/Engine/Program.swift b/Sources/_StringProcessing/Engine/MEProgram.swift
similarity index 92%
rename from Sources/_MatchingEngine/Engine/Program.swift
rename to Sources/_StringProcessing/Engine/MEProgram.swift
index 5737fd8ee..c45882b32 100644
--- a/Sources/_MatchingEngine/Engine/Program.swift
+++ b/Sources/_StringProcessing/Engine/MEProgram.swift
@@ -9,7 +9,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-public struct Program<Input: Collection> where Input.Element: Equatable {
+public struct MEProgram<Input: Collection> where Input.Element: Equatable {
   public typealias ConsumeFunction = (Input, Range<Input.Index>) -> Input.Index?
   public typealias AssertionFunction =
     (Input, Input.Index, Range<Input.Index>) -> Bool
@@ -26,7 +26,7 @@ public struct Program<Input: Collection> where Input.Element: Equatable {
   var enableTracing: Bool = false
 }
 
-extension Program: CustomStringConvertible {
+extension MEProgram: CustomStringConvertible {
   public var description: String {
     var result = """
     Elements: \(staticElements)
diff --git a/Sources/_MatchingEngine/Engine/Processor.swift b/Sources/_StringProcessing/Engine/Processor.swift
similarity index 98%
rename from Sources/_MatchingEngine/Engine/Processor.swift
rename to Sources/_StringProcessing/Engine/Processor.swift
index 7adcc9fa2..03217a518 100644
--- a/Sources/_MatchingEngine/Engine/Processor.swift
+++ b/Sources/_StringProcessing/Engine/Processor.swift
@@ -10,8 +10,8 @@
 //===----------------------------------------------------------------------===//
 
 public enum MatchMode {
-  case full
-  case `prefix`
+  case wholeString
+  case partialFromFront
 }
 
 /// A concrete CU. Somehow will run the concrete logic and
@@ -63,7 +63,7 @@ extension Processor {
 
 extension Processor {
   init(
-    program: Program<Input>,
+    program: MEProgram<Input>,
     input: Input,
     bounds: Range<Position>,
     matchMode: MatchMode,
@@ -182,12 +182,12 @@ extension Processor {
     switch (currentPosition, matchMode) {
     // When reaching the end of the match bounds or when we are only doing a
     // prefix match, transition to accept.
-    case (bounds.upperBound, _), (_, .prefix):
+    case (bounds.upperBound, _), (_, .partialFromFront):
       state = .accept
 
     // When we are doing a full match but did not reach the end of the match
     // bounds, backtrack if possible.
-    case (_, .full):
+    case (_, .wholeString):
       signalFailure()
     }
   }
diff --git a/Sources/_MatchingEngine/Engine/Registers.swift b/Sources/_StringProcessing/Engine/Registers.swift
similarity index 93%
rename from Sources/_MatchingEngine/Engine/Registers.swift
rename to Sources/_StringProcessing/Engine/Registers.swift
index 1c6096674..d3834b1f0 100644
--- a/Sources/_MatchingEngine/Engine/Registers.swift
+++ b/Sources/_StringProcessing/Engine/Registers.swift
@@ -24,10 +24,10 @@ extension Processor {
     var bools: [Bool] // TODO: bitset
 
     // currently, these are static readonly
-    var consumeFunctions: [Program<Input>.ConsumeFunction]
+    var consumeFunctions: [MEProgram<Input>.ConsumeFunction]
 
     // currently, these are static readonly
-    var assertionFunctions: [Program<Input>.AssertionFunction]
+    var assertionFunctions: [MEProgram<Input>.AssertionFunction]
 
     // currently, these are for comments and abort messages
     var strings: [String]
@@ -74,10 +74,10 @@ extension Processor {
     subscript(_ i: ElementRegister) -> Element {
       elements[i.rawValue]
     }
-    subscript(_ i: ConsumeFunctionRegister) -> Program<Input>.ConsumeFunction {
+    subscript(_ i: ConsumeFunctionRegister) -> MEProgram<Input>.ConsumeFunction {
       consumeFunctions[i.rawValue]
     }
-    subscript(_ i: AssertionFunctionRegister) -> Program<Input>.AssertionFunction {
+    subscript(_ i: AssertionFunctionRegister) -> MEProgram<Input>.AssertionFunction {
       assertionFunctions[i.rawValue]
     }
   }
@@ -85,7 +85,7 @@ extension Processor {
 
 extension Processor.Registers {
   init(
-    _ program: Program<Input>,
+    _ program: MEProgram<Input>,
     _ sentinel: Input.Index
   ) {
     let info = program.registerInfo
@@ -123,7 +123,7 @@ extension Processor.Registers {
   }
 }
 
-extension Program {
+extension MEProgram {
   struct RegisterInfo {
     var elements = 0
     var sequences = 0
diff --git a/Sources/_StringProcessing/Engine/StringProcessor.swift b/Sources/_StringProcessing/Engine/StringProcessor.swift
new file mode 100644
index 000000000..75ef97cec
--- /dev/null
+++ b/Sources/_StringProcessing/Engine/StringProcessor.swift
@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2021-2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+//
+//===----------------------------------------------------------------------===//
+
+typealias Program = MEProgram<String>
+
+public struct MatchResult {
+  public var range: Range<String.Index>
+  var captures: Capture
+
+  var destructure: (
+    matched: Range<String.Index>, captures: Capture
+  ) {
+    (range, captures)
+  }
+
+  init(
+    _ matched: Range<String.Index>, _ captures: Capture
+  ) {
+    self.range = matched
+    self.captures = captures
+  }
+}
diff --git a/Sources/_MatchingEngine/Engine/Tracing.swift b/Sources/_StringProcessing/Engine/Tracing.swift
similarity index 100%
rename from Sources/_MatchingEngine/Engine/Tracing.swift
rename to Sources/_StringProcessing/Engine/Tracing.swift
diff --git a/Sources/_StringProcessing/Executor.swift b/Sources/_StringProcessing/Executor.swift
index a3c591df6..70fbb41d2 100644
--- a/Sources/_StringProcessing/Executor.swift
+++ b/Sources/_StringProcessing/Executor.swift
@@ -15,8 +15,8 @@ public struct Executor {
   // TODO: consider let, for now lets us toggle tracing
   var engine: Engine<String>
 
-  init(program: RegexProgram, enablesTracing: Bool = false) {
-    self.engine = Engine(program.program, enableTracing: enablesTracing)
+  init(program: Program, enablesTracing: Bool = false) {
+    self.engine = Engine(program, enableTracing: enablesTracing)
   }
 
   public func execute(
@@ -25,7 +25,7 @@ public struct Executor {
     mode: MatchMode = .wholeString
   ) -> MatchResult? {
     engine.consume(
-      input, in: range, matchMode: mode.loweredMatchMode
+      input, in: range, matchMode: mode
     ).map { endIndex, capture in
       _ = capture // TODO: construct structure
       return MatchResult(range.lowerBound..<endIndex, .void)
@@ -47,7 +47,7 @@ public struct Executor {
     mode: MatchMode = .wholeString
   ) -> (Range<String.Index>, CaptureList)? {
     engine.consume(
-      input, in: range, matchMode: mode.loweredMatchMode
+      input, in: range, matchMode: mode
     ).map { endIndex, capture in
       (range.lowerBound..<endIndex, capture)
     }
@@ -59,18 +59,7 @@ public struct Executor {
 extension Executor: VirtualMachine {
   static let motto = "Executor"
 
-  init(program: RegexProgram) {
+  init(program: Program) {
     self.init(program: program, enablesTracing: false)
   }
 }
-
-extension _StringProcessing.MatchMode {
-  var loweredMatchMode: _MatchingEngine.MatchMode {
-    switch self {
-    case .wholeString:
-      return .full
-    case .partialFromFront:
-      return .prefix
-    }
-  }
-}
diff --git a/Sources/_StringProcessing/Legacy/VirtualMachine.swift b/Sources/_StringProcessing/Legacy/VirtualMachine.swift
index ab0d98bd8..7021356ae 100644
--- a/Sources/_StringProcessing/Legacy/VirtualMachine.swift
+++ b/Sources/_StringProcessing/Legacy/VirtualMachine.swift
@@ -11,29 +11,6 @@
 
 import _MatchingEngine
 
-public enum MatchMode {
-  case wholeString
-  case partialFromFront
-}
-
-public struct MatchResult {
-  public var range: Range<String.Index>
-  var captures: Capture
-
-  var destructure: (
-    matched: Range<String.Index>, captures: Capture
-  ) {
-    (range, captures)
-  }
-
-  init(
-    _ matched: Range<String.Index>, _ captures: Capture
-  ) {
-    self.range = matched
-    self.captures = captures
-  }
-}
-
 protocol VirtualMachine {
   associatedtype Program
 
diff --git a/Sources/_MatchingEngine/Utility/Protocols.swift b/Sources/_StringProcessing/Utility/Protocols.swift
similarity index 100%
rename from Sources/_MatchingEngine/Utility/Protocols.swift
rename to Sources/_StringProcessing/Utility/Protocols.swift
diff --git a/Sources/_MatchingEngine/Utility/Formatting.swift b/Sources/_StringProcessing/Utility/Traced.swift
similarity index 100%
rename from Sources/_MatchingEngine/Utility/Formatting.swift
rename to Sources/_StringProcessing/Utility/Traced.swift
diff --git a/Sources/_MatchingEngine/Utility/TypedIndex.swift b/Sources/_StringProcessing/Utility/TypedIndex.swift
similarity index 100%
rename from Sources/_MatchingEngine/Utility/TypedIndex.swift
rename to Sources/_StringProcessing/Utility/TypedIndex.swift
diff --git a/Sources/_MatchingEngine/Utility/TypedInt.swift b/Sources/_StringProcessing/Utility/TypedInt.swift
similarity index 100%
rename from Sources/_MatchingEngine/Utility/TypedInt.swift
rename to Sources/_StringProcessing/Utility/TypedInt.swift
diff --git a/Tests/MatchingEngineTests/MatchingEngineTests.swift b/Tests/MatchingEngineTests/MatchingEngineTests.swift
index aac65733d..b7c89661d 100644
--- a/Tests/MatchingEngineTests/MatchingEngineTests.swift
+++ b/Tests/MatchingEngineTests/MatchingEngineTests.swift
@@ -11,7 +11,7 @@
 
 import XCTest
 
-@testable import _MatchingEngine
+@testable import _StringProcessing
 
 /// Hold context and run variety of ad-hoc tests
 ///
@@ -140,9 +140,9 @@ func show(_ s: CustomStringConvertible) {
 }
 
 func makeEngine(
-  _ constructor: (inout Program<String>.Builder) -> ()
+  _ constructor: (inout Program.Builder) -> ()
 ) -> Engine<String> {
-  var builder = Program<String>.Builder()
+  var builder = Program.Builder()
   constructor(&builder)
   let program = try! builder.assemble()
   let engine = Engine<String>(program)