neva-to-mermaid

name	neva-to-mermaid
description	Convert Neva programs to valid Mermaid flowchart diagrams. Use when asked to visualize Neva code as Mermaid.

Neva to Mermaid

Use this skill to convert any Neva source code into a Mermaid flowchart.

Instructions

1. Read the Neva code to be converted.

2. Generate a Mermaid flowchart TB diagram using the following rules:

   • Layout: Always include this header at the top:

     ---
     config:
       layout: elk
     ---
     flowchart TB
     

   • Ports:

     • Use stadium shapes for external ports :in / :out:
       • ([":data"]), ([":res"]), ([":err"]), etc.
     • In edges, label with the port name (data, res, err, sig, case[0], etc).

   • Components:

     • Use unique Mermaid node IDs.
     • Render component nodes as regular boxes using only their declared instance name: id["name"].
     • Do not annotate component nodes with type names, generic parameters, or usage information.

   • Literals:

     • Render numeric and string literals as rectangles using Mermaid shape syntax:
       • zero@{ label: "0", shape: rect }
       • dot@{ label: "'.'", shape: rect }

   • Connections:

     • Use -- <port> --> labels for the wire’s port name.
     • For a:out -> b:in, label the edge with the output port name (out), unless Neva explicitly uses the input port name in the wiring (e.g., b:sig).
     • Only label an edge with a port name when the Neva source explicitly names a port on that connection.
       • Examples that MUST be labeled:
       • x:res -> y → label edge as res
       • x -> y:sig → label edge as sig
       • x:case[0] -> y → label edge as case[0]

   • If a port name is omitted in Neva, do not infer or guess it. Render an unlabeled edge:

     • x -> y → x --> y

   • Fan-out / Fan-in (IMPORTANT):

     • Mermaid edges do not create real “ports as objects”, so list-wiring must be represented explicitly with virtual junction nodes.
     • A junction node is a small circle: jX(( )) where jX is a unique ID.

     Fan-out: src -> [a, b, :out]

     • Insert a junction node jX(( )).
     • Wire: src -- <port> --> jX
     • Then wire: jX --> a, jX --> b, jX --> out_port

     Fan-in: [a, b] -> dst:port

     • Insert a junction node jX(( )).
     • Wire: a --> jX and b --> jX
     • Then wire: jX -- <port> --> dst

   • Grouping (&):

     • You MAY use & to reduce clutter only when it does not hide fan-in/fan-out topology.
     • If Neva uses list-wiring ([...]), prefer junction nodes over &.

3. Do not look up other files in the repo or call web search; this text describes the conversion rules.

4. Ensure the output is ready to be pasted into the Mermaid playground.

Reference Example

Neva

pub def Tap<T>(data T) (res T, err error) {
    pass1 Pass<T>
    pass2 Pass<T>
    lock Lock<T>
    handler ITapHandler<T>
    ---
    :data -> [lock:data, handler]
    handler:res -> pass1
    handler:err -> [pass2, :err]
    [pass1, pass2] -> lock:sig
    lock -> :res
}