plumb 0.0.18 → 0.2.0.beta.2

data/lib/plumb/type_cache.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Plumb
+  # Process-level memoization for computed type graphs (resolved input/output
+  # and accepted types — see Plumb::Subtyping). Keyed by type identity in
+  # WeakKeyMaps, so entries are pruned by GC together with their types. Only
+  # frozen types are cached: a mutable type (an unfrozen Pipeline, a Deferred)
+  # may change its answer over time, so it always recomputes.
+  module TypeCache
+    MAPS = {
+      resolved_input: ObjectSpace::WeakKeyMap.new,
+      resolved_output: ObjectSpace::WeakKeyMap.new,
+      accepted_type: ObjectSpace::WeakKeyMap.new,
+      value_preserving: ObjectSpace::WeakKeyMap.new
+    }.freeze
+
+    LOCK = Mutex.new
+
+    # Sentinel distinguishing "no entry" from a cached `false`/`nil` — WeakKeyMap#[]
+    # returns nil for both, so a truthiness check would never cache a falsy value
+    # (e.g. #value_preserving? is a boolean, false for every transform/container).
+    ABSENT = Object.new.freeze
+    private_constant :ABSENT
+
+    # Presence-based so cached `false`/`nil` are returned as hits, not recomputed.
+    #
+    # NOTE: compute OUTSIDE the lock — computations recurse back into #fetch
+    # (And/Or children, resolved_* chains) and a non-reentrant Mutex would
+    # deadlock. A race may compute the same pure value twice; the first write wins.
+    def self.fetch(slot, key)
+      return yield unless key.frozen?
+
+      map = MAPS.fetch(slot)
+      cached = LOCK.synchronize { map.key?(key) ? map[key] : ABSENT }
+      return cached unless cached.equal?(ABSENT)
+
+      value = yield
+      LOCK.synchronize { map.key?(key) ? map[key] : (map[key] = value) }
+    end
+  end
+end

data/lib/plumb/type_registry.rb

@@ -1,7 +1,67 @@
 # frozen_string_literal: true
 
 module Plumb
+  # Mix-in that turns a module into a namespace of named Plumb types: every
+  # {Composable} assigned to one of its constants is named after that constant,
+  # so it inspects under the module's path rather than as an anonymous type.
+  #
+  # There are two ways to attach it, and they cover different lifecycles:
+  #
+  # ## `extend TypeRegistry` — name a module's own constants
+  #
+  # Extend a module to make it a type registry. From that point, {#const_added}
+  # fires for each constant assigned on it and names the type in place. Nested
+  # modules are extended automatically, so naming continues down the tree.
+  #
+  # @example Defining your own registry
+  #   module MyTypes
+  #     extend Plumb::TypeRegistry
+  #
+  #     # `String | Integer` builds an anonymous Or; assigning it names it.
+  #     Name  = Plumb::Types::String.present
+  #     Score = Plumb::Types::Integer[0..100]
+  #   end
+  #
+  #   MyTypes::Name.inspect  # => "MyTypes::Name"
+  #   MyTypes::Score.inspect # => "MyTypes::Score"
+  #
+  # ## `include <a registry>` — re-home its types into your namespace
+  #
+  # Including a module that is already a registry triggers {#included}, which
+  # extends the host (so its future constants are named too) and copies the
+  # source's predefined types into the host under the host's own namespace.
+  # Composable types are `dup`ed so the shared originals are left untouched;
+  # nested namespace modules are rebuilt recursively.
+  #
+  # @example Inheriting an existing registry's types
+  #   module MyTypes
+  #     include Plumb::Types   # Plumb::Types is itself a registry (see below)
+  #
+  #     # `String`/`Integer` now resolve to MyTypes' own copies.
+  #     Foo = String | Integer
+  #   end
+  #
+  #   MyTypes::String.inspect # => "MyTypes::String" (a copy, host-namespaced)
+  #   MyTypes::Foo.inspect    # => "MyTypes::Foo"
+  #
+  # {Plumb::Types} is the canonical registry: it does `extend TypeRegistry` so
+  # all its built-in types (`String`, `Integer`, `Lax::*`, …) are named, and
+  # so `include Plumb::Types` re-homes them into your own module.
+  #
+  # @note {#const_added} names the assigned instance *in place*. Assigning a
+  #   type that composes/derives another (e.g. `Types::Integer[18..]`,
+  #   `Types::String.present`) builds a fresh instance, so only the new
+  #   constant is named. Aliasing an existing type directly
+  #   (`Age = Types::Integer`) assigns the same shared instance and renames
+  #   the original — assign a derived copy if you want an independent name.
   module TypeRegistry
+    # `Module#const_added` hook (Ruby >= 3.2). Fires whenever a constant is
+    # assigned on a host extended with this module. Names the assigned type
+    # instance after the constant, and extends nested modules so the naming
+    # continues down the tree.
+    #
+    # @param const_name [Symbol] the name of the just-assigned constant
+    # @return [void]
     def const_added(const_name)
       obj = const_get(const_name)
       case obj
@@ -13,6 +73,17 @@ module Plumb
       end
     end
 
+    # `Module#included` hook. Fires when a module carrying this registry (e.g.
+    # {Plumb::Types}) is included into a host. Copies every predefined type
+    # from the source into the host under the host's namespace, and extends the
+    # host so that constants assigned afterwards are named via {#const_added}.
+    #
+    # Composable types are `dup`ed before renaming so the shared originals are
+    # left untouched; nested namespace modules are rebuilt so their own
+    # constants are recursively re-homed under the host.
+    #
+    # @param host [Module] the module or class including the source
+    # @return [void]
     def included(host)
       host.extend TypeRegistry
       constants(false).each do |const_name|

data/lib/plumb/typed_step.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Plumb
+  # A TYPED STEP declares an #input_type, an #output_type and a `Result => Result`
+  # core, and its #call runs that core between the two checks.
+  #
+  # Two implementations exist, differing only in WHO OWNS THE STORAGE:
+  #
+  #   - {Plumb::Function} — Plumb owns the object, so the declared pair and the
+  #     callable are ivars behind plain readers.
+  #   - {Plumb::Implementation::TypeInterface} — the HOST owns its object and its
+  #     constructor, so the pair comes from the declaration and the core is reached
+  #     through the host's private #_call.
+  #
+  # This module holds only what follows from the DECLARATION, and is therefore
+  # identical either way. Anything that depends on the storage (#call, #children,
+  # #fn, #identity, #==) stays with each implementation, as does #standard_call?.
+  #
+  # Include AFTER Composable, whose #subtype_identity / #accepted_type defaults
+  # these replace.
+  module TypedStep
+    # Declaring no types at all: both ends are Any (top), so neither check can fail
+    # and neither is worth dropping. A statement about the declared types only — a node
+    # that WRAPS a caller's callable says so through Function#wraps_callable?, since a
+    # wrapper that has absorbed a neighbouring type into a slot is not opaque.
+    def opaque? = input_type == Types::Any && output_type == Types::Any
+
+    # A conversion is identified for subtyping by what it PRODUCES — the input
+    # constraints do not carry through to the output.
+    # @see Plumb::Subtyping.subtype?
+    def subtype_identity = output_type
+
+    # As a `left >> self` consumer, a step accepts what its INPUT type accepts —
+    # not the input node verbatim. When that input is a Hash/container whose fields
+    # are themselves converting (eg. a codec's decode schema, whose `flags` field is
+    # a `String -> Integer` step), the accepted type is the input relaxed per field
+    # to the type it consumes. This is what lets an encode pipeline compose with the
+    # matching decode pipeline (`encode >> decode`): both meet at the same input
+    # type. Mirrors HashClass#accepted_type.
+    def accepted_type = Plumb::Subtyping.accepted_type(input_type)
+
+    # Does #call end by validating against #output_type? True for the plain
+    # `input -> fn -> output` mapping; false only where that check is provably
+    # redundant (see GuaranteedFunction). This is what tells Function#fuse_with
+    # whether a seam has an output check to drop, and whether the node it builds
+    # needs to keep one — replacing two `is_a?(GuaranteedFunction)` tests, which
+    # gave a non-Function step the right answer only by default.
+    #
+    # Defaults to true, the fail-safe direction: a wrong `true` keeps a redundant
+    # check (slower, still correct), a wrong `false` drops a necessary one.
+    def checks_output? = true
+
+    # Can Function#fuse_with drop this node's boundary checks? Only when #call is
+    # the canonical mapping for its kind — a node that replaced #call runs
+    # different checks, and nothing can be assumed about which of them a seam
+    # removes. Excluded when OPAQUE too: the only checks dropped would be no-ops,
+    # so there is nothing to win.
+    def fusable_step? = !opaque? && standard_call?
+
+    # Is #call still the canonical mapping described above? Only the node can
+    # answer, and each implementation answers against its own.
+    # @return [Boolean]
+    def standard_call?
+      raise NotImplementedError, "#{self.class} must define #standard_call?"
+    end
+  end
+end

data/lib/plumb/types.rb

@@ -19,11 +19,20 @@ module Plumb
   end
 
   # Generic options policy for all other types.
+  # An Array argument is treated as an enumeration of allowed values.
+  # Any other argument (Range, Regexp, Class, etc.) is delegated to a Match
+  # constraint, ie `type[opts]`, so it composes with the rest of the library
+  # (eg. a Range serializes to JSON Schema as `minimum`/`maximum`).
   # Usage:
   #   type = Types::String.options(['a', 'b'])
+  #   type = Types::Integer.options(10..20)
   policy :options do |type, opts|
-    type.check("must be included in #{opts.inspect}") do |v|
-      opts.include?(v)
+    if opts.is_a?(::Array)
+      type.check("must be included in #{opts.inspect}") do |v|
+        opts.include?(v)
+      end
+    else
+      type[opts]
     end
   end
 
@@ -87,9 +96,16 @@ module Plumb
   # Works with a block too:
   #   date = Type::Any[Date].default { Date.today }
   #
+  # A generated default declares, and is checked against, `type`'s OUTPUT — not `type`
+  # itself, which would re-run a conversion on a value the block already produced
+  # (`Types::String.transform(::Integer).default { 10 }` generates the Integer).
+  # Declaring it also tells the rest of the library what fills this position: without
+  # it the branch resolves to `Any`, and a Codec has nothing to encode.
   policy :default, helper: true do |type, value = Undefined, &block|
     val_type = if value == Undefined
-                 Step.new(->(result) { result.valid(block.call) }, 'default proc')
+                 fn = ->(result) { result.valid(block.call) }
+                 Function.new(Types::Any, Plumb::Subtyping.resolved_output(type), fn,
+                              inspect: 'default proc', identity: [:default, block])
                else
                  Types::Static[value]
                end
@@ -101,12 +117,20 @@ module Plumb
   # Expect a specific exception class, and return an invalid result if it is raised.
   # Usage:
   #   type = Types::String.build(Date, :parse).policy(:rescue, Date::Error)
+  #
+  # The guard returns what `type` returned, so it declares `type`'s OUTPUT — opaque,
+  # it would erase the type it wraps (the closure is invisible) and resolve to `Any`.
+  # Unchecked: `type` already validated what it produced. The INPUT stays `Any`, or
+  # `type`'s own input check runs a second time, outside the rescue.
   policy :rescue do |type, exception_class|
-    Step.new(nil, 'Rescue') do |result|
+    fn = lambda do |result|
       type.call(result)
     rescue exception_class => e
       result.invalid(errors: e.message)
     end
+
+    GuaranteedFunction.new(Types::Any, Plumb::Subtyping.resolved_output(type), fn,
+                           inspect: 'Rescue', identity: [:rescue, type, exception_class])
   end
 
   # Split a string into an array. Default separator is /\s*,\s*/
@@ -133,11 +157,13 @@ module Plumb
     extend TypeRegistry
 
     Any = AnyClass.new
+    Never = NeverClass.new
     Undefined = Any.value(Plumb::Undefined)
     String = Any[::String]
     Symbol = Any[::Symbol]
     Numeric = Any[::Numeric]
     Integer = Any[::Integer]
+    Float = Any[::Float]
     Decimal = Any[BigDecimal]
     Static = StaticClass.new
     Value = ValueClass.new
@@ -149,11 +175,16 @@ module Plumb
     Stream = StreamClass.new
     Tuple = TupleClass.new
     Hash = HashClass.new
+    Range = RangeClass.new
     Not = Plumb::Not.new
     Interface = InterfaceClass.new
     Email = String[URI::MailTo::EMAIL_REGEXP].as_node(:email)
     Date = Any[::Date]
     Time = Any[::Time]
+    # What a lenient container accepts (a Stream, a `.filtered` Array/Hash/HashMap).
+    # Here, not beside those classes, because Types is loaded after all of them.
+    Each = Interface[:each]
+    EachPair = Interface[:each_pair]
 
     # A type that recursively converts string keys to symbols in nested hashes.
     # This is commonly used for normalizing payload data in commands and events.
@@ -166,7 +197,7 @@ module Plumb
     #   SymbolizedHash.parse({ 'count' => 1, 'active' => true })  # => { count: 1, active: true }
     SymbolizedHash = Hash[
       # String keys are converted to symbols, existing symbols are preserved
-      (Symbol | String.transform(::Symbol, &:to_sym)),
+      (Symbol | String.transform(::Symbol, :to_sym)),
       # Hash values are recursively symbolized, other types pass through unchanged
       Any.defer { SymbolizedHash } | Any
     ]
@@ -191,54 +222,24 @@ module Plumb
 
       String = Types::String \
         | Types::Decimal.transform(::String) { |v| v.to_s('F') } \
-        | Types::Numeric.transform(::String, &:to_s)
+        | Types::Numeric.transform(::String, :to_s)
 
-      Symbol = Types::Symbol | Types::String.transform(::Symbol, &:to_sym)
+      Symbol = Types::Symbol | Types::String.transform(::Symbol, :to_sym)
 
       NumberString = Types::String.match(NUMBER_EXPR)
       CoercibleNumberString = NumberString.transform(::String) { |v| v.tr(',', '') }
 
-      Numeric = Types::Numeric | CoercibleNumberString.transform(::Numeric, &:to_f)
+      Numeric = Types::Numeric | CoercibleNumberString.transform(::Numeric, :to_f)
 
       Decimal = Types::Decimal | \
-                (Types::Numeric.transform(::String, &:to_s) | CoercibleNumberString) \
+                (Types::Numeric.transform(::String, :to_s) | CoercibleNumberString) \
                 .transform(::BigDecimal) { |v| BigDecimal(v) }
 
-      Integer = Numeric.transform(::Integer, &:to_i)
+      Integer = Numeric.transform(::Integer, :to_i)
     end
 
-    module Forms
-      True = Types::True \
-        | (
-          Types::String[/^true$/i] \
-          | Types::String['1'] \
-          | Types::Integer[1]
-        ).transform(::TrueClass) { |_| true }
-
-      False = Types::False \
-        | (
-          Types::String[/^false$/i] \
-          | Types::String['0'] \
-          | Types::Integer[0]
-        ).transform(::FalseClass) { |_| false }
-
-      Boolean = True | False
-
-      Nil = Nil | (String[BLANK_STRING] >> nil)
-
-      # Accept a Date, or a string that can be parsed into a Date
-      # via Date.parse
-      Date = Date | (String >> Any.build(::Date, :parse).policy(:rescue, ::Date::Error))
-      Time = Time | (String >> Any.build(::Time, :parse).policy(:rescue, ::ArgumentError))
-
-      # Turn strings into different URI types
-      module URI
-        # URI.parse is very permisive - a blank string is valid.
-        # We want to ensure that a generic URI at least starts with a scheme as per RFC 3986
-        Generic = Types::URI::Generic | (String[/^([a-z][a-z0-9+\-.]*)/].build(::URI, :parse))
-        HTTP = Generic[::URI::HTTP]
-        File = Generic[::URI::File]
-      end
-    end
+    # NOTE: the one-way Types::Forms coercions were replaced by the two-way
+    # Plumb::Codec::Forms — apply it to a schema written in output types
+    # (`Codec::Forms >> schema`), or use its encoders per-field.
   end
 end

data/lib/plumb/union.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'plumb/composable'
+require 'plumb/disjunction'
+
+module Plumb
+  # THE LATTICE JOIN — the least upper bound of two types, dual to
+  # {Plumb::Intersection}. Built by `#|` when every branch returns its value
+  # untouched, so the node describes exactly "a value in either set" and is its own
+  # output type. That is the difference from {Plumb::Or}, whose ends differ.
+  class Union
+    include Composable
+    include Disjunction
+
+    # No lazy rebuild, no identity guard, no allocation — the mapping Or needs exists
+    # only because a converting branch makes its ends differ.
+    #
+    # NOT symmetric with #input_type, which is inherited from Disjunction: a branch may
+    # accept more than it describes, so the input side still has to map.
+    def output_type = self
+
+    # An invariant of the node: Disjunction.build only produces a Union when every
+    # branch preserves the value. @see Intersection#value_preserving?
+    def value_preserving? = true
+
+    # node_name comes from Naming (:union, derived from the class). The JSON
+    # Schema visitor handles it separately from :or — a union is a plain anyOf,
+    # with none of the default-value handling a choice needs.
+  end
+end

data/lib/plumb/value_class.rb

@@ -3,6 +3,16 @@
 require 'plumb/composable'
 
 module Plumb
+  # A single literal value, matched by `==`.
+  #
+  # Unlike the other bare matchers — a Constraint with no base, an
+  # AttributeValueMatch — this does NOT report `Types::Any` as its #input_type.
+  # Those opt out of #>>'s subtype check because they narrow arbitrary input and
+  # have no declared domain to check against; a literal's domain is a known
+  # singleton, so it keeps the default (`self`) and accepts only its own value.
+  # That is what makes `Value['a'] >> Value['b']` raise rather than build a chain
+  # no value can satisfy. Narrowing a wider type down to a literal is spelled
+  # `#[]` (`Types::String['a']`), which builds the refinement directly.
   class ValueClass
     include Composable
 
@@ -10,14 +20,23 @@ module Plumb
 
     def initialize(value = Undefined)
       @value = value
+      # Pre-build the failure message once (the object is frozen and @value is
+      # fixed), so a miss on the hot path — eg. every non-matching branch of a
+      # `Value[a] | Value[b]` enum union — doesn't allocate a fresh String.
+      # Frozen because it's shared across every failing call (and across threads
+      # under Types::Array#concurrent) and only ever read, never mutated.
+      @error = "Must be equal to #{value}".freeze
       @children = [value].freeze
       freeze
     end
 
     def [](value) = self.class.new(value)
 
+    # Matches a specific value and passes it through unchanged.
+    def value_preserving? = true
+
     def call(result)
-      @value == result.value ? result : result.invalid(errors: "Must be equal to #{@value}")
+      @value == result.value ? result : result.invalid!(errors: @error)
     end
 
     private

data/lib/plumb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Plumb
-  VERSION = '0.0.18'
+  VERSION = '0.2.0.beta.2'
 end

data/lib/plumb/visitor_handlers.rb

@@ -2,6 +2,17 @@
 
 module Plumb
   module VisitorHandlers
+    # Node names introduced by the type/computation split, each mapped to the name
+    # the node was reported under before it existed. `Plumb::Intersection` used to
+    # be an `And` and `Plumb::Union` used to be an `Or`, so a visitor written
+    # against the old AST defines only `on(:and)` / `on(:or)` — without this it
+    # would raise "no handler" on a type it used to understand.
+    #
+    # Consulted ONLY when the specific handler is absent, so a visitor that does
+    # distinguish the two (see JSONSchemaVisitor) keeps full control. Plumb's own
+    # visitors register both names explicitly; this is for visitors outside the gem.
+    NODE_NAME_FALLBACKS = { intersection: :and, union: :or }.freeze
+
     def self.included(base)
       base.extend(ClassMethods)
     end
@@ -28,11 +39,16 @@ module Plumb
     end
 
     def visit_name(method_name, node, props = BLANK_HASH)
-      method_name = :"visit_#{method_name}"
-      if respond_to?(method_name)
-        send(method_name, node, props)
+      target = :"visit_#{method_name}"
+
+      if !respond_to?(target) && (fallback = NODE_NAME_FALLBACKS[method_name])
+        target = :"visit_#{fallback}"
+      end
+
+      if respond_to?(target)
+        send(target, node, props)
       else
-        on_missing_handler(node, props, method_name)
+        on_missing_handler(node, props, target)
       end
     end
 

data/lib/plumb.rb

@@ -57,27 +57,114 @@ module Plumb
   def self.decorate(type, &block)
     Decorator.call(type, &block)
   end
+
+  # Recursively resolve the underlying Ruby classes ("base types") of a node.
+  #   Types::String             => [String]
+  #   Types::String | Integer   => [String, Integer]
+  #
+  # This is a temporary helper to preserve type-specific policy resolution
+  # (see Composable#policy) until proper subtyping checks are implemented.
+  # Returns the value's matching domain, widened to Numeric because numeric
+  # equality crosses concrete classes (`5 == 5.0`).
+  # Keeping a concrete numeric class would falsely make compatible literal and
+  # numeric types appear disjoint and reduce their intersection to Never.
+  # @param value [Object]
+  # @return [Class]
+  def self.value_base_class(value) = SemanticMatcher.value_domain(value)
+
+  def self.resolve_base_types(node)
+    return [node] if node.is_a?(::Class)
+    return [] unless node.respond_to?(:node_name)
+
+    # A transparent wrapper (Policy / Metadata / #as_node Node) only RE-LABELS the type
+    # it wraps, so it has the same base types. Peeled here rather than per branch: a
+    # Node's node_name is whatever #as_node was given, so it cannot be a `when` at all,
+    # and every #as_node type would report NO base types — which callers read as
+    # "unknown base, allow", silently skipping build-time checks like
+    # `Types::Email[1..20]`.
+    unwrapped = Plumb::Subtyping.unwrap_transparent(node)
+    return resolve_base_types(unwrapped) unless unwrapped.equal?(node)
+
+    case node.node_name
+    when :or, :union
+      node.children.flat_map { |child| resolve_base_types(child) }
+    when :function
+      resolve_base_types(node.output_type)
+    when :intersection
+      # A meet narrows a single value, so its base types are its LEFT's —
+      # `String.where(size: 1..3)` is still a String.
+      resolve_base_types(node.children[0])
+    when :and
+      # Descend into whichever side carries the resulting type: a value-preserving right
+      # NARROWS what the left produces, a converting right REPLACES it.
+      #
+      # Deliberately NOT `node.output_type`, which encodes the same rule but is not
+      # guaranteed to be a smaller node — for `Array[<record with a coercing field>]
+      # .where(size: 1..)` it is a DIFFERENT And whose own output type is itself, so
+      # following it ping-pongs until the stack blows. A child always terminates.
+      left, right = node.children
+      resolve_base_types(Plumb::Subtyping.value_preserving?(right) ? left : right)
+    when :constraint
+      # A refinement matcher carries its base type — resolve that (eg.
+      # `Integer[1..10]` => [Integer], `User.check {}` => the User's base types).
+      return resolve_base_types(node.base) if node.base
+
+      SemanticMatcher.matcher_domain(node.children.first)
+    when :array, :tuple then [::Array]
+    when :hash, :hash_map, :tagged_hash, :filtered_hash, :filtered_hash_map then [::Hash]
+    when :stream then [::Enumerator]
+    when :range then [::Range]
+    when :not
+      # A complement has no finite base-class representation.
+      []
+    when :value
+      # Literals match by ==, including across numeric classes.
+      value = node.children.first
+      value.equal?(Undefined) ? [] : [value_base_class(value)]
+    when :static
+      value = node.children.first
+      [value.is_a?(::Class) ? value : value_base_class(value)]
+    else
+      node.respond_to?(:children) ? node.children.flat_map { |child| resolve_base_types(child) } : []
+    end
+  end
 end
 
 require 'plumb/result'
 require 'plumb/type_registry'
+require 'plumb/relation'
+require 'plumb/semantic_matcher'
 require 'plumb/composable'
+require 'plumb/typed_step'
+require 'plumb/node_mapper'
+require 'plumb/covariant_fusion'
 require 'plumb/any_class'
-require 'plumb/step'
+require 'plumb/never_class'
+require 'plumb/conjunction'
 require 'plumb/and'
+require 'plumb/intersection'
+require 'plumb/function'
+require 'plumb/encoder'
+require 'plumb/implementation'
 require 'plumb/pipeline'
 require 'plumb/static_class'
 require 'plumb/value_class'
-require 'plumb/match_class'
+require 'plumb/constraint'
 require 'plumb/not'
+require 'plumb/disjunction'
 require 'plumb/or'
+require 'plumb/union'
 require 'plumb/tuple_class'
 require 'plumb/array_class'
 require 'plumb/stream_class'
 require 'plumb/hash_class'
+require 'plumb/range_class'
 require 'plumb/interface_class'
 require 'plumb/attributes'
+require 'plumb/subtyping'
+require 'plumb/optimizer'
 require 'plumb/types'
+require 'plumb/codec'
 require 'plumb/json_schema_visitor'
-require 'plumb/schema'
+require 'plumb/mermaid_visitor'
 require 'plumb/decorator'