[4.1] The ruling reaches the AST accessor too; [4.4] count coherence

Two corrections from Reid, both of which I had got wrong.

[4.1] REACHES FURTHER than I implemented. Reid: *"Is an entity with
portlets a streamlet? Yes, it is. Is a projector with inlets and
outlets a streamlet? Yes it is. So when a definition includes
WithStreamlets, it includes all the processor definitions in its
purview that have portlets."* I had deliberately left
`WithStreamlets.streamlets` alone and asked whether it was in scope; it
was.

So a streamlet is now defined by a NON-ZERO PORTLET COUNT, not by which
keyword declared it — and that definition is applied everywhere,
including narrowing the three output accessors I had over-widened to
"all processors" yesterday.

`checkStreaming` needed nothing: `StreamingValidation` was already
widened to every Processor kind in 70b0f52. The accessor was the last
narrow piece.

ONE RULE WAS RIDING ON THE OLD NARROWNESS and had to be written out.
The "context with entities needs a Sink" check tested
`c.streamlets.exists(_.inlets.nonEmpty)`, and its own suggestion says
"an entity's own inlet does not satisfy this — driving an entity from
outside IS an inbound stream and belongs at the context boundary". Once
entities became streamlets, an entity inlet would have satisfied it
silently. The exclusion is now in the code, not just the prose.

The consequence to know: a PORTLESS processor is not a streamlet,
including a stubbed or `void` Streamlet. Three tests asserted the old
meaning and now say what they mean — `source src is { ??? }` has no
ports, so it is a Streamlet declaration but not a streamlet. Data-flow
diagrams keep portless Streamlet stubs in the GATE (so a stub context
does not lose its diagram) while keeping them out of the DATA.

[4.4] I measured the wrong thing. Reid: *"they shouldn't drop if the
shape is consistent with the number of inlets and outlets; having those
line up is AN INDICATOR of maturity."* I had counted
`ascribedShape.nonEmpty`, which scores whether the author TYPED
something rather than whether the model hangs together, and would have
penalised every correct model that leaves the shape implicit. It now
scores COHERENCE: an ascription that matches the arity counts, an
absent one counts (it cannot disagree), a contradicting one does not.

Compared by KEYWORD, not `==`: `StreamletShape` carries a `loc` and
`arityShape` builds one at the processor's location, so `==` would have
been false for every processor alive — a corpus-wide maturity collapse
that would have looked like a finding.

language 731, passes 1453, riddlLib 144, commands 245 green; corpus
validation-parity holds at 190/190.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: reid-spencer

language/src/main/scala/com/ossuminc/riddl/language/AST.scala

@@ -749,8 +749,25 @@ object AST:
   /** Base trait to use in any [[Definition]] that can define [[Streamlet]]s */
   sealed trait WithStreamlets[CV <: RiddlValue] extends Container[CV]:
 
-    /** A lazily constructed [[Seq]] of [[Streamlet]] filtered from the contents */
-    def streamlets: Seq[Streamlet] = contents.filterThroughWrappers[Streamlet]
+    /** Every STREAMLET in this container's purview — which since [4.1] means **every contained
+      * [[Processor]] with a non-zero portlet count**, not merely the [[Streamlet]] case class.
+      *
+      * **RULED 2026-08-17 by Reid:** *"Is an entity with portlets a streamlet? Yes, it is. Is a
+      * projector with inlets and outlets a streamlet? Yes it is. So when a definition includes
+      * WithStreamlets, it includes all the processor definitions in its purview that have portlets,
+      * including entities, repositories, projectors."*
+      *
+      * A streamlet is therefore defined by what it HAS, not by which keyword declared it. That is
+      * the whole content of the unified processor model: `Streamlet` was the port-bearing kind
+      * until every processor became port-bearing, at which point the case class stopped being the
+      * useful boundary and the portlet count started being it.
+      *
+      * **A processor with no portlets is NOT a streamlet**, including a `void`-shaped or stubbed
+      * `Streamlet` — it has nothing in a stream to be. Callers wanting the case class regardless
+      * write `.collect { case s: Streamlet => s }` on `contents`.
+      */
+    def streamlets: Seq[Processor[?]] =
+      contents.filterThroughWrappers[Processor[?]].filter(_.ports.nonEmpty)
   end WithStreamlets
 
   /** Base trait to use in any [[Definition]] that can define [[Connector]]s */

language/src/test/scala/com/ossuminc/riddl/language/ASTTest.scala

@@ -559,6 +559,7 @@ class ASTTest extends AbstractTestingBasis {
       val connector = Connector(At.empty, Identifier(At.empty, "channel"), outletRef, inletRef)
       val plant =
         Context(At.empty, Identifier(At.empty, "plant"), Contents(source, sink, connector))
+      // [4.1]: a streamlet is any processor WITH PORTLETS, so this asserts on the port-bearing set.
       plant.streamlets.map(_.id.value) mustBe Seq("Source", "Sink")
       plant.connectors.map(_.id.value) mustBe Seq("channel")
       source.effectiveShape mustBe Source(At.empty)

language/src/test/scala/com/ossuminc/riddl/language/parsing/ParsingTestTest.scala

@@ -151,7 +151,12 @@ abstract class ParsingTestTest(using PlatformContext) extends AbstractParsingTes
 
     "parseTopLevelDomain[Processor]" in { (td: TestData) =>
       val input = RiddlParserInput("domain foo is { context C is { source X is { ??? } } }", td)
-      parseTopLevelDomain[Streamlet](input, _.domains.head.contexts.head.streamlets.head) match {
+      // [4.1]: `streamlets` means processors WITH PORTLETS, and `source X is { ??? }` has none,
+      // so this case asks the contents for the Streamlet declaration rather than the accessor.
+      parseTopLevelDomain[Streamlet](
+        input,
+        _.domains.head.contexts.head.contents.filter[Streamlet].head
+      ) match {
         case Left(messages)  => fail(messages.format)
         case Right((src, _)) => src.id.value mustBe "X"
       }

language/src/test/scala/com/ossuminc/riddl/language/parsing/StreamingParserTest.scala

@@ -262,7 +262,10 @@ abstract class StreamingParserTest(using PlatformContext) extends AbstractParsin
       TopLevelParser.parseAsContext(input) match {
         case Left(errors) => fail(errors.format)
         case Right(context) =>
-          val streamlet = context.streamlets.head
+          // [4.1]: `context.streamlets` is every processor WITH PORTLETS, and `processor P is
+          // { ??? }` declares none — so it is deliberately NOT a streamlet and this case must ask
+          // for the declaration itself. That distinction is the ruling, not an accident of it.
+          val streamlet = context.contents.filter[Streamlet].head
           streamlet.id.value mustBe "P"
           streamlet.ascribedShape mustBe None
       }

passes/src/main/scala/com/ossuminc/riddl/passes/analysis/AnalysisResult.scala

@@ -189,11 +189,14 @@ case class AnalysisResult(
     * and shipped in `2.0.0-rc.15`. It is DELETED rather than kept as a synonym: two names for one
     * answer is how a consumer ends up believing they differ.
     *
+    * A streamlet is defined by a NON-ZERO PORTLET COUNT, not by which keyword declared it, so a
+    * portless processor — including a stubbed or `void`-shaped `Streamlet` — is not one.
+    *
     * **Breaking**: the element type widened from `Streamlet` to `Processor[?]`. A caller wanting
     * only the `Streamlet` case class writes `.collect { case s: Streamlet => s }`.
     */
   def streamlets: Seq[Processor[?]] =
-    symbols.parentage.keys.collect { case p: Processor[?] => p }.toSeq
+    symbols.parentage.keys.collect { case p: Processor[?] if p.ports.nonEmpty => p }.toSeq
 
   /** Get all projectors in the model */
   def projectors: Seq[Projector] =

passes/src/main/scala/com/ossuminc/riddl/passes/diagrams/DiagramsPass.scala

@@ -499,11 +499,11 @@ class DiagramsPass(input: PassInput, outputs: PassesOutput)(using PlatformContex
     // `filterThroughWrappers`, not `contents.processors`: the latter is deliberately LITERAL (see
     // its note in Contents.scala), and this must see an included processor exactly as the AST's
     // own `context.streamlets` containment accessor does.
-    val ctxProcessors = context.contents.filterThroughWrappers[Processor[?]]
-    // The DIAGRAM GATE stays on processors that actually declare a port. `ctxProcessors` is now
-    // true of nearly every context, so gating on it would emit a data-flow diagram for every
-    // context in the model, most of them with nothing to draw.
-    val ctxWithPorts = ctxProcessors.filter(p => p.inlets.nonEmpty || p.outlets.nonEmpty)
+    // [4.1]: `context.streamlets` IS this question now — every contained processor with a
+    // non-zero portlet count — so ask the accessor rather than re-deriving it here. The manual
+    // `filterThroughWrappers` that stood here was doing the accessor's job while the accessor was
+    // still narrow.
+    val ctxStreamlets = context.streamlets
     val connections = ctxConnectors.flatMap { connector =>
       if connector.nonEmpty then
         val maybeOutlet = refMap.definitionOf[Outlet](connector.from, context)
@@ -526,13 +526,17 @@ class DiagramsPass(input: PassInput, outputs: PassesOutput)(using PlatformContex
           case _ => None
       else None
     }
-    // A portless Streamlet (a stub, or a `void` shape) still earns a diagram, as it did before
-    // [4.1] widened the field: it is a streaming component whose ports are simply not written yet.
-    val ctxStreamletStubs = ctxProcessors.collect { case s: Streamlet => s }
-    if ctxConnectors.nonEmpty || ctxWithPorts.nonEmpty || ctxStreamletStubs.nonEmpty then
+    // A portless `Streamlet` (a stub, or a `void` shape) is NOT a streamlet under [4.1], but it is
+    // still a streaming component whose ports are merely unwritten, and a context holding one
+    // produced a data flow diagram before this change. Keep it in the GATE so a stub context does
+    // not silently lose its diagram — while keeping it out of the DATA, which now answers the
+    // portlet question exactly.
+    val ctxStreamletStubs =
+      context.contents.filterThroughWrappers[Streamlet].filter(_.ports.isEmpty)
+    if ctxConnectors.nonEmpty || ctxStreamlets.nonEmpty || ctxStreamletStubs.nonEmpty then
       dataFlowDiagrams.put(
         context,
-        DataFlowDiagramData(context, ctxConnectors, ctxProcessors, connections)
+        DataFlowDiagramData(context, ctxConnectors, ctxStreamlets, connections)
       )
   }
 

passes/src/main/scala/com/ossuminc/riddl/passes/stats/StatsPass.scala

@@ -406,17 +406,25 @@ case class StatsPass(input: PassInput, outputs: PassesOutput)(using PlatformCont
     if p.handlers.nonEmpty then result += 1
     if p.functions.nonEmpty then result += 1
     if p.constants.nonEmpty then result += 1
-    // [4.4], RULED 2026-08-17 by Reid (option B): a shape is a specification EVERY processor may
-    // complete, not only a Streamlet -- since the unified processor model, any of the six kinds
-    // may carry an `ascribedShape`. Counted here rather than per-kind below so the numerator and
-    // the denominator (`specsForProcessor`) move together; they were previously both
-    // Streamlet-only, at two sites that had to be kept in step by hand.
+    // [4.4], RULED 2026-08-17 by Reid (option B), then CORRECTED by him the same day:
+    // *"they shouldn't drop if the shape is consistent with the number of inlets and outlets;
+    // having those line up is AN INDICATOR of maturity, so make it count that way."*
     //
-    // A Streamlet still counts unconditionally. Its shape is REQUIRED and is known even when
-    // `ascribedShape` is None, because the keyword form (`source X is …`) states it and the
-    // arity derives it -- so testing `ascribedShape` alone would have SILENTLY DROPPED every
-    // keyword-declared streamlet's score from 1 to 0, which is a regression dressed as a ruling.
-    if p.ascribedShape.nonEmpty || p.isInstanceOf[Streamlet] then result += 1
+    // So the credit is for COHERENCE, not for the mere presence of an `as <shape>` clause. A
+    // processor whose ascribed shape matches its arity has said something true about itself and
+    // scores; one whose ascription CONTRADICTS its ports has not, and does not. A processor that
+    // ascribes nothing scores too — its shape is derived from arity and so cannot disagree with
+    // it — which is what keeps percentages from dropping across the corpus for models that simply
+    // never write the clause.
+    //
+    // My first implementation counted `ascribedShape.nonEmpty`, which measured whether the author
+    // had TYPED something rather than whether the model hangs together, and would have penalised
+    // every correct model that leaves the shape implicit.
+    // Compared by KEYWORD, not by `==`. `StreamletShape` is a case class carrying a `loc`, and
+    // `arityShape` builds one at the PROCESSOR's location while an ascribed shape carries its own
+    // — so `==` would be false for every processor alive, scoring zero everywhere and looking
+    // like a corpus-wide maturity collapse.
+    if p.ascribedShape.forall(_.keyword == p.arityShape.keyword) then result += 1
     result
 
   private def completedCount(v: RiddlValue): Int = {

passes/src/main/scala/com/ossuminc/riddl/passes/validate/ValidationPass.scala

@@ -99,10 +99,11 @@ case class ValidationPass(
       inlets.toSeq,
       outlets.toSeq,
       connectors.toSeq,
-      // [4.1], RULED 2026-08-17: `streamlets` means ALL port-bearing processors, so the graph's
-      // node buffer -- which is already every Processor kind -- passes through UNNARROWED. The
-      // `.collect { case s: Streamlet => s }` that used to sit here was the narrowing.
-      processors.toSeq,
+      // [4.1], RULED 2026-08-17: a streamlet is any processor with a NON-ZERO PORTLET COUNT. The
+      // graph's node buffer is already every Processor kind, so the old
+      // `.collect { case s: Streamlet => s }` narrowing is gone -- but the portlet test is real,
+      // not a formality: a processor with no ports is not in a stream.
+      processors.toSeq.filter(_.ports.nonEmpty),
       computedHandlerCompleteness,
       deliverableTypes.toMap
     )
@@ -4526,7 +4527,15 @@ case class ValidationPass(
     val nonEmptyEntities = c.entities.filter(_.nonEmpty)
     if nonEmptyEntities.nonEmpty && c.nonEmpty then {
       // Completeness 4i: context with entities must have a Sink
-      val hasSinkOrInlet = c.streamlets.exists(_.inlets.nonEmpty)
+      // [4.1]: `c.streamlets` now includes ANY port-bearing processor, entities included — so the
+      // Entity exclusion this check has always relied on must be written out. It used to ride on
+      // the accessor being narrow, which is precisely the kind of rule that disappears when an
+      // accessor is widened underneath it. The suggestion below states the rule; now the code does
+      // too: driving an entity from outside IS an inbound stream and belongs at the context
+      // boundary where it can be seen.
+      val hasSinkOrInlet = c.streamlets.exists { s =>
+        s.inlets.nonEmpty && !s.isInstanceOf[Entity]
+      }
       if !hasSinkOrInlet then {
         messages.addCompleteness(
           c.errorLoc,

passes/src/test/scala-jvm-native/com/ossuminc/riddl/passes/analysis/AnalysisPassSpec.scala

@@ -128,13 +128,12 @@ class AnalysisPassSpec extends AnyWordSpec with Matchers {
           result.sagas mustBe empty
           result.epics mustBe empty
           result.repositories mustBe empty
-          // [4.1], RULED 2026-08-17: `streamlets` means every PORT-BEARING processor, which since
-          // the unified processor model is every Processor kind. This model declares no `Streamlet`
-          // but does declare 2 contexts and 2 entities, and those ARE processors — so the old
-          // `mustBe empty` was asserting the narrow reading, not an empty model.
-          result.streamlets.map(_.id.value).toSet mustBe
-            Set("Orders", "Customers", "Order", "Customer")
-          result.streamlets.collect { case s: Streamlet => s } mustBe empty
+          // [4.1], RULED 2026-08-17: a streamlet is any processor with a NON-ZERO PORTLET COUNT.
+          // This model's contexts and entities declare no inlets or outlets, so none of them is a
+          // streamlet and the answer is empty — the same result as before the ruling, for a
+          // completely different reason. Worth stating: the old assertion passed because nothing
+          // here is a `Streamlet` case class; this one passes because nothing here has a port.
+          result.streamlets mustBe empty
           result.projectors mustBe empty
           result.adaptors mustBe empty
           result.functions mustBe empty

passes/src/test/scala-jvm-native/com/ossuminc/riddl/passes/resolve/ReferenceMapTest.scala

@@ -79,9 +79,12 @@ class ReferenceMapTest extends AbstractValidatingTest {
       refMap.definitionOf[Inlet](pid) match {
         case Some(actual: Inlet) =>
           actual.id.value mustBe ("InCommands")
+          // [4.1]: `streamlets` is `Seq[Processor[?]]` now, so this match is no longer exhaustive
+          // on `Some(_: Streamlet)` — which `-Werror` caught. The case wants the port-bearing
+          // processor named "Sink" whatever kind declared it, so it matches on the wider type.
           val expected = context.streamlets.find("Sink")
           expected match {
-            case Some(streamlet: Streamlet) =>
+            case Some(streamlet) =>
               streamlet.id.value mustBe ("Sink")
               streamlet.inlets must (not be (empty))
               val expected = streamlet.inlets.head