plumb 0.2.0.beta.1 → 0.2.0.beta.3

data/lib/plumb/array_class.rb

@@ -45,22 +45,17 @@ module Plumb
     def output_type = Plumb::Subtyping.map_children(self) { |c| Plumb::Subtyping.resolved_output(c) }
 
     def concurrent
-      ConcurrentArrayClass.new(element_type:)
+      concurrent_class.new(element_type:)
     end
 
     def stream
       StreamClass.new(element_type:)
     end
 
+    # A lenient version of this Array: it accepts any Array and emits one with only
+    # the valid elements, dropping the rest. @see FilteredArray
     def filtered
-      Constraint.new(::Array) >> Function.opaque(inspect: "Array[#{element_type}].filtered",
-                                                identity: [:filtered_array, element_type]) do |result|
-        arr = result.value.each.with_object([]) do |e, memo|
-          r = element_type.resolve(e)
-          memo << r.value if r.valid?
-        end
-        result.valid!(arr)
-      end
+      filtered_class.new(element_type:)
     end
 
     def call(result)
@@ -78,6 +73,12 @@ module Plumb
 
     attr_reader :element_type
 
+    # Named, not hardcoded, so the two combine in EITHER order: each subclass points
+    # at the variant that keeps what it already is, instead of the second call
+    # dropping the first.
+    def concurrent_class = ConcurrentArrayClass
+    def filtered_class = FilteredArray
+
     def _inspect
       %(Array[#{element_type}])
     end
@@ -136,6 +137,68 @@ module Plumb
 
         [values, errors]
       end
+
+      def filtered_class = ConcurrentFilteredArray
+    end
+
+    # Same element type as an ArrayClass, but drops invalid elements instead of
+    # rejecting the whole Array. Being an ArrayClass is what keeps it rewritable: a
+    # visitor — or a Codec — that maps the element type rebuilds a FilteredArray, not
+    # a plain one. @see HashMap::FilteredHashMap, the same arrangement for maps.
+    class FilteredArray < self
+      # It drops elements, so it changes the value whatever its element type does.
+      def value_preserving? = false
+
+      # Lenient: it never rejects an Array, so as a #>> consumer it accepts any
+      # enumerable — without this `Types::Array >> Array[String].filtered` is an
+      # illegal narrowing.
+      def accepted_type = Types::Each
+
+      # `Array[T].filtered.stream` IS `Array[T].stream.filtered` — a filtered Stream
+      # drops the same elements, lazily.
+      def stream = super.filtered
+
+      def call(result)
+        return result.invalid!(errors: 'is not an Array') unless ::Array === result.value
+
+        result.valid!(valid_elements(result.value))
+      end
+
+      private
+
+      def concurrent_class = ConcurrentFilteredArray
+
+      # The only thing the concurrent variant replaces. No errors to collect, unlike
+      # #map_array_elements — an invalid element is simply not there.
+      def valid_elements(array)
+        array.each.with_object([]) do |e, memo|
+          r = element_type.resolve(e)
+          memo << r.value if r.valid?
+        end
+      end
+
+      def _inspect = "Array[#{element_type}].filtered"
+    end
+
+    # Both at once, reached from either side (`.filtered.concurrent`,
+    # `.concurrent.filtered`), and itself under both.
+    class ConcurrentFilteredArray < FilteredArray
+      private
+
+      def filtered_class = ConcurrentFilteredArray
+
+      # A rejected future re-raises, as ConcurrentArrayClass does: an element step
+      # that RAISED is a bug to surface, not an element to drop.
+      def valid_elements(array)
+        futures = array.map { |e| Concurrent::Future.execute { element_type.resolve(e) } }
+
+        futures.each_with_object([]) do |future, memo|
+          r = future.value # blocks until settled; nil when rejected
+          raise future.reason if future.rejected?
+
+          memo << r.value if r.valid?
+        end
+      end
     end
   end
 end

data/lib/plumb/codec.rb

@@ -32,9 +32,8 @@ module Plumb
   # algebra, so parsing, subtyping and visitors work on it unchanged. It works
   # on any type, not just Hash schemas: `JSONCodec >> Types::Date` returns the
   # matched encoder's decode step.
+  #
   class Codec
-    include Composable
-
     class << self
       # Register one or more Encoder subclasses, in matching-priority order.
       # The registry is inheritable: subclassing a codec extends it, and a
@@ -46,7 +45,7 @@ module Plumb
             raise ArgumentError, "expected an Encoder subclass, got #{enc.inspect}"
           end
 
-          own_encoders << enc
+          encoders << enc
         end
         self
       end
@@ -56,154 +55,196 @@ module Plumb
       # nothing. Real encoders always match first, so a noop never shadows a
       # registered encoder for the same type.
       def noop(*types)
-        types.each { |t| own_noop_types << Composable.wrap(t) }
+        types.each { |t| noop_types << Composable.wrap(t) }
         self
       end
 
-      # All registered encoders, inherited first, own last (later registrations
-      # win ties in matching).
-      def encoders = inherited_registry(:encoders, own_encoders)
+      # A subclass starts from a COPY of its parent's registries and appends its own,
+      # so `encoders` reads inherited-first, own-last (later registrations win ties in
+      # matching). Copied at subclass time rather than resolved at read time because
+      # registration happens in a class body: a parent is complete before a subclass
+      # of it exists.
+      def inherited(subclass)
+        super
+        subclass.encoders = encoders.dup
+        subclass.noop_types = noop_types.dup
+      end
 
-      # All registered pass-through types, inherited first.
-      def noop_types = inherited_registry(:noop_types, own_noop_types)
+      def encoders = @encoders ||= []
+      def noop_types = @noop_types ||= []
 
-      # Class-level composition delegates to a memoized instance, so a Codec
-      # subclass composes directly: `JSONCodec >> Person`.
-      def instance = @instance ||= new
-      def >>(other) = instance >> other
-      def |(other) = instance | other
-      def &(other) = instance & other
-      def for(type) = instance.for(type)
-      def to_plumb_type(op:, left:) = instance.to_plumb_type(op:, left:)
-      def to_composable = instance
-      def call(result) = instance.call(result)
+      # Only #inherited seeds a registry; everything else registers through
+      # #encoder / #noop.
+      attr_writer :encoders, :noop_types
+      protected :encoders=, :noop_types=
 
-      private
+      # Decode direction: rewrite `other` so it accepts the encoders' input form
+      # and produces the output values `other` describes. The rewritten type
+      # REPLACES the composition — no codec node remains.
+      def >>(other)
+        Rewriter.new(self, :decode).call(Composable.wrap(other))
+      end
+
+      # Both directions for a type, as a [decoding, encoding] pair:
+      #
+      #   decoder, encoder = Plumb::Codec::JSON.for(Person)
+      #   decoder.parse(input_data) # => a Person hash
+      #   encoder.parse(person)     # => output structures
+      #
+      # @param type [Composable, Object]
+      # @return [Array(Composable, Composable)]
+      def for(type)
+        type = Composable.wrap(type)
+        [self >> type, type >> self]
+      end
+
+      # Encode direction, reached when the codec is the RIGHT operand
+      # (`Person >> JSONCodec` — see Composable.resolve_operand): build an encode
+      # rewrite of what `left` produces. Composable#>> then composes
+      # `And(left, rewrite)`: the left validates its input once, the
+      # rewrite encodes. Building from `left`'s OUTPUT (not `left` itself)
+      # avoids re-running its coercions on already-parsed values.
+      def to_plumb_type(op:, left:)
+        unless op == :>>
+          raise Plumb::TypeError, "#{inspect} only composes with #>> (got #{op}); a Codec is not a value type"
+        end
 
-      # A registry a subclass extends rather than replaces: whatever the
-      # ancestor exposes under `name`, plus this class's own registrations.
-      def inherited_registry(name, own)
-        inherited = superclass.respond_to?(name) ? superclass.public_send(name) : BLANK_ARRAY
-        inherited + own
+        left = Composable.wrap(left)
+        # A plain-include struct wraps as an opaque Step (output Any), so its
+        # rewrite target is the struct node itself, not its resolved output.
+        target = Plumb::Attributes.struct_class(left) ? left : Plumb::Subtyping.resolved_output(left)
+        Rewriter.new(self, :encode).call(target)
       end
 
-      def own_encoders = @own_encoders ||= []
-      def own_noop_types = @own_noop_types ||= []
-    end
+      def |(_other) = raise Plumb::TypeError, "#{inspect} only composes with #>>; a Codec is not a value type"
+      alias & |
 
-    attr_reader :encoders, :noop_types
+      # A Codec is not a value type, and has no node to stand in for one. Both of
+      # these say so at the point of the mistake — without #to_composable,
+      # Composable.wrap would see a `#call` and build an opaque step out of the class.
+      def to_composable = raise(Plumb::TypeError, "#{inspect} is not a type; compose it with a type via #>>")
 
-    # @param extra_encoders [Array<Class>] encoders for this instance, appended
-    #   after (and winning ties over) the class-level registry.
-    def initialize(*extra_encoders)
-      @encoders = self.class.encoders + extra_encoders
-      @noop_types = self.class.noop_types
-      @noop_union = @noop_types.reduce(:|)
-      freeze
-    end
+      def call(_result)
+        raise Plumb::TypeError, "#{inspect} is not a runtime type; compose it with a type via #>>"
+      end
 
-    # Decode direction: rewrite `other` so it accepts the encoders' input form
-    # and produces the output values `other` describes. The rewritten type
-    # REPLACES the composition — no codec node remains.
-    def >>(other)
-      Rewriter.new(self, :decode).call(Composable.wrap(other))
-    end
+      # The best matching encoder for `type`, or nil. Matching is against each
+      # encoder's output type — schemas are written in output
+      # terms in both directions. Most-specific wins; equivalent types
+      # tie-break to the last registered; incomparable multi-matches raise.
+      def encoder_for(type, path = BLANK_ARRAY)
+        matches = encoders.select { |e| Plumb::Subtyping.subtype?(type, e.output_type) }
+        return nil if matches.empty?
+        return matches.first if matches.size == 1
 
-    # Both directions for a type, as a [decoding, encoding] pair:
-    #
-    #   decoder, encoder = Plumb::Codec::JSON.for(Person)
-    #   decoder.parse(input_data) # => a Person hash
-    #   encoder.parse(person)     # => output structures
-    #
-    # @param type [Composable, Object]
-    # @return [Array(Composable, Composable)]
-    def for(type)
-      type = Composable.wrap(type)
-      [self >> type, type >> self]
-    end
+        minimal = matches.reject do |e|
+          # e is dominated when another match's output type is strictly narrower.
+          matches.any? do |o|
+            !o.equal?(e) && Plumb::Subtyping.strict_subtype?(o.output_type, e.output_type)
+          end
+        end
 
-    # Encode direction, reached when the codec is the RIGHT operand
-    # (`Person >> JSONCodec` — see Composable#to_plumb_type): build an encode
-    # rewrite of what `left` produces. Composable#>> then composes
-    # `And(left, rewrite)`: the left validates its input once, the
-    # rewrite encodes. Building from `left`'s OUTPUT (not `left` itself)
-    # avoids re-running its coercions on already-parsed values.
-    def to_plumb_type(op:, left:)
-      unless op == :>>
-        raise Plumb::TypeError, "#{inspect} only composes with #>> (got #{op}); a Codec is not a value type"
-      end
-
-      left = Composable.wrap(left)
-      # A plain-include struct wraps as an opaque Step (output Any), so its
-      # rewrite target is the struct node itself, not its resolved output.
-      target = Plumb::Attributes.struct_class(left) ? left : Plumb::Subtyping.resolved_output(left)
-      Rewriter.new(self, :encode).call(target)
-    end
+        first = minimal.first
+        unless minimal.all? { |e| Plumb::Subtyping.equivalent?(e.output_type, first.output_type) }
+          raise Plumb::TypeError,
+                "#{inspect}: #{at_path(path)} (#{type.inspect}) matches multiple incomparable encoders: " \
+                "#{minimal.map(&:inspect).join(', ')}. Register a more specific encoder or restructure."
+        end
 
-    def |(_other) = raise Plumb::TypeError, "#{inspect} only composes with #>>; a Codec is not a value type"
-    alias & |
+        minimal.last
+      end
 
-    def call(_result)
-      raise Plumb::TypeError, "#{inspect} is not a runtime type; compose it with a type via #>>"
-    end
+      # Is `type` (one side of it, per direction) covered by the registered noop
+      # types? Decode checks what the type ACCEPTS (it will be fed raw input
+      # data); encode checks what it PRODUCES (its output lands in the encoded
+      # document).
+      def noop?(type, direction)
+        return false unless noop_union
 
-    # The best matching encoder for `type`, or nil. Matching is against each
-    # encoder's output type — schemas are written in output
-    # terms in both directions. Most-specific wins; equivalent types
-    # tie-break to the last registered; incomparable multi-matches raise.
-    def encoder_for(type, path = BLANK_ARRAY)
-      matches = encoders.select { |e| Plumb::Subtyping.subtype?(type, e.output_type) }
-      return nil if matches.empty?
-      return matches.first if matches.size == 1
-
-      minimal = matches.reject do |e|
-        # e is dominated when another match's output type is strictly narrower.
-        matches.any? do |o|
-          !o.equal?(e) && Plumb::Subtyping.strict_subtype?(o.output_type, e.output_type)
-        end
+        side = direction == :decode ? Plumb::Subtyping.accepted_type(type) : Plumb::Subtyping.resolved_output(type)
+        # A pure filter with an opaque side is judged by the type itself: a
+        # bare-matcher Constraint (a branch of a factored refinement union, eg.
+        # the `String[/\Atrue\z/i] | String['1']` boolean input type) reports Any
+        # as its accepted type, but as a value-preserving refinement it IS its
+        # own honest description.
+        side = type if side.is_a?(AnyClass) && Plumb::Subtyping.value_preserving?(type)
+        Plumb::Subtyping.subtype?(side, noop_union)
       end
 
-      first = minimal.first
-      unless minimal.all? { |e| Plumb::Subtyping.equivalent?(e.output_type, first.output_type) }
-        raise Plumb::TypeError,
-              "#{inspect}: #{at_path(path)} (#{type.inspect}) matches multiple incomparable encoders: " \
-              "#{minimal.map(&:inspect).join(', ')}. Register a more specific encoder or restructure."
+      # Is this concrete VALUE covered by the noop types? Used for Static nodes,
+      # whose fixed value can be validated directly — subtyping over the node
+      # can't relate an atomic Static to a container noop (`Static[[]]` vs
+      # `Types::Array`), but the value itself can just be checked.
+      def noop_value?(value)
+        return false unless noop_union
+
+        noop_union === value
       end
 
-      minimal.last
+      def at_path(path) = path.empty? ? 'the root type' : "field `#{path.join('.')}`"
+
+      # Named, so an anonymous `Class.new(Codec)` still says what it carries.
+      def inspect = "#{name || superclass.name}[#{encoders.map(&:inspect).join(', ')}]"
+
+      private
+
+      # Derived from #noop_types, so resolved once — after boot, when the first
+      # composition asks.
+      def noop_union
+        return @noop_union if defined?(@noop_union)
+
+        @noop_union = noop_types.reduce(:|)
+      end
     end
 
-    # Is `type` (one side of it, per direction) covered by the registered noop
-    # types? Decode checks what the type ACCEPTS (it will be fed raw input
-    # data); encode checks what it PRODUCES (its output lands in the encoded
-    # document).
-    def noop?(type, direction)
-      return false unless @noop_union
-
-      side = direction == :decode ? Plumb::Subtyping.accepted_type(type) : Plumb::Subtyping.resolved_output(type)
-      # A pure filter with an opaque side is judged by the type itself: a
-      # bare-matcher Constraint (a branch of a factored refinement union, eg.
-      # the `String[/\Atrue\z/i] | String['1']` boolean input type) reports Any
-      # as its accepted type, but as a value-preserving refinement it IS its
-      # own honest description.
-      side = type if side.is_a?(AnyClass) && Plumb::Subtyping.value_preserving?(type)
-      Plumb::Subtyping.subtype?(side, @noop_union)
+    Entry = Data.define(:decoder, :encoder)
+    NoEntryError = Class.new(KeyError)
+
+    # An INSTANCE is a registry of composed [decoder, encoder] pairs, so the
+    # per-message path is just #parse. Keys are the app's own — a tag for
+    # self-describing payloads, or the type itself:
+    #
+    #   registry = Plumb::Codec::JSON.new do |c|
+    #     c.register('person.created', Person)  # tag -> type
+    #     c.register(Types::Date)               # key defaults to the type
+    #   end
+    #   registry.decode('person.created', payload)
+    #   registry.encode(Types::Date, Date.today)
+    #
+    # Built with a block it is FROZEN — a closed set, declared at boot. Built
+    # without one it stays open and composes type keys on first use, so an app
+    # need not enumerate them; #freeze seals it later.
+    def initialize(&)
+      @entries = {}
+      @lock = Mutex.new
+      return unless block_given?
+
+      yield self
+      freeze
     end
 
-    # Is this concrete VALUE covered by the noop types? Used for Static nodes,
-    # whose fixed value can be validated directly — subtyping over the node
-    # can't relate an atomic Static to a container noop (`Static[[]]` vs
-    # `Types::Array`), but the value itself can just be checked.
-    def noop_value?(value)
-      return false unless @noop_union
+    def freeze
+      @entries.freeze
+      super
+    end
 
-      @noop_union === value
+    # Named, not splatted: both sides are types that #parse, so a swapped pair would
+    # decode where it should encode without anything raising.
+    def register(key, type = key)
+      raise FrozenError, "#{inspect} is sealed; register before freezing it" if frozen?
+
+      entry = build_entry(type)
+      @lock.synchronize { @entries[key] = entry }
+      self
     end
 
-    def at_path(path) = path.empty? ? 'the root type' : "field `#{path.join('.')}`"
+    def key?(key) = !read(key).nil?
+
+    def decode(key, payload) = entry(key).decoder.parse(payload)
+    def encode(key, payload) = entry(key).encoder.parse(payload)
 
-    private def _inspect
-      "#{self.class == Codec ? 'Plumb::Codec' : self.class.name}[#{encoders.map(&:inspect).join(', ')}]"
+    def inspect
+      %(#<#{self.class}:#{object_id} [#{@entries.size} entries]>)
     end
 
     # The deep rewrite walker. Top-down, per node:
@@ -293,11 +334,16 @@ module Plumb
           return NodeMapper.map(type) { |t| visit(t, path) }
         end
 
+        # Before encoder matching, for the Static reason: a source IS a subtype of what
+        # it declares, so an encoder would replace the code that produces the value.
+        return visit_source(type, path) if source_step?(type)
+
         enc = encoder_for(type, path)
         return replace(type, enc, path) if enc
 
         case type
         when HashClass then visit_hash(type, path)
+        when FilteredHash then visit_filtered_hash(type, path)
         when ArrayClass, StreamClass then visit_array(type, path)
         when TupleClass then visit_tuple(type, path)
         when HashMap then visit_hash_map(type, path)
@@ -311,13 +357,37 @@ module Plumb
         end
       end
 
-      # A leaf: nothing to recurse into structurally. It survives when the
-      # format already carries it (the noop check), or — decoding — when the
+      # A leaf: nothing to recurse into structurally. It survives when it is OPAQUE,
+      # when the format already carries it (the noop check), or — decoding — when the
       # codec can bridge what it CONSUMES.
       def visit_leaf(type, path)
+        return type if opaque_step?(type)
+
         bridge_input(type, path) || noop_or_fail(type, path)
       end
 
+      # An OPAQUE step (`Any -> Any`) is a black box — a `#generate` generator, a bare
+      # proc in a schema. It names no type to rewrite, so it passes through, and what
+      # it emits lands unencoded, exactly as its `Any` output says.
+      def opaque_step?(type) = type.is_a?(Plumb::TypedStep) && type.opaque?
+
+      # A SOURCE step declares `Any -> T`: it produces a T out of whatever it is
+      # handed. The `#default { }` generator is one.
+      def source_step?(type)
+        type.is_a?(Plumb::TypedStep) && type.input_type.is_a?(AnyClass) && !type.output_type.is_a?(AnyClass)
+      end
+
+      # DECODE: leave it alone. Accepting `Any` it already accepts the encoded form,
+      # and it produces the decoded value itself (`Date.default { Date.today }` yields
+      # a Date, not a wire string).
+      #
+      # ENCODE: the rewrite is composed AFTER the type it encodes (see
+      # Codec#to_plumb_type), so the source has already run and the T it declared is
+      # what sits here. Rewriting the node would run the generator a second time.
+      def visit_source(type, path)
+        @direction == :decode ? type : visit(type.output_type, path)
+      end
+
       # DECODE: a converting leaf (a Function, a Plumb::Implementation — any node
       # whose accepted type is a distinct node) consumes values the encoded
       # document does not carry: `Hash[time: Time] -> Thing` wants a Time, a JSON
@@ -443,12 +513,10 @@ module Plumb
         # constant) still rewrite their input once.
         input = enc.input_type_for(type)
         rewritten_input = @input_memo.fetch(type) do
-          begin
-            @input_stack.push(enc)
-            @input_memo[type] = visit(input, path + ["<#{enc.inspect} input>"])
-          ensure
-            @input_stack.pop
-          end
+          @input_stack.push(enc)
+          @input_memo[type] = visit(input, path + ["<#{enc.inspect} input>"])
+        ensure
+          @input_stack.pop
         end
 
         # Splice the input into the step unless it is the encoder's declared
@@ -480,6 +548,21 @@ module Plumb
         end
       end
 
+      # DECODE rewrites the schema a filter FILTERS and rebuilds the filter around it,
+      # so decoding happens inside it, per field: #bridge_input's spliced step would
+      # decode the whole hash first, making one unreadable field fatal — what
+      # .filtered exists to avoid. (The filtered Array and HashMap need none of this;
+      # being containers they rewrite through #visit_array / #visit_hash_map.)
+      #
+      # ENCODE: `resolved_output` reduces the filter to its relaxed schema before the
+      # rewrite, so this is only reached defensively.
+      def visit_filtered_hash(type, path)
+        return visit(type.output_type, path) unless @direction == :decode
+
+        schema = visit(type.input_type, path)
+        schema.equal?(type.input_type) ? type : schema.filtered
+      end
+
       def visit_array(type, path)
         return noop_or_fail(type, path) if type.children.first.is_a?(AnyClass) # untyped — a leaf
 
@@ -507,11 +590,16 @@ module Plumb
         NodeMapper.map_children(type) { |variant| visit(variant, path) }
       end
 
+      # Rewriting can collapse two branches onto the SAME node — encoding a
+      # `#default { }`, both resolve to the type. Keep one: the second is unreachable,
+      # and a failing encode would otherwise report its errors twice.
       def visit_or(type, path)
         left, right = type.children
         l = visit(left, path)
         r = visit(right, path)
-        l.equal?(left) && r.equal?(right) ? type : Disjunction.build(l, r)
+        return type if l.equal?(left) && r.equal?(right)
+
+        l == r ? l : Disjunction.build(l, r)
       end
 
       # A MEET: a data-bearing type refined by pure filters (a #where's
@@ -560,27 +648,41 @@ module Plumb
       # Rewriting it too decodes twice: #bridge_input splices `b`'s own decode step in
       # front, the already-decoded value hits a step expecting the encoded form, and the
       # pipeline rejects everything. A step only counts as having consumed the wire if
-      # its rewrite actually CHANGED it.
+      # its rewrite actually CHANGED it — or if it is a black box, which says the same
+      # thing: what it hands on is unknown. `Types::Integer.generate { 1 }` is
+      # `(opaque >> Integer)`, and rewriting that Integer into the codec's
+      # `String -> Integer` step would feed it the generated Integer and reject
+      # everything.
       def visit_composition(type, path)
         left, right = type.children
         l = pure_refinement?(left) ? left : visit(left, path)
-        # `right` receives what `left` produced, so it faces the wire only when
-        # `left`'s rewrite left it unchanged.
-        wire_consumed = @direction == :decode && !l.equal?(left)
-        r = pure_refinement?(right) || wire_consumed ? right : visit(right, path)
+        r = pure_refinement?(right) || wire_consumed?(left, l) ? right : visit(right, path)
 
         l.equal?(left) && r.equal?(right) ? type : Conjunction.build(l, r)
       end
 
+      # Encoding, nothing consumes a wire: every step is rewritten in place.
+      def wire_consumed?(left, rewritten)
+        return false unless @direction == :decode
+
+        !rewritten.equal?(left) || opaque_step?(rewritten) || source_step?(rewritten)
+      end
+
       # A pure refinement carries no encodable type — it filters the adjacent
       # type's values. A baseless Constraint refining a sibling qualifies, but a
       # base-type Constraint — `Types::Date` IS `Constraint(::Date)` — is data an
       # encoder must see (eg. in `Types::Date.where(year: ...)` ==
       # `And(Constraint(::Date), AVM)`), and so is a baseless Module gate, which
       # names a type rather than filtering one.
+      #
+      # `Any` is the TRIVIAL filter, so it qualifies too — but only ALONGSIDE a sibling
+      # that carries a type; on its own it is still a leaf, and still an error. It gets
+      # here from an opaque step's output slot, which is what `resolved_output` leaves
+      # behind (`Integer.generate { 1 }` resolves to `(Any >> Integer)`): the value is
+      # unknown until the Integer beside it vouches for it, and that is what to encode.
       def pure_refinement?(child)
         case child
-        when AttributeValueMatch, ValueClass, Not then true
+        when AttributeValueMatch, ValueClass, Not, AnyClass then true
         when Constraint then child.base.nil? && !child.matcher.is_a?(::Module)
         else false
         end
@@ -608,7 +710,6 @@ module Plumb
                 'Register an encoder for it, or declare it with .noop.'
         end
       end
-
     end
 
     # ------------------------------------------------------------------
@@ -634,9 +735,10 @@ module Plumb
       def decode(str) = ::Date.parse(str)
     end
 
-    # Time <=> ISO 8601 date-time string ("2024-08-30T20:15:23Z").
+    # Time <=> ISO 8601 date-time string ("2024-08-30T20:15:23.456789Z").
+    #
     class TimeEncoder < Encoder[Types::String[TIME_EXPR].metadata(format: 'date-time') => Types::Time]
-      def encode(time) = time.iso8601
+      def encode(time) = time.iso8601(6)
       def decode(str) = ::Time.parse(str)
     end
 
@@ -791,5 +893,38 @@ module Plumb
       encoder DateEncoder, TimeEncoder, SymbolEncoder, DecimalEncoder
       encoder URIEncoder, HTTPURIEncoder, FileURIEncoder
     end
+
+    private
+
+    def entry(key)
+      read(key) || lazy_entry(key) || raise(NoEntryError, "no encoder/decoder registered for #{key}")
+    end
+
+    # Sealed, @entries can never change again, so reads need no synchronization —
+    # the shared-global case is also the cheapest one.
+    def read(key) = frozen? ? @entries[key] : @lock.synchronize { @entries[key] }
+
+    # Fill in on demand, so an app need not enumerate every type it exchanges.
+    # Only for keys that ARE types: an app-owned tag ('person.created') names
+    # nothing the codec could compile, and still raises. Freezing is how an app
+    # declares its set closed — a sealed registry never fills in.
+    #
+    # Keys match by value, so a type literal built fresh per call adds an entry
+    # per call. Constants and classes are stable; sealing rules it out entirely.
+    def lazy_entry(key)
+      return nil if frozen? || !(key.is_a?(Composable) || key.is_a?(::Module))
+
+      # Composed OUTSIDE the lock, as TypeCache does: holding it across a rewrite
+      # would convoy every other thread's lookups behind one cold type. Racing
+      # threads both compose; the rewrite is a pure function of the type, so the
+      # loser's copy is equivalent and simply dropped.
+      entry = build_entry(key)
+      @lock.synchronize { @entries[key] ||= entry }
+    end
+
+    def build_entry(type)
+      decoder, encoder = self.class.for(type)
+      Entry.new(decoder:, encoder:)
+    end
   end
 end